; LLVM IR from aferikoglou/GenHLSOptimizer :: dataset/rodinia_lc_gicov_0_baseline_0 (lc_gicov)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@__const.workload.sin_angle = external hidden unnamed_addr constant [16 x float], align 16
@__const.workload.cos_angle = external hidden unnamed_addr constant [16 x float], align 16
@__const.workload.tX = external hidden unnamed_addr constant [2 x [16 x i32]], align 16
@__const.workload.tY = external hidden unnamed_addr constant [2 x [16 x i32]], align 16

; Function Attrs: mustprogress uwtable
define dso_local void @workload(ptr noundef %0, ptr noundef %1, ptr noundef %2) #0 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca [16 x float], align 16
  %8 = alloca [16 x float], align 16
  %9 = alloca [2 x [16 x i32]], align 16
  %10 = alloca [2 x [16 x i32]], align 16
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca ptr, align 8
  %15 = alloca [16 x float], align 16
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca float, align 4
  %22 = alloca float, align 4
  %23 = alloca float, align 4
  %24 = alloca float, align 4
  store ptr %0, ptr %4, align 8, !tbaa !5
  store ptr %1, ptr %5, align 8, !tbaa !5
  store ptr %2, ptr %6, align 8, !tbaa !5
  br label %25

25:                                               ; preds = %3
  call void @llvm.lifetime.start.p0(i64 64, ptr %7) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %7, ptr align 16 @__const.workload.sin_angle, i64 64, i1 false)
  br label %26

26:                                               ; preds = %25
  call void @llvm.lifetime.start.p0(i64 64, ptr %8) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %8, ptr align 16 @__const.workload.cos_angle, i64 64, i1 false)
  br label %27

27:                                               ; preds = %26
  call void @llvm.lifetime.start.p0(i64 128, ptr %9) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %9, ptr align 16 @__const.workload.tX, i64 128, i1 false)
  br label %28

28:                                               ; preds = %27
  call void @llvm.lifetime.start.p0(i64 128, ptr %10) #6
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %10, ptr align 16 @__const.workload.tY, i64 128, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #6
  %29 = call noalias ptr @malloc(i64 noundef 262144) #7
  store ptr %29, ptr %14, align 8, !tbaa !5
  br label %30

30:                                               ; preds = %28
  store i32 3, ptr %11, align 4, !tbaa !9
  br label %31

31:                                               ; preds = %173, %30
  %32 = load i32, ptr %11, align 4, !tbaa !9
  %33 = icmp slt i32 %32, 253
  br i1 %33, label %34, label %176

34:                                               ; preds = %31
  br label %35

35:                                               ; preds = %34
  call void @llvm.lifetime.start.p0(i64 64, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #6
  br label %36

36:                                               ; preds = %35
  store i32 3, ptr %16, align 4, !tbaa !9
  br label %37

37:                                               ; preds = %169, %36
  %38 = load i32, ptr %16, align 4, !tbaa !9
  %39 = icmp slt i32 %38, 253
  br i1 %39, label %40, label %172

40:                                               ; preds = %37
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  store float 0.000000e+00, ptr %21, align 4, !tbaa !11
  br label %41

41:                                               ; preds = %40
  store i32 0, ptr %17, align 4, !tbaa !9
  br label %42

42:                                               ; preds = %165, %41
  %43 = load i32, ptr %17, align 4, !tbaa !9
  %44 = icmp slt i32 %43, 2
  br i1 %44, label %45, label %168

45:                                               ; preds = %42
  br label %46

46:                                               ; preds = %45
  store i32 0, ptr %18, align 4, !tbaa !9
  br label %47

47:                                               ; preds = %98, %46
  %48 = load i32, ptr %18, align 4, !tbaa !9
  %49 = icmp slt i32 %48, 16
  br i1 %49, label %50, label %101

50:                                               ; preds = %47
  %51 = load i32, ptr %16, align 4, !tbaa !9
  %52 = load i32, ptr %17, align 4, !tbaa !9
  %53 = sext i32 %52 to i64
  %54 = getelementptr inbounds [2 x [16 x i32]], ptr %10, i64 0, i64 %53
  %55 = load i32, ptr %18, align 4, !tbaa !9
  %56 = sext i32 %55 to i64
  %57 = getelementptr inbounds [16 x i32], ptr %54, i64 0, i64 %56
  %58 = load i32, ptr %57, align 4, !tbaa !9
  %59 = add nsw i32 %51, %58
  store i32 %59, ptr %20, align 4, !tbaa !9
  %60 = load i32, ptr %11, align 4, !tbaa !9
  %61 = load i32, ptr %17, align 4, !tbaa !9
  %62 = sext i32 %61 to i64
  %63 = getelementptr inbounds [2 x [16 x i32]], ptr %9, i64 0, i64 %62
  %64 = load i32, ptr %18, align 4, !tbaa !9
  %65 = sext i32 %64 to i64
  %66 = getelementptr inbounds [16 x i32], ptr %63, i64 0, i64 %65
  %67 = load i32, ptr %66, align 4, !tbaa !9
  %68 = add nsw i32 %60, %67
  store i32 %68, ptr %19, align 4, !tbaa !9
  %69 = load ptr, ptr %5, align 8, !tbaa !5
  %70 = load i32, ptr %20, align 4, !tbaa !9
  %71 = mul nsw i32 %70, 256
  %72 = load i32, ptr %19, align 4, !tbaa !9
  %73 = add nsw i32 %71, %72
  %74 = sext i32 %73 to i64
  %75 = getelementptr inbounds float, ptr %69, i64 %74
  %76 = load float, ptr %75, align 4, !tbaa !11
  %77 = load i32, ptr %18, align 4, !tbaa !9
  %78 = sext i32 %77 to i64
  %79 = getelementptr inbounds [16 x float], ptr %8, i64 0, i64 %78
  %80 = load float, ptr %79, align 4, !tbaa !11
  %81 = load ptr, ptr %6, align 8, !tbaa !5
  %82 = load i32, ptr %20, align 4, !tbaa !9
  %83 = mul nsw i32 %82, 256
  %84 = load i32, ptr %19, align 4, !tbaa !9
  %85 = add nsw i32 %83, %84
  %86 = sext i32 %85 to i64
  %87 = getelementptr inbounds float, ptr %81, i64 %86
  %88 = load float, ptr %87, align 4, !tbaa !11
  %89 = load i32, ptr %18, align 4, !tbaa !9
  %90 = sext i32 %89 to i64
  %91 = getelementptr inbounds [16 x float], ptr %7, i64 0, i64 %90
  %92 = load float, ptr %91, align 4, !tbaa !11
  %93 = fmul float %88, %92
  %94 = call float @llvm.fmuladd.f32(float %76, float %80, float %93)
  %95 = load i32, ptr %18, align 4, !tbaa !9
  %96 = sext i32 %95 to i64
  %97 = getelementptr inbounds [16 x float], ptr %15, i64 0, i64 %96
  store float %94, ptr %97, align 4, !tbaa !11
  br label %98

98:                                               ; preds = %50
  %99 = load i32, ptr %18, align 4, !tbaa !9
  %100 = add nsw i32 %99, 1
  store i32 %100, ptr %18, align 4, !tbaa !9
  br label %47, !llvm.loop !13

101:                                              ; preds = %47
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  store float 0.000000e+00, ptr %22, align 4, !tbaa !11
  br label %102

102:                                              ; preds = %101
  store i32 0, ptr %18, align 4, !tbaa !9
  br label %103

103:                                              ; preds = %113, %102
  %104 = load i32, ptr %18, align 4, !tbaa !9
  %105 = icmp slt i32 %104, 16
  br i1 %105, label %106, label %116

106:                                              ; preds = %103
  %107 = load i32, ptr %18, align 4, !tbaa !9
  %108 = sext i32 %107 to i64
  %109 = getelementptr inbounds [16 x float], ptr %15, i64 0, i64 %108
  %110 = load float, ptr %109, align 4, !tbaa !11
  %111 = load float, ptr %22, align 4, !tbaa !11
  %112 = fadd float %111, %110
  store float %112, ptr %22, align 4, !tbaa !11
  br label %113

113:                                              ; preds = %106
  %114 = load i32, ptr %18, align 4, !tbaa !9
  %115 = add nsw i32 %114, 1
  store i32 %115, ptr %18, align 4, !tbaa !9
  br label %103, !llvm.loop !15

116:                                              ; preds = %103
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #6
  %117 = load float, ptr %22, align 4, !tbaa !11
  %118 = fdiv float %117, 1.600000e+01
  store float %118, ptr %23, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #6
  store float 0.000000e+00, ptr %24, align 4, !tbaa !11
  br label %119

119:                                              ; preds = %116
  store i32 0, ptr %18, align 4, !tbaa !9
  br label %120

120:                                              ; preds = %134, %119
  %121 = load i32, ptr %18, align 4, !tbaa !9
  %122 = icmp slt i32 %121, 16
  br i1 %122, label %123, label %137

123:                                              ; preds = %120
  %124 = load i32, ptr %18, align 4, !tbaa !9
  %125 = sext i32 %124 to i64
  %126 = getelementptr inbounds [16 x float], ptr %15, i64 0, i64 %125
  %127 = load float, ptr %126, align 4, !tbaa !11
  %128 = load float, ptr %23, align 4, !tbaa !11
  %129 = fsub float %127, %128
  store float %129, ptr %22, align 4, !tbaa !11
  %130 = load float, ptr %22, align 4, !tbaa !11
  %131 = load float, ptr %22, align 4, !tbaa !11
  %132 = load float, ptr %24, align 4, !tbaa !11
  %133 = call float @llvm.fmuladd.f32(float %130, float %131, float %132)
  store float %133, ptr %24, align 4, !tbaa !11
  br label %134

134:                                              ; preds = %123
  %135 = load i32, ptr %18, align 4, !tbaa !9
  %136 = add nsw i32 %135, 1
  store i32 %136, ptr %18, align 4, !tbaa !9
  br label %120, !llvm.loop !16

137:                                              ; preds = %120
  %138 = load float, ptr %24, align 4, !tbaa !11
  %139 = fdiv float %138, 1.500000e+01
  store float %139, ptr %24, align 4, !tbaa !11
  %140 = load float, ptr %23, align 4, !tbaa !11
  %141 = load float, ptr %23, align 4, !tbaa !11
  %142 = fmul float %140, %141
  %143 = load float, ptr %24, align 4, !tbaa !11
  %144 = fdiv float %142, %143
  %145 = load float, ptr %21, align 4, !tbaa !11
  %146 = fcmp ogt float %144, %145
  br i1 %146, label %147, label %164

147:                                              ; preds = %137
  %148 = load float, ptr %23, align 4, !tbaa !11
  %149 = load float, ptr %24, align 4, !tbaa !11
  %150 = call noundef float @_ZSt4sqrtf(float noundef %149)
  %151 = fdiv float %148, %150
  %152 = load ptr, ptr %4, align 8, !tbaa !5
  %153 = load i32, ptr %16, align 4, !tbaa !9
  %154 = mul nsw i32 %153, 256
  %155 = load i32, ptr %11, align 4, !tbaa !9
  %156 = add nsw i32 %154, %155
  %157 = sext i32 %156 to i64
  %158 = getelementptr inbounds float, ptr %152, i64 %157
  store float %151, ptr %158, align 4, !tbaa !11
  %159 = load float, ptr %23, align 4, !tbaa !11
  %160 = load float, ptr %23, align 4, !tbaa !11
  %161 = fmul float %159, %160
  %162 = load float, ptr %24, align 4, !tbaa !11
  %163 = fdiv float %161, %162
  store float %163, ptr %21, align 4, !tbaa !11
  br label %164

164:                                              ; preds = %147, %137
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  br label %165

165:                                              ; preds = %164
  %166 = load i32, ptr %17, align 4, !tbaa !9
  %167 = add nsw i32 %166, 1
  store i32 %167, ptr %17, align 4, !tbaa !9
  br label %42, !llvm.loop !17

168:                                              ; preds = %42
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #6
  br label %169

169:                                              ; preds = %168
  %170 = load i32, ptr %16, align 4, !tbaa !9
  %171 = add nsw i32 %170, 1
  store i32 %171, ptr %16, align 4, !tbaa !9
  br label %37, !llvm.loop !18

172:                                              ; preds = %37
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %15) #6
  br label %173

173:                                              ; preds = %172
  %174 = load i32, ptr %11, align 4, !tbaa !9
  %175 = add nsw i32 %174, 1
  store i32 %175, ptr %11, align 4, !tbaa !9
  br label %31, !llvm.loop !19

176:                                              ; preds = %31
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 64, ptr %7) #6
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #1

; 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) #2

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #3

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #4

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef float @_ZSt4sqrtf(float noundef) #5

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #1

attributes #0 = { mustprogress uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #3 = { nounwind allocsize(0) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { inlinehint mustprogress nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #6 = { nounwind }
attributes #7 = { nounwind allocsize(0) }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"float", !7, i64 0}
!13 = distinct !{!13, !14}
!14 = !{!"llvm.loop.mustprogress"}
!15 = distinct !{!15, !14}
!16 = distinct !{!16, !14}
!17 = distinct !{!17, !14}
!18 = distinct !{!18, !14}
!19 = distinct !{!19, !14}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@__const.workload.sin_angle = external hidden unnamed_addr constant [16 x float], align 16
@__const.workload.cos_angle = external hidden unnamed_addr constant [16 x float], align 16
@__const.workload.tX = external hidden unnamed_addr constant [2 x [16 x i32]], align 16
@__const.workload.tY = external hidden unnamed_addr constant [2 x [16 x i32]], align 16

; Function Attrs: mustprogress nounwind uwtable
define dso_local void @workload(ptr nocapture noundef writeonly %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2) local_unnamed_addr #0 {
  %4 = load i32, ptr @__const.workload.tY, align 16, !tbaa !5
  %5 = load i32, ptr @__const.workload.tX, align 16, !tbaa !5
  %6 = load float, ptr @__const.workload.cos_angle, align 16, !tbaa !9
  %7 = load float, ptr @__const.workload.sin_angle, align 16, !tbaa !9
  %8 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 4), align 4, !tbaa !5
  %9 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 4), align 4, !tbaa !5
  %10 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 4), align 4, !tbaa !9
  %11 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 4), align 4, !tbaa !9
  %12 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 8), align 8, !tbaa !5
  %13 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 8), align 8, !tbaa !5
  %14 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 8), align 8, !tbaa !9
  %15 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 8), align 8, !tbaa !9
  %16 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 12), align 4, !tbaa !5
  %17 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 12), align 4, !tbaa !5
  %18 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 12), align 4, !tbaa !9
  %19 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 12), align 4, !tbaa !9
  %20 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 16), align 16, !tbaa !5
  %21 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 16), align 16, !tbaa !5
  %22 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 16), align 16, !tbaa !9
  %23 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 16), align 16, !tbaa !9
  %24 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 20), align 4, !tbaa !5
  %25 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 20), align 4, !tbaa !5
  %26 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 20), align 4, !tbaa !9
  %27 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 20), align 4, !tbaa !9
  %28 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 24), align 8, !tbaa !5
  %29 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 24), align 8, !tbaa !5
  %30 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 24), align 8, !tbaa !9
  %31 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 24), align 8, !tbaa !9
  %32 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 28), align 4, !tbaa !5
  %33 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 28), align 4, !tbaa !5
  %34 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 28), align 4, !tbaa !9
  %35 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 28), align 4, !tbaa !9
  %36 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 32), align 16, !tbaa !5
  %37 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 32), align 16, !tbaa !5
  %38 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 32), align 16, !tbaa !9
  %39 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 32), align 16, !tbaa !9
  %40 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 36), align 4, !tbaa !5
  %41 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 36), align 4, !tbaa !5
  %42 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 36), align 4, !tbaa !9
  %43 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 36), align 4, !tbaa !9
  %44 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 40), align 8, !tbaa !5
  %45 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 40), align 8, !tbaa !5
  %46 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 40), align 8, !tbaa !9
  %47 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 40), align 8, !tbaa !9
  %48 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 44), align 4, !tbaa !5
  %49 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 44), align 4, !tbaa !5
  %50 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 44), align 4, !tbaa !9
  %51 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 44), align 4, !tbaa !9
  %52 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 48), align 16, !tbaa !5
  %53 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 48), align 16, !tbaa !5
  %54 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 48), align 16, !tbaa !9
  %55 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 48), align 16, !tbaa !9
  %56 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 52), align 4, !tbaa !5
  %57 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 52), align 4, !tbaa !5
  %58 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 52), align 4, !tbaa !9
  %59 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 52), align 4, !tbaa !9
  %60 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 56), align 8, !tbaa !5
  %61 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 56), align 8, !tbaa !5
  %62 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 56), align 8, !tbaa !9
  %63 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 56), align 8, !tbaa !9
  %64 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 60), align 4, !tbaa !5
  %65 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 60), align 4, !tbaa !5
  %66 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 60), align 4, !tbaa !9
  %67 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 60), align 4, !tbaa !9
  %68 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 64), align 16
  %69 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 64), align 16
  %70 = load float, ptr @__const.workload.cos_angle, align 16
  %71 = load float, ptr @__const.workload.sin_angle, align 16
  %72 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 68), align 4
  %73 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 68), align 4
  %74 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 4), align 4
  %75 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 4), align 4
  %76 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 72), align 8
  %77 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 72), align 8
  %78 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 8), align 8
  %79 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 8), align 8
  %80 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 76), align 4
  %81 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 76), align 4
  %82 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 12), align 4
  %83 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 12), align 4
  %84 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 80), align 16
  %85 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 80), align 16
  %86 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 16), align 16
  %87 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 16), align 16
  %88 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 84), align 4
  %89 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 84), align 4
  %90 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 20), align 4
  %91 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 20), align 4
  %92 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 88), align 8
  %93 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 88), align 8
  %94 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 24), align 8
  %95 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 24), align 8
  %96 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 92), align 4
  %97 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 92), align 4
  %98 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 28), align 4
  %99 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 28), align 4
  %100 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 96), align 16
  %101 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 96), align 16
  %102 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 32), align 16
  %103 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 32), align 16
  %104 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 100), align 4
  %105 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 100), align 4
  %106 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 36), align 4
  %107 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 36), align 4
  %108 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 104), align 8
  %109 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 104), align 8
  %110 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 40), align 8
  %111 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 40), align 8
  %112 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 108), align 4
  %113 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 108), align 4
  %114 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 44), align 4
  %115 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 44), align 4
  %116 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 112), align 16
  %117 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 112), align 16
  %118 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 48), align 16
  %119 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 48), align 16
  %120 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 116), align 4
  %121 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 116), align 4
  %122 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 52), align 4
  %123 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 52), align 4
  %124 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 120), align 8
  %125 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 120), align 8
  %126 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 56), align 8
  %127 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 56), align 8
  %128 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tY, i64 124), align 4
  %129 = load i32, ptr getelementptr inbounds (i8, ptr @__const.workload.tX, i64 124), align 4
  %130 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.cos_angle, i64 60), align 4
  %131 = load float, ptr getelementptr inbounds (i8, ptr @__const.workload.sin_angle, i64 60), align 4
  br label %132

132:                                              ; preds = %3, %600
  %indvars.iv80 = phi i64 [ 3, %3 ], [ %indvars.iv.next81, %600 ]
  %invariant.gep = getelementptr inbounds float, ptr %0, i64 %indvars.iv80
  %133 = trunc nuw nsw i64 %indvars.iv80 to i32
  %134 = add nsw i32 %5, %133
  %135 = add nsw i32 %9, %133
  %136 = add nsw i32 %13, %133
  %137 = add nsw i32 %17, %133
  %138 = add nsw i32 %21, %133
  %139 = add nsw i32 %25, %133
  %140 = add nsw i32 %29, %133
  %141 = add nsw i32 %33, %133
  %142 = add nsw i32 %37, %133
  %143 = add nsw i32 %41, %133
  %144 = add nsw i32 %45, %133
  %145 = add nsw i32 %49, %133
  %146 = add nsw i32 %53, %133
  %147 = add nsw i32 %57, %133
  %148 = add nsw i32 %61, %133
  %149 = add nsw i32 %65, %133
  %150 = add nsw i32 %69, %133
  %151 = add nsw i32 %73, %133
  %152 = add nsw i32 %77, %133
  %153 = add nsw i32 %81, %133
  %154 = add nsw i32 %85, %133
  %155 = add nsw i32 %89, %133
  %156 = add nsw i32 %93, %133
  %157 = add nsw i32 %97, %133
  %158 = add nsw i32 %101, %133
  %159 = add nsw i32 %105, %133
  %160 = add nsw i32 %109, %133
  %161 = add nsw i32 %113, %133
  %162 = add nsw i32 %117, %133
  %163 = add nsw i32 %121, %133
  %164 = add nsw i32 %125, %133
  %165 = add nsw i32 %129, %133
  br label %.preheader56

.preheader56:                                     ; preds = %132, %599
  %indvars.iv = phi i64 [ 3, %132 ], [ %indvars.iv.next, %599 ]
  %.idx = shl nsw i64 %indvars.iv, 10
  %gep = getelementptr inbounds i8, ptr %invariant.gep, i64 %.idx
  %166 = trunc nuw nsw i64 %indvars.iv to i32
  %167 = add nsw i32 %4, %166
  %168 = shl nsw i32 %167, 8
  %169 = add nsw i32 %134, %168
  %170 = sext i32 %169 to i64
  %171 = getelementptr inbounds float, ptr %1, i64 %170
  %172 = load float, ptr %171, align 4, !tbaa !9
  %173 = getelementptr inbounds float, ptr %2, i64 %170
  %174 = load float, ptr %173, align 4, !tbaa !9
  %175 = fmul float %174, %7
  %176 = tail call float @llvm.fmuladd.f32(float %172, float %6, float %175)
  %177 = add nsw i32 %8, %166
  %178 = shl nsw i32 %177, 8
  %179 = add nsw i32 %135, %178
  %180 = sext i32 %179 to i64
  %181 = getelementptr inbounds float, ptr %1, i64 %180
  %182 = load float, ptr %181, align 4, !tbaa !9
  %183 = getelementptr inbounds float, ptr %2, i64 %180
  %184 = load float, ptr %183, align 4, !tbaa !9
  %185 = fmul float %184, %11
  %186 = tail call float @llvm.fmuladd.f32(float %182, float %10, float %185)
  %187 = add nsw i32 %12, %166
  %188 = shl nsw i32 %187, 8
  %189 = add nsw i32 %136, %188
  %190 = sext i32 %189 to i64
  %191 = getelementptr inbounds float, ptr %1, i64 %190
  %192 = load float, ptr %191, align 4, !tbaa !9
  %193 = getelementptr inbounds float, ptr %2, i64 %190
  %194 = load float, ptr %193, align 4, !tbaa !9
  %195 = fmul float %194, %15
  %196 = tail call float @llvm.fmuladd.f32(float %192, float %14, float %195)
  %197 = add nsw i32 %16, %166
  %198 = shl nsw i32 %197, 8
  %199 = add nsw i32 %137, %198
  %200 = sext i32 %199 to i64
  %201 = getelementptr inbounds float, ptr %1, i64 %200
  %202 = load float, ptr %201, align 4, !tbaa !9
  %203 = getelementptr inbounds float, ptr %2, i64 %200
  %204 = load float, ptr %203, align 4, !tbaa !9
  %205 = fmul float %204, %19
  %206 = tail call float @llvm.fmuladd.f32(float %202, float %18, float %205)
  %207 = add nsw i32 %20, %166
  %208 = shl nsw i32 %207, 8
  %209 = add nsw i32 %138, %208
  %210 = sext i32 %209 to i64
  %211 = getelementptr inbounds float, ptr %1, i64 %210
  %212 = load float, ptr %211, align 4, !tbaa !9
  %213 = getelementptr inbounds float, ptr %2, i64 %210
  %214 = load float, ptr %213, align 4, !tbaa !9
  %215 = fmul float %214, %23
  %216 = tail call float @llvm.fmuladd.f32(float %212, float %22, float %215)
  %217 = add nsw i32 %24, %166
  %218 = shl nsw i32 %217, 8
  %219 = add nsw i32 %139, %218
  %220 = sext i32 %219 to i64
  %221 = getelementptr inbounds float, ptr %1, i64 %220
  %222 = load float, ptr %221, align 4, !tbaa !9
  %223 = getelementptr inbounds float, ptr %2, i64 %220
  %224 = load float, ptr %223, align 4, !tbaa !9
  %225 = fmul float %224, %27
  %226 = tail call float @llvm.fmuladd.f32(float %222, float %26, float %225)
  %227 = add nsw i32 %28, %166
  %228 = shl nsw i32 %227, 8
  %229 = add nsw i32 %140, %228
  %230 = sext i32 %229 to i64
  %231 = getelementptr inbounds float, ptr %1, i64 %230
  %232 = load float, ptr %231, align 4, !tbaa !9
  %233 = getelementptr inbounds float, ptr %2, i64 %230
  %234 = load float, ptr %233, align 4, !tbaa !9
  %235 = fmul float %234, %31
  %236 = tail call float @llvm.fmuladd.f32(float %232, float %30, float %235)
  %237 = add nsw i32 %32, %166
  %238 = shl nsw i32 %237, 8
  %239 = add nsw i32 %141, %238
  %240 = sext i32 %239 to i64
  %241 = getelementptr inbounds float, ptr %1, i64 %240
  %242 = load float, ptr %241, align 4, !tbaa !9
  %243 = getelementptr inbounds float, ptr %2, i64 %240
  %244 = load float, ptr %243, align 4, !tbaa !9
  %245 = fmul float %244, %35
  %246 = tail call float @llvm.fmuladd.f32(float %242, float %34, float %245)
  %247 = add nsw i32 %36, %166
  %248 = shl nsw i32 %247, 8
  %249 = add nsw i32 %142, %248
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds float, ptr %1, i64 %250
  %252 = load float, ptr %251, align 4, !tbaa !9
  %253 = getelementptr inbounds float, ptr %2, i64 %250
  %254 = load float, ptr %253, align 4, !tbaa !9
  %255 = fmul float %254, %39
  %256 = tail call float @llvm.fmuladd.f32(float %252, float %38, float %255)
  %257 = add nsw i32 %40, %166
  %258 = shl nsw i32 %257, 8
  %259 = add nsw i32 %143, %258
  %260 = sext i32 %259 to i64
  %261 = getelementptr inbounds float, ptr %1, i64 %260
  %262 = load float, ptr %261, align 4, !tbaa !9
  %263 = getelementptr inbounds float, ptr %2, i64 %260
  %264 = load float, ptr %263, align 4, !tbaa !9
  %265 = fmul float %264, %43
  %266 = tail call float @llvm.fmuladd.f32(float %262, float %42, float %265)
  %267 = add nsw i32 %44, %166
  %268 = shl nsw i32 %267, 8
  %269 = add nsw i32 %144, %268
  %270 = sext i32 %269 to i64
  %271 = getelementptr inbounds float, ptr %1, i64 %270
  %272 = load float, ptr %271, align 4, !tbaa !9
  %273 = getelementptr inbounds float, ptr %2, i64 %270
  %274 = load float, ptr %273, align 4, !tbaa !9
  %275 = fmul float %274, %47
  %276 = tail call float @llvm.fmuladd.f32(float %272, float %46, float %275)
  %277 = add nsw i32 %48, %166
  %278 = shl nsw i32 %277, 8
  %279 = add nsw i32 %145, %278
  %280 = sext i32 %279 to i64
  %281 = getelementptr inbounds float, ptr %1, i64 %280
  %282 = load float, ptr %281, align 4, !tbaa !9
  %283 = getelementptr inbounds float, ptr %2, i64 %280
  %284 = load float, ptr %283, align 4, !tbaa !9
  %285 = fmul float %284, %51
  %286 = tail call float @llvm.fmuladd.f32(float %282, float %50, float %285)
  %287 = add nsw i32 %52, %166
  %288 = shl nsw i32 %287, 8
  %289 = add nsw i32 %146, %288
  %290 = sext i32 %289 to i64
  %291 = getelementptr inbounds float, ptr %1, i64 %290
  %292 = load float, ptr %291, align 4, !tbaa !9
  %293 = getelementptr inbounds float, ptr %2, i64 %290
  %294 = load float, ptr %293, align 4, !tbaa !9
  %295 = fmul float %294, %55
  %296 = tail call float @llvm.fmuladd.f32(float %292, float %54, float %295)
  %297 = add nsw i32 %56, %166
  %298 = shl nsw i32 %297, 8
  %299 = add nsw i32 %147, %298
  %300 = sext i32 %299 to i64
  %301 = getelementptr inbounds float, ptr %1, i64 %300
  %302 = load float, ptr %301, align 4, !tbaa !9
  %303 = getelementptr inbounds float, ptr %2, i64 %300
  %304 = load float, ptr %303, align 4, !tbaa !9
  %305 = fmul float %304, %59
  %306 = tail call float @llvm.fmuladd.f32(float %302, float %58, float %305)
  %307 = add nsw i32 %60, %166
  %308 = shl nsw i32 %307, 8
  %309 = add nsw i32 %148, %308
  %310 = sext i32 %309 to i64
  %311 = getelementptr inbounds float, ptr %1, i64 %310
  %312 = load float, ptr %311, align 4, !tbaa !9
  %313 = getelementptr inbounds float, ptr %2, i64 %310
  %314 = load float, ptr %313, align 4, !tbaa !9
  %315 = fmul float %314, %63
  %316 = tail call float @llvm.fmuladd.f32(float %312, float %62, float %315)
  %317 = add nsw i32 %64, %166
  %318 = shl nsw i32 %317, 8
  %319 = add nsw i32 %149, %318
  %320 = sext i32 %319 to i64
  %321 = getelementptr inbounds float, ptr %1, i64 %320
  %322 = load float, ptr %321, align 4, !tbaa !9
  %323 = getelementptr inbounds float, ptr %2, i64 %320
  %324 = load float, ptr %323, align 4, !tbaa !9
  %325 = fmul float %324, %67
  %326 = tail call float @llvm.fmuladd.f32(float %322, float %66, float %325)
  %327 = fadd float %176, 0.000000e+00
  %328 = fadd float %327, %186
  %329 = fadd float %328, %196
  %330 = fadd float %329, %206
  %331 = fadd float %330, %216
  %332 = fadd float %331, %226
  %333 = fadd float %332, %236
  %334 = fadd float %333, %246
  %335 = fadd float %334, %256
  %336 = fadd float %335, %266
  %337 = fadd float %336, %276
  %338 = fadd float %337, %286
  %339 = fadd float %338, %296
  %340 = fadd float %339, %306
  %341 = fadd float %340, %316
  %342 = fadd float %341, %326
  %343 = fmul float %342, 6.250000e-02
  %344 = fsub float %176, %343
  %345 = tail call float @llvm.fmuladd.f32(float %344, float %344, float 0.000000e+00)
  %346 = fsub float %186, %343
  %347 = tail call float @llvm.fmuladd.f32(float %346, float %346, float %345)
  %348 = fsub float %196, %343
  %349 = tail call float @llvm.fmuladd.f32(float %348, float %348, float %347)
  %350 = fsub float %206, %343
  %351 = tail call float @llvm.fmuladd.f32(float %350, float %350, float %349)
  %352 = fsub float %216, %343
  %353 = tail call float @llvm.fmuladd.f32(float %352, float %352, float %351)
  %354 = fsub float %226, %343
  %355 = tail call float @llvm.fmuladd.f32(float %354, float %354, float %353)
  %356 = fsub float %236, %343
  %357 = tail call float @llvm.fmuladd.f32(float %356, float %356, float %355)
  %358 = fsub float %246, %343
  %359 = tail call float @llvm.fmuladd.f32(float %358, float %358, float %357)
  %360 = fsub float %256, %343
  %361 = tail call float @llvm.fmuladd.f32(float %360, float %360, float %359)
  %362 = fsub float %266, %343
  %363 = tail call float @llvm.fmuladd.f32(float %362, float %362, float %361)
  %364 = fsub float %276, %343
  %365 = tail call float @llvm.fmuladd.f32(float %364, float %364, float %363)
  %366 = fsub float %286, %343
  %367 = tail call float @llvm.fmuladd.f32(float %366, float %366, float %365)
  %368 = fsub float %296, %343
  %369 = tail call float @llvm.fmuladd.f32(float %368, float %368, float %367)
  %370 = fsub float %306, %343
  %371 = tail call float @llvm.fmuladd.f32(float %370, float %370, float %369)
  %372 = fsub float %316, %343
  %373 = tail call float @llvm.fmuladd.f32(float %372, float %372, float %371)
  %374 = fsub float %326, %343
  %375 = tail call float @llvm.fmuladd.f32(float %374, float %374, float %373)
  %376 = fdiv float %375, 1.500000e+01
  %377 = fmul float %343, %343
  %378 = fdiv float %377, %376
  %379 = fcmp ogt float %378, 0.000000e+00
  br i1 %379, label %380, label %.preheader55.1

380:                                              ; preds = %.preheader56
  %381 = tail call noundef float @_ZSt4sqrtf(float noundef %376)
  %382 = fdiv float %343, %381
  store float %382, ptr %gep, align 4, !tbaa !9
  br label %.preheader55.1

.preheader55.1:                                   ; preds = %380, %.preheader56
  %.1 = phi float [ %378, %380 ], [ 0.000000e+00, %.preheader56 ]
  %383 = add nsw i32 %68, %166
  %384 = shl nsw i32 %383, 8
  %385 = add nsw i32 %150, %384
  %386 = sext i32 %385 to i64
  %387 = getelementptr inbounds float, ptr %1, i64 %386
  %388 = load float, ptr %387, align 4, !tbaa !9
  %389 = getelementptr inbounds float, ptr %2, i64 %386
  %390 = load float, ptr %389, align 4, !tbaa !9
  %391 = fmul float %390, %71
  %392 = tail call float @llvm.fmuladd.f32(float %388, float %70, float %391)
  %393 = add nsw i32 %72, %166
  %394 = shl nsw i32 %393, 8
  %395 = add nsw i32 %151, %394
  %396 = sext i32 %395 to i64
  %397 = getelementptr inbounds float, ptr %1, i64 %396
  %398 = load float, ptr %397, align 4, !tbaa !9
  %399 = getelementptr inbounds float, ptr %2, i64 %396
  %400 = load float, ptr %399, align 4, !tbaa !9
  %401 = fmul float %400, %75
  %402 = tail call float @llvm.fmuladd.f32(float %398, float %74, float %401)
  %403 = add nsw i32 %76, %166
  %404 = shl nsw i32 %403, 8
  %405 = add nsw i32 %152, %404
  %406 = sext i32 %405 to i64
  %407 = getelementptr inbounds float, ptr %1, i64 %406
  %408 = load float, ptr %407, align 4, !tbaa !9
  %409 = getelementptr inbounds float, ptr %2, i64 %406
  %410 = load float, ptr %409, align 4, !tbaa !9
  %411 = fmul float %410, %79
  %412 = tail call float @llvm.fmuladd.f32(float %408, float %78, float %411)
  %413 = add nsw i32 %80, %166
  %414 = shl nsw i32 %413, 8
  %415 = add nsw i32 %153, %414
  %416 = sext i32 %415 to i64
  %417 = getelementptr inbounds float, ptr %1, i64 %416
  %418 = load float, ptr %417, align 4, !tbaa !9
  %419 = getelementptr inbounds float, ptr %2, i64 %416
  %420 = load float, ptr %419, align 4, !tbaa !9
  %421 = fmul float %420, %83
  %422 = tail call float @llvm.fmuladd.f32(float %418, float %82, float %421)
  %423 = add nsw i32 %84, %166
  %424 = shl nsw i32 %423, 8
  %425 = add nsw i32 %154, %424
  %426 = sext i32 %425 to i64
  %427 = getelementptr inbounds float, ptr %1, i64 %426
  %428 = load float, ptr %427, align 4, !tbaa !9
  %429 = getelementptr inbounds float, ptr %2, i64 %426
  %430 = load float, ptr %429, align 4, !tbaa !9
  %431 = fmul float %430, %87
  %432 = tail call float @llvm.fmuladd.f32(float %428, float %86, float %431)
  %433 = add nsw i32 %88, %166
  %434 = shl nsw i32 %433, 8
  %435 = add nsw i32 %155, %434
  %436 = sext i32 %435 to i64
  %437 = getelementptr inbounds float, ptr %1, i64 %436
  %438 = load float, ptr %437, align 4, !tbaa !9
  %439 = getelementptr inbounds float, ptr %2, i64 %436
  %440 = load float, ptr %439, align 4, !tbaa !9
  %441 = fmul float %440, %91
  %442 = tail call float @llvm.fmuladd.f32(float %438, float %90, float %441)
  %443 = add nsw i32 %92, %166
  %444 = shl nsw i32 %443, 8
  %445 = add nsw i32 %156, %444
  %446 = sext i32 %445 to i64
  %447 = getelementptr inbounds float, ptr %1, i64 %446
  %448 = load float, ptr %447, align 4, !tbaa !9
  %449 = getelementptr inbounds float, ptr %2, i64 %446
  %450 = load float, ptr %449, align 4, !tbaa !9
  %451 = fmul float %450, %95
  %452 = tail call float @llvm.fmuladd.f32(float %448, float %94, float %451)
  %453 = add nsw i32 %96, %166
  %454 = shl nsw i32 %453, 8
  %455 = add nsw i32 %157, %454
  %456 = sext i32 %455 to i64
  %457 = getelementptr inbounds float, ptr %1, i64 %456
  %458 = load float, ptr %457, align 4, !tbaa !9
  %459 = getelementptr inbounds float, ptr %2, i64 %456
  %460 = load float, ptr %459, align 4, !tbaa !9
  %461 = fmul float %460, %99
  %462 = tail call float @llvm.fmuladd.f32(float %458, float %98, float %461)
  %463 = add nsw i32 %100, %166
  %464 = shl nsw i32 %463, 8
  %465 = add nsw i32 %158, %464
  %466 = sext i32 %465 to i64
  %467 = getelementptr inbounds float, ptr %1, i64 %466
  %468 = load float, ptr %467, align 4, !tbaa !9
  %469 = getelementptr inbounds float, ptr %2, i64 %466
  %470 = load float, ptr %469, align 4, !tbaa !9
  %471 = fmul float %470, %103
  %472 = tail call float @llvm.fmuladd.f32(float %468, float %102, float %471)
  %473 = add nsw i32 %104, %166
  %474 = shl nsw i32 %473, 8
  %475 = add nsw i32 %159, %474
  %476 = sext i32 %475 to i64
  %477 = getelementptr inbounds float, ptr %1, i64 %476
  %478 = load float, ptr %477, align 4, !tbaa !9
  %479 = getelementptr inbounds float, ptr %2, i64 %476
  %480 = load float, ptr %479, align 4, !tbaa !9
  %481 = fmul float %480, %107
  %482 = tail call float @llvm.fmuladd.f32(float %478, float %106, float %481)
  %483 = add nsw i32 %108, %166
  %484 = shl nsw i32 %483, 8
  %485 = add nsw i32 %160, %484
  %486 = sext i32 %485 to i64
  %487 = getelementptr inbounds float, ptr %1, i64 %486
  %488 = load float, ptr %487, align 4, !tbaa !9
  %489 = getelementptr inbounds float, ptr %2, i64 %486
  %490 = load float, ptr %489, align 4, !tbaa !9
  %491 = fmul float %490, %111
  %492 = tail call float @llvm.fmuladd.f32(float %488, float %110, float %491)
  %493 = add nsw i32 %112, %166
  %494 = shl nsw i32 %493, 8
  %495 = add nsw i32 %161, %494
  %496 = sext i32 %495 to i64
  %497 = getelementptr inbounds float, ptr %1, i64 %496
  %498 = load float, ptr %497, align 4, !tbaa !9
  %499 = getelementptr inbounds float, ptr %2, i64 %496
  %500 = load float, ptr %499, align 4, !tbaa !9
  %501 = fmul float %500, %115
  %502 = tail call float @llvm.fmuladd.f32(float %498, float %114, float %501)
  %503 = add nsw i32 %116, %166
  %504 = shl nsw i32 %503, 8
  %505 = add nsw i32 %162, %504
  %506 = sext i32 %505 to i64
  %507 = getelementptr inbounds float, ptr %1, i64 %506
  %508 = load float, ptr %507, align 4, !tbaa !9
  %509 = getelementptr inbounds float, ptr %2, i64 %506
  %510 = load float, ptr %509, align 4, !tbaa !9
  %511 = fmul float %510, %119
  %512 = tail call float @llvm.fmuladd.f32(float %508, float %118, float %511)
  %513 = add nsw i32 %120, %166
  %514 = shl nsw i32 %513, 8
  %515 = add nsw i32 %163, %514
  %516 = sext i32 %515 to i64
  %517 = getelementptr inbounds float, ptr %1, i64 %516
  %518 = load float, ptr %517, align 4, !tbaa !9
  %519 = getelementptr inbounds float, ptr %2, i64 %516
  %520 = load float, ptr %519, align 4, !tbaa !9
  %521 = fmul float %520, %123
  %522 = tail call float @llvm.fmuladd.f32(float %518, float %122, float %521)
  %523 = add nsw i32 %124, %166
  %524 = shl nsw i32 %523, 8
  %525 = add nsw i32 %164, %524
  %526 = sext i32 %525 to i64
  %527 = getelementptr inbounds float, ptr %1, i64 %526
  %528 = load float, ptr %527, align 4, !tbaa !9
  %529 = getelementptr inbounds float, ptr %2, i64 %526
  %530 = load float, ptr %529, align 4, !tbaa !9
  %531 = fmul float %530, %127
  %532 = tail call float @llvm.fmuladd.f32(float %528, float %126, float %531)
  %533 = add nsw i32 %128, %166
  %534 = shl nsw i32 %533, 8
  %535 = add nsw i32 %165, %534
  %536 = sext i32 %535 to i64
  %537 = getelementptr inbounds float, ptr %1, i64 %536
  %538 = load float, ptr %537, align 4, !tbaa !9
  %539 = getelementptr inbounds float, ptr %2, i64 %536
  %540 = load float, ptr %539, align 4, !tbaa !9
  %541 = fmul float %540, %131
  %542 = tail call float @llvm.fmuladd.f32(float %538, float %130, float %541)
  %543 = fadd float %392, 0.000000e+00
  %544 = fadd float %543, %402
  %545 = fadd float %544, %412
  %546 = fadd float %545, %422
  %547 = fadd float %546, %432
  %548 = fadd float %547, %442
  %549 = fadd float %548, %452
  %550 = fadd float %549, %462
  %551 = fadd float %550, %472
  %552 = fadd float %551, %482
  %553 = fadd float %552, %492
  %554 = fadd float %553, %502
  %555 = fadd float %554, %512
  %556 = fadd float %555, %522
  %557 = fadd float %556, %532
  %558 = fadd float %557, %542
  %559 = fmul float %558, 6.250000e-02
  %560 = fsub float %392, %559
  %561 = tail call float @llvm.fmuladd.f32(float %560, float %560, float 0.000000e+00)
  %562 = fsub float %402, %559
  %563 = tail call float @llvm.fmuladd.f32(float %562, float %562, float %561)
  %564 = fsub float %412, %559
  %565 = tail call float @llvm.fmuladd.f32(float %564, float %564, float %563)
  %566 = fsub float %422, %559
  %567 = tail call float @llvm.fmuladd.f32(float %566, float %566, float %565)
  %568 = fsub float %432, %559
  %569 = tail call float @llvm.fmuladd.f32(float %568, float %568, float %567)
  %570 = fsub float %442, %559
  %571 = tail call float @llvm.fmuladd.f32(float %570, float %570, float %569)
  %572 = fsub float %452, %559
  %573 = tail call float @llvm.fmuladd.f32(float %572, float %572, float %571)
  %574 = fsub float %462, %559
  %575 = tail call float @llvm.fmuladd.f32(float %574, float %574, float %573)
  %576 = fsub float %472, %559
  %577 = tail call float @llvm.fmuladd.f32(float %576, float %576, float %575)
  %578 = fsub float %482, %559
  %579 = tail call float @llvm.fmuladd.f32(float %578, float %578, float %577)
  %580 = fsub float %492, %559
  %581 = tail call float @llvm.fmuladd.f32(float %580, float %580, float %579)
  %582 = fsub float %502, %559
  %583 = tail call float @llvm.fmuladd.f32(float %582, float %582, float %581)
  %584 = fsub float %512, %559
  %585 = tail call float @llvm.fmuladd.f32(float %584, float %584, float %583)
  %586 = fsub float %522, %559
  %587 = tail call float @llvm.fmuladd.f32(float %586, float %586, float %585)
  %588 = fsub float %532, %559
  %589 = tail call float @llvm.fmuladd.f32(float %588, float %588, float %587)
  %590 = fsub float %542, %559
  %591 = tail call float @llvm.fmuladd.f32(float %590, float %590, float %589)
  %592 = fdiv float %591, 1.500000e+01
  %593 = fmul float %559, %559
  %594 = fdiv float %593, %592
  %595 = fcmp ogt float %594, %.1
  br i1 %595, label %596, label %599

596:                                              ; preds = %.preheader55.1
  %597 = tail call noundef float @_ZSt4sqrtf(float noundef %592)
  %598 = fdiv float %559, %597
  store float %598, ptr %gep, align 4, !tbaa !9
  br label %599

599:                                              ; preds = %596, %.preheader55.1
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, 253
  br i1 %exitcond.not, label %600, label %.preheader56, !llvm.loop !11

600:                                              ; preds = %599
  %indvars.iv.next81 = add nuw nsw i64 %indvars.iv80, 1
  %exitcond83.not = icmp eq i64 %indvars.iv.next81, 253
  br i1 %exitcond83.not, label %601, label %132, !llvm.loop !13

601:                                              ; preds = %600
  ret void
}

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fmuladd.f32(float, float, float) #1

; Function Attrs: inlinehint mustprogress nounwind uwtable
declare dso_local noundef float @_ZSt4sqrtf(float noundef) local_unnamed_addr #2

attributes #0 = { mustprogress nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { inlinehint mustprogress nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"float", !7, i64 0}
!11 = distinct !{!11, !12}
!12 = !{!"llvm.loop.mustprogress"}
!13 = distinct !{!13, !12}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass