; LLVM IR from pms67/HadesFCS :: Firmware/F4/HadesF4Testbed/Core/Src (KalmanRollPitch)

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

%struct.KalmanRollPitch = type { float, float, [4 x float], [2 x float], [3 x float] }

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @KalmanRollPitch_UpdateMeasurement(ptr noundef %0, ptr noundef %1, ptr noundef %2, float noundef %3) #3 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca float, align 4
  %9 = alloca float, align 4
  %10 = alloca float, align 4
  %11 = alloca float, align 4
  %12 = alloca float, align 4
  %13 = alloca float, align 4
  %14 = alloca float, align 4
  %15 = alloca float, align 4
  %16 = alloca float, align 4
  %17 = alloca float, align 4
  %18 = alloca float, align 4
  %19 = alloca [3 x float], align 4
  %20 = alloca [6 x float], align 16
  %21 = alloca [9 x float], align 16
  %22 = alloca float, align 4
  %23 = alloca [9 x float], align 16
  %24 = alloca [6 x float], align 16
  %25 = alloca [4 x float], align 16
  store ptr %0, ptr %5, align 8, !tbaa !5
  store ptr %1, ptr %6, align 8, !tbaa !5
  store ptr %2, ptr %7, align 8, !tbaa !5
  store float %3, ptr %8, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #4
  %26 = load ptr, ptr %6, align 8, !tbaa !5
  %27 = getelementptr inbounds float, ptr %26, i64 0
  %28 = load float, ptr %27, align 4, !tbaa !9
  store float %28, ptr %9, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #4
  %29 = load ptr, ptr %6, align 8, !tbaa !5
  %30 = getelementptr inbounds float, ptr %29, i64 1
  %31 = load float, ptr %30, align 4, !tbaa !9
  store float %31, ptr %10, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #4
  %32 = load ptr, ptr %6, align 8, !tbaa !5
  %33 = getelementptr inbounds float, ptr %32, i64 2
  %34 = load float, ptr %33, align 4, !tbaa !9
  store float %34, ptr %11, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #4
  %35 = load ptr, ptr %7, align 8, !tbaa !5
  %36 = getelementptr inbounds float, ptr %35, i64 0
  %37 = load float, ptr %36, align 4, !tbaa !9
  store float %37, ptr %12, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #4
  %38 = load ptr, ptr %7, align 8, !tbaa !5
  %39 = getelementptr inbounds float, ptr %38, i64 1
  %40 = load float, ptr %39, align 4, !tbaa !9
  store float %40, ptr %13, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #4
  %41 = load ptr, ptr %7, align 8, !tbaa !5
  %42 = getelementptr inbounds float, ptr %41, i64 2
  %43 = load float, ptr %42, align 4, !tbaa !9
  store float %43, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  %44 = load ptr, ptr %5, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.KalmanRollPitch, ptr %44, i32 0, i32 0
  %46 = load float, ptr %45, align 4, !tbaa !11
  %47 = fpext float %46 to double
  %48 = call double @sin(double noundef %47) #4
  %49 = fptrunc double %48 to float
  store float %49, ptr %15, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #4
  %50 = load ptr, ptr %5, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.KalmanRollPitch, ptr %50, i32 0, i32 0
  %52 = load float, ptr %51, align 4, !tbaa !11
  %53 = fpext float %52 to double
  %54 = call double @cos(double noundef %53) #4
  %55 = fptrunc double %54 to float
  store float %55, ptr %16, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  %56 = load ptr, ptr %5, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.KalmanRollPitch, ptr %56, i32 0, i32 1
  %58 = load float, ptr %57, align 4, !tbaa !13
  %59 = fpext float %58 to double
  %60 = call double @sin(double noundef %59) #4
  %61 = fptrunc double %60 to float
  store float %61, ptr %17, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #4
  %62 = load ptr, ptr %5, align 8, !tbaa !5
  %63 = getelementptr inbounds %struct.KalmanRollPitch, ptr %62, i32 0, i32 1
  %64 = load float, ptr %63, align 4, !tbaa !13
  %65 = fpext float %64 to double
  %66 = call double @cos(double noundef %65) #4
  %67 = fptrunc double %66 to float
  store float %67, ptr %18, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 12, ptr %19) #4
  %68 = load float, ptr %10, align 4, !tbaa !9
  %69 = load float, ptr %8, align 4, !tbaa !9
  %70 = fmul float %68, %69
  %71 = load float, ptr %17, align 4, !tbaa !9
  %72 = load float, ptr %17, align 4, !tbaa !9
  %73 = fmul float 0x40239EB860000000, %72
  %74 = call float @llvm.fmuladd.f32(float %70, float %71, float %73)
  store float %74, ptr %19, align 4, !tbaa !9
  %75 = getelementptr inbounds float, ptr %19, i64 1
  %76 = load float, ptr %11, align 4, !tbaa !9
  %77 = load float, ptr %8, align 4, !tbaa !9
  %78 = fmul float %76, %77
  %79 = load float, ptr %18, align 4, !tbaa !9
  %80 = load float, ptr %9, align 4, !tbaa !9
  %81 = load float, ptr %8, align 4, !tbaa !9
  %82 = fmul float %80, %81
  %83 = load float, ptr %17, align 4, !tbaa !9
  %84 = fmul float %82, %83
  %85 = fneg float %84
  %86 = call float @llvm.fmuladd.f32(float %78, float %79, float %85)
  %87 = load float, ptr %18, align 4, !tbaa !9
  %88 = fmul float 0x40239EB860000000, %87
  %89 = load float, ptr %15, align 4, !tbaa !9
  %90 = fneg float %88
  %91 = call float @llvm.fmuladd.f32(float %90, float %89, float %86)
  store float %91, ptr %75, align 4, !tbaa !9
  %92 = getelementptr inbounds float, ptr %19, i64 2
  %93 = load float, ptr %10, align 4, !tbaa !9
  %94 = fneg float %93
  %95 = load float, ptr %8, align 4, !tbaa !9
  %96 = fmul float %94, %95
  %97 = load float, ptr %18, align 4, !tbaa !9
  %98 = load float, ptr %18, align 4, !tbaa !9
  %99 = fmul float 0x40239EB860000000, %98
  %100 = load float, ptr %16, align 4, !tbaa !9
  %101 = fmul float %99, %100
  %102 = fneg float %101
  %103 = call float @llvm.fmuladd.f32(float %96, float %97, float %102)
  store float %103, ptr %92, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 24, ptr %20) #4
  store float 0.000000e+00, ptr %20, align 4, !tbaa !9
  %104 = getelementptr inbounds float, ptr %20, i64 1
  %105 = load float, ptr %10, align 4, !tbaa !9
  %106 = load float, ptr %8, align 4, !tbaa !9
  %107 = fmul float %105, %106
  %108 = load float, ptr %18, align 4, !tbaa !9
  %109 = load float, ptr %18, align 4, !tbaa !9
  %110 = fmul float 0x40239EB860000000, %109
  %111 = call float @llvm.fmuladd.f32(float %107, float %108, float %110)
  store float %111, ptr %104, align 4, !tbaa !9
  %112 = getelementptr inbounds float, ptr %20, i64 2
  %113 = load float, ptr %16, align 4, !tbaa !9
  %114 = fmul float 0xC0239EB860000000, %113
  %115 = load float, ptr %18, align 4, !tbaa !9
  %116 = fmul float %114, %115
  store float %116, ptr %112, align 4, !tbaa !9
  %117 = getelementptr inbounds float, ptr %20, i64 3
  %118 = load float, ptr %11, align 4, !tbaa !9
  %119 = fneg float %118
  %120 = load float, ptr %8, align 4, !tbaa !9
  %121 = fmul float %119, %120
  %122 = load float, ptr %17, align 4, !tbaa !9
  %123 = load float, ptr %9, align 4, !tbaa !9
  %124 = load float, ptr %8, align 4, !tbaa !9
  %125 = fmul float %123, %124
  %126 = load float, ptr %18, align 4, !tbaa !9
  %127 = fmul float %125, %126
  %128 = fneg float %127
  %129 = call float @llvm.fmuladd.f32(float %121, float %122, float %128)
  %130 = load float, ptr %15, align 4, !tbaa !9
  %131 = fmul float 0x40239EB860000000, %130
  %132 = load float, ptr %17, align 4, !tbaa !9
  %133 = call float @llvm.fmuladd.f32(float %131, float %132, float %129)
  store float %133, ptr %117, align 4, !tbaa !9
  %134 = getelementptr inbounds float, ptr %20, i64 4
  %135 = load float, ptr %15, align 4, !tbaa !9
  %136 = fmul float 0x40239EB860000000, %135
  %137 = load float, ptr %18, align 4, !tbaa !9
  %138 = fmul float %136, %137
  store float %138, ptr %134, align 4, !tbaa !9
  %139 = getelementptr inbounds float, ptr %20, i64 5
  %140 = load float, ptr %10, align 4, !tbaa !9
  %141 = load float, ptr %8, align 4, !tbaa !9
  %142 = load float, ptr %16, align 4, !tbaa !9
  %143 = fmul float 0x40239EB860000000, %142
  %144 = call float @llvm.fmuladd.f32(float %140, float %141, float %143)
  %145 = load float, ptr %17, align 4, !tbaa !9
  %146 = fmul float %144, %145
  store float %146, ptr %139, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 36, ptr %21) #4
  %147 = load ptr, ptr %5, align 8, !tbaa !5
  %148 = getelementptr inbounds %struct.KalmanRollPitch, ptr %147, i32 0, i32 2
  %149 = getelementptr inbounds [4 x float], ptr %148, i64 0, i64 3
  %150 = load float, ptr %149, align 4, !tbaa !9
  %151 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %152 = load float, ptr %151, align 4, !tbaa !9
  %153 = fmul float %150, %152
  %154 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %155 = load float, ptr %154, align 4, !tbaa !9
  %156 = load ptr, ptr %5, align 8, !tbaa !5
  %157 = getelementptr inbounds %struct.KalmanRollPitch, ptr %156, i32 0, i32 4
  %158 = getelementptr inbounds [3 x float], ptr %157, i64 0, i64 0
  %159 = load float, ptr %158, align 4, !tbaa !9
  %160 = call float @llvm.fmuladd.f32(float %153, float %155, float %159)
  store float %160, ptr %21, align 4, !tbaa !9
  %161 = getelementptr inbounds float, ptr %21, i64 1
  %162 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %163 = load float, ptr %162, align 4, !tbaa !9
  %164 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %165 = load float, ptr %164, align 8, !tbaa !9
  %166 = fmul float %163, %165
  %167 = load ptr, ptr %5, align 8, !tbaa !5
  %168 = getelementptr inbounds %struct.KalmanRollPitch, ptr %167, i32 0, i32 2
  %169 = getelementptr inbounds [4 x float], ptr %168, i64 0, i64 2
  %170 = load float, ptr %169, align 4, !tbaa !9
  %171 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %172 = load float, ptr %171, align 4, !tbaa !9
  %173 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %174 = load float, ptr %173, align 4, !tbaa !9
  %175 = fmul float %172, %174
  %176 = load ptr, ptr %5, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.KalmanRollPitch, ptr %176, i32 0, i32 2
  %178 = getelementptr inbounds [4 x float], ptr %177, i64 0, i64 3
  %179 = load float, ptr %178, align 4, !tbaa !9
  %180 = fmul float %175, %179
  %181 = call float @llvm.fmuladd.f32(float %166, float %170, float %180)
  store float %181, ptr %161, align 4, !tbaa !9
  %182 = getelementptr inbounds float, ptr %21, i64 2
  %183 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %184 = load float, ptr %183, align 4, !tbaa !9
  %185 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %186 = load float, ptr %185, align 16, !tbaa !9
  %187 = fmul float %184, %186
  %188 = load ptr, ptr %5, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.KalmanRollPitch, ptr %188, i32 0, i32 2
  %190 = getelementptr inbounds [4 x float], ptr %189, i64 0, i64 2
  %191 = load float, ptr %190, align 4, !tbaa !9
  %192 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %193 = load float, ptr %192, align 4, !tbaa !9
  %194 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %195 = load float, ptr %194, align 4, !tbaa !9
  %196 = fmul float %193, %195
  %197 = load ptr, ptr %5, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct.KalmanRollPitch, ptr %197, i32 0, i32 2
  %199 = getelementptr inbounds [4 x float], ptr %198, i64 0, i64 3
  %200 = load float, ptr %199, align 4, !tbaa !9
  %201 = fmul float %196, %200
  %202 = call float @llvm.fmuladd.f32(float %187, float %191, float %201)
  store float %202, ptr %182, align 4, !tbaa !9
  %203 = getelementptr inbounds float, ptr %21, i64 3
  %204 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %205 = load float, ptr %204, align 4, !tbaa !9
  %206 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %207 = load float, ptr %206, align 8, !tbaa !9
  %208 = load ptr, ptr %5, align 8, !tbaa !5
  %209 = getelementptr inbounds %struct.KalmanRollPitch, ptr %208, i32 0, i32 2
  %210 = getelementptr inbounds [4 x float], ptr %209, i64 0, i64 1
  %211 = load float, ptr %210, align 4, !tbaa !9
  %212 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %213 = load float, ptr %212, align 4, !tbaa !9
  %214 = load ptr, ptr %5, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.KalmanRollPitch, ptr %214, i32 0, i32 2
  %216 = getelementptr inbounds [4 x float], ptr %215, i64 0, i64 3
  %217 = load float, ptr %216, align 4, !tbaa !9
  %218 = fmul float %213, %217
  %219 = call float @llvm.fmuladd.f32(float %207, float %211, float %218)
  %220 = fmul float %205, %219
  store float %220, ptr %203, align 4, !tbaa !9
  %221 = getelementptr inbounds float, ptr %21, i64 4
  %222 = load ptr, ptr %5, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.KalmanRollPitch, ptr %222, i32 0, i32 4
  %224 = getelementptr inbounds [3 x float], ptr %223, i64 0, i64 1
  %225 = load float, ptr %224, align 4, !tbaa !9
  %226 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %227 = load float, ptr %226, align 8, !tbaa !9
  %228 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %229 = load float, ptr %228, align 8, !tbaa !9
  %230 = load ptr, ptr %5, align 8, !tbaa !5
  %231 = getelementptr inbounds %struct.KalmanRollPitch, ptr %230, i32 0, i32 2
  %232 = getelementptr inbounds [4 x float], ptr %231, i64 0, i64 0
  %233 = load float, ptr %232, align 4, !tbaa !9
  %234 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %235 = load float, ptr %234, align 4, !tbaa !9
  %236 = load ptr, ptr %5, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.KalmanRollPitch, ptr %236, i32 0, i32 2
  %238 = getelementptr inbounds [4 x float], ptr %237, i64 0, i64 2
  %239 = load float, ptr %238, align 4, !tbaa !9
  %240 = fmul float %235, %239
  %241 = call float @llvm.fmuladd.f32(float %229, float %233, float %240)
  %242 = call float @llvm.fmuladd.f32(float %227, float %241, float %225)
  %243 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %244 = load float, ptr %243, align 4, !tbaa !9
  %245 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %246 = load float, ptr %245, align 8, !tbaa !9
  %247 = load ptr, ptr %5, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.KalmanRollPitch, ptr %247, i32 0, i32 2
  %249 = getelementptr inbounds [4 x float], ptr %248, i64 0, i64 1
  %250 = load float, ptr %249, align 4, !tbaa !9
  %251 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %252 = load float, ptr %251, align 4, !tbaa !9
  %253 = load ptr, ptr %5, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.KalmanRollPitch, ptr %253, i32 0, i32 2
  %255 = getelementptr inbounds [4 x float], ptr %254, i64 0, i64 3
  %256 = load float, ptr %255, align 4, !tbaa !9
  %257 = fmul float %252, %256
  %258 = call float @llvm.fmuladd.f32(float %246, float %250, float %257)
  %259 = call float @llvm.fmuladd.f32(float %244, float %258, float %242)
  store float %259, ptr %221, align 4, !tbaa !9
  %260 = getelementptr inbounds float, ptr %21, i64 5
  %261 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %262 = load float, ptr %261, align 16, !tbaa !9
  %263 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %264 = load float, ptr %263, align 8, !tbaa !9
  %265 = load ptr, ptr %5, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.KalmanRollPitch, ptr %265, i32 0, i32 2
  %267 = getelementptr inbounds [4 x float], ptr %266, i64 0, i64 0
  %268 = load float, ptr %267, align 4, !tbaa !9
  %269 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %270 = load float, ptr %269, align 4, !tbaa !9
  %271 = load ptr, ptr %5, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct.KalmanRollPitch, ptr %271, i32 0, i32 2
  %273 = getelementptr inbounds [4 x float], ptr %272, i64 0, i64 2
  %274 = load float, ptr %273, align 4, !tbaa !9
  %275 = fmul float %270, %274
  %276 = call float @llvm.fmuladd.f32(float %264, float %268, float %275)
  %277 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %278 = load float, ptr %277, align 4, !tbaa !9
  %279 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %280 = load float, ptr %279, align 8, !tbaa !9
  %281 = load ptr, ptr %5, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.KalmanRollPitch, ptr %281, i32 0, i32 2
  %283 = getelementptr inbounds [4 x float], ptr %282, i64 0, i64 1
  %284 = load float, ptr %283, align 4, !tbaa !9
  %285 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %286 = load float, ptr %285, align 4, !tbaa !9
  %287 = load ptr, ptr %5, align 8, !tbaa !5
  %288 = getelementptr inbounds %struct.KalmanRollPitch, ptr %287, i32 0, i32 2
  %289 = getelementptr inbounds [4 x float], ptr %288, i64 0, i64 3
  %290 = load float, ptr %289, align 4, !tbaa !9
  %291 = fmul float %286, %290
  %292 = call float @llvm.fmuladd.f32(float %280, float %284, float %291)
  %293 = fmul float %278, %292
  %294 = call float @llvm.fmuladd.f32(float %262, float %276, float %293)
  store float %294, ptr %260, align 4, !tbaa !9
  %295 = getelementptr inbounds float, ptr %21, i64 6
  %296 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %297 = load float, ptr %296, align 4, !tbaa !9
  %298 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %299 = load float, ptr %298, align 16, !tbaa !9
  %300 = load ptr, ptr %5, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.KalmanRollPitch, ptr %300, i32 0, i32 2
  %302 = getelementptr inbounds [4 x float], ptr %301, i64 0, i64 1
  %303 = load float, ptr %302, align 4, !tbaa !9
  %304 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %305 = load float, ptr %304, align 4, !tbaa !9
  %306 = load ptr, ptr %5, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.KalmanRollPitch, ptr %306, i32 0, i32 2
  %308 = getelementptr inbounds [4 x float], ptr %307, i64 0, i64 3
  %309 = load float, ptr %308, align 4, !tbaa !9
  %310 = fmul float %305, %309
  %311 = call float @llvm.fmuladd.f32(float %299, float %303, float %310)
  %312 = fmul float %297, %311
  store float %312, ptr %295, align 4, !tbaa !9
  %313 = getelementptr inbounds float, ptr %21, i64 7
  %314 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %315 = load float, ptr %314, align 8, !tbaa !9
  %316 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %317 = load float, ptr %316, align 16, !tbaa !9
  %318 = load ptr, ptr %5, align 8, !tbaa !5
  %319 = getelementptr inbounds %struct.KalmanRollPitch, ptr %318, i32 0, i32 2
  %320 = getelementptr inbounds [4 x float], ptr %319, i64 0, i64 0
  %321 = load float, ptr %320, align 4, !tbaa !9
  %322 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %323 = load float, ptr %322, align 4, !tbaa !9
  %324 = load ptr, ptr %5, align 8, !tbaa !5
  %325 = getelementptr inbounds %struct.KalmanRollPitch, ptr %324, i32 0, i32 2
  %326 = getelementptr inbounds [4 x float], ptr %325, i64 0, i64 2
  %327 = load float, ptr %326, align 4, !tbaa !9
  %328 = fmul float %323, %327
  %329 = call float @llvm.fmuladd.f32(float %317, float %321, float %328)
  %330 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %331 = load float, ptr %330, align 4, !tbaa !9
  %332 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %333 = load float, ptr %332, align 16, !tbaa !9
  %334 = load ptr, ptr %5, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.KalmanRollPitch, ptr %334, i32 0, i32 2
  %336 = getelementptr inbounds [4 x float], ptr %335, i64 0, i64 1
  %337 = load float, ptr %336, align 4, !tbaa !9
  %338 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %339 = load float, ptr %338, align 4, !tbaa !9
  %340 = load ptr, ptr %5, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.KalmanRollPitch, ptr %340, i32 0, i32 2
  %342 = getelementptr inbounds [4 x float], ptr %341, i64 0, i64 3
  %343 = load float, ptr %342, align 4, !tbaa !9
  %344 = fmul float %339, %343
  %345 = call float @llvm.fmuladd.f32(float %333, float %337, float %344)
  %346 = fmul float %331, %345
  %347 = call float @llvm.fmuladd.f32(float %315, float %329, float %346)
  store float %347, ptr %313, align 4, !tbaa !9
  %348 = getelementptr inbounds float, ptr %21, i64 8
  %349 = load ptr, ptr %5, align 8, !tbaa !5
  %350 = getelementptr inbounds %struct.KalmanRollPitch, ptr %349, i32 0, i32 4
  %351 = getelementptr inbounds [3 x float], ptr %350, i64 0, i64 2
  %352 = load float, ptr %351, align 4, !tbaa !9
  %353 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %354 = load float, ptr %353, align 16, !tbaa !9
  %355 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %356 = load float, ptr %355, align 16, !tbaa !9
  %357 = load ptr, ptr %5, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.KalmanRollPitch, ptr %357, i32 0, i32 2
  %359 = getelementptr inbounds [4 x float], ptr %358, i64 0, i64 0
  %360 = load float, ptr %359, align 4, !tbaa !9
  %361 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %362 = load float, ptr %361, align 4, !tbaa !9
  %363 = load ptr, ptr %5, align 8, !tbaa !5
  %364 = getelementptr inbounds %struct.KalmanRollPitch, ptr %363, i32 0, i32 2
  %365 = getelementptr inbounds [4 x float], ptr %364, i64 0, i64 2
  %366 = load float, ptr %365, align 4, !tbaa !9
  %367 = fmul float %362, %366
  %368 = call float @llvm.fmuladd.f32(float %356, float %360, float %367)
  %369 = call float @llvm.fmuladd.f32(float %354, float %368, float %352)
  %370 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %371 = load float, ptr %370, align 4, !tbaa !9
  %372 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %373 = load float, ptr %372, align 16, !tbaa !9
  %374 = load ptr, ptr %5, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.KalmanRollPitch, ptr %374, i32 0, i32 2
  %376 = getelementptr inbounds [4 x float], ptr %375, i64 0, i64 1
  %377 = load float, ptr %376, align 4, !tbaa !9
  %378 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %379 = load float, ptr %378, align 4, !tbaa !9
  %380 = load ptr, ptr %5, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.KalmanRollPitch, ptr %380, i32 0, i32 2
  %382 = getelementptr inbounds [4 x float], ptr %381, i64 0, i64 3
  %383 = load float, ptr %382, align 4, !tbaa !9
  %384 = fmul float %379, %383
  %385 = call float @llvm.fmuladd.f32(float %373, float %377, float %384)
  %386 = call float @llvm.fmuladd.f32(float %371, float %385, float %369)
  store float %386, ptr %348, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #4
  %387 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %388 = load float, ptr %387, align 16, !tbaa !9
  %389 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %390 = load float, ptr %389, align 16, !tbaa !9
  %391 = fmul float %388, %390
  %392 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %393 = load float, ptr %392, align 16, !tbaa !9
  %394 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %395 = load float, ptr %394, align 16, !tbaa !9
  %396 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %397 = load float, ptr %396, align 4, !tbaa !9
  %398 = fmul float %395, %397
  %399 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %400 = load float, ptr %399, align 4, !tbaa !9
  %401 = fmul float %398, %400
  %402 = fneg float %401
  %403 = call float @llvm.fmuladd.f32(float %391, float %393, float %402)
  %404 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %405 = load float, ptr %404, align 4, !tbaa !9
  %406 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %407 = load float, ptr %406, align 4, !tbaa !9
  %408 = fmul float %405, %407
  %409 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %410 = load float, ptr %409, align 16, !tbaa !9
  %411 = fneg float %408
  %412 = call float @llvm.fmuladd.f32(float %411, float %410, float %403)
  %413 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %414 = load float, ptr %413, align 4, !tbaa !9
  %415 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %416 = load float, ptr %415, align 4, !tbaa !9
  %417 = fmul float %414, %416
  %418 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %419 = load float, ptr %418, align 8, !tbaa !9
  %420 = call float @llvm.fmuladd.f32(float %417, float %419, float %412)
  %421 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %422 = load float, ptr %421, align 8, !tbaa !9
  %423 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %424 = load float, ptr %423, align 4, !tbaa !9
  %425 = fmul float %422, %424
  %426 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %427 = load float, ptr %426, align 4, !tbaa !9
  %428 = call float @llvm.fmuladd.f32(float %425, float %427, float %420)
  %429 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %430 = load float, ptr %429, align 8, !tbaa !9
  %431 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %432 = load float, ptr %431, align 16, !tbaa !9
  %433 = fmul float %430, %432
  %434 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %435 = load float, ptr %434, align 8, !tbaa !9
  %436 = fneg float %433
  %437 = call float @llvm.fmuladd.f32(float %436, float %435, float %428)
  %438 = fdiv float 1.000000e+00, %437
  store float %438, ptr %22, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 36, ptr %23) #4
  %439 = load float, ptr %22, align 4, !tbaa !9
  %440 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %441 = load float, ptr %440, align 16, !tbaa !9
  %442 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %443 = load float, ptr %442, align 16, !tbaa !9
  %444 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %445 = load float, ptr %444, align 4, !tbaa !9
  %446 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %447 = load float, ptr %446, align 4, !tbaa !9
  %448 = fmul float %445, %447
  %449 = fneg float %448
  %450 = call float @llvm.fmuladd.f32(float %441, float %443, float %449)
  %451 = fmul float %439, %450
  store float %451, ptr %23, align 4, !tbaa !9
  %452 = getelementptr inbounds float, ptr %23, i64 1
  %453 = load float, ptr %22, align 4, !tbaa !9
  %454 = fneg float %453
  %455 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %456 = load float, ptr %455, align 4, !tbaa !9
  %457 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %458 = load float, ptr %457, align 16, !tbaa !9
  %459 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %460 = load float, ptr %459, align 8, !tbaa !9
  %461 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %462 = load float, ptr %461, align 4, !tbaa !9
  %463 = fmul float %460, %462
  %464 = fneg float %463
  %465 = call float @llvm.fmuladd.f32(float %456, float %458, float %464)
  %466 = fmul float %454, %465
  store float %466, ptr %452, align 4, !tbaa !9
  %467 = getelementptr inbounds float, ptr %23, i64 2
  %468 = load float, ptr %22, align 4, !tbaa !9
  %469 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %470 = load float, ptr %469, align 4, !tbaa !9
  %471 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %472 = load float, ptr %471, align 4, !tbaa !9
  %473 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %474 = load float, ptr %473, align 8, !tbaa !9
  %475 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %476 = load float, ptr %475, align 16, !tbaa !9
  %477 = fmul float %474, %476
  %478 = fneg float %477
  %479 = call float @llvm.fmuladd.f32(float %470, float %472, float %478)
  %480 = fmul float %468, %479
  store float %480, ptr %467, align 4, !tbaa !9
  %481 = getelementptr inbounds float, ptr %23, i64 3
  %482 = load float, ptr %22, align 4, !tbaa !9
  %483 = fneg float %482
  %484 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %485 = load float, ptr %484, align 4, !tbaa !9
  %486 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %487 = load float, ptr %486, align 16, !tbaa !9
  %488 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %489 = load float, ptr %488, align 4, !tbaa !9
  %490 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %491 = load float, ptr %490, align 8, !tbaa !9
  %492 = fmul float %489, %491
  %493 = fneg float %492
  %494 = call float @llvm.fmuladd.f32(float %485, float %487, float %493)
  %495 = fmul float %483, %494
  store float %495, ptr %481, align 4, !tbaa !9
  %496 = getelementptr inbounds float, ptr %23, i64 4
  %497 = load float, ptr %22, align 4, !tbaa !9
  %498 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %499 = load float, ptr %498, align 16, !tbaa !9
  %500 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 8
  %501 = load float, ptr %500, align 16, !tbaa !9
  %502 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %503 = load float, ptr %502, align 8, !tbaa !9
  %504 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %505 = load float, ptr %504, align 8, !tbaa !9
  %506 = fmul float %503, %505
  %507 = fneg float %506
  %508 = call float @llvm.fmuladd.f32(float %499, float %501, float %507)
  %509 = fmul float %497, %508
  store float %509, ptr %496, align 4, !tbaa !9
  %510 = getelementptr inbounds float, ptr %23, i64 5
  %511 = load float, ptr %22, align 4, !tbaa !9
  %512 = fneg float %511
  %513 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %514 = load float, ptr %513, align 16, !tbaa !9
  %515 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 5
  %516 = load float, ptr %515, align 4, !tbaa !9
  %517 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 2
  %518 = load float, ptr %517, align 8, !tbaa !9
  %519 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %520 = load float, ptr %519, align 4, !tbaa !9
  %521 = fmul float %518, %520
  %522 = fneg float %521
  %523 = call float @llvm.fmuladd.f32(float %514, float %516, float %522)
  %524 = fmul float %512, %523
  store float %524, ptr %510, align 4, !tbaa !9
  %525 = getelementptr inbounds float, ptr %23, i64 6
  %526 = load float, ptr %22, align 4, !tbaa !9
  %527 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %528 = load float, ptr %527, align 4, !tbaa !9
  %529 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %530 = load float, ptr %529, align 4, !tbaa !9
  %531 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %532 = load float, ptr %531, align 16, !tbaa !9
  %533 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %534 = load float, ptr %533, align 8, !tbaa !9
  %535 = fmul float %532, %534
  %536 = fneg float %535
  %537 = call float @llvm.fmuladd.f32(float %528, float %530, float %536)
  %538 = fmul float %526, %537
  store float %538, ptr %525, align 4, !tbaa !9
  %539 = getelementptr inbounds float, ptr %23, i64 7
  %540 = load float, ptr %22, align 4, !tbaa !9
  %541 = fneg float %540
  %542 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %543 = load float, ptr %542, align 16, !tbaa !9
  %544 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 7
  %545 = load float, ptr %544, align 4, !tbaa !9
  %546 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %547 = load float, ptr %546, align 4, !tbaa !9
  %548 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 6
  %549 = load float, ptr %548, align 8, !tbaa !9
  %550 = fmul float %547, %549
  %551 = fneg float %550
  %552 = call float @llvm.fmuladd.f32(float %543, float %545, float %551)
  %553 = fmul float %541, %552
  store float %553, ptr %539, align 4, !tbaa !9
  %554 = getelementptr inbounds float, ptr %23, i64 8
  %555 = load float, ptr %22, align 4, !tbaa !9
  %556 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 0
  %557 = load float, ptr %556, align 16, !tbaa !9
  %558 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 4
  %559 = load float, ptr %558, align 16, !tbaa !9
  %560 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 1
  %561 = load float, ptr %560, align 4, !tbaa !9
  %562 = getelementptr inbounds [9 x float], ptr %21, i64 0, i64 3
  %563 = load float, ptr %562, align 4, !tbaa !9
  %564 = fmul float %561, %563
  %565 = fneg float %564
  %566 = call float @llvm.fmuladd.f32(float %557, float %559, float %565)
  %567 = fmul float %555, %566
  store float %567, ptr %554, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 24, ptr %24) #4
  %568 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 3
  %569 = load float, ptr %568, align 4, !tbaa !9
  %570 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %571 = load float, ptr %570, align 8, !tbaa !9
  %572 = load ptr, ptr %5, align 8, !tbaa !5
  %573 = getelementptr inbounds %struct.KalmanRollPitch, ptr %572, i32 0, i32 2
  %574 = getelementptr inbounds [4 x float], ptr %573, i64 0, i64 0
  %575 = load float, ptr %574, align 4, !tbaa !9
  %576 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %577 = load float, ptr %576, align 4, !tbaa !9
  %578 = load ptr, ptr %5, align 8, !tbaa !5
  %579 = getelementptr inbounds %struct.KalmanRollPitch, ptr %578, i32 0, i32 2
  %580 = getelementptr inbounds [4 x float], ptr %579, i64 0, i64 1
  %581 = load float, ptr %580, align 4, !tbaa !9
  %582 = fmul float %577, %581
  %583 = call float @llvm.fmuladd.f32(float %571, float %575, float %582)
  %584 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 6
  %585 = load float, ptr %584, align 8, !tbaa !9
  %586 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %587 = load float, ptr %586, align 16, !tbaa !9
  %588 = load ptr, ptr %5, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.KalmanRollPitch, ptr %588, i32 0, i32 2
  %590 = getelementptr inbounds [4 x float], ptr %589, i64 0, i64 0
  %591 = load float, ptr %590, align 4, !tbaa !9
  %592 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %593 = load float, ptr %592, align 4, !tbaa !9
  %594 = load ptr, ptr %5, align 8, !tbaa !5
  %595 = getelementptr inbounds %struct.KalmanRollPitch, ptr %594, i32 0, i32 2
  %596 = getelementptr inbounds [4 x float], ptr %595, i64 0, i64 1
  %597 = load float, ptr %596, align 4, !tbaa !9
  %598 = fmul float %593, %597
  %599 = call float @llvm.fmuladd.f32(float %587, float %591, float %598)
  %600 = fmul float %585, %599
  %601 = call float @llvm.fmuladd.f32(float %569, float %583, float %600)
  %602 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %603 = load float, ptr %602, align 4, !tbaa !9
  %604 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 0
  %605 = load float, ptr %604, align 16, !tbaa !9
  %606 = fmul float %603, %605
  %607 = load ptr, ptr %5, align 8, !tbaa !5
  %608 = getelementptr inbounds %struct.KalmanRollPitch, ptr %607, i32 0, i32 2
  %609 = getelementptr inbounds [4 x float], ptr %608, i64 0, i64 1
  %610 = load float, ptr %609, align 4, !tbaa !9
  %611 = call float @llvm.fmuladd.f32(float %606, float %610, float %601)
  store float %611, ptr %24, align 4, !tbaa !9
  %612 = getelementptr inbounds float, ptr %24, i64 1
  %613 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 4
  %614 = load float, ptr %613, align 16, !tbaa !9
  %615 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %616 = load float, ptr %615, align 8, !tbaa !9
  %617 = load ptr, ptr %5, align 8, !tbaa !5
  %618 = getelementptr inbounds %struct.KalmanRollPitch, ptr %617, i32 0, i32 2
  %619 = getelementptr inbounds [4 x float], ptr %618, i64 0, i64 0
  %620 = load float, ptr %619, align 4, !tbaa !9
  %621 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %622 = load float, ptr %621, align 4, !tbaa !9
  %623 = load ptr, ptr %5, align 8, !tbaa !5
  %624 = getelementptr inbounds %struct.KalmanRollPitch, ptr %623, i32 0, i32 2
  %625 = getelementptr inbounds [4 x float], ptr %624, i64 0, i64 1
  %626 = load float, ptr %625, align 4, !tbaa !9
  %627 = fmul float %622, %626
  %628 = call float @llvm.fmuladd.f32(float %616, float %620, float %627)
  %629 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 7
  %630 = load float, ptr %629, align 4, !tbaa !9
  %631 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %632 = load float, ptr %631, align 16, !tbaa !9
  %633 = load ptr, ptr %5, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.KalmanRollPitch, ptr %633, i32 0, i32 2
  %635 = getelementptr inbounds [4 x float], ptr %634, i64 0, i64 0
  %636 = load float, ptr %635, align 4, !tbaa !9
  %637 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %638 = load float, ptr %637, align 4, !tbaa !9
  %639 = load ptr, ptr %5, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.KalmanRollPitch, ptr %639, i32 0, i32 2
  %641 = getelementptr inbounds [4 x float], ptr %640, i64 0, i64 1
  %642 = load float, ptr %641, align 4, !tbaa !9
  %643 = fmul float %638, %642
  %644 = call float @llvm.fmuladd.f32(float %632, float %636, float %643)
  %645 = fmul float %630, %644
  %646 = call float @llvm.fmuladd.f32(float %614, float %628, float %645)
  %647 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %648 = load float, ptr %647, align 4, !tbaa !9
  %649 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 1
  %650 = load float, ptr %649, align 4, !tbaa !9
  %651 = fmul float %648, %650
  %652 = load ptr, ptr %5, align 8, !tbaa !5
  %653 = getelementptr inbounds %struct.KalmanRollPitch, ptr %652, i32 0, i32 2
  %654 = getelementptr inbounds [4 x float], ptr %653, i64 0, i64 1
  %655 = load float, ptr %654, align 4, !tbaa !9
  %656 = call float @llvm.fmuladd.f32(float %651, float %655, float %646)
  store float %656, ptr %612, align 4, !tbaa !9
  %657 = getelementptr inbounds float, ptr %24, i64 2
  %658 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 5
  %659 = load float, ptr %658, align 4, !tbaa !9
  %660 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %661 = load float, ptr %660, align 8, !tbaa !9
  %662 = load ptr, ptr %5, align 8, !tbaa !5
  %663 = getelementptr inbounds %struct.KalmanRollPitch, ptr %662, i32 0, i32 2
  %664 = getelementptr inbounds [4 x float], ptr %663, i64 0, i64 0
  %665 = load float, ptr %664, align 4, !tbaa !9
  %666 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %667 = load float, ptr %666, align 4, !tbaa !9
  %668 = load ptr, ptr %5, align 8, !tbaa !5
  %669 = getelementptr inbounds %struct.KalmanRollPitch, ptr %668, i32 0, i32 2
  %670 = getelementptr inbounds [4 x float], ptr %669, i64 0, i64 1
  %671 = load float, ptr %670, align 4, !tbaa !9
  %672 = fmul float %667, %671
  %673 = call float @llvm.fmuladd.f32(float %661, float %665, float %672)
  %674 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 8
  %675 = load float, ptr %674, align 16, !tbaa !9
  %676 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %677 = load float, ptr %676, align 16, !tbaa !9
  %678 = load ptr, ptr %5, align 8, !tbaa !5
  %679 = getelementptr inbounds %struct.KalmanRollPitch, ptr %678, i32 0, i32 2
  %680 = getelementptr inbounds [4 x float], ptr %679, i64 0, i64 0
  %681 = load float, ptr %680, align 4, !tbaa !9
  %682 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %683 = load float, ptr %682, align 4, !tbaa !9
  %684 = load ptr, ptr %5, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.KalmanRollPitch, ptr %684, i32 0, i32 2
  %686 = getelementptr inbounds [4 x float], ptr %685, i64 0, i64 1
  %687 = load float, ptr %686, align 4, !tbaa !9
  %688 = fmul float %683, %687
  %689 = call float @llvm.fmuladd.f32(float %677, float %681, float %688)
  %690 = fmul float %675, %689
  %691 = call float @llvm.fmuladd.f32(float %659, float %673, float %690)
  %692 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %693 = load float, ptr %692, align 4, !tbaa !9
  %694 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 2
  %695 = load float, ptr %694, align 8, !tbaa !9
  %696 = fmul float %693, %695
  %697 = load ptr, ptr %5, align 8, !tbaa !5
  %698 = getelementptr inbounds %struct.KalmanRollPitch, ptr %697, i32 0, i32 2
  %699 = getelementptr inbounds [4 x float], ptr %698, i64 0, i64 1
  %700 = load float, ptr %699, align 4, !tbaa !9
  %701 = call float @llvm.fmuladd.f32(float %696, float %700, float %691)
  store float %701, ptr %657, align 4, !tbaa !9
  %702 = getelementptr inbounds float, ptr %24, i64 3
  %703 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 3
  %704 = load float, ptr %703, align 4, !tbaa !9
  %705 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %706 = load float, ptr %705, align 8, !tbaa !9
  %707 = load ptr, ptr %5, align 8, !tbaa !5
  %708 = getelementptr inbounds %struct.KalmanRollPitch, ptr %707, i32 0, i32 2
  %709 = getelementptr inbounds [4 x float], ptr %708, i64 0, i64 2
  %710 = load float, ptr %709, align 4, !tbaa !9
  %711 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %712 = load float, ptr %711, align 4, !tbaa !9
  %713 = load ptr, ptr %5, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.KalmanRollPitch, ptr %713, i32 0, i32 2
  %715 = getelementptr inbounds [4 x float], ptr %714, i64 0, i64 3
  %716 = load float, ptr %715, align 4, !tbaa !9
  %717 = fmul float %712, %716
  %718 = call float @llvm.fmuladd.f32(float %706, float %710, float %717)
  %719 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 6
  %720 = load float, ptr %719, align 8, !tbaa !9
  %721 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %722 = load float, ptr %721, align 16, !tbaa !9
  %723 = load ptr, ptr %5, align 8, !tbaa !5
  %724 = getelementptr inbounds %struct.KalmanRollPitch, ptr %723, i32 0, i32 2
  %725 = getelementptr inbounds [4 x float], ptr %724, i64 0, i64 2
  %726 = load float, ptr %725, align 4, !tbaa !9
  %727 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %728 = load float, ptr %727, align 4, !tbaa !9
  %729 = load ptr, ptr %5, align 8, !tbaa !5
  %730 = getelementptr inbounds %struct.KalmanRollPitch, ptr %729, i32 0, i32 2
  %731 = getelementptr inbounds [4 x float], ptr %730, i64 0, i64 3
  %732 = load float, ptr %731, align 4, !tbaa !9
  %733 = fmul float %728, %732
  %734 = call float @llvm.fmuladd.f32(float %722, float %726, float %733)
  %735 = fmul float %720, %734
  %736 = call float @llvm.fmuladd.f32(float %704, float %718, float %735)
  %737 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %738 = load float, ptr %737, align 4, !tbaa !9
  %739 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 0
  %740 = load float, ptr %739, align 16, !tbaa !9
  %741 = fmul float %738, %740
  %742 = load ptr, ptr %5, align 8, !tbaa !5
  %743 = getelementptr inbounds %struct.KalmanRollPitch, ptr %742, i32 0, i32 2
  %744 = getelementptr inbounds [4 x float], ptr %743, i64 0, i64 3
  %745 = load float, ptr %744, align 4, !tbaa !9
  %746 = call float @llvm.fmuladd.f32(float %741, float %745, float %736)
  store float %746, ptr %702, align 4, !tbaa !9
  %747 = getelementptr inbounds float, ptr %24, i64 4
  %748 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 4
  %749 = load float, ptr %748, align 16, !tbaa !9
  %750 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %751 = load float, ptr %750, align 8, !tbaa !9
  %752 = load ptr, ptr %5, align 8, !tbaa !5
  %753 = getelementptr inbounds %struct.KalmanRollPitch, ptr %752, i32 0, i32 2
  %754 = getelementptr inbounds [4 x float], ptr %753, i64 0, i64 2
  %755 = load float, ptr %754, align 4, !tbaa !9
  %756 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %757 = load float, ptr %756, align 4, !tbaa !9
  %758 = load ptr, ptr %5, align 8, !tbaa !5
  %759 = getelementptr inbounds %struct.KalmanRollPitch, ptr %758, i32 0, i32 2
  %760 = getelementptr inbounds [4 x float], ptr %759, i64 0, i64 3
  %761 = load float, ptr %760, align 4, !tbaa !9
  %762 = fmul float %757, %761
  %763 = call float @llvm.fmuladd.f32(float %751, float %755, float %762)
  %764 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 7
  %765 = load float, ptr %764, align 4, !tbaa !9
  %766 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %767 = load float, ptr %766, align 16, !tbaa !9
  %768 = load ptr, ptr %5, align 8, !tbaa !5
  %769 = getelementptr inbounds %struct.KalmanRollPitch, ptr %768, i32 0, i32 2
  %770 = getelementptr inbounds [4 x float], ptr %769, i64 0, i64 2
  %771 = load float, ptr %770, align 4, !tbaa !9
  %772 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %773 = load float, ptr %772, align 4, !tbaa !9
  %774 = load ptr, ptr %5, align 8, !tbaa !5
  %775 = getelementptr inbounds %struct.KalmanRollPitch, ptr %774, i32 0, i32 2
  %776 = getelementptr inbounds [4 x float], ptr %775, i64 0, i64 3
  %777 = load float, ptr %776, align 4, !tbaa !9
  %778 = fmul float %773, %777
  %779 = call float @llvm.fmuladd.f32(float %767, float %771, float %778)
  %780 = fmul float %765, %779
  %781 = call float @llvm.fmuladd.f32(float %749, float %763, float %780)
  %782 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %783 = load float, ptr %782, align 4, !tbaa !9
  %784 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 1
  %785 = load float, ptr %784, align 4, !tbaa !9
  %786 = fmul float %783, %785
  %787 = load ptr, ptr %5, align 8, !tbaa !5
  %788 = getelementptr inbounds %struct.KalmanRollPitch, ptr %787, i32 0, i32 2
  %789 = getelementptr inbounds [4 x float], ptr %788, i64 0, i64 3
  %790 = load float, ptr %789, align 4, !tbaa !9
  %791 = call float @llvm.fmuladd.f32(float %786, float %790, float %781)
  store float %791, ptr %747, align 4, !tbaa !9
  %792 = getelementptr inbounds float, ptr %24, i64 5
  %793 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 5
  %794 = load float, ptr %793, align 4, !tbaa !9
  %795 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %796 = load float, ptr %795, align 8, !tbaa !9
  %797 = load ptr, ptr %5, align 8, !tbaa !5
  %798 = getelementptr inbounds %struct.KalmanRollPitch, ptr %797, i32 0, i32 2
  %799 = getelementptr inbounds [4 x float], ptr %798, i64 0, i64 2
  %800 = load float, ptr %799, align 4, !tbaa !9
  %801 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %802 = load float, ptr %801, align 4, !tbaa !9
  %803 = load ptr, ptr %5, align 8, !tbaa !5
  %804 = getelementptr inbounds %struct.KalmanRollPitch, ptr %803, i32 0, i32 2
  %805 = getelementptr inbounds [4 x float], ptr %804, i64 0, i64 3
  %806 = load float, ptr %805, align 4, !tbaa !9
  %807 = fmul float %802, %806
  %808 = call float @llvm.fmuladd.f32(float %796, float %800, float %807)
  %809 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 8
  %810 = load float, ptr %809, align 16, !tbaa !9
  %811 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %812 = load float, ptr %811, align 16, !tbaa !9
  %813 = load ptr, ptr %5, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.KalmanRollPitch, ptr %813, i32 0, i32 2
  %815 = getelementptr inbounds [4 x float], ptr %814, i64 0, i64 2
  %816 = load float, ptr %815, align 4, !tbaa !9
  %817 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %818 = load float, ptr %817, align 4, !tbaa !9
  %819 = load ptr, ptr %5, align 8, !tbaa !5
  %820 = getelementptr inbounds %struct.KalmanRollPitch, ptr %819, i32 0, i32 2
  %821 = getelementptr inbounds [4 x float], ptr %820, i64 0, i64 3
  %822 = load float, ptr %821, align 4, !tbaa !9
  %823 = fmul float %818, %822
  %824 = call float @llvm.fmuladd.f32(float %812, float %816, float %823)
  %825 = fmul float %810, %824
  %826 = call float @llvm.fmuladd.f32(float %794, float %808, float %825)
  %827 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %828 = load float, ptr %827, align 4, !tbaa !9
  %829 = getelementptr inbounds [9 x float], ptr %23, i64 0, i64 2
  %830 = load float, ptr %829, align 8, !tbaa !9
  %831 = fmul float %828, %830
  %832 = load ptr, ptr %5, align 8, !tbaa !5
  %833 = getelementptr inbounds %struct.KalmanRollPitch, ptr %832, i32 0, i32 2
  %834 = getelementptr inbounds [4 x float], ptr %833, i64 0, i64 3
  %835 = load float, ptr %834, align 4, !tbaa !9
  %836 = call float @llvm.fmuladd.f32(float %831, float %835, float %826)
  store float %836, ptr %792, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 16, ptr %25) #4
  %837 = load ptr, ptr %5, align 8, !tbaa !5
  %838 = getelementptr inbounds %struct.KalmanRollPitch, ptr %837, i32 0, i32 2
  %839 = getelementptr inbounds [4 x float], ptr %838, i64 0, i64 2
  %840 = load float, ptr %839, align 4, !tbaa !9
  %841 = fneg float %840
  %842 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %843 = load float, ptr %842, align 4, !tbaa !9
  %844 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 0
  %845 = load float, ptr %844, align 16, !tbaa !9
  %846 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %847 = load float, ptr %846, align 4, !tbaa !9
  %848 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 1
  %849 = load float, ptr %848, align 4, !tbaa !9
  %850 = fmul float %847, %849
  %851 = call float @llvm.fmuladd.f32(float %843, float %845, float %850)
  %852 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %853 = load float, ptr %852, align 4, !tbaa !9
  %854 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 2
  %855 = load float, ptr %854, align 8, !tbaa !9
  %856 = call float @llvm.fmuladd.f32(float %853, float %855, float %851)
  %857 = load ptr, ptr %5, align 8, !tbaa !5
  %858 = getelementptr inbounds %struct.KalmanRollPitch, ptr %857, i32 0, i32 2
  %859 = getelementptr inbounds [4 x float], ptr %858, i64 0, i64 0
  %860 = load float, ptr %859, align 4, !tbaa !9
  %861 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %862 = load float, ptr %861, align 8, !tbaa !9
  %863 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 1
  %864 = load float, ptr %863, align 4, !tbaa !9
  %865 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %866 = load float, ptr %865, align 16, !tbaa !9
  %867 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 2
  %868 = load float, ptr %867, align 8, !tbaa !9
  %869 = fmul float %866, %868
  %870 = call float @llvm.fmuladd.f32(float %862, float %864, float %869)
  %871 = fsub float %870, 1.000000e+00
  %872 = fmul float %860, %871
  %873 = fneg float %872
  %874 = call float @llvm.fmuladd.f32(float %841, float %856, float %873)
  %875 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 0
  store float %874, ptr %875, align 16, !tbaa !9
  %876 = load ptr, ptr %5, align 8, !tbaa !5
  %877 = getelementptr inbounds %struct.KalmanRollPitch, ptr %876, i32 0, i32 2
  %878 = getelementptr inbounds [4 x float], ptr %877, i64 0, i64 3
  %879 = load float, ptr %878, align 4, !tbaa !9
  %880 = fneg float %879
  %881 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %882 = load float, ptr %881, align 4, !tbaa !9
  %883 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 0
  %884 = load float, ptr %883, align 16, !tbaa !9
  %885 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %886 = load float, ptr %885, align 4, !tbaa !9
  %887 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 1
  %888 = load float, ptr %887, align 4, !tbaa !9
  %889 = fmul float %886, %888
  %890 = call float @llvm.fmuladd.f32(float %882, float %884, float %889)
  %891 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %892 = load float, ptr %891, align 4, !tbaa !9
  %893 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 2
  %894 = load float, ptr %893, align 8, !tbaa !9
  %895 = call float @llvm.fmuladd.f32(float %892, float %894, float %890)
  %896 = load ptr, ptr %5, align 8, !tbaa !5
  %897 = getelementptr inbounds %struct.KalmanRollPitch, ptr %896, i32 0, i32 2
  %898 = getelementptr inbounds [4 x float], ptr %897, i64 0, i64 1
  %899 = load float, ptr %898, align 4, !tbaa !9
  %900 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %901 = load float, ptr %900, align 8, !tbaa !9
  %902 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 1
  %903 = load float, ptr %902, align 4, !tbaa !9
  %904 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %905 = load float, ptr %904, align 16, !tbaa !9
  %906 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 2
  %907 = load float, ptr %906, align 8, !tbaa !9
  %908 = fmul float %905, %907
  %909 = call float @llvm.fmuladd.f32(float %901, float %903, float %908)
  %910 = fsub float %909, 1.000000e+00
  %911 = fmul float %899, %910
  %912 = fneg float %911
  %913 = call float @llvm.fmuladd.f32(float %880, float %895, float %912)
  %914 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 1
  store float %913, ptr %914, align 4, !tbaa !9
  %915 = load ptr, ptr %5, align 8, !tbaa !5
  %916 = getelementptr inbounds %struct.KalmanRollPitch, ptr %915, i32 0, i32 2
  %917 = getelementptr inbounds [4 x float], ptr %916, i64 0, i64 2
  %918 = load float, ptr %917, align 4, !tbaa !9
  %919 = fneg float %918
  %920 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %921 = load float, ptr %920, align 4, !tbaa !9
  %922 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 3
  %923 = load float, ptr %922, align 4, !tbaa !9
  %924 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %925 = load float, ptr %924, align 4, !tbaa !9
  %926 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 4
  %927 = load float, ptr %926, align 16, !tbaa !9
  %928 = fmul float %925, %927
  %929 = call float @llvm.fmuladd.f32(float %921, float %923, float %928)
  %930 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %931 = load float, ptr %930, align 4, !tbaa !9
  %932 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 5
  %933 = load float, ptr %932, align 4, !tbaa !9
  %934 = call float @llvm.fmuladd.f32(float %931, float %933, float %929)
  %935 = fsub float %934, 1.000000e+00
  %936 = load ptr, ptr %5, align 8, !tbaa !5
  %937 = getelementptr inbounds %struct.KalmanRollPitch, ptr %936, i32 0, i32 2
  %938 = getelementptr inbounds [4 x float], ptr %937, i64 0, i64 0
  %939 = load float, ptr %938, align 4, !tbaa !9
  %940 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %941 = load float, ptr %940, align 8, !tbaa !9
  %942 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 4
  %943 = load float, ptr %942, align 16, !tbaa !9
  %944 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %945 = load float, ptr %944, align 16, !tbaa !9
  %946 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 5
  %947 = load float, ptr %946, align 4, !tbaa !9
  %948 = fmul float %945, %947
  %949 = call float @llvm.fmuladd.f32(float %941, float %943, float %948)
  %950 = fmul float %939, %949
  %951 = fneg float %950
  %952 = call float @llvm.fmuladd.f32(float %919, float %935, float %951)
  %953 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 2
  store float %952, ptr %953, align 8, !tbaa !9
  %954 = load ptr, ptr %5, align 8, !tbaa !5
  %955 = getelementptr inbounds %struct.KalmanRollPitch, ptr %954, i32 0, i32 2
  %956 = getelementptr inbounds [4 x float], ptr %955, i64 0, i64 3
  %957 = load float, ptr %956, align 4, !tbaa !9
  %958 = fneg float %957
  %959 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 1
  %960 = load float, ptr %959, align 4, !tbaa !9
  %961 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 3
  %962 = load float, ptr %961, align 4, !tbaa !9
  %963 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 3
  %964 = load float, ptr %963, align 4, !tbaa !9
  %965 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 4
  %966 = load float, ptr %965, align 16, !tbaa !9
  %967 = fmul float %964, %966
  %968 = call float @llvm.fmuladd.f32(float %960, float %962, float %967)
  %969 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 5
  %970 = load float, ptr %969, align 4, !tbaa !9
  %971 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 5
  %972 = load float, ptr %971, align 4, !tbaa !9
  %973 = call float @llvm.fmuladd.f32(float %970, float %972, float %968)
  %974 = fsub float %973, 1.000000e+00
  %975 = load ptr, ptr %5, align 8, !tbaa !5
  %976 = getelementptr inbounds %struct.KalmanRollPitch, ptr %975, i32 0, i32 2
  %977 = getelementptr inbounds [4 x float], ptr %976, i64 0, i64 1
  %978 = load float, ptr %977, align 4, !tbaa !9
  %979 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 2
  %980 = load float, ptr %979, align 8, !tbaa !9
  %981 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 4
  %982 = load float, ptr %981, align 16, !tbaa !9
  %983 = getelementptr inbounds [6 x float], ptr %20, i64 0, i64 4
  %984 = load float, ptr %983, align 16, !tbaa !9
  %985 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 5
  %986 = load float, ptr %985, align 4, !tbaa !9
  %987 = fmul float %984, %986
  %988 = call float @llvm.fmuladd.f32(float %980, float %982, float %987)
  %989 = fmul float %978, %988
  %990 = fneg float %989
  %991 = call float @llvm.fmuladd.f32(float %958, float %974, float %990)
  %992 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 3
  store float %991, ptr %992, align 4, !tbaa !9
  %993 = load ptr, ptr %5, align 8, !tbaa !5
  %994 = getelementptr inbounds %struct.KalmanRollPitch, ptr %993, i32 0, i32 2
  %995 = getelementptr inbounds [4 x float], ptr %994, i64 0, i64 0
  %996 = load float, ptr %995, align 4, !tbaa !9
  %997 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 0
  %998 = load float, ptr %997, align 16, !tbaa !9
  %999 = fadd float %996, %998
  %1000 = load ptr, ptr %5, align 8, !tbaa !5
  %1001 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1000, i32 0, i32 2
  %1002 = getelementptr inbounds [4 x float], ptr %1001, i64 0, i64 0
  store float %999, ptr %1002, align 4, !tbaa !9
  %1003 = load ptr, ptr %5, align 8, !tbaa !5
  %1004 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1003, i32 0, i32 2
  %1005 = getelementptr inbounds [4 x float], ptr %1004, i64 0, i64 1
  %1006 = load float, ptr %1005, align 4, !tbaa !9
  %1007 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 1
  %1008 = load float, ptr %1007, align 4, !tbaa !9
  %1009 = fadd float %1006, %1008
  %1010 = load ptr, ptr %5, align 8, !tbaa !5
  %1011 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1010, i32 0, i32 2
  %1012 = getelementptr inbounds [4 x float], ptr %1011, i64 0, i64 1
  store float %1009, ptr %1012, align 4, !tbaa !9
  %1013 = load ptr, ptr %5, align 8, !tbaa !5
  %1014 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1013, i32 0, i32 2
  %1015 = getelementptr inbounds [4 x float], ptr %1014, i64 0, i64 2
  %1016 = load float, ptr %1015, align 4, !tbaa !9
  %1017 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 2
  %1018 = load float, ptr %1017, align 8, !tbaa !9
  %1019 = fadd float %1016, %1018
  %1020 = load ptr, ptr %5, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1020, i32 0, i32 2
  %1022 = getelementptr inbounds [4 x float], ptr %1021, i64 0, i64 2
  store float %1019, ptr %1022, align 4, !tbaa !9
  %1023 = load ptr, ptr %5, align 8, !tbaa !5
  %1024 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1023, i32 0, i32 2
  %1025 = getelementptr inbounds [4 x float], ptr %1024, i64 0, i64 3
  %1026 = load float, ptr %1025, align 4, !tbaa !9
  %1027 = getelementptr inbounds [4 x float], ptr %25, i64 0, i64 3
  %1028 = load float, ptr %1027, align 4, !tbaa !9
  %1029 = fadd float %1026, %1028
  %1030 = load ptr, ptr %5, align 8, !tbaa !5
  %1031 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1030, i32 0, i32 2
  %1032 = getelementptr inbounds [4 x float], ptr %1031, i64 0, i64 3
  store float %1029, ptr %1032, align 4, !tbaa !9
  %1033 = load ptr, ptr %5, align 8, !tbaa !5
  %1034 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1033, i32 0, i32 0
  %1035 = load float, ptr %1034, align 4, !tbaa !11
  %1036 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 0
  %1037 = load float, ptr %1036, align 16, !tbaa !9
  %1038 = load float, ptr %12, align 4, !tbaa !9
  %1039 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 0
  %1040 = load float, ptr %1039, align 4, !tbaa !9
  %1041 = fsub float %1038, %1040
  %1042 = call float @llvm.fmuladd.f32(float %1037, float %1041, float %1035)
  %1043 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 1
  %1044 = load float, ptr %1043, align 4, !tbaa !9
  %1045 = load float, ptr %13, align 4, !tbaa !9
  %1046 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 1
  %1047 = load float, ptr %1046, align 4, !tbaa !9
  %1048 = fsub float %1045, %1047
  %1049 = call float @llvm.fmuladd.f32(float %1044, float %1048, float %1042)
  %1050 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 2
  %1051 = load float, ptr %1050, align 8, !tbaa !9
  %1052 = load float, ptr %14, align 4, !tbaa !9
  %1053 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 2
  %1054 = load float, ptr %1053, align 4, !tbaa !9
  %1055 = fsub float %1052, %1054
  %1056 = call float @llvm.fmuladd.f32(float %1051, float %1055, float %1049)
  %1057 = load ptr, ptr %5, align 8, !tbaa !5
  %1058 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1057, i32 0, i32 0
  store float %1056, ptr %1058, align 4, !tbaa !11
  %1059 = load ptr, ptr %5, align 8, !tbaa !5
  %1060 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1059, i32 0, i32 1
  %1061 = load float, ptr %1060, align 4, !tbaa !13
  %1062 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 3
  %1063 = load float, ptr %1062, align 4, !tbaa !9
  %1064 = load float, ptr %12, align 4, !tbaa !9
  %1065 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 0
  %1066 = load float, ptr %1065, align 4, !tbaa !9
  %1067 = fsub float %1064, %1066
  %1068 = call float @llvm.fmuladd.f32(float %1063, float %1067, float %1061)
  %1069 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 4
  %1070 = load float, ptr %1069, align 16, !tbaa !9
  %1071 = load float, ptr %13, align 4, !tbaa !9
  %1072 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 1
  %1073 = load float, ptr %1072, align 4, !tbaa !9
  %1074 = fsub float %1071, %1073
  %1075 = call float @llvm.fmuladd.f32(float %1070, float %1074, float %1068)
  %1076 = getelementptr inbounds [6 x float], ptr %24, i64 0, i64 5
  %1077 = load float, ptr %1076, align 4, !tbaa !9
  %1078 = load float, ptr %14, align 4, !tbaa !9
  %1079 = getelementptr inbounds [3 x float], ptr %19, i64 0, i64 2
  %1080 = load float, ptr %1079, align 4, !tbaa !9
  %1081 = fsub float %1078, %1080
  %1082 = call float @llvm.fmuladd.f32(float %1077, float %1081, float %1075)
  %1083 = load ptr, ptr %5, align 8, !tbaa !5
  %1084 = getelementptr inbounds %struct.KalmanRollPitch, ptr %1083, i32 0, i32 1
  store float %1082, ptr %1084, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 16, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 24, ptr %24) #4
  call void @llvm.lifetime.end.p0(i64 36, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 36, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 24, ptr %20) #4
  call void @llvm.lifetime.end.p0(i64 12, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #4
  ret void
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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 #4 = { 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 = !{!"float", !7, i64 0}
!11 = !{!12, !10, i64 0}
!12 = !{!"", !10, i64 0, !10, i64 4, !7, i64 8, !7, i64 24, !7, i64 32}
!13 = !{!12, !10, i64 4}


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

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

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

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

; Function Attrs: mustprogress nofree nounwind willreturn memory(write, argmem: readwrite) uwtable
define dso_local void @KalmanRollPitch_UpdateMeasurement(ptr nocapture noundef %0, ptr nocapture noundef readonly %1, ptr nocapture noundef readonly %2, float noundef %3) local_unnamed_addr #2 {
  %5 = load float, ptr %1, align 4, !tbaa !5
  %6 = getelementptr inbounds i8, ptr %1, i64 4
  %7 = load float, ptr %6, align 4, !tbaa !5
  %8 = getelementptr inbounds i8, ptr %1, i64 8
  %9 = load float, ptr %8, align 4, !tbaa !5
  %10 = load float, ptr %2, align 4, !tbaa !5
  %11 = getelementptr inbounds i8, ptr %2, i64 4
  %12 = load float, ptr %11, align 4, !tbaa !5
  %13 = getelementptr inbounds i8, ptr %2, i64 8
  %14 = load float, ptr %13, align 4, !tbaa !5
  %15 = load float, ptr %0, align 4, !tbaa !9
  %16 = fpext float %15 to double
  %17 = tail call double @sin(double noundef %16) #4
  %18 = fptrunc double %17 to float
  %19 = load float, ptr %0, align 4, !tbaa !9
  %20 = fpext float %19 to double
  %21 = tail call double @cos(double noundef %20) #4
  %22 = fptrunc double %21 to float
  %23 = getelementptr inbounds i8, ptr %0, i64 4
  %24 = load float, ptr %23, align 4, !tbaa !11
  %25 = fpext float %24 to double
  %26 = tail call double @sin(double noundef %25) #4
  %27 = fptrunc double %26 to float
  %28 = load float, ptr %23, align 4, !tbaa !11
  %29 = fpext float %28 to double
  %30 = tail call double @cos(double noundef %29) #4
  %31 = fptrunc double %30 to float
  %32 = fmul float %7, %3
  %33 = fmul float %27, 0x40239EB860000000
  %34 = tail call float @llvm.fmuladd.f32(float %32, float %27, float %33)
  %35 = fmul float %9, %3
  %36 = fneg float %5
  %37 = fmul float %36, %3
  %38 = fmul float %37, %27
  %39 = tail call float @llvm.fmuladd.f32(float %35, float %31, float %38)
  %40 = fmul float %31, 0x40239EB860000000
  %41 = fneg float %40
  %42 = tail call float @llvm.fmuladd.f32(float %41, float %18, float %39)
  %43 = fneg float %7
  %44 = fmul float %43, %3
  %45 = fmul float %22, %41
  %46 = tail call float @llvm.fmuladd.f32(float %44, float %31, float %45)
  %47 = tail call float @llvm.fmuladd.f32(float %32, float %31, float %40)
  %48 = fmul float %22, 0xC0239EB860000000
  %49 = fmul float %48, %31
  %50 = fneg float %9
  %51 = fmul float %50, %3
  %52 = fmul float %37, %31
  %53 = tail call float @llvm.fmuladd.f32(float %51, float %27, float %52)
  %54 = fmul float %18, 0x40239EB860000000
  %55 = tail call float @llvm.fmuladd.f32(float %54, float %27, float %53)
  %56 = fmul float %54, %31
  %57 = fmul float %22, 0x40239EB860000000
  %58 = tail call float @llvm.fmuladd.f32(float %7, float %3, float %57)
  %59 = fmul float %58, %27
  %60 = getelementptr inbounds i8, ptr %0, i64 8
  %61 = getelementptr inbounds i8, ptr %0, i64 32
  %62 = load float, ptr %61, align 4, !tbaa !5
  %63 = fmul float %49, %47
  %64 = fmul float %47, %55
  %65 = fmul float %56, %47
  %66 = fmul float %59, %47
  %67 = getelementptr inbounds i8, ptr %0, i64 36
  %68 = load float, ptr %67, align 4, !tbaa !5
  %69 = getelementptr inbounds i8, ptr %0, i64 40
  %70 = load float, ptr %69, align 4, !tbaa !5
  %71 = load <4 x float>, ptr %60, align 4, !tbaa !5
  %72 = extractelement <4 x float> %71, i64 3
  %73 = fmul float %72, %47
  %74 = tail call float @llvm.fmuladd.f32(float %73, float %47, float %62)
  %75 = fmul float %72, %64
  %76 = extractelement <4 x float> %71, i64 2
  %77 = tail call float @llvm.fmuladd.f32(float %63, float %76, float %75)
  %78 = fmul float %72, %66
  %79 = tail call float @llvm.fmuladd.f32(float %65, float %76, float %78)
  %80 = extractelement <4 x float> %71, i64 1
  %81 = fmul float %76, %55
  %82 = extractelement <4 x float> %71, i64 0
  %83 = tail call float @llvm.fmuladd.f32(float %49, float %82, float %81)
  %84 = tail call float @llvm.fmuladd.f32(float %49, float %83, float %68)
  %85 = fmul float %59, %76
  %86 = tail call float @llvm.fmuladd.f32(float %56, float %82, float %85)
  %87 = tail call float @llvm.fmuladd.f32(float %56, float %86, float %70)
  %88 = fneg float %74
  %89 = fneg float %77
  %90 = fneg float %79
  %91 = shufflevector <4 x float> %71, <4 x float> poison, <2 x i32> <i32 2, i32 3>
  %92 = shufflevector <2 x float> %91, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  %93 = fneg <4 x float> %92
  %94 = shufflevector <4 x float> %71, <4 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
  %95 = fneg <4 x float> %94
  %96 = fsub float %10, %34
  %97 = fsub float %12, %42
  %98 = fsub float %14, %46
  %99 = insertelement <2 x float> poison, float %55, i64 0
  %100 = shufflevector <2 x float> %99, <2 x float> poison, <2 x i32> zeroinitializer
  %101 = shufflevector <4 x float> %71, <4 x float> poison, <2 x i32> <i32 1, i32 3>
  %102 = fmul <2 x float> %100, %101
  %103 = extractelement <2 x float> %102, i64 1
  %104 = tail call float @llvm.fmuladd.f32(float %49, float %80, float %103)
  %105 = fmul float %47, %104
  %106 = tail call float @llvm.fmuladd.f32(float %55, float %104, float %84)
  %107 = fmul float %59, %104
  %108 = tail call float @llvm.fmuladd.f32(float %56, float %83, float %107)
  %109 = insertelement <2 x float> poison, float %59, i64 0
  %110 = shufflevector <2 x float> %109, <2 x float> poison, <2 x i32> zeroinitializer
  %111 = fmul <2 x float> %110, %101
  %112 = extractelement <2 x float> %111, i64 1
  %113 = tail call float @llvm.fmuladd.f32(float %56, float %80, float %112)
  %114 = fmul float %47, %113
  %115 = fmul float %55, %113
  %116 = tail call float @llvm.fmuladd.f32(float %49, float %86, float %115)
  %117 = tail call float @llvm.fmuladd.f32(float %59, float %113, float %87)
  %118 = fmul float %74, %106
  %119 = fmul float %108, %88
  %120 = fmul float %116, %119
  %121 = tail call float @llvm.fmuladd.f32(float %118, float %117, float %120)
  %122 = fmul float %105, %89
  %123 = tail call float @llvm.fmuladd.f32(float %122, float %117, float %121)
  %124 = fmul float %77, %108
  %125 = tail call float @llvm.fmuladd.f32(float %124, float %114, float %123)
  %126 = fmul float %79, %105
  %127 = tail call float @llvm.fmuladd.f32(float %126, float %116, float %125)
  %128 = fmul float %106, %90
  %129 = tail call float @llvm.fmuladd.f32(float %128, float %114, float %127)
  %130 = fdiv float 1.000000e+00, %129
  %131 = fneg float %108
  %132 = fmul float %116, %131
  %133 = tail call float @llvm.fmuladd.f32(float %106, float %117, float %132)
  %134 = fmul float %133, %130
  %135 = fneg float %130
  %136 = fmul float %116, %90
  %137 = tail call float @llvm.fmuladd.f32(float %77, float %117, float %136)
  %138 = fmul float %137, %135
  %139 = tail call float @llvm.fmuladd.f32(float %77, float %108, float %128)
  %140 = fmul float %139, %130
  %141 = fmul float %114, %131
  %142 = tail call float @llvm.fmuladd.f32(float %105, float %117, float %141)
  %143 = fmul float %142, %135
  %144 = fmul float %114, %90
  %145 = tail call float @llvm.fmuladd.f32(float %74, float %117, float %144)
  %146 = fmul float %145, %130
  %147 = fneg float %126
  %148 = tail call float @llvm.fmuladd.f32(float %74, float %108, float %147)
  %149 = fmul float %148, %135
  %150 = fneg float %106
  %151 = fmul float %114, %150
  %152 = tail call float @llvm.fmuladd.f32(float %105, float %116, float %151)
  %153 = fmul float %152, %130
  %154 = fmul float %114, %89
  %155 = tail call float @llvm.fmuladd.f32(float %74, float %116, float %154)
  %156 = fmul float %155, %135
  %157 = tail call float @llvm.fmuladd.f32(float %74, float %106, float %122)
  %158 = fmul float %157, %130
  %159 = fmul float %47, %134
  %160 = fmul float %47, %138
  %161 = fmul float %47, %140
  %162 = insertelement <2 x float> poison, float %49, i64 0
  %163 = shufflevector <2 x float> %162, <2 x float> poison, <2 x i32> zeroinitializer
  %164 = shufflevector <4 x float> %71, <4 x float> poison, <2 x i32> <i32 0, i32 2>
  %165 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %163, <2 x float> %164, <2 x float> %102)
  %166 = insertelement <2 x float> poison, float %56, i64 0
  %167 = shufflevector <2 x float> %166, <2 x float> poison, <2 x i32> zeroinitializer
  %168 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %167, <2 x float> %164, <2 x float> %111)
  %169 = insertelement <2 x float> poison, float %153, i64 0
  %170 = shufflevector <2 x float> %169, <2 x float> poison, <2 x i32> zeroinitializer
  %171 = fmul <2 x float> %168, %170
  %172 = insertelement <2 x float> poison, float %143, i64 0
  %173 = shufflevector <2 x float> %172, <2 x float> poison, <2 x i32> zeroinitializer
  %174 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %173, <2 x float> %165, <2 x float> %171)
  %175 = insertelement <2 x float> poison, float %159, i64 0
  %176 = shufflevector <2 x float> %175, <2 x float> poison, <2 x i32> zeroinitializer
  %177 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %176, <2 x float> %101, <2 x float> %174)
  %178 = insertelement <2 x float> poison, float %156, i64 0
  %179 = shufflevector <2 x float> %178, <2 x float> poison, <2 x i32> zeroinitializer
  %180 = fmul <2 x float> %168, %179
  %181 = insertelement <2 x float> poison, float %146, i64 0
  %182 = shufflevector <2 x float> %181, <2 x float> poison, <2 x i32> zeroinitializer
  %183 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %182, <2 x float> %165, <2 x float> %180)
  %184 = insertelement <2 x float> poison, float %160, i64 0
  %185 = shufflevector <2 x float> %184, <2 x float> poison, <2 x i32> zeroinitializer
  %186 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %185, <2 x float> %101, <2 x float> %183)
  %187 = insertelement <2 x float> poison, float %158, i64 0
  %188 = shufflevector <2 x float> %187, <2 x float> poison, <2 x i32> zeroinitializer
  %189 = fmul <2 x float> %168, %188
  %190 = insertelement <2 x float> poison, float %149, i64 0
  %191 = shufflevector <2 x float> %190, <2 x float> poison, <2 x i32> zeroinitializer
  %192 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %191, <2 x float> %165, <2 x float> %189)
  %193 = insertelement <2 x float> poison, float %161, i64 0
  %194 = shufflevector <2 x float> %193, <2 x float> poison, <2 x i32> zeroinitializer
  %195 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %194, <2 x float> %101, <2 x float> %192)
  %196 = extractelement <2 x float> %186, i64 0
  %197 = fmul float %55, %196
  %198 = extractelement <2 x float> %177, i64 0
  %199 = tail call float @llvm.fmuladd.f32(float %47, float %198, float %197)
  %200 = extractelement <2 x float> %195, i64 0
  %201 = tail call float @llvm.fmuladd.f32(float %59, float %200, float %199)
  %202 = fmul float %56, %200
  %203 = tail call float @llvm.fmuladd.f32(float %49, float %196, float %202)
  %204 = fadd float %203, -1.000000e+00
  %205 = extractelement <2 x float> %186, i64 1
  %206 = fmul float %55, %205
  %207 = extractelement <2 x float> %177, i64 1
  %208 = tail call float @llvm.fmuladd.f32(float %47, float %207, float %206)
  %209 = extractelement <2 x float> %195, i64 1
  %210 = tail call float @llvm.fmuladd.f32(float %59, float %209, float %208)
  %211 = fadd float %210, -1.000000e+00
  %212 = fmul float %56, %209
  %213 = tail call float @llvm.fmuladd.f32(float %49, float %205, float %212)
  %214 = insertelement <4 x float> poison, float %204, i64 0
  %215 = insertelement <4 x float> %214, float %213, i64 1
  %216 = shufflevector <4 x float> %215, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
  %217 = fmul <4 x float> %216, %95
  %218 = insertelement <4 x float> poison, float %201, i64 0
  %219 = insertelement <4 x float> %218, float %211, i64 1
  %220 = shufflevector <4 x float> %219, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
  %221 = tail call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %93, <4 x float> %220, <4 x float> %217)
  %222 = fadd <4 x float> %71, %221
  store <4 x float> %222, ptr %60, align 4, !tbaa !5
  %223 = load <2 x float>, ptr %0, align 4, !tbaa !5
  %224 = insertelement <2 x float> poison, float %96, i64 0
  %225 = shufflevector <2 x float> %224, <2 x float> poison, <2 x i32> zeroinitializer
  %226 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %177, <2 x float> %225, <2 x float> %223)
  %227 = insertelement <2 x float> poison, float %97, i64 0
  %228 = shufflevector <2 x float> %227, <2 x float> poison, <2 x i32> zeroinitializer
  %229 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %186, <2 x float> %228, <2 x float> %226)
  %230 = insertelement <2 x float> poison, float %98, i64 0
  %231 = shufflevector <2 x float> %230, <2 x float> poison, <2 x i32> zeroinitializer
  %232 = tail call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %195, <2 x float> %231, <2 x float> %229)
  store <2 x float> %232, ptr %0, align 4, !tbaa !5
  ret void
}

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <4 x float> @llvm.fmuladd.v4f32(<4 x float>, <4 x float>, <4 x float>) #3

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

attributes #0 = { 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 #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #2 = { mustprogress nofree nounwind willreturn memory(write, argmem: readwrite) 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 #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { 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 = !{!"float", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 0}
!10 = !{!"", !6, i64 0, !6, i64 4, !7, i64 8, !7, i64 24, !7, i64 32}
!11 = !{!10, !6, i64 4}


; Effective O3 passes: EarlyCSEPass,GlobalOptPass,InferFunctionAttrsPass,InstCombinePass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,TailCallElimPass