; LLVM IR from pms67/HadesFCS :: State Estimation/Matlab/codegen/lib/ekfAHRS (ekfAHRS)

; 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"

@ekfAHRS.dv0 = external hidden constant [81 x double], align 16
@ekfAHRS.dv1 = external hidden constant [9 x double], align 16
@ekfAHRS.iv0 = external hidden constant [16 x i8], align 16
@ekfAHRS.iv1 = external hidden constant [9 x i8], align 1
@flag_not_empty = external hidden global i8, align 1
@P = external hidden global [81 x double], align 16
@Q = external hidden global [81 x double], align 16
@R = external hidden global [16 x double], align 16
@lpfGyrCoeff = external hidden global double, align 8
@p = external hidden global double, align 8
@q = external hidden global double, align 8
@r = external hidden global double, align 8
@lpfAccCoeff = external hidden global double, align 8
@ax = external hidden global double, align 8
@ay = external hidden global double, align 8
@az = external hidden global double, align 8
@lpfVaCoeff = external hidden global double, align 8
@V = external hidden global double, align 8
@xhat = external hidden global [9 x double], align 16
@g = external hidden global double, align 8

; Function Attrs: nounwind uwtable
define dso_local void @ekfAHRS(ptr noundef %0, ptr noundef %1, ptr noundef %2, double noundef %3, double noundef %4, double noundef %5, ptr noundef %6, ptr noundef %7, ptr noundef %8, ptr noundef %9) #0 {
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca double, align 8
  %15 = alloca double, align 8
  %16 = alloca double, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca double, align 8
  %24 = alloca double, align 8
  %25 = alloca double, align 8
  %26 = alloca double, align 8
  %27 = alloca double, align 8
  %28 = alloca double, align 8
  %29 = alloca double, align 8
  %30 = alloca [81 x double], align 16
  %31 = alloca double, align 8
  %32 = alloca double, align 8
  %33 = alloca [36 x double], align 16
  %34 = alloca [9 x double], align 16
  %35 = alloca [16 x double], align 16
  %36 = alloca i32, align 4
  %37 = alloca [36 x double], align 16
  %38 = alloca [36 x double], align 16
  %39 = alloca i32, align 4
  %40 = alloca [81 x double], align 16
  %41 = alloca [81 x double], align 16
  %42 = alloca double, align 8
  %43 = alloca [81 x double], align 16
  %44 = alloca [4 x double], align 16
  %45 = alloca [4 x double], align 16
  %46 = alloca [4 x double], align 16
  store ptr %0, ptr %11, align 8, !tbaa !5
  store ptr %1, ptr %12, align 8, !tbaa !5
  store ptr %2, ptr %13, align 8, !tbaa !5
  store double %3, ptr %14, align 8, !tbaa !9
  store double %4, ptr %15, align 8, !tbaa !9
  store double %5, ptr %16, align 8, !tbaa !9
  store ptr %6, ptr %17, align 8, !tbaa !5
  store ptr %7, ptr %18, align 8, !tbaa !5
  store ptr %8, ptr %19, align 8, !tbaa !5
  store ptr %9, ptr %20, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 648, ptr %30) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  call void @llvm.lifetime.start.p0(i64 288, ptr %33) #6
  call void @llvm.lifetime.start.p0(i64 72, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 128, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.start.p0(i64 288, ptr %37) #6
  call void @llvm.lifetime.start.p0(i64 288, ptr %38) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.start.p0(i64 648, ptr %40) #6
  call void @llvm.lifetime.start.p0(i64 648, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #6
  call void @llvm.lifetime.start.p0(i64 648, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %44) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %45) #6
  call void @llvm.lifetime.start.p0(i64 32, ptr %46) #6
  %47 = load i8, ptr @flag_not_empty, align 1, !tbaa !11
  %48 = icmp ne i8 %47, 0
  br i1 %48, label %102, label %49

49:                                               ; preds = %10
  store i8 1, ptr @flag_not_empty, align 1, !tbaa !11
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %50

50:                                               ; preds = %64, %49
  %51 = load i32, ptr %21, align 4, !tbaa !12
  %52 = icmp slt i32 %51, 81
  br i1 %52, label %53, label %67

53:                                               ; preds = %50
  %54 = load i32, ptr %21, align 4, !tbaa !12
  %55 = sext i32 %54 to i64
  %56 = getelementptr inbounds [81 x double], ptr @ekfAHRS.dv0, i64 0, i64 %55
  %57 = load double, ptr %56, align 8, !tbaa !9
  %58 = load i32, ptr %21, align 4, !tbaa !12
  %59 = sext i32 %58 to i64
  %60 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %59
  store double %57, ptr %60, align 8, !tbaa !9
  %61 = load i32, ptr %21, align 4, !tbaa !12
  %62 = sext i32 %61 to i64
  %63 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %62
  store double 0.000000e+00, ptr %63, align 8, !tbaa !9
  br label %64

64:                                               ; preds = %53
  %65 = load i32, ptr %21, align 4, !tbaa !12
  %66 = add nsw i32 %65, 1
  store i32 %66, ptr %21, align 4, !tbaa !12
  br label %50, !llvm.loop !14

67:                                               ; preds = %50
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %68

68:                                               ; preds = %82, %67
  %69 = load i32, ptr %21, align 4, !tbaa !12
  %70 = icmp slt i32 %69, 9
  br i1 %70, label %71, label %85

71:                                               ; preds = %68
  %72 = load i32, ptr %21, align 4, !tbaa !12
  %73 = sext i32 %72 to i64
  %74 = getelementptr inbounds [9 x double], ptr @ekfAHRS.dv1, i64 0, i64 %73
  %75 = load double, ptr %74, align 8, !tbaa !9
  %76 = load i32, ptr %21, align 4, !tbaa !12
  %77 = load i32, ptr %21, align 4, !tbaa !12
  %78 = mul nsw i32 9, %77
  %79 = add nsw i32 %76, %78
  %80 = sext i32 %79 to i64
  %81 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %80
  store double %75, ptr %81, align 8, !tbaa !9
  br label %82

82:                                               ; preds = %71
  %83 = load i32, ptr %21, align 4, !tbaa !12
  %84 = add nsw i32 %83, 1
  store i32 %84, ptr %21, align 4, !tbaa !12
  br label %68, !llvm.loop !16

85:                                               ; preds = %68
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %86

86:                                               ; preds = %98, %85
  %87 = load i32, ptr %21, align 4, !tbaa !12
  %88 = icmp slt i32 %87, 16
  br i1 %88, label %89, label %101

89:                                               ; preds = %86
  %90 = load i32, ptr %21, align 4, !tbaa !12
  %91 = sext i32 %90 to i64
  %92 = getelementptr inbounds [16 x i8], ptr @ekfAHRS.iv0, i64 0, i64 %91
  %93 = load i8, ptr %92, align 1, !tbaa !11
  %94 = sitofp i8 %93 to double
  %95 = load i32, ptr %21, align 4, !tbaa !12
  %96 = sext i32 %95 to i64
  %97 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %96
  store double %94, ptr %97, align 8, !tbaa !9
  br label %98

98:                                               ; preds = %89
  %99 = load i32, ptr %21, align 4, !tbaa !12
  %100 = add nsw i32 %99, 1
  store i32 %100, ptr %21, align 4, !tbaa !12
  br label %86, !llvm.loop !17

101:                                              ; preds = %86
  br label %102

102:                                              ; preds = %101, %10
  %103 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %104 = load double, ptr @p, align 8, !tbaa !9
  %105 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %106 = fsub double 1.000000e+00, %105
  %107 = load ptr, ptr %12, align 8, !tbaa !5
  %108 = getelementptr inbounds double, ptr %107, i64 0
  %109 = load double, ptr %108, align 8, !tbaa !9
  %110 = fmul double %106, %109
  %111 = call double @llvm.fmuladd.f64(double %103, double %104, double %110)
  store double %111, ptr @p, align 8, !tbaa !9
  %112 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %113 = load double, ptr @q, align 8, !tbaa !9
  %114 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %115 = fsub double 1.000000e+00, %114
  %116 = load ptr, ptr %12, align 8, !tbaa !5
  %117 = getelementptr inbounds double, ptr %116, i64 1
  %118 = load double, ptr %117, align 8, !tbaa !9
  %119 = fmul double %115, %118
  %120 = call double @llvm.fmuladd.f64(double %112, double %113, double %119)
  store double %120, ptr @q, align 8, !tbaa !9
  %121 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %122 = load double, ptr @r, align 8, !tbaa !9
  %123 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !9
  %124 = fsub double 1.000000e+00, %123
  %125 = load ptr, ptr %12, align 8, !tbaa !5
  %126 = getelementptr inbounds double, ptr %125, i64 2
  %127 = load double, ptr %126, align 8, !tbaa !9
  %128 = fmul double %124, %127
  %129 = call double @llvm.fmuladd.f64(double %121, double %122, double %128)
  store double %129, ptr @r, align 8, !tbaa !9
  %130 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %131 = load double, ptr @ax, align 8, !tbaa !9
  %132 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %133 = fsub double 1.000000e+00, %132
  %134 = load ptr, ptr %11, align 8, !tbaa !5
  %135 = getelementptr inbounds double, ptr %134, i64 0
  %136 = load double, ptr %135, align 8, !tbaa !9
  %137 = fmul double %133, %136
  %138 = call double @llvm.fmuladd.f64(double %130, double %131, double %137)
  store double %138, ptr @ax, align 8, !tbaa !9
  %139 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %140 = load double, ptr @ay, align 8, !tbaa !9
  %141 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %142 = fsub double 1.000000e+00, %141
  %143 = load ptr, ptr %11, align 8, !tbaa !5
  %144 = getelementptr inbounds double, ptr %143, i64 1
  %145 = load double, ptr %144, align 8, !tbaa !9
  %146 = fmul double %142, %145
  %147 = call double @llvm.fmuladd.f64(double %139, double %140, double %146)
  store double %147, ptr @ay, align 8, !tbaa !9
  %148 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %149 = load double, ptr @az, align 8, !tbaa !9
  %150 = load double, ptr @lpfAccCoeff, align 8, !tbaa !9
  %151 = fsub double 1.000000e+00, %150
  %152 = load ptr, ptr %11, align 8, !tbaa !5
  %153 = getelementptr inbounds double, ptr %152, i64 2
  %154 = load double, ptr %153, align 8, !tbaa !9
  %155 = fmul double %151, %154
  %156 = call double @llvm.fmuladd.f64(double %148, double %149, double %155)
  store double %156, ptr @az, align 8, !tbaa !9
  %157 = load double, ptr @lpfVaCoeff, align 8, !tbaa !9
  %158 = load double, ptr @V, align 8, !tbaa !9
  %159 = load double, ptr @lpfVaCoeff, align 8, !tbaa !9
  %160 = fsub double 1.000000e+00, %159
  %161 = load double, ptr %14, align 8, !tbaa !9
  %162 = fmul double %160, %161
  %163 = call double @llvm.fmuladd.f64(double %157, double %158, double %162)
  store double %163, ptr @V, align 8, !tbaa !9
  %164 = load double, ptr %15, align 8, !tbaa !9
  %165 = fdiv double %164, 1.013250e+05
  %166 = call double @log(double noundef %165) #6
  %167 = fmul double -8.576600e+03, %166
  %168 = load ptr, ptr %20, align 8, !tbaa !5
  store double %167, ptr %168, align 8, !tbaa !9
  store i32 0, ptr %22, align 4, !tbaa !12
  br label %169

169:                                              ; preds = %582, %102
  %170 = load i32, ptr %22, align 4, !tbaa !12
  %171 = icmp slt i32 %170, 10
  br i1 %171, label %172, label %585

172:                                              ; preds = %169
  %173 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %174 = call double @tan(double noundef %173) #6
  store double %174, ptr %23, align 8, !tbaa !9
  %175 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %176 = call double @tan(double noundef %175) #6
  store double %176, ptr %24, align 8, !tbaa !9
  %177 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %178 = call double @cos(double noundef %177) #6
  store double %178, ptr %25, align 8, !tbaa !9
  %179 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %180 = call double @cos(double noundef %179) #6
  store double %180, ptr %26, align 8, !tbaa !9
  %181 = load double, ptr @xhat, align 16, !tbaa !9
  %182 = call double @sin(double noundef %181) #6
  %183 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %184 = call double @tan(double noundef %183) #6
  %185 = fmul double %182, %184
  %186 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %187 = load double, ptr @r, align 8, !tbaa !9
  %188 = fsub double %186, %187
  %189 = load double, ptr @xhat, align 16, !tbaa !9
  %190 = call double @cos(double noundef %189) #6
  %191 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %192 = call double @tan(double noundef %191) #6
  %193 = fmul double %190, %192
  %194 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %195 = load double, ptr @q, align 8, !tbaa !9
  %196 = fsub double %194, %195
  %197 = fmul double %193, %196
  %198 = fneg double %197
  %199 = call double @llvm.fmuladd.f64(double %185, double %188, double %198)
  %200 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 0
  store double %199, ptr %200, align 16, !tbaa !9
  %201 = load double, ptr @xhat, align 16, !tbaa !9
  %202 = call double @cos(double noundef %201) #6
  %203 = fneg double %202
  %204 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %205 = load double, ptr @r, align 8, !tbaa !9
  %206 = fsub double %204, %205
  %207 = fmul double %203, %206
  %208 = load double, ptr %23, align 8, !tbaa !9
  %209 = load double, ptr %23, align 8, !tbaa !9
  %210 = call double @llvm.fmuladd.f64(double %208, double %209, double 1.000000e+00)
  %211 = load double, ptr @xhat, align 16, !tbaa !9
  %212 = call double @sin(double noundef %211) #6
  %213 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %214 = load double, ptr @q, align 8, !tbaa !9
  %215 = fsub double %213, %214
  %216 = fmul double %212, %215
  %217 = load double, ptr %24, align 8, !tbaa !9
  %218 = load double, ptr %24, align 8, !tbaa !9
  %219 = call double @llvm.fmuladd.f64(double %217, double %218, double 1.000000e+00)
  %220 = fmul double %216, %219
  %221 = fneg double %220
  %222 = call double @llvm.fmuladd.f64(double %207, double %210, double %221)
  %223 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 9
  store double %222, ptr %223, align 8, !tbaa !9
  %224 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 18
  store double 0.000000e+00, ptr %224, align 16, !tbaa !9
  %225 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 27
  store double -1.000000e+00, ptr %225, align 8, !tbaa !9
  %226 = load double, ptr @xhat, align 16, !tbaa !9
  %227 = call double @sin(double noundef %226) #6
  %228 = fneg double %227
  %229 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %230 = call double @tan(double noundef %229) #6
  %231 = fmul double %228, %230
  %232 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 36
  store double %231, ptr %232, align 16, !tbaa !9
  %233 = load double, ptr @xhat, align 16, !tbaa !9
  %234 = call double @cos(double noundef %233) #6
  %235 = fneg double %234
  %236 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %237 = call double @tan(double noundef %236) #6
  %238 = fmul double %235, %237
  %239 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 45
  store double %238, ptr %239, align 8, !tbaa !9
  %240 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 54
  store double 0.000000e+00, ptr %240, align 16, !tbaa !9
  %241 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 63
  store double 0.000000e+00, ptr %241, align 8, !tbaa !9
  %242 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 72
  store double 0.000000e+00, ptr %242, align 16, !tbaa !9
  %243 = load double, ptr @xhat, align 16, !tbaa !9
  %244 = call double @cos(double noundef %243) #6
  %245 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %246 = load double, ptr @r, align 8, !tbaa !9
  %247 = fsub double %245, %246
  %248 = load double, ptr @xhat, align 16, !tbaa !9
  %249 = call double @sin(double noundef %248) #6
  %250 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %251 = load double, ptr @q, align 8, !tbaa !9
  %252 = fsub double %250, %251
  %253 = fmul double %249, %252
  %254 = call double @llvm.fmuladd.f64(double %244, double %247, double %253)
  %255 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 1
  store double %254, ptr %255, align 8, !tbaa !9
  %256 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 10
  store double 0.000000e+00, ptr %256, align 16, !tbaa !9
  %257 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 19
  store double 0.000000e+00, ptr %257, align 8, !tbaa !9
  %258 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 28
  store double 0.000000e+00, ptr %258, align 16, !tbaa !9
  %259 = load double, ptr @xhat, align 16, !tbaa !9
  %260 = call double @cos(double noundef %259) #6
  %261 = fneg double %260
  %262 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 37
  store double %261, ptr %262, align 8, !tbaa !9
  %263 = load double, ptr @xhat, align 16, !tbaa !9
  %264 = call double @sin(double noundef %263) #6
  %265 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 46
  store double %264, ptr %265, align 16, !tbaa !9
  %266 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 55
  store double 0.000000e+00, ptr %266, align 8, !tbaa !9
  %267 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 64
  store double 0.000000e+00, ptr %267, align 16, !tbaa !9
  %268 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 73
  store double 0.000000e+00, ptr %268, align 8, !tbaa !9
  %269 = load double, ptr @xhat, align 16, !tbaa !9
  %270 = call double @sin(double noundef %269) #6
  %271 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %272 = load double, ptr @r, align 8, !tbaa !9
  %273 = fsub double %271, %272
  %274 = fmul double %270, %273
  %275 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %276 = call double @cos(double noundef %275) #6
  %277 = fdiv double %274, %276
  %278 = load double, ptr @xhat, align 16, !tbaa !9
  %279 = call double @cos(double noundef %278) #6
  %280 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %281 = load double, ptr @q, align 8, !tbaa !9
  %282 = fsub double %280, %281
  %283 = fmul double %279, %282
  %284 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %285 = call double @cos(double noundef %284) #6
  %286 = fdiv double %283, %285
  %287 = fsub double %277, %286
  %288 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 2
  store double %287, ptr %288, align 16, !tbaa !9
  %289 = load double, ptr @xhat, align 16, !tbaa !9
  %290 = call double @cos(double noundef %289) #6
  %291 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %292 = call double @sin(double noundef %291) #6
  %293 = fmul double %290, %292
  %294 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %295 = load double, ptr @r, align 8, !tbaa !9
  %296 = fsub double %294, %295
  %297 = fmul double %293, %296
  %298 = fneg double %297
  %299 = load double, ptr %25, align 8, !tbaa !9
  %300 = load double, ptr %25, align 8, !tbaa !9
  %301 = fmul double %299, %300
  %302 = fdiv double %298, %301
  %303 = load double, ptr @xhat, align 16, !tbaa !9
  %304 = call double @sin(double noundef %303) #6
  %305 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %306 = call double @sin(double noundef %305) #6
  %307 = fmul double %304, %306
  %308 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %309 = load double, ptr @q, align 8, !tbaa !9
  %310 = fsub double %308, %309
  %311 = fmul double %307, %310
  %312 = load double, ptr %26, align 8, !tbaa !9
  %313 = load double, ptr %26, align 8, !tbaa !9
  %314 = fmul double %312, %313
  %315 = fdiv double %311, %314
  %316 = fsub double %302, %315
  %317 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 11
  store double %316, ptr %317, align 8, !tbaa !9
  %318 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 20
  store double 0.000000e+00, ptr %318, align 16, !tbaa !9
  %319 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 29
  store double 0.000000e+00, ptr %319, align 8, !tbaa !9
  %320 = load double, ptr @xhat, align 16, !tbaa !9
  %321 = call double @sin(double noundef %320) #6
  %322 = fneg double %321
  %323 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %324 = call double @cos(double noundef %323) #6
  %325 = fdiv double %322, %324
  %326 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 38
  store double %325, ptr %326, align 16, !tbaa !9
  %327 = load double, ptr @xhat, align 16, !tbaa !9
  %328 = call double @cos(double noundef %327) #6
  %329 = fneg double %328
  %330 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %331 = call double @cos(double noundef %330) #6
  %332 = fdiv double %329, %331
  %333 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 47
  store double %332, ptr %333, align 8, !tbaa !9
  %334 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 56
  store double 0.000000e+00, ptr %334, align 16, !tbaa !9
  %335 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 65
  store double 0.000000e+00, ptr %335, align 8, !tbaa !9
  %336 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 74
  store double 0.000000e+00, ptr %336, align 16, !tbaa !9
  %337 = load double, ptr %16, align 8, !tbaa !9
  %338 = fdiv double %337, 1.000000e+01
  store double %338, ptr %23, align 8, !tbaa !9
  %339 = load double, ptr @p, align 8, !tbaa !9
  %340 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 3), align 8, !tbaa !9
  %341 = fsub double %339, %340
  %342 = load double, ptr @xhat, align 16, !tbaa !9
  %343 = call double @cos(double noundef %342) #6
  %344 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %345 = call double @tan(double noundef %344) #6
  %346 = fmul double %343, %345
  %347 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %348 = load double, ptr @r, align 8, !tbaa !9
  %349 = fsub double %347, %348
  %350 = fneg double %346
  %351 = call double @llvm.fmuladd.f64(double %350, double %349, double %341)
  %352 = load double, ptr @xhat, align 16, !tbaa !9
  %353 = call double @sin(double noundef %352) #6
  %354 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %355 = call double @tan(double noundef %354) #6
  %356 = fmul double %353, %355
  %357 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %358 = load double, ptr @q, align 8, !tbaa !9
  %359 = fsub double %357, %358
  %360 = fneg double %356
  %361 = call double @llvm.fmuladd.f64(double %360, double %359, double %351)
  %362 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 0
  store double %361, ptr %362, align 16, !tbaa !9
  %363 = load double, ptr @xhat, align 16, !tbaa !9
  %364 = call double @sin(double noundef %363) #6
  %365 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %366 = load double, ptr @r, align 8, !tbaa !9
  %367 = fsub double %365, %366
  %368 = load double, ptr @xhat, align 16, !tbaa !9
  %369 = call double @cos(double noundef %368) #6
  %370 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %371 = load double, ptr @q, align 8, !tbaa !9
  %372 = fsub double %370, %371
  %373 = fmul double %369, %372
  %374 = fneg double %373
  %375 = call double @llvm.fmuladd.f64(double %364, double %367, double %374)
  %376 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 1
  store double %375, ptr %376, align 8, !tbaa !9
  %377 = load double, ptr @xhat, align 16, !tbaa !9
  %378 = call double @sin(double noundef %377) #6
  %379 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %380 = load double, ptr @q, align 8, !tbaa !9
  %381 = fsub double %379, %380
  %382 = fmul double %378, %381
  %383 = fneg double %382
  %384 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %385 = call double @cos(double noundef %384) #6
  %386 = fdiv double %383, %385
  %387 = load double, ptr @xhat, align 16, !tbaa !9
  %388 = call double @cos(double noundef %387) #6
  %389 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %390 = load double, ptr @r, align 8, !tbaa !9
  %391 = fsub double %389, %390
  %392 = fmul double %388, %391
  %393 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %394 = call double @cos(double noundef %393) #6
  %395 = fdiv double %392, %394
  %396 = fsub double %386, %395
  %397 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 2
  store double %396, ptr %397, align 16, !tbaa !9
  %398 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 3
  store double 0.000000e+00, ptr %398, align 8, !tbaa !9
  %399 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 4
  store double 0.000000e+00, ptr %399, align 16, !tbaa !9
  %400 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 5
  store double 0.000000e+00, ptr %400, align 8, !tbaa !9
  %401 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 6
  store double 0.000000e+00, ptr %401, align 16, !tbaa !9
  %402 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 7
  store double 0.000000e+00, ptr %402, align 8, !tbaa !9
  %403 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 8
  store double 0.000000e+00, ptr %403, align 16, !tbaa !9
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %404

404:                                              ; preds = %448, %172
  %405 = load i32, ptr %21, align 4, !tbaa !12
  %406 = icmp slt i32 %405, 9
  br i1 %406, label %407, label %451

407:                                              ; preds = %404
  %408 = load i32, ptr %21, align 4, !tbaa !12
  %409 = mul nsw i32 9, %408
  %410 = add nsw i32 3, %409
  %411 = sext i32 %410 to i64
  %412 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %411
  store double 0.000000e+00, ptr %412, align 8, !tbaa !9
  %413 = load i32, ptr %21, align 4, !tbaa !12
  %414 = mul nsw i32 9, %413
  %415 = add nsw i32 4, %414
  %416 = sext i32 %415 to i64
  %417 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %416
  store double 0.000000e+00, ptr %417, align 8, !tbaa !9
  %418 = load i32, ptr %21, align 4, !tbaa !12
  %419 = mul nsw i32 9, %418
  %420 = add nsw i32 5, %419
  %421 = sext i32 %420 to i64
  %422 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %421
  store double 0.000000e+00, ptr %422, align 8, !tbaa !9
  %423 = load i32, ptr %21, align 4, !tbaa !12
  %424 = mul nsw i32 9, %423
  %425 = add nsw i32 6, %424
  %426 = sext i32 %425 to i64
  %427 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %426
  store double 0.000000e+00, ptr %427, align 8, !tbaa !9
  %428 = load i32, ptr %21, align 4, !tbaa !12
  %429 = mul nsw i32 9, %428
  %430 = add nsw i32 7, %429
  %431 = sext i32 %430 to i64
  %432 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %431
  store double 0.000000e+00, ptr %432, align 8, !tbaa !9
  %433 = load i32, ptr %21, align 4, !tbaa !12
  %434 = mul nsw i32 9, %433
  %435 = add nsw i32 8, %434
  %436 = sext i32 %435 to i64
  %437 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %436
  store double 0.000000e+00, ptr %437, align 8, !tbaa !9
  %438 = load double, ptr %23, align 8, !tbaa !9
  %439 = load i32, ptr %21, align 4, !tbaa !12
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds [9 x double], ptr %34, i64 0, i64 %440
  %442 = load double, ptr %441, align 8, !tbaa !9
  %443 = load i32, ptr %21, align 4, !tbaa !12
  %444 = sext i32 %443 to i64
  %445 = getelementptr inbounds [9 x double], ptr @xhat, i64 0, i64 %444
  %446 = load double, ptr %445, align 8, !tbaa !9
  %447 = call double @llvm.fmuladd.f64(double %438, double %442, double %446)
  store double %447, ptr %445, align 8, !tbaa !9
  br label %448

448:                                              ; preds = %407
  %449 = load i32, ptr %21, align 4, !tbaa !12
  %450 = add nsw i32 %449, 1
  store i32 %450, ptr %21, align 4, !tbaa !12
  br label %404, !llvm.loop !18

451:                                              ; preds = %404
  %452 = load double, ptr %16, align 8, !tbaa !9
  %453 = fdiv double %452, 1.000000e+01
  store double %453, ptr %23, align 8, !tbaa !9
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %454

454:                                              ; preds = %530, %451
  %455 = load i32, ptr %21, align 4, !tbaa !12
  %456 = icmp slt i32 %455, 9
  br i1 %456, label %457, label %533

457:                                              ; preds = %454
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %458

458:                                              ; preds = %526, %457
  %459 = load i32, ptr %36, align 4, !tbaa !12
  %460 = icmp slt i32 %459, 9
  br i1 %460, label %461, label %529

461:                                              ; preds = %458
  %462 = load i32, ptr %21, align 4, !tbaa !12
  %463 = load i32, ptr %36, align 4, !tbaa !12
  %464 = mul nsw i32 9, %463
  %465 = add nsw i32 %462, %464
  %466 = sext i32 %465 to i64
  %467 = getelementptr inbounds [81 x double], ptr %40, i64 0, i64 %466
  store double 0.000000e+00, ptr %467, align 8, !tbaa !9
  %468 = load i32, ptr %21, align 4, !tbaa !12
  %469 = load i32, ptr %36, align 4, !tbaa !12
  %470 = mul nsw i32 9, %469
  %471 = add nsw i32 %468, %470
  %472 = sext i32 %471 to i64
  %473 = getelementptr inbounds [81 x double], ptr %41, i64 0, i64 %472
  store double 0.000000e+00, ptr %473, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %474

474:                                              ; preds = %522, %461
  %475 = load i32, ptr %39, align 4, !tbaa !12
  %476 = icmp slt i32 %475, 9
  br i1 %476, label %477, label %525

477:                                              ; preds = %474
  %478 = load i32, ptr %21, align 4, !tbaa !12
  %479 = load i32, ptr %39, align 4, !tbaa !12
  %480 = mul nsw i32 9, %479
  %481 = add nsw i32 %478, %480
  %482 = sext i32 %481 to i64
  %483 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %482
  %484 = load double, ptr %483, align 8, !tbaa !9
  %485 = load i32, ptr %39, align 4, !tbaa !12
  %486 = load i32, ptr %36, align 4, !tbaa !12
  %487 = mul nsw i32 9, %486
  %488 = add nsw i32 %485, %487
  %489 = sext i32 %488 to i64
  %490 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %489
  %491 = load double, ptr %490, align 8, !tbaa !9
  %492 = load i32, ptr %21, align 4, !tbaa !12
  %493 = load i32, ptr %36, align 4, !tbaa !12
  %494 = mul nsw i32 9, %493
  %495 = add nsw i32 %492, %494
  %496 = sext i32 %495 to i64
  %497 = getelementptr inbounds [81 x double], ptr %40, i64 0, i64 %496
  %498 = load double, ptr %497, align 8, !tbaa !9
  %499 = call double @llvm.fmuladd.f64(double %484, double %491, double %498)
  store double %499, ptr %497, align 8, !tbaa !9
  %500 = load i32, ptr %21, align 4, !tbaa !12
  %501 = load i32, ptr %39, align 4, !tbaa !12
  %502 = mul nsw i32 9, %501
  %503 = add nsw i32 %500, %502
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %504
  %506 = load double, ptr %505, align 8, !tbaa !9
  %507 = load i32, ptr %36, align 4, !tbaa !12
  %508 = load i32, ptr %39, align 4, !tbaa !12
  %509 = mul nsw i32 9, %508
  %510 = add nsw i32 %507, %509
  %511 = sext i32 %510 to i64
  %512 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %511
  %513 = load double, ptr %512, align 8, !tbaa !9
  %514 = load i32, ptr %21, align 4, !tbaa !12
  %515 = load i32, ptr %36, align 4, !tbaa !12
  %516 = mul nsw i32 9, %515
  %517 = add nsw i32 %514, %516
  %518 = sext i32 %517 to i64
  %519 = getelementptr inbounds [81 x double], ptr %41, i64 0, i64 %518
  %520 = load double, ptr %519, align 8, !tbaa !9
  %521 = call double @llvm.fmuladd.f64(double %506, double %513, double %520)
  store double %521, ptr %519, align 8, !tbaa !9
  br label %522

522:                                              ; preds = %477
  %523 = load i32, ptr %39, align 4, !tbaa !12
  %524 = add nsw i32 %523, 1
  store i32 %524, ptr %39, align 4, !tbaa !12
  br label %474, !llvm.loop !19

525:                                              ; preds = %474
  br label %526

526:                                              ; preds = %525
  %527 = load i32, ptr %36, align 4, !tbaa !12
  %528 = add nsw i32 %527, 1
  store i32 %528, ptr %36, align 4, !tbaa !12
  br label %458, !llvm.loop !20

529:                                              ; preds = %458
  br label %530

530:                                              ; preds = %529
  %531 = load i32, ptr %21, align 4, !tbaa !12
  %532 = add nsw i32 %531, 1
  store i32 %532, ptr %21, align 4, !tbaa !12
  br label %454, !llvm.loop !21

533:                                              ; preds = %454
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %534

534:                                              ; preds = %578, %533
  %535 = load i32, ptr %21, align 4, !tbaa !12
  %536 = icmp slt i32 %535, 9
  br i1 %536, label %537, label %581

537:                                              ; preds = %534
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %538

538:                                              ; preds = %574, %537
  %539 = load i32, ptr %36, align 4, !tbaa !12
  %540 = icmp slt i32 %539, 9
  br i1 %540, label %541, label %577

541:                                              ; preds = %538
  %542 = load double, ptr %23, align 8, !tbaa !9
  %543 = load i32, ptr %36, align 4, !tbaa !12
  %544 = load i32, ptr %21, align 4, !tbaa !12
  %545 = mul nsw i32 9, %544
  %546 = add nsw i32 %543, %545
  %547 = sext i32 %546 to i64
  %548 = getelementptr inbounds [81 x double], ptr %40, i64 0, i64 %547
  %549 = load double, ptr %548, align 8, !tbaa !9
  %550 = load i32, ptr %36, align 4, !tbaa !12
  %551 = load i32, ptr %21, align 4, !tbaa !12
  %552 = mul nsw i32 9, %551
  %553 = add nsw i32 %550, %552
  %554 = sext i32 %553 to i64
  %555 = getelementptr inbounds [81 x double], ptr %41, i64 0, i64 %554
  %556 = load double, ptr %555, align 8, !tbaa !9
  %557 = fadd double %549, %556
  %558 = load i32, ptr %36, align 4, !tbaa !12
  %559 = load i32, ptr %21, align 4, !tbaa !12
  %560 = mul nsw i32 9, %559
  %561 = add nsw i32 %558, %560
  %562 = sext i32 %561 to i64
  %563 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %562
  %564 = load double, ptr %563, align 8, !tbaa !9
  %565 = fadd double %557, %564
  %566 = load i32, ptr %36, align 4, !tbaa !12
  %567 = load i32, ptr %21, align 4, !tbaa !12
  %568 = mul nsw i32 9, %567
  %569 = add nsw i32 %566, %568
  %570 = sext i32 %569 to i64
  %571 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %570
  %572 = load double, ptr %571, align 8, !tbaa !9
  %573 = call double @llvm.fmuladd.f64(double %542, double %565, double %572)
  store double %573, ptr %571, align 8, !tbaa !9
  br label %574

574:                                              ; preds = %541
  %575 = load i32, ptr %36, align 4, !tbaa !12
  %576 = add nsw i32 %575, 1
  store i32 %576, ptr %36, align 4, !tbaa !12
  br label %538, !llvm.loop !22

577:                                              ; preds = %538
  br label %578

578:                                              ; preds = %577
  %579 = load i32, ptr %21, align 4, !tbaa !12
  %580 = add nsw i32 %579, 1
  store i32 %580, ptr %21, align 4, !tbaa !12
  br label %534, !llvm.loop !23

581:                                              ; preds = %534
  br label %582

582:                                              ; preds = %581
  %583 = load i32, ptr %22, align 4, !tbaa !12
  %584 = add nsw i32 %583, 1
  store i32 %584, ptr %22, align 4, !tbaa !12
  br label %169, !llvm.loop !24

585:                                              ; preds = %169
  %586 = load double, ptr @xhat, align 16, !tbaa !9
  store double %586, ptr %23, align 8, !tbaa !9
  %587 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  store double %587, ptr %24, align 8, !tbaa !9
  %588 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 2), align 16, !tbaa !9
  store double %588, ptr %25, align 8, !tbaa !9
  %589 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 3), align 8, !tbaa !9
  store double %589, ptr %26, align 8, !tbaa !9
  %590 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  store double %590, ptr %27, align 8, !tbaa !9
  %591 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  store double %591, ptr %28, align 8, !tbaa !9
  %592 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 6), align 16, !tbaa !9
  store double %592, ptr %29, align 8, !tbaa !9
  %593 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 7), align 8, !tbaa !9
  store double %593, ptr %31, align 8, !tbaa !9
  %594 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 8), align 16, !tbaa !9
  store double %594, ptr %32, align 8, !tbaa !9
  %595 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 0
  store double 0.000000e+00, ptr %595, align 16, !tbaa !9
  %596 = load double, ptr @g, align 8, !tbaa !9
  %597 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %598 = call double @cos(double noundef %597) #6
  %599 = load double, ptr @V, align 8, !tbaa !9
  %600 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %601 = call double @cos(double noundef %600) #6
  %602 = fmul double %599, %601
  %603 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %604 = load double, ptr @q, align 8, !tbaa !9
  %605 = fsub double %603, %604
  %606 = fmul double %602, %605
  %607 = fneg double %606
  %608 = call double @llvm.fmuladd.f64(double %596, double %598, double %607)
  %609 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 4
  store double %608, ptr %609, align 16, !tbaa !9
  %610 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 8
  store double 0.000000e+00, ptr %610, align 16, !tbaa !9
  %611 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 12
  store double 0.000000e+00, ptr %611, align 16, !tbaa !9
  %612 = load double, ptr @V, align 8, !tbaa !9
  %613 = fneg double %612
  %614 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %615 = call double @sin(double noundef %614) #6
  %616 = fmul double %613, %615
  %617 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 16
  store double %616, ptr %617, align 16, !tbaa !9
  %618 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 20
  store double 0.000000e+00, ptr %618, align 16, !tbaa !9
  %619 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 24
  store double -1.000000e+00, ptr %619, align 16, !tbaa !9
  %620 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 28
  store double 0.000000e+00, ptr %620, align 16, !tbaa !9
  %621 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 32
  store double 0.000000e+00, ptr %621, align 16, !tbaa !9
  %622 = load double, ptr @g, align 8, !tbaa !9
  %623 = fneg double %622
  %624 = load double, ptr @xhat, align 16, !tbaa !9
  %625 = call double @cos(double noundef %624) #6
  %626 = fmul double %623, %625
  %627 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %628 = call double @cos(double noundef %627) #6
  %629 = fmul double %626, %628
  %630 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 1
  store double %629, ptr %630, align 8, !tbaa !9
  %631 = load double, ptr @V, align 8, !tbaa !9
  %632 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %633 = call double @cos(double noundef %632) #6
  %634 = fmul double %631, %633
  %635 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 3), align 8, !tbaa !9
  %636 = load double, ptr @p, align 8, !tbaa !9
  %637 = fsub double %635, %636
  %638 = load double, ptr @V, align 8, !tbaa !9
  %639 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %640 = call double @sin(double noundef %639) #6
  %641 = fmul double %638, %640
  %642 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 5), align 8, !tbaa !9
  %643 = load double, ptr @r, align 8, !tbaa !9
  %644 = fsub double %642, %643
  %645 = fmul double %641, %644
  %646 = call double @llvm.fmuladd.f64(double %634, double %637, double %645)
  %647 = load double, ptr @g, align 8, !tbaa !9
  %648 = load double, ptr @xhat, align 16, !tbaa !9
  %649 = call double @sin(double noundef %648) #6
  %650 = fmul double %647, %649
  %651 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %652 = call double @sin(double noundef %651) #6
  %653 = call double @llvm.fmuladd.f64(double %650, double %652, double %646)
  %654 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 5
  store double %653, ptr %654, align 8, !tbaa !9
  %655 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 9
  store double 0.000000e+00, ptr %655, align 8, !tbaa !9
  %656 = load double, ptr @V, align 8, !tbaa !9
  %657 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %658 = call double @sin(double noundef %657) #6
  %659 = fmul double %656, %658
  %660 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 13
  store double %659, ptr %660, align 8, !tbaa !9
  %661 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 17
  store double 0.000000e+00, ptr %661, align 8, !tbaa !9
  %662 = load double, ptr @V, align 8, !tbaa !9
  %663 = fneg double %662
  %664 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %665 = call double @cos(double noundef %664) #6
  %666 = fmul double %663, %665
  %667 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 21
  store double %666, ptr %667, align 8, !tbaa !9
  %668 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 25
  store double 0.000000e+00, ptr %668, align 8, !tbaa !9
  %669 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 29
  store double -1.000000e+00, ptr %669, align 8, !tbaa !9
  %670 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 33
  store double 0.000000e+00, ptr %670, align 8, !tbaa !9
  %671 = load double, ptr @g, align 8, !tbaa !9
  %672 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %673 = call double @cos(double noundef %672) #6
  %674 = fmul double %671, %673
  %675 = load double, ptr @xhat, align 16, !tbaa !9
  %676 = call double @sin(double noundef %675) #6
  %677 = fmul double %674, %676
  %678 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 2
  store double %677, ptr %678, align 16, !tbaa !9
  %679 = load double, ptr @g, align 8, !tbaa !9
  %680 = load double, ptr @xhat, align 16, !tbaa !9
  %681 = call double @cos(double noundef %680) #6
  %682 = fmul double %679, %681
  %683 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %684 = call double @sin(double noundef %683) #6
  %685 = load double, ptr @V, align 8, !tbaa !9
  %686 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %687 = call double @sin(double noundef %686) #6
  %688 = fmul double %685, %687
  %689 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 4), align 16, !tbaa !9
  %690 = load double, ptr @q, align 8, !tbaa !9
  %691 = fsub double %689, %690
  %692 = fmul double %688, %691
  %693 = fneg double %692
  %694 = call double @llvm.fmuladd.f64(double %682, double %684, double %693)
  %695 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 6
  store double %694, ptr %695, align 16, !tbaa !9
  %696 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 10
  store double 0.000000e+00, ptr %696, align 16, !tbaa !9
  %697 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 14
  store double 0.000000e+00, ptr %697, align 16, !tbaa !9
  %698 = load double, ptr @V, align 8, !tbaa !9
  %699 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %700 = call double @cos(double noundef %699) #6
  %701 = fmul double %698, %700
  %702 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 18
  store double %701, ptr %702, align 16, !tbaa !9
  %703 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 22
  store double 0.000000e+00, ptr %703, align 16, !tbaa !9
  %704 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 26
  store double 0.000000e+00, ptr %704, align 16, !tbaa !9
  %705 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 30
  store double 0.000000e+00, ptr %705, align 16, !tbaa !9
  %706 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 34
  store double -1.000000e+00, ptr %706, align 16, !tbaa !9
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %707

707:                                              ; preds = %721, %585
  %708 = load i32, ptr %21, align 4, !tbaa !12
  %709 = icmp slt i32 %708, 9
  br i1 %709, label %710, label %724

710:                                              ; preds = %707
  %711 = load i32, ptr %21, align 4, !tbaa !12
  %712 = sext i32 %711 to i64
  %713 = getelementptr inbounds [9 x i8], ptr @ekfAHRS.iv1, i64 0, i64 %712
  %714 = load i8, ptr %713, align 1, !tbaa !11
  %715 = sitofp i8 %714 to double
  %716 = load i32, ptr %21, align 4, !tbaa !12
  %717 = shl i32 %716, 2
  %718 = add nsw i32 3, %717
  %719 = sext i32 %718 to i64
  %720 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 %719
  store double %715, ptr %720, align 8, !tbaa !9
  br label %721

721:                                              ; preds = %710
  %722 = load i32, ptr %21, align 4, !tbaa !12
  %723 = add nsw i32 %722, 1
  store i32 %723, ptr %21, align 4, !tbaa !12
  br label %707, !llvm.loop !25

724:                                              ; preds = %707
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %725

725:                                              ; preds = %773, %724
  %726 = load i32, ptr %21, align 4, !tbaa !12
  %727 = icmp slt i32 %726, 9
  br i1 %727, label %728, label %776

728:                                              ; preds = %725
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %729

729:                                              ; preds = %769, %728
  %730 = load i32, ptr %36, align 4, !tbaa !12
  %731 = icmp slt i32 %730, 4
  br i1 %731, label %732, label %772

732:                                              ; preds = %729
  %733 = load i32, ptr %21, align 4, !tbaa !12
  %734 = load i32, ptr %36, align 4, !tbaa !12
  %735 = mul nsw i32 9, %734
  %736 = add nsw i32 %733, %735
  %737 = sext i32 %736 to i64
  %738 = getelementptr inbounds [36 x double], ptr %38, i64 0, i64 %737
  store double 0.000000e+00, ptr %738, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %739

739:                                              ; preds = %765, %732
  %740 = load i32, ptr %39, align 4, !tbaa !12
  %741 = icmp slt i32 %740, 9
  br i1 %741, label %742, label %768

742:                                              ; preds = %739
  %743 = load i32, ptr %21, align 4, !tbaa !12
  %744 = load i32, ptr %39, align 4, !tbaa !12
  %745 = mul nsw i32 9, %744
  %746 = add nsw i32 %743, %745
  %747 = sext i32 %746 to i64
  %748 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %747
  %749 = load double, ptr %748, align 8, !tbaa !9
  %750 = load i32, ptr %36, align 4, !tbaa !12
  %751 = load i32, ptr %39, align 4, !tbaa !12
  %752 = shl i32 %751, 2
  %753 = add nsw i32 %750, %752
  %754 = sext i32 %753 to i64
  %755 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 %754
  %756 = load double, ptr %755, align 8, !tbaa !9
  %757 = load i32, ptr %21, align 4, !tbaa !12
  %758 = load i32, ptr %36, align 4, !tbaa !12
  %759 = mul nsw i32 9, %758
  %760 = add nsw i32 %757, %759
  %761 = sext i32 %760 to i64
  %762 = getelementptr inbounds [36 x double], ptr %38, i64 0, i64 %761
  %763 = load double, ptr %762, align 8, !tbaa !9
  %764 = call double @llvm.fmuladd.f64(double %749, double %756, double %763)
  store double %764, ptr %762, align 8, !tbaa !9
  br label %765

765:                                              ; preds = %742
  %766 = load i32, ptr %39, align 4, !tbaa !12
  %767 = add nsw i32 %766, 1
  store i32 %767, ptr %39, align 4, !tbaa !12
  br label %739, !llvm.loop !26

768:                                              ; preds = %739
  br label %769

769:                                              ; preds = %768
  %770 = load i32, ptr %36, align 4, !tbaa !12
  %771 = add nsw i32 %770, 1
  store i32 %771, ptr %36, align 4, !tbaa !12
  br label %729, !llvm.loop !27

772:                                              ; preds = %729
  br label %773

773:                                              ; preds = %772
  %774 = load i32, ptr %21, align 4, !tbaa !12
  %775 = add nsw i32 %774, 1
  store i32 %775, ptr %21, align 4, !tbaa !12
  br label %725, !llvm.loop !28

776:                                              ; preds = %725
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %777

777:                                              ; preds = %872, %776
  %778 = load i32, ptr %21, align 4, !tbaa !12
  %779 = icmp slt i32 %778, 4
  br i1 %779, label %780, label %875

780:                                              ; preds = %777
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %781

781:                                              ; preds = %821, %780
  %782 = load i32, ptr %36, align 4, !tbaa !12
  %783 = icmp slt i32 %782, 9
  br i1 %783, label %784, label %824

784:                                              ; preds = %781
  %785 = load i32, ptr %21, align 4, !tbaa !12
  %786 = load i32, ptr %36, align 4, !tbaa !12
  %787 = shl i32 %786, 2
  %788 = add nsw i32 %785, %787
  %789 = sext i32 %788 to i64
  %790 = getelementptr inbounds [36 x double], ptr %37, i64 0, i64 %789
  store double 0.000000e+00, ptr %790, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %791

791:                                              ; preds = %817, %784
  %792 = load i32, ptr %39, align 4, !tbaa !12
  %793 = icmp slt i32 %792, 9
  br i1 %793, label %794, label %820

794:                                              ; preds = %791
  %795 = load i32, ptr %21, align 4, !tbaa !12
  %796 = load i32, ptr %39, align 4, !tbaa !12
  %797 = shl i32 %796, 2
  %798 = add nsw i32 %795, %797
  %799 = sext i32 %798 to i64
  %800 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 %799
  %801 = load double, ptr %800, align 8, !tbaa !9
  %802 = load i32, ptr %39, align 4, !tbaa !12
  %803 = load i32, ptr %36, align 4, !tbaa !12
  %804 = mul nsw i32 9, %803
  %805 = add nsw i32 %802, %804
  %806 = sext i32 %805 to i64
  %807 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %806
  %808 = load double, ptr %807, align 8, !tbaa !9
  %809 = load i32, ptr %21, align 4, !tbaa !12
  %810 = load i32, ptr %36, align 4, !tbaa !12
  %811 = shl i32 %810, 2
  %812 = add nsw i32 %809, %811
  %813 = sext i32 %812 to i64
  %814 = getelementptr inbounds [36 x double], ptr %37, i64 0, i64 %813
  %815 = load double, ptr %814, align 8, !tbaa !9
  %816 = call double @llvm.fmuladd.f64(double %801, double %808, double %815)
  store double %816, ptr %814, align 8, !tbaa !9
  br label %817

817:                                              ; preds = %794
  %818 = load i32, ptr %39, align 4, !tbaa !12
  %819 = add nsw i32 %818, 1
  store i32 %819, ptr %39, align 4, !tbaa !12
  br label %791, !llvm.loop !29

820:                                              ; preds = %791
  br label %821

821:                                              ; preds = %820
  %822 = load i32, ptr %36, align 4, !tbaa !12
  %823 = add nsw i32 %822, 1
  store i32 %823, ptr %36, align 4, !tbaa !12
  br label %781, !llvm.loop !30

824:                                              ; preds = %781
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %825

825:                                              ; preds = %868, %824
  %826 = load i32, ptr %36, align 4, !tbaa !12
  %827 = icmp slt i32 %826, 4
  br i1 %827, label %828, label %871

828:                                              ; preds = %825
  store double 0.000000e+00, ptr %42, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %829

829:                                              ; preds = %849, %828
  %830 = load i32, ptr %39, align 4, !tbaa !12
  %831 = icmp slt i32 %830, 9
  br i1 %831, label %832, label %852

832:                                              ; preds = %829
  %833 = load i32, ptr %21, align 4, !tbaa !12
  %834 = load i32, ptr %39, align 4, !tbaa !12
  %835 = shl i32 %834, 2
  %836 = add nsw i32 %833, %835
  %837 = sext i32 %836 to i64
  %838 = getelementptr inbounds [36 x double], ptr %37, i64 0, i64 %837
  %839 = load double, ptr %838, align 8, !tbaa !9
  %840 = load i32, ptr %36, align 4, !tbaa !12
  %841 = load i32, ptr %39, align 4, !tbaa !12
  %842 = shl i32 %841, 2
  %843 = add nsw i32 %840, %842
  %844 = sext i32 %843 to i64
  %845 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 %844
  %846 = load double, ptr %845, align 8, !tbaa !9
  %847 = load double, ptr %42, align 8, !tbaa !9
  %848 = call double @llvm.fmuladd.f64(double %839, double %846, double %847)
  store double %848, ptr %42, align 8, !tbaa !9
  br label %849

849:                                              ; preds = %832
  %850 = load i32, ptr %39, align 4, !tbaa !12
  %851 = add nsw i32 %850, 1
  store i32 %851, ptr %39, align 4, !tbaa !12
  br label %829, !llvm.loop !31

852:                                              ; preds = %829
  %853 = load double, ptr %42, align 8, !tbaa !9
  %854 = load i32, ptr %21, align 4, !tbaa !12
  %855 = load i32, ptr %36, align 4, !tbaa !12
  %856 = shl i32 %855, 2
  %857 = add nsw i32 %854, %856
  %858 = sext i32 %857 to i64
  %859 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %858
  %860 = load double, ptr %859, align 8, !tbaa !9
  %861 = fadd double %853, %860
  %862 = load i32, ptr %21, align 4, !tbaa !12
  %863 = load i32, ptr %36, align 4, !tbaa !12
  %864 = shl i32 %863, 2
  %865 = add nsw i32 %862, %864
  %866 = sext i32 %865 to i64
  %867 = getelementptr inbounds [16 x double], ptr %35, i64 0, i64 %866
  store double %861, ptr %867, align 8, !tbaa !9
  br label %868

868:                                              ; preds = %852
  %869 = load i32, ptr %36, align 4, !tbaa !12
  %870 = add nsw i32 %869, 1
  store i32 %870, ptr %36, align 4, !tbaa !12
  br label %825, !llvm.loop !32

871:                                              ; preds = %825
  br label %872

872:                                              ; preds = %871
  %873 = load i32, ptr %21, align 4, !tbaa !12
  %874 = add nsw i32 %873, 1
  store i32 %874, ptr %21, align 4, !tbaa !12
  br label %777, !llvm.loop !33

875:                                              ; preds = %777
  %876 = getelementptr inbounds [36 x double], ptr %38, i64 0, i64 0
  %877 = getelementptr inbounds [16 x double], ptr %35, i64 0, i64 0
  call void @mrdivide(ptr noundef %876, ptr noundef %877)
  %878 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 0
  call void @llvm.memset.p0.i64(ptr align 16 %878, i8 0, i64 648, i1 false)
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %879

879:                                              ; preds = %889, %875
  %880 = load i32, ptr %21, align 4, !tbaa !12
  %881 = icmp slt i32 %880, 9
  br i1 %881, label %882, label %892

882:                                              ; preds = %879
  %883 = load i32, ptr %21, align 4, !tbaa !12
  %884 = load i32, ptr %21, align 4, !tbaa !12
  %885 = mul nsw i32 9, %884
  %886 = add nsw i32 %883, %885
  %887 = sext i32 %886 to i64
  %888 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %887
  store double 1.000000e+00, ptr %888, align 8, !tbaa !9
  br label %889

889:                                              ; preds = %882
  %890 = load i32, ptr %21, align 4, !tbaa !12
  %891 = add nsw i32 %890, 1
  store i32 %891, ptr %21, align 4, !tbaa !12
  br label %879, !llvm.loop !34

892:                                              ; preds = %879
  %893 = getelementptr inbounds [81 x double], ptr %43, i64 0, i64 0
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %893, ptr align 16 @P, i64 648, i1 false)
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %894

894:                                              ; preds = %989, %892
  %895 = load i32, ptr %21, align 4, !tbaa !12
  %896 = icmp slt i32 %895, 9
  br i1 %896, label %897, label %992

897:                                              ; preds = %894
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %898

898:                                              ; preds = %941, %897
  %899 = load i32, ptr %36, align 4, !tbaa !12
  %900 = icmp slt i32 %899, 9
  br i1 %900, label %901, label %944

901:                                              ; preds = %898
  store double 0.000000e+00, ptr %42, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %902

902:                                              ; preds = %922, %901
  %903 = load i32, ptr %39, align 4, !tbaa !12
  %904 = icmp slt i32 %903, 4
  br i1 %904, label %905, label %925

905:                                              ; preds = %902
  %906 = load i32, ptr %21, align 4, !tbaa !12
  %907 = load i32, ptr %39, align 4, !tbaa !12
  %908 = mul nsw i32 9, %907
  %909 = add nsw i32 %906, %908
  %910 = sext i32 %909 to i64
  %911 = getelementptr inbounds [36 x double], ptr %38, i64 0, i64 %910
  %912 = load double, ptr %911, align 8, !tbaa !9
  %913 = load i32, ptr %39, align 4, !tbaa !12
  %914 = load i32, ptr %36, align 4, !tbaa !12
  %915 = shl i32 %914, 2
  %916 = add nsw i32 %913, %915
  %917 = sext i32 %916 to i64
  %918 = getelementptr inbounds [36 x double], ptr %33, i64 0, i64 %917
  %919 = load double, ptr %918, align 8, !tbaa !9
  %920 = load double, ptr %42, align 8, !tbaa !9
  %921 = call double @llvm.fmuladd.f64(double %912, double %919, double %920)
  store double %921, ptr %42, align 8, !tbaa !9
  br label %922

922:                                              ; preds = %905
  %923 = load i32, ptr %39, align 4, !tbaa !12
  %924 = add nsw i32 %923, 1
  store i32 %924, ptr %39, align 4, !tbaa !12
  br label %902, !llvm.loop !35

925:                                              ; preds = %902
  %926 = load i32, ptr %21, align 4, !tbaa !12
  %927 = load i32, ptr %36, align 4, !tbaa !12
  %928 = mul nsw i32 9, %927
  %929 = add nsw i32 %926, %928
  %930 = sext i32 %929 to i64
  %931 = getelementptr inbounds [81 x double], ptr %30, i64 0, i64 %930
  %932 = load double, ptr %931, align 8, !tbaa !9
  %933 = load double, ptr %42, align 8, !tbaa !9
  %934 = fsub double %932, %933
  %935 = load i32, ptr %21, align 4, !tbaa !12
  %936 = load i32, ptr %36, align 4, !tbaa !12
  %937 = mul nsw i32 9, %936
  %938 = add nsw i32 %935, %937
  %939 = sext i32 %938 to i64
  %940 = getelementptr inbounds [81 x double], ptr %40, i64 0, i64 %939
  store double %934, ptr %940, align 8, !tbaa !9
  br label %941

941:                                              ; preds = %925
  %942 = load i32, ptr %36, align 4, !tbaa !12
  %943 = add nsw i32 %942, 1
  store i32 %943, ptr %36, align 4, !tbaa !12
  br label %898, !llvm.loop !36

944:                                              ; preds = %898
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %945

945:                                              ; preds = %985, %944
  %946 = load i32, ptr %36, align 4, !tbaa !12
  %947 = icmp slt i32 %946, 9
  br i1 %947, label %948, label %988

948:                                              ; preds = %945
  %949 = load i32, ptr %21, align 4, !tbaa !12
  %950 = load i32, ptr %36, align 4, !tbaa !12
  %951 = mul nsw i32 9, %950
  %952 = add nsw i32 %949, %951
  %953 = sext i32 %952 to i64
  %954 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %953
  store double 0.000000e+00, ptr %954, align 8, !tbaa !9
  store i32 0, ptr %39, align 4, !tbaa !12
  br label %955

955:                                              ; preds = %981, %948
  %956 = load i32, ptr %39, align 4, !tbaa !12
  %957 = icmp slt i32 %956, 9
  br i1 %957, label %958, label %984

958:                                              ; preds = %955
  %959 = load i32, ptr %21, align 4, !tbaa !12
  %960 = load i32, ptr %39, align 4, !tbaa !12
  %961 = mul nsw i32 9, %960
  %962 = add nsw i32 %959, %961
  %963 = sext i32 %962 to i64
  %964 = getelementptr inbounds [81 x double], ptr %40, i64 0, i64 %963
  %965 = load double, ptr %964, align 8, !tbaa !9
  %966 = load i32, ptr %39, align 4, !tbaa !12
  %967 = load i32, ptr %36, align 4, !tbaa !12
  %968 = mul nsw i32 9, %967
  %969 = add nsw i32 %966, %968
  %970 = sext i32 %969 to i64
  %971 = getelementptr inbounds [81 x double], ptr %43, i64 0, i64 %970
  %972 = load double, ptr %971, align 8, !tbaa !9
  %973 = load i32, ptr %21, align 4, !tbaa !12
  %974 = load i32, ptr %36, align 4, !tbaa !12
  %975 = mul nsw i32 9, %974
  %976 = add nsw i32 %973, %975
  %977 = sext i32 %976 to i64
  %978 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %977
  %979 = load double, ptr %978, align 8, !tbaa !9
  %980 = call double @llvm.fmuladd.f64(double %965, double %972, double %979)
  store double %980, ptr %978, align 8, !tbaa !9
  br label %981

981:                                              ; preds = %958
  %982 = load i32, ptr %39, align 4, !tbaa !12
  %983 = add nsw i32 %982, 1
  store i32 %983, ptr %39, align 4, !tbaa !12
  br label %955, !llvm.loop !37

984:                                              ; preds = %955
  br label %985

985:                                              ; preds = %984
  %986 = load i32, ptr %36, align 4, !tbaa !12
  %987 = add nsw i32 %986, 1
  store i32 %987, ptr %36, align 4, !tbaa !12
  br label %945, !llvm.loop !38

988:                                              ; preds = %945
  br label %989

989:                                              ; preds = %988
  %990 = load i32, ptr %21, align 4, !tbaa !12
  %991 = add nsw i32 %990, 1
  store i32 %991, ptr %21, align 4, !tbaa !12
  br label %894, !llvm.loop !39

992:                                              ; preds = %894
  %993 = load double, ptr @ax, align 8, !tbaa !9
  %994 = getelementptr inbounds [4 x double], ptr %44, i64 0, i64 0
  store double %993, ptr %994, align 16, !tbaa !9
  %995 = load double, ptr @ay, align 8, !tbaa !9
  %996 = getelementptr inbounds [4 x double], ptr %44, i64 0, i64 1
  store double %995, ptr %996, align 8, !tbaa !9
  %997 = load double, ptr @az, align 8, !tbaa !9
  %998 = getelementptr inbounds [4 x double], ptr %44, i64 0, i64 2
  store double %997, ptr %998, align 16, !tbaa !9
  %999 = load ptr, ptr %13, align 8, !tbaa !5
  %1000 = getelementptr inbounds double, ptr %999, i64 1
  %1001 = load double, ptr %1000, align 8, !tbaa !9
  %1002 = fneg double %1001
  %1003 = load double, ptr %23, align 8, !tbaa !9
  %1004 = call double @cos(double noundef %1003) #6
  %1005 = load ptr, ptr %13, align 8, !tbaa !5
  %1006 = getelementptr inbounds double, ptr %1005, i64 2
  %1007 = load double, ptr %1006, align 8, !tbaa !9
  %1008 = load double, ptr %23, align 8, !tbaa !9
  %1009 = call double @sin(double noundef %1008) #6
  %1010 = fmul double %1007, %1009
  %1011 = call double @llvm.fmuladd.f64(double %1002, double %1004, double %1010)
  %1012 = load ptr, ptr %13, align 8, !tbaa !5
  %1013 = getelementptr inbounds double, ptr %1012, i64 0
  %1014 = load double, ptr %1013, align 8, !tbaa !9
  %1015 = load double, ptr %24, align 8, !tbaa !9
  %1016 = call double @cos(double noundef %1015) #6
  %1017 = load ptr, ptr %13, align 8, !tbaa !5
  %1018 = getelementptr inbounds double, ptr %1017, i64 1
  %1019 = load double, ptr %1018, align 8, !tbaa !9
  %1020 = load double, ptr %23, align 8, !tbaa !9
  %1021 = call double @sin(double noundef %1020) #6
  %1022 = load ptr, ptr %13, align 8, !tbaa !5
  %1023 = getelementptr inbounds double, ptr %1022, i64 2
  %1024 = load double, ptr %1023, align 8, !tbaa !9
  %1025 = load double, ptr %23, align 8, !tbaa !9
  %1026 = call double @cos(double noundef %1025) #6
  %1027 = fmul double %1024, %1026
  %1028 = call double @llvm.fmuladd.f64(double %1019, double %1021, double %1027)
  %1029 = load double, ptr %24, align 8, !tbaa !9
  %1030 = call double @sin(double noundef %1029) #6
  %1031 = fmul double %1028, %1030
  %1032 = call double @llvm.fmuladd.f64(double %1014, double %1016, double %1031)
  %1033 = call double @atan2(double noundef %1011, double noundef %1032) #6
  %1034 = fadd double %1033, 0x3FEBECDE5DA115A9
  %1035 = getelementptr inbounds [4 x double], ptr %44, i64 0, i64 3
  store double %1034, ptr %1035, align 8, !tbaa !9
  %1036 = load double, ptr @g, align 8, !tbaa !9
  %1037 = load double, ptr %24, align 8, !tbaa !9
  %1038 = call double @sin(double noundef %1037) #6
  %1039 = load double, ptr @V, align 8, !tbaa !9
  %1040 = load double, ptr %24, align 8, !tbaa !9
  %1041 = call double @sin(double noundef %1040) #6
  %1042 = fmul double %1039, %1041
  %1043 = load double, ptr %27, align 8, !tbaa !9
  %1044 = load double, ptr @q, align 8, !tbaa !9
  %1045 = fsub double %1043, %1044
  %1046 = fmul double %1042, %1045
  %1047 = fneg double %1046
  %1048 = call double @llvm.fmuladd.f64(double %1036, double %1038, double %1047)
  %1049 = load double, ptr %29, align 8, !tbaa !9
  %1050 = fsub double %1048, %1049
  %1051 = getelementptr inbounds [4 x double], ptr %45, i64 0, i64 0
  store double %1050, ptr %1051, align 16, !tbaa !9
  %1052 = load double, ptr @V, align 8, !tbaa !9
  %1053 = load double, ptr %24, align 8, !tbaa !9
  %1054 = call double @sin(double noundef %1053) #6
  %1055 = fmul double %1052, %1054
  %1056 = load double, ptr %26, align 8, !tbaa !9
  %1057 = load double, ptr @p, align 8, !tbaa !9
  %1058 = fsub double %1056, %1057
  %1059 = load double, ptr @V, align 8, !tbaa !9
  %1060 = load double, ptr %24, align 8, !tbaa !9
  %1061 = call double @cos(double noundef %1060) #6
  %1062 = fmul double %1059, %1061
  %1063 = load double, ptr %28, align 8, !tbaa !9
  %1064 = load double, ptr @r, align 8, !tbaa !9
  %1065 = fsub double %1063, %1064
  %1066 = fmul double %1062, %1065
  %1067 = fneg double %1066
  %1068 = call double @llvm.fmuladd.f64(double %1055, double %1058, double %1067)
  %1069 = load double, ptr @g, align 8, !tbaa !9
  %1070 = load double, ptr %24, align 8, !tbaa !9
  %1071 = call double @cos(double noundef %1070) #6
  %1072 = fmul double %1069, %1071
  %1073 = load double, ptr %23, align 8, !tbaa !9
  %1074 = call double @sin(double noundef %1073) #6
  %1075 = fneg double %1072
  %1076 = call double @llvm.fmuladd.f64(double %1075, double %1074, double %1068)
  %1077 = load double, ptr %31, align 8, !tbaa !9
  %1078 = fsub double %1076, %1077
  %1079 = getelementptr inbounds [4 x double], ptr %45, i64 0, i64 1
  store double %1078, ptr %1079, align 8, !tbaa !9
  %1080 = load double, ptr @V, align 8, !tbaa !9
  %1081 = load double, ptr %24, align 8, !tbaa !9
  %1082 = call double @cos(double noundef %1081) #6
  %1083 = fmul double %1080, %1082
  %1084 = load double, ptr %27, align 8, !tbaa !9
  %1085 = load double, ptr @q, align 8, !tbaa !9
  %1086 = fsub double %1084, %1085
  %1087 = load double, ptr @g, align 8, !tbaa !9
  %1088 = load double, ptr %23, align 8, !tbaa !9
  %1089 = call double @cos(double noundef %1088) #6
  %1090 = fmul double %1087, %1089
  %1091 = load double, ptr %24, align 8, !tbaa !9
  %1092 = call double @cos(double noundef %1091) #6
  %1093 = fmul double %1090, %1092
  %1094 = fneg double %1093
  %1095 = call double @llvm.fmuladd.f64(double %1083, double %1086, double %1094)
  %1096 = load double, ptr %32, align 8, !tbaa !9
  %1097 = fsub double %1095, %1096
  %1098 = getelementptr inbounds [4 x double], ptr %45, i64 0, i64 2
  store double %1097, ptr %1098, align 16, !tbaa !9
  %1099 = load double, ptr %25, align 8, !tbaa !9
  %1100 = getelementptr inbounds [4 x double], ptr %45, i64 0, i64 3
  store double %1099, ptr %1100, align 8, !tbaa !9
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %1101

1101:                                             ; preds = %1117, %992
  %1102 = load i32, ptr %21, align 4, !tbaa !12
  %1103 = icmp slt i32 %1102, 4
  br i1 %1103, label %1104, label %1120

1104:                                             ; preds = %1101
  %1105 = load i32, ptr %21, align 4, !tbaa !12
  %1106 = sext i32 %1105 to i64
  %1107 = getelementptr inbounds [4 x double], ptr %44, i64 0, i64 %1106
  %1108 = load double, ptr %1107, align 8, !tbaa !9
  %1109 = load i32, ptr %21, align 4, !tbaa !12
  %1110 = sext i32 %1109 to i64
  %1111 = getelementptr inbounds [4 x double], ptr %45, i64 0, i64 %1110
  %1112 = load double, ptr %1111, align 8, !tbaa !9
  %1113 = fsub double %1108, %1112
  %1114 = load i32, ptr %21, align 4, !tbaa !12
  %1115 = sext i32 %1114 to i64
  %1116 = getelementptr inbounds [4 x double], ptr %46, i64 0, i64 %1115
  store double %1113, ptr %1116, align 8, !tbaa !9
  br label %1117

1117:                                             ; preds = %1104
  %1118 = load i32, ptr %21, align 4, !tbaa !12
  %1119 = add nsw i32 %1118, 1
  store i32 %1119, ptr %21, align 4, !tbaa !12
  br label %1101, !llvm.loop !40

1120:                                             ; preds = %1101
  store i32 0, ptr %21, align 4, !tbaa !12
  br label %1121

1121:                                             ; preds = %1152, %1120
  %1122 = load i32, ptr %21, align 4, !tbaa !12
  %1123 = icmp slt i32 %1122, 9
  br i1 %1123, label %1124, label %1155

1124:                                             ; preds = %1121
  store double 0.000000e+00, ptr %42, align 8, !tbaa !9
  store i32 0, ptr %36, align 4, !tbaa !12
  br label %1125

1125:                                             ; preds = %1142, %1124
  %1126 = load i32, ptr %36, align 4, !tbaa !12
  %1127 = icmp slt i32 %1126, 4
  br i1 %1127, label %1128, label %1145

1128:                                             ; preds = %1125
  %1129 = load i32, ptr %21, align 4, !tbaa !12
  %1130 = load i32, ptr %36, align 4, !tbaa !12
  %1131 = mul nsw i32 9, %1130
  %1132 = add nsw i32 %1129, %1131
  %1133 = sext i32 %1132 to i64
  %1134 = getelementptr inbounds [36 x double], ptr %38, i64 0, i64 %1133
  %1135 = load double, ptr %1134, align 8, !tbaa !9
  %1136 = load i32, ptr %36, align 4, !tbaa !12
  %1137 = sext i32 %1136 to i64
  %1138 = getelementptr inbounds [4 x double], ptr %46, i64 0, i64 %1137
  %1139 = load double, ptr %1138, align 8, !tbaa !9
  %1140 = load double, ptr %42, align 8, !tbaa !9
  %1141 = call double @llvm.fmuladd.f64(double %1135, double %1139, double %1140)
  store double %1141, ptr %42, align 8, !tbaa !9
  br label %1142

1142:                                             ; preds = %1128
  %1143 = load i32, ptr %36, align 4, !tbaa !12
  %1144 = add nsw i32 %1143, 1
  store i32 %1144, ptr %36, align 4, !tbaa !12
  br label %1125, !llvm.loop !41

1145:                                             ; preds = %1125
  %1146 = load double, ptr %42, align 8, !tbaa !9
  %1147 = load i32, ptr %21, align 4, !tbaa !12
  %1148 = sext i32 %1147 to i64
  %1149 = getelementptr inbounds [9 x double], ptr @xhat, i64 0, i64 %1148
  %1150 = load double, ptr %1149, align 8, !tbaa !9
  %1151 = fadd double %1150, %1146
  store double %1151, ptr %1149, align 8, !tbaa !9
  br label %1152

1152:                                             ; preds = %1145
  %1153 = load i32, ptr %21, align 4, !tbaa !12
  %1154 = add nsw i32 %1153, 1
  store i32 %1154, ptr %21, align 4, !tbaa !12
  br label %1121, !llvm.loop !42

1155:                                             ; preds = %1121
  %1156 = load double, ptr @xhat, align 16, !tbaa !9
  %1157 = fmul double %1156, 1.800000e+02
  %1158 = fdiv double %1157, 0x400921FB54442D18
  %1159 = load ptr, ptr %17, align 8, !tbaa !5
  store double %1158, ptr %1159, align 8, !tbaa !9
  %1160 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 1), align 8, !tbaa !9
  %1161 = fmul double %1160, 1.800000e+02
  %1162 = fdiv double %1161, 0x400921FB54442D18
  %1163 = load ptr, ptr %18, align 8, !tbaa !5
  store double %1162, ptr %1163, align 8, !tbaa !9
  %1164 = load double, ptr getelementptr inbounds ([9 x double], ptr @xhat, i64 0, i64 2), align 16, !tbaa !9
  %1165 = fmul double %1164, 1.800000e+02
  %1166 = fdiv double %1165, 0x400921FB54442D18
  %1167 = load ptr, ptr %19, align 8, !tbaa !5
  store double %1166, ptr %1167, align 8, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 32, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 32, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 648, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 648, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 648, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 288, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 288, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 128, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 72, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 288, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 648, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #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 nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #2

; Function Attrs: nounwind
declare double @log(double noundef) #3

; Function Attrs: nounwind
declare double @tan(double noundef) #3

; Function Attrs: nounwind
declare double @cos(double noundef) #3

; Function Attrs: nounwind
declare double @sin(double noundef) #3

; Function Attrs: nounwind uwtable
declare hidden void @mrdivide(ptr noundef, ptr noundef) #0

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

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

; Function Attrs: nounwind
declare double @atan2(double noundef, double noundef) #3

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

attributes #0 = { 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 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { nounwind "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 nounwind willreturn memory(argmem: write) }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { nounwind }

!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/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!7, !7, i64 0}
!12 = !{!13, !13, i64 0}
!13 = !{!"int", !7, i64 0}
!14 = distinct !{!14, !15}
!15 = !{!"llvm.loop.mustprogress"}
!16 = distinct !{!16, !15}
!17 = distinct !{!17, !15}
!18 = distinct !{!18, !15}
!19 = distinct !{!19, !15}
!20 = distinct !{!20, !15}
!21 = distinct !{!21, !15}
!22 = distinct !{!22, !15}
!23 = distinct !{!23, !15}
!24 = distinct !{!24, !15}
!25 = distinct !{!25, !15}
!26 = distinct !{!26, !15}
!27 = distinct !{!27, !15}
!28 = distinct !{!28, !15}
!29 = distinct !{!29, !15}
!30 = distinct !{!30, !15}
!31 = distinct !{!31, !15}
!32 = distinct !{!32, !15}
!33 = distinct !{!33, !15}
!34 = distinct !{!34, !15}
!35 = distinct !{!35, !15}
!36 = distinct !{!36, !15}
!37 = distinct !{!37, !15}
!38 = distinct !{!38, !15}
!39 = distinct !{!39, !15}
!40 = distinct !{!40, !15}
!41 = distinct !{!41, !15}
!42 = distinct !{!42, !15}


; 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"

@ekfAHRS.dv0 = external hidden local_unnamed_addr constant [81 x double], align 16
@ekfAHRS.dv1 = external hidden local_unnamed_addr constant [9 x double], align 16
@ekfAHRS.iv0 = external hidden local_unnamed_addr constant [16 x i8], align 16
@ekfAHRS.iv1 = external hidden local_unnamed_addr constant [9 x i8], align 1
@flag_not_empty = external hidden local_unnamed_addr global i8, align 1
@P = external hidden local_unnamed_addr global [81 x double], align 16
@Q = external hidden local_unnamed_addr global [81 x double], align 16
@R = external hidden local_unnamed_addr global [16 x double], align 16
@lpfGyrCoeff = external hidden local_unnamed_addr global double, align 8
@p = external hidden local_unnamed_addr global double, align 8
@q = external hidden local_unnamed_addr global double, align 8
@r = external hidden local_unnamed_addr global double, align 8
@lpfAccCoeff = external hidden local_unnamed_addr global double, align 8
@ax = external hidden local_unnamed_addr global double, align 8
@ay = external hidden local_unnamed_addr global double, align 8
@az = external hidden local_unnamed_addr global double, align 8
@lpfVaCoeff = external hidden local_unnamed_addr global double, align 8
@V = external hidden local_unnamed_addr global double, align 8
@xhat = external hidden local_unnamed_addr global [9 x double], align 16
@g = external hidden local_unnamed_addr global double, align 8

; Function Attrs: nounwind uwtable
define dso_local void @ekfAHRS(ptr nocapture noundef readonly %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2, double noundef %3, double noundef %4, double noundef %5, ptr nocapture noundef writeonly %6, ptr nocapture noundef writeonly %7, ptr nocapture noundef writeonly %8, ptr nocapture noundef writeonly %9) local_unnamed_addr #0 {
  %11 = alloca [81 x double], align 16
  %12 = alloca [36 x double], align 16
  %13 = alloca [16 x double], align 16
  %14 = alloca [36 x double], align 16
  %15 = alloca [36 x double], align 16
  %16 = alloca [81 x double], align 16
  %17 = alloca [81 x double], align 16
  call void @llvm.lifetime.start.p0(i64 648, ptr nonnull %11) #7
  call void @llvm.lifetime.start.p0(i64 288, ptr nonnull %12) #7
  call void @llvm.lifetime.start.p0(i64 128, ptr nonnull %13) #7
  call void @llvm.lifetime.start.p0(i64 288, ptr nonnull %14) #7
  call void @llvm.lifetime.start.p0(i64 288, ptr nonnull %15) #7
  call void @llvm.lifetime.start.p0(i64 648, ptr nonnull %16) #7
  call void @llvm.lifetime.start.p0(i64 648, ptr nonnull %17) #7
  %18 = load i8, ptr @flag_not_empty, align 1, !tbaa !5
  %.not = icmp eq i8 %18, 0
  br i1 %.not, label %.preheader237.preheader, label %.loopexit

.preheader237.preheader:                          ; preds = %10
  store i8 1, ptr @flag_not_empty, align 1, !tbaa !5
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(648) @Q, i8 0, i64 640, i1 false), !tbaa !8
  tail call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 16 dereferenceable(648) @P, ptr noundef nonnull align 16 dereferenceable(648) @ekfAHRS.dv0, i64 648, i1 false), !tbaa !8
  %19 = load double, ptr @ekfAHRS.dv1, align 16, !tbaa !8
  store double %19, ptr @Q, align 16, !tbaa !8
  %20 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 8), align 8, !tbaa !8
  store double %20, ptr getelementptr inbounds (i8, ptr @Q, i64 80), align 16, !tbaa !8
  %21 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 16), align 16, !tbaa !8
  store double %21, ptr getelementptr inbounds (i8, ptr @Q, i64 160), align 16, !tbaa !8
  %22 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 24), align 8, !tbaa !8
  store double %22, ptr getelementptr inbounds (i8, ptr @Q, i64 240), align 16, !tbaa !8
  %23 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 32), align 16, !tbaa !8
  store double %23, ptr getelementptr inbounds (i8, ptr @Q, i64 320), align 16, !tbaa !8
  %24 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 40), align 8, !tbaa !8
  store double %24, ptr getelementptr inbounds (i8, ptr @Q, i64 400), align 16, !tbaa !8
  %25 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 48), align 16, !tbaa !8
  store double %25, ptr getelementptr inbounds (i8, ptr @Q, i64 480), align 16, !tbaa !8
  %26 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 56), align 8, !tbaa !8
  store double %26, ptr getelementptr inbounds (i8, ptr @Q, i64 560), align 16, !tbaa !8
  %27 = load double, ptr getelementptr inbounds (i8, ptr @ekfAHRS.dv1, i64 64), align 16, !tbaa !8
  store double %27, ptr getelementptr inbounds (i8, ptr @Q, i64 640), align 16, !tbaa !8
  %28 = load <2 x i8>, ptr @ekfAHRS.iv0, align 16, !tbaa !5
  %29 = sitofp <2 x i8> %28 to <2 x double>
  store <2 x double> %29, ptr @R, align 16, !tbaa !8
  %30 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 2), align 2, !tbaa !5
  %31 = sitofp <2 x i8> %30 to <2 x double>
  store <2 x double> %31, ptr getelementptr inbounds (i8, ptr @R, i64 16), align 16, !tbaa !8
  %32 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 4), align 4, !tbaa !5
  %33 = sitofp <2 x i8> %32 to <2 x double>
  store <2 x double> %33, ptr getelementptr inbounds (i8, ptr @R, i64 32), align 16, !tbaa !8
  %34 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 6), align 2, !tbaa !5
  %35 = sitofp <2 x i8> %34 to <2 x double>
  store <2 x double> %35, ptr getelementptr inbounds (i8, ptr @R, i64 48), align 16, !tbaa !8
  %36 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 8), align 8, !tbaa !5
  %37 = sitofp <2 x i8> %36 to <2 x double>
  store <2 x double> %37, ptr getelementptr inbounds (i8, ptr @R, i64 64), align 16, !tbaa !8
  %38 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 10), align 2, !tbaa !5
  %39 = sitofp <2 x i8> %38 to <2 x double>
  store <2 x double> %39, ptr getelementptr inbounds (i8, ptr @R, i64 80), align 16, !tbaa !8
  %40 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 12), align 4, !tbaa !5
  %41 = sitofp <2 x i8> %40 to <2 x double>
  store <2 x double> %41, ptr getelementptr inbounds (i8, ptr @R, i64 96), align 16, !tbaa !8
  %42 = load <2 x i8>, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv0, i64 14), align 2, !tbaa !5
  %43 = sitofp <2 x i8> %42 to <2 x double>
  store <2 x double> %43, ptr getelementptr inbounds (i8, ptr @R, i64 112), align 16, !tbaa !8
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader237.preheader, %10
  %44 = load double, ptr @lpfGyrCoeff, align 8, !tbaa !8
  %45 = load double, ptr @p, align 8, !tbaa !8
  %46 = fsub double 1.000000e+00, %44
  %47 = load double, ptr %1, align 8, !tbaa !8
  %48 = fmul double %46, %47
  %49 = tail call double @llvm.fmuladd.f64(double %44, double %45, double %48)
  store double %49, ptr @p, align 8, !tbaa !8
  %50 = load double, ptr @q, align 8, !tbaa !8
  %51 = getelementptr inbounds i8, ptr %1, i64 8
  %52 = load double, ptr %51, align 8, !tbaa !8
  %53 = fmul double %46, %52
  %54 = tail call double @llvm.fmuladd.f64(double %44, double %50, double %53)
  store double %54, ptr @q, align 8, !tbaa !8
  %55 = load double, ptr @r, align 8, !tbaa !8
  %56 = getelementptr inbounds i8, ptr %1, i64 16
  %57 = load double, ptr %56, align 8, !tbaa !8
  %58 = fmul double %46, %57
  %59 = tail call double @llvm.fmuladd.f64(double %44, double %55, double %58)
  store double %59, ptr @r, align 8, !tbaa !8
  %60 = load double, ptr @lpfAccCoeff, align 8, !tbaa !8
  %61 = load double, ptr @ax, align 8, !tbaa !8
  %62 = fsub double 1.000000e+00, %60
  %63 = load double, ptr %0, align 8, !tbaa !8
  %64 = fmul double %62, %63
  %65 = tail call double @llvm.fmuladd.f64(double %60, double %61, double %64)
  store double %65, ptr @ax, align 8, !tbaa !8
  %66 = load double, ptr @ay, align 8, !tbaa !8
  %67 = getelementptr inbounds i8, ptr %0, i64 8
  %68 = load double, ptr %67, align 8, !tbaa !8
  %69 = fmul double %62, %68
  %70 = tail call double @llvm.fmuladd.f64(double %60, double %66, double %69)
  store double %70, ptr @ay, align 8, !tbaa !8
  %71 = load double, ptr @az, align 8, !tbaa !8
  %72 = getelementptr inbounds i8, ptr %0, i64 16
  %73 = load double, ptr %72, align 8, !tbaa !8
  %74 = fmul double %62, %73
  %75 = tail call double @llvm.fmuladd.f64(double %60, double %71, double %74)
  store double %75, ptr @az, align 8, !tbaa !8
  %76 = load double, ptr @lpfVaCoeff, align 8, !tbaa !8
  %77 = load double, ptr @V, align 8, !tbaa !8
  %78 = fsub double 1.000000e+00, %76
  %79 = fmul double %78, %3
  %80 = tail call double @llvm.fmuladd.f64(double %76, double %77, double %79)
  store double %80, ptr @V, align 8, !tbaa !8
  %81 = fdiv double %4, 1.013250e+05
  %82 = tail call double @log(double noundef %81) #7
  %83 = fmul double %82, -8.576600e+03
  store double %83, ptr %9, align 8, !tbaa !8
  %84 = getelementptr inbounds i8, ptr %11, i64 72
  %85 = getelementptr inbounds i8, ptr %11, i64 144
  %86 = getelementptr inbounds i8, ptr %11, i64 216
  %87 = getelementptr inbounds i8, ptr %11, i64 288
  %88 = getelementptr inbounds i8, ptr %11, i64 360
  %89 = getelementptr inbounds i8, ptr %11, i64 432
  %90 = getelementptr inbounds i8, ptr %11, i64 504
  %91 = getelementptr inbounds i8, ptr %11, i64 576
  %92 = getelementptr inbounds i8, ptr %11, i64 80
  %93 = getelementptr inbounds i8, ptr %11, i64 296
  %94 = getelementptr inbounds i8, ptr %11, i64 368
  %95 = getelementptr inbounds i8, ptr %11, i64 16
  %96 = getelementptr inbounds i8, ptr %11, i64 88
  %97 = getelementptr inbounds i8, ptr %11, i64 160
  %98 = getelementptr inbounds i8, ptr %11, i64 232
  %99 = getelementptr inbounds i8, ptr %11, i64 304
  %100 = getelementptr inbounds i8, ptr %11, i64 376
  %101 = getelementptr inbounds i8, ptr %11, i64 448
  %102 = getelementptr inbounds i8, ptr %11, i64 520
  %103 = getelementptr inbounds i8, ptr %11, i64 592
  %104 = fdiv double %5, 1.000000e+01
  %105 = getelementptr inbounds i8, ptr %11, i64 24
  %106 = getelementptr inbounds i8, ptr %11, i64 96
  %107 = getelementptr inbounds i8, ptr %11, i64 168
  %108 = getelementptr inbounds i8, ptr %11, i64 240
  %109 = getelementptr inbounds i8, ptr %11, i64 312
  %110 = getelementptr inbounds i8, ptr %11, i64 384
  %111 = getelementptr inbounds i8, ptr %11, i64 456
  %112 = getelementptr inbounds i8, ptr %11, i64 528
  %113 = getelementptr inbounds i8, ptr %11, i64 600
  %114 = insertelement <2 x double> poison, double %104, i64 0
  %115 = shufflevector <2 x double> %114, <2 x double> poison, <2 x i32> zeroinitializer
  br label %.preheader233.preheader

.preheader233.preheader:                          ; preds = %.loopexit, %507
  %.0221249 = phi i32 [ 0, %.loopexit ], [ %508, %507 ]
  %116 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %117 = tail call double @tan(double noundef %116) #7
  %118 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %119 = tail call double @tan(double noundef %118) #7
  %120 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %121 = tail call double @cos(double noundef %120) #7
  %122 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %123 = tail call double @cos(double noundef %122) #7
  %124 = load double, ptr @xhat, align 16, !tbaa !8
  %125 = tail call double @sin(double noundef %124) #7
  %126 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %127 = tail call double @tan(double noundef %126) #7
  %128 = fmul double %125, %127
  %129 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8
  %130 = load double, ptr @r, align 8, !tbaa !8
  %131 = load double, ptr @xhat, align 16, !tbaa !8
  %132 = tail call double @cos(double noundef %131) #7
  %133 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %134 = tail call double @tan(double noundef %133) #7
  %135 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16
  %136 = load double, ptr @q, align 8, !tbaa !8
  %137 = fneg double %132
  %138 = fmul double %134, %137
  %139 = load double, ptr @xhat, align 16, !tbaa !8
  %140 = tail call double @cos(double noundef %139) #7
  %141 = fneg double %140
  %142 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %143 = load double, ptr @r, align 8, !tbaa !8
  %144 = fsub double %142, %143
  %145 = fmul double %144, %141
  %146 = tail call double @llvm.fmuladd.f64(double %117, double %117, double 1.000000e+00)
  %147 = load double, ptr @xhat, align 16, !tbaa !8
  %148 = tail call double @sin(double noundef %147) #7
  %149 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %150 = load double, ptr @q, align 8, !tbaa !8
  %151 = fsub double %149, %150
  %152 = tail call double @llvm.fmuladd.f64(double %119, double %119, double 1.000000e+00)
  %153 = fneg double %148
  %154 = fmul double %151, %153
  %155 = fmul double %152, %154
  %156 = tail call double @llvm.fmuladd.f64(double %145, double %146, double %155)
  store double %156, ptr %84, align 8, !tbaa !8
  %157 = load double, ptr @xhat, align 16, !tbaa !8
  %158 = tail call double @sin(double noundef %157) #7
  %159 = fneg double %158
  %160 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %161 = tail call double @tan(double noundef %160) #7
  %162 = fmul double %161, %159
  store double %162, ptr %87, align 16, !tbaa !8
  %163 = load double, ptr @xhat, align 16, !tbaa !8
  %164 = tail call double @cos(double noundef %163) #7
  %165 = fneg double %164
  %166 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %167 = tail call double @tan(double noundef %166) #7
  %168 = fmul double %167, %165
  store double %168, ptr %88, align 8, !tbaa !8
  %169 = load double, ptr @xhat, align 16, !tbaa !8
  %170 = tail call double @cos(double noundef %169) #7
  %171 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %172 = load double, ptr @r, align 8, !tbaa !8
  %173 = load double, ptr @xhat, align 16, !tbaa !8
  %174 = tail call double @sin(double noundef %173) #7
  %175 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %176 = load double, ptr @q, align 8, !tbaa !8
  %177 = insertelement <2 x double> %129, double %171, i64 1
  %178 = insertelement <2 x double> poison, double %130, i64 0
  %179 = insertelement <2 x double> %178, double %172, i64 1
  %180 = fsub <2 x double> %177, %179
  %181 = insertelement <2 x double> %135, double %175, i64 1
  %182 = insertelement <2 x double> poison, double %136, i64 0
  %183 = insertelement <2 x double> %182, double %176, i64 1
  %184 = fsub <2 x double> %181, %183
  %185 = insertelement <2 x double> poison, double %138, i64 0
  %186 = insertelement <2 x double> %185, double %174, i64 1
  %187 = fmul <2 x double> %186, %184
  %188 = insertelement <2 x double> poison, double %128, i64 0
  %189 = insertelement <2 x double> %188, double %170, i64 1
  %190 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %189, <2 x double> %180, <2 x double> %187)
  store <2 x double> %190, ptr %11, align 16, !tbaa !8
  store double 0.000000e+00, ptr %92, align 16, !tbaa !8
  store <2 x double> zeroinitializer, ptr %85, align 16, !tbaa !8
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %86, align 8, !tbaa !8
  %191 = load double, ptr @xhat, align 16, !tbaa !8
  %192 = tail call double @cos(double noundef %191) #7
  %193 = fneg double %192
  store double %193, ptr %93, align 8, !tbaa !8
  %194 = load double, ptr @xhat, align 16, !tbaa !8
  %195 = tail call double @sin(double noundef %194) #7
  store double %195, ptr %94, align 16, !tbaa !8
  store <2 x double> zeroinitializer, ptr %89, align 16, !tbaa !8
  store <2 x double> zeroinitializer, ptr %90, align 8, !tbaa !8
  store <2 x double> zeroinitializer, ptr %91, align 16, !tbaa !8
  %196 = load double, ptr @xhat, align 16, !tbaa !8
  %197 = tail call double @sin(double noundef %196) #7
  %198 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %199 = load double, ptr @r, align 8, !tbaa !8
  %200 = fsub double %198, %199
  %201 = fmul double %197, %200
  %202 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %203 = tail call double @cos(double noundef %202) #7
  %204 = fdiv double %201, %203
  %205 = load double, ptr @xhat, align 16, !tbaa !8
  %206 = tail call double @cos(double noundef %205) #7
  %207 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %208 = load double, ptr @q, align 8, !tbaa !8
  %209 = fsub double %207, %208
  %210 = fmul double %206, %209
  %211 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %212 = tail call double @cos(double noundef %211) #7
  %213 = fdiv double %210, %212
  %214 = fsub double %204, %213
  store double %214, ptr %95, align 16, !tbaa !8
  %215 = load double, ptr @xhat, align 16, !tbaa !8
  %216 = tail call double @cos(double noundef %215) #7
  %217 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %218 = tail call double @sin(double noundef %217) #7
  %219 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %220 = load double, ptr @r, align 8, !tbaa !8
  %221 = fsub double %219, %220
  %222 = fneg double %216
  %223 = fmul double %218, %222
  %224 = fmul double %223, %221
  %225 = fmul double %121, %121
  %226 = fdiv double %224, %225
  %227 = load double, ptr @xhat, align 16, !tbaa !8
  %228 = tail call double @sin(double noundef %227) #7
  %229 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %230 = tail call double @sin(double noundef %229) #7
  %231 = fmul double %228, %230
  %232 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %233 = load double, ptr @q, align 8, !tbaa !8
  %234 = fsub double %232, %233
  %235 = fmul double %231, %234
  %236 = fmul double %123, %123
  %237 = fdiv double %235, %236
  %238 = fsub double %226, %237
  store double %238, ptr %96, align 8, !tbaa !8
  store double 0.000000e+00, ptr %97, align 16, !tbaa !8
  store double 0.000000e+00, ptr %98, align 8, !tbaa !8
  %239 = load double, ptr @xhat, align 16, !tbaa !8
  %240 = tail call double @sin(double noundef %239) #7
  %241 = fneg double %240
  %242 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %243 = tail call double @cos(double noundef %242) #7
  %244 = fdiv double %241, %243
  store double %244, ptr %99, align 16, !tbaa !8
  %245 = load double, ptr @xhat, align 16, !tbaa !8
  %246 = tail call double @cos(double noundef %245) #7
  %247 = fneg double %246
  %248 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %249 = tail call double @cos(double noundef %248) #7
  %250 = fdiv double %247, %249
  store double %250, ptr %100, align 8, !tbaa !8
  store double 0.000000e+00, ptr %101, align 16, !tbaa !8
  store double 0.000000e+00, ptr %102, align 8, !tbaa !8
  store double 0.000000e+00, ptr %103, align 16, !tbaa !8
  %251 = load double, ptr @p, align 8, !tbaa !8
  %252 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 24), align 8, !tbaa !8
  %253 = fsub double %251, %252
  %254 = load double, ptr @xhat, align 16, !tbaa !8
  %255 = tail call double @cos(double noundef %254) #7
  %256 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %257 = tail call double @tan(double noundef %256) #7
  %258 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %259 = load double, ptr @r, align 8, !tbaa !8
  %260 = fsub double %258, %259
  %261 = fneg double %255
  %262 = fmul double %257, %261
  %263 = tail call double @llvm.fmuladd.f64(double %262, double %260, double %253)
  %264 = load double, ptr @xhat, align 16, !tbaa !8
  %265 = tail call double @sin(double noundef %264) #7
  %266 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %267 = tail call double @tan(double noundef %266) #7
  %268 = load double, ptr @q, align 8, !tbaa !8
  %269 = fneg double %265
  %270 = fmul double %267, %269
  %271 = load double, ptr @xhat, align 16, !tbaa !8
  %272 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16
  %273 = tail call double @sin(double noundef %271) #7
  %274 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %275 = load double, ptr @r, align 8, !tbaa !8
  %276 = insertelement <2 x double> %272, double %274, i64 1
  %277 = insertelement <2 x double> poison, double %268, i64 0
  %278 = insertelement <2 x double> %277, double %275, i64 1
  %279 = fsub <2 x double> %276, %278
  %280 = load double, ptr @xhat, align 16, !tbaa !8
  %281 = tail call double @cos(double noundef %280) #7
  %282 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %283 = load double, ptr @q, align 8, !tbaa !8
  %284 = fsub double %282, %283
  %285 = fneg double %281
  %286 = fmul double %284, %285
  %287 = insertelement <2 x double> poison, double %270, i64 0
  %288 = insertelement <2 x double> %287, double %273, i64 1
  %289 = insertelement <2 x double> poison, double %263, i64 0
  %290 = insertelement <2 x double> %289, double %286, i64 1
  %291 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %288, <2 x double> %279, <2 x double> %290)
  %292 = load double, ptr @xhat, align 16, !tbaa !8
  %293 = tail call double @sin(double noundef %292) #7
  %294 = load double, ptr @q, align 8, !tbaa !8
  %295 = fneg double %293
  %296 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %297 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16
  %298 = tail call double @cos(double noundef %296) #7
  %299 = load double, ptr @xhat, align 16, !tbaa !8
  %300 = tail call double @cos(double noundef %299) #7
  %301 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %302 = load double, ptr @r, align 8, !tbaa !8
  %303 = insertelement <2 x double> %297, double %301, i64 1
  %304 = insertelement <2 x double> poison, double %294, i64 0
  %305 = insertelement <2 x double> %304, double %302, i64 1
  %306 = fsub <2 x double> %303, %305
  %307 = insertelement <2 x double> poison, double %295, i64 0
  %308 = insertelement <2 x double> %307, double %300, i64 1
  %309 = fmul <2 x double> %306, %308
  %310 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %311 = tail call double @cos(double noundef %310) #7
  %312 = insertelement <2 x double> poison, double %298, i64 0
  %313 = insertelement <2 x double> %312, double %311, i64 1
  %314 = fdiv <2 x double> %309, %313
  %shift = shufflevector <2 x double> %314, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %315 = fsub <2 x double> %314, %shift
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %105, i8 0, i64 48, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(48) %106, i8 0, i64 48, i1 false)
  %316 = load <2 x double>, ptr @xhat, align 16, !tbaa !8
  %317 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %291, <2 x double> %316)
  store <2 x double> %317, ptr @xhat, align 16, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %107, i8 0, i64 48, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(48) %108, i8 0, i64 48, i1 false)
  %318 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  %319 = insertelement <2 x double> %315, double 0.000000e+00, i64 1
  %320 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %319, <2 x double> %318)
  store <2 x double> %320, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %109, i8 0, i64 48, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(48) %110, i8 0, i64 48, i1 false)
  %321 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %322 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> zeroinitializer, <2 x double> %321)
  store <2 x double> %322, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %111, i8 0, i64 48, i1 false)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(48) %112, i8 0, i64 48, i1 false)
  %323 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 48), align 16, !tbaa !8
  %324 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> zeroinitializer, <2 x double> %323)
  store <2 x double> %324, ptr getelementptr inbounds (i8, ptr @xhat, i64 48), align 16, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(48) %113, i8 0, i64 48, i1 false)
  %325 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 64), align 16, !tbaa !8
  %326 = tail call double @llvm.fmuladd.f64(double %104, double 0.000000e+00, double %325)
  store double %326, ptr getelementptr inbounds (i8, ptr @xhat, i64 64), align 16, !tbaa !8
  br label %.preheader233

.preheader233:                                    ; preds = %.preheader233.preheader, %446
  %indvars.iv290 = phi i64 [ 0, %.preheader233.preheader ], [ %indvars.iv.next291, %446 ]
  %327 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %indvars.iv290
  %328 = load double, ptr %327, align 8, !tbaa !8
  %329 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %indvars.iv290
  %330 = load double, ptr %329, align 8, !tbaa !8
  %331 = add nuw nsw i64 %indvars.iv290, 9
  %332 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %331
  %333 = load double, ptr %332, align 8, !tbaa !8
  %334 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %331
  %335 = load double, ptr %334, align 8, !tbaa !8
  %336 = add nuw nsw i64 %indvars.iv290, 18
  %337 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %336
  %338 = load double, ptr %337, align 8, !tbaa !8
  %339 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %336
  %340 = load double, ptr %339, align 8, !tbaa !8
  %341 = add nuw nsw i64 %indvars.iv290, 27
  %342 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %341
  %343 = load double, ptr %342, align 8, !tbaa !8
  %344 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %341
  %345 = load double, ptr %344, align 8, !tbaa !8
  %346 = add nuw nsw i64 %indvars.iv290, 36
  %347 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %346
  %348 = load double, ptr %347, align 8, !tbaa !8
  %349 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %346
  %350 = load double, ptr %349, align 8, !tbaa !8
  %351 = add nuw nsw i64 %indvars.iv290, 45
  %352 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %351
  %353 = load double, ptr %352, align 8, !tbaa !8
  %354 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %351
  %355 = load double, ptr %354, align 8, !tbaa !8
  %356 = add nuw nsw i64 %indvars.iv290, 54
  %357 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %356
  %358 = load double, ptr %357, align 8, !tbaa !8
  %359 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %356
  %360 = load double, ptr %359, align 8, !tbaa !8
  %361 = add nuw nsw i64 %indvars.iv290, 63
  %362 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %361
  %363 = load double, ptr %362, align 8, !tbaa !8
  %364 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %361
  %365 = load double, ptr %364, align 8, !tbaa !8
  %366 = add nuw nsw i64 %indvars.iv290, 72
  %367 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %366
  %368 = load double, ptr %367, align 8, !tbaa !8
  %369 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %366
  %370 = load double, ptr %369, align 8, !tbaa !8
  br label %371

371:                                              ; preds = %.preheader233, %371
  %indvars.iv = phi i64 [ 0, %.preheader233 ], [ %indvars.iv.next, %371 ]
  %372 = mul nuw nsw i64 %indvars.iv, 9
  %373 = add nuw nsw i64 %372, %indvars.iv290
  %374 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %373
  %375 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %373
  %376 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %372
  %377 = load double, ptr %376, align 8, !tbaa !8
  %378 = tail call double @llvm.fmuladd.f64(double %328, double %377, double 0.000000e+00)
  %379 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %indvars.iv
  %380 = load double, ptr %379, align 8, !tbaa !8
  %381 = tail call double @llvm.fmuladd.f64(double %330, double %380, double 0.000000e+00)
  %382 = add nuw nsw i64 %372, 1
  %383 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %382
  %384 = load double, ptr %383, align 8, !tbaa !8
  %385 = tail call double @llvm.fmuladd.f64(double %333, double %384, double %378)
  %386 = add nuw nsw i64 %indvars.iv, 9
  %387 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %386
  %388 = load double, ptr %387, align 8, !tbaa !8
  %389 = tail call double @llvm.fmuladd.f64(double %335, double %388, double %381)
  %390 = add nuw nsw i64 %372, 2
  %391 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %390
  %392 = load double, ptr %391, align 8, !tbaa !8
  %393 = tail call double @llvm.fmuladd.f64(double %338, double %392, double %385)
  %394 = add nuw nsw i64 %indvars.iv, 18
  %395 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %394
  %396 = load double, ptr %395, align 8, !tbaa !8
  %397 = tail call double @llvm.fmuladd.f64(double %340, double %396, double %389)
  %398 = add nuw nsw i64 %372, 3
  %399 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %398
  %400 = load double, ptr %399, align 8, !tbaa !8
  %401 = tail call double @llvm.fmuladd.f64(double %343, double %400, double %393)
  %402 = add nuw nsw i64 %indvars.iv, 27
  %403 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %402
  %404 = load double, ptr %403, align 8, !tbaa !8
  %405 = tail call double @llvm.fmuladd.f64(double %345, double %404, double %397)
  %406 = add nuw nsw i64 %372, 4
  %407 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %406
  %408 = load double, ptr %407, align 8, !tbaa !8
  %409 = tail call double @llvm.fmuladd.f64(double %348, double %408, double %401)
  %410 = add nuw nsw i64 %indvars.iv, 36
  %411 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %410
  %412 = load double, ptr %411, align 8, !tbaa !8
  %413 = tail call double @llvm.fmuladd.f64(double %350, double %412, double %405)
  %414 = add nuw nsw i64 %372, 5
  %415 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %414
  %416 = load double, ptr %415, align 8, !tbaa !8
  %417 = tail call double @llvm.fmuladd.f64(double %353, double %416, double %409)
  %418 = add nuw nsw i64 %indvars.iv, 45
  %419 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %418
  %420 = load double, ptr %419, align 8, !tbaa !8
  %421 = tail call double @llvm.fmuladd.f64(double %355, double %420, double %413)
  %422 = add nuw nsw i64 %372, 6
  %423 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %422
  %424 = load double, ptr %423, align 8, !tbaa !8
  %425 = tail call double @llvm.fmuladd.f64(double %358, double %424, double %417)
  %426 = add nuw nsw i64 %indvars.iv, 54
  %427 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %426
  %428 = load double, ptr %427, align 8, !tbaa !8
  %429 = tail call double @llvm.fmuladd.f64(double %360, double %428, double %421)
  %430 = add nuw nsw i64 %372, 7
  %431 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %430
  %432 = load double, ptr %431, align 8, !tbaa !8
  %433 = tail call double @llvm.fmuladd.f64(double %363, double %432, double %425)
  %434 = add nuw nsw i64 %indvars.iv, 63
  %435 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %434
  %436 = load double, ptr %435, align 8, !tbaa !8
  %437 = tail call double @llvm.fmuladd.f64(double %365, double %436, double %429)
  %438 = add nuw nsw i64 %372, 8
  %439 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %438
  %440 = load double, ptr %439, align 8, !tbaa !8
  %441 = tail call double @llvm.fmuladd.f64(double %368, double %440, double %433)
  %442 = add nuw nsw i64 %indvars.iv, 72
  %443 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %442
  %444 = load double, ptr %443, align 8, !tbaa !8
  %445 = tail call double @llvm.fmuladd.f64(double %370, double %444, double %437)
  store double %441, ptr %374, align 8, !tbaa !8
  store double %445, ptr %375, align 8, !tbaa !8
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, 9
  br i1 %exitcond.not, label %446, label %371, !llvm.loop !10

446:                                              ; preds = %371
  %indvars.iv.next291 = add nuw nsw i64 %indvars.iv290, 1
  %exitcond293.not = icmp eq i64 %indvars.iv.next291, 9
  br i1 %exitcond293.not, label %.preheader232, label %.preheader233, !llvm.loop !12

.preheader232:                                    ; preds = %446, %.preheader232
  %indvars.iv298 = phi i64 [ %indvars.iv.next299, %.preheader232 ], [ 0, %446 ]
  %447 = mul nuw nsw i64 %indvars.iv298, 9
  %448 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %447
  %449 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %447
  %450 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %447
  %451 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %447
  %452 = load <2 x double>, ptr %448, align 8, !tbaa !8
  %453 = load <2 x double>, ptr %449, align 8, !tbaa !8
  %454 = fadd <2 x double> %452, %453
  %455 = load <2 x double>, ptr %450, align 8, !tbaa !8
  %456 = fadd <2 x double> %454, %455
  %457 = load <2 x double>, ptr %451, align 8, !tbaa !8
  %458 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %456, <2 x double> %457)
  store <2 x double> %458, ptr %451, align 8, !tbaa !8
  %459 = add nuw nsw i64 %447, 2
  %460 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %459
  %461 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %459
  %462 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %459
  %463 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %459
  %464 = load <2 x double>, ptr %460, align 8, !tbaa !8
  %465 = load <2 x double>, ptr %461, align 8, !tbaa !8
  %466 = fadd <2 x double> %464, %465
  %467 = load <2 x double>, ptr %462, align 8, !tbaa !8
  %468 = fadd <2 x double> %466, %467
  %469 = load <2 x double>, ptr %463, align 8, !tbaa !8
  %470 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %468, <2 x double> %469)
  store <2 x double> %470, ptr %463, align 8, !tbaa !8
  %471 = add nuw nsw i64 %447, 4
  %472 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %471
  %473 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %471
  %474 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %471
  %475 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %471
  %476 = load <2 x double>, ptr %472, align 8, !tbaa !8
  %477 = load <2 x double>, ptr %473, align 8, !tbaa !8
  %478 = fadd <2 x double> %476, %477
  %479 = load <2 x double>, ptr %474, align 8, !tbaa !8
  %480 = fadd <2 x double> %478, %479
  %481 = load <2 x double>, ptr %475, align 8, !tbaa !8
  %482 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %480, <2 x double> %481)
  store <2 x double> %482, ptr %475, align 8, !tbaa !8
  %483 = add nuw nsw i64 %447, 6
  %484 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %483
  %485 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %483
  %486 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %483
  %487 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %483
  %488 = load <2 x double>, ptr %484, align 8, !tbaa !8
  %489 = load <2 x double>, ptr %485, align 8, !tbaa !8
  %490 = fadd <2 x double> %488, %489
  %491 = load <2 x double>, ptr %486, align 8, !tbaa !8
  %492 = fadd <2 x double> %490, %491
  %493 = load <2 x double>, ptr %487, align 8, !tbaa !8
  %494 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %115, <2 x double> %492, <2 x double> %493)
  store <2 x double> %494, ptr %487, align 8, !tbaa !8
  %495 = add nuw nsw i64 %447, 8
  %496 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %495
  %497 = load double, ptr %496, align 8, !tbaa !8
  %498 = getelementptr inbounds [81 x double], ptr %17, i64 0, i64 %495
  %499 = load double, ptr %498, align 8, !tbaa !8
  %500 = fadd double %497, %499
  %501 = getelementptr inbounds [81 x double], ptr @Q, i64 0, i64 %495
  %502 = load double, ptr %501, align 8, !tbaa !8
  %503 = fadd double %500, %502
  %504 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %495
  %505 = load double, ptr %504, align 8, !tbaa !8
  %506 = tail call double @llvm.fmuladd.f64(double %104, double %503, double %505)
  store double %506, ptr %504, align 8, !tbaa !8
  %indvars.iv.next299 = add nuw nsw i64 %indvars.iv298, 1
  %exitcond301.not = icmp eq i64 %indvars.iv.next299, 9
  br i1 %exitcond301.not, label %507, label %.preheader232, !llvm.loop !13

507:                                              ; preds = %.preheader232
  %508 = add nuw nsw i32 %.0221249, 1
  %exitcond302.not = icmp eq i32 %508, 10
  br i1 %exitcond302.not, label %.preheader230.preheader, label %.preheader233.preheader, !llvm.loop !14

.preheader230.preheader:                          ; preds = %507
  %509 = getelementptr inbounds i8, ptr %11, i64 320
  %510 = getelementptr inbounds i8, ptr %11, i64 400
  %511 = getelementptr inbounds i8, ptr %11, i64 480
  %512 = getelementptr inbounds i8, ptr %11, i64 560
  %513 = getelementptr inbounds i8, ptr %11, i64 640
  %514 = load double, ptr @xhat, align 16, !tbaa !8
  %515 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %516 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  %517 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 24), align 8, !tbaa !8
  %518 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %519 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %520 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 48), align 16, !tbaa !8
  %521 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 56), align 8, !tbaa !8
  %522 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 64), align 16, !tbaa !8
  store double 0.000000e+00, ptr %12, align 16, !tbaa !8
  %523 = load double, ptr @g, align 8, !tbaa !8
  %524 = tail call double @cos(double noundef %515) #7
  %525 = load double, ptr @V, align 8, !tbaa !8
  %526 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %527 = tail call double @cos(double noundef %526) #7
  %528 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %529 = load double, ptr @q, align 8, !tbaa !8
  %530 = fsub double %528, %529
  %531 = fneg double %525
  %532 = fmul double %527, %531
  %533 = fmul double %532, %530
  %534 = getelementptr inbounds i8, ptr %12, i64 32
  %535 = getelementptr inbounds i8, ptr %12, i64 64
  %536 = getelementptr inbounds i8, ptr %12, i64 96
  store double 0.000000e+00, ptr %536, align 16, !tbaa !8
  %537 = load double, ptr @V, align 8, !tbaa !8
  %538 = fneg double %537
  %539 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %540 = tail call double @sin(double noundef %539) #7
  %541 = fmul double %540, %538
  %542 = getelementptr inbounds i8, ptr %12, i64 128
  store double %541, ptr %542, align 16, !tbaa !8
  %543 = getelementptr inbounds i8, ptr %12, i64 160
  store double 0.000000e+00, ptr %543, align 16, !tbaa !8
  %544 = getelementptr inbounds i8, ptr %12, i64 192
  %545 = getelementptr inbounds i8, ptr %12, i64 224
  %546 = getelementptr inbounds i8, ptr %12, i64 256
  %547 = load double, ptr @g, align 8, !tbaa !8
  %548 = fneg double %547
  %549 = load double, ptr @xhat, align 16, !tbaa !8
  %550 = tail call double @cos(double noundef %549) #7
  %551 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %552 = tail call double @cos(double noundef %551) #7
  %553 = getelementptr inbounds i8, ptr %12, i64 8
  %554 = load double, ptr @V, align 8, !tbaa !8
  %555 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %556 = tail call double @cos(double noundef %555) #7
  %557 = fmul double %554, %556
  %558 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 24), align 8, !tbaa !8
  %559 = load double, ptr @p, align 8, !tbaa !8
  %560 = fsub double %558, %559
  %561 = load double, ptr @V, align 8, !tbaa !8
  %562 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %563 = tail call double @sin(double noundef %562) #7
  %564 = fmul double %561, %563
  %565 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 40), align 8, !tbaa !8
  %566 = load double, ptr @r, align 8, !tbaa !8
  %567 = fsub double %565, %566
  %568 = fmul double %564, %567
  %569 = tail call double @llvm.fmuladd.f64(double %557, double %560, double %568)
  %570 = load double, ptr @g, align 8, !tbaa !8
  %571 = load double, ptr @xhat, align 16, !tbaa !8
  %572 = tail call double @sin(double noundef %571) #7
  %573 = fmul double %570, %572
  %574 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %575 = tail call double @sin(double noundef %574) #7
  %576 = getelementptr inbounds i8, ptr %12, i64 40
  %577 = insertelement <2 x double> poison, double %523, i64 0
  %578 = insertelement <2 x double> %577, double %573, i64 1
  %579 = insertelement <2 x double> poison, double %524, i64 0
  %580 = insertelement <2 x double> %579, double %575, i64 1
  %581 = insertelement <2 x double> poison, double %533, i64 0
  %582 = insertelement <2 x double> %581, double %569, i64 1
  %583 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %578, <2 x double> %580, <2 x double> %582)
  store <2 x double> %583, ptr %534, align 16, !tbaa !8
  %584 = getelementptr inbounds i8, ptr %12, i64 72
  store <2 x double> zeroinitializer, ptr %535, align 16, !tbaa !8
  %585 = load double, ptr @V, align 8, !tbaa !8
  %586 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %587 = tail call double @sin(double noundef %586) #7
  %588 = fmul double %585, %587
  %589 = getelementptr inbounds i8, ptr %12, i64 104
  store double %588, ptr %589, align 8, !tbaa !8
  %590 = getelementptr inbounds i8, ptr %12, i64 136
  store double 0.000000e+00, ptr %590, align 8, !tbaa !8
  %591 = load double, ptr @V, align 8, !tbaa !8
  %592 = fneg double %591
  %593 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %594 = tail call double @cos(double noundef %593) #7
  %595 = fmul double %594, %592
  %596 = getelementptr inbounds i8, ptr %12, i64 168
  store double %595, ptr %596, align 8, !tbaa !8
  %597 = getelementptr inbounds i8, ptr %12, i64 200
  store <2 x double> <double -1.000000e+00, double 0.000000e+00>, ptr %544, align 16, !tbaa !8
  %598 = getelementptr inbounds i8, ptr %12, i64 232
  store <2 x double> <double 0.000000e+00, double -1.000000e+00>, ptr %545, align 16, !tbaa !8
  %599 = getelementptr inbounds i8, ptr %12, i64 264
  store <2 x double> zeroinitializer, ptr %546, align 16, !tbaa !8
  %600 = load double, ptr @g, align 8, !tbaa !8
  %601 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %602 = tail call double @cos(double noundef %601) #7
  %603 = load double, ptr @xhat, align 16, !tbaa !8
  %604 = tail call double @sin(double noundef %603) #7
  %605 = getelementptr inbounds i8, ptr %12, i64 16
  %606 = insertelement <2 x double> poison, double %550, i64 0
  %607 = insertelement <2 x double> %606, double %600, i64 1
  %608 = insertelement <2 x double> poison, double %548, i64 0
  %609 = insertelement <2 x double> %608, double %602, i64 1
  %610 = fmul <2 x double> %607, %609
  %611 = insertelement <2 x double> poison, double %552, i64 0
  %612 = insertelement <2 x double> %611, double %604, i64 1
  %613 = fmul <2 x double> %610, %612
  store <2 x double> %613, ptr %553, align 8, !tbaa !8
  %614 = load double, ptr @g, align 8, !tbaa !8
  %615 = load double, ptr @xhat, align 16, !tbaa !8
  %616 = tail call double @cos(double noundef %615) #7
  %617 = fmul double %614, %616
  %618 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %619 = tail call double @sin(double noundef %618) #7
  %620 = load double, ptr @V, align 8, !tbaa !8
  %621 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %622 = tail call double @sin(double noundef %621) #7
  %623 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %624 = load double, ptr @q, align 8, !tbaa !8
  %625 = fsub double %623, %624
  %626 = fneg double %620
  %627 = fmul double %622, %626
  %628 = fmul double %627, %625
  %629 = tail call double @llvm.fmuladd.f64(double %617, double %619, double %628)
  %630 = getelementptr inbounds i8, ptr %12, i64 48
  store double %629, ptr %630, align 16, !tbaa !8
  %631 = getelementptr inbounds i8, ptr %12, i64 80
  store double 0.000000e+00, ptr %631, align 16, !tbaa !8
  %632 = getelementptr inbounds i8, ptr %12, i64 112
  store double 0.000000e+00, ptr %632, align 16, !tbaa !8
  %633 = load double, ptr @V, align 8, !tbaa !8
  %634 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %635 = tail call double @cos(double noundef %634) #7
  %636 = fmul double %633, %635
  %637 = getelementptr inbounds i8, ptr %12, i64 144
  store double %636, ptr %637, align 16, !tbaa !8
  %638 = getelementptr inbounds i8, ptr %12, i64 176
  store double 0.000000e+00, ptr %638, align 16, !tbaa !8
  %639 = getelementptr inbounds i8, ptr %12, i64 208
  store double 0.000000e+00, ptr %639, align 16, !tbaa !8
  %640 = getelementptr inbounds i8, ptr %12, i64 240
  store double 0.000000e+00, ptr %640, align 16, !tbaa !8
  %641 = getelementptr inbounds i8, ptr %12, i64 272
  store double -1.000000e+00, ptr %641, align 16, !tbaa !8
  %642 = load i8, ptr @ekfAHRS.iv1, align 1, !tbaa !5
  %643 = sitofp i8 %642 to double
  %644 = getelementptr inbounds i8, ptr %12, i64 24
  store double %643, ptr %644, align 8, !tbaa !8
  %645 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 1), align 1, !tbaa !5
  %646 = sitofp i8 %645 to double
  %647 = getelementptr inbounds i8, ptr %12, i64 56
  store double %646, ptr %647, align 8, !tbaa !8
  %648 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 2), align 1, !tbaa !5
  %649 = sitofp i8 %648 to double
  %650 = getelementptr inbounds i8, ptr %12, i64 88
  store double %649, ptr %650, align 8, !tbaa !8
  %651 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 3), align 1, !tbaa !5
  %652 = sitofp i8 %651 to double
  %653 = getelementptr inbounds i8, ptr %12, i64 120
  store double %652, ptr %653, align 8, !tbaa !8
  %654 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 4), align 1, !tbaa !5
  %655 = sitofp i8 %654 to double
  %656 = getelementptr inbounds i8, ptr %12, i64 152
  store double %655, ptr %656, align 8, !tbaa !8
  %657 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 5), align 1, !tbaa !5
  %658 = sitofp i8 %657 to double
  %659 = getelementptr inbounds i8, ptr %12, i64 184
  store double %658, ptr %659, align 8, !tbaa !8
  %660 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 6), align 1, !tbaa !5
  %661 = sitofp i8 %660 to double
  %662 = getelementptr inbounds i8, ptr %12, i64 216
  store double %661, ptr %662, align 8, !tbaa !8
  %663 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 7), align 1, !tbaa !5
  %664 = sitofp i8 %663 to double
  %665 = getelementptr inbounds i8, ptr %12, i64 248
  store double %664, ptr %665, align 8, !tbaa !8
  %666 = load i8, ptr getelementptr inbounds (i8, ptr @ekfAHRS.iv1, i64 8), align 1, !tbaa !5
  %667 = sitofp i8 %666 to double
  %668 = getelementptr inbounds i8, ptr %12, i64 280
  store double %667, ptr %668, align 8, !tbaa !8
  %.pre = load double, ptr %534, align 16, !tbaa !8
  %.pre428 = load double, ptr %535, align 16, !tbaa !8
  %.pre429 = load double, ptr %536, align 16, !tbaa !8
  %.pre430 = load double, ptr %542, align 16, !tbaa !8
  %.pre431 = load double, ptr %543, align 16, !tbaa !8
  %.pre432 = load double, ptr %544, align 16, !tbaa !8
  %.pre433 = load double, ptr %545, align 16, !tbaa !8
  %.pre434 = load double, ptr %546, align 16, !tbaa !8
  %.pre435 = load double, ptr %553, align 8, !tbaa !8
  %.pre436 = load double, ptr %576, align 8, !tbaa !8
  %.pre437 = load double, ptr %584, align 8, !tbaa !8
  %.pre438 = load double, ptr %589, align 8, !tbaa !8
  %.pre439 = load double, ptr %590, align 8, !tbaa !8
  %.pre440 = load double, ptr %596, align 8, !tbaa !8
  %.pre441 = load double, ptr %597, align 8, !tbaa !8
  %669 = load double, ptr %12, align 16, !tbaa !8
  %670 = extractelement <2 x double> %613, i64 1
  br label %.preheader230

.preheader230:                                    ; preds = %.preheader230.preheader, %.preheader230
  %indvars.iv315 = phi i64 [ 0, %.preheader230.preheader ], [ %indvars.iv.next316, %.preheader230 ]
  %671 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %indvars.iv315
  %672 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %indvars.iv315
  %673 = load double, ptr %671, align 8, !tbaa !8
  %674 = tail call double @llvm.fmuladd.f64(double %673, double %669, double 0.000000e+00)
  %675 = add nuw nsw i64 %indvars.iv315, 9
  %676 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %675
  %677 = load double, ptr %676, align 8, !tbaa !8
  %678 = tail call double @llvm.fmuladd.f64(double %677, double %.pre, double %674)
  %679 = add nuw nsw i64 %indvars.iv315, 18
  %680 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %679
  %681 = load double, ptr %680, align 8, !tbaa !8
  %682 = tail call double @llvm.fmuladd.f64(double %681, double %.pre428, double %678)
  %683 = add nuw nsw i64 %indvars.iv315, 27
  %684 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %683
  %685 = load double, ptr %684, align 8, !tbaa !8
  %686 = tail call double @llvm.fmuladd.f64(double %685, double %.pre429, double %682)
  %687 = add nuw nsw i64 %indvars.iv315, 36
  %688 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %687
  %689 = load double, ptr %688, align 8, !tbaa !8
  %690 = tail call double @llvm.fmuladd.f64(double %689, double %.pre430, double %686)
  %691 = add nuw nsw i64 %indvars.iv315, 45
  %692 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %691
  %693 = load double, ptr %692, align 8, !tbaa !8
  %694 = tail call double @llvm.fmuladd.f64(double %693, double %.pre431, double %690)
  %695 = add nuw nsw i64 %indvars.iv315, 54
  %696 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %695
  %697 = load double, ptr %696, align 8, !tbaa !8
  %698 = tail call double @llvm.fmuladd.f64(double %697, double %.pre432, double %694)
  %699 = add nuw nsw i64 %indvars.iv315, 63
  %700 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %699
  %701 = load double, ptr %700, align 8, !tbaa !8
  %702 = tail call double @llvm.fmuladd.f64(double %701, double %.pre433, double %698)
  %703 = add nuw nsw i64 %indvars.iv315, 72
  %704 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %703
  %705 = load double, ptr %704, align 8, !tbaa !8
  %706 = tail call double @llvm.fmuladd.f64(double %705, double %.pre434, double %702)
  store double %706, ptr %672, align 8, !tbaa !8
  %707 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %675
  %708 = tail call double @llvm.fmuladd.f64(double %673, double %.pre435, double 0.000000e+00)
  %709 = tail call double @llvm.fmuladd.f64(double %677, double %.pre436, double %708)
  %710 = tail call double @llvm.fmuladd.f64(double %681, double %.pre437, double %709)
  %711 = tail call double @llvm.fmuladd.f64(double %685, double %.pre438, double %710)
  %712 = tail call double @llvm.fmuladd.f64(double %689, double %.pre439, double %711)
  %713 = tail call double @llvm.fmuladd.f64(double %693, double %.pre440, double %712)
  %714 = tail call double @llvm.fmuladd.f64(double %697, double %.pre441, double %713)
  %715 = tail call double @llvm.fmuladd.f64(double %701, double -1.000000e+00, double %714)
  %716 = tail call double @llvm.fmuladd.f64(double %705, double 0.000000e+00, double %715)
  store double %716, ptr %707, align 8, !tbaa !8
  %717 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %679
  %718 = tail call double @llvm.fmuladd.f64(double %673, double %670, double 0.000000e+00)
  %719 = tail call double @llvm.fmuladd.f64(double %677, double %629, double %718)
  %720 = tail call double @llvm.fmuladd.f64(double %681, double 0.000000e+00, double %719)
  %721 = tail call double @llvm.fmuladd.f64(double %685, double 0.000000e+00, double %720)
  %722 = tail call double @llvm.fmuladd.f64(double %689, double %636, double %721)
  %723 = tail call double @llvm.fmuladd.f64(double %693, double 0.000000e+00, double %722)
  %724 = tail call double @llvm.fmuladd.f64(double %697, double 0.000000e+00, double %723)
  %725 = tail call double @llvm.fmuladd.f64(double %701, double 0.000000e+00, double %724)
  %726 = tail call double @llvm.fmuladd.f64(double %705, double -1.000000e+00, double %725)
  store double %726, ptr %717, align 8, !tbaa !8
  %727 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %683
  %728 = tail call double @llvm.fmuladd.f64(double %673, double %643, double 0.000000e+00)
  %729 = tail call double @llvm.fmuladd.f64(double %677, double %646, double %728)
  %730 = tail call double @llvm.fmuladd.f64(double %681, double %649, double %729)
  %731 = tail call double @llvm.fmuladd.f64(double %685, double %652, double %730)
  %732 = tail call double @llvm.fmuladd.f64(double %689, double %655, double %731)
  %733 = tail call double @llvm.fmuladd.f64(double %693, double %658, double %732)
  %734 = tail call double @llvm.fmuladd.f64(double %697, double %661, double %733)
  %735 = tail call double @llvm.fmuladd.f64(double %701, double %664, double %734)
  %736 = tail call double @llvm.fmuladd.f64(double %705, double %667, double %735)
  store double %736, ptr %727, align 8, !tbaa !8
  %indvars.iv.next316 = add nuw nsw i64 %indvars.iv315, 1
  %exitcond318.not = icmp eq i64 %indvars.iv.next316, 9
  br i1 %exitcond318.not, label %vector.ph, label %.preheader230, !llvm.loop !15

vector.ph:                                        ; preds = %.preheader230
  %737 = load <2 x double>, ptr %605, align 16
  %738 = load <2 x double>, ptr %599, align 8
  %739 = load <2 x double>, ptr %598, align 8
  %740 = load <2 x double>, ptr %597, align 8
  %741 = load <2 x double>, ptr %596, align 8
  %742 = load <2 x double>, ptr %590, align 8
  %743 = load <2 x double>, ptr %589, align 8
  %744 = load <2 x double>, ptr %584, align 8
  %745 = load <2 x double>, ptr %576, align 8
  %746 = load <2 x double>, ptr %553, align 8
  %747 = load <2 x double>, ptr %546, align 16
  %748 = load <2 x double>, ptr %545, align 16
  %749 = load <2 x double>, ptr %544, align 16
  %750 = load <2 x double>, ptr %543, align 16
  %751 = load <2 x double>, ptr %542, align 16
  %752 = load <2 x double>, ptr %536, align 16
  %753 = load <2 x double>, ptr %535, align 16
  %754 = load <2 x double>, ptr %534, align 16
  %755 = load <2 x double>, ptr %12, align 16
  %756 = load double, ptr getelementptr inbounds (i8, ptr @P, i64 640), align 16, !tbaa !8
  %757 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 632), align 8
  %758 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 624), align 16
  %759 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 616), align 8
  %760 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 608), align 16
  %761 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 600), align 8
  %762 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 592), align 16
  %763 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 584), align 8
  %764 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 576), align 16
  %765 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 568), align 8
  %766 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 560), align 16
  %767 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 552), align 8
  %768 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 544), align 16
  %769 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 536), align 8
  %770 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 528), align 16
  %771 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 520), align 8
  %772 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 512), align 16
  %773 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 504), align 8
  %774 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 496), align 16
  %775 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 488), align 8
  %776 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 480), align 16
  %777 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 472), align 8
  %778 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 464), align 16
  %779 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 456), align 8
  %780 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 448), align 16
  %781 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 440), align 8
  %782 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 432), align 16
  %783 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 424), align 8
  %784 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 416), align 16
  %785 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 408), align 8
  %786 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 400), align 16
  %787 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 392), align 8
  %788 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 384), align 16
  %789 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 376), align 8
  %790 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 368), align 16
  %791 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 360), align 8
  %792 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 352), align 16
  %793 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 344), align 8
  %794 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 336), align 16
  %795 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 328), align 8
  %796 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 320), align 16
  %797 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 312), align 8
  %798 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 304), align 16
  %799 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 296), align 8
  %800 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 288), align 16
  %801 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 280), align 8
  %802 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 272), align 16
  %803 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 264), align 8
  %804 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 256), align 16
  %805 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 248), align 8
  %806 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 240), align 16
  %807 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 232), align 8
  %808 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 224), align 16
  %809 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 216), align 8
  %810 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 208), align 16
  %811 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 200), align 8
  %812 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 192), align 16
  %813 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 184), align 8
  %814 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 176), align 16
  %815 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 168), align 8
  %816 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 160), align 16
  %817 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 152), align 8
  %818 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 144), align 16
  %819 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 136), align 8
  %820 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 128), align 16
  %821 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 120), align 8
  %822 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 112), align 16
  %823 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 104), align 8
  %824 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 96), align 16
  %825 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 88), align 8
  %826 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 80), align 16
  %827 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 72), align 8
  %828 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 64), align 16
  %829 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 56), align 8
  %830 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 48), align 16
  %831 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 40), align 8
  %832 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 32), align 16
  %833 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 24), align 8
  %834 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 16), align 16
  %835 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @P, i64 8), align 8
  %836 = load <2 x double>, ptr @P, align 16
  %broadcast.splat = shufflevector <2 x double> %836, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat450 = shufflevector <2 x double> %835, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat453 = shufflevector <2 x double> %834, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat456 = shufflevector <2 x double> %833, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat459 = shufflevector <2 x double> %832, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat462 = shufflevector <2 x double> %831, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat465 = shufflevector <2 x double> %830, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat468 = shufflevector <2 x double> %829, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat471 = shufflevector <2 x double> %828, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat473 = shufflevector <2 x double> %827, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat475 = shufflevector <2 x double> %826, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat477 = shufflevector <2 x double> %825, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat479 = shufflevector <2 x double> %824, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat481 = shufflevector <2 x double> %823, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat483 = shufflevector <2 x double> %822, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat485 = shufflevector <2 x double> %821, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat487 = shufflevector <2 x double> %820, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat489 = shufflevector <2 x double> %819, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat491 = shufflevector <2 x double> %818, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat493 = shufflevector <2 x double> %817, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat495 = shufflevector <2 x double> %816, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat497 = shufflevector <2 x double> %815, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat499 = shufflevector <2 x double> %814, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat501 = shufflevector <2 x double> %813, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat503 = shufflevector <2 x double> %812, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat505 = shufflevector <2 x double> %811, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat507 = shufflevector <2 x double> %810, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat509 = shufflevector <2 x double> %809, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat511 = shufflevector <2 x double> %808, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat513 = shufflevector <2 x double> %807, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat515 = shufflevector <2 x double> %806, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat517 = shufflevector <2 x double> %805, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat519 = shufflevector <2 x double> %804, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat521 = shufflevector <2 x double> %803, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat523 = shufflevector <2 x double> %802, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat525 = shufflevector <2 x double> %801, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat528 = shufflevector <2 x double> %800, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat531 = shufflevector <2 x double> %799, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat534 = shufflevector <2 x double> %798, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat537 = shufflevector <2 x double> %797, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat540 = shufflevector <2 x double> %796, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat542 = shufflevector <2 x double> %795, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat544 = shufflevector <2 x double> %794, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat546 = shufflevector <2 x double> %793, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat548 = shufflevector <2 x double> %792, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat550 = shufflevector <2 x double> %791, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat552 = shufflevector <2 x double> %790, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat554 = shufflevector <2 x double> %789, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat556 = shufflevector <2 x double> %788, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat558 = shufflevector <2 x double> %787, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat561 = shufflevector <2 x double> %786, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat564 = shufflevector <2 x double> %785, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat567 = shufflevector <2 x double> %784, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat570 = shufflevector <2 x double> %783, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat572 = shufflevector <2 x double> %782, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat574 = shufflevector <2 x double> %781, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat576 = shufflevector <2 x double> %780, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat578 = shufflevector <2 x double> %779, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat580 = shufflevector <2 x double> %778, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat582 = shufflevector <2 x double> %777, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat584 = shufflevector <2 x double> %776, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat586 = shufflevector <2 x double> %775, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat588 = shufflevector <2 x double> %774, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat590 = shufflevector <2 x double> %773, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat592 = shufflevector <2 x double> %772, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat594 = shufflevector <2 x double> %771, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat596 = shufflevector <2 x double> %770, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat598 = shufflevector <2 x double> %769, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat600 = shufflevector <2 x double> %768, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat602 = shufflevector <2 x double> %767, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat604 = shufflevector <2 x double> %766, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat606 = shufflevector <2 x double> %765, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat608 = shufflevector <2 x double> %764, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat610 = shufflevector <2 x double> %763, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat612 = shufflevector <2 x double> %762, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat614 = shufflevector <2 x double> %761, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat616 = shufflevector <2 x double> %760, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat618 = shufflevector <2 x double> %759, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat620 = shufflevector <2 x double> %758, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat622 = shufflevector <2 x double> %757, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert623 = insertelement <2 x double> poison, double %756, i64 0
  %broadcast.splat624 = shufflevector <2 x double> %broadcast.splatinsert623, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat627 = shufflevector <2 x double> %755, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat630 = shufflevector <2 x double> %754, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat633 = shufflevector <2 x double> %753, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat636 = shufflevector <2 x double> %752, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat639 = shufflevector <2 x double> %751, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat642 = shufflevector <2 x double> %750, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat645 = shufflevector <2 x double> %749, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat648 = shufflevector <2 x double> %748, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat651 = shufflevector <2 x double> %747, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat654 = shufflevector <2 x double> %746, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat656 = shufflevector <2 x double> %745, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat658 = shufflevector <2 x double> %744, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat660 = shufflevector <2 x double> %743, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat662 = shufflevector <2 x double> %742, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat664 = shufflevector <2 x double> %741, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat666 = shufflevector <2 x double> %740, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat668 = shufflevector <2 x double> %739, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat670 = shufflevector <2 x double> %738, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splat673 = shufflevector <2 x double> %737, <2 x double> poison, <2 x i32> zeroinitializer
  %837 = load <2 x double>, ptr %630, align 16
  %broadcast.splat675 = shufflevector <2 x double> %837, <2 x double> poison, <2 x i32> zeroinitializer
  %838 = load <2 x double>, ptr %631, align 16
  %broadcast.splat677 = shufflevector <2 x double> %838, <2 x double> poison, <2 x i32> zeroinitializer
  %839 = load <2 x double>, ptr %632, align 16
  %broadcast.splat679 = shufflevector <2 x double> %839, <2 x double> poison, <2 x i32> zeroinitializer
  %840 = load <2 x double>, ptr %637, align 16
  %broadcast.splat681 = shufflevector <2 x double> %840, <2 x double> poison, <2 x i32> zeroinitializer
  %841 = load <2 x double>, ptr %638, align 16
  %broadcast.splat683 = shufflevector <2 x double> %841, <2 x double> poison, <2 x i32> zeroinitializer
  %842 = load <2 x double>, ptr %639, align 16
  %broadcast.splat685 = shufflevector <2 x double> %842, <2 x double> poison, <2 x i32> zeroinitializer
  %843 = load <2 x double>, ptr %640, align 16
  %broadcast.splat687 = shufflevector <2 x double> %843, <2 x double> poison, <2 x i32> zeroinitializer
  %844 = load <2 x double>, ptr %641, align 16
  %broadcast.splat689 = shufflevector <2 x double> %844, <2 x double> poison, <2 x i32> zeroinitializer
  %845 = load <2 x double>, ptr %644, align 8
  %broadcast.splat692 = shufflevector <2 x double> %845, <2 x double> poison, <2 x i32> zeroinitializer
  %846 = load <2 x double>, ptr %647, align 8
  %broadcast.splat694 = shufflevector <2 x double> %846, <2 x double> poison, <2 x i32> zeroinitializer
  %847 = load <2 x double>, ptr %650, align 8
  %broadcast.splat696 = shufflevector <2 x double> %847, <2 x double> poison, <2 x i32> zeroinitializer
  %848 = load <2 x double>, ptr %653, align 8
  %broadcast.splat698 = shufflevector <2 x double> %848, <2 x double> poison, <2 x i32> zeroinitializer
  %849 = load <2 x double>, ptr %656, align 8
  %broadcast.splat700 = shufflevector <2 x double> %849, <2 x double> poison, <2 x i32> zeroinitializer
  %850 = load <2 x double>, ptr %659, align 8
  %broadcast.splat702 = shufflevector <2 x double> %850, <2 x double> poison, <2 x i32> zeroinitializer
  %851 = load <2 x double>, ptr %662, align 8
  %broadcast.splat704 = shufflevector <2 x double> %851, <2 x double> poison, <2 x i32> zeroinitializer
  %852 = load <2 x double>, ptr %665, align 8
  %broadcast.splat706 = shufflevector <2 x double> %852, <2 x double> poison, <2 x i32> zeroinitializer
  %853 = load double, ptr %668, align 8, !tbaa !8
  %broadcast.splatinsert707 = insertelement <2 x double> poison, double %853, i64 0
  %broadcast.splat708 = shufflevector <2 x double> %broadcast.splatinsert707, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %854 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %index
  %855 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %index
  %wide.load = load <2 x double>, ptr %854, align 16, !tbaa !8
  %856 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load, <2 x double> %broadcast.splat, <2 x double> zeroinitializer)
  %857 = add nuw nsw i64 %index, 4
  %858 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %857
  %wide.load448 = load <2 x double>, ptr %858, align 16, !tbaa !8
  %859 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load448, <2 x double> %broadcast.splat450, <2 x double> %856)
  %860 = add nuw nsw i64 %index, 8
  %861 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %860
  %wide.load451 = load <2 x double>, ptr %861, align 16, !tbaa !8
  %862 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load451, <2 x double> %broadcast.splat453, <2 x double> %859)
  %863 = add nuw nsw i64 %index, 12
  %864 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %863
  %wide.load454 = load <2 x double>, ptr %864, align 16, !tbaa !8
  %865 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load454, <2 x double> %broadcast.splat456, <2 x double> %862)
  %866 = add nuw nsw i64 %index, 16
  %867 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %866
  %wide.load457 = load <2 x double>, ptr %867, align 16, !tbaa !8
  %868 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load457, <2 x double> %broadcast.splat459, <2 x double> %865)
  %869 = add nuw nsw i64 %index, 20
  %870 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %869
  %wide.load460 = load <2 x double>, ptr %870, align 16, !tbaa !8
  %871 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load460, <2 x double> %broadcast.splat462, <2 x double> %868)
  %872 = add nuw nsw i64 %index, 24
  %873 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %872
  %wide.load463 = load <2 x double>, ptr %873, align 16, !tbaa !8
  %874 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load463, <2 x double> %broadcast.splat465, <2 x double> %871)
  %875 = add nuw nsw i64 %index, 28
  %876 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %875
  %wide.load466 = load <2 x double>, ptr %876, align 16, !tbaa !8
  %877 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load466, <2 x double> %broadcast.splat468, <2 x double> %874)
  %878 = add nuw nsw i64 %index, 32
  %879 = getelementptr inbounds [36 x double], ptr %12, i64 0, i64 %878
  %wide.load469 = load <2 x double>, ptr %879, align 16, !tbaa !8
  %880 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load469, <2 x double> %broadcast.splat471, <2 x double> %877)
  store <2 x double> %880, ptr %855, align 16, !tbaa !8
  %881 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %857
  %882 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load, <2 x double> %broadcast.splat473, <2 x double> zeroinitializer)
  %883 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load448, <2 x double> %broadcast.splat475, <2 x double> %882)
  %884 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load451, <2 x double> %broadcast.splat477, <2 x double> %883)
  %885 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load454, <2 x double> %broadcast.splat479, <2 x double> %884)
  %886 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load457, <2 x double> %broadcast.splat481, <2 x double> %885)
  %887 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load460, <2 x double> %broadcast.splat483, <2 x double> %886)
  %888 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load463, <2 x double> %broadcast.splat485, <2 x double> %887)
  %889 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load466, <2 x double> %broadcast.splat487, <2 x double> %888)
  %890 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load469, <2 x double> %broadcast.splat489, <2 x double> %889)
  store <2 x double> %890, ptr %881, align 16, !tbaa !8
  %891 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %860
  %892 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load, <2 x double> %broadcast.splat491, <2 x double> zeroinitializer)
  %893 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load448, <2 x double> %broadcast.splat493, <2 x double> %892)
  %894 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load451, <2 x double> %broadcast.splat495, <2 x double> %893)
  %895 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load454, <2 x double> %broadcast.splat497, <2 x double> %894)
  %896 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load457, <2 x double> %broadcast.splat499, <2 x double> %895)
  %897 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load460, <2 x double> %broadcast.splat501, <2 x double> %896)
  %898 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load463, <2 x double> %broadcast.splat503, <2 x double> %897)
  %899 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load466, <2 x double> %broadcast.splat505, <2 x double> %898)
  %900 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load469, <2 x double> %broadcast.splat507, <2 x double> %899)
  store <2 x double> %900, ptr %891, align 16, !tbaa !8
  %901 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %863
  %902 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load, <2 x double> %broadcast.splat509, <2 x double> zeroinitializer)
  %903 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load448, <2 x double> %broadcast.splat511, <2 x double> %902)
  %904 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load451, <2 x double> %broadcast.splat513, <2 x double> %903)
  %905 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load454, <2 x double> %broadcast.splat515, <2 x double> %904)
  %906 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load457, <2 x double> %broadcast.splat517, <2 x double> %905)
  %907 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load460, <2 x double> %broadcast.splat519, <2 x double> %906)
  %908 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load463, <2 x double> %broadcast.splat521, <2 x double> %907)
  %909 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load466, <2 x double> %broadcast.splat523, <2 x double> %908)
  %910 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load469, <2 x double> %broadcast.splat525, <2 x double> %909)
  store <2 x double> %910, ptr %901, align 16, !tbaa !8
  %911 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %866
  %wide.load526 = load <2 x double>, ptr %854, align 16, !tbaa !8
  %912 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load526, <2 x double> %broadcast.splat528, <2 x double> zeroinitializer)
  %wide.load529 = load <2 x double>, ptr %858, align 16, !tbaa !8
  %913 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load529, <2 x double> %broadcast.splat531, <2 x double> %912)
  %wide.load532 = load <2 x double>, ptr %861, align 16, !tbaa !8
  %914 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load532, <2 x double> %broadcast.splat534, <2 x double> %913)
  %wide.load535 = load <2 x double>, ptr %864, align 16, !tbaa !8
  %915 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load535, <2 x double> %broadcast.splat537, <2 x double> %914)
  %wide.load538 = load <2 x double>, ptr %867, align 16, !tbaa !8
  %916 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load538, <2 x double> %broadcast.splat540, <2 x double> %915)
  %917 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load460, <2 x double> %broadcast.splat542, <2 x double> %916)
  %918 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load463, <2 x double> %broadcast.splat544, <2 x double> %917)
  %919 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load466, <2 x double> %broadcast.splat546, <2 x double> %918)
  %920 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load469, <2 x double> %broadcast.splat548, <2 x double> %919)
  store <2 x double> %920, ptr %911, align 16, !tbaa !8
  %921 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %869
  %922 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load526, <2 x double> %broadcast.splat550, <2 x double> zeroinitializer)
  %923 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load529, <2 x double> %broadcast.splat552, <2 x double> %922)
  %924 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load532, <2 x double> %broadcast.splat554, <2 x double> %923)
  %925 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load535, <2 x double> %broadcast.splat556, <2 x double> %924)
  %926 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load538, <2 x double> %broadcast.splat558, <2 x double> %925)
  %wide.load559 = load <2 x double>, ptr %870, align 16, !tbaa !8
  %927 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load559, <2 x double> %broadcast.splat561, <2 x double> %926)
  %wide.load562 = load <2 x double>, ptr %873, align 16, !tbaa !8
  %928 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load562, <2 x double> %broadcast.splat564, <2 x double> %927)
  %wide.load565 = load <2 x double>, ptr %876, align 16, !tbaa !8
  %929 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load565, <2 x double> %broadcast.splat567, <2 x double> %928)
  %wide.load568 = load <2 x double>, ptr %879, align 16, !tbaa !8
  %930 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load568, <2 x double> %broadcast.splat570, <2 x double> %929)
  store <2 x double> %930, ptr %921, align 16, !tbaa !8
  %931 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %872
  %932 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load526, <2 x double> %broadcast.splat572, <2 x double> zeroinitializer)
  %933 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load529, <2 x double> %broadcast.splat574, <2 x double> %932)
  %934 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load532, <2 x double> %broadcast.splat576, <2 x double> %933)
  %935 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load535, <2 x double> %broadcast.splat578, <2 x double> %934)
  %936 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load538, <2 x double> %broadcast.splat580, <2 x double> %935)
  %937 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load559, <2 x double> %broadcast.splat582, <2 x double> %936)
  %938 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load562, <2 x double> %broadcast.splat584, <2 x double> %937)
  %939 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load565, <2 x double> %broadcast.splat586, <2 x double> %938)
  %940 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load568, <2 x double> %broadcast.splat588, <2 x double> %939)
  store <2 x double> %940, ptr %931, align 16, !tbaa !8
  %941 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %875
  %942 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load526, <2 x double> %broadcast.splat590, <2 x double> zeroinitializer)
  %943 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load529, <2 x double> %broadcast.splat592, <2 x double> %942)
  %944 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load532, <2 x double> %broadcast.splat594, <2 x double> %943)
  %945 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load535, <2 x double> %broadcast.splat596, <2 x double> %944)
  %946 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load538, <2 x double> %broadcast.splat598, <2 x double> %945)
  %947 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load559, <2 x double> %broadcast.splat600, <2 x double> %946)
  %948 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load562, <2 x double> %broadcast.splat602, <2 x double> %947)
  %949 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load565, <2 x double> %broadcast.splat604, <2 x double> %948)
  %950 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load568, <2 x double> %broadcast.splat606, <2 x double> %949)
  store <2 x double> %950, ptr %941, align 16, !tbaa !8
  %951 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %878
  %952 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load526, <2 x double> %broadcast.splat608, <2 x double> zeroinitializer)
  %953 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load529, <2 x double> %broadcast.splat610, <2 x double> %952)
  %954 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load532, <2 x double> %broadcast.splat612, <2 x double> %953)
  %955 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load535, <2 x double> %broadcast.splat614, <2 x double> %954)
  %956 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load538, <2 x double> %broadcast.splat616, <2 x double> %955)
  %957 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load559, <2 x double> %broadcast.splat618, <2 x double> %956)
  %958 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load562, <2 x double> %broadcast.splat620, <2 x double> %957)
  %959 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load565, <2 x double> %broadcast.splat622, <2 x double> %958)
  %960 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load568, <2 x double> %broadcast.splat624, <2 x double> %959)
  store <2 x double> %960, ptr %951, align 16, !tbaa !8
  %wide.load625 = load <2 x double>, ptr %855, align 16, !tbaa !8
  %961 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load625, <2 x double> %broadcast.splat627, <2 x double> zeroinitializer)
  %962 = or disjoint i64 %index, 4
  %963 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %962
  %wide.load628 = load <2 x double>, ptr %963, align 16, !tbaa !8
  %964 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load628, <2 x double> %broadcast.splat630, <2 x double> %961)
  %965 = or disjoint i64 %index, 8
  %966 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %965
  %wide.load631 = load <2 x double>, ptr %966, align 16, !tbaa !8
  %967 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load631, <2 x double> %broadcast.splat633, <2 x double> %964)
  %968 = or disjoint i64 %index, 12
  %969 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %968
  %wide.load634 = load <2 x double>, ptr %969, align 16, !tbaa !8
  %970 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load634, <2 x double> %broadcast.splat636, <2 x double> %967)
  %971 = or disjoint i64 %index, 16
  %972 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %971
  %wide.load637 = load <2 x double>, ptr %972, align 16, !tbaa !8
  %973 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load637, <2 x double> %broadcast.splat639, <2 x double> %970)
  %974 = or disjoint i64 %index, 20
  %975 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %974
  %wide.load640 = load <2 x double>, ptr %975, align 16, !tbaa !8
  %976 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load640, <2 x double> %broadcast.splat642, <2 x double> %973)
  %977 = or disjoint i64 %index, 24
  %978 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %977
  %wide.load643 = load <2 x double>, ptr %978, align 16, !tbaa !8
  %979 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load643, <2 x double> %broadcast.splat645, <2 x double> %976)
  %980 = or disjoint i64 %index, 28
  %981 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %980
  %wide.load646 = load <2 x double>, ptr %981, align 16, !tbaa !8
  %982 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load646, <2 x double> %broadcast.splat648, <2 x double> %979)
  %983 = or disjoint i64 %index, 32
  %984 = getelementptr inbounds [36 x double], ptr %14, i64 0, i64 %983
  %wide.load649 = load <2 x double>, ptr %984, align 16, !tbaa !8
  %985 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load649, <2 x double> %broadcast.splat651, <2 x double> %982)
  %986 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %index
  %wide.load652 = load <2 x double>, ptr %986, align 16, !tbaa !8
  %987 = fadd <2 x double> %985, %wide.load652
  %988 = getelementptr inbounds [16 x double], ptr %13, i64 0, i64 %index
  store <2 x double> %987, ptr %988, align 16, !tbaa !8
  %989 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load625, <2 x double> %broadcast.splat654, <2 x double> zeroinitializer)
  %990 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load628, <2 x double> %broadcast.splat656, <2 x double> %989)
  %991 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load631, <2 x double> %broadcast.splat658, <2 x double> %990)
  %992 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load634, <2 x double> %broadcast.splat660, <2 x double> %991)
  %993 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load637, <2 x double> %broadcast.splat662, <2 x double> %992)
  %994 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load640, <2 x double> %broadcast.splat664, <2 x double> %993)
  %995 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load643, <2 x double> %broadcast.splat666, <2 x double> %994)
  %996 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load646, <2 x double> %broadcast.splat668, <2 x double> %995)
  %997 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load649, <2 x double> %broadcast.splat670, <2 x double> %996)
  %998 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %857
  %wide.load671 = load <2 x double>, ptr %998, align 16, !tbaa !8
  %999 = fadd <2 x double> %997, %wide.load671
  %1000 = getelementptr inbounds [16 x double], ptr %13, i64 0, i64 %857
  store <2 x double> %999, ptr %1000, align 16, !tbaa !8
  %1001 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load625, <2 x double> %broadcast.splat673, <2 x double> zeroinitializer)
  %1002 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load628, <2 x double> %broadcast.splat675, <2 x double> %1001)
  %1003 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load631, <2 x double> %broadcast.splat677, <2 x double> %1002)
  %1004 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load634, <2 x double> %broadcast.splat679, <2 x double> %1003)
  %1005 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load637, <2 x double> %broadcast.splat681, <2 x double> %1004)
  %1006 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load640, <2 x double> %broadcast.splat683, <2 x double> %1005)
  %1007 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load643, <2 x double> %broadcast.splat685, <2 x double> %1006)
  %1008 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load646, <2 x double> %broadcast.splat687, <2 x double> %1007)
  %1009 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load649, <2 x double> %broadcast.splat689, <2 x double> %1008)
  %1010 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %860
  %wide.load690 = load <2 x double>, ptr %1010, align 16, !tbaa !8
  %1011 = fadd <2 x double> %1009, %wide.load690
  %1012 = getelementptr inbounds [16 x double], ptr %13, i64 0, i64 %860
  store <2 x double> %1011, ptr %1012, align 16, !tbaa !8
  %1013 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load625, <2 x double> %broadcast.splat692, <2 x double> zeroinitializer)
  %1014 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load628, <2 x double> %broadcast.splat694, <2 x double> %1013)
  %1015 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load631, <2 x double> %broadcast.splat696, <2 x double> %1014)
  %1016 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load634, <2 x double> %broadcast.splat698, <2 x double> %1015)
  %1017 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load637, <2 x double> %broadcast.splat700, <2 x double> %1016)
  %1018 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load640, <2 x double> %broadcast.splat702, <2 x double> %1017)
  %1019 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load643, <2 x double> %broadcast.splat704, <2 x double> %1018)
  %1020 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load646, <2 x double> %broadcast.splat706, <2 x double> %1019)
  %1021 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %wide.load649, <2 x double> %broadcast.splat708, <2 x double> %1020)
  %1022 = getelementptr inbounds [16 x double], ptr @R, i64 0, i64 %863
  %wide.load709 = load <2 x double>, ptr %1022, align 16, !tbaa !8
  %1023 = fadd <2 x double> %1021, %wide.load709
  %1024 = getelementptr inbounds [16 x double], ptr %13, i64 0, i64 %863
  store <2 x double> %1023, ptr %1024, align 16, !tbaa !8
  %index.next = add nuw i64 %index, 2
  %1025 = icmp eq i64 %index.next, 4
  br i1 %1025, label %middle.block, label %vector.body, !llvm.loop !16

middle.block:                                     ; preds = %vector.body
  call void @mrdivide(ptr noundef nonnull %15, ptr noundef nonnull %13)
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(648) %11, i8 0, i64 640, i1 false)
  store double 1.000000e+00, ptr %11, align 16, !tbaa !8
  store double 1.000000e+00, ptr %92, align 16, !tbaa !8
  store double 1.000000e+00, ptr %97, align 16, !tbaa !8
  store double 1.000000e+00, ptr %108, align 16, !tbaa !8
  store double 1.000000e+00, ptr %509, align 16, !tbaa !8
  store double 1.000000e+00, ptr %510, align 16, !tbaa !8
  store double 1.000000e+00, ptr %511, align 16, !tbaa !8
  store double 1.000000e+00, ptr %512, align 16, !tbaa !8
  store double 1.000000e+00, ptr %513, align 16, !tbaa !8
  %.sroa.0412.0.copyload = load double, ptr @P, align 16
  %.sroa.4413.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 8), align 8
  %.sroa.5.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 16), align 16
  %.sroa.6414.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 24), align 8
  %.sroa.7.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 32), align 16
  %.sroa.8415.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 40), align 8
  %.sroa.9.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 48), align 16
  %.sroa.10.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 56), align 8
  %.sroa.11.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 64), align 16
  %.sroa.12416.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 72), align 8
  %.sroa.13.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 80), align 16
  %.sroa.14.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 88), align 8
  %.sroa.15.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 96), align 16
  %.sroa.16.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 104), align 8
  %.sroa.17.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 112), align 16
  %.sroa.18.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 120), align 8
  %.sroa.19.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 128), align 16
  %.sroa.20.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 136), align 8
  %.sroa.21.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 144), align 16
  %.sroa.22417.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 152), align 8
  %.sroa.23.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 160), align 16
  %.sroa.24.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 168), align 8
  %.sroa.25.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 176), align 16
  %.sroa.26.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 184), align 8
  %.sroa.27.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 192), align 16
  %.sroa.28.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 200), align 8
  %.sroa.29.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 208), align 16
  %.sroa.30.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 216), align 8
  %.sroa.31.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 224), align 16
  %.sroa.32418.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 232), align 8
  %.sroa.33.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 240), align 16
  %.sroa.34.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 248), align 8
  %.sroa.35.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 256), align 16
  %.sroa.36.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 264), align 8
  %.sroa.37.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 272), align 16
  %.sroa.38.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 280), align 8
  %.sroa.39.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 288), align 16
  %.sroa.40.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 296), align 8
  %.sroa.41.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 304), align 16
  %.sroa.42.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 312), align 8
  %.sroa.43.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 320), align 16
  %.sroa.44.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 328), align 8
  %.sroa.45.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 336), align 16
  %.sroa.46.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 344), align 8
  %.sroa.47.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 352), align 16
  %.sroa.48.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 360), align 8
  %.sroa.49.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 368), align 16
  %.sroa.50.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 376), align 8
  %.sroa.51.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 384), align 16
  %.sroa.52.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 392), align 8
  %.sroa.53.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 400), align 16
  %.sroa.54.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 408), align 8
  %.sroa.55.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 416), align 16
  %.sroa.56.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 424), align 8
  %.sroa.57.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 432), align 16
  %.sroa.58.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 440), align 8
  %.sroa.59.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 448), align 16
  %.sroa.60.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 456), align 8
  %.sroa.61.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 464), align 16
  %.sroa.62.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 472), align 8
  %.sroa.63.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 480), align 16
  %.sroa.64.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 488), align 8
  %.sroa.65.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 496), align 16
  %.sroa.66.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 504), align 8
  %.sroa.67.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 512), align 16
  %.sroa.68.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 520), align 8
  %.sroa.69.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 528), align 16
  %.sroa.70.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 536), align 8
  %.sroa.71.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 544), align 16
  %.sroa.72.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 552), align 8
  %.sroa.73.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 560), align 16
  %.sroa.74.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 568), align 8
  %.sroa.75.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 576), align 16
  %.sroa.76.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 584), align 8
  %.sroa.77.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 592), align 16
  %.sroa.78.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 600), align 8
  %.sroa.79.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 608), align 16
  %.sroa.80.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 616), align 8
  %.sroa.81.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 624), align 16
  %.sroa.82.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 632), align 8
  %.sroa.83.0.copyload = load double, ptr getelementptr inbounds (i8, ptr @P, i64 640), align 16
  %1026 = load double, ptr %12, align 16, !tbaa !8
  %1027 = load double, ptr %553, align 8, !tbaa !8
  %1028 = load double, ptr %605, align 16, !tbaa !8
  %1029 = load double, ptr %644, align 8, !tbaa !8
  %1030 = load double, ptr %534, align 16, !tbaa !8
  %1031 = load double, ptr %576, align 8, !tbaa !8
  %1032 = load double, ptr %630, align 16, !tbaa !8
  %1033 = load double, ptr %647, align 8, !tbaa !8
  %1034 = load double, ptr %535, align 16, !tbaa !8
  %1035 = load double, ptr %584, align 8, !tbaa !8
  %1036 = load double, ptr %631, align 16, !tbaa !8
  %1037 = load double, ptr %650, align 8, !tbaa !8
  %1038 = load double, ptr %536, align 16, !tbaa !8
  %1039 = load double, ptr %589, align 8, !tbaa !8
  %1040 = load double, ptr %632, align 16, !tbaa !8
  %1041 = load double, ptr %653, align 8, !tbaa !8
  %1042 = load double, ptr %542, align 16, !tbaa !8
  %1043 = load double, ptr %590, align 8, !tbaa !8
  %1044 = load double, ptr %637, align 16, !tbaa !8
  %1045 = load double, ptr %656, align 8, !tbaa !8
  %1046 = load double, ptr %543, align 16, !tbaa !8
  %1047 = load double, ptr %596, align 8, !tbaa !8
  %1048 = load double, ptr %638, align 16, !tbaa !8
  %1049 = load double, ptr %659, align 8, !tbaa !8
  %1050 = load double, ptr %544, align 16, !tbaa !8
  %1051 = load double, ptr %597, align 8, !tbaa !8
  %1052 = load double, ptr %639, align 16, !tbaa !8
  %1053 = load double, ptr %662, align 8, !tbaa !8
  %1054 = load double, ptr %545, align 16, !tbaa !8
  %1055 = load double, ptr %598, align 8, !tbaa !8
  %1056 = load double, ptr %640, align 16, !tbaa !8
  %1057 = load double, ptr %665, align 8, !tbaa !8
  %1058 = load double, ptr %546, align 16, !tbaa !8
  %1059 = load double, ptr %599, align 8, !tbaa !8
  %1060 = load double, ptr %641, align 16, !tbaa !8
  %1061 = load double, ptr %668, align 8, !tbaa !8
  br label %.preheader225

.preheader225:                                    ; preds = %middle.block, %.preheader225
  %indvars.iv359 = phi i64 [ 0, %middle.block ], [ %indvars.iv.next360, %.preheader225 ]
  %1062 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %indvars.iv359
  %1063 = load double, ptr %1062, align 8, !tbaa !8
  %1064 = call double @llvm.fmuladd.f64(double %1063, double %1026, double 0.000000e+00)
  %1065 = add nuw nsw i64 %indvars.iv359, 9
  %1066 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %1065
  %1067 = load double, ptr %1066, align 8, !tbaa !8
  %1068 = call double @llvm.fmuladd.f64(double %1067, double %1027, double %1064)
  %1069 = add nuw nsw i64 %indvars.iv359, 18
  %1070 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %1069
  %1071 = load double, ptr %1070, align 8, !tbaa !8
  %1072 = call double @llvm.fmuladd.f64(double %1071, double %1028, double %1068)
  %1073 = add nuw nsw i64 %indvars.iv359, 27
  %1074 = getelementptr inbounds [36 x double], ptr %15, i64 0, i64 %1073
  %1075 = load double, ptr %1074, align 8, !tbaa !8
  %1076 = call double @llvm.fmuladd.f64(double %1075, double %1029, double %1072)
  %1077 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %indvars.iv359
  %1078 = load double, ptr %1077, align 8, !tbaa !8
  %1079 = fsub double %1078, %1076
  %1080 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %indvars.iv359
  store double %1079, ptr %1080, align 8, !tbaa !8
  %1081 = call double @llvm.fmuladd.f64(double %1063, double %1030, double 0.000000e+00)
  %1082 = call double @llvm.fmuladd.f64(double %1067, double %1031, double %1081)
  %1083 = call double @llvm.fmuladd.f64(double %1071, double %1032, double %1082)
  %1084 = call double @llvm.fmuladd.f64(double %1075, double %1033, double %1083)
  %1085 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1065
  %1086 = load double, ptr %1085, align 8, !tbaa !8
  %1087 = fsub double %1086, %1084
  %1088 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1065
  store double %1087, ptr %1088, align 8, !tbaa !8
  %1089 = call double @llvm.fmuladd.f64(double %1063, double %1034, double 0.000000e+00)
  %1090 = call double @llvm.fmuladd.f64(double %1067, double %1035, double %1089)
  %1091 = call double @llvm.fmuladd.f64(double %1071, double %1036, double %1090)
  %1092 = call double @llvm.fmuladd.f64(double %1075, double %1037, double %1091)
  %1093 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1069
  %1094 = load double, ptr %1093, align 8, !tbaa !8
  %1095 = fsub double %1094, %1092
  %1096 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1069
  store double %1095, ptr %1096, align 8, !tbaa !8
  %1097 = call double @llvm.fmuladd.f64(double %1063, double %1038, double 0.000000e+00)
  %1098 = call double @llvm.fmuladd.f64(double %1067, double %1039, double %1097)
  %1099 = call double @llvm.fmuladd.f64(double %1071, double %1040, double %1098)
  %1100 = call double @llvm.fmuladd.f64(double %1075, double %1041, double %1099)
  %1101 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1073
  %1102 = load double, ptr %1101, align 8, !tbaa !8
  %1103 = fsub double %1102, %1100
  %1104 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1073
  store double %1103, ptr %1104, align 8, !tbaa !8
  %1105 = call double @llvm.fmuladd.f64(double %1063, double %1042, double 0.000000e+00)
  %1106 = call double @llvm.fmuladd.f64(double %1067, double %1043, double %1105)
  %1107 = call double @llvm.fmuladd.f64(double %1071, double %1044, double %1106)
  %1108 = call double @llvm.fmuladd.f64(double %1075, double %1045, double %1107)
  %1109 = add nuw nsw i64 %indvars.iv359, 36
  %1110 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1109
  %1111 = load double, ptr %1110, align 8, !tbaa !8
  %1112 = fsub double %1111, %1108
  %1113 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1109
  store double %1112, ptr %1113, align 8, !tbaa !8
  %1114 = call double @llvm.fmuladd.f64(double %1063, double %1046, double 0.000000e+00)
  %1115 = call double @llvm.fmuladd.f64(double %1067, double %1047, double %1114)
  %1116 = call double @llvm.fmuladd.f64(double %1071, double %1048, double %1115)
  %1117 = call double @llvm.fmuladd.f64(double %1075, double %1049, double %1116)
  %1118 = add nuw nsw i64 %indvars.iv359, 45
  %1119 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1118
  %1120 = load double, ptr %1119, align 8, !tbaa !8
  %1121 = fsub double %1120, %1117
  %1122 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1118
  store double %1121, ptr %1122, align 8, !tbaa !8
  %1123 = call double @llvm.fmuladd.f64(double %1063, double %1050, double 0.000000e+00)
  %1124 = call double @llvm.fmuladd.f64(double %1067, double %1051, double %1123)
  %1125 = call double @llvm.fmuladd.f64(double %1071, double %1052, double %1124)
  %1126 = call double @llvm.fmuladd.f64(double %1075, double %1053, double %1125)
  %1127 = add nuw nsw i64 %indvars.iv359, 54
  %1128 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1127
  %1129 = load double, ptr %1128, align 8, !tbaa !8
  %1130 = fsub double %1129, %1126
  %1131 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1127
  store double %1130, ptr %1131, align 8, !tbaa !8
  %1132 = load double, ptr %1062, align 8, !tbaa !8
  %1133 = call double @llvm.fmuladd.f64(double %1132, double %1054, double 0.000000e+00)
  %1134 = load double, ptr %1066, align 8, !tbaa !8
  %1135 = call double @llvm.fmuladd.f64(double %1134, double %1055, double %1133)
  %1136 = load double, ptr %1070, align 8, !tbaa !8
  %1137 = call double @llvm.fmuladd.f64(double %1136, double %1056, double %1135)
  %1138 = call double @llvm.fmuladd.f64(double %1075, double %1057, double %1137)
  %1139 = add nuw nsw i64 %indvars.iv359, 63
  %1140 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1139
  %1141 = load double, ptr %1140, align 8, !tbaa !8
  %1142 = fsub double %1141, %1138
  %1143 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1139
  store double %1142, ptr %1143, align 8, !tbaa !8
  %1144 = call double @llvm.fmuladd.f64(double %1132, double %1058, double 0.000000e+00)
  %1145 = call double @llvm.fmuladd.f64(double %1134, double %1059, double %1144)
  %1146 = call double @llvm.fmuladd.f64(double %1136, double %1060, double %1145)
  %1147 = load double, ptr %1074, align 8, !tbaa !8
  %1148 = call double @llvm.fmuladd.f64(double %1147, double %1061, double %1146)
  %1149 = add nuw nsw i64 %indvars.iv359, 72
  %1150 = getelementptr inbounds [81 x double], ptr %11, i64 0, i64 %1149
  %1151 = load double, ptr %1150, align 8, !tbaa !8
  %1152 = fsub double %1151, %1148
  %1153 = getelementptr inbounds [81 x double], ptr %16, i64 0, i64 %1149
  store double %1152, ptr %1153, align 8, !tbaa !8
  %1154 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %indvars.iv359
  %1155 = load double, ptr %1080, align 8, !tbaa !8
  %1156 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.0412.0.copyload, double 0.000000e+00)
  %1157 = load double, ptr %1088, align 8, !tbaa !8
  %1158 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.4413.0.copyload, double %1156)
  %1159 = call double @llvm.fmuladd.f64(double %1095, double %.sroa.5.0.copyload, double %1158)
  %1160 = call double @llvm.fmuladd.f64(double %1103, double %.sroa.6414.0.copyload, double %1159)
  %1161 = call double @llvm.fmuladd.f64(double %1112, double %.sroa.7.0.copyload, double %1160)
  %1162 = call double @llvm.fmuladd.f64(double %1121, double %.sroa.8415.0.copyload, double %1161)
  %1163 = call double @llvm.fmuladd.f64(double %1130, double %.sroa.9.0.copyload, double %1162)
  %1164 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.10.0.copyload, double %1163)
  %1165 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.11.0.copyload, double %1164)
  store double %1165, ptr %1154, align 8, !tbaa !8
  %1166 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1065
  %1167 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.12416.0.copyload, double 0.000000e+00)
  %1168 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.13.0.copyload, double %1167)
  %1169 = load double, ptr %1096, align 8, !tbaa !8
  %1170 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.14.0.copyload, double %1168)
  %1171 = call double @llvm.fmuladd.f64(double %1103, double %.sroa.15.0.copyload, double %1170)
  %1172 = call double @llvm.fmuladd.f64(double %1112, double %.sroa.16.0.copyload, double %1171)
  %1173 = call double @llvm.fmuladd.f64(double %1121, double %.sroa.17.0.copyload, double %1172)
  %1174 = call double @llvm.fmuladd.f64(double %1130, double %.sroa.18.0.copyload, double %1173)
  %1175 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.19.0.copyload, double %1174)
  %1176 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.20.0.copyload, double %1175)
  store double %1176, ptr %1166, align 8, !tbaa !8
  %1177 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1069
  %1178 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.21.0.copyload, double 0.000000e+00)
  %1179 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.22417.0.copyload, double %1178)
  %1180 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.23.0.copyload, double %1179)
  %1181 = load double, ptr %1104, align 8, !tbaa !8
  %1182 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.24.0.copyload, double %1180)
  %1183 = call double @llvm.fmuladd.f64(double %1112, double %.sroa.25.0.copyload, double %1182)
  %1184 = call double @llvm.fmuladd.f64(double %1121, double %.sroa.26.0.copyload, double %1183)
  %1185 = call double @llvm.fmuladd.f64(double %1130, double %.sroa.27.0.copyload, double %1184)
  %1186 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.28.0.copyload, double %1185)
  %1187 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.29.0.copyload, double %1186)
  store double %1187, ptr %1177, align 8, !tbaa !8
  %1188 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1073
  %1189 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.30.0.copyload, double 0.000000e+00)
  %1190 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.31.0.copyload, double %1189)
  %1191 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.32418.0.copyload, double %1190)
  %1192 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.33.0.copyload, double %1191)
  %1193 = load double, ptr %1113, align 8, !tbaa !8
  %1194 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.34.0.copyload, double %1192)
  %1195 = call double @llvm.fmuladd.f64(double %1121, double %.sroa.35.0.copyload, double %1194)
  %1196 = call double @llvm.fmuladd.f64(double %1130, double %.sroa.36.0.copyload, double %1195)
  %1197 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.37.0.copyload, double %1196)
  %1198 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.38.0.copyload, double %1197)
  store double %1198, ptr %1188, align 8, !tbaa !8
  %1199 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1109
  %1200 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.39.0.copyload, double 0.000000e+00)
  %1201 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.40.0.copyload, double %1200)
  %1202 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.41.0.copyload, double %1201)
  %1203 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.42.0.copyload, double %1202)
  %1204 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.43.0.copyload, double %1203)
  %1205 = load double, ptr %1122, align 8, !tbaa !8
  %1206 = call double @llvm.fmuladd.f64(double %1205, double %.sroa.44.0.copyload, double %1204)
  %1207 = call double @llvm.fmuladd.f64(double %1130, double %.sroa.45.0.copyload, double %1206)
  %1208 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.46.0.copyload, double %1207)
  %1209 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.47.0.copyload, double %1208)
  store double %1209, ptr %1199, align 8, !tbaa !8
  %1210 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1118
  %1211 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.48.0.copyload, double 0.000000e+00)
  %1212 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.49.0.copyload, double %1211)
  %1213 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.50.0.copyload, double %1212)
  %1214 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.51.0.copyload, double %1213)
  %1215 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.52.0.copyload, double %1214)
  %1216 = call double @llvm.fmuladd.f64(double %1205, double %.sroa.53.0.copyload, double %1215)
  %1217 = load double, ptr %1131, align 8, !tbaa !8
  %1218 = call double @llvm.fmuladd.f64(double %1217, double %.sroa.54.0.copyload, double %1216)
  %1219 = call double @llvm.fmuladd.f64(double %1142, double %.sroa.55.0.copyload, double %1218)
  %1220 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.56.0.copyload, double %1219)
  store double %1220, ptr %1210, align 8, !tbaa !8
  %1221 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1127
  %1222 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.57.0.copyload, double 0.000000e+00)
  %1223 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.58.0.copyload, double %1222)
  %1224 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.59.0.copyload, double %1223)
  %1225 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.60.0.copyload, double %1224)
  %1226 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.61.0.copyload, double %1225)
  %1227 = call double @llvm.fmuladd.f64(double %1205, double %.sroa.62.0.copyload, double %1226)
  %1228 = call double @llvm.fmuladd.f64(double %1217, double %.sroa.63.0.copyload, double %1227)
  %1229 = load double, ptr %1143, align 8, !tbaa !8
  %1230 = call double @llvm.fmuladd.f64(double %1229, double %.sroa.64.0.copyload, double %1228)
  %1231 = call double @llvm.fmuladd.f64(double %1152, double %.sroa.65.0.copyload, double %1230)
  store double %1231, ptr %1221, align 8, !tbaa !8
  %1232 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1139
  %1233 = call double @llvm.fmuladd.f64(double %1155, double %.sroa.66.0.copyload, double 0.000000e+00)
  %1234 = call double @llvm.fmuladd.f64(double %1157, double %.sroa.67.0.copyload, double %1233)
  %1235 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.68.0.copyload, double %1234)
  %1236 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.69.0.copyload, double %1235)
  %1237 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.70.0.copyload, double %1236)
  %1238 = call double @llvm.fmuladd.f64(double %1205, double %.sroa.71.0.copyload, double %1237)
  %1239 = call double @llvm.fmuladd.f64(double %1217, double %.sroa.72.0.copyload, double %1238)
  %1240 = call double @llvm.fmuladd.f64(double %1229, double %.sroa.73.0.copyload, double %1239)
  %1241 = load double, ptr %1153, align 8, !tbaa !8
  %1242 = call double @llvm.fmuladd.f64(double %1241, double %.sroa.74.0.copyload, double %1240)
  store double %1242, ptr %1232, align 8, !tbaa !8
  %1243 = getelementptr inbounds [81 x double], ptr @P, i64 0, i64 %1149
  %1244 = load double, ptr %1080, align 8, !tbaa !8
  %1245 = call double @llvm.fmuladd.f64(double %1244, double %.sroa.75.0.copyload, double 0.000000e+00)
  %1246 = load double, ptr %1088, align 8, !tbaa !8
  %1247 = call double @llvm.fmuladd.f64(double %1246, double %.sroa.76.0.copyload, double %1245)
  %1248 = call double @llvm.fmuladd.f64(double %1169, double %.sroa.77.0.copyload, double %1247)
  %1249 = call double @llvm.fmuladd.f64(double %1181, double %.sroa.78.0.copyload, double %1248)
  %1250 = call double @llvm.fmuladd.f64(double %1193, double %.sroa.79.0.copyload, double %1249)
  %1251 = call double @llvm.fmuladd.f64(double %1205, double %.sroa.80.0.copyload, double %1250)
  %1252 = call double @llvm.fmuladd.f64(double %1217, double %.sroa.81.0.copyload, double %1251)
  %1253 = call double @llvm.fmuladd.f64(double %1229, double %.sroa.82.0.copyload, double %1252)
  %1254 = call double @llvm.fmuladd.f64(double %1241, double %.sroa.83.0.copyload, double %1253)
  store double %1254, ptr %1243, align 8, !tbaa !8
  %indvars.iv.next360 = add nuw nsw i64 %indvars.iv359, 1
  %exitcond362.not = icmp eq i64 %indvars.iv.next360, 9
  br i1 %exitcond362.not, label %.preheader.preheader, label %.preheader225, !llvm.loop !19

.preheader.preheader:                             ; preds = %.preheader225
  %1255 = load double, ptr @ax, align 8, !tbaa !8
  %1256 = load double, ptr @ay, align 8, !tbaa !8
  %1257 = load double, ptr @az, align 8, !tbaa !8
  %1258 = getelementptr inbounds i8, ptr %2, i64 8
  %1259 = load double, ptr %1258, align 8, !tbaa !8
  %1260 = fneg double %1259
  %1261 = call double @cos(double noundef %514) #7
  %1262 = getelementptr inbounds i8, ptr %2, i64 16
  %1263 = load double, ptr %1262, align 8, !tbaa !8
  %1264 = call double @sin(double noundef %514) #7
  %1265 = fmul double %1263, %1264
  %1266 = call double @llvm.fmuladd.f64(double %1260, double %1261, double %1265)
  %1267 = load double, ptr %2, align 8, !tbaa !8
  %1268 = call double @cos(double noundef %515) #7
  %1269 = load double, ptr %1258, align 8, !tbaa !8
  %1270 = call double @sin(double noundef %514) #7
  %1271 = load double, ptr %1262, align 8, !tbaa !8
  %1272 = call double @cos(double noundef %514) #7
  %1273 = fmul double %1271, %1272
  %1274 = call double @llvm.fmuladd.f64(double %1269, double %1270, double %1273)
  %1275 = call double @sin(double noundef %515) #7
  %1276 = fmul double %1275, %1274
  %1277 = call double @llvm.fmuladd.f64(double %1267, double %1268, double %1276)
  %1278 = call double @atan2(double noundef %1266, double noundef %1277) #7
  %1279 = fadd double %1278, 0x3FEBECDE5DA115A9
  %1280 = load double, ptr @g, align 8, !tbaa !8
  %1281 = call double @sin(double noundef %515) #7
  %1282 = load double, ptr @V, align 8, !tbaa !8
  %1283 = call double @sin(double noundef %515) #7
  %1284 = load double, ptr @q, align 8, !tbaa !8
  %1285 = fsub double %518, %1284
  %1286 = fneg double %1282
  %1287 = fmul double %1283, %1286
  %1288 = fmul double %1287, %1285
  %1289 = call double @llvm.fmuladd.f64(double %1280, double %1281, double %1288)
  %1290 = fsub double %1289, %520
  %1291 = load double, ptr @V, align 8, !tbaa !8
  %1292 = call double @sin(double noundef %515) #7
  %1293 = fmul double %1291, %1292
  %1294 = load double, ptr @p, align 8, !tbaa !8
  %1295 = fsub double %517, %1294
  %1296 = load double, ptr @V, align 8, !tbaa !8
  %1297 = call double @cos(double noundef %515) #7
  %1298 = load double, ptr @r, align 8, !tbaa !8
  %1299 = fsub double %519, %1298
  %1300 = fneg double %1296
  %1301 = fmul double %1297, %1300
  %1302 = fmul double %1301, %1299
  %1303 = call double @llvm.fmuladd.f64(double %1293, double %1295, double %1302)
  %1304 = load double, ptr @g, align 8, !tbaa !8
  %1305 = call double @cos(double noundef %515) #7
  %1306 = call double @sin(double noundef %514) #7
  %1307 = fneg double %1304
  %1308 = fmul double %1305, %1307
  %1309 = call double @llvm.fmuladd.f64(double %1308, double %1306, double %1303)
  %1310 = fsub double %1309, %521
  %1311 = load double, ptr @V, align 8, !tbaa !8
  %1312 = call double @cos(double noundef %515) #7
  %1313 = fmul double %1311, %1312
  %1314 = load double, ptr @q, align 8, !tbaa !8
  %1315 = fsub double %518, %1314
  %1316 = load double, ptr @g, align 8, !tbaa !8
  %1317 = call double @cos(double noundef %514) #7
  %1318 = call double @cos(double noundef %515) #7
  %1319 = fneg double %1316
  %1320 = fmul double %1317, %1319
  %1321 = fmul double %1320, %1318
  %1322 = call double @llvm.fmuladd.f64(double %1313, double %1315, double %1321)
  %1323 = fsub double %1322, %522
  %1324 = fsub double %1255, %1290
  %1325 = fsub double %1256, %1310
  %1326 = fsub double %1257, %1323
  %1327 = fsub double %1279, %516
  %1328 = getelementptr inbounds i8, ptr %15, i64 72
  %1329 = getelementptr inbounds i8, ptr %15, i64 144
  %1330 = getelementptr inbounds i8, ptr %15, i64 216
  %1331 = load <2 x double>, ptr %15, align 16, !tbaa !8
  %1332 = insertelement <2 x double> poison, double %1324, i64 0
  %1333 = shufflevector <2 x double> %1332, <2 x double> poison, <2 x i32> zeroinitializer
  %1334 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1331, <2 x double> %1333, <2 x double> zeroinitializer)
  %1335 = load <2 x double>, ptr %1328, align 8, !tbaa !8
  %1336 = insertelement <2 x double> poison, double %1325, i64 0
  %1337 = shufflevector <2 x double> %1336, <2 x double> poison, <2 x i32> zeroinitializer
  %1338 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1335, <2 x double> %1337, <2 x double> %1334)
  %1339 = load <2 x double>, ptr %1329, align 16, !tbaa !8
  %1340 = insertelement <2 x double> poison, double %1326, i64 0
  %1341 = shufflevector <2 x double> %1340, <2 x double> poison, <2 x i32> zeroinitializer
  %1342 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1339, <2 x double> %1341, <2 x double> %1338)
  %1343 = load <2 x double>, ptr %1330, align 8, !tbaa !8
  %1344 = insertelement <2 x double> poison, double %1327, i64 0
  %1345 = shufflevector <2 x double> %1344, <2 x double> poison, <2 x i32> zeroinitializer
  %1346 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1343, <2 x double> %1345, <2 x double> %1342)
  %1347 = load <2 x double>, ptr @xhat, align 16, !tbaa !8
  %1348 = fadd <2 x double> %1346, %1347
  store <2 x double> %1348, ptr @xhat, align 16, !tbaa !8
  %1349 = getelementptr inbounds i8, ptr %15, i64 16
  %1350 = getelementptr inbounds i8, ptr %15, i64 88
  %1351 = getelementptr inbounds i8, ptr %15, i64 160
  %1352 = getelementptr inbounds i8, ptr %15, i64 232
  %1353 = load <2 x double>, ptr %1349, align 16, !tbaa !8
  %1354 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1353, <2 x double> %1333, <2 x double> zeroinitializer)
  %1355 = load <2 x double>, ptr %1350, align 8, !tbaa !8
  %1356 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1355, <2 x double> %1337, <2 x double> %1354)
  %1357 = load <2 x double>, ptr %1351, align 16, !tbaa !8
  %1358 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1357, <2 x double> %1341, <2 x double> %1356)
  %1359 = load <2 x double>, ptr %1352, align 8, !tbaa !8
  %1360 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1359, <2 x double> %1345, <2 x double> %1358)
  %1361 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  %1362 = fadd <2 x double> %1360, %1361
  store <2 x double> %1362, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  %1363 = getelementptr inbounds i8, ptr %15, i64 32
  %1364 = getelementptr inbounds i8, ptr %15, i64 104
  %1365 = getelementptr inbounds i8, ptr %15, i64 176
  %1366 = getelementptr inbounds i8, ptr %15, i64 248
  %1367 = load <2 x double>, ptr %1363, align 16, !tbaa !8
  %1368 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1367, <2 x double> %1333, <2 x double> zeroinitializer)
  %1369 = load <2 x double>, ptr %1364, align 8, !tbaa !8
  %1370 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1369, <2 x double> %1337, <2 x double> %1368)
  %1371 = load <2 x double>, ptr %1365, align 16, !tbaa !8
  %1372 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1371, <2 x double> %1341, <2 x double> %1370)
  %1373 = load <2 x double>, ptr %1366, align 8, !tbaa !8
  %1374 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1373, <2 x double> %1345, <2 x double> %1372)
  %1375 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %1376 = fadd <2 x double> %1374, %1375
  store <2 x double> %1376, ptr getelementptr inbounds (i8, ptr @xhat, i64 32), align 16, !tbaa !8
  %1377 = getelementptr inbounds i8, ptr %15, i64 48
  %1378 = getelementptr inbounds i8, ptr %15, i64 120
  %1379 = getelementptr inbounds i8, ptr %15, i64 192
  %1380 = getelementptr inbounds i8, ptr %15, i64 264
  %1381 = load <2 x double>, ptr %1377, align 16, !tbaa !8
  %1382 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1381, <2 x double> %1333, <2 x double> zeroinitializer)
  %1383 = load <2 x double>, ptr %1378, align 8, !tbaa !8
  %1384 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1383, <2 x double> %1337, <2 x double> %1382)
  %1385 = load <2 x double>, ptr %1379, align 16, !tbaa !8
  %1386 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1385, <2 x double> %1341, <2 x double> %1384)
  %1387 = load <2 x double>, ptr %1380, align 8, !tbaa !8
  %1388 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1387, <2 x double> %1345, <2 x double> %1386)
  %1389 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @xhat, i64 48), align 16, !tbaa !8
  %1390 = fadd <2 x double> %1388, %1389
  store <2 x double> %1390, ptr getelementptr inbounds (i8, ptr @xhat, i64 48), align 16, !tbaa !8
  %1391 = getelementptr inbounds i8, ptr %15, i64 64
  %1392 = load double, ptr %1391, align 16, !tbaa !8
  %1393 = call double @llvm.fmuladd.f64(double %1392, double %1324, double 0.000000e+00)
  %1394 = getelementptr inbounds i8, ptr %15, i64 136
  %1395 = load double, ptr %1394, align 8, !tbaa !8
  %1396 = call double @llvm.fmuladd.f64(double %1395, double %1325, double %1393)
  %1397 = getelementptr inbounds i8, ptr %15, i64 208
  %1398 = load double, ptr %1397, align 16, !tbaa !8
  %1399 = call double @llvm.fmuladd.f64(double %1398, double %1326, double %1396)
  %1400 = getelementptr inbounds i8, ptr %15, i64 280
  %1401 = load double, ptr %1400, align 8, !tbaa !8
  %1402 = call double @llvm.fmuladd.f64(double %1401, double %1327, double %1399)
  %1403 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 64), align 16, !tbaa !8
  %1404 = fadd double %1402, %1403
  store double %1404, ptr getelementptr inbounds (i8, ptr @xhat, i64 64), align 16, !tbaa !8
  %1405 = load double, ptr @xhat, align 16, !tbaa !8
  %1406 = fmul double %1405, 1.800000e+02
  %1407 = fdiv double %1406, 0x400921FB54442D18
  store double %1407, ptr %6, align 8, !tbaa !8
  %1408 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 8), align 8, !tbaa !8
  %1409 = fmul double %1408, 1.800000e+02
  %1410 = fdiv double %1409, 0x400921FB54442D18
  store double %1410, ptr %7, align 8, !tbaa !8
  %1411 = load double, ptr getelementptr inbounds (i8, ptr @xhat, i64 16), align 16, !tbaa !8
  %1412 = fmul double %1411, 1.800000e+02
  %1413 = fdiv double %1412, 0x400921FB54442D18
  store double %1413, ptr %8, align 8, !tbaa !8
  call void @llvm.lifetime.end.p0(i64 648, ptr nonnull %17) #7
  call void @llvm.lifetime.end.p0(i64 648, ptr nonnull %16) #7
  call void @llvm.lifetime.end.p0(i64 288, ptr nonnull %15) #7
  call void @llvm.lifetime.end.p0(i64 288, ptr nonnull %14) #7
  call void @llvm.lifetime.end.p0(i64 128, ptr nonnull %13) #7
  call void @llvm.lifetime.end.p0(i64 288, ptr nonnull %12) #7
  call void @llvm.lifetime.end.p0(i64 648, ptr nonnull %11) #7
  ret void
}

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

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #2

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @log(double noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @tan(double noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @cos(double noundef) local_unnamed_addr #3

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @sin(double noundef) local_unnamed_addr #3

; Function Attrs: nounwind uwtable
declare hidden void @mrdivide(ptr noundef, ptr noundef) local_unnamed_addr #0

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

; Function Attrs: mustprogress 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) #5

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @atan2(double noundef, double noundef) local_unnamed_addr #3

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x double> @llvm.fmuladd.v2f64(<2 x double>, <2 x double>, <2 x double>) #6

attributes #0 = { 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 willreturn memory(argmem: readwrite) }
attributes #2 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { mustprogress nofree nounwind willreturn memory(write) "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 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #7 = { nounwind }

!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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9, !9, i64 0}
!9 = !{!"double", !6, i64 0}
!10 = distinct !{!10, !11}
!11 = !{!"llvm.loop.mustprogress"}
!12 = distinct !{!12, !11}
!13 = distinct !{!13, !11}
!14 = distinct !{!14, !11}
!15 = distinct !{!15, !11}
!16 = distinct !{!16, !11, !17, !18}
!17 = !{!"llvm.loop.isvectorized", i32 1}
!18 = !{!"llvm.loop.unroll.runtime.disable"}
!19 = distinct !{!19, !11}


; Effective O3 passes: DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,MemCpyOptPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass