; LLVM IR from jgaeddert/liquid-dsp :: src/fft/src (fftf)

; 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.fftplan_s = type { i32, ptr, ptr, i32, i32, i32, i32, ptr, ptr, ptr, %union.anon }
%union.anon = type { %struct.anon.1 }
%struct.anon.1 = type { i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }

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

; 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 i32 @fft_execute_dft_16(ptr noundef %0) #1 {
  %2 = alloca ptr, align 8
  %3 = alloca { float, float }, align 4
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca { float, float }, align 4
  %8 = alloca { float, float }, align 4
  %9 = alloca { float, float }, align 4
  %10 = alloca { float, float }, align 4
  %11 = alloca { float, float }, align 4
  %12 = alloca { float, float }, align 4
  %13 = alloca { float, float }, align 4
  %14 = alloca { float, float }, align 4
  %15 = alloca { float, float }, align 4
  %16 = alloca { float, float }, align 4
  %17 = alloca { float, float }, align 4
  %18 = alloca { float, float }, align 4
  %19 = alloca { float, float }, align 4
  %20 = alloca { float, float }, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #2
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #2
  %21 = load ptr, ptr %2, align 8, !tbaa !5
  %22 = getelementptr inbounds %struct.fftplan_s, ptr %21, i32 0, i32 1
  %23 = load ptr, ptr %22, align 8, !tbaa !9
  store ptr %23, ptr %4, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #2
  %24 = load ptr, ptr %2, align 8, !tbaa !5
  %25 = getelementptr inbounds %struct.fftplan_s, ptr %24, i32 0, i32 2
  %26 = load ptr, ptr %25, align 8, !tbaa !12
  store ptr %26, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #2
  %27 = load ptr, ptr %2, align 8, !tbaa !5
  %28 = getelementptr inbounds %struct.fftplan_s, ptr %27, i32 0, i32 3
  %29 = load i32, ptr %28, align 8, !tbaa !13
  %30 = icmp eq i32 %29, 1
  %31 = zext i1 %30 to i64
  %32 = select i1 %30, i32 1, i32 0
  store i32 %32, ptr %6, align 4, !tbaa !14
  %33 = load ptr, ptr %4, align 8, !tbaa !5
  %34 = getelementptr inbounds { float, float }, ptr %33, i64 0
  %35 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 0
  %36 = load float, ptr %35, align 4
  %37 = getelementptr inbounds { float, float }, ptr %34, i32 0, i32 1
  %38 = load float, ptr %37, align 4
  %39 = load ptr, ptr %5, align 8, !tbaa !5
  %40 = getelementptr inbounds { float, float }, ptr %39, i64 0
  %41 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 0
  %42 = getelementptr inbounds { float, float }, ptr %40, i32 0, i32 1
  store float %36, ptr %41, align 4
  store float %38, ptr %42, align 4
  %43 = load ptr, ptr %4, align 8, !tbaa !5
  %44 = getelementptr inbounds { float, float }, ptr %43, i64 8
  %45 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 0
  %46 = load float, ptr %45, align 4
  %47 = getelementptr inbounds { float, float }, ptr %44, i32 0, i32 1
  %48 = load float, ptr %47, align 4
  %49 = load ptr, ptr %5, align 8, !tbaa !5
  %50 = getelementptr inbounds { float, float }, ptr %49, i64 1
  %51 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 0
  %52 = getelementptr inbounds { float, float }, ptr %50, i32 0, i32 1
  store float %46, ptr %51, align 4
  store float %48, ptr %52, align 4
  %53 = load ptr, ptr %4, align 8, !tbaa !5
  %54 = getelementptr inbounds { float, float }, ptr %53, i64 4
  %55 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 0
  %56 = load float, ptr %55, align 4
  %57 = getelementptr inbounds { float, float }, ptr %54, i32 0, i32 1
  %58 = load float, ptr %57, align 4
  %59 = load ptr, ptr %5, align 8, !tbaa !5
  %60 = getelementptr inbounds { float, float }, ptr %59, i64 2
  %61 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 0
  %62 = getelementptr inbounds { float, float }, ptr %60, i32 0, i32 1
  store float %56, ptr %61, align 4
  store float %58, ptr %62, align 4
  %63 = load ptr, ptr %4, align 8, !tbaa !5
  %64 = getelementptr inbounds { float, float }, ptr %63, i64 12
  %65 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 0
  %66 = load float, ptr %65, align 4
  %67 = getelementptr inbounds { float, float }, ptr %64, i32 0, i32 1
  %68 = load float, ptr %67, align 4
  %69 = load ptr, ptr %5, align 8, !tbaa !5
  %70 = getelementptr inbounds { float, float }, ptr %69, i64 3
  %71 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 0
  %72 = getelementptr inbounds { float, float }, ptr %70, i32 0, i32 1
  store float %66, ptr %71, align 4
  store float %68, ptr %72, align 4
  %73 = load ptr, ptr %4, align 8, !tbaa !5
  %74 = getelementptr inbounds { float, float }, ptr %73, i64 2
  %75 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 0
  %76 = load float, ptr %75, align 4
  %77 = getelementptr inbounds { float, float }, ptr %74, i32 0, i32 1
  %78 = load float, ptr %77, align 4
  %79 = load ptr, ptr %5, align 8, !tbaa !5
  %80 = getelementptr inbounds { float, float }, ptr %79, i64 4
  %81 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 0
  %82 = getelementptr inbounds { float, float }, ptr %80, i32 0, i32 1
  store float %76, ptr %81, align 4
  store float %78, ptr %82, align 4
  %83 = load ptr, ptr %4, align 8, !tbaa !5
  %84 = getelementptr inbounds { float, float }, ptr %83, i64 10
  %85 = getelementptr inbounds { float, float }, ptr %84, i32 0, i32 0
  %86 = load float, ptr %85, align 4
  %87 = getelementptr inbounds { float, float }, ptr %84, i32 0, i32 1
  %88 = load float, ptr %87, align 4
  %89 = load ptr, ptr %5, align 8, !tbaa !5
  %90 = getelementptr inbounds { float, float }, ptr %89, i64 5
  %91 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 0
  %92 = getelementptr inbounds { float, float }, ptr %90, i32 0, i32 1
  store float %86, ptr %91, align 4
  store float %88, ptr %92, align 4
  %93 = load ptr, ptr %4, align 8, !tbaa !5
  %94 = getelementptr inbounds { float, float }, ptr %93, i64 6
  %95 = getelementptr inbounds { float, float }, ptr %94, i32 0, i32 0
  %96 = load float, ptr %95, align 4
  %97 = getelementptr inbounds { float, float }, ptr %94, i32 0, i32 1
  %98 = load float, ptr %97, align 4
  %99 = load ptr, ptr %5, align 8, !tbaa !5
  %100 = getelementptr inbounds { float, float }, ptr %99, i64 6
  %101 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 0
  %102 = getelementptr inbounds { float, float }, ptr %100, i32 0, i32 1
  store float %96, ptr %101, align 4
  store float %98, ptr %102, align 4
  %103 = load ptr, ptr %4, align 8, !tbaa !5
  %104 = getelementptr inbounds { float, float }, ptr %103, i64 14
  %105 = getelementptr inbounds { float, float }, ptr %104, i32 0, i32 0
  %106 = load float, ptr %105, align 4
  %107 = getelementptr inbounds { float, float }, ptr %104, i32 0, i32 1
  %108 = load float, ptr %107, align 4
  %109 = load ptr, ptr %5, align 8, !tbaa !5
  %110 = getelementptr inbounds { float, float }, ptr %109, i64 7
  %111 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 0
  %112 = getelementptr inbounds { float, float }, ptr %110, i32 0, i32 1
  store float %106, ptr %111, align 4
  store float %108, ptr %112, align 4
  %113 = load ptr, ptr %4, align 8, !tbaa !5
  %114 = getelementptr inbounds { float, float }, ptr %113, i64 1
  %115 = getelementptr inbounds { float, float }, ptr %114, i32 0, i32 0
  %116 = load float, ptr %115, align 4
  %117 = getelementptr inbounds { float, float }, ptr %114, i32 0, i32 1
  %118 = load float, ptr %117, align 4
  %119 = load ptr, ptr %5, align 8, !tbaa !5
  %120 = getelementptr inbounds { float, float }, ptr %119, i64 8
  %121 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 0
  %122 = getelementptr inbounds { float, float }, ptr %120, i32 0, i32 1
  store float %116, ptr %121, align 4
  store float %118, ptr %122, align 4
  %123 = load ptr, ptr %4, align 8, !tbaa !5
  %124 = getelementptr inbounds { float, float }, ptr %123, i64 9
  %125 = getelementptr inbounds { float, float }, ptr %124, i32 0, i32 0
  %126 = load float, ptr %125, align 4
  %127 = getelementptr inbounds { float, float }, ptr %124, i32 0, i32 1
  %128 = load float, ptr %127, align 4
  %129 = load ptr, ptr %5, align 8, !tbaa !5
  %130 = getelementptr inbounds { float, float }, ptr %129, i64 9
  %131 = getelementptr inbounds { float, float }, ptr %130, i32 0, i32 0
  %132 = getelementptr inbounds { float, float }, ptr %130, i32 0, i32 1
  store float %126, ptr %131, align 4
  store float %128, ptr %132, align 4
  %133 = load ptr, ptr %4, align 8, !tbaa !5
  %134 = getelementptr inbounds { float, float }, ptr %133, i64 5
  %135 = getelementptr inbounds { float, float }, ptr %134, i32 0, i32 0
  %136 = load float, ptr %135, align 4
  %137 = getelementptr inbounds { float, float }, ptr %134, i32 0, i32 1
  %138 = load float, ptr %137, align 4
  %139 = load ptr, ptr %5, align 8, !tbaa !5
  %140 = getelementptr inbounds { float, float }, ptr %139, i64 10
  %141 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 0
  %142 = getelementptr inbounds { float, float }, ptr %140, i32 0, i32 1
  store float %136, ptr %141, align 4
  store float %138, ptr %142, align 4
  %143 = load ptr, ptr %4, align 8, !tbaa !5
  %144 = getelementptr inbounds { float, float }, ptr %143, i64 13
  %145 = getelementptr inbounds { float, float }, ptr %144, i32 0, i32 0
  %146 = load float, ptr %145, align 4
  %147 = getelementptr inbounds { float, float }, ptr %144, i32 0, i32 1
  %148 = load float, ptr %147, align 4
  %149 = load ptr, ptr %5, align 8, !tbaa !5
  %150 = getelementptr inbounds { float, float }, ptr %149, i64 11
  %151 = getelementptr inbounds { float, float }, ptr %150, i32 0, i32 0
  %152 = getelementptr inbounds { float, float }, ptr %150, i32 0, i32 1
  store float %146, ptr %151, align 4
  store float %148, ptr %152, align 4
  %153 = load ptr, ptr %4, align 8, !tbaa !5
  %154 = getelementptr inbounds { float, float }, ptr %153, i64 3
  %155 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 0
  %156 = load float, ptr %155, align 4
  %157 = getelementptr inbounds { float, float }, ptr %154, i32 0, i32 1
  %158 = load float, ptr %157, align 4
  %159 = load ptr, ptr %5, align 8, !tbaa !5
  %160 = getelementptr inbounds { float, float }, ptr %159, i64 12
  %161 = getelementptr inbounds { float, float }, ptr %160, i32 0, i32 0
  %162 = getelementptr inbounds { float, float }, ptr %160, i32 0, i32 1
  store float %156, ptr %161, align 4
  store float %158, ptr %162, align 4
  %163 = load ptr, ptr %4, align 8, !tbaa !5
  %164 = getelementptr inbounds { float, float }, ptr %163, i64 11
  %165 = getelementptr inbounds { float, float }, ptr %164, i32 0, i32 0
  %166 = load float, ptr %165, align 4
  %167 = getelementptr inbounds { float, float }, ptr %164, i32 0, i32 1
  %168 = load float, ptr %167, align 4
  %169 = load ptr, ptr %5, align 8, !tbaa !5
  %170 = getelementptr inbounds { float, float }, ptr %169, i64 13
  %171 = getelementptr inbounds { float, float }, ptr %170, i32 0, i32 0
  %172 = getelementptr inbounds { float, float }, ptr %170, i32 0, i32 1
  store float %166, ptr %171, align 4
  store float %168, ptr %172, align 4
  %173 = load ptr, ptr %4, align 8, !tbaa !5
  %174 = getelementptr inbounds { float, float }, ptr %173, i64 7
  %175 = getelementptr inbounds { float, float }, ptr %174, i32 0, i32 0
  %176 = load float, ptr %175, align 4
  %177 = getelementptr inbounds { float, float }, ptr %174, i32 0, i32 1
  %178 = load float, ptr %177, align 4
  %179 = load ptr, ptr %5, align 8, !tbaa !5
  %180 = getelementptr inbounds { float, float }, ptr %179, i64 14
  %181 = getelementptr inbounds { float, float }, ptr %180, i32 0, i32 0
  %182 = getelementptr inbounds { float, float }, ptr %180, i32 0, i32 1
  store float %176, ptr %181, align 4
  store float %178, ptr %182, align 4
  %183 = load ptr, ptr %4, align 8, !tbaa !5
  %184 = getelementptr inbounds { float, float }, ptr %183, i64 15
  %185 = getelementptr inbounds { float, float }, ptr %184, i32 0, i32 0
  %186 = load float, ptr %185, align 4
  %187 = getelementptr inbounds { float, float }, ptr %184, i32 0, i32 1
  %188 = load float, ptr %187, align 4
  %189 = load ptr, ptr %5, align 8, !tbaa !5
  %190 = getelementptr inbounds { float, float }, ptr %189, i64 15
  %191 = getelementptr inbounds { float, float }, ptr %190, i32 0, i32 0
  %192 = getelementptr inbounds { float, float }, ptr %190, i32 0, i32 1
  store float %186, ptr %191, align 4
  store float %188, ptr %192, align 4
  %193 = load ptr, ptr %5, align 8, !tbaa !5
  %194 = getelementptr inbounds { float, float }, ptr %193, i64 1
  %195 = getelementptr inbounds { float, float }, ptr %194, i32 0, i32 0
  %196 = load float, ptr %195, align 4
  %197 = getelementptr inbounds { float, float }, ptr %194, i32 0, i32 1
  %198 = load float, ptr %197, align 4
  %199 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %200 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %196, ptr %199, align 4
  store float %198, ptr %200, align 4
  %201 = load ptr, ptr %5, align 8, !tbaa !5
  %202 = getelementptr inbounds { float, float }, ptr %201, i64 0
  %203 = getelementptr inbounds { float, float }, ptr %202, i32 0, i32 0
  %204 = load float, ptr %203, align 4
  %205 = getelementptr inbounds { float, float }, ptr %202, i32 0, i32 1
  %206 = load float, ptr %205, align 4
  %207 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %208 = load float, ptr %207, align 4
  %209 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %210 = load float, ptr %209, align 4
  %211 = fsub float %204, %208
  %212 = fsub float %206, %210
  %213 = load ptr, ptr %5, align 8, !tbaa !5
  %214 = getelementptr inbounds { float, float }, ptr %213, i64 1
  %215 = getelementptr inbounds { float, float }, ptr %214, i32 0, i32 0
  %216 = getelementptr inbounds { float, float }, ptr %214, i32 0, i32 1
  store float %211, ptr %215, align 4
  store float %212, ptr %216, align 4
  %217 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %218 = load float, ptr %217, align 4
  %219 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %220 = load float, ptr %219, align 4
  %221 = load ptr, ptr %5, align 8, !tbaa !5
  %222 = getelementptr inbounds { float, float }, ptr %221, i64 0
  %223 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 0
  %224 = load float, ptr %223, align 4
  %225 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 1
  %226 = load float, ptr %225, align 4
  %227 = fadd float %224, %218
  %228 = fadd float %226, %220
  %229 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 0
  %230 = getelementptr inbounds { float, float }, ptr %222, i32 0, i32 1
  store float %227, ptr %229, align 4
  store float %228, ptr %230, align 4
  %231 = load ptr, ptr %5, align 8, !tbaa !5
  %232 = getelementptr inbounds { float, float }, ptr %231, i64 3
  %233 = getelementptr inbounds { float, float }, ptr %232, i32 0, i32 0
  %234 = load float, ptr %233, align 4
  %235 = getelementptr inbounds { float, float }, ptr %232, i32 0, i32 1
  %236 = load float, ptr %235, align 4
  %237 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %238 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %234, ptr %237, align 4
  store float %236, ptr %238, align 4
  %239 = load ptr, ptr %5, align 8, !tbaa !5
  %240 = getelementptr inbounds { float, float }, ptr %239, i64 2
  %241 = getelementptr inbounds { float, float }, ptr %240, i32 0, i32 0
  %242 = load float, ptr %241, align 4
  %243 = getelementptr inbounds { float, float }, ptr %240, i32 0, i32 1
  %244 = load float, ptr %243, align 4
  %245 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %246 = load float, ptr %245, align 4
  %247 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %248 = load float, ptr %247, align 4
  %249 = fsub float %242, %246
  %250 = fsub float %244, %248
  %251 = load ptr, ptr %5, align 8, !tbaa !5
  %252 = getelementptr inbounds { float, float }, ptr %251, i64 3
  %253 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 0
  %254 = getelementptr inbounds { float, float }, ptr %252, i32 0, i32 1
  store float %249, ptr %253, align 4
  store float %250, ptr %254, align 4
  %255 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %256 = load float, ptr %255, align 4
  %257 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %258 = load float, ptr %257, align 4
  %259 = load ptr, ptr %5, align 8, !tbaa !5
  %260 = getelementptr inbounds { float, float }, ptr %259, i64 2
  %261 = getelementptr inbounds { float, float }, ptr %260, i32 0, i32 0
  %262 = load float, ptr %261, align 4
  %263 = getelementptr inbounds { float, float }, ptr %260, i32 0, i32 1
  %264 = load float, ptr %263, align 4
  %265 = fadd float %262, %256
  %266 = fadd float %264, %258
  %267 = getelementptr inbounds { float, float }, ptr %260, i32 0, i32 0
  %268 = getelementptr inbounds { float, float }, ptr %260, i32 0, i32 1
  store float %265, ptr %267, align 4
  store float %266, ptr %268, align 4
  %269 = load ptr, ptr %5, align 8, !tbaa !5
  %270 = getelementptr inbounds { float, float }, ptr %269, i64 5
  %271 = getelementptr inbounds { float, float }, ptr %270, i32 0, i32 0
  %272 = load float, ptr %271, align 4
  %273 = getelementptr inbounds { float, float }, ptr %270, i32 0, i32 1
  %274 = load float, ptr %273, align 4
  %275 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %276 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %272, ptr %275, align 4
  store float %274, ptr %276, align 4
  %277 = load ptr, ptr %5, align 8, !tbaa !5
  %278 = getelementptr inbounds { float, float }, ptr %277, i64 4
  %279 = getelementptr inbounds { float, float }, ptr %278, i32 0, i32 0
  %280 = load float, ptr %279, align 4
  %281 = getelementptr inbounds { float, float }, ptr %278, i32 0, i32 1
  %282 = load float, ptr %281, align 4
  %283 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %284 = load float, ptr %283, align 4
  %285 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %286 = load float, ptr %285, align 4
  %287 = fsub float %280, %284
  %288 = fsub float %282, %286
  %289 = load ptr, ptr %5, align 8, !tbaa !5
  %290 = getelementptr inbounds { float, float }, ptr %289, i64 5
  %291 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 0
  %292 = getelementptr inbounds { float, float }, ptr %290, i32 0, i32 1
  store float %287, ptr %291, align 4
  store float %288, ptr %292, align 4
  %293 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %294 = load float, ptr %293, align 4
  %295 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %296 = load float, ptr %295, align 4
  %297 = load ptr, ptr %5, align 8, !tbaa !5
  %298 = getelementptr inbounds { float, float }, ptr %297, i64 4
  %299 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 0
  %300 = load float, ptr %299, align 4
  %301 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 1
  %302 = load float, ptr %301, align 4
  %303 = fadd float %300, %294
  %304 = fadd float %302, %296
  %305 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 0
  %306 = getelementptr inbounds { float, float }, ptr %298, i32 0, i32 1
  store float %303, ptr %305, align 4
  store float %304, ptr %306, align 4
  %307 = load ptr, ptr %5, align 8, !tbaa !5
  %308 = getelementptr inbounds { float, float }, ptr %307, i64 7
  %309 = getelementptr inbounds { float, float }, ptr %308, i32 0, i32 0
  %310 = load float, ptr %309, align 4
  %311 = getelementptr inbounds { float, float }, ptr %308, i32 0, i32 1
  %312 = load float, ptr %311, align 4
  %313 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %314 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %310, ptr %313, align 4
  store float %312, ptr %314, align 4
  %315 = load ptr, ptr %5, align 8, !tbaa !5
  %316 = getelementptr inbounds { float, float }, ptr %315, i64 6
  %317 = getelementptr inbounds { float, float }, ptr %316, i32 0, i32 0
  %318 = load float, ptr %317, align 4
  %319 = getelementptr inbounds { float, float }, ptr %316, i32 0, i32 1
  %320 = load float, ptr %319, align 4
  %321 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %322 = load float, ptr %321, align 4
  %323 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %324 = load float, ptr %323, align 4
  %325 = fsub float %318, %322
  %326 = fsub float %320, %324
  %327 = load ptr, ptr %5, align 8, !tbaa !5
  %328 = getelementptr inbounds { float, float }, ptr %327, i64 7
  %329 = getelementptr inbounds { float, float }, ptr %328, i32 0, i32 0
  %330 = getelementptr inbounds { float, float }, ptr %328, i32 0, i32 1
  store float %325, ptr %329, align 4
  store float %326, ptr %330, align 4
  %331 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %332 = load float, ptr %331, align 4
  %333 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %334 = load float, ptr %333, align 4
  %335 = load ptr, ptr %5, align 8, !tbaa !5
  %336 = getelementptr inbounds { float, float }, ptr %335, i64 6
  %337 = getelementptr inbounds { float, float }, ptr %336, i32 0, i32 0
  %338 = load float, ptr %337, align 4
  %339 = getelementptr inbounds { float, float }, ptr %336, i32 0, i32 1
  %340 = load float, ptr %339, align 4
  %341 = fadd float %338, %332
  %342 = fadd float %340, %334
  %343 = getelementptr inbounds { float, float }, ptr %336, i32 0, i32 0
  %344 = getelementptr inbounds { float, float }, ptr %336, i32 0, i32 1
  store float %341, ptr %343, align 4
  store float %342, ptr %344, align 4
  %345 = load ptr, ptr %5, align 8, !tbaa !5
  %346 = getelementptr inbounds { float, float }, ptr %345, i64 9
  %347 = getelementptr inbounds { float, float }, ptr %346, i32 0, i32 0
  %348 = load float, ptr %347, align 4
  %349 = getelementptr inbounds { float, float }, ptr %346, i32 0, i32 1
  %350 = load float, ptr %349, align 4
  %351 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %352 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %348, ptr %351, align 4
  store float %350, ptr %352, align 4
  %353 = load ptr, ptr %5, align 8, !tbaa !5
  %354 = getelementptr inbounds { float, float }, ptr %353, i64 8
  %355 = getelementptr inbounds { float, float }, ptr %354, i32 0, i32 0
  %356 = load float, ptr %355, align 4
  %357 = getelementptr inbounds { float, float }, ptr %354, i32 0, i32 1
  %358 = load float, ptr %357, align 4
  %359 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %360 = load float, ptr %359, align 4
  %361 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %362 = load float, ptr %361, align 4
  %363 = fsub float %356, %360
  %364 = fsub float %358, %362
  %365 = load ptr, ptr %5, align 8, !tbaa !5
  %366 = getelementptr inbounds { float, float }, ptr %365, i64 9
  %367 = getelementptr inbounds { float, float }, ptr %366, i32 0, i32 0
  %368 = getelementptr inbounds { float, float }, ptr %366, i32 0, i32 1
  store float %363, ptr %367, align 4
  store float %364, ptr %368, align 4
  %369 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %370 = load float, ptr %369, align 4
  %371 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %372 = load float, ptr %371, align 4
  %373 = load ptr, ptr %5, align 8, !tbaa !5
  %374 = getelementptr inbounds { float, float }, ptr %373, i64 8
  %375 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 0
  %376 = load float, ptr %375, align 4
  %377 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 1
  %378 = load float, ptr %377, align 4
  %379 = fadd float %376, %370
  %380 = fadd float %378, %372
  %381 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 0
  %382 = getelementptr inbounds { float, float }, ptr %374, i32 0, i32 1
  store float %379, ptr %381, align 4
  store float %380, ptr %382, align 4
  %383 = load ptr, ptr %5, align 8, !tbaa !5
  %384 = getelementptr inbounds { float, float }, ptr %383, i64 11
  %385 = getelementptr inbounds { float, float }, ptr %384, i32 0, i32 0
  %386 = load float, ptr %385, align 4
  %387 = getelementptr inbounds { float, float }, ptr %384, i32 0, i32 1
  %388 = load float, ptr %387, align 4
  %389 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %390 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %386, ptr %389, align 4
  store float %388, ptr %390, align 4
  %391 = load ptr, ptr %5, align 8, !tbaa !5
  %392 = getelementptr inbounds { float, float }, ptr %391, i64 10
  %393 = getelementptr inbounds { float, float }, ptr %392, i32 0, i32 0
  %394 = load float, ptr %393, align 4
  %395 = getelementptr inbounds { float, float }, ptr %392, i32 0, i32 1
  %396 = load float, ptr %395, align 4
  %397 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %398 = load float, ptr %397, align 4
  %399 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %400 = load float, ptr %399, align 4
  %401 = fsub float %394, %398
  %402 = fsub float %396, %400
  %403 = load ptr, ptr %5, align 8, !tbaa !5
  %404 = getelementptr inbounds { float, float }, ptr %403, i64 11
  %405 = getelementptr inbounds { float, float }, ptr %404, i32 0, i32 0
  %406 = getelementptr inbounds { float, float }, ptr %404, i32 0, i32 1
  store float %401, ptr %405, align 4
  store float %402, ptr %406, align 4
  %407 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %408 = load float, ptr %407, align 4
  %409 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %410 = load float, ptr %409, align 4
  %411 = load ptr, ptr %5, align 8, !tbaa !5
  %412 = getelementptr inbounds { float, float }, ptr %411, i64 10
  %413 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 0
  %414 = load float, ptr %413, align 4
  %415 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 1
  %416 = load float, ptr %415, align 4
  %417 = fadd float %414, %408
  %418 = fadd float %416, %410
  %419 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 0
  %420 = getelementptr inbounds { float, float }, ptr %412, i32 0, i32 1
  store float %417, ptr %419, align 4
  store float %418, ptr %420, align 4
  %421 = load ptr, ptr %5, align 8, !tbaa !5
  %422 = getelementptr inbounds { float, float }, ptr %421, i64 13
  %423 = getelementptr inbounds { float, float }, ptr %422, i32 0, i32 0
  %424 = load float, ptr %423, align 4
  %425 = getelementptr inbounds { float, float }, ptr %422, i32 0, i32 1
  %426 = load float, ptr %425, align 4
  %427 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %428 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %424, ptr %427, align 4
  store float %426, ptr %428, align 4
  %429 = load ptr, ptr %5, align 8, !tbaa !5
  %430 = getelementptr inbounds { float, float }, ptr %429, i64 12
  %431 = getelementptr inbounds { float, float }, ptr %430, i32 0, i32 0
  %432 = load float, ptr %431, align 4
  %433 = getelementptr inbounds { float, float }, ptr %430, i32 0, i32 1
  %434 = load float, ptr %433, align 4
  %435 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %436 = load float, ptr %435, align 4
  %437 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %438 = load float, ptr %437, align 4
  %439 = fsub float %432, %436
  %440 = fsub float %434, %438
  %441 = load ptr, ptr %5, align 8, !tbaa !5
  %442 = getelementptr inbounds { float, float }, ptr %441, i64 13
  %443 = getelementptr inbounds { float, float }, ptr %442, i32 0, i32 0
  %444 = getelementptr inbounds { float, float }, ptr %442, i32 0, i32 1
  store float %439, ptr %443, align 4
  store float %440, ptr %444, align 4
  %445 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %446 = load float, ptr %445, align 4
  %447 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %448 = load float, ptr %447, align 4
  %449 = load ptr, ptr %5, align 8, !tbaa !5
  %450 = getelementptr inbounds { float, float }, ptr %449, i64 12
  %451 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 0
  %452 = load float, ptr %451, align 4
  %453 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 1
  %454 = load float, ptr %453, align 4
  %455 = fadd float %452, %446
  %456 = fadd float %454, %448
  %457 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 0
  %458 = getelementptr inbounds { float, float }, ptr %450, i32 0, i32 1
  store float %455, ptr %457, align 4
  store float %456, ptr %458, align 4
  %459 = load ptr, ptr %5, align 8, !tbaa !5
  %460 = getelementptr inbounds { float, float }, ptr %459, i64 15
  %461 = getelementptr inbounds { float, float }, ptr %460, i32 0, i32 0
  %462 = load float, ptr %461, align 4
  %463 = getelementptr inbounds { float, float }, ptr %460, i32 0, i32 1
  %464 = load float, ptr %463, align 4
  %465 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %466 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %462, ptr %465, align 4
  store float %464, ptr %466, align 4
  %467 = load ptr, ptr %5, align 8, !tbaa !5
  %468 = getelementptr inbounds { float, float }, ptr %467, i64 14
  %469 = getelementptr inbounds { float, float }, ptr %468, i32 0, i32 0
  %470 = load float, ptr %469, align 4
  %471 = getelementptr inbounds { float, float }, ptr %468, i32 0, i32 1
  %472 = load float, ptr %471, align 4
  %473 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %474 = load float, ptr %473, align 4
  %475 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %476 = load float, ptr %475, align 4
  %477 = fsub float %470, %474
  %478 = fsub float %472, %476
  %479 = load ptr, ptr %5, align 8, !tbaa !5
  %480 = getelementptr inbounds { float, float }, ptr %479, i64 15
  %481 = getelementptr inbounds { float, float }, ptr %480, i32 0, i32 0
  %482 = getelementptr inbounds { float, float }, ptr %480, i32 0, i32 1
  store float %477, ptr %481, align 4
  store float %478, ptr %482, align 4
  %483 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %484 = load float, ptr %483, align 4
  %485 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %486 = load float, ptr %485, align 4
  %487 = load ptr, ptr %5, align 8, !tbaa !5
  %488 = getelementptr inbounds { float, float }, ptr %487, i64 14
  %489 = getelementptr inbounds { float, float }, ptr %488, i32 0, i32 0
  %490 = load float, ptr %489, align 4
  %491 = getelementptr inbounds { float, float }, ptr %488, i32 0, i32 1
  %492 = load float, ptr %491, align 4
  %493 = fadd float %490, %484
  %494 = fadd float %492, %486
  %495 = getelementptr inbounds { float, float }, ptr %488, i32 0, i32 0
  %496 = getelementptr inbounds { float, float }, ptr %488, i32 0, i32 1
  store float %493, ptr %495, align 4
  store float %494, ptr %496, align 4
  %497 = load ptr, ptr %5, align 8, !tbaa !5
  %498 = getelementptr inbounds { float, float }, ptr %497, i64 2
  %499 = getelementptr inbounds { float, float }, ptr %498, i32 0, i32 0
  %500 = load float, ptr %499, align 4
  %501 = getelementptr inbounds { float, float }, ptr %498, i32 0, i32 1
  %502 = load float, ptr %501, align 4
  %503 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %504 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %500, ptr %503, align 4
  store float %502, ptr %504, align 4
  %505 = load ptr, ptr %5, align 8, !tbaa !5
  %506 = getelementptr inbounds { float, float }, ptr %505, i64 0
  %507 = getelementptr inbounds { float, float }, ptr %506, i32 0, i32 0
  %508 = load float, ptr %507, align 4
  %509 = getelementptr inbounds { float, float }, ptr %506, i32 0, i32 1
  %510 = load float, ptr %509, align 4
  %511 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %512 = load float, ptr %511, align 4
  %513 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %514 = load float, ptr %513, align 4
  %515 = fsub float %508, %512
  %516 = fsub float %510, %514
  %517 = load ptr, ptr %5, align 8, !tbaa !5
  %518 = getelementptr inbounds { float, float }, ptr %517, i64 2
  %519 = getelementptr inbounds { float, float }, ptr %518, i32 0, i32 0
  %520 = getelementptr inbounds { float, float }, ptr %518, i32 0, i32 1
  store float %515, ptr %519, align 4
  store float %516, ptr %520, align 4
  %521 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %522 = load float, ptr %521, align 4
  %523 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %524 = load float, ptr %523, align 4
  %525 = load ptr, ptr %5, align 8, !tbaa !5
  %526 = getelementptr inbounds { float, float }, ptr %525, i64 0
  %527 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 0
  %528 = load float, ptr %527, align 4
  %529 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 1
  %530 = load float, ptr %529, align 4
  %531 = fadd float %528, %522
  %532 = fadd float %530, %524
  %533 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 0
  %534 = getelementptr inbounds { float, float }, ptr %526, i32 0, i32 1
  store float %531, ptr %533, align 4
  store float %532, ptr %534, align 4
  %535 = load ptr, ptr %5, align 8, !tbaa !5
  %536 = getelementptr inbounds { float, float }, ptr %535, i64 6
  %537 = getelementptr inbounds { float, float }, ptr %536, i32 0, i32 0
  %538 = load float, ptr %537, align 4
  %539 = getelementptr inbounds { float, float }, ptr %536, i32 0, i32 1
  %540 = load float, ptr %539, align 4
  %541 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %542 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %538, ptr %541, align 4
  store float %540, ptr %542, align 4
  %543 = load ptr, ptr %5, align 8, !tbaa !5
  %544 = getelementptr inbounds { float, float }, ptr %543, i64 4
  %545 = getelementptr inbounds { float, float }, ptr %544, i32 0, i32 0
  %546 = load float, ptr %545, align 4
  %547 = getelementptr inbounds { float, float }, ptr %544, i32 0, i32 1
  %548 = load float, ptr %547, align 4
  %549 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %550 = load float, ptr %549, align 4
  %551 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %552 = load float, ptr %551, align 4
  %553 = fsub float %546, %550
  %554 = fsub float %548, %552
  %555 = load ptr, ptr %5, align 8, !tbaa !5
  %556 = getelementptr inbounds { float, float }, ptr %555, i64 6
  %557 = getelementptr inbounds { float, float }, ptr %556, i32 0, i32 0
  %558 = getelementptr inbounds { float, float }, ptr %556, i32 0, i32 1
  store float %553, ptr %557, align 4
  store float %554, ptr %558, align 4
  %559 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %560 = load float, ptr %559, align 4
  %561 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %562 = load float, ptr %561, align 4
  %563 = load ptr, ptr %5, align 8, !tbaa !5
  %564 = getelementptr inbounds { float, float }, ptr %563, i64 4
  %565 = getelementptr inbounds { float, float }, ptr %564, i32 0, i32 0
  %566 = load float, ptr %565, align 4
  %567 = getelementptr inbounds { float, float }, ptr %564, i32 0, i32 1
  %568 = load float, ptr %567, align 4
  %569 = fadd float %566, %560
  %570 = fadd float %568, %562
  %571 = getelementptr inbounds { float, float }, ptr %564, i32 0, i32 0
  %572 = getelementptr inbounds { float, float }, ptr %564, i32 0, i32 1
  store float %569, ptr %571, align 4
  store float %570, ptr %572, align 4
  %573 = load ptr, ptr %5, align 8, !tbaa !5
  %574 = getelementptr inbounds { float, float }, ptr %573, i64 10
  %575 = getelementptr inbounds { float, float }, ptr %574, i32 0, i32 0
  %576 = load float, ptr %575, align 4
  %577 = getelementptr inbounds { float, float }, ptr %574, i32 0, i32 1
  %578 = load float, ptr %577, align 4
  %579 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %580 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %576, ptr %579, align 4
  store float %578, ptr %580, align 4
  %581 = load ptr, ptr %5, align 8, !tbaa !5
  %582 = getelementptr inbounds { float, float }, ptr %581, i64 8
  %583 = getelementptr inbounds { float, float }, ptr %582, i32 0, i32 0
  %584 = load float, ptr %583, align 4
  %585 = getelementptr inbounds { float, float }, ptr %582, i32 0, i32 1
  %586 = load float, ptr %585, align 4
  %587 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %588 = load float, ptr %587, align 4
  %589 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %590 = load float, ptr %589, align 4
  %591 = fsub float %584, %588
  %592 = fsub float %586, %590
  %593 = load ptr, ptr %5, align 8, !tbaa !5
  %594 = getelementptr inbounds { float, float }, ptr %593, i64 10
  %595 = getelementptr inbounds { float, float }, ptr %594, i32 0, i32 0
  %596 = getelementptr inbounds { float, float }, ptr %594, i32 0, i32 1
  store float %591, ptr %595, align 4
  store float %592, ptr %596, align 4
  %597 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %598 = load float, ptr %597, align 4
  %599 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %600 = load float, ptr %599, align 4
  %601 = load ptr, ptr %5, align 8, !tbaa !5
  %602 = getelementptr inbounds { float, float }, ptr %601, i64 8
  %603 = getelementptr inbounds { float, float }, ptr %602, i32 0, i32 0
  %604 = load float, ptr %603, align 4
  %605 = getelementptr inbounds { float, float }, ptr %602, i32 0, i32 1
  %606 = load float, ptr %605, align 4
  %607 = fadd float %604, %598
  %608 = fadd float %606, %600
  %609 = getelementptr inbounds { float, float }, ptr %602, i32 0, i32 0
  %610 = getelementptr inbounds { float, float }, ptr %602, i32 0, i32 1
  store float %607, ptr %609, align 4
  store float %608, ptr %610, align 4
  %611 = load ptr, ptr %5, align 8, !tbaa !5
  %612 = getelementptr inbounds { float, float }, ptr %611, i64 14
  %613 = getelementptr inbounds { float, float }, ptr %612, i32 0, i32 0
  %614 = load float, ptr %613, align 4
  %615 = getelementptr inbounds { float, float }, ptr %612, i32 0, i32 1
  %616 = load float, ptr %615, align 4
  %617 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %618 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %614, ptr %617, align 4
  store float %616, ptr %618, align 4
  %619 = load ptr, ptr %5, align 8, !tbaa !5
  %620 = getelementptr inbounds { float, float }, ptr %619, i64 12
  %621 = getelementptr inbounds { float, float }, ptr %620, i32 0, i32 0
  %622 = load float, ptr %621, align 4
  %623 = getelementptr inbounds { float, float }, ptr %620, i32 0, i32 1
  %624 = load float, ptr %623, align 4
  %625 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %626 = load float, ptr %625, align 4
  %627 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %628 = load float, ptr %627, align 4
  %629 = fsub float %622, %626
  %630 = fsub float %624, %628
  %631 = load ptr, ptr %5, align 8, !tbaa !5
  %632 = getelementptr inbounds { float, float }, ptr %631, i64 14
  %633 = getelementptr inbounds { float, float }, ptr %632, i32 0, i32 0
  %634 = getelementptr inbounds { float, float }, ptr %632, i32 0, i32 1
  store float %629, ptr %633, align 4
  store float %630, ptr %634, align 4
  %635 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %636 = load float, ptr %635, align 4
  %637 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %638 = load float, ptr %637, align 4
  %639 = load ptr, ptr %5, align 8, !tbaa !5
  %640 = getelementptr inbounds { float, float }, ptr %639, i64 12
  %641 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 0
  %642 = load float, ptr %641, align 4
  %643 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 1
  %644 = load float, ptr %643, align 4
  %645 = fadd float %642, %636
  %646 = fadd float %644, %638
  %647 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 0
  %648 = getelementptr inbounds { float, float }, ptr %640, i32 0, i32 1
  store float %645, ptr %647, align 4
  store float %646, ptr %648, align 4
  %649 = load i32, ptr %6, align 4, !tbaa !14
  %650 = icmp ne i32 %649, 0
  br i1 %650, label %651, label %884

651:                                              ; preds = %1
  %652 = load ptr, ptr %5, align 8, !tbaa !5
  %653 = getelementptr inbounds { float, float }, ptr %652, i64 3
  %654 = getelementptr inbounds { float, float }, ptr %653, i32 0, i32 0
  %655 = load float, ptr %654, align 4
  %656 = getelementptr inbounds { float, float }, ptr %653, i32 0, i32 1
  %657 = load float, ptr %656, align 4
  %658 = fneg float %655
  %659 = fneg float %657
  %660 = fmul float %658, 0.000000e+00
  %661 = fmul float %659, 1.000000e+00
  %662 = fmul float %658, 1.000000e+00
  %663 = fmul float %659, 0.000000e+00
  %664 = fsub float %660, %661
  %665 = fadd float %662, %663
  %666 = fcmp uno float %664, %664
  br i1 %666, label %667, label %675, !prof !15

667:                                              ; preds = %651
  %668 = fcmp uno float %665, %665
  br i1 %668, label %669, label %675, !prof !15

669:                                              ; preds = %667
  %670 = call <2 x float> @__mulsc3(float noundef %658, float noundef %659, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %670, ptr %7, align 4
  %671 = getelementptr inbounds { float, float }, ptr %7, i32 0, i32 0
  %672 = load float, ptr %671, align 4
  %673 = getelementptr inbounds { float, float }, ptr %7, i32 0, i32 1
  %674 = load float, ptr %673, align 4
  br label %675

675:                                              ; preds = %669, %667, %651
  %676 = phi float [ %664, %651 ], [ %664, %667 ], [ %672, %669 ]
  %677 = phi float [ %665, %651 ], [ %665, %667 ], [ %674, %669 ]
  %678 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %679 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %676, ptr %678, align 4
  store float %677, ptr %679, align 4
  %680 = load ptr, ptr %5, align 8, !tbaa !5
  %681 = getelementptr inbounds { float, float }, ptr %680, i64 1
  %682 = getelementptr inbounds { float, float }, ptr %681, i32 0, i32 0
  %683 = load float, ptr %682, align 4
  %684 = getelementptr inbounds { float, float }, ptr %681, i32 0, i32 1
  %685 = load float, ptr %684, align 4
  %686 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %687 = load float, ptr %686, align 4
  %688 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %689 = load float, ptr %688, align 4
  %690 = fsub float %683, %687
  %691 = fsub float %685, %689
  %692 = load ptr, ptr %5, align 8, !tbaa !5
  %693 = getelementptr inbounds { float, float }, ptr %692, i64 3
  %694 = getelementptr inbounds { float, float }, ptr %693, i32 0, i32 0
  %695 = getelementptr inbounds { float, float }, ptr %693, i32 0, i32 1
  store float %690, ptr %694, align 4
  store float %691, ptr %695, align 4
  %696 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %697 = load float, ptr %696, align 4
  %698 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %699 = load float, ptr %698, align 4
  %700 = load ptr, ptr %5, align 8, !tbaa !5
  %701 = getelementptr inbounds { float, float }, ptr %700, i64 1
  %702 = getelementptr inbounds { float, float }, ptr %701, i32 0, i32 0
  %703 = load float, ptr %702, align 4
  %704 = getelementptr inbounds { float, float }, ptr %701, i32 0, i32 1
  %705 = load float, ptr %704, align 4
  %706 = fadd float %703, %697
  %707 = fadd float %705, %699
  %708 = getelementptr inbounds { float, float }, ptr %701, i32 0, i32 0
  %709 = getelementptr inbounds { float, float }, ptr %701, i32 0, i32 1
  store float %706, ptr %708, align 4
  store float %707, ptr %709, align 4
  %710 = load ptr, ptr %5, align 8, !tbaa !5
  %711 = getelementptr inbounds { float, float }, ptr %710, i64 7
  %712 = getelementptr inbounds { float, float }, ptr %711, i32 0, i32 0
  %713 = load float, ptr %712, align 4
  %714 = getelementptr inbounds { float, float }, ptr %711, i32 0, i32 1
  %715 = load float, ptr %714, align 4
  %716 = fneg float %713
  %717 = fneg float %715
  %718 = fmul float %716, 0.000000e+00
  %719 = fmul float %717, 1.000000e+00
  %720 = fmul float %716, 1.000000e+00
  %721 = fmul float %717, 0.000000e+00
  %722 = fsub float %718, %719
  %723 = fadd float %720, %721
  %724 = fcmp uno float %722, %722
  br i1 %724, label %725, label %733, !prof !15

725:                                              ; preds = %675
  %726 = fcmp uno float %723, %723
  br i1 %726, label %727, label %733, !prof !15

727:                                              ; preds = %725
  %728 = call <2 x float> @__mulsc3(float noundef %716, float noundef %717, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %728, ptr %8, align 4
  %729 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 0
  %730 = load float, ptr %729, align 4
  %731 = getelementptr inbounds { float, float }, ptr %8, i32 0, i32 1
  %732 = load float, ptr %731, align 4
  br label %733

733:                                              ; preds = %727, %725, %675
  %734 = phi float [ %722, %675 ], [ %722, %725 ], [ %730, %727 ]
  %735 = phi float [ %723, %675 ], [ %723, %725 ], [ %732, %727 ]
  %736 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %737 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %734, ptr %736, align 4
  store float %735, ptr %737, align 4
  %738 = load ptr, ptr %5, align 8, !tbaa !5
  %739 = getelementptr inbounds { float, float }, ptr %738, i64 5
  %740 = getelementptr inbounds { float, float }, ptr %739, i32 0, i32 0
  %741 = load float, ptr %740, align 4
  %742 = getelementptr inbounds { float, float }, ptr %739, i32 0, i32 1
  %743 = load float, ptr %742, align 4
  %744 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %745 = load float, ptr %744, align 4
  %746 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %747 = load float, ptr %746, align 4
  %748 = fsub float %741, %745
  %749 = fsub float %743, %747
  %750 = load ptr, ptr %5, align 8, !tbaa !5
  %751 = getelementptr inbounds { float, float }, ptr %750, i64 7
  %752 = getelementptr inbounds { float, float }, ptr %751, i32 0, i32 0
  %753 = getelementptr inbounds { float, float }, ptr %751, i32 0, i32 1
  store float %748, ptr %752, align 4
  store float %749, ptr %753, align 4
  %754 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %755 = load float, ptr %754, align 4
  %756 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %757 = load float, ptr %756, align 4
  %758 = load ptr, ptr %5, align 8, !tbaa !5
  %759 = getelementptr inbounds { float, float }, ptr %758, i64 5
  %760 = getelementptr inbounds { float, float }, ptr %759, i32 0, i32 0
  %761 = load float, ptr %760, align 4
  %762 = getelementptr inbounds { float, float }, ptr %759, i32 0, i32 1
  %763 = load float, ptr %762, align 4
  %764 = fadd float %761, %755
  %765 = fadd float %763, %757
  %766 = getelementptr inbounds { float, float }, ptr %759, i32 0, i32 0
  %767 = getelementptr inbounds { float, float }, ptr %759, i32 0, i32 1
  store float %764, ptr %766, align 4
  store float %765, ptr %767, align 4
  %768 = load ptr, ptr %5, align 8, !tbaa !5
  %769 = getelementptr inbounds { float, float }, ptr %768, i64 11
  %770 = getelementptr inbounds { float, float }, ptr %769, i32 0, i32 0
  %771 = load float, ptr %770, align 4
  %772 = getelementptr inbounds { float, float }, ptr %769, i32 0, i32 1
  %773 = load float, ptr %772, align 4
  %774 = fneg float %771
  %775 = fneg float %773
  %776 = fmul float %774, 0.000000e+00
  %777 = fmul float %775, 1.000000e+00
  %778 = fmul float %774, 1.000000e+00
  %779 = fmul float %775, 0.000000e+00
  %780 = fsub float %776, %777
  %781 = fadd float %778, %779
  %782 = fcmp uno float %780, %780
  br i1 %782, label %783, label %791, !prof !15

783:                                              ; preds = %733
  %784 = fcmp uno float %781, %781
  br i1 %784, label %785, label %791, !prof !15

785:                                              ; preds = %783
  %786 = call <2 x float> @__mulsc3(float noundef %774, float noundef %775, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %786, ptr %9, align 4
  %787 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 0
  %788 = load float, ptr %787, align 4
  %789 = getelementptr inbounds { float, float }, ptr %9, i32 0, i32 1
  %790 = load float, ptr %789, align 4
  br label %791

791:                                              ; preds = %785, %783, %733
  %792 = phi float [ %780, %733 ], [ %780, %783 ], [ %788, %785 ]
  %793 = phi float [ %781, %733 ], [ %781, %783 ], [ %790, %785 ]
  %794 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %795 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %792, ptr %794, align 4
  store float %793, ptr %795, align 4
  %796 = load ptr, ptr %5, align 8, !tbaa !5
  %797 = getelementptr inbounds { float, float }, ptr %796, i64 9
  %798 = getelementptr inbounds { float, float }, ptr %797, i32 0, i32 0
  %799 = load float, ptr %798, align 4
  %800 = getelementptr inbounds { float, float }, ptr %797, i32 0, i32 1
  %801 = load float, ptr %800, align 4
  %802 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %803 = load float, ptr %802, align 4
  %804 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %805 = load float, ptr %804, align 4
  %806 = fsub float %799, %803
  %807 = fsub float %801, %805
  %808 = load ptr, ptr %5, align 8, !tbaa !5
  %809 = getelementptr inbounds { float, float }, ptr %808, i64 11
  %810 = getelementptr inbounds { float, float }, ptr %809, i32 0, i32 0
  %811 = getelementptr inbounds { float, float }, ptr %809, i32 0, i32 1
  store float %806, ptr %810, align 4
  store float %807, ptr %811, align 4
  %812 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %813 = load float, ptr %812, align 4
  %814 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %815 = load float, ptr %814, align 4
  %816 = load ptr, ptr %5, align 8, !tbaa !5
  %817 = getelementptr inbounds { float, float }, ptr %816, i64 9
  %818 = getelementptr inbounds { float, float }, ptr %817, i32 0, i32 0
  %819 = load float, ptr %818, align 4
  %820 = getelementptr inbounds { float, float }, ptr %817, i32 0, i32 1
  %821 = load float, ptr %820, align 4
  %822 = fadd float %819, %813
  %823 = fadd float %821, %815
  %824 = getelementptr inbounds { float, float }, ptr %817, i32 0, i32 0
  %825 = getelementptr inbounds { float, float }, ptr %817, i32 0, i32 1
  store float %822, ptr %824, align 4
  store float %823, ptr %825, align 4
  %826 = load ptr, ptr %5, align 8, !tbaa !5
  %827 = getelementptr inbounds { float, float }, ptr %826, i64 15
  %828 = getelementptr inbounds { float, float }, ptr %827, i32 0, i32 0
  %829 = load float, ptr %828, align 4
  %830 = getelementptr inbounds { float, float }, ptr %827, i32 0, i32 1
  %831 = load float, ptr %830, align 4
  %832 = fneg float %829
  %833 = fneg float %831
  %834 = fmul float %832, 0.000000e+00
  %835 = fmul float %833, 1.000000e+00
  %836 = fmul float %832, 1.000000e+00
  %837 = fmul float %833, 0.000000e+00
  %838 = fsub float %834, %835
  %839 = fadd float %836, %837
  %840 = fcmp uno float %838, %838
  br i1 %840, label %841, label %849, !prof !15

841:                                              ; preds = %791
  %842 = fcmp uno float %839, %839
  br i1 %842, label %843, label %849, !prof !15

843:                                              ; preds = %841
  %844 = call <2 x float> @__mulsc3(float noundef %832, float noundef %833, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %844, ptr %10, align 4
  %845 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 0
  %846 = load float, ptr %845, align 4
  %847 = getelementptr inbounds { float, float }, ptr %10, i32 0, i32 1
  %848 = load float, ptr %847, align 4
  br label %849

849:                                              ; preds = %843, %841, %791
  %850 = phi float [ %838, %791 ], [ %838, %841 ], [ %846, %843 ]
  %851 = phi float [ %839, %791 ], [ %839, %841 ], [ %848, %843 ]
  %852 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %853 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %850, ptr %852, align 4
  store float %851, ptr %853, align 4
  %854 = load ptr, ptr %5, align 8, !tbaa !5
  %855 = getelementptr inbounds { float, float }, ptr %854, i64 13
  %856 = getelementptr inbounds { float, float }, ptr %855, i32 0, i32 0
  %857 = load float, ptr %856, align 4
  %858 = getelementptr inbounds { float, float }, ptr %855, i32 0, i32 1
  %859 = load float, ptr %858, align 4
  %860 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %861 = load float, ptr %860, align 4
  %862 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %863 = load float, ptr %862, align 4
  %864 = fsub float %857, %861
  %865 = fsub float %859, %863
  %866 = load ptr, ptr %5, align 8, !tbaa !5
  %867 = getelementptr inbounds { float, float }, ptr %866, i64 15
  %868 = getelementptr inbounds { float, float }, ptr %867, i32 0, i32 0
  %869 = getelementptr inbounds { float, float }, ptr %867, i32 0, i32 1
  store float %864, ptr %868, align 4
  store float %865, ptr %869, align 4
  %870 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %871 = load float, ptr %870, align 4
  %872 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %873 = load float, ptr %872, align 4
  %874 = load ptr, ptr %5, align 8, !tbaa !5
  %875 = getelementptr inbounds { float, float }, ptr %874, i64 13
  %876 = getelementptr inbounds { float, float }, ptr %875, i32 0, i32 0
  %877 = load float, ptr %876, align 4
  %878 = getelementptr inbounds { float, float }, ptr %875, i32 0, i32 1
  %879 = load float, ptr %878, align 4
  %880 = fadd float %877, %871
  %881 = fadd float %879, %873
  %882 = getelementptr inbounds { float, float }, ptr %875, i32 0, i32 0
  %883 = getelementptr inbounds { float, float }, ptr %875, i32 0, i32 1
  store float %880, ptr %882, align 4
  store float %881, ptr %883, align 4
  br label %1109

884:                                              ; preds = %1
  %885 = load ptr, ptr %5, align 8, !tbaa !5
  %886 = getelementptr inbounds { float, float }, ptr %885, i64 3
  %887 = getelementptr inbounds { float, float }, ptr %886, i32 0, i32 0
  %888 = load float, ptr %887, align 4
  %889 = getelementptr inbounds { float, float }, ptr %886, i32 0, i32 1
  %890 = load float, ptr %889, align 4
  %891 = fmul float %888, 0.000000e+00
  %892 = fmul float %890, 1.000000e+00
  %893 = fmul float %888, 1.000000e+00
  %894 = fmul float %890, 0.000000e+00
  %895 = fsub float %891, %892
  %896 = fadd float %893, %894
  %897 = fcmp uno float %895, %895
  br i1 %897, label %898, label %906, !prof !15

898:                                              ; preds = %884
  %899 = fcmp uno float %896, %896
  br i1 %899, label %900, label %906, !prof !15

900:                                              ; preds = %898
  %901 = call <2 x float> @__mulsc3(float noundef %888, float noundef %890, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %901, ptr %11, align 4
  %902 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 0
  %903 = load float, ptr %902, align 4
  %904 = getelementptr inbounds { float, float }, ptr %11, i32 0, i32 1
  %905 = load float, ptr %904, align 4
  br label %906

906:                                              ; preds = %900, %898, %884
  %907 = phi float [ %895, %884 ], [ %895, %898 ], [ %903, %900 ]
  %908 = phi float [ %896, %884 ], [ %896, %898 ], [ %905, %900 ]
  %909 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %910 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %907, ptr %909, align 4
  store float %908, ptr %910, align 4
  %911 = load ptr, ptr %5, align 8, !tbaa !5
  %912 = getelementptr inbounds { float, float }, ptr %911, i64 1
  %913 = getelementptr inbounds { float, float }, ptr %912, i32 0, i32 0
  %914 = load float, ptr %913, align 4
  %915 = getelementptr inbounds { float, float }, ptr %912, i32 0, i32 1
  %916 = load float, ptr %915, align 4
  %917 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %918 = load float, ptr %917, align 4
  %919 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %920 = load float, ptr %919, align 4
  %921 = fsub float %914, %918
  %922 = fsub float %916, %920
  %923 = load ptr, ptr %5, align 8, !tbaa !5
  %924 = getelementptr inbounds { float, float }, ptr %923, i64 3
  %925 = getelementptr inbounds { float, float }, ptr %924, i32 0, i32 0
  %926 = getelementptr inbounds { float, float }, ptr %924, i32 0, i32 1
  store float %921, ptr %925, align 4
  store float %922, ptr %926, align 4
  %927 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %928 = load float, ptr %927, align 4
  %929 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %930 = load float, ptr %929, align 4
  %931 = load ptr, ptr %5, align 8, !tbaa !5
  %932 = getelementptr inbounds { float, float }, ptr %931, i64 1
  %933 = getelementptr inbounds { float, float }, ptr %932, i32 0, i32 0
  %934 = load float, ptr %933, align 4
  %935 = getelementptr inbounds { float, float }, ptr %932, i32 0, i32 1
  %936 = load float, ptr %935, align 4
  %937 = fadd float %934, %928
  %938 = fadd float %936, %930
  %939 = getelementptr inbounds { float, float }, ptr %932, i32 0, i32 0
  %940 = getelementptr inbounds { float, float }, ptr %932, i32 0, i32 1
  store float %937, ptr %939, align 4
  store float %938, ptr %940, align 4
  %941 = load ptr, ptr %5, align 8, !tbaa !5
  %942 = getelementptr inbounds { float, float }, ptr %941, i64 7
  %943 = getelementptr inbounds { float, float }, ptr %942, i32 0, i32 0
  %944 = load float, ptr %943, align 4
  %945 = getelementptr inbounds { float, float }, ptr %942, i32 0, i32 1
  %946 = load float, ptr %945, align 4
  %947 = fmul float %944, 0.000000e+00
  %948 = fmul float %946, 1.000000e+00
  %949 = fmul float %944, 1.000000e+00
  %950 = fmul float %946, 0.000000e+00
  %951 = fsub float %947, %948
  %952 = fadd float %949, %950
  %953 = fcmp uno float %951, %951
  br i1 %953, label %954, label %962, !prof !15

954:                                              ; preds = %906
  %955 = fcmp uno float %952, %952
  br i1 %955, label %956, label %962, !prof !15

956:                                              ; preds = %954
  %957 = call <2 x float> @__mulsc3(float noundef %944, float noundef %946, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %957, ptr %12, align 4
  %958 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 0
  %959 = load float, ptr %958, align 4
  %960 = getelementptr inbounds { float, float }, ptr %12, i32 0, i32 1
  %961 = load float, ptr %960, align 4
  br label %962

962:                                              ; preds = %956, %954, %906
  %963 = phi float [ %951, %906 ], [ %951, %954 ], [ %959, %956 ]
  %964 = phi float [ %952, %906 ], [ %952, %954 ], [ %961, %956 ]
  %965 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %966 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %963, ptr %965, align 4
  store float %964, ptr %966, align 4
  %967 = load ptr, ptr %5, align 8, !tbaa !5
  %968 = getelementptr inbounds { float, float }, ptr %967, i64 5
  %969 = getelementptr inbounds { float, float }, ptr %968, i32 0, i32 0
  %970 = load float, ptr %969, align 4
  %971 = getelementptr inbounds { float, float }, ptr %968, i32 0, i32 1
  %972 = load float, ptr %971, align 4
  %973 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %974 = load float, ptr %973, align 4
  %975 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %976 = load float, ptr %975, align 4
  %977 = fsub float %970, %974
  %978 = fsub float %972, %976
  %979 = load ptr, ptr %5, align 8, !tbaa !5
  %980 = getelementptr inbounds { float, float }, ptr %979, i64 7
  %981 = getelementptr inbounds { float, float }, ptr %980, i32 0, i32 0
  %982 = getelementptr inbounds { float, float }, ptr %980, i32 0, i32 1
  store float %977, ptr %981, align 4
  store float %978, ptr %982, align 4
  %983 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %984 = load float, ptr %983, align 4
  %985 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %986 = load float, ptr %985, align 4
  %987 = load ptr, ptr %5, align 8, !tbaa !5
  %988 = getelementptr inbounds { float, float }, ptr %987, i64 5
  %989 = getelementptr inbounds { float, float }, ptr %988, i32 0, i32 0
  %990 = load float, ptr %989, align 4
  %991 = getelementptr inbounds { float, float }, ptr %988, i32 0, i32 1
  %992 = load float, ptr %991, align 4
  %993 = fadd float %990, %984
  %994 = fadd float %992, %986
  %995 = getelementptr inbounds { float, float }, ptr %988, i32 0, i32 0
  %996 = getelementptr inbounds { float, float }, ptr %988, i32 0, i32 1
  store float %993, ptr %995, align 4
  store float %994, ptr %996, align 4
  %997 = load ptr, ptr %5, align 8, !tbaa !5
  %998 = getelementptr inbounds { float, float }, ptr %997, i64 11
  %999 = getelementptr inbounds { float, float }, ptr %998, i32 0, i32 0
  %1000 = load float, ptr %999, align 4
  %1001 = getelementptr inbounds { float, float }, ptr %998, i32 0, i32 1
  %1002 = load float, ptr %1001, align 4
  %1003 = fmul float %1000, 0.000000e+00
  %1004 = fmul float %1002, 1.000000e+00
  %1005 = fmul float %1000, 1.000000e+00
  %1006 = fmul float %1002, 0.000000e+00
  %1007 = fsub float %1003, %1004
  %1008 = fadd float %1005, %1006
  %1009 = fcmp uno float %1007, %1007
  br i1 %1009, label %1010, label %1018, !prof !15

1010:                                             ; preds = %962
  %1011 = fcmp uno float %1008, %1008
  br i1 %1011, label %1012, label %1018, !prof !15

1012:                                             ; preds = %1010
  %1013 = call <2 x float> @__mulsc3(float noundef %1000, float noundef %1002, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1013, ptr %13, align 4
  %1014 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 0
  %1015 = load float, ptr %1014, align 4
  %1016 = getelementptr inbounds { float, float }, ptr %13, i32 0, i32 1
  %1017 = load float, ptr %1016, align 4
  br label %1018

1018:                                             ; preds = %1012, %1010, %962
  %1019 = phi float [ %1007, %962 ], [ %1007, %1010 ], [ %1015, %1012 ]
  %1020 = phi float [ %1008, %962 ], [ %1008, %1010 ], [ %1017, %1012 ]
  %1021 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1022 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1019, ptr %1021, align 4
  store float %1020, ptr %1022, align 4
  %1023 = load ptr, ptr %5, align 8, !tbaa !5
  %1024 = getelementptr inbounds { float, float }, ptr %1023, i64 9
  %1025 = getelementptr inbounds { float, float }, ptr %1024, i32 0, i32 0
  %1026 = load float, ptr %1025, align 4
  %1027 = getelementptr inbounds { float, float }, ptr %1024, i32 0, i32 1
  %1028 = load float, ptr %1027, align 4
  %1029 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1030 = load float, ptr %1029, align 4
  %1031 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1032 = load float, ptr %1031, align 4
  %1033 = fsub float %1026, %1030
  %1034 = fsub float %1028, %1032
  %1035 = load ptr, ptr %5, align 8, !tbaa !5
  %1036 = getelementptr inbounds { float, float }, ptr %1035, i64 11
  %1037 = getelementptr inbounds { float, float }, ptr %1036, i32 0, i32 0
  %1038 = getelementptr inbounds { float, float }, ptr %1036, i32 0, i32 1
  store float %1033, ptr %1037, align 4
  store float %1034, ptr %1038, align 4
  %1039 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1040 = load float, ptr %1039, align 4
  %1041 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1042 = load float, ptr %1041, align 4
  %1043 = load ptr, ptr %5, align 8, !tbaa !5
  %1044 = getelementptr inbounds { float, float }, ptr %1043, i64 9
  %1045 = getelementptr inbounds { float, float }, ptr %1044, i32 0, i32 0
  %1046 = load float, ptr %1045, align 4
  %1047 = getelementptr inbounds { float, float }, ptr %1044, i32 0, i32 1
  %1048 = load float, ptr %1047, align 4
  %1049 = fadd float %1046, %1040
  %1050 = fadd float %1048, %1042
  %1051 = getelementptr inbounds { float, float }, ptr %1044, i32 0, i32 0
  %1052 = getelementptr inbounds { float, float }, ptr %1044, i32 0, i32 1
  store float %1049, ptr %1051, align 4
  store float %1050, ptr %1052, align 4
  %1053 = load ptr, ptr %5, align 8, !tbaa !5
  %1054 = getelementptr inbounds { float, float }, ptr %1053, i64 15
  %1055 = getelementptr inbounds { float, float }, ptr %1054, i32 0, i32 0
  %1056 = load float, ptr %1055, align 4
  %1057 = getelementptr inbounds { float, float }, ptr %1054, i32 0, i32 1
  %1058 = load float, ptr %1057, align 4
  %1059 = fmul float %1056, 0.000000e+00
  %1060 = fmul float %1058, 1.000000e+00
  %1061 = fmul float %1056, 1.000000e+00
  %1062 = fmul float %1058, 0.000000e+00
  %1063 = fsub float %1059, %1060
  %1064 = fadd float %1061, %1062
  %1065 = fcmp uno float %1063, %1063
  br i1 %1065, label %1066, label %1074, !prof !15

1066:                                             ; preds = %1018
  %1067 = fcmp uno float %1064, %1064
  br i1 %1067, label %1068, label %1074, !prof !15

1068:                                             ; preds = %1066
  %1069 = call <2 x float> @__mulsc3(float noundef %1056, float noundef %1058, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1069, ptr %14, align 4
  %1070 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 0
  %1071 = load float, ptr %1070, align 4
  %1072 = getelementptr inbounds { float, float }, ptr %14, i32 0, i32 1
  %1073 = load float, ptr %1072, align 4
  br label %1074

1074:                                             ; preds = %1068, %1066, %1018
  %1075 = phi float [ %1063, %1018 ], [ %1063, %1066 ], [ %1071, %1068 ]
  %1076 = phi float [ %1064, %1018 ], [ %1064, %1066 ], [ %1073, %1068 ]
  %1077 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1078 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1075, ptr %1077, align 4
  store float %1076, ptr %1078, align 4
  %1079 = load ptr, ptr %5, align 8, !tbaa !5
  %1080 = getelementptr inbounds { float, float }, ptr %1079, i64 13
  %1081 = getelementptr inbounds { float, float }, ptr %1080, i32 0, i32 0
  %1082 = load float, ptr %1081, align 4
  %1083 = getelementptr inbounds { float, float }, ptr %1080, i32 0, i32 1
  %1084 = load float, ptr %1083, align 4
  %1085 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1086 = load float, ptr %1085, align 4
  %1087 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1088 = load float, ptr %1087, align 4
  %1089 = fsub float %1082, %1086
  %1090 = fsub float %1084, %1088
  %1091 = load ptr, ptr %5, align 8, !tbaa !5
  %1092 = getelementptr inbounds { float, float }, ptr %1091, i64 15
  %1093 = getelementptr inbounds { float, float }, ptr %1092, i32 0, i32 0
  %1094 = getelementptr inbounds { float, float }, ptr %1092, i32 0, i32 1
  store float %1089, ptr %1093, align 4
  store float %1090, ptr %1094, align 4
  %1095 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1096 = load float, ptr %1095, align 4
  %1097 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1098 = load float, ptr %1097, align 4
  %1099 = load ptr, ptr %5, align 8, !tbaa !5
  %1100 = getelementptr inbounds { float, float }, ptr %1099, i64 13
  %1101 = getelementptr inbounds { float, float }, ptr %1100, i32 0, i32 0
  %1102 = load float, ptr %1101, align 4
  %1103 = getelementptr inbounds { float, float }, ptr %1100, i32 0, i32 1
  %1104 = load float, ptr %1103, align 4
  %1105 = fadd float %1102, %1096
  %1106 = fadd float %1104, %1098
  %1107 = getelementptr inbounds { float, float }, ptr %1100, i32 0, i32 0
  %1108 = getelementptr inbounds { float, float }, ptr %1100, i32 0, i32 1
  store float %1105, ptr %1107, align 4
  store float %1106, ptr %1108, align 4
  br label %1109

1109:                                             ; preds = %1074, %849
  %1110 = load ptr, ptr %5, align 8, !tbaa !5
  %1111 = getelementptr inbounds { float, float }, ptr %1110, i64 4
  %1112 = getelementptr inbounds { float, float }, ptr %1111, i32 0, i32 0
  %1113 = load float, ptr %1112, align 4
  %1114 = getelementptr inbounds { float, float }, ptr %1111, i32 0, i32 1
  %1115 = load float, ptr %1114, align 4
  %1116 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1117 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1113, ptr %1116, align 4
  store float %1115, ptr %1117, align 4
  %1118 = load ptr, ptr %5, align 8, !tbaa !5
  %1119 = getelementptr inbounds { float, float }, ptr %1118, i64 0
  %1120 = getelementptr inbounds { float, float }, ptr %1119, i32 0, i32 0
  %1121 = load float, ptr %1120, align 4
  %1122 = getelementptr inbounds { float, float }, ptr %1119, i32 0, i32 1
  %1123 = load float, ptr %1122, align 4
  %1124 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1125 = load float, ptr %1124, align 4
  %1126 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1127 = load float, ptr %1126, align 4
  %1128 = fsub float %1121, %1125
  %1129 = fsub float %1123, %1127
  %1130 = load ptr, ptr %5, align 8, !tbaa !5
  %1131 = getelementptr inbounds { float, float }, ptr %1130, i64 4
  %1132 = getelementptr inbounds { float, float }, ptr %1131, i32 0, i32 0
  %1133 = getelementptr inbounds { float, float }, ptr %1131, i32 0, i32 1
  store float %1128, ptr %1132, align 4
  store float %1129, ptr %1133, align 4
  %1134 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1135 = load float, ptr %1134, align 4
  %1136 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1137 = load float, ptr %1136, align 4
  %1138 = load ptr, ptr %5, align 8, !tbaa !5
  %1139 = getelementptr inbounds { float, float }, ptr %1138, i64 0
  %1140 = getelementptr inbounds { float, float }, ptr %1139, i32 0, i32 0
  %1141 = load float, ptr %1140, align 4
  %1142 = getelementptr inbounds { float, float }, ptr %1139, i32 0, i32 1
  %1143 = load float, ptr %1142, align 4
  %1144 = fadd float %1141, %1135
  %1145 = fadd float %1143, %1137
  %1146 = getelementptr inbounds { float, float }, ptr %1139, i32 0, i32 0
  %1147 = getelementptr inbounds { float, float }, ptr %1139, i32 0, i32 1
  store float %1144, ptr %1146, align 4
  store float %1145, ptr %1147, align 4
  %1148 = load ptr, ptr %5, align 8, !tbaa !5
  %1149 = getelementptr inbounds { float, float }, ptr %1148, i64 12
  %1150 = getelementptr inbounds { float, float }, ptr %1149, i32 0, i32 0
  %1151 = load float, ptr %1150, align 4
  %1152 = getelementptr inbounds { float, float }, ptr %1149, i32 0, i32 1
  %1153 = load float, ptr %1152, align 4
  %1154 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1155 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1151, ptr %1154, align 4
  store float %1153, ptr %1155, align 4
  %1156 = load ptr, ptr %5, align 8, !tbaa !5
  %1157 = getelementptr inbounds { float, float }, ptr %1156, i64 8
  %1158 = getelementptr inbounds { float, float }, ptr %1157, i32 0, i32 0
  %1159 = load float, ptr %1158, align 4
  %1160 = getelementptr inbounds { float, float }, ptr %1157, i32 0, i32 1
  %1161 = load float, ptr %1160, align 4
  %1162 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1163 = load float, ptr %1162, align 4
  %1164 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1165 = load float, ptr %1164, align 4
  %1166 = fsub float %1159, %1163
  %1167 = fsub float %1161, %1165
  %1168 = load ptr, ptr %5, align 8, !tbaa !5
  %1169 = getelementptr inbounds { float, float }, ptr %1168, i64 12
  %1170 = getelementptr inbounds { float, float }, ptr %1169, i32 0, i32 0
  %1171 = getelementptr inbounds { float, float }, ptr %1169, i32 0, i32 1
  store float %1166, ptr %1170, align 4
  store float %1167, ptr %1171, align 4
  %1172 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1173 = load float, ptr %1172, align 4
  %1174 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1175 = load float, ptr %1174, align 4
  %1176 = load ptr, ptr %5, align 8, !tbaa !5
  %1177 = getelementptr inbounds { float, float }, ptr %1176, i64 8
  %1178 = getelementptr inbounds { float, float }, ptr %1177, i32 0, i32 0
  %1179 = load float, ptr %1178, align 4
  %1180 = getelementptr inbounds { float, float }, ptr %1177, i32 0, i32 1
  %1181 = load float, ptr %1180, align 4
  %1182 = fadd float %1179, %1173
  %1183 = fadd float %1181, %1175
  %1184 = getelementptr inbounds { float, float }, ptr %1177, i32 0, i32 0
  %1185 = getelementptr inbounds { float, float }, ptr %1177, i32 0, i32 1
  store float %1182, ptr %1184, align 4
  store float %1183, ptr %1185, align 4
  %1186 = load i32, ptr %6, align 4, !tbaa !14
  %1187 = icmp ne i32 %1186, 0
  br i1 %1187, label %1188, label %1537

1188:                                             ; preds = %1109
  %1189 = load ptr, ptr %5, align 8, !tbaa !5
  %1190 = getelementptr inbounds { float, float }, ptr %1189, i64 5
  %1191 = getelementptr inbounds { float, float }, ptr %1190, i32 0, i32 0
  %1192 = load float, ptr %1191, align 4
  %1193 = getelementptr inbounds { float, float }, ptr %1190, i32 0, i32 1
  %1194 = load float, ptr %1193, align 4
  %1195 = fpext float %1192 to double
  %1196 = fpext float %1194 to double
  %1197 = fmul double %1195, 0x3FE6A09E607DC426
  %1198 = fmul double %1196, 0xBFE6A09E607DC426
  %1199 = fmul double %1195, 0xBFE6A09E607DC426
  %1200 = fmul double %1196, 0x3FE6A09E607DC426
  %1201 = fsub double %1197, %1198
  %1202 = fadd double %1199, %1200
  %1203 = fcmp uno double %1201, %1201
  br i1 %1203, label %1204, label %1210, !prof !15

1204:                                             ; preds = %1188
  %1205 = fcmp uno double %1202, %1202
  br i1 %1205, label %1206, label %1210, !prof !15

1206:                                             ; preds = %1204
  %1207 = call { double, double } @__muldc3(double noundef %1195, double noundef %1196, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %1208 = extractvalue { double, double } %1207, 0
  %1209 = extractvalue { double, double } %1207, 1
  br label %1210

1210:                                             ; preds = %1206, %1204, %1188
  %1211 = phi double [ %1201, %1188 ], [ %1201, %1204 ], [ %1208, %1206 ]
  %1212 = phi double [ %1202, %1188 ], [ %1202, %1204 ], [ %1209, %1206 ]
  %1213 = fptrunc double %1211 to float
  %1214 = fptrunc double %1212 to float
  %1215 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1216 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1213, ptr %1215, align 4
  store float %1214, ptr %1216, align 4
  %1217 = load ptr, ptr %5, align 8, !tbaa !5
  %1218 = getelementptr inbounds { float, float }, ptr %1217, i64 1
  %1219 = getelementptr inbounds { float, float }, ptr %1218, i32 0, i32 0
  %1220 = load float, ptr %1219, align 4
  %1221 = getelementptr inbounds { float, float }, ptr %1218, i32 0, i32 1
  %1222 = load float, ptr %1221, align 4
  %1223 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1224 = load float, ptr %1223, align 4
  %1225 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1226 = load float, ptr %1225, align 4
  %1227 = fsub float %1220, %1224
  %1228 = fsub float %1222, %1226
  %1229 = load ptr, ptr %5, align 8, !tbaa !5
  %1230 = getelementptr inbounds { float, float }, ptr %1229, i64 5
  %1231 = getelementptr inbounds { float, float }, ptr %1230, i32 0, i32 0
  %1232 = getelementptr inbounds { float, float }, ptr %1230, i32 0, i32 1
  store float %1227, ptr %1231, align 4
  store float %1228, ptr %1232, align 4
  %1233 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1234 = load float, ptr %1233, align 4
  %1235 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1236 = load float, ptr %1235, align 4
  %1237 = load ptr, ptr %5, align 8, !tbaa !5
  %1238 = getelementptr inbounds { float, float }, ptr %1237, i64 1
  %1239 = getelementptr inbounds { float, float }, ptr %1238, i32 0, i32 0
  %1240 = load float, ptr %1239, align 4
  %1241 = getelementptr inbounds { float, float }, ptr %1238, i32 0, i32 1
  %1242 = load float, ptr %1241, align 4
  %1243 = fadd float %1240, %1234
  %1244 = fadd float %1242, %1236
  %1245 = getelementptr inbounds { float, float }, ptr %1238, i32 0, i32 0
  %1246 = getelementptr inbounds { float, float }, ptr %1238, i32 0, i32 1
  store float %1243, ptr %1245, align 4
  store float %1244, ptr %1246, align 4
  %1247 = load ptr, ptr %5, align 8, !tbaa !5
  %1248 = getelementptr inbounds { float, float }, ptr %1247, i64 13
  %1249 = getelementptr inbounds { float, float }, ptr %1248, i32 0, i32 0
  %1250 = load float, ptr %1249, align 4
  %1251 = getelementptr inbounds { float, float }, ptr %1248, i32 0, i32 1
  %1252 = load float, ptr %1251, align 4
  %1253 = fpext float %1250 to double
  %1254 = fpext float %1252 to double
  %1255 = fmul double %1253, 0x3FE6A09E607DC426
  %1256 = fmul double %1254, 0xBFE6A09E607DC426
  %1257 = fmul double %1253, 0xBFE6A09E607DC426
  %1258 = fmul double %1254, 0x3FE6A09E607DC426
  %1259 = fsub double %1255, %1256
  %1260 = fadd double %1257, %1258
  %1261 = fcmp uno double %1259, %1259
  br i1 %1261, label %1262, label %1268, !prof !15

1262:                                             ; preds = %1210
  %1263 = fcmp uno double %1260, %1260
  br i1 %1263, label %1264, label %1268, !prof !15

1264:                                             ; preds = %1262
  %1265 = call { double, double } @__muldc3(double noundef %1253, double noundef %1254, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %1266 = extractvalue { double, double } %1265, 0
  %1267 = extractvalue { double, double } %1265, 1
  br label %1268

1268:                                             ; preds = %1264, %1262, %1210
  %1269 = phi double [ %1259, %1210 ], [ %1259, %1262 ], [ %1266, %1264 ]
  %1270 = phi double [ %1260, %1210 ], [ %1260, %1262 ], [ %1267, %1264 ]
  %1271 = fptrunc double %1269 to float
  %1272 = fptrunc double %1270 to float
  %1273 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1274 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1271, ptr %1273, align 4
  store float %1272, ptr %1274, align 4
  %1275 = load ptr, ptr %5, align 8, !tbaa !5
  %1276 = getelementptr inbounds { float, float }, ptr %1275, i64 9
  %1277 = getelementptr inbounds { float, float }, ptr %1276, i32 0, i32 0
  %1278 = load float, ptr %1277, align 4
  %1279 = getelementptr inbounds { float, float }, ptr %1276, i32 0, i32 1
  %1280 = load float, ptr %1279, align 4
  %1281 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1282 = load float, ptr %1281, align 4
  %1283 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1284 = load float, ptr %1283, align 4
  %1285 = fsub float %1278, %1282
  %1286 = fsub float %1280, %1284
  %1287 = load ptr, ptr %5, align 8, !tbaa !5
  %1288 = getelementptr inbounds { float, float }, ptr %1287, i64 13
  %1289 = getelementptr inbounds { float, float }, ptr %1288, i32 0, i32 0
  %1290 = getelementptr inbounds { float, float }, ptr %1288, i32 0, i32 1
  store float %1285, ptr %1289, align 4
  store float %1286, ptr %1290, align 4
  %1291 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1292 = load float, ptr %1291, align 4
  %1293 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1294 = load float, ptr %1293, align 4
  %1295 = load ptr, ptr %5, align 8, !tbaa !5
  %1296 = getelementptr inbounds { float, float }, ptr %1295, i64 9
  %1297 = getelementptr inbounds { float, float }, ptr %1296, i32 0, i32 0
  %1298 = load float, ptr %1297, align 4
  %1299 = getelementptr inbounds { float, float }, ptr %1296, i32 0, i32 1
  %1300 = load float, ptr %1299, align 4
  %1301 = fadd float %1298, %1292
  %1302 = fadd float %1300, %1294
  %1303 = getelementptr inbounds { float, float }, ptr %1296, i32 0, i32 0
  %1304 = getelementptr inbounds { float, float }, ptr %1296, i32 0, i32 1
  store float %1301, ptr %1303, align 4
  store float %1302, ptr %1304, align 4
  %1305 = load ptr, ptr %5, align 8, !tbaa !5
  %1306 = getelementptr inbounds { float, float }, ptr %1305, i64 6
  %1307 = getelementptr inbounds { float, float }, ptr %1306, i32 0, i32 0
  %1308 = load float, ptr %1307, align 4
  %1309 = getelementptr inbounds { float, float }, ptr %1306, i32 0, i32 1
  %1310 = load float, ptr %1309, align 4
  %1311 = fneg float %1308
  %1312 = fneg float %1310
  %1313 = fmul float %1311, 0.000000e+00
  %1314 = fmul float %1312, 1.000000e+00
  %1315 = fmul float %1311, 1.000000e+00
  %1316 = fmul float %1312, 0.000000e+00
  %1317 = fsub float %1313, %1314
  %1318 = fadd float %1315, %1316
  %1319 = fcmp uno float %1317, %1317
  br i1 %1319, label %1320, label %1328, !prof !15

1320:                                             ; preds = %1268
  %1321 = fcmp uno float %1318, %1318
  br i1 %1321, label %1322, label %1328, !prof !15

1322:                                             ; preds = %1320
  %1323 = call <2 x float> @__mulsc3(float noundef %1311, float noundef %1312, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1323, ptr %15, align 4
  %1324 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 0
  %1325 = load float, ptr %1324, align 4
  %1326 = getelementptr inbounds { float, float }, ptr %15, i32 0, i32 1
  %1327 = load float, ptr %1326, align 4
  br label %1328

1328:                                             ; preds = %1322, %1320, %1268
  %1329 = phi float [ %1317, %1268 ], [ %1317, %1320 ], [ %1325, %1322 ]
  %1330 = phi float [ %1318, %1268 ], [ %1318, %1320 ], [ %1327, %1322 ]
  %1331 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1332 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1329, ptr %1331, align 4
  store float %1330, ptr %1332, align 4
  %1333 = load ptr, ptr %5, align 8, !tbaa !5
  %1334 = getelementptr inbounds { float, float }, ptr %1333, i64 2
  %1335 = getelementptr inbounds { float, float }, ptr %1334, i32 0, i32 0
  %1336 = load float, ptr %1335, align 4
  %1337 = getelementptr inbounds { float, float }, ptr %1334, i32 0, i32 1
  %1338 = load float, ptr %1337, align 4
  %1339 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1340 = load float, ptr %1339, align 4
  %1341 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1342 = load float, ptr %1341, align 4
  %1343 = fsub float %1336, %1340
  %1344 = fsub float %1338, %1342
  %1345 = load ptr, ptr %5, align 8, !tbaa !5
  %1346 = getelementptr inbounds { float, float }, ptr %1345, i64 6
  %1347 = getelementptr inbounds { float, float }, ptr %1346, i32 0, i32 0
  %1348 = getelementptr inbounds { float, float }, ptr %1346, i32 0, i32 1
  store float %1343, ptr %1347, align 4
  store float %1344, ptr %1348, align 4
  %1349 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1350 = load float, ptr %1349, align 4
  %1351 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1352 = load float, ptr %1351, align 4
  %1353 = load ptr, ptr %5, align 8, !tbaa !5
  %1354 = getelementptr inbounds { float, float }, ptr %1353, i64 2
  %1355 = getelementptr inbounds { float, float }, ptr %1354, i32 0, i32 0
  %1356 = load float, ptr %1355, align 4
  %1357 = getelementptr inbounds { float, float }, ptr %1354, i32 0, i32 1
  %1358 = load float, ptr %1357, align 4
  %1359 = fadd float %1356, %1350
  %1360 = fadd float %1358, %1352
  %1361 = getelementptr inbounds { float, float }, ptr %1354, i32 0, i32 0
  %1362 = getelementptr inbounds { float, float }, ptr %1354, i32 0, i32 1
  store float %1359, ptr %1361, align 4
  store float %1360, ptr %1362, align 4
  %1363 = load ptr, ptr %5, align 8, !tbaa !5
  %1364 = getelementptr inbounds { float, float }, ptr %1363, i64 14
  %1365 = getelementptr inbounds { float, float }, ptr %1364, i32 0, i32 0
  %1366 = load float, ptr %1365, align 4
  %1367 = getelementptr inbounds { float, float }, ptr %1364, i32 0, i32 1
  %1368 = load float, ptr %1367, align 4
  %1369 = fneg float %1366
  %1370 = fneg float %1368
  %1371 = fmul float %1369, 0.000000e+00
  %1372 = fmul float %1370, 1.000000e+00
  %1373 = fmul float %1369, 1.000000e+00
  %1374 = fmul float %1370, 0.000000e+00
  %1375 = fsub float %1371, %1372
  %1376 = fadd float %1373, %1374
  %1377 = fcmp uno float %1375, %1375
  br i1 %1377, label %1378, label %1386, !prof !15

1378:                                             ; preds = %1328
  %1379 = fcmp uno float %1376, %1376
  br i1 %1379, label %1380, label %1386, !prof !15

1380:                                             ; preds = %1378
  %1381 = call <2 x float> @__mulsc3(float noundef %1369, float noundef %1370, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1381, ptr %16, align 4
  %1382 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 0
  %1383 = load float, ptr %1382, align 4
  %1384 = getelementptr inbounds { float, float }, ptr %16, i32 0, i32 1
  %1385 = load float, ptr %1384, align 4
  br label %1386

1386:                                             ; preds = %1380, %1378, %1328
  %1387 = phi float [ %1375, %1328 ], [ %1375, %1378 ], [ %1383, %1380 ]
  %1388 = phi float [ %1376, %1328 ], [ %1376, %1378 ], [ %1385, %1380 ]
  %1389 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1390 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1387, ptr %1389, align 4
  store float %1388, ptr %1390, align 4
  %1391 = load ptr, ptr %5, align 8, !tbaa !5
  %1392 = getelementptr inbounds { float, float }, ptr %1391, i64 10
  %1393 = getelementptr inbounds { float, float }, ptr %1392, i32 0, i32 0
  %1394 = load float, ptr %1393, align 4
  %1395 = getelementptr inbounds { float, float }, ptr %1392, i32 0, i32 1
  %1396 = load float, ptr %1395, align 4
  %1397 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1398 = load float, ptr %1397, align 4
  %1399 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1400 = load float, ptr %1399, align 4
  %1401 = fsub float %1394, %1398
  %1402 = fsub float %1396, %1400
  %1403 = load ptr, ptr %5, align 8, !tbaa !5
  %1404 = getelementptr inbounds { float, float }, ptr %1403, i64 14
  %1405 = getelementptr inbounds { float, float }, ptr %1404, i32 0, i32 0
  %1406 = getelementptr inbounds { float, float }, ptr %1404, i32 0, i32 1
  store float %1401, ptr %1405, align 4
  store float %1402, ptr %1406, align 4
  %1407 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1408 = load float, ptr %1407, align 4
  %1409 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1410 = load float, ptr %1409, align 4
  %1411 = load ptr, ptr %5, align 8, !tbaa !5
  %1412 = getelementptr inbounds { float, float }, ptr %1411, i64 10
  %1413 = getelementptr inbounds { float, float }, ptr %1412, i32 0, i32 0
  %1414 = load float, ptr %1413, align 4
  %1415 = getelementptr inbounds { float, float }, ptr %1412, i32 0, i32 1
  %1416 = load float, ptr %1415, align 4
  %1417 = fadd float %1414, %1408
  %1418 = fadd float %1416, %1410
  %1419 = getelementptr inbounds { float, float }, ptr %1412, i32 0, i32 0
  %1420 = getelementptr inbounds { float, float }, ptr %1412, i32 0, i32 1
  store float %1417, ptr %1419, align 4
  store float %1418, ptr %1420, align 4
  %1421 = load ptr, ptr %5, align 8, !tbaa !5
  %1422 = getelementptr inbounds { float, float }, ptr %1421, i64 7
  %1423 = getelementptr inbounds { float, float }, ptr %1422, i32 0, i32 0
  %1424 = load float, ptr %1423, align 4
  %1425 = getelementptr inbounds { float, float }, ptr %1422, i32 0, i32 1
  %1426 = load float, ptr %1425, align 4
  %1427 = fpext float %1424 to double
  %1428 = fpext float %1426 to double
  %1429 = fmul double %1427, 0xBFE6A09E607DC426
  %1430 = fmul double %1428, 0xBFE6A09E607DC426
  %1431 = fmul double %1427, 0xBFE6A09E607DC426
  %1432 = fmul double %1428, 0xBFE6A09E607DC426
  %1433 = fsub double %1429, %1430
  %1434 = fadd double %1431, %1432
  %1435 = fcmp uno double %1433, %1433
  br i1 %1435, label %1436, label %1442, !prof !15

1436:                                             ; preds = %1386
  %1437 = fcmp uno double %1434, %1434
  br i1 %1437, label %1438, label %1442, !prof !15

1438:                                             ; preds = %1436
  %1439 = call { double, double } @__muldc3(double noundef %1427, double noundef %1428, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %1440 = extractvalue { double, double } %1439, 0
  %1441 = extractvalue { double, double } %1439, 1
  br label %1442

1442:                                             ; preds = %1438, %1436, %1386
  %1443 = phi double [ %1433, %1386 ], [ %1433, %1436 ], [ %1440, %1438 ]
  %1444 = phi double [ %1434, %1386 ], [ %1434, %1436 ], [ %1441, %1438 ]
  %1445 = fptrunc double %1443 to float
  %1446 = fptrunc double %1444 to float
  %1447 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1448 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1445, ptr %1447, align 4
  store float %1446, ptr %1448, align 4
  %1449 = load ptr, ptr %5, align 8, !tbaa !5
  %1450 = getelementptr inbounds { float, float }, ptr %1449, i64 3
  %1451 = getelementptr inbounds { float, float }, ptr %1450, i32 0, i32 0
  %1452 = load float, ptr %1451, align 4
  %1453 = getelementptr inbounds { float, float }, ptr %1450, i32 0, i32 1
  %1454 = load float, ptr %1453, align 4
  %1455 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1456 = load float, ptr %1455, align 4
  %1457 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1458 = load float, ptr %1457, align 4
  %1459 = fsub float %1452, %1456
  %1460 = fsub float %1454, %1458
  %1461 = load ptr, ptr %5, align 8, !tbaa !5
  %1462 = getelementptr inbounds { float, float }, ptr %1461, i64 7
  %1463 = getelementptr inbounds { float, float }, ptr %1462, i32 0, i32 0
  %1464 = getelementptr inbounds { float, float }, ptr %1462, i32 0, i32 1
  store float %1459, ptr %1463, align 4
  store float %1460, ptr %1464, align 4
  %1465 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1466 = load float, ptr %1465, align 4
  %1467 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1468 = load float, ptr %1467, align 4
  %1469 = load ptr, ptr %5, align 8, !tbaa !5
  %1470 = getelementptr inbounds { float, float }, ptr %1469, i64 3
  %1471 = getelementptr inbounds { float, float }, ptr %1470, i32 0, i32 0
  %1472 = load float, ptr %1471, align 4
  %1473 = getelementptr inbounds { float, float }, ptr %1470, i32 0, i32 1
  %1474 = load float, ptr %1473, align 4
  %1475 = fadd float %1472, %1466
  %1476 = fadd float %1474, %1468
  %1477 = getelementptr inbounds { float, float }, ptr %1470, i32 0, i32 0
  %1478 = getelementptr inbounds { float, float }, ptr %1470, i32 0, i32 1
  store float %1475, ptr %1477, align 4
  store float %1476, ptr %1478, align 4
  %1479 = load ptr, ptr %5, align 8, !tbaa !5
  %1480 = getelementptr inbounds { float, float }, ptr %1479, i64 15
  %1481 = getelementptr inbounds { float, float }, ptr %1480, i32 0, i32 0
  %1482 = load float, ptr %1481, align 4
  %1483 = getelementptr inbounds { float, float }, ptr %1480, i32 0, i32 1
  %1484 = load float, ptr %1483, align 4
  %1485 = fpext float %1482 to double
  %1486 = fpext float %1484 to double
  %1487 = fmul double %1485, 0xBFE6A09E607DC426
  %1488 = fmul double %1486, 0xBFE6A09E607DC426
  %1489 = fmul double %1485, 0xBFE6A09E607DC426
  %1490 = fmul double %1486, 0xBFE6A09E607DC426
  %1491 = fsub double %1487, %1488
  %1492 = fadd double %1489, %1490
  %1493 = fcmp uno double %1491, %1491
  br i1 %1493, label %1494, label %1500, !prof !15

1494:                                             ; preds = %1442
  %1495 = fcmp uno double %1492, %1492
  br i1 %1495, label %1496, label %1500, !prof !15

1496:                                             ; preds = %1494
  %1497 = call { double, double } @__muldc3(double noundef %1485, double noundef %1486, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %1498 = extractvalue { double, double } %1497, 0
  %1499 = extractvalue { double, double } %1497, 1
  br label %1500

1500:                                             ; preds = %1496, %1494, %1442
  %1501 = phi double [ %1491, %1442 ], [ %1491, %1494 ], [ %1498, %1496 ]
  %1502 = phi double [ %1492, %1442 ], [ %1492, %1494 ], [ %1499, %1496 ]
  %1503 = fptrunc double %1501 to float
  %1504 = fptrunc double %1502 to float
  %1505 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1506 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1503, ptr %1505, align 4
  store float %1504, ptr %1506, align 4
  %1507 = load ptr, ptr %5, align 8, !tbaa !5
  %1508 = getelementptr inbounds { float, float }, ptr %1507, i64 11
  %1509 = getelementptr inbounds { float, float }, ptr %1508, i32 0, i32 0
  %1510 = load float, ptr %1509, align 4
  %1511 = getelementptr inbounds { float, float }, ptr %1508, i32 0, i32 1
  %1512 = load float, ptr %1511, align 4
  %1513 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1514 = load float, ptr %1513, align 4
  %1515 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1516 = load float, ptr %1515, align 4
  %1517 = fsub float %1510, %1514
  %1518 = fsub float %1512, %1516
  %1519 = load ptr, ptr %5, align 8, !tbaa !5
  %1520 = getelementptr inbounds { float, float }, ptr %1519, i64 15
  %1521 = getelementptr inbounds { float, float }, ptr %1520, i32 0, i32 0
  %1522 = getelementptr inbounds { float, float }, ptr %1520, i32 0, i32 1
  store float %1517, ptr %1521, align 4
  store float %1518, ptr %1522, align 4
  %1523 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1524 = load float, ptr %1523, align 4
  %1525 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1526 = load float, ptr %1525, align 4
  %1527 = load ptr, ptr %5, align 8, !tbaa !5
  %1528 = getelementptr inbounds { float, float }, ptr %1527, i64 11
  %1529 = getelementptr inbounds { float, float }, ptr %1528, i32 0, i32 0
  %1530 = load float, ptr %1529, align 4
  %1531 = getelementptr inbounds { float, float }, ptr %1528, i32 0, i32 1
  %1532 = load float, ptr %1531, align 4
  %1533 = fadd float %1530, %1524
  %1534 = fadd float %1532, %1526
  %1535 = getelementptr inbounds { float, float }, ptr %1528, i32 0, i32 0
  %1536 = getelementptr inbounds { float, float }, ptr %1528, i32 0, i32 1
  store float %1533, ptr %1535, align 4
  store float %1534, ptr %1536, align 4
  br label %1882

1537:                                             ; preds = %1109
  %1538 = load ptr, ptr %5, align 8, !tbaa !5
  %1539 = getelementptr inbounds { float, float }, ptr %1538, i64 5
  %1540 = getelementptr inbounds { float, float }, ptr %1539, i32 0, i32 0
  %1541 = load float, ptr %1540, align 4
  %1542 = getelementptr inbounds { float, float }, ptr %1539, i32 0, i32 1
  %1543 = load float, ptr %1542, align 4
  %1544 = fpext float %1541 to double
  %1545 = fpext float %1543 to double
  %1546 = fmul double %1544, 0x3FE6A09E607DC426
  %1547 = fmul double %1545, 0x3FE6A09E607DC426
  %1548 = fmul double %1544, 0x3FE6A09E607DC426
  %1549 = fmul double %1545, 0x3FE6A09E607DC426
  %1550 = fsub double %1546, %1547
  %1551 = fadd double %1548, %1549
  %1552 = fcmp uno double %1550, %1550
  br i1 %1552, label %1553, label %1559, !prof !15

1553:                                             ; preds = %1537
  %1554 = fcmp uno double %1551, %1551
  br i1 %1554, label %1555, label %1559, !prof !15

1555:                                             ; preds = %1553
  %1556 = call { double, double } @__muldc3(double noundef %1544, double noundef %1545, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %1557 = extractvalue { double, double } %1556, 0
  %1558 = extractvalue { double, double } %1556, 1
  br label %1559

1559:                                             ; preds = %1555, %1553, %1537
  %1560 = phi double [ %1550, %1537 ], [ %1550, %1553 ], [ %1557, %1555 ]
  %1561 = phi double [ %1551, %1537 ], [ %1551, %1553 ], [ %1558, %1555 ]
  %1562 = fptrunc double %1560 to float
  %1563 = fptrunc double %1561 to float
  %1564 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1565 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1562, ptr %1564, align 4
  store float %1563, ptr %1565, align 4
  %1566 = load ptr, ptr %5, align 8, !tbaa !5
  %1567 = getelementptr inbounds { float, float }, ptr %1566, i64 1
  %1568 = getelementptr inbounds { float, float }, ptr %1567, i32 0, i32 0
  %1569 = load float, ptr %1568, align 4
  %1570 = getelementptr inbounds { float, float }, ptr %1567, i32 0, i32 1
  %1571 = load float, ptr %1570, align 4
  %1572 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1573 = load float, ptr %1572, align 4
  %1574 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1575 = load float, ptr %1574, align 4
  %1576 = fsub float %1569, %1573
  %1577 = fsub float %1571, %1575
  %1578 = load ptr, ptr %5, align 8, !tbaa !5
  %1579 = getelementptr inbounds { float, float }, ptr %1578, i64 5
  %1580 = getelementptr inbounds { float, float }, ptr %1579, i32 0, i32 0
  %1581 = getelementptr inbounds { float, float }, ptr %1579, i32 0, i32 1
  store float %1576, ptr %1580, align 4
  store float %1577, ptr %1581, align 4
  %1582 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1583 = load float, ptr %1582, align 4
  %1584 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1585 = load float, ptr %1584, align 4
  %1586 = load ptr, ptr %5, align 8, !tbaa !5
  %1587 = getelementptr inbounds { float, float }, ptr %1586, i64 1
  %1588 = getelementptr inbounds { float, float }, ptr %1587, i32 0, i32 0
  %1589 = load float, ptr %1588, align 4
  %1590 = getelementptr inbounds { float, float }, ptr %1587, i32 0, i32 1
  %1591 = load float, ptr %1590, align 4
  %1592 = fadd float %1589, %1583
  %1593 = fadd float %1591, %1585
  %1594 = getelementptr inbounds { float, float }, ptr %1587, i32 0, i32 0
  %1595 = getelementptr inbounds { float, float }, ptr %1587, i32 0, i32 1
  store float %1592, ptr %1594, align 4
  store float %1593, ptr %1595, align 4
  %1596 = load ptr, ptr %5, align 8, !tbaa !5
  %1597 = getelementptr inbounds { float, float }, ptr %1596, i64 13
  %1598 = getelementptr inbounds { float, float }, ptr %1597, i32 0, i32 0
  %1599 = load float, ptr %1598, align 4
  %1600 = getelementptr inbounds { float, float }, ptr %1597, i32 0, i32 1
  %1601 = load float, ptr %1600, align 4
  %1602 = fpext float %1599 to double
  %1603 = fpext float %1601 to double
  %1604 = fmul double %1602, 0x3FE6A09E607DC426
  %1605 = fmul double %1603, 0x3FE6A09E607DC426
  %1606 = fmul double %1602, 0x3FE6A09E607DC426
  %1607 = fmul double %1603, 0x3FE6A09E607DC426
  %1608 = fsub double %1604, %1605
  %1609 = fadd double %1606, %1607
  %1610 = fcmp uno double %1608, %1608
  br i1 %1610, label %1611, label %1617, !prof !15

1611:                                             ; preds = %1559
  %1612 = fcmp uno double %1609, %1609
  br i1 %1612, label %1613, label %1617, !prof !15

1613:                                             ; preds = %1611
  %1614 = call { double, double } @__muldc3(double noundef %1602, double noundef %1603, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %1615 = extractvalue { double, double } %1614, 0
  %1616 = extractvalue { double, double } %1614, 1
  br label %1617

1617:                                             ; preds = %1613, %1611, %1559
  %1618 = phi double [ %1608, %1559 ], [ %1608, %1611 ], [ %1615, %1613 ]
  %1619 = phi double [ %1609, %1559 ], [ %1609, %1611 ], [ %1616, %1613 ]
  %1620 = fptrunc double %1618 to float
  %1621 = fptrunc double %1619 to float
  %1622 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1623 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1620, ptr %1622, align 4
  store float %1621, ptr %1623, align 4
  %1624 = load ptr, ptr %5, align 8, !tbaa !5
  %1625 = getelementptr inbounds { float, float }, ptr %1624, i64 9
  %1626 = getelementptr inbounds { float, float }, ptr %1625, i32 0, i32 0
  %1627 = load float, ptr %1626, align 4
  %1628 = getelementptr inbounds { float, float }, ptr %1625, i32 0, i32 1
  %1629 = load float, ptr %1628, align 4
  %1630 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1631 = load float, ptr %1630, align 4
  %1632 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1633 = load float, ptr %1632, align 4
  %1634 = fsub float %1627, %1631
  %1635 = fsub float %1629, %1633
  %1636 = load ptr, ptr %5, align 8, !tbaa !5
  %1637 = getelementptr inbounds { float, float }, ptr %1636, i64 13
  %1638 = getelementptr inbounds { float, float }, ptr %1637, i32 0, i32 0
  %1639 = getelementptr inbounds { float, float }, ptr %1637, i32 0, i32 1
  store float %1634, ptr %1638, align 4
  store float %1635, ptr %1639, align 4
  %1640 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1641 = load float, ptr %1640, align 4
  %1642 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1643 = load float, ptr %1642, align 4
  %1644 = load ptr, ptr %5, align 8, !tbaa !5
  %1645 = getelementptr inbounds { float, float }, ptr %1644, i64 9
  %1646 = getelementptr inbounds { float, float }, ptr %1645, i32 0, i32 0
  %1647 = load float, ptr %1646, align 4
  %1648 = getelementptr inbounds { float, float }, ptr %1645, i32 0, i32 1
  %1649 = load float, ptr %1648, align 4
  %1650 = fadd float %1647, %1641
  %1651 = fadd float %1649, %1643
  %1652 = getelementptr inbounds { float, float }, ptr %1645, i32 0, i32 0
  %1653 = getelementptr inbounds { float, float }, ptr %1645, i32 0, i32 1
  store float %1650, ptr %1652, align 4
  store float %1651, ptr %1653, align 4
  %1654 = load ptr, ptr %5, align 8, !tbaa !5
  %1655 = getelementptr inbounds { float, float }, ptr %1654, i64 6
  %1656 = getelementptr inbounds { float, float }, ptr %1655, i32 0, i32 0
  %1657 = load float, ptr %1656, align 4
  %1658 = getelementptr inbounds { float, float }, ptr %1655, i32 0, i32 1
  %1659 = load float, ptr %1658, align 4
  %1660 = fmul float %1657, 0.000000e+00
  %1661 = fmul float %1659, 1.000000e+00
  %1662 = fmul float %1657, 1.000000e+00
  %1663 = fmul float %1659, 0.000000e+00
  %1664 = fsub float %1660, %1661
  %1665 = fadd float %1662, %1663
  %1666 = fcmp uno float %1664, %1664
  br i1 %1666, label %1667, label %1675, !prof !15

1667:                                             ; preds = %1617
  %1668 = fcmp uno float %1665, %1665
  br i1 %1668, label %1669, label %1675, !prof !15

1669:                                             ; preds = %1667
  %1670 = call <2 x float> @__mulsc3(float noundef %1657, float noundef %1659, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1670, ptr %17, align 4
  %1671 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 0
  %1672 = load float, ptr %1671, align 4
  %1673 = getelementptr inbounds { float, float }, ptr %17, i32 0, i32 1
  %1674 = load float, ptr %1673, align 4
  br label %1675

1675:                                             ; preds = %1669, %1667, %1617
  %1676 = phi float [ %1664, %1617 ], [ %1664, %1667 ], [ %1672, %1669 ]
  %1677 = phi float [ %1665, %1617 ], [ %1665, %1667 ], [ %1674, %1669 ]
  %1678 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1679 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1676, ptr %1678, align 4
  store float %1677, ptr %1679, align 4
  %1680 = load ptr, ptr %5, align 8, !tbaa !5
  %1681 = getelementptr inbounds { float, float }, ptr %1680, i64 2
  %1682 = getelementptr inbounds { float, float }, ptr %1681, i32 0, i32 0
  %1683 = load float, ptr %1682, align 4
  %1684 = getelementptr inbounds { float, float }, ptr %1681, i32 0, i32 1
  %1685 = load float, ptr %1684, align 4
  %1686 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1687 = load float, ptr %1686, align 4
  %1688 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1689 = load float, ptr %1688, align 4
  %1690 = fsub float %1683, %1687
  %1691 = fsub float %1685, %1689
  %1692 = load ptr, ptr %5, align 8, !tbaa !5
  %1693 = getelementptr inbounds { float, float }, ptr %1692, i64 6
  %1694 = getelementptr inbounds { float, float }, ptr %1693, i32 0, i32 0
  %1695 = getelementptr inbounds { float, float }, ptr %1693, i32 0, i32 1
  store float %1690, ptr %1694, align 4
  store float %1691, ptr %1695, align 4
  %1696 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1697 = load float, ptr %1696, align 4
  %1698 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1699 = load float, ptr %1698, align 4
  %1700 = load ptr, ptr %5, align 8, !tbaa !5
  %1701 = getelementptr inbounds { float, float }, ptr %1700, i64 2
  %1702 = getelementptr inbounds { float, float }, ptr %1701, i32 0, i32 0
  %1703 = load float, ptr %1702, align 4
  %1704 = getelementptr inbounds { float, float }, ptr %1701, i32 0, i32 1
  %1705 = load float, ptr %1704, align 4
  %1706 = fadd float %1703, %1697
  %1707 = fadd float %1705, %1699
  %1708 = getelementptr inbounds { float, float }, ptr %1701, i32 0, i32 0
  %1709 = getelementptr inbounds { float, float }, ptr %1701, i32 0, i32 1
  store float %1706, ptr %1708, align 4
  store float %1707, ptr %1709, align 4
  %1710 = load ptr, ptr %5, align 8, !tbaa !5
  %1711 = getelementptr inbounds { float, float }, ptr %1710, i64 14
  %1712 = getelementptr inbounds { float, float }, ptr %1711, i32 0, i32 0
  %1713 = load float, ptr %1712, align 4
  %1714 = getelementptr inbounds { float, float }, ptr %1711, i32 0, i32 1
  %1715 = load float, ptr %1714, align 4
  %1716 = fmul float %1713, 0.000000e+00
  %1717 = fmul float %1715, 1.000000e+00
  %1718 = fmul float %1713, 1.000000e+00
  %1719 = fmul float %1715, 0.000000e+00
  %1720 = fsub float %1716, %1717
  %1721 = fadd float %1718, %1719
  %1722 = fcmp uno float %1720, %1720
  br i1 %1722, label %1723, label %1731, !prof !15

1723:                                             ; preds = %1675
  %1724 = fcmp uno float %1721, %1721
  br i1 %1724, label %1725, label %1731, !prof !15

1725:                                             ; preds = %1723
  %1726 = call <2 x float> @__mulsc3(float noundef %1713, float noundef %1715, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %1726, ptr %18, align 4
  %1727 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 0
  %1728 = load float, ptr %1727, align 4
  %1729 = getelementptr inbounds { float, float }, ptr %18, i32 0, i32 1
  %1730 = load float, ptr %1729, align 4
  br label %1731

1731:                                             ; preds = %1725, %1723, %1675
  %1732 = phi float [ %1720, %1675 ], [ %1720, %1723 ], [ %1728, %1725 ]
  %1733 = phi float [ %1721, %1675 ], [ %1721, %1723 ], [ %1730, %1725 ]
  %1734 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1735 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1732, ptr %1734, align 4
  store float %1733, ptr %1735, align 4
  %1736 = load ptr, ptr %5, align 8, !tbaa !5
  %1737 = getelementptr inbounds { float, float }, ptr %1736, i64 10
  %1738 = getelementptr inbounds { float, float }, ptr %1737, i32 0, i32 0
  %1739 = load float, ptr %1738, align 4
  %1740 = getelementptr inbounds { float, float }, ptr %1737, i32 0, i32 1
  %1741 = load float, ptr %1740, align 4
  %1742 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1743 = load float, ptr %1742, align 4
  %1744 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1745 = load float, ptr %1744, align 4
  %1746 = fsub float %1739, %1743
  %1747 = fsub float %1741, %1745
  %1748 = load ptr, ptr %5, align 8, !tbaa !5
  %1749 = getelementptr inbounds { float, float }, ptr %1748, i64 14
  %1750 = getelementptr inbounds { float, float }, ptr %1749, i32 0, i32 0
  %1751 = getelementptr inbounds { float, float }, ptr %1749, i32 0, i32 1
  store float %1746, ptr %1750, align 4
  store float %1747, ptr %1751, align 4
  %1752 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1753 = load float, ptr %1752, align 4
  %1754 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1755 = load float, ptr %1754, align 4
  %1756 = load ptr, ptr %5, align 8, !tbaa !5
  %1757 = getelementptr inbounds { float, float }, ptr %1756, i64 10
  %1758 = getelementptr inbounds { float, float }, ptr %1757, i32 0, i32 0
  %1759 = load float, ptr %1758, align 4
  %1760 = getelementptr inbounds { float, float }, ptr %1757, i32 0, i32 1
  %1761 = load float, ptr %1760, align 4
  %1762 = fadd float %1759, %1753
  %1763 = fadd float %1761, %1755
  %1764 = getelementptr inbounds { float, float }, ptr %1757, i32 0, i32 0
  %1765 = getelementptr inbounds { float, float }, ptr %1757, i32 0, i32 1
  store float %1762, ptr %1764, align 4
  store float %1763, ptr %1765, align 4
  %1766 = load ptr, ptr %5, align 8, !tbaa !5
  %1767 = getelementptr inbounds { float, float }, ptr %1766, i64 7
  %1768 = getelementptr inbounds { float, float }, ptr %1767, i32 0, i32 0
  %1769 = load float, ptr %1768, align 4
  %1770 = getelementptr inbounds { float, float }, ptr %1767, i32 0, i32 1
  %1771 = load float, ptr %1770, align 4
  %1772 = fpext float %1769 to double
  %1773 = fpext float %1771 to double
  %1774 = fmul double %1772, 0xBFE6A09E607DC426
  %1775 = fmul double %1773, 0x3FE6A09E607DC426
  %1776 = fmul double %1772, 0x3FE6A09E607DC426
  %1777 = fmul double %1773, 0xBFE6A09E607DC426
  %1778 = fsub double %1774, %1775
  %1779 = fadd double %1776, %1777
  %1780 = fcmp uno double %1778, %1778
  br i1 %1780, label %1781, label %1787, !prof !15

1781:                                             ; preds = %1731
  %1782 = fcmp uno double %1779, %1779
  br i1 %1782, label %1783, label %1787, !prof !15

1783:                                             ; preds = %1781
  %1784 = call { double, double } @__muldc3(double noundef %1772, double noundef %1773, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %1785 = extractvalue { double, double } %1784, 0
  %1786 = extractvalue { double, double } %1784, 1
  br label %1787

1787:                                             ; preds = %1783, %1781, %1731
  %1788 = phi double [ %1778, %1731 ], [ %1778, %1781 ], [ %1785, %1783 ]
  %1789 = phi double [ %1779, %1731 ], [ %1779, %1781 ], [ %1786, %1783 ]
  %1790 = fptrunc double %1788 to float
  %1791 = fptrunc double %1789 to float
  %1792 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1793 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1790, ptr %1792, align 4
  store float %1791, ptr %1793, align 4
  %1794 = load ptr, ptr %5, align 8, !tbaa !5
  %1795 = getelementptr inbounds { float, float }, ptr %1794, i64 3
  %1796 = getelementptr inbounds { float, float }, ptr %1795, i32 0, i32 0
  %1797 = load float, ptr %1796, align 4
  %1798 = getelementptr inbounds { float, float }, ptr %1795, i32 0, i32 1
  %1799 = load float, ptr %1798, align 4
  %1800 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1801 = load float, ptr %1800, align 4
  %1802 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1803 = load float, ptr %1802, align 4
  %1804 = fsub float %1797, %1801
  %1805 = fsub float %1799, %1803
  %1806 = load ptr, ptr %5, align 8, !tbaa !5
  %1807 = getelementptr inbounds { float, float }, ptr %1806, i64 7
  %1808 = getelementptr inbounds { float, float }, ptr %1807, i32 0, i32 0
  %1809 = getelementptr inbounds { float, float }, ptr %1807, i32 0, i32 1
  store float %1804, ptr %1808, align 4
  store float %1805, ptr %1809, align 4
  %1810 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1811 = load float, ptr %1810, align 4
  %1812 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1813 = load float, ptr %1812, align 4
  %1814 = load ptr, ptr %5, align 8, !tbaa !5
  %1815 = getelementptr inbounds { float, float }, ptr %1814, i64 3
  %1816 = getelementptr inbounds { float, float }, ptr %1815, i32 0, i32 0
  %1817 = load float, ptr %1816, align 4
  %1818 = getelementptr inbounds { float, float }, ptr %1815, i32 0, i32 1
  %1819 = load float, ptr %1818, align 4
  %1820 = fadd float %1817, %1811
  %1821 = fadd float %1819, %1813
  %1822 = getelementptr inbounds { float, float }, ptr %1815, i32 0, i32 0
  %1823 = getelementptr inbounds { float, float }, ptr %1815, i32 0, i32 1
  store float %1820, ptr %1822, align 4
  store float %1821, ptr %1823, align 4
  %1824 = load ptr, ptr %5, align 8, !tbaa !5
  %1825 = getelementptr inbounds { float, float }, ptr %1824, i64 15
  %1826 = getelementptr inbounds { float, float }, ptr %1825, i32 0, i32 0
  %1827 = load float, ptr %1826, align 4
  %1828 = getelementptr inbounds { float, float }, ptr %1825, i32 0, i32 1
  %1829 = load float, ptr %1828, align 4
  %1830 = fpext float %1827 to double
  %1831 = fpext float %1829 to double
  %1832 = fmul double %1830, 0xBFE6A09E607DC426
  %1833 = fmul double %1831, 0x3FE6A09E607DC426
  %1834 = fmul double %1830, 0x3FE6A09E607DC426
  %1835 = fmul double %1831, 0xBFE6A09E607DC426
  %1836 = fsub double %1832, %1833
  %1837 = fadd double %1834, %1835
  %1838 = fcmp uno double %1836, %1836
  br i1 %1838, label %1839, label %1845, !prof !15

1839:                                             ; preds = %1787
  %1840 = fcmp uno double %1837, %1837
  br i1 %1840, label %1841, label %1845, !prof !15

1841:                                             ; preds = %1839
  %1842 = call { double, double } @__muldc3(double noundef %1830, double noundef %1831, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %1843 = extractvalue { double, double } %1842, 0
  %1844 = extractvalue { double, double } %1842, 1
  br label %1845

1845:                                             ; preds = %1841, %1839, %1787
  %1846 = phi double [ %1836, %1787 ], [ %1836, %1839 ], [ %1843, %1841 ]
  %1847 = phi double [ %1837, %1787 ], [ %1837, %1839 ], [ %1844, %1841 ]
  %1848 = fptrunc double %1846 to float
  %1849 = fptrunc double %1847 to float
  %1850 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1851 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1848, ptr %1850, align 4
  store float %1849, ptr %1851, align 4
  %1852 = load ptr, ptr %5, align 8, !tbaa !5
  %1853 = getelementptr inbounds { float, float }, ptr %1852, i64 11
  %1854 = getelementptr inbounds { float, float }, ptr %1853, i32 0, i32 0
  %1855 = load float, ptr %1854, align 4
  %1856 = getelementptr inbounds { float, float }, ptr %1853, i32 0, i32 1
  %1857 = load float, ptr %1856, align 4
  %1858 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1859 = load float, ptr %1858, align 4
  %1860 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1861 = load float, ptr %1860, align 4
  %1862 = fsub float %1855, %1859
  %1863 = fsub float %1857, %1861
  %1864 = load ptr, ptr %5, align 8, !tbaa !5
  %1865 = getelementptr inbounds { float, float }, ptr %1864, i64 15
  %1866 = getelementptr inbounds { float, float }, ptr %1865, i32 0, i32 0
  %1867 = getelementptr inbounds { float, float }, ptr %1865, i32 0, i32 1
  store float %1862, ptr %1866, align 4
  store float %1863, ptr %1867, align 4
  %1868 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1869 = load float, ptr %1868, align 4
  %1870 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1871 = load float, ptr %1870, align 4
  %1872 = load ptr, ptr %5, align 8, !tbaa !5
  %1873 = getelementptr inbounds { float, float }, ptr %1872, i64 11
  %1874 = getelementptr inbounds { float, float }, ptr %1873, i32 0, i32 0
  %1875 = load float, ptr %1874, align 4
  %1876 = getelementptr inbounds { float, float }, ptr %1873, i32 0, i32 1
  %1877 = load float, ptr %1876, align 4
  %1878 = fadd float %1875, %1869
  %1879 = fadd float %1877, %1871
  %1880 = getelementptr inbounds { float, float }, ptr %1873, i32 0, i32 0
  %1881 = getelementptr inbounds { float, float }, ptr %1873, i32 0, i32 1
  store float %1878, ptr %1880, align 4
  store float %1879, ptr %1881, align 4
  br label %1882

1882:                                             ; preds = %1845, %1500
  %1883 = load ptr, ptr %5, align 8, !tbaa !5
  %1884 = getelementptr inbounds { float, float }, ptr %1883, i64 8
  %1885 = getelementptr inbounds { float, float }, ptr %1884, i32 0, i32 0
  %1886 = load float, ptr %1885, align 4
  %1887 = getelementptr inbounds { float, float }, ptr %1884, i32 0, i32 1
  %1888 = load float, ptr %1887, align 4
  %1889 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1890 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1886, ptr %1889, align 4
  store float %1888, ptr %1890, align 4
  %1891 = load ptr, ptr %5, align 8, !tbaa !5
  %1892 = getelementptr inbounds { float, float }, ptr %1891, i64 0
  %1893 = getelementptr inbounds { float, float }, ptr %1892, i32 0, i32 0
  %1894 = load float, ptr %1893, align 4
  %1895 = getelementptr inbounds { float, float }, ptr %1892, i32 0, i32 1
  %1896 = load float, ptr %1895, align 4
  %1897 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1898 = load float, ptr %1897, align 4
  %1899 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1900 = load float, ptr %1899, align 4
  %1901 = fsub float %1894, %1898
  %1902 = fsub float %1896, %1900
  %1903 = load ptr, ptr %5, align 8, !tbaa !5
  %1904 = getelementptr inbounds { float, float }, ptr %1903, i64 8
  %1905 = getelementptr inbounds { float, float }, ptr %1904, i32 0, i32 0
  %1906 = getelementptr inbounds { float, float }, ptr %1904, i32 0, i32 1
  store float %1901, ptr %1905, align 4
  store float %1902, ptr %1906, align 4
  %1907 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1908 = load float, ptr %1907, align 4
  %1909 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1910 = load float, ptr %1909, align 4
  %1911 = load ptr, ptr %5, align 8, !tbaa !5
  %1912 = getelementptr inbounds { float, float }, ptr %1911, i64 0
  %1913 = getelementptr inbounds { float, float }, ptr %1912, i32 0, i32 0
  %1914 = load float, ptr %1913, align 4
  %1915 = getelementptr inbounds { float, float }, ptr %1912, i32 0, i32 1
  %1916 = load float, ptr %1915, align 4
  %1917 = fadd float %1914, %1908
  %1918 = fadd float %1916, %1910
  %1919 = getelementptr inbounds { float, float }, ptr %1912, i32 0, i32 0
  %1920 = getelementptr inbounds { float, float }, ptr %1912, i32 0, i32 1
  store float %1917, ptr %1919, align 4
  store float %1918, ptr %1920, align 4
  %1921 = load i32, ptr %6, align 4, !tbaa !14
  %1922 = icmp ne i32 %1921, 0
  br i1 %1922, label %1923, label %2330

1923:                                             ; preds = %1882
  %1924 = load ptr, ptr %5, align 8, !tbaa !5
  %1925 = getelementptr inbounds { float, float }, ptr %1924, i64 9
  %1926 = getelementptr inbounds { float, float }, ptr %1925, i32 0, i32 0
  %1927 = load float, ptr %1926, align 4
  %1928 = getelementptr inbounds { float, float }, ptr %1925, i32 0, i32 1
  %1929 = load float, ptr %1928, align 4
  %1930 = fpext float %1927 to double
  %1931 = fpext float %1929 to double
  %1932 = fmul double %1930, 0x3FED906BBDBE3C10
  %1933 = fmul double %1931, 0xBFD87DE2C45AE350
  %1934 = fmul double %1930, 0xBFD87DE2C45AE350
  %1935 = fmul double %1931, 0x3FED906BBDBE3C10
  %1936 = fsub double %1932, %1933
  %1937 = fadd double %1934, %1935
  %1938 = fcmp uno double %1936, %1936
  br i1 %1938, label %1939, label %1945, !prof !15

1939:                                             ; preds = %1923
  %1940 = fcmp uno double %1937, %1937
  br i1 %1940, label %1941, label %1945, !prof !15

1941:                                             ; preds = %1939
  %1942 = call { double, double } @__muldc3(double noundef %1930, double noundef %1931, double noundef 0x3FED906BBDBE3C10, double noundef 0xBFD87DE2C45AE350) #2
  %1943 = extractvalue { double, double } %1942, 0
  %1944 = extractvalue { double, double } %1942, 1
  br label %1945

1945:                                             ; preds = %1941, %1939, %1923
  %1946 = phi double [ %1936, %1923 ], [ %1936, %1939 ], [ %1943, %1941 ]
  %1947 = phi double [ %1937, %1923 ], [ %1937, %1939 ], [ %1944, %1941 ]
  %1948 = fptrunc double %1946 to float
  %1949 = fptrunc double %1947 to float
  %1950 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1951 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %1948, ptr %1950, align 4
  store float %1949, ptr %1951, align 4
  %1952 = load ptr, ptr %5, align 8, !tbaa !5
  %1953 = getelementptr inbounds { float, float }, ptr %1952, i64 1
  %1954 = getelementptr inbounds { float, float }, ptr %1953, i32 0, i32 0
  %1955 = load float, ptr %1954, align 4
  %1956 = getelementptr inbounds { float, float }, ptr %1953, i32 0, i32 1
  %1957 = load float, ptr %1956, align 4
  %1958 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1959 = load float, ptr %1958, align 4
  %1960 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1961 = load float, ptr %1960, align 4
  %1962 = fsub float %1955, %1959
  %1963 = fsub float %1957, %1961
  %1964 = load ptr, ptr %5, align 8, !tbaa !5
  %1965 = getelementptr inbounds { float, float }, ptr %1964, i64 9
  %1966 = getelementptr inbounds { float, float }, ptr %1965, i32 0, i32 0
  %1967 = getelementptr inbounds { float, float }, ptr %1965, i32 0, i32 1
  store float %1962, ptr %1966, align 4
  store float %1963, ptr %1967, align 4
  %1968 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %1969 = load float, ptr %1968, align 4
  %1970 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %1971 = load float, ptr %1970, align 4
  %1972 = load ptr, ptr %5, align 8, !tbaa !5
  %1973 = getelementptr inbounds { float, float }, ptr %1972, i64 1
  %1974 = getelementptr inbounds { float, float }, ptr %1973, i32 0, i32 0
  %1975 = load float, ptr %1974, align 4
  %1976 = getelementptr inbounds { float, float }, ptr %1973, i32 0, i32 1
  %1977 = load float, ptr %1976, align 4
  %1978 = fadd float %1975, %1969
  %1979 = fadd float %1977, %1971
  %1980 = getelementptr inbounds { float, float }, ptr %1973, i32 0, i32 0
  %1981 = getelementptr inbounds { float, float }, ptr %1973, i32 0, i32 1
  store float %1978, ptr %1980, align 4
  store float %1979, ptr %1981, align 4
  %1982 = load ptr, ptr %5, align 8, !tbaa !5
  %1983 = getelementptr inbounds { float, float }, ptr %1982, i64 10
  %1984 = getelementptr inbounds { float, float }, ptr %1983, i32 0, i32 0
  %1985 = load float, ptr %1984, align 4
  %1986 = getelementptr inbounds { float, float }, ptr %1983, i32 0, i32 1
  %1987 = load float, ptr %1986, align 4
  %1988 = fpext float %1985 to double
  %1989 = fpext float %1987 to double
  %1990 = fmul double %1988, 0x3FE6A09E607DC426
  %1991 = fmul double %1989, 0xBFE6A09E607DC426
  %1992 = fmul double %1988, 0xBFE6A09E607DC426
  %1993 = fmul double %1989, 0x3FE6A09E607DC426
  %1994 = fsub double %1990, %1991
  %1995 = fadd double %1992, %1993
  %1996 = fcmp uno double %1994, %1994
  br i1 %1996, label %1997, label %2003, !prof !15

1997:                                             ; preds = %1945
  %1998 = fcmp uno double %1995, %1995
  br i1 %1998, label %1999, label %2003, !prof !15

1999:                                             ; preds = %1997
  %2000 = call { double, double } @__muldc3(double noundef %1988, double noundef %1989, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %2001 = extractvalue { double, double } %2000, 0
  %2002 = extractvalue { double, double } %2000, 1
  br label %2003

2003:                                             ; preds = %1999, %1997, %1945
  %2004 = phi double [ %1994, %1945 ], [ %1994, %1997 ], [ %2001, %1999 ]
  %2005 = phi double [ %1995, %1945 ], [ %1995, %1997 ], [ %2002, %1999 ]
  %2006 = fptrunc double %2004 to float
  %2007 = fptrunc double %2005 to float
  %2008 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2009 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2006, ptr %2008, align 4
  store float %2007, ptr %2009, align 4
  %2010 = load ptr, ptr %5, align 8, !tbaa !5
  %2011 = getelementptr inbounds { float, float }, ptr %2010, i64 2
  %2012 = getelementptr inbounds { float, float }, ptr %2011, i32 0, i32 0
  %2013 = load float, ptr %2012, align 4
  %2014 = getelementptr inbounds { float, float }, ptr %2011, i32 0, i32 1
  %2015 = load float, ptr %2014, align 4
  %2016 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2017 = load float, ptr %2016, align 4
  %2018 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2019 = load float, ptr %2018, align 4
  %2020 = fsub float %2013, %2017
  %2021 = fsub float %2015, %2019
  %2022 = load ptr, ptr %5, align 8, !tbaa !5
  %2023 = getelementptr inbounds { float, float }, ptr %2022, i64 10
  %2024 = getelementptr inbounds { float, float }, ptr %2023, i32 0, i32 0
  %2025 = getelementptr inbounds { float, float }, ptr %2023, i32 0, i32 1
  store float %2020, ptr %2024, align 4
  store float %2021, ptr %2025, align 4
  %2026 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2027 = load float, ptr %2026, align 4
  %2028 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2029 = load float, ptr %2028, align 4
  %2030 = load ptr, ptr %5, align 8, !tbaa !5
  %2031 = getelementptr inbounds { float, float }, ptr %2030, i64 2
  %2032 = getelementptr inbounds { float, float }, ptr %2031, i32 0, i32 0
  %2033 = load float, ptr %2032, align 4
  %2034 = getelementptr inbounds { float, float }, ptr %2031, i32 0, i32 1
  %2035 = load float, ptr %2034, align 4
  %2036 = fadd float %2033, %2027
  %2037 = fadd float %2035, %2029
  %2038 = getelementptr inbounds { float, float }, ptr %2031, i32 0, i32 0
  %2039 = getelementptr inbounds { float, float }, ptr %2031, i32 0, i32 1
  store float %2036, ptr %2038, align 4
  store float %2037, ptr %2039, align 4
  %2040 = load ptr, ptr %5, align 8, !tbaa !5
  %2041 = getelementptr inbounds { float, float }, ptr %2040, i64 11
  %2042 = getelementptr inbounds { float, float }, ptr %2041, i32 0, i32 0
  %2043 = load float, ptr %2042, align 4
  %2044 = getelementptr inbounds { float, float }, ptr %2041, i32 0, i32 1
  %2045 = load float, ptr %2044, align 4
  %2046 = fpext float %2043 to double
  %2047 = fpext float %2045 to double
  %2048 = fmul double %2046, 0x3FD87DE2A4248CFD
  %2049 = fmul double %2047, 0xBFED906BBDBE3C10
  %2050 = fmul double %2046, 0xBFED906BBDBE3C10
  %2051 = fmul double %2047, 0x3FD87DE2A4248CFD
  %2052 = fsub double %2048, %2049
  %2053 = fadd double %2050, %2051
  %2054 = fcmp uno double %2052, %2052
  br i1 %2054, label %2055, label %2061, !prof !15

2055:                                             ; preds = %2003
  %2056 = fcmp uno double %2053, %2053
  br i1 %2056, label %2057, label %2061, !prof !15

2057:                                             ; preds = %2055
  %2058 = call { double, double } @__muldc3(double noundef %2046, double noundef %2047, double noundef 0x3FD87DE2A4248CFD, double noundef 0xBFED906BBDBE3C10) #2
  %2059 = extractvalue { double, double } %2058, 0
  %2060 = extractvalue { double, double } %2058, 1
  br label %2061

2061:                                             ; preds = %2057, %2055, %2003
  %2062 = phi double [ %2052, %2003 ], [ %2052, %2055 ], [ %2059, %2057 ]
  %2063 = phi double [ %2053, %2003 ], [ %2053, %2055 ], [ %2060, %2057 ]
  %2064 = fptrunc double %2062 to float
  %2065 = fptrunc double %2063 to float
  %2066 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2067 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2064, ptr %2066, align 4
  store float %2065, ptr %2067, align 4
  %2068 = load ptr, ptr %5, align 8, !tbaa !5
  %2069 = getelementptr inbounds { float, float }, ptr %2068, i64 3
  %2070 = getelementptr inbounds { float, float }, ptr %2069, i32 0, i32 0
  %2071 = load float, ptr %2070, align 4
  %2072 = getelementptr inbounds { float, float }, ptr %2069, i32 0, i32 1
  %2073 = load float, ptr %2072, align 4
  %2074 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2075 = load float, ptr %2074, align 4
  %2076 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2077 = load float, ptr %2076, align 4
  %2078 = fsub float %2071, %2075
  %2079 = fsub float %2073, %2077
  %2080 = load ptr, ptr %5, align 8, !tbaa !5
  %2081 = getelementptr inbounds { float, float }, ptr %2080, i64 11
  %2082 = getelementptr inbounds { float, float }, ptr %2081, i32 0, i32 0
  %2083 = getelementptr inbounds { float, float }, ptr %2081, i32 0, i32 1
  store float %2078, ptr %2082, align 4
  store float %2079, ptr %2083, align 4
  %2084 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2085 = load float, ptr %2084, align 4
  %2086 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2087 = load float, ptr %2086, align 4
  %2088 = load ptr, ptr %5, align 8, !tbaa !5
  %2089 = getelementptr inbounds { float, float }, ptr %2088, i64 3
  %2090 = getelementptr inbounds { float, float }, ptr %2089, i32 0, i32 0
  %2091 = load float, ptr %2090, align 4
  %2092 = getelementptr inbounds { float, float }, ptr %2089, i32 0, i32 1
  %2093 = load float, ptr %2092, align 4
  %2094 = fadd float %2091, %2085
  %2095 = fadd float %2093, %2087
  %2096 = getelementptr inbounds { float, float }, ptr %2089, i32 0, i32 0
  %2097 = getelementptr inbounds { float, float }, ptr %2089, i32 0, i32 1
  store float %2094, ptr %2096, align 4
  store float %2095, ptr %2097, align 4
  %2098 = load ptr, ptr %5, align 8, !tbaa !5
  %2099 = getelementptr inbounds { float, float }, ptr %2098, i64 12
  %2100 = getelementptr inbounds { float, float }, ptr %2099, i32 0, i32 0
  %2101 = load float, ptr %2100, align 4
  %2102 = getelementptr inbounds { float, float }, ptr %2099, i32 0, i32 1
  %2103 = load float, ptr %2102, align 4
  %2104 = fneg float %2101
  %2105 = fneg float %2103
  %2106 = fmul float %2104, 0.000000e+00
  %2107 = fmul float %2105, 1.000000e+00
  %2108 = fmul float %2104, 1.000000e+00
  %2109 = fmul float %2105, 0.000000e+00
  %2110 = fsub float %2106, %2107
  %2111 = fadd float %2108, %2109
  %2112 = fcmp uno float %2110, %2110
  br i1 %2112, label %2113, label %2121, !prof !15

2113:                                             ; preds = %2061
  %2114 = fcmp uno float %2111, %2111
  br i1 %2114, label %2115, label %2121, !prof !15

2115:                                             ; preds = %2113
  %2116 = call <2 x float> @__mulsc3(float noundef %2104, float noundef %2105, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %2116, ptr %19, align 4
  %2117 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 0
  %2118 = load float, ptr %2117, align 4
  %2119 = getelementptr inbounds { float, float }, ptr %19, i32 0, i32 1
  %2120 = load float, ptr %2119, align 4
  br label %2121

2121:                                             ; preds = %2115, %2113, %2061
  %2122 = phi float [ %2110, %2061 ], [ %2110, %2113 ], [ %2118, %2115 ]
  %2123 = phi float [ %2111, %2061 ], [ %2111, %2113 ], [ %2120, %2115 ]
  %2124 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2125 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2122, ptr %2124, align 4
  store float %2123, ptr %2125, align 4
  %2126 = load ptr, ptr %5, align 8, !tbaa !5
  %2127 = getelementptr inbounds { float, float }, ptr %2126, i64 4
  %2128 = getelementptr inbounds { float, float }, ptr %2127, i32 0, i32 0
  %2129 = load float, ptr %2128, align 4
  %2130 = getelementptr inbounds { float, float }, ptr %2127, i32 0, i32 1
  %2131 = load float, ptr %2130, align 4
  %2132 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2133 = load float, ptr %2132, align 4
  %2134 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2135 = load float, ptr %2134, align 4
  %2136 = fsub float %2129, %2133
  %2137 = fsub float %2131, %2135
  %2138 = load ptr, ptr %5, align 8, !tbaa !5
  %2139 = getelementptr inbounds { float, float }, ptr %2138, i64 12
  %2140 = getelementptr inbounds { float, float }, ptr %2139, i32 0, i32 0
  %2141 = getelementptr inbounds { float, float }, ptr %2139, i32 0, i32 1
  store float %2136, ptr %2140, align 4
  store float %2137, ptr %2141, align 4
  %2142 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2143 = load float, ptr %2142, align 4
  %2144 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2145 = load float, ptr %2144, align 4
  %2146 = load ptr, ptr %5, align 8, !tbaa !5
  %2147 = getelementptr inbounds { float, float }, ptr %2146, i64 4
  %2148 = getelementptr inbounds { float, float }, ptr %2147, i32 0, i32 0
  %2149 = load float, ptr %2148, align 4
  %2150 = getelementptr inbounds { float, float }, ptr %2147, i32 0, i32 1
  %2151 = load float, ptr %2150, align 4
  %2152 = fadd float %2149, %2143
  %2153 = fadd float %2151, %2145
  %2154 = getelementptr inbounds { float, float }, ptr %2147, i32 0, i32 0
  %2155 = getelementptr inbounds { float, float }, ptr %2147, i32 0, i32 1
  store float %2152, ptr %2154, align 4
  store float %2153, ptr %2155, align 4
  %2156 = load ptr, ptr %5, align 8, !tbaa !5
  %2157 = getelementptr inbounds { float, float }, ptr %2156, i64 13
  %2158 = getelementptr inbounds { float, float }, ptr %2157, i32 0, i32 0
  %2159 = load float, ptr %2158, align 4
  %2160 = getelementptr inbounds { float, float }, ptr %2157, i32 0, i32 1
  %2161 = load float, ptr %2160, align 4
  %2162 = fpext float %2159 to double
  %2163 = fpext float %2161 to double
  %2164 = fmul double %2162, 0xBFD87DE283EE36AA
  %2165 = fmul double %2163, 0xBFED906BDDF49264
  %2166 = fmul double %2162, 0xBFED906BDDF49264
  %2167 = fmul double %2163, 0xBFD87DE283EE36AA
  %2168 = fsub double %2164, %2165
  %2169 = fadd double %2166, %2167
  %2170 = fcmp uno double %2168, %2168
  br i1 %2170, label %2171, label %2177, !prof !15

2171:                                             ; preds = %2121
  %2172 = fcmp uno double %2169, %2169
  br i1 %2172, label %2173, label %2177, !prof !15

2173:                                             ; preds = %2171
  %2174 = call { double, double } @__muldc3(double noundef %2162, double noundef %2163, double noundef 0xBFD87DE283EE36AA, double noundef 0xBFED906BDDF49264) #2
  %2175 = extractvalue { double, double } %2174, 0
  %2176 = extractvalue { double, double } %2174, 1
  br label %2177

2177:                                             ; preds = %2173, %2171, %2121
  %2178 = phi double [ %2168, %2121 ], [ %2168, %2171 ], [ %2175, %2173 ]
  %2179 = phi double [ %2169, %2121 ], [ %2169, %2171 ], [ %2176, %2173 ]
  %2180 = fptrunc double %2178 to float
  %2181 = fptrunc double %2179 to float
  %2182 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2183 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2180, ptr %2182, align 4
  store float %2181, ptr %2183, align 4
  %2184 = load ptr, ptr %5, align 8, !tbaa !5
  %2185 = getelementptr inbounds { float, float }, ptr %2184, i64 5
  %2186 = getelementptr inbounds { float, float }, ptr %2185, i32 0, i32 0
  %2187 = load float, ptr %2186, align 4
  %2188 = getelementptr inbounds { float, float }, ptr %2185, i32 0, i32 1
  %2189 = load float, ptr %2188, align 4
  %2190 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2191 = load float, ptr %2190, align 4
  %2192 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2193 = load float, ptr %2192, align 4
  %2194 = fsub float %2187, %2191
  %2195 = fsub float %2189, %2193
  %2196 = load ptr, ptr %5, align 8, !tbaa !5
  %2197 = getelementptr inbounds { float, float }, ptr %2196, i64 13
  %2198 = getelementptr inbounds { float, float }, ptr %2197, i32 0, i32 0
  %2199 = getelementptr inbounds { float, float }, ptr %2197, i32 0, i32 1
  store float %2194, ptr %2198, align 4
  store float %2195, ptr %2199, align 4
  %2200 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2201 = load float, ptr %2200, align 4
  %2202 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2203 = load float, ptr %2202, align 4
  %2204 = load ptr, ptr %5, align 8, !tbaa !5
  %2205 = getelementptr inbounds { float, float }, ptr %2204, i64 5
  %2206 = getelementptr inbounds { float, float }, ptr %2205, i32 0, i32 0
  %2207 = load float, ptr %2206, align 4
  %2208 = getelementptr inbounds { float, float }, ptr %2205, i32 0, i32 1
  %2209 = load float, ptr %2208, align 4
  %2210 = fadd float %2207, %2201
  %2211 = fadd float %2209, %2203
  %2212 = getelementptr inbounds { float, float }, ptr %2205, i32 0, i32 0
  %2213 = getelementptr inbounds { float, float }, ptr %2205, i32 0, i32 1
  store float %2210, ptr %2212, align 4
  store float %2211, ptr %2213, align 4
  %2214 = load ptr, ptr %5, align 8, !tbaa !5
  %2215 = getelementptr inbounds { float, float }, ptr %2214, i64 14
  %2216 = getelementptr inbounds { float, float }, ptr %2215, i32 0, i32 0
  %2217 = load float, ptr %2216, align 4
  %2218 = getelementptr inbounds { float, float }, ptr %2215, i32 0, i32 1
  %2219 = load float, ptr %2218, align 4
  %2220 = fpext float %2217 to double
  %2221 = fpext float %2219 to double
  %2222 = fmul double %2220, 0xBFE6A09E607DC426
  %2223 = fmul double %2221, 0xBFE6A09E607DC426
  %2224 = fmul double %2220, 0xBFE6A09E607DC426
  %2225 = fmul double %2221, 0xBFE6A09E607DC426
  %2226 = fsub double %2222, %2223
  %2227 = fadd double %2224, %2225
  %2228 = fcmp uno double %2226, %2226
  br i1 %2228, label %2229, label %2235, !prof !15

2229:                                             ; preds = %2177
  %2230 = fcmp uno double %2227, %2227
  br i1 %2230, label %2231, label %2235, !prof !15

2231:                                             ; preds = %2229
  %2232 = call { double, double } @__muldc3(double noundef %2220, double noundef %2221, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #2
  %2233 = extractvalue { double, double } %2232, 0
  %2234 = extractvalue { double, double } %2232, 1
  br label %2235

2235:                                             ; preds = %2231, %2229, %2177
  %2236 = phi double [ %2226, %2177 ], [ %2226, %2229 ], [ %2233, %2231 ]
  %2237 = phi double [ %2227, %2177 ], [ %2227, %2229 ], [ %2234, %2231 ]
  %2238 = fptrunc double %2236 to float
  %2239 = fptrunc double %2237 to float
  %2240 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2241 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2238, ptr %2240, align 4
  store float %2239, ptr %2241, align 4
  %2242 = load ptr, ptr %5, align 8, !tbaa !5
  %2243 = getelementptr inbounds { float, float }, ptr %2242, i64 6
  %2244 = getelementptr inbounds { float, float }, ptr %2243, i32 0, i32 0
  %2245 = load float, ptr %2244, align 4
  %2246 = getelementptr inbounds { float, float }, ptr %2243, i32 0, i32 1
  %2247 = load float, ptr %2246, align 4
  %2248 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2249 = load float, ptr %2248, align 4
  %2250 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2251 = load float, ptr %2250, align 4
  %2252 = fsub float %2245, %2249
  %2253 = fsub float %2247, %2251
  %2254 = load ptr, ptr %5, align 8, !tbaa !5
  %2255 = getelementptr inbounds { float, float }, ptr %2254, i64 14
  %2256 = getelementptr inbounds { float, float }, ptr %2255, i32 0, i32 0
  %2257 = getelementptr inbounds { float, float }, ptr %2255, i32 0, i32 1
  store float %2252, ptr %2256, align 4
  store float %2253, ptr %2257, align 4
  %2258 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2259 = load float, ptr %2258, align 4
  %2260 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2261 = load float, ptr %2260, align 4
  %2262 = load ptr, ptr %5, align 8, !tbaa !5
  %2263 = getelementptr inbounds { float, float }, ptr %2262, i64 6
  %2264 = getelementptr inbounds { float, float }, ptr %2263, i32 0, i32 0
  %2265 = load float, ptr %2264, align 4
  %2266 = getelementptr inbounds { float, float }, ptr %2263, i32 0, i32 1
  %2267 = load float, ptr %2266, align 4
  %2268 = fadd float %2265, %2259
  %2269 = fadd float %2267, %2261
  %2270 = getelementptr inbounds { float, float }, ptr %2263, i32 0, i32 0
  %2271 = getelementptr inbounds { float, float }, ptr %2263, i32 0, i32 1
  store float %2268, ptr %2270, align 4
  store float %2269, ptr %2271, align 4
  %2272 = load ptr, ptr %5, align 8, !tbaa !5
  %2273 = getelementptr inbounds { float, float }, ptr %2272, i64 15
  %2274 = getelementptr inbounds { float, float }, ptr %2273, i32 0, i32 0
  %2275 = load float, ptr %2274, align 4
  %2276 = getelementptr inbounds { float, float }, ptr %2273, i32 0, i32 1
  %2277 = load float, ptr %2276, align 4
  %2278 = fpext float %2275 to double
  %2279 = fpext float %2277 to double
  %2280 = fmul double %2278, 0xBFED906BBDBE3C10
  %2281 = fmul double %2279, 0xBFD87DE2E49139A4
  %2282 = fmul double %2278, 0xBFD87DE2E49139A4
  %2283 = fmul double %2279, 0xBFED906BBDBE3C10
  %2284 = fsub double %2280, %2281
  %2285 = fadd double %2282, %2283
  %2286 = fcmp uno double %2284, %2284
  br i1 %2286, label %2287, label %2293, !prof !15

2287:                                             ; preds = %2235
  %2288 = fcmp uno double %2285, %2285
  br i1 %2288, label %2289, label %2293, !prof !15

2289:                                             ; preds = %2287
  %2290 = call { double, double } @__muldc3(double noundef %2278, double noundef %2279, double noundef 0xBFED906BBDBE3C10, double noundef 0xBFD87DE2E49139A4) #2
  %2291 = extractvalue { double, double } %2290, 0
  %2292 = extractvalue { double, double } %2290, 1
  br label %2293

2293:                                             ; preds = %2289, %2287, %2235
  %2294 = phi double [ %2284, %2235 ], [ %2284, %2287 ], [ %2291, %2289 ]
  %2295 = phi double [ %2285, %2235 ], [ %2285, %2287 ], [ %2292, %2289 ]
  %2296 = fptrunc double %2294 to float
  %2297 = fptrunc double %2295 to float
  %2298 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2299 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2296, ptr %2298, align 4
  store float %2297, ptr %2299, align 4
  %2300 = load ptr, ptr %5, align 8, !tbaa !5
  %2301 = getelementptr inbounds { float, float }, ptr %2300, i64 7
  %2302 = getelementptr inbounds { float, float }, ptr %2301, i32 0, i32 0
  %2303 = load float, ptr %2302, align 4
  %2304 = getelementptr inbounds { float, float }, ptr %2301, i32 0, i32 1
  %2305 = load float, ptr %2304, align 4
  %2306 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2307 = load float, ptr %2306, align 4
  %2308 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2309 = load float, ptr %2308, align 4
  %2310 = fsub float %2303, %2307
  %2311 = fsub float %2305, %2309
  %2312 = load ptr, ptr %5, align 8, !tbaa !5
  %2313 = getelementptr inbounds { float, float }, ptr %2312, i64 15
  %2314 = getelementptr inbounds { float, float }, ptr %2313, i32 0, i32 0
  %2315 = getelementptr inbounds { float, float }, ptr %2313, i32 0, i32 1
  store float %2310, ptr %2314, align 4
  store float %2311, ptr %2315, align 4
  %2316 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2317 = load float, ptr %2316, align 4
  %2318 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2319 = load float, ptr %2318, align 4
  %2320 = load ptr, ptr %5, align 8, !tbaa !5
  %2321 = getelementptr inbounds { float, float }, ptr %2320, i64 7
  %2322 = getelementptr inbounds { float, float }, ptr %2321, i32 0, i32 0
  %2323 = load float, ptr %2322, align 4
  %2324 = getelementptr inbounds { float, float }, ptr %2321, i32 0, i32 1
  %2325 = load float, ptr %2324, align 4
  %2326 = fadd float %2323, %2317
  %2327 = fadd float %2325, %2319
  %2328 = getelementptr inbounds { float, float }, ptr %2321, i32 0, i32 0
  %2329 = getelementptr inbounds { float, float }, ptr %2321, i32 0, i32 1
  store float %2326, ptr %2328, align 4
  store float %2327, ptr %2329, align 4
  br label %2735

2330:                                             ; preds = %1882
  %2331 = load ptr, ptr %5, align 8, !tbaa !5
  %2332 = getelementptr inbounds { float, float }, ptr %2331, i64 9
  %2333 = getelementptr inbounds { float, float }, ptr %2332, i32 0, i32 0
  %2334 = load float, ptr %2333, align 4
  %2335 = getelementptr inbounds { float, float }, ptr %2332, i32 0, i32 1
  %2336 = load float, ptr %2335, align 4
  %2337 = fpext float %2334 to double
  %2338 = fpext float %2336 to double
  %2339 = fmul double %2337, 0x3FED906BBDBE3C10
  %2340 = fmul double %2338, 0x3FD87DE2C45AE350
  %2341 = fmul double %2337, 0x3FD87DE2C45AE350
  %2342 = fmul double %2338, 0x3FED906BBDBE3C10
  %2343 = fsub double %2339, %2340
  %2344 = fadd double %2341, %2342
  %2345 = fcmp uno double %2343, %2343
  br i1 %2345, label %2346, label %2352, !prof !15

2346:                                             ; preds = %2330
  %2347 = fcmp uno double %2344, %2344
  br i1 %2347, label %2348, label %2352, !prof !15

2348:                                             ; preds = %2346
  %2349 = call { double, double } @__muldc3(double noundef %2337, double noundef %2338, double noundef 0x3FED906BBDBE3C10, double noundef 0x3FD87DE2C45AE350) #2
  %2350 = extractvalue { double, double } %2349, 0
  %2351 = extractvalue { double, double } %2349, 1
  br label %2352

2352:                                             ; preds = %2348, %2346, %2330
  %2353 = phi double [ %2343, %2330 ], [ %2343, %2346 ], [ %2350, %2348 ]
  %2354 = phi double [ %2344, %2330 ], [ %2344, %2346 ], [ %2351, %2348 ]
  %2355 = fptrunc double %2353 to float
  %2356 = fptrunc double %2354 to float
  %2357 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2358 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2355, ptr %2357, align 4
  store float %2356, ptr %2358, align 4
  %2359 = load ptr, ptr %5, align 8, !tbaa !5
  %2360 = getelementptr inbounds { float, float }, ptr %2359, i64 1
  %2361 = getelementptr inbounds { float, float }, ptr %2360, i32 0, i32 0
  %2362 = load float, ptr %2361, align 4
  %2363 = getelementptr inbounds { float, float }, ptr %2360, i32 0, i32 1
  %2364 = load float, ptr %2363, align 4
  %2365 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2366 = load float, ptr %2365, align 4
  %2367 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2368 = load float, ptr %2367, align 4
  %2369 = fsub float %2362, %2366
  %2370 = fsub float %2364, %2368
  %2371 = load ptr, ptr %5, align 8, !tbaa !5
  %2372 = getelementptr inbounds { float, float }, ptr %2371, i64 9
  %2373 = getelementptr inbounds { float, float }, ptr %2372, i32 0, i32 0
  %2374 = getelementptr inbounds { float, float }, ptr %2372, i32 0, i32 1
  store float %2369, ptr %2373, align 4
  store float %2370, ptr %2374, align 4
  %2375 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2376 = load float, ptr %2375, align 4
  %2377 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2378 = load float, ptr %2377, align 4
  %2379 = load ptr, ptr %5, align 8, !tbaa !5
  %2380 = getelementptr inbounds { float, float }, ptr %2379, i64 1
  %2381 = getelementptr inbounds { float, float }, ptr %2380, i32 0, i32 0
  %2382 = load float, ptr %2381, align 4
  %2383 = getelementptr inbounds { float, float }, ptr %2380, i32 0, i32 1
  %2384 = load float, ptr %2383, align 4
  %2385 = fadd float %2382, %2376
  %2386 = fadd float %2384, %2378
  %2387 = getelementptr inbounds { float, float }, ptr %2380, i32 0, i32 0
  %2388 = getelementptr inbounds { float, float }, ptr %2380, i32 0, i32 1
  store float %2385, ptr %2387, align 4
  store float %2386, ptr %2388, align 4
  %2389 = load ptr, ptr %5, align 8, !tbaa !5
  %2390 = getelementptr inbounds { float, float }, ptr %2389, i64 10
  %2391 = getelementptr inbounds { float, float }, ptr %2390, i32 0, i32 0
  %2392 = load float, ptr %2391, align 4
  %2393 = getelementptr inbounds { float, float }, ptr %2390, i32 0, i32 1
  %2394 = load float, ptr %2393, align 4
  %2395 = fpext float %2392 to double
  %2396 = fpext float %2394 to double
  %2397 = fmul double %2395, 0x3FE6A09E607DC426
  %2398 = fmul double %2396, 0x3FE6A09E607DC426
  %2399 = fmul double %2395, 0x3FE6A09E607DC426
  %2400 = fmul double %2396, 0x3FE6A09E607DC426
  %2401 = fsub double %2397, %2398
  %2402 = fadd double %2399, %2400
  %2403 = fcmp uno double %2401, %2401
  br i1 %2403, label %2404, label %2410, !prof !15

2404:                                             ; preds = %2352
  %2405 = fcmp uno double %2402, %2402
  br i1 %2405, label %2406, label %2410, !prof !15

2406:                                             ; preds = %2404
  %2407 = call { double, double } @__muldc3(double noundef %2395, double noundef %2396, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %2408 = extractvalue { double, double } %2407, 0
  %2409 = extractvalue { double, double } %2407, 1
  br label %2410

2410:                                             ; preds = %2406, %2404, %2352
  %2411 = phi double [ %2401, %2352 ], [ %2401, %2404 ], [ %2408, %2406 ]
  %2412 = phi double [ %2402, %2352 ], [ %2402, %2404 ], [ %2409, %2406 ]
  %2413 = fptrunc double %2411 to float
  %2414 = fptrunc double %2412 to float
  %2415 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2416 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2413, ptr %2415, align 4
  store float %2414, ptr %2416, align 4
  %2417 = load ptr, ptr %5, align 8, !tbaa !5
  %2418 = getelementptr inbounds { float, float }, ptr %2417, i64 2
  %2419 = getelementptr inbounds { float, float }, ptr %2418, i32 0, i32 0
  %2420 = load float, ptr %2419, align 4
  %2421 = getelementptr inbounds { float, float }, ptr %2418, i32 0, i32 1
  %2422 = load float, ptr %2421, align 4
  %2423 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2424 = load float, ptr %2423, align 4
  %2425 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2426 = load float, ptr %2425, align 4
  %2427 = fsub float %2420, %2424
  %2428 = fsub float %2422, %2426
  %2429 = load ptr, ptr %5, align 8, !tbaa !5
  %2430 = getelementptr inbounds { float, float }, ptr %2429, i64 10
  %2431 = getelementptr inbounds { float, float }, ptr %2430, i32 0, i32 0
  %2432 = getelementptr inbounds { float, float }, ptr %2430, i32 0, i32 1
  store float %2427, ptr %2431, align 4
  store float %2428, ptr %2432, align 4
  %2433 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2434 = load float, ptr %2433, align 4
  %2435 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2436 = load float, ptr %2435, align 4
  %2437 = load ptr, ptr %5, align 8, !tbaa !5
  %2438 = getelementptr inbounds { float, float }, ptr %2437, i64 2
  %2439 = getelementptr inbounds { float, float }, ptr %2438, i32 0, i32 0
  %2440 = load float, ptr %2439, align 4
  %2441 = getelementptr inbounds { float, float }, ptr %2438, i32 0, i32 1
  %2442 = load float, ptr %2441, align 4
  %2443 = fadd float %2440, %2434
  %2444 = fadd float %2442, %2436
  %2445 = getelementptr inbounds { float, float }, ptr %2438, i32 0, i32 0
  %2446 = getelementptr inbounds { float, float }, ptr %2438, i32 0, i32 1
  store float %2443, ptr %2445, align 4
  store float %2444, ptr %2446, align 4
  %2447 = load ptr, ptr %5, align 8, !tbaa !5
  %2448 = getelementptr inbounds { float, float }, ptr %2447, i64 11
  %2449 = getelementptr inbounds { float, float }, ptr %2448, i32 0, i32 0
  %2450 = load float, ptr %2449, align 4
  %2451 = getelementptr inbounds { float, float }, ptr %2448, i32 0, i32 1
  %2452 = load float, ptr %2451, align 4
  %2453 = fpext float %2450 to double
  %2454 = fpext float %2452 to double
  %2455 = fmul double %2453, 0x3FD87DE2A4248CFD
  %2456 = fmul double %2454, 0x3FED906BBDBE3C10
  %2457 = fmul double %2453, 0x3FED906BBDBE3C10
  %2458 = fmul double %2454, 0x3FD87DE2A4248CFD
  %2459 = fsub double %2455, %2456
  %2460 = fadd double %2457, %2458
  %2461 = fcmp uno double %2459, %2459
  br i1 %2461, label %2462, label %2468, !prof !15

2462:                                             ; preds = %2410
  %2463 = fcmp uno double %2460, %2460
  br i1 %2463, label %2464, label %2468, !prof !15

2464:                                             ; preds = %2462
  %2465 = call { double, double } @__muldc3(double noundef %2453, double noundef %2454, double noundef 0x3FD87DE2A4248CFD, double noundef 0x3FED906BBDBE3C10) #2
  %2466 = extractvalue { double, double } %2465, 0
  %2467 = extractvalue { double, double } %2465, 1
  br label %2468

2468:                                             ; preds = %2464, %2462, %2410
  %2469 = phi double [ %2459, %2410 ], [ %2459, %2462 ], [ %2466, %2464 ]
  %2470 = phi double [ %2460, %2410 ], [ %2460, %2462 ], [ %2467, %2464 ]
  %2471 = fptrunc double %2469 to float
  %2472 = fptrunc double %2470 to float
  %2473 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2474 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2471, ptr %2473, align 4
  store float %2472, ptr %2474, align 4
  %2475 = load ptr, ptr %5, align 8, !tbaa !5
  %2476 = getelementptr inbounds { float, float }, ptr %2475, i64 3
  %2477 = getelementptr inbounds { float, float }, ptr %2476, i32 0, i32 0
  %2478 = load float, ptr %2477, align 4
  %2479 = getelementptr inbounds { float, float }, ptr %2476, i32 0, i32 1
  %2480 = load float, ptr %2479, align 4
  %2481 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2482 = load float, ptr %2481, align 4
  %2483 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2484 = load float, ptr %2483, align 4
  %2485 = fsub float %2478, %2482
  %2486 = fsub float %2480, %2484
  %2487 = load ptr, ptr %5, align 8, !tbaa !5
  %2488 = getelementptr inbounds { float, float }, ptr %2487, i64 11
  %2489 = getelementptr inbounds { float, float }, ptr %2488, i32 0, i32 0
  %2490 = getelementptr inbounds { float, float }, ptr %2488, i32 0, i32 1
  store float %2485, ptr %2489, align 4
  store float %2486, ptr %2490, align 4
  %2491 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2492 = load float, ptr %2491, align 4
  %2493 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2494 = load float, ptr %2493, align 4
  %2495 = load ptr, ptr %5, align 8, !tbaa !5
  %2496 = getelementptr inbounds { float, float }, ptr %2495, i64 3
  %2497 = getelementptr inbounds { float, float }, ptr %2496, i32 0, i32 0
  %2498 = load float, ptr %2497, align 4
  %2499 = getelementptr inbounds { float, float }, ptr %2496, i32 0, i32 1
  %2500 = load float, ptr %2499, align 4
  %2501 = fadd float %2498, %2492
  %2502 = fadd float %2500, %2494
  %2503 = getelementptr inbounds { float, float }, ptr %2496, i32 0, i32 0
  %2504 = getelementptr inbounds { float, float }, ptr %2496, i32 0, i32 1
  store float %2501, ptr %2503, align 4
  store float %2502, ptr %2504, align 4
  %2505 = load ptr, ptr %5, align 8, !tbaa !5
  %2506 = getelementptr inbounds { float, float }, ptr %2505, i64 12
  %2507 = getelementptr inbounds { float, float }, ptr %2506, i32 0, i32 0
  %2508 = load float, ptr %2507, align 4
  %2509 = getelementptr inbounds { float, float }, ptr %2506, i32 0, i32 1
  %2510 = load float, ptr %2509, align 4
  %2511 = fmul float %2508, 0.000000e+00
  %2512 = fmul float %2510, 1.000000e+00
  %2513 = fmul float %2508, 1.000000e+00
  %2514 = fmul float %2510, 0.000000e+00
  %2515 = fsub float %2511, %2512
  %2516 = fadd float %2513, %2514
  %2517 = fcmp uno float %2515, %2515
  br i1 %2517, label %2518, label %2526, !prof !15

2518:                                             ; preds = %2468
  %2519 = fcmp uno float %2516, %2516
  br i1 %2519, label %2520, label %2526, !prof !15

2520:                                             ; preds = %2518
  %2521 = call <2 x float> @__mulsc3(float noundef %2508, float noundef %2510, float noundef 0.000000e+00, float noundef 1.000000e+00) #2
  store <2 x float> %2521, ptr %20, align 4
  %2522 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 0
  %2523 = load float, ptr %2522, align 4
  %2524 = getelementptr inbounds { float, float }, ptr %20, i32 0, i32 1
  %2525 = load float, ptr %2524, align 4
  br label %2526

2526:                                             ; preds = %2520, %2518, %2468
  %2527 = phi float [ %2515, %2468 ], [ %2515, %2518 ], [ %2523, %2520 ]
  %2528 = phi float [ %2516, %2468 ], [ %2516, %2518 ], [ %2525, %2520 ]
  %2529 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2530 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2527, ptr %2529, align 4
  store float %2528, ptr %2530, align 4
  %2531 = load ptr, ptr %5, align 8, !tbaa !5
  %2532 = getelementptr inbounds { float, float }, ptr %2531, i64 4
  %2533 = getelementptr inbounds { float, float }, ptr %2532, i32 0, i32 0
  %2534 = load float, ptr %2533, align 4
  %2535 = getelementptr inbounds { float, float }, ptr %2532, i32 0, i32 1
  %2536 = load float, ptr %2535, align 4
  %2537 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2538 = load float, ptr %2537, align 4
  %2539 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2540 = load float, ptr %2539, align 4
  %2541 = fsub float %2534, %2538
  %2542 = fsub float %2536, %2540
  %2543 = load ptr, ptr %5, align 8, !tbaa !5
  %2544 = getelementptr inbounds { float, float }, ptr %2543, i64 12
  %2545 = getelementptr inbounds { float, float }, ptr %2544, i32 0, i32 0
  %2546 = getelementptr inbounds { float, float }, ptr %2544, i32 0, i32 1
  store float %2541, ptr %2545, align 4
  store float %2542, ptr %2546, align 4
  %2547 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2548 = load float, ptr %2547, align 4
  %2549 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2550 = load float, ptr %2549, align 4
  %2551 = load ptr, ptr %5, align 8, !tbaa !5
  %2552 = getelementptr inbounds { float, float }, ptr %2551, i64 4
  %2553 = getelementptr inbounds { float, float }, ptr %2552, i32 0, i32 0
  %2554 = load float, ptr %2553, align 4
  %2555 = getelementptr inbounds { float, float }, ptr %2552, i32 0, i32 1
  %2556 = load float, ptr %2555, align 4
  %2557 = fadd float %2554, %2548
  %2558 = fadd float %2556, %2550
  %2559 = getelementptr inbounds { float, float }, ptr %2552, i32 0, i32 0
  %2560 = getelementptr inbounds { float, float }, ptr %2552, i32 0, i32 1
  store float %2557, ptr %2559, align 4
  store float %2558, ptr %2560, align 4
  %2561 = load ptr, ptr %5, align 8, !tbaa !5
  %2562 = getelementptr inbounds { float, float }, ptr %2561, i64 13
  %2563 = getelementptr inbounds { float, float }, ptr %2562, i32 0, i32 0
  %2564 = load float, ptr %2563, align 4
  %2565 = getelementptr inbounds { float, float }, ptr %2562, i32 0, i32 1
  %2566 = load float, ptr %2565, align 4
  %2567 = fpext float %2564 to double
  %2568 = fpext float %2566 to double
  %2569 = fmul double %2567, 0xBFD87DE283EE36AA
  %2570 = fmul double %2568, 0x3FED906BDDF49264
  %2571 = fmul double %2567, 0x3FED906BDDF49264
  %2572 = fmul double %2568, 0xBFD87DE283EE36AA
  %2573 = fsub double %2569, %2570
  %2574 = fadd double %2571, %2572
  %2575 = fcmp uno double %2573, %2573
  br i1 %2575, label %2576, label %2582, !prof !15

2576:                                             ; preds = %2526
  %2577 = fcmp uno double %2574, %2574
  br i1 %2577, label %2578, label %2582, !prof !15

2578:                                             ; preds = %2576
  %2579 = call { double, double } @__muldc3(double noundef %2567, double noundef %2568, double noundef 0xBFD87DE283EE36AA, double noundef 0x3FED906BDDF49264) #2
  %2580 = extractvalue { double, double } %2579, 0
  %2581 = extractvalue { double, double } %2579, 1
  br label %2582

2582:                                             ; preds = %2578, %2576, %2526
  %2583 = phi double [ %2573, %2526 ], [ %2573, %2576 ], [ %2580, %2578 ]
  %2584 = phi double [ %2574, %2526 ], [ %2574, %2576 ], [ %2581, %2578 ]
  %2585 = fptrunc double %2583 to float
  %2586 = fptrunc double %2584 to float
  %2587 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2588 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2585, ptr %2587, align 4
  store float %2586, ptr %2588, align 4
  %2589 = load ptr, ptr %5, align 8, !tbaa !5
  %2590 = getelementptr inbounds { float, float }, ptr %2589, i64 5
  %2591 = getelementptr inbounds { float, float }, ptr %2590, i32 0, i32 0
  %2592 = load float, ptr %2591, align 4
  %2593 = getelementptr inbounds { float, float }, ptr %2590, i32 0, i32 1
  %2594 = load float, ptr %2593, align 4
  %2595 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2596 = load float, ptr %2595, align 4
  %2597 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2598 = load float, ptr %2597, align 4
  %2599 = fsub float %2592, %2596
  %2600 = fsub float %2594, %2598
  %2601 = load ptr, ptr %5, align 8, !tbaa !5
  %2602 = getelementptr inbounds { float, float }, ptr %2601, i64 13
  %2603 = getelementptr inbounds { float, float }, ptr %2602, i32 0, i32 0
  %2604 = getelementptr inbounds { float, float }, ptr %2602, i32 0, i32 1
  store float %2599, ptr %2603, align 4
  store float %2600, ptr %2604, align 4
  %2605 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2606 = load float, ptr %2605, align 4
  %2607 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2608 = load float, ptr %2607, align 4
  %2609 = load ptr, ptr %5, align 8, !tbaa !5
  %2610 = getelementptr inbounds { float, float }, ptr %2609, i64 5
  %2611 = getelementptr inbounds { float, float }, ptr %2610, i32 0, i32 0
  %2612 = load float, ptr %2611, align 4
  %2613 = getelementptr inbounds { float, float }, ptr %2610, i32 0, i32 1
  %2614 = load float, ptr %2613, align 4
  %2615 = fadd float %2612, %2606
  %2616 = fadd float %2614, %2608
  %2617 = getelementptr inbounds { float, float }, ptr %2610, i32 0, i32 0
  %2618 = getelementptr inbounds { float, float }, ptr %2610, i32 0, i32 1
  store float %2615, ptr %2617, align 4
  store float %2616, ptr %2618, align 4
  %2619 = load ptr, ptr %5, align 8, !tbaa !5
  %2620 = getelementptr inbounds { float, float }, ptr %2619, i64 14
  %2621 = getelementptr inbounds { float, float }, ptr %2620, i32 0, i32 0
  %2622 = load float, ptr %2621, align 4
  %2623 = getelementptr inbounds { float, float }, ptr %2620, i32 0, i32 1
  %2624 = load float, ptr %2623, align 4
  %2625 = fpext float %2622 to double
  %2626 = fpext float %2624 to double
  %2627 = fmul double %2625, 0xBFE6A09E607DC426
  %2628 = fmul double %2626, 0x3FE6A09E607DC426
  %2629 = fmul double %2625, 0x3FE6A09E607DC426
  %2630 = fmul double %2626, 0xBFE6A09E607DC426
  %2631 = fsub double %2627, %2628
  %2632 = fadd double %2629, %2630
  %2633 = fcmp uno double %2631, %2631
  br i1 %2633, label %2634, label %2640, !prof !15

2634:                                             ; preds = %2582
  %2635 = fcmp uno double %2632, %2632
  br i1 %2635, label %2636, label %2640, !prof !15

2636:                                             ; preds = %2634
  %2637 = call { double, double } @__muldc3(double noundef %2625, double noundef %2626, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #2
  %2638 = extractvalue { double, double } %2637, 0
  %2639 = extractvalue { double, double } %2637, 1
  br label %2640

2640:                                             ; preds = %2636, %2634, %2582
  %2641 = phi double [ %2631, %2582 ], [ %2631, %2634 ], [ %2638, %2636 ]
  %2642 = phi double [ %2632, %2582 ], [ %2632, %2634 ], [ %2639, %2636 ]
  %2643 = fptrunc double %2641 to float
  %2644 = fptrunc double %2642 to float
  %2645 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2646 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2643, ptr %2645, align 4
  store float %2644, ptr %2646, align 4
  %2647 = load ptr, ptr %5, align 8, !tbaa !5
  %2648 = getelementptr inbounds { float, float }, ptr %2647, i64 6
  %2649 = getelementptr inbounds { float, float }, ptr %2648, i32 0, i32 0
  %2650 = load float, ptr %2649, align 4
  %2651 = getelementptr inbounds { float, float }, ptr %2648, i32 0, i32 1
  %2652 = load float, ptr %2651, align 4
  %2653 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2654 = load float, ptr %2653, align 4
  %2655 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2656 = load float, ptr %2655, align 4
  %2657 = fsub float %2650, %2654
  %2658 = fsub float %2652, %2656
  %2659 = load ptr, ptr %5, align 8, !tbaa !5
  %2660 = getelementptr inbounds { float, float }, ptr %2659, i64 14
  %2661 = getelementptr inbounds { float, float }, ptr %2660, i32 0, i32 0
  %2662 = getelementptr inbounds { float, float }, ptr %2660, i32 0, i32 1
  store float %2657, ptr %2661, align 4
  store float %2658, ptr %2662, align 4
  %2663 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2664 = load float, ptr %2663, align 4
  %2665 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2666 = load float, ptr %2665, align 4
  %2667 = load ptr, ptr %5, align 8, !tbaa !5
  %2668 = getelementptr inbounds { float, float }, ptr %2667, i64 6
  %2669 = getelementptr inbounds { float, float }, ptr %2668, i32 0, i32 0
  %2670 = load float, ptr %2669, align 4
  %2671 = getelementptr inbounds { float, float }, ptr %2668, i32 0, i32 1
  %2672 = load float, ptr %2671, align 4
  %2673 = fadd float %2670, %2664
  %2674 = fadd float %2672, %2666
  %2675 = getelementptr inbounds { float, float }, ptr %2668, i32 0, i32 0
  %2676 = getelementptr inbounds { float, float }, ptr %2668, i32 0, i32 1
  store float %2673, ptr %2675, align 4
  store float %2674, ptr %2676, align 4
  %2677 = load ptr, ptr %5, align 8, !tbaa !5
  %2678 = getelementptr inbounds { float, float }, ptr %2677, i64 15
  %2679 = getelementptr inbounds { float, float }, ptr %2678, i32 0, i32 0
  %2680 = load float, ptr %2679, align 4
  %2681 = getelementptr inbounds { float, float }, ptr %2678, i32 0, i32 1
  %2682 = load float, ptr %2681, align 4
  %2683 = fpext float %2680 to double
  %2684 = fpext float %2682 to double
  %2685 = fmul double %2683, 0xBFED906BBDBE3C10
  %2686 = fmul double %2684, 0x3FD87DE2E49139A4
  %2687 = fmul double %2683, 0x3FD87DE2E49139A4
  %2688 = fmul double %2684, 0xBFED906BBDBE3C10
  %2689 = fsub double %2685, %2686
  %2690 = fadd double %2687, %2688
  %2691 = fcmp uno double %2689, %2689
  br i1 %2691, label %2692, label %2698, !prof !15

2692:                                             ; preds = %2640
  %2693 = fcmp uno double %2690, %2690
  br i1 %2693, label %2694, label %2698, !prof !15

2694:                                             ; preds = %2692
  %2695 = call { double, double } @__muldc3(double noundef %2683, double noundef %2684, double noundef 0xBFED906BBDBE3C10, double noundef 0x3FD87DE2E49139A4) #2
  %2696 = extractvalue { double, double } %2695, 0
  %2697 = extractvalue { double, double } %2695, 1
  br label %2698

2698:                                             ; preds = %2694, %2692, %2640
  %2699 = phi double [ %2689, %2640 ], [ %2689, %2692 ], [ %2696, %2694 ]
  %2700 = phi double [ %2690, %2640 ], [ %2690, %2692 ], [ %2697, %2694 ]
  %2701 = fptrunc double %2699 to float
  %2702 = fptrunc double %2700 to float
  %2703 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2704 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  store float %2701, ptr %2703, align 4
  store float %2702, ptr %2704, align 4
  %2705 = load ptr, ptr %5, align 8, !tbaa !5
  %2706 = getelementptr inbounds { float, float }, ptr %2705, i64 7
  %2707 = getelementptr inbounds { float, float }, ptr %2706, i32 0, i32 0
  %2708 = load float, ptr %2707, align 4
  %2709 = getelementptr inbounds { float, float }, ptr %2706, i32 0, i32 1
  %2710 = load float, ptr %2709, align 4
  %2711 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2712 = load float, ptr %2711, align 4
  %2713 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2714 = load float, ptr %2713, align 4
  %2715 = fsub float %2708, %2712
  %2716 = fsub float %2710, %2714
  %2717 = load ptr, ptr %5, align 8, !tbaa !5
  %2718 = getelementptr inbounds { float, float }, ptr %2717, i64 15
  %2719 = getelementptr inbounds { float, float }, ptr %2718, i32 0, i32 0
  %2720 = getelementptr inbounds { float, float }, ptr %2718, i32 0, i32 1
  store float %2715, ptr %2719, align 4
  store float %2716, ptr %2720, align 4
  %2721 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 0
  %2722 = load float, ptr %2721, align 4
  %2723 = getelementptr inbounds { float, float }, ptr %3, i32 0, i32 1
  %2724 = load float, ptr %2723, align 4
  %2725 = load ptr, ptr %5, align 8, !tbaa !5
  %2726 = getelementptr inbounds { float, float }, ptr %2725, i64 7
  %2727 = getelementptr inbounds { float, float }, ptr %2726, i32 0, i32 0
  %2728 = load float, ptr %2727, align 4
  %2729 = getelementptr inbounds { float, float }, ptr %2726, i32 0, i32 1
  %2730 = load float, ptr %2729, align 4
  %2731 = fadd float %2728, %2722
  %2732 = fadd float %2730, %2724
  %2733 = getelementptr inbounds { float, float }, ptr %2726, i32 0, i32 0
  %2734 = getelementptr inbounds { float, float }, ptr %2726, i32 0, i32 1
  store float %2731, ptr %2733, align 4
  store float %2732, ptr %2734, align 4
  br label %2735

2735:                                             ; preds = %2698, %2293
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #2
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #2
  ret i32 0
}

declare <2 x float> @__mulsc3(float, float, float, float)

declare { double, double } @__muldc3(double, double, double, double)

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="64" "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 = { 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, !6, i64 8}
!10 = !{!"fftplan_s", !11, i64 0, !6, i64 8, !6, i64 16, !11, i64 24, !11, i64 28, !11, i64 32, !11, i64 36, !6, i64 40, !6, i64 48, !6, i64 56, !7, i64 64}
!11 = !{!"int", !7, i64 0}
!12 = !{!10, !6, i64 16}
!13 = !{!10, !11, i64 24}
!14 = !{!11, !11, i64 0}
!15 = !{!"branch_weights", i32 1, i32 1048575}


; 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: nounwind uwtable
define dso_local noundef i32 @fft_execute_dft_16(ptr nocapture noundef readonly %0) local_unnamed_addr #0 {
  %2 = getelementptr inbounds i8, ptr %0, i64 8
  %3 = load ptr, ptr %2, align 8, !tbaa !5
  %4 = getelementptr inbounds i8, ptr %0, i64 16
  %5 = load ptr, ptr %4, align 8, !tbaa !11
  %6 = getelementptr inbounds i8, ptr %0, i64 24
  %7 = load i32, ptr %6, align 8, !tbaa !12
  %8 = icmp eq i32 %7, 1
  %9 = getelementptr inbounds i8, ptr %3, i64 64
  %10 = getelementptr inbounds i8, ptr %5, i64 8
  %11 = getelementptr inbounds i8, ptr %5, i64 12
  %12 = getelementptr inbounds i8, ptr %3, i64 32
  %13 = getelementptr inbounds i8, ptr %5, i64 16
  %14 = getelementptr inbounds i8, ptr %5, i64 20
  %15 = getelementptr inbounds i8, ptr %3, i64 96
  %16 = getelementptr inbounds i8, ptr %5, i64 24
  %17 = getelementptr inbounds i8, ptr %5, i64 28
  %18 = getelementptr inbounds i8, ptr %3, i64 16
  %19 = getelementptr inbounds i8, ptr %5, i64 32
  %20 = getelementptr inbounds i8, ptr %3, i64 80
  %21 = getelementptr inbounds i8, ptr %5, i64 40
  %22 = getelementptr inbounds i8, ptr %5, i64 44
  %23 = getelementptr inbounds i8, ptr %3, i64 48
  %24 = getelementptr inbounds i8, ptr %5, i64 48
  %25 = getelementptr inbounds i8, ptr %5, i64 52
  %26 = getelementptr inbounds i8, ptr %3, i64 112
  %27 = getelementptr inbounds i8, ptr %5, i64 56
  %28 = getelementptr inbounds i8, ptr %5, i64 60
  %29 = getelementptr inbounds i8, ptr %3, i64 8
  %30 = getelementptr inbounds i8, ptr %5, i64 64
  %31 = getelementptr inbounds i8, ptr %3, i64 72
  %32 = getelementptr inbounds i8, ptr %5, i64 72
  %33 = getelementptr inbounds i8, ptr %5, i64 76
  %34 = getelementptr inbounds i8, ptr %3, i64 40
  %35 = getelementptr inbounds i8, ptr %5, i64 80
  %36 = getelementptr inbounds i8, ptr %5, i64 84
  %37 = getelementptr inbounds i8, ptr %3, i64 104
  %38 = getelementptr inbounds i8, ptr %5, i64 88
  %39 = getelementptr inbounds i8, ptr %5, i64 92
  %40 = getelementptr inbounds i8, ptr %3, i64 24
  %41 = getelementptr inbounds i8, ptr %5, i64 96
  %42 = getelementptr inbounds i8, ptr %5, i64 100
  %43 = getelementptr inbounds i8, ptr %3, i64 88
  %44 = getelementptr inbounds i8, ptr %5, i64 104
  %45 = getelementptr inbounds i8, ptr %5, i64 108
  %46 = getelementptr inbounds i8, ptr %3, i64 56
  %47 = getelementptr inbounds i8, ptr %5, i64 112
  %48 = getelementptr inbounds i8, ptr %5, i64 116
  %49 = getelementptr inbounds i8, ptr %3, i64 120
  %50 = getelementptr inbounds i8, ptr %5, i64 120
  %51 = getelementptr inbounds i8, ptr %5, i64 124
  %52 = load <2 x float>, ptr %3, align 4
  store <2 x float> %52, ptr %5, align 4
  %53 = load <2 x float>, ptr %9, align 4
  store <2 x float> %53, ptr %10, align 4
  %54 = fsub <2 x float> %52, %53
  %55 = load <2 x float>, ptr %12, align 4
  store <2 x float> %55, ptr %13, align 4
  %56 = load <2 x float>, ptr %15, align 4
  store <2 x float> %56, ptr %16, align 4
  %57 = fsub <2 x float> %55, %56
  %58 = fadd <2 x float> %52, %53
  %59 = fadd <2 x float> %55, %56
  %60 = fsub <2 x float> %58, %59
  %61 = fadd <2 x float> %58, %59
  %62 = load <2 x float>, ptr %18, align 4
  store <2 x float> %62, ptr %19, align 4
  %63 = load <2 x float>, ptr %20, align 4
  store <2 x float> %63, ptr %21, align 4
  %64 = fadd <2 x float> %62, %63
  %65 = load <2 x float>, ptr %23, align 4
  store <2 x float> %65, ptr %24, align 4
  %66 = load <2 x float>, ptr %26, align 4
  store <2 x float> %66, ptr %27, align 4
  %67 = load <2 x float>, ptr %29, align 4
  store <2 x float> %67, ptr %30, align 4
  %68 = load <2 x float>, ptr %31, align 4
  store <2 x float> %68, ptr %32, align 4
  %69 = load <2 x float>, ptr %34, align 4
  store <2 x float> %69, ptr %35, align 4
  %70 = load <2 x float>, ptr %37, align 4
  store <2 x float> %70, ptr %38, align 4
  %71 = load <2 x float>, ptr %40, align 4
  store <2 x float> %71, ptr %41, align 4
  %72 = load <2 x float>, ptr %43, align 4
  store <2 x float> %72, ptr %44, align 4
  %73 = load <2 x float>, ptr %46, align 4
  store <2 x float> %73, ptr %47, align 4
  %74 = load <2 x float>, ptr %49, align 4
  store <2 x float> %54, ptr %10, align 4
  store <2 x float> %57, ptr %16, align 4
  %75 = fsub <2 x float> %65, %66
  store <2 x float> %75, ptr %27, align 4
  %76 = fadd <2 x float> %65, %66
  %77 = fadd <2 x float> %67, %68
  %78 = fadd <2 x float> %69, %70
  %79 = fadd <2 x float> %71, %72
  %80 = fadd <2 x float> %73, %74
  store <2 x float> %60, ptr %13, align 4
  store <2 x float> %61, ptr %5, align 4
  %81 = fsub <2 x float> %64, %76
  store <2 x float> %81, ptr %24, align 4
  %82 = shufflevector <2 x float> %64, <2 x float> %62, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %83 = shufflevector <2 x float> %63, <2 x float> %76, <4 x i32> <i32 2, i32 3, i32 0, i32 1>
  %84 = fadd <4 x float> %82, %83
  %85 = fsub <4 x float> %82, %83
  %86 = shufflevector <4 x float> %84, <4 x float> %85, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
  store <4 x float> %86, ptr %19, align 4
  %87 = fsub <2 x float> %77, %78
  %88 = fsub <2 x float> %69, %70
  %89 = shufflevector <2 x float> %87, <2 x float> %88, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  store <4 x float> %89, ptr %35, align 4
  %90 = shufflevector <2 x float> %77, <2 x float> %67, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %91 = shufflevector <2 x float> %78, <2 x float> %68, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %92 = fadd <4 x float> %90, %91
  %93 = fsub <4 x float> %90, %91
  %94 = shufflevector <4 x float> %92, <4 x float> %93, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
  store <4 x float> %94, ptr %30, align 4
  %95 = fsub <2 x float> %79, %80
  %96 = fsub <2 x float> %73, %74
  %97 = shufflevector <2 x float> %95, <2 x float> %96, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  store <4 x float> %97, ptr %47, align 4
  %98 = shufflevector <2 x float> %79, <2 x float> %71, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %99 = shufflevector <2 x float> %80, <2 x float> %72, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
  %100 = fadd <4 x float> %98, %99
  %101 = fsub <4 x float> %98, %99
  %102 = shufflevector <4 x float> %100, <4 x float> %101, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
  store <4 x float> %102, ptr %41, align 4
  br i1 %8, label %103, label %194

103:                                              ; preds = %1
  %104 = extractelement <2 x float> %57, i64 0
  %105 = fneg float %104
  %106 = extractelement <2 x float> %57, i64 1
  %107 = fneg float %106
  %108 = fmul float %104, 0.000000e+00
  %109 = fmul float %106, -0.000000e+00
  %110 = shufflevector <2 x float> %57, <2 x float> poison, <2 x i32> <i32 1, i32 poison>
  %111 = insertelement <2 x float> %110, float %109, i64 1
  %112 = insertelement <2 x float> poison, float %108, i64 0
  %113 = shufflevector <2 x float> %112, <2 x float> %57, <2 x i32> <i32 0, i32 2>
  %114 = fsub <2 x float> %111, %113
  %115 = extractelement <2 x float> %114, i64 0
  %116 = fcmp uno float %115, 0.000000e+00
  %117 = extractelement <2 x float> %75, i64 0
  %118 = extractelement <2 x float> %75, i64 1
  br i1 %116, label %119, label %125, !prof !13

119:                                              ; preds = %103
  %120 = extractelement <2 x float> %114, i64 1
  %121 = fcmp uno float %120, 0.000000e+00
  br i1 %121, label %122, label %125, !prof !13

122:                                              ; preds = %119
  %123 = tail call <2 x float> @__mulsc3(float noundef %105, float noundef %107, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  %124 = load <2 x float>, ptr %10, align 4
  %.pre451 = load float, ptr %27, align 4
  %.pre452 = load float, ptr %28, align 4
  br label %125

125:                                              ; preds = %122, %119, %103
  %126 = phi float [ %118, %103 ], [ %118, %119 ], [ %.pre452, %122 ]
  %127 = phi float [ %117, %103 ], [ %117, %119 ], [ %.pre451, %122 ]
  %128 = phi <2 x float> [ %114, %103 ], [ %114, %119 ], [ %123, %122 ]
  %129 = phi <2 x float> [ %54, %103 ], [ %54, %119 ], [ %124, %122 ]
  %130 = fsub <2 x float> %129, %128
  store <2 x float> %130, ptr %16, align 4
  %131 = fadd <2 x float> %128, %129
  store <2 x float> %131, ptr %10, align 4
  %132 = fneg float %127
  %133 = fneg float %126
  %134 = fmul float %127, 0.000000e+00
  %135 = fmul float %126, -0.000000e+00
  %136 = insertelement <2 x float> poison, float %126, i64 0
  %137 = insertelement <2 x float> %136, float %135, i64 1
  %138 = insertelement <2 x float> poison, float %134, i64 0
  %139 = insertelement <2 x float> %138, float %127, i64 1
  %140 = fsub <2 x float> %137, %139
  %141 = extractelement <2 x float> %140, i64 0
  %142 = fcmp uno float %141, 0.000000e+00
  br i1 %142, label %143, label %148, !prof !13

143:                                              ; preds = %125
  %144 = extractelement <2 x float> %140, i64 1
  %145 = fcmp uno float %144, 0.000000e+00
  br i1 %145, label %146, label %148, !prof !13

146:                                              ; preds = %143
  %147 = tail call <2 x float> @__mulsc3(float noundef %132, float noundef %133, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %148

148:                                              ; preds = %146, %143, %125
  %149 = phi <2 x float> [ %140, %125 ], [ %140, %143 ], [ %147, %146 ]
  %150 = load <2 x float>, ptr %21, align 4
  %151 = fsub <2 x float> %150, %149
  store <2 x float> %151, ptr %27, align 4
  %152 = fadd <2 x float> %149, %150
  store <2 x float> %152, ptr %21, align 4
  %153 = load float, ptr %38, align 4
  %154 = load float, ptr %39, align 4
  %155 = fneg float %153
  %156 = fneg float %154
  %157 = fmul float %153, 0.000000e+00
  %158 = fmul float %154, -0.000000e+00
  %159 = insertelement <2 x float> poison, float %154, i64 0
  %160 = insertelement <2 x float> %159, float %158, i64 1
  %161 = insertelement <2 x float> poison, float %157, i64 0
  %162 = insertelement <2 x float> %161, float %153, i64 1
  %163 = fsub <2 x float> %160, %162
  %164 = extractelement <2 x float> %163, i64 0
  %165 = fcmp uno float %164, 0.000000e+00
  br i1 %165, label %166, label %171, !prof !13

166:                                              ; preds = %148
  %167 = extractelement <2 x float> %163, i64 1
  %168 = fcmp uno float %167, 0.000000e+00
  br i1 %168, label %169, label %171, !prof !13

169:                                              ; preds = %166
  %170 = tail call <2 x float> @__mulsc3(float noundef %155, float noundef %156, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %171

171:                                              ; preds = %169, %166, %148
  %172 = phi <2 x float> [ %163, %148 ], [ %163, %166 ], [ %170, %169 ]
  %173 = load <2 x float>, ptr %32, align 4
  %174 = fsub <2 x float> %173, %172
  store <2 x float> %174, ptr %38, align 4
  %175 = fadd <2 x float> %172, %173
  store <2 x float> %175, ptr %32, align 4
  %176 = load float, ptr %50, align 4
  %177 = load float, ptr %51, align 4
  %178 = fneg float %176
  %179 = fneg float %177
  %180 = fmul float %176, 0.000000e+00
  %181 = fmul float %177, -0.000000e+00
  %182 = insertelement <2 x float> poison, float %177, i64 0
  %183 = insertelement <2 x float> %182, float %181, i64 1
  %184 = insertelement <2 x float> poison, float %180, i64 0
  %185 = insertelement <2 x float> %184, float %176, i64 1
  %186 = fsub <2 x float> %183, %185
  %187 = extractelement <2 x float> %186, i64 0
  %188 = fcmp uno float %187, 0.000000e+00
  br i1 %188, label %189, label %271, !prof !13

189:                                              ; preds = %171
  %190 = extractelement <2 x float> %186, i64 1
  %191 = fcmp uno float %190, 0.000000e+00
  br i1 %191, label %192, label %271, !prof !13

192:                                              ; preds = %189
  %193 = tail call <2 x float> @__mulsc3(float noundef %178, float noundef %179, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %271

194:                                              ; preds = %1
  %195 = fmul <2 x float> %57, zeroinitializer
  %196 = shufflevector <2 x float> %57, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %197 = fsub <2 x float> %195, %196
  %198 = fadd <2 x float> %195, %196
  %199 = shufflevector <2 x float> %197, <2 x float> %198, <2 x i32> <i32 0, i32 3>
  %200 = extractelement <2 x float> %197, i64 0
  %201 = fcmp uno float %200, 0.000000e+00
  br i1 %201, label %202, label %211, !prof !13

202:                                              ; preds = %194
  %203 = extractelement <2 x float> %198, i64 1
  %204 = fcmp uno float %203, 0.000000e+00
  br i1 %204, label %205, label %211, !prof !13

205:                                              ; preds = %202
  %206 = extractelement <2 x float> %57, i64 0
  %207 = extractelement <2 x float> %57, i64 1
  %208 = tail call <2 x float> @__mulsc3(float noundef %206, float noundef %207, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  %209 = load <2 x float>, ptr %10, align 4
  %210 = load <2 x float>, ptr %27, align 4
  br label %211

211:                                              ; preds = %205, %202, %194
  %212 = phi <2 x float> [ %75, %194 ], [ %75, %202 ], [ %210, %205 ]
  %213 = phi <2 x float> [ %199, %194 ], [ %199, %202 ], [ %208, %205 ]
  %214 = phi <2 x float> [ %54, %194 ], [ %54, %202 ], [ %209, %205 ]
  %215 = fsub <2 x float> %214, %213
  store <2 x float> %215, ptr %16, align 4
  %216 = fadd <2 x float> %213, %214
  store <2 x float> %216, ptr %10, align 4
  %217 = fmul <2 x float> %212, zeroinitializer
  %218 = shufflevector <2 x float> %212, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %219 = fsub <2 x float> %217, %218
  %220 = fadd <2 x float> %217, %218
  %221 = shufflevector <2 x float> %219, <2 x float> %220, <2 x i32> <i32 0, i32 3>
  %222 = extractelement <2 x float> %219, i64 0
  %223 = fcmp uno float %222, 0.000000e+00
  br i1 %223, label %224, label %231, !prof !13

224:                                              ; preds = %211
  %225 = extractelement <2 x float> %220, i64 1
  %226 = fcmp uno float %225, 0.000000e+00
  br i1 %226, label %227, label %231, !prof !13

227:                                              ; preds = %224
  %228 = extractelement <2 x float> %212, i64 0
  %229 = extractelement <2 x float> %212, i64 1
  %230 = tail call <2 x float> @__mulsc3(float noundef %228, float noundef %229, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %231

231:                                              ; preds = %227, %224, %211
  %232 = phi <2 x float> [ %221, %211 ], [ %221, %224 ], [ %230, %227 ]
  %233 = load <2 x float>, ptr %21, align 4
  %234 = fsub <2 x float> %233, %232
  store <2 x float> %234, ptr %27, align 4
  %235 = fadd <2 x float> %232, %233
  store <2 x float> %235, ptr %21, align 4
  %236 = load <2 x float>, ptr %38, align 4
  %237 = fmul <2 x float> %236, zeroinitializer
  %238 = shufflevector <2 x float> %236, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %239 = fsub <2 x float> %237, %238
  %240 = fadd <2 x float> %237, %238
  %241 = shufflevector <2 x float> %239, <2 x float> %240, <2 x i32> <i32 0, i32 3>
  %242 = extractelement <2 x float> %239, i64 0
  %243 = fcmp uno float %242, 0.000000e+00
  br i1 %243, label %244, label %251, !prof !13

244:                                              ; preds = %231
  %245 = extractelement <2 x float> %240, i64 1
  %246 = fcmp uno float %245, 0.000000e+00
  br i1 %246, label %247, label %251, !prof !13

247:                                              ; preds = %244
  %248 = extractelement <2 x float> %236, i64 0
  %249 = extractelement <2 x float> %236, i64 1
  %250 = tail call <2 x float> @__mulsc3(float noundef %248, float noundef %249, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %251

251:                                              ; preds = %247, %244, %231
  %252 = phi <2 x float> [ %241, %231 ], [ %241, %244 ], [ %250, %247 ]
  %253 = load <2 x float>, ptr %32, align 4
  %254 = fsub <2 x float> %253, %252
  store <2 x float> %254, ptr %38, align 4
  %255 = fadd <2 x float> %252, %253
  store <2 x float> %255, ptr %32, align 4
  %256 = load <2 x float>, ptr %50, align 4
  %257 = fmul <2 x float> %256, zeroinitializer
  %258 = shufflevector <2 x float> %256, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %259 = fsub <2 x float> %257, %258
  %260 = fadd <2 x float> %257, %258
  %261 = shufflevector <2 x float> %259, <2 x float> %260, <2 x i32> <i32 0, i32 3>
  %262 = extractelement <2 x float> %259, i64 0
  %263 = fcmp uno float %262, 0.000000e+00
  br i1 %263, label %264, label %271, !prof !13

264:                                              ; preds = %251
  %265 = extractelement <2 x float> %260, i64 1
  %266 = fcmp uno float %265, 0.000000e+00
  br i1 %266, label %267, label %271, !prof !13

267:                                              ; preds = %264
  %268 = extractelement <2 x float> %256, i64 0
  %269 = extractelement <2 x float> %256, i64 1
  %270 = tail call <2 x float> @__mulsc3(float noundef %268, float noundef %269, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %271

271:                                              ; preds = %251, %264, %267, %171, %189, %192
  %272 = phi <2 x float> [ %186, %171 ], [ %186, %189 ], [ %193, %192 ], [ %261, %251 ], [ %261, %264 ], [ %270, %267 ]
  %273 = load <2 x float>, ptr %44, align 4
  %274 = fsub <2 x float> %273, %272
  store <2 x float> %274, ptr %50, align 4
  %275 = fadd <2 x float> %272, %273
  store <2 x float> %275, ptr %44, align 4
  %276 = load <2 x float>, ptr %19, align 4
  %277 = load <2 x float>, ptr %5, align 4
  %278 = fsub <2 x float> %277, %276
  store <2 x float> %278, ptr %19, align 4
  %279 = fadd <2 x float> %276, %277
  store <2 x float> %279, ptr %5, align 4
  %280 = load <2 x float>, ptr %41, align 4
  %281 = load <2 x float>, ptr %30, align 4
  %282 = fsub <2 x float> %281, %280
  store <2 x float> %282, ptr %41, align 4
  %283 = fadd <2 x float> %280, %281
  store <2 x float> %283, ptr %30, align 4
  %284 = load float, ptr %21, align 4
  %285 = load float, ptr %22, align 4
  %286 = fpext float %284 to double
  %287 = fpext float %285 to double
  %288 = fmul double %286, 0x3FE6A09E607DC426
  %289 = fmul double %287, 0x3FE6A09E607DC426
  br i1 %8, label %290, label %428

290:                                              ; preds = %271
  %291 = fadd double %288, %289
  %292 = fsub double %289, %288
  %293 = fcmp uno double %291, 0.000000e+00
  br i1 %293, label %294, label %301, !prof !13

294:                                              ; preds = %290
  %295 = fcmp uno double %292, 0.000000e+00
  br i1 %295, label %296, label %301, !prof !13

296:                                              ; preds = %294
  %297 = tail call { double, double } @__muldc3(double noundef %286, double noundef %287, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %298 = extractvalue { double, double } %297, 0
  %299 = extractvalue { double, double } %297, 1
  %300 = load <2 x float>, ptr %44, align 4
  br label %301

301:                                              ; preds = %296, %294, %290
  %302 = phi double [ %291, %290 ], [ %291, %294 ], [ %298, %296 ]
  %303 = phi double [ %292, %290 ], [ %292, %294 ], [ %299, %296 ]
  %304 = phi <2 x float> [ %275, %290 ], [ %275, %294 ], [ %300, %296 ]
  %305 = fptrunc double %302 to float
  %306 = fptrunc double %303 to float
  %307 = load float, ptr %10, align 4
  %308 = load float, ptr %11, align 4
  %309 = fsub float %307, %305
  %310 = fsub float %308, %306
  store float %309, ptr %21, align 4
  store float %310, ptr %22, align 4
  %311 = fadd float %307, %305
  %312 = fadd float %308, %306
  store float %311, ptr %10, align 4
  store float %312, ptr %11, align 4
  %313 = fpext <2 x float> %304 to <2 x double>
  %314 = fmul <2 x double> %313, <double 0x3FE6A09E607DC426, double 0x3FE6A09E607DC426>
  %315 = extractelement <2 x double> %314, i64 0
  %316 = extractelement <2 x double> %314, i64 1
  %317 = fadd double %315, %316
  %318 = fsub double %316, %315
  %319 = fcmp uno double %317, 0.000000e+00
  br i1 %319, label %320, label %328, !prof !13

320:                                              ; preds = %301
  %321 = fcmp uno double %318, 0.000000e+00
  br i1 %321, label %322, label %328, !prof !13

322:                                              ; preds = %320
  %323 = extractelement <2 x double> %313, i64 0
  %324 = extractelement <2 x double> %313, i64 1
  %325 = tail call { double, double } @__muldc3(double noundef %323, double noundef %324, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %326 = extractvalue { double, double } %325, 0
  %327 = extractvalue { double, double } %325, 1
  br label %328

328:                                              ; preds = %322, %320, %301
  %329 = phi double [ %317, %301 ], [ %317, %320 ], [ %326, %322 ]
  %330 = phi double [ %318, %301 ], [ %318, %320 ], [ %327, %322 ]
  %331 = fptrunc double %329 to float
  %332 = fptrunc double %330 to float
  %333 = load float, ptr %32, align 4
  %334 = load float, ptr %33, align 4
  %335 = fsub float %333, %331
  %336 = fsub float %334, %332
  store float %335, ptr %44, align 4
  store float %336, ptr %45, align 4
  %337 = fadd float %333, %331
  %338 = fadd float %334, %332
  store float %337, ptr %32, align 4
  store float %338, ptr %33, align 4
  %339 = load float, ptr %24, align 4
  %340 = load float, ptr %25, align 4
  %341 = fneg float %339
  %342 = fneg float %340
  %343 = fmul float %339, 0.000000e+00
  %344 = fmul float %340, -0.000000e+00
  %345 = insertelement <2 x float> poison, float %340, i64 0
  %346 = insertelement <2 x float> %345, float %344, i64 1
  %347 = insertelement <2 x float> poison, float %343, i64 0
  %348 = insertelement <2 x float> %347, float %339, i64 1
  %349 = fsub <2 x float> %346, %348
  %350 = extractelement <2 x float> %349, i64 0
  %351 = fcmp uno float %350, 0.000000e+00
  br i1 %351, label %352, label %357, !prof !13

352:                                              ; preds = %328
  %353 = extractelement <2 x float> %349, i64 1
  %354 = fcmp uno float %353, 0.000000e+00
  br i1 %354, label %355, label %357, !prof !13

355:                                              ; preds = %352
  %356 = tail call <2 x float> @__mulsc3(float noundef %341, float noundef %342, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %357

357:                                              ; preds = %355, %352, %328
  %358 = phi <2 x float> [ %349, %328 ], [ %349, %352 ], [ %356, %355 ]
  %359 = load <2 x float>, ptr %13, align 4
  %360 = fsub <2 x float> %359, %358
  store <2 x float> %360, ptr %24, align 4
  %361 = fadd <2 x float> %358, %359
  store <2 x float> %361, ptr %13, align 4
  %362 = load float, ptr %47, align 4
  %363 = load float, ptr %48, align 4
  %364 = fneg float %362
  %365 = fneg float %363
  %366 = fmul float %362, 0.000000e+00
  %367 = fmul float %363, -0.000000e+00
  %368 = insertelement <2 x float> poison, float %363, i64 0
  %369 = insertelement <2 x float> %368, float %367, i64 1
  %370 = insertelement <2 x float> poison, float %366, i64 0
  %371 = insertelement <2 x float> %370, float %362, i64 1
  %372 = fsub <2 x float> %369, %371
  %373 = extractelement <2 x float> %372, i64 0
  %374 = fcmp uno float %373, 0.000000e+00
  br i1 %374, label %375, label %380, !prof !13

375:                                              ; preds = %357
  %376 = extractelement <2 x float> %372, i64 1
  %377 = fcmp uno float %376, 0.000000e+00
  br i1 %377, label %378, label %380, !prof !13

378:                                              ; preds = %375
  %379 = tail call <2 x float> @__mulsc3(float noundef %364, float noundef %365, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %380

380:                                              ; preds = %378, %375, %357
  %381 = phi <2 x float> [ %372, %357 ], [ %372, %375 ], [ %379, %378 ]
  %382 = load <2 x float>, ptr %35, align 4
  %383 = fsub <2 x float> %382, %381
  store <2 x float> %383, ptr %47, align 4
  %384 = fadd <2 x float> %381, %382
  store <2 x float> %384, ptr %35, align 4
  %385 = load <2 x float>, ptr %27, align 4
  %386 = fpext <2 x float> %385 to <2 x double>
  %387 = fmul <2 x double> %386, <double 0xBFE6A09E607DC426, double 0xBFE6A09E607DC426>
  %388 = extractelement <2 x double> %387, i64 0
  %389 = extractelement <2 x double> %387, i64 1
  %390 = fsub double %388, %389
  %391 = fadd double %388, %389
  %392 = fcmp uno double %390, 0.000000e+00
  br i1 %392, label %393, label %401, !prof !13

393:                                              ; preds = %380
  %394 = fcmp uno double %391, 0.000000e+00
  br i1 %394, label %395, label %401, !prof !13

395:                                              ; preds = %393
  %396 = extractelement <2 x double> %386, i64 0
  %397 = extractelement <2 x double> %386, i64 1
  %398 = tail call { double, double } @__muldc3(double noundef %396, double noundef %397, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %399 = extractvalue { double, double } %398, 0
  %400 = extractvalue { double, double } %398, 1
  br label %401

401:                                              ; preds = %395, %393, %380
  %402 = phi double [ %390, %380 ], [ %390, %393 ], [ %399, %395 ]
  %403 = phi double [ %391, %380 ], [ %391, %393 ], [ %400, %395 ]
  %404 = fptrunc double %402 to float
  %405 = fptrunc double %403 to float
  %406 = load float, ptr %16, align 4
  %407 = load float, ptr %17, align 4
  %408 = fsub float %406, %404
  %409 = fsub float %407, %405
  store float %408, ptr %27, align 4
  store float %409, ptr %28, align 4
  %410 = fadd float %406, %404
  %411 = fadd float %407, %405
  store float %410, ptr %16, align 4
  store float %411, ptr %17, align 4
  %412 = load <2 x float>, ptr %50, align 4
  %413 = fpext <2 x float> %412 to <2 x double>
  %414 = fmul <2 x double> %413, <double 0xBFE6A09E607DC426, double 0xBFE6A09E607DC426>
  %415 = extractelement <2 x double> %414, i64 0
  %416 = extractelement <2 x double> %414, i64 1
  %417 = fsub double %415, %416
  %418 = fadd double %415, %416
  %419 = fcmp uno double %417, 0.000000e+00
  br i1 %419, label %420, label %562, !prof !13

420:                                              ; preds = %401
  %421 = fcmp uno double %418, 0.000000e+00
  br i1 %421, label %422, label %562, !prof !13

422:                                              ; preds = %420
  %423 = extractelement <2 x double> %413, i64 0
  %424 = extractelement <2 x double> %413, i64 1
  %425 = tail call { double, double } @__muldc3(double noundef %423, double noundef %424, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %426 = extractvalue { double, double } %425, 0
  %427 = extractvalue { double, double } %425, 1
  br label %562

428:                                              ; preds = %271
  %429 = fsub double %288, %289
  %430 = fadd double %288, %289
  %431 = fcmp uno double %429, 0.000000e+00
  br i1 %431, label %432, label %439, !prof !13

432:                                              ; preds = %428
  %433 = fcmp uno double %430, 0.000000e+00
  br i1 %433, label %434, label %439, !prof !13

434:                                              ; preds = %432
  %435 = tail call { double, double } @__muldc3(double noundef %286, double noundef %287, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %436 = extractvalue { double, double } %435, 0
  %437 = extractvalue { double, double } %435, 1
  %438 = load <2 x float>, ptr %44, align 4
  br label %439

439:                                              ; preds = %434, %432, %428
  %440 = phi double [ %429, %428 ], [ %429, %432 ], [ %436, %434 ]
  %441 = phi double [ %430, %428 ], [ %430, %432 ], [ %437, %434 ]
  %442 = phi <2 x float> [ %275, %428 ], [ %275, %432 ], [ %438, %434 ]
  %443 = fptrunc double %440 to float
  %444 = fptrunc double %441 to float
  %445 = load float, ptr %10, align 4
  %446 = load float, ptr %11, align 4
  %447 = fsub float %445, %443
  %448 = fsub float %446, %444
  store float %447, ptr %21, align 4
  store float %448, ptr %22, align 4
  %449 = fadd float %445, %443
  %450 = fadd float %446, %444
  store float %449, ptr %10, align 4
  store float %450, ptr %11, align 4
  %451 = fpext <2 x float> %442 to <2 x double>
  %452 = fmul <2 x double> %451, <double 0x3FE6A09E607DC426, double 0x3FE6A09E607DC426>
  %453 = extractelement <2 x double> %452, i64 0
  %454 = extractelement <2 x double> %452, i64 1
  %455 = fsub double %453, %454
  %456 = fadd double %453, %454
  %457 = fcmp uno double %455, 0.000000e+00
  br i1 %457, label %458, label %466, !prof !13

458:                                              ; preds = %439
  %459 = fcmp uno double %456, 0.000000e+00
  br i1 %459, label %460, label %466, !prof !13

460:                                              ; preds = %458
  %461 = extractelement <2 x double> %451, i64 0
  %462 = extractelement <2 x double> %451, i64 1
  %463 = tail call { double, double } @__muldc3(double noundef %461, double noundef %462, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %464 = extractvalue { double, double } %463, 0
  %465 = extractvalue { double, double } %463, 1
  br label %466

466:                                              ; preds = %460, %458, %439
  %467 = phi double [ %455, %439 ], [ %455, %458 ], [ %464, %460 ]
  %468 = phi double [ %456, %439 ], [ %456, %458 ], [ %465, %460 ]
  %469 = fptrunc double %467 to float
  %470 = fptrunc double %468 to float
  %471 = load float, ptr %32, align 4
  %472 = load float, ptr %33, align 4
  %473 = fsub float %471, %469
  %474 = fsub float %472, %470
  store float %473, ptr %44, align 4
  store float %474, ptr %45, align 4
  %475 = fadd float %471, %469
  %476 = fadd float %472, %470
  store float %475, ptr %32, align 4
  store float %476, ptr %33, align 4
  %477 = load <2 x float>, ptr %24, align 4
  %478 = fmul <2 x float> %477, zeroinitializer
  %479 = shufflevector <2 x float> %477, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %480 = fsub <2 x float> %478, %479
  %481 = fadd <2 x float> %478, %479
  %482 = shufflevector <2 x float> %480, <2 x float> %481, <2 x i32> <i32 0, i32 3>
  %483 = extractelement <2 x float> %480, i64 0
  %484 = fcmp uno float %483, 0.000000e+00
  br i1 %484, label %485, label %492, !prof !13

485:                                              ; preds = %466
  %486 = extractelement <2 x float> %481, i64 1
  %487 = fcmp uno float %486, 0.000000e+00
  br i1 %487, label %488, label %492, !prof !13

488:                                              ; preds = %485
  %489 = extractelement <2 x float> %477, i64 0
  %490 = extractelement <2 x float> %477, i64 1
  %491 = tail call <2 x float> @__mulsc3(float noundef %489, float noundef %490, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %492

492:                                              ; preds = %488, %485, %466
  %493 = phi <2 x float> [ %482, %466 ], [ %482, %485 ], [ %491, %488 ]
  %494 = load <2 x float>, ptr %13, align 4
  %495 = fsub <2 x float> %494, %493
  store <2 x float> %495, ptr %24, align 4
  %496 = fadd <2 x float> %493, %494
  store <2 x float> %496, ptr %13, align 4
  %497 = load <2 x float>, ptr %47, align 4
  %498 = fmul <2 x float> %497, zeroinitializer
  %499 = shufflevector <2 x float> %497, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %500 = fsub <2 x float> %498, %499
  %501 = fadd <2 x float> %498, %499
  %502 = shufflevector <2 x float> %500, <2 x float> %501, <2 x i32> <i32 0, i32 3>
  %503 = extractelement <2 x float> %500, i64 0
  %504 = fcmp uno float %503, 0.000000e+00
  br i1 %504, label %505, label %512, !prof !13

505:                                              ; preds = %492
  %506 = extractelement <2 x float> %501, i64 1
  %507 = fcmp uno float %506, 0.000000e+00
  br i1 %507, label %508, label %512, !prof !13

508:                                              ; preds = %505
  %509 = extractelement <2 x float> %497, i64 0
  %510 = extractelement <2 x float> %497, i64 1
  %511 = tail call <2 x float> @__mulsc3(float noundef %509, float noundef %510, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %512

512:                                              ; preds = %508, %505, %492
  %513 = phi <2 x float> [ %502, %492 ], [ %502, %505 ], [ %511, %508 ]
  %514 = load <2 x float>, ptr %35, align 4
  %515 = fsub <2 x float> %514, %513
  store <2 x float> %515, ptr %47, align 4
  %516 = fadd <2 x float> %513, %514
  store <2 x float> %516, ptr %35, align 4
  %517 = load float, ptr %27, align 4
  %518 = load float, ptr %28, align 4
  %519 = fpext float %517 to double
  %520 = fpext float %518 to double
  %521 = fmul double %520, 0x3FE6A09E607DC426
  %522 = insertelement <2 x double> poison, double %519, i64 0
  %523 = shufflevector <2 x double> %522, <2 x double> poison, <2 x i32> zeroinitializer
  %524 = fmul <2 x double> %523, <double 0xBFE6A09E607DC426, double 0x3FE6A09E607DC426>
  %525 = insertelement <2 x double> poison, double %521, i64 0
  %526 = shufflevector <2 x double> %525, <2 x double> poison, <2 x i32> zeroinitializer
  %527 = fsub <2 x double> %524, %526
  %528 = extractelement <2 x double> %527, i64 0
  %529 = fcmp uno double %528, 0.000000e+00
  br i1 %529, label %530, label %539, !prof !13

530:                                              ; preds = %512
  %531 = extractelement <2 x double> %527, i64 1
  %532 = fcmp uno double %531, 0.000000e+00
  br i1 %532, label %533, label %539, !prof !13

533:                                              ; preds = %530
  %534 = tail call { double, double } @__muldc3(double noundef %519, double noundef %520, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %535 = extractvalue { double, double } %534, 0
  %536 = extractvalue { double, double } %534, 1
  %537 = insertelement <2 x double> poison, double %535, i64 0
  %538 = insertelement <2 x double> %537, double %536, i64 1
  br label %539

539:                                              ; preds = %533, %530, %512
  %540 = phi <2 x double> [ %527, %512 ], [ %527, %530 ], [ %538, %533 ]
  %541 = fptrunc <2 x double> %540 to <2 x float>
  %542 = load <2 x float>, ptr %16, align 4
  %543 = fsub <2 x float> %542, %541
  store <2 x float> %543, ptr %27, align 4
  %544 = fadd <2 x float> %542, %541
  store <2 x float> %544, ptr %16, align 4
  %545 = load <2 x float>, ptr %50, align 4
  %546 = fpext <2 x float> %545 to <2 x double>
  %547 = fmul <2 x double> %546, <double 0xBFE6A09E607DC426, double 0x3FE6A09E607DC426>
  %548 = extractelement <2 x double> %546, i64 0
  %549 = fmul double %548, 0x3FE6A09E607DC426
  %550 = extractelement <2 x double> %547, i64 0
  %551 = extractelement <2 x double> %547, i64 1
  %552 = fsub double %550, %551
  %553 = fsub double %549, %551
  %554 = fcmp uno double %552, 0.000000e+00
  br i1 %554, label %555, label %562, !prof !13

555:                                              ; preds = %539
  %556 = fcmp uno double %553, 0.000000e+00
  br i1 %556, label %557, label %562, !prof !13

557:                                              ; preds = %555
  %558 = extractelement <2 x double> %546, i64 1
  %559 = tail call { double, double } @__muldc3(double noundef %548, double noundef %558, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %560 = extractvalue { double, double } %559, 0
  %561 = extractvalue { double, double } %559, 1
  br label %562

562:                                              ; preds = %539, %555, %557, %401, %420, %422
  %.sink477 = phi double [ %417, %401 ], [ %417, %420 ], [ %426, %422 ], [ %552, %539 ], [ %552, %555 ], [ %560, %557 ]
  %.sink476 = phi double [ %418, %401 ], [ %418, %420 ], [ %427, %422 ], [ %553, %539 ], [ %553, %555 ], [ %561, %557 ]
  %563 = fptrunc double %.sink477 to float
  %564 = fptrunc double %.sink476 to float
  %565 = load float, ptr %38, align 4
  %566 = load float, ptr %39, align 4
  %567 = fsub float %565, %563
  %568 = fsub float %566, %564
  store float %567, ptr %50, align 4
  store float %568, ptr %51, align 4
  %569 = fadd float %565, %563
  %570 = fadd float %566, %564
  store float %569, ptr %38, align 4
  store float %570, ptr %39, align 4
  %571 = load <2 x float>, ptr %30, align 4
  %572 = load <2 x float>, ptr %5, align 4
  %573 = fsub <2 x float> %572, %571
  store <2 x float> %573, ptr %30, align 4
  %574 = fadd <2 x float> %571, %572
  store <2 x float> %574, ptr %5, align 4
  %575 = load <2 x float>, ptr %32, align 4
  %576 = fpext <2 x float> %575 to <2 x double>
  %577 = fmul <2 x double> %576, <double 0x3FD87DE2C45AE350, double 0x3FD87DE2C45AE350>
  %578 = shufflevector <2 x double> %577, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %579 = fmul <2 x double> %576, <double 0x3FED906BBDBE3C10, double 0x3FED906BBDBE3C10>
  br i1 %8, label %580, label %755

580:                                              ; preds = %562
  %581 = fadd <2 x double> %579, %578
  %582 = fsub <2 x double> %579, %578
  %583 = shufflevector <2 x double> %581, <2 x double> %582, <2 x i32> <i32 0, i32 3>
  %584 = extractelement <2 x double> %581, i64 0
  %585 = fcmp uno double %584, 0.000000e+00
  br i1 %585, label %586, label %597, !prof !13

586:                                              ; preds = %580
  %587 = extractelement <2 x double> %582, i64 1
  %588 = fcmp uno double %587, 0.000000e+00
  br i1 %588, label %589, label %597, !prof !13

589:                                              ; preds = %586
  %590 = extractelement <2 x double> %576, i64 0
  %591 = extractelement <2 x double> %576, i64 1
  %592 = tail call { double, double } @__muldc3(double noundef %590, double noundef %591, double noundef 0x3FED906BBDBE3C10, double noundef 0xBFD87DE2C45AE350) #1
  %593 = extractvalue { double, double } %592, 0
  %594 = extractvalue { double, double } %592, 1
  %595 = insertelement <2 x double> poison, double %593, i64 0
  %596 = insertelement <2 x double> %595, double %594, i64 1
  br label %597

597:                                              ; preds = %589, %586, %580
  %598 = phi <2 x double> [ %583, %580 ], [ %583, %586 ], [ %596, %589 ]
  %599 = fptrunc <2 x double> %598 to <2 x float>
  %600 = load <2 x float>, ptr %10, align 4
  %601 = fsub <2 x float> %600, %599
  store <2 x float> %601, ptr %32, align 4
  %602 = fadd <2 x float> %600, %599
  store <2 x float> %602, ptr %10, align 4
  %603 = load <2 x float>, ptr %35, align 4
  %604 = fpext <2 x float> %603 to <2 x double>
  %605 = fmul <2 x double> %604, <double 0x3FE6A09E607DC426, double 0x3FE6A09E607DC426>
  %606 = extractelement <2 x double> %605, i64 0
  %607 = extractelement <2 x double> %605, i64 1
  %608 = fadd double %606, %607
  %609 = fsub double %607, %606
  %610 = fcmp uno double %608, 0.000000e+00
  br i1 %610, label %611, label %619, !prof !13

611:                                              ; preds = %597
  %612 = fcmp uno double %609, 0.000000e+00
  br i1 %612, label %613, label %619, !prof !13

613:                                              ; preds = %611
  %614 = extractelement <2 x double> %604, i64 0
  %615 = extractelement <2 x double> %604, i64 1
  %616 = tail call { double, double } @__muldc3(double noundef %614, double noundef %615, double noundef 0x3FE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %617 = extractvalue { double, double } %616, 0
  %618 = extractvalue { double, double } %616, 1
  br label %619

619:                                              ; preds = %613, %611, %597
  %620 = phi double [ %608, %597 ], [ %608, %611 ], [ %617, %613 ]
  %621 = phi double [ %609, %597 ], [ %609, %611 ], [ %618, %613 ]
  %622 = fptrunc double %620 to float
  %623 = fptrunc double %621 to float
  %624 = load float, ptr %13, align 4
  %625 = load float, ptr %14, align 4
  %626 = fsub float %624, %622
  %627 = fsub float %625, %623
  store float %626, ptr %35, align 4
  store float %627, ptr %36, align 4
  %628 = fadd float %624, %622
  %629 = fadd float %625, %623
  store float %628, ptr %13, align 4
  store float %629, ptr %14, align 4
  %630 = load <2 x float>, ptr %38, align 4
  %631 = fpext <2 x float> %630 to <2 x double>
  %632 = fmul <2 x double> %631, <double 0x3FED906BBDBE3C10, double 0x3FED906BBDBE3C10>
  %633 = shufflevector <2 x double> %632, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %634 = fmul <2 x double> %631, <double 0x3FD87DE2A4248CFD, double 0x3FD87DE2A4248CFD>
  %635 = fadd <2 x double> %634, %633
  %636 = fsub <2 x double> %634, %633
  %637 = shufflevector <2 x double> %635, <2 x double> %636, <2 x i32> <i32 0, i32 3>
  %638 = extractelement <2 x double> %635, i64 0
  %639 = fcmp uno double %638, 0.000000e+00
  br i1 %639, label %640, label %651, !prof !13

640:                                              ; preds = %619
  %641 = extractelement <2 x double> %636, i64 1
  %642 = fcmp uno double %641, 0.000000e+00
  br i1 %642, label %643, label %651, !prof !13

643:                                              ; preds = %640
  %644 = extractelement <2 x double> %631, i64 0
  %645 = extractelement <2 x double> %631, i64 1
  %646 = tail call { double, double } @__muldc3(double noundef %644, double noundef %645, double noundef 0x3FD87DE2A4248CFD, double noundef 0xBFED906BBDBE3C10) #1
  %647 = extractvalue { double, double } %646, 0
  %648 = extractvalue { double, double } %646, 1
  %649 = insertelement <2 x double> poison, double %647, i64 0
  %650 = insertelement <2 x double> %649, double %648, i64 1
  br label %651

651:                                              ; preds = %643, %640, %619
  %652 = phi <2 x double> [ %637, %619 ], [ %637, %640 ], [ %650, %643 ]
  %653 = fptrunc <2 x double> %652 to <2 x float>
  %654 = load <2 x float>, ptr %16, align 4
  %655 = fsub <2 x float> %654, %653
  store <2 x float> %655, ptr %38, align 4
  %656 = fadd <2 x float> %654, %653
  store <2 x float> %656, ptr %16, align 4
  %657 = load float, ptr %41, align 4
  %658 = load float, ptr %42, align 4
  %659 = fneg float %657
  %660 = fneg float %658
  %661 = fmul float %657, 0.000000e+00
  %662 = fmul float %658, -0.000000e+00
  %663 = insertelement <2 x float> poison, float %658, i64 0
  %664 = insertelement <2 x float> %663, float %662, i64 1
  %665 = insertelement <2 x float> poison, float %661, i64 0
  %666 = insertelement <2 x float> %665, float %657, i64 1
  %667 = fsub <2 x float> %664, %666
  %668 = extractelement <2 x float> %667, i64 0
  %669 = fcmp uno float %668, 0.000000e+00
  br i1 %669, label %670, label %675, !prof !13

670:                                              ; preds = %651
  %671 = extractelement <2 x float> %667, i64 1
  %672 = fcmp uno float %671, 0.000000e+00
  br i1 %672, label %673, label %675, !prof !13

673:                                              ; preds = %670
  %674 = tail call <2 x float> @__mulsc3(float noundef %659, float noundef %660, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %675

675:                                              ; preds = %673, %670, %651
  %676 = phi <2 x float> [ %667, %651 ], [ %667, %670 ], [ %674, %673 ]
  %677 = load <2 x float>, ptr %19, align 4
  %678 = fsub <2 x float> %677, %676
  store <2 x float> %678, ptr %41, align 4
  %679 = fadd <2 x float> %676, %677
  store <2 x float> %679, ptr %19, align 4
  %680 = load <2 x float>, ptr %44, align 4
  %681 = fpext <2 x float> %680 to <2 x double>
  %682 = fmul <2 x double> %681, <double 0xBFED906BDDF49264, double 0x3FED906BDDF49264>
  %683 = fmul <2 x double> %681, <double 0xBFD87DE283EE36AA, double 0x3FD87DE283EE36AA>
  %684 = shufflevector <2 x double> %683, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %685 = fadd <2 x double> %682, %684
  %686 = fsub <2 x double> %682, %684
  %687 = shufflevector <2 x double> %685, <2 x double> %686, <2 x i32> <i32 1, i32 2>
  %688 = extractelement <2 x double> %685, i64 1
  %689 = fcmp uno double %688, 0.000000e+00
  br i1 %689, label %690, label %701, !prof !13

690:                                              ; preds = %675
  %691 = extractelement <2 x double> %686, i64 0
  %692 = fcmp uno double %691, 0.000000e+00
  br i1 %692, label %693, label %701, !prof !13

693:                                              ; preds = %690
  %694 = extractelement <2 x double> %681, i64 0
  %695 = extractelement <2 x double> %681, i64 1
  %696 = tail call { double, double } @__muldc3(double noundef %694, double noundef %695, double noundef 0xBFD87DE283EE36AA, double noundef 0xBFED906BDDF49264) #1
  %697 = extractvalue { double, double } %696, 0
  %698 = extractvalue { double, double } %696, 1
  %699 = insertelement <2 x double> poison, double %697, i64 0
  %700 = insertelement <2 x double> %699, double %698, i64 1
  br label %701

701:                                              ; preds = %693, %690, %675
  %702 = phi <2 x double> [ %687, %675 ], [ %687, %690 ], [ %700, %693 ]
  %703 = fptrunc <2 x double> %702 to <2 x float>
  %704 = load <2 x float>, ptr %21, align 4
  %705 = fsub <2 x float> %704, %703
  store <2 x float> %705, ptr %44, align 4
  %706 = fadd <2 x float> %704, %703
  store <2 x float> %706, ptr %21, align 4
  %707 = load <2 x float>, ptr %47, align 4
  %708 = fpext <2 x float> %707 to <2 x double>
  %709 = fmul <2 x double> %708, <double 0xBFE6A09E607DC426, double 0xBFE6A09E607DC426>
  %710 = extractelement <2 x double> %709, i64 0
  %711 = extractelement <2 x double> %709, i64 1
  %712 = fsub double %710, %711
  %713 = fadd double %710, %711
  %714 = fcmp uno double %712, 0.000000e+00
  br i1 %714, label %715, label %723, !prof !13

715:                                              ; preds = %701
  %716 = fcmp uno double %713, 0.000000e+00
  br i1 %716, label %717, label %723, !prof !13

717:                                              ; preds = %715
  %718 = extractelement <2 x double> %708, i64 0
  %719 = extractelement <2 x double> %708, i64 1
  %720 = tail call { double, double } @__muldc3(double noundef %718, double noundef %719, double noundef 0xBFE6A09E607DC426, double noundef 0xBFE6A09E607DC426) #1
  %721 = extractvalue { double, double } %720, 0
  %722 = extractvalue { double, double } %720, 1
  br label %723

723:                                              ; preds = %717, %715, %701
  %724 = phi double [ %712, %701 ], [ %712, %715 ], [ %721, %717 ]
  %725 = phi double [ %713, %701 ], [ %713, %715 ], [ %722, %717 ]
  %726 = fptrunc double %724 to float
  %727 = fptrunc double %725 to float
  %728 = load float, ptr %24, align 4
  %729 = load float, ptr %25, align 4
  %730 = fsub float %728, %726
  %731 = fsub float %729, %727
  store float %730, ptr %47, align 4
  store float %731, ptr %48, align 4
  %732 = fadd float %728, %726
  %733 = fadd float %729, %727
  store float %732, ptr %24, align 4
  store float %733, ptr %25, align 4
  %734 = load <2 x float>, ptr %50, align 4
  %735 = fpext <2 x float> %734 to <2 x double>
  %736 = fmul <2 x double> %735, <double 0xBFD87DE2E49139A4, double 0x3FD87DE2E49139A4>
  %737 = fmul <2 x double> %735, <double 0xBFED906BBDBE3C10, double 0x3FED906BBDBE3C10>
  %738 = shufflevector <2 x double> %737, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %739 = fadd <2 x double> %736, %738
  %740 = fsub <2 x double> %736, %738
  %741 = shufflevector <2 x double> %739, <2 x double> %740, <2 x i32> <i32 1, i32 2>
  %742 = extractelement <2 x double> %739, i64 1
  %743 = fcmp uno double %742, 0.000000e+00
  br i1 %743, label %744, label %933, !prof !13

744:                                              ; preds = %723
  %745 = extractelement <2 x double> %740, i64 0
  %746 = fcmp uno double %745, 0.000000e+00
  br i1 %746, label %747, label %933, !prof !13

747:                                              ; preds = %744
  %748 = extractelement <2 x double> %735, i64 0
  %749 = extractelement <2 x double> %735, i64 1
  %750 = tail call { double, double } @__muldc3(double noundef %748, double noundef %749, double noundef 0xBFED906BBDBE3C10, double noundef 0xBFD87DE2E49139A4) #1
  %751 = extractvalue { double, double } %750, 0
  %752 = extractvalue { double, double } %750, 1
  %753 = insertelement <2 x double> poison, double %751, i64 0
  %754 = insertelement <2 x double> %753, double %752, i64 1
  br label %933

755:                                              ; preds = %562
  %756 = fsub <2 x double> %579, %578
  %757 = fadd <2 x double> %579, %578
  %758 = shufflevector <2 x double> %756, <2 x double> %757, <2 x i32> <i32 0, i32 3>
  %759 = extractelement <2 x double> %756, i64 0
  %760 = fcmp uno double %759, 0.000000e+00
  br i1 %760, label %761, label %772, !prof !13

761:                                              ; preds = %755
  %762 = extractelement <2 x double> %757, i64 1
  %763 = fcmp uno double %762, 0.000000e+00
  br i1 %763, label %764, label %772, !prof !13

764:                                              ; preds = %761
  %765 = extractelement <2 x double> %576, i64 0
  %766 = extractelement <2 x double> %576, i64 1
  %767 = tail call { double, double } @__muldc3(double noundef %765, double noundef %766, double noundef 0x3FED906BBDBE3C10, double noundef 0x3FD87DE2C45AE350) #1
  %768 = extractvalue { double, double } %767, 0
  %769 = extractvalue { double, double } %767, 1
  %770 = insertelement <2 x double> poison, double %768, i64 0
  %771 = insertelement <2 x double> %770, double %769, i64 1
  br label %772

772:                                              ; preds = %764, %761, %755
  %773 = phi <2 x double> [ %758, %755 ], [ %758, %761 ], [ %771, %764 ]
  %774 = fptrunc <2 x double> %773 to <2 x float>
  %775 = load <2 x float>, ptr %10, align 4
  %776 = fsub <2 x float> %775, %774
  store <2 x float> %776, ptr %32, align 4
  %777 = fadd <2 x float> %775, %774
  store <2 x float> %777, ptr %10, align 4
  %778 = load <2 x float>, ptr %35, align 4
  %779 = fpext <2 x float> %778 to <2 x double>
  %780 = fmul <2 x double> %779, <double 0x3FE6A09E607DC426, double 0x3FE6A09E607DC426>
  %781 = extractelement <2 x double> %780, i64 0
  %782 = extractelement <2 x double> %780, i64 1
  %783 = fsub double %781, %782
  %784 = fadd double %781, %782
  %785 = fcmp uno double %783, 0.000000e+00
  br i1 %785, label %786, label %794, !prof !13

786:                                              ; preds = %772
  %787 = fcmp uno double %784, 0.000000e+00
  br i1 %787, label %788, label %794, !prof !13

788:                                              ; preds = %786
  %789 = extractelement <2 x double> %779, i64 0
  %790 = extractelement <2 x double> %779, i64 1
  %791 = tail call { double, double } @__muldc3(double noundef %789, double noundef %790, double noundef 0x3FE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %792 = extractvalue { double, double } %791, 0
  %793 = extractvalue { double, double } %791, 1
  br label %794

794:                                              ; preds = %788, %786, %772
  %795 = phi double [ %783, %772 ], [ %783, %786 ], [ %792, %788 ]
  %796 = phi double [ %784, %772 ], [ %784, %786 ], [ %793, %788 ]
  %797 = fptrunc double %795 to float
  %798 = fptrunc double %796 to float
  %799 = load float, ptr %13, align 4
  %800 = load float, ptr %14, align 4
  %801 = fsub float %799, %797
  %802 = fsub float %800, %798
  store float %801, ptr %35, align 4
  store float %802, ptr %36, align 4
  %803 = fadd float %799, %797
  %804 = fadd float %800, %798
  store float %803, ptr %13, align 4
  store float %804, ptr %14, align 4
  %805 = load float, ptr %38, align 4
  %806 = load float, ptr %39, align 4
  %807 = fpext float %805 to double
  %808 = fpext float %806 to double
  %809 = insertelement <2 x double> poison, double %807, i64 0
  %810 = shufflevector <2 x double> %809, <2 x double> poison, <2 x i32> zeroinitializer
  %811 = fmul <2 x double> %810, <double 0x3FD87DE2A4248CFD, double 0x3FED906BBDBE3C10>
  %812 = insertelement <2 x double> poison, double %808, i64 0
  %813 = shufflevector <2 x double> %812, <2 x double> poison, <2 x i32> zeroinitializer
  %814 = fmul <2 x double> %813, <double 0x3FED906BBDBE3C10, double 0x3FD87DE2A4248CFD>
  %815 = fsub <2 x double> %811, %814
  %816 = fadd <2 x double> %811, %814
  %817 = shufflevector <2 x double> %815, <2 x double> %816, <2 x i32> <i32 0, i32 3>
  %818 = extractelement <2 x double> %815, i64 0
  %819 = fcmp uno double %818, 0.000000e+00
  br i1 %819, label %820, label %829, !prof !13

820:                                              ; preds = %794
  %821 = extractelement <2 x double> %816, i64 1
  %822 = fcmp uno double %821, 0.000000e+00
  br i1 %822, label %823, label %829, !prof !13

823:                                              ; preds = %820
  %824 = tail call { double, double } @__muldc3(double noundef %807, double noundef %808, double noundef 0x3FD87DE2A4248CFD, double noundef 0x3FED906BBDBE3C10) #1
  %825 = extractvalue { double, double } %824, 0
  %826 = extractvalue { double, double } %824, 1
  %827 = insertelement <2 x double> poison, double %825, i64 0
  %828 = insertelement <2 x double> %827, double %826, i64 1
  br label %829

829:                                              ; preds = %823, %820, %794
  %830 = phi <2 x double> [ %817, %794 ], [ %817, %820 ], [ %828, %823 ]
  %831 = fptrunc <2 x double> %830 to <2 x float>
  %832 = load <2 x float>, ptr %16, align 4
  %833 = fsub <2 x float> %832, %831
  store <2 x float> %833, ptr %38, align 4
  %834 = fadd <2 x float> %832, %831
  store <2 x float> %834, ptr %16, align 4
  %835 = load <2 x float>, ptr %41, align 4
  %836 = fmul <2 x float> %835, zeroinitializer
  %837 = shufflevector <2 x float> %835, <2 x float> poison, <2 x i32> <i32 1, i32 0>
  %838 = fsub <2 x float> %836, %837
  %839 = fadd <2 x float> %836, %837
  %840 = shufflevector <2 x float> %838, <2 x float> %839, <2 x i32> <i32 0, i32 3>
  %841 = extractelement <2 x float> %838, i64 0
  %842 = fcmp uno float %841, 0.000000e+00
  br i1 %842, label %843, label %850, !prof !13

843:                                              ; preds = %829
  %844 = extractelement <2 x float> %839, i64 1
  %845 = fcmp uno float %844, 0.000000e+00
  br i1 %845, label %846, label %850, !prof !13

846:                                              ; preds = %843
  %847 = extractelement <2 x float> %835, i64 0
  %848 = extractelement <2 x float> %835, i64 1
  %849 = tail call <2 x float> @__mulsc3(float noundef %847, float noundef %848, float noundef 0.000000e+00, float noundef 1.000000e+00) #1
  br label %850

850:                                              ; preds = %846, %843, %829
  %851 = phi <2 x float> [ %840, %829 ], [ %840, %843 ], [ %849, %846 ]
  %852 = load <2 x float>, ptr %19, align 4
  %853 = fsub <2 x float> %852, %851
  store <2 x float> %853, ptr %41, align 4
  %854 = fadd <2 x float> %851, %852
  store <2 x float> %854, ptr %19, align 4
  %855 = load float, ptr %44, align 4
  %856 = load float, ptr %45, align 4
  %857 = fpext float %855 to double
  %858 = fpext float %856 to double
  %859 = insertelement <2 x double> poison, double %857, i64 0
  %860 = shufflevector <2 x double> %859, <2 x double> poison, <2 x i32> zeroinitializer
  %861 = fmul <2 x double> %860, <double 0xBFD87DE283EE36AA, double 0x3FED906BDDF49264>
  %862 = insertelement <2 x double> poison, double %858, i64 0
  %863 = shufflevector <2 x double> %862, <2 x double> poison, <2 x i32> zeroinitializer
  %864 = fmul <2 x double> %863, <double 0x3FED906BDDF49264, double 0x3FD87DE283EE36AA>
  %865 = fsub <2 x double> %861, %864
  %866 = extractelement <2 x double> %865, i64 0
  %867 = fcmp uno double %866, 0.000000e+00
  br i1 %867, label %868, label %877, !prof !13

868:                                              ; preds = %850
  %869 = extractelement <2 x double> %865, i64 1
  %870 = fcmp uno double %869, 0.000000e+00
  br i1 %870, label %871, label %877, !prof !13

871:                                              ; preds = %868
  %872 = tail call { double, double } @__muldc3(double noundef %857, double noundef %858, double noundef 0xBFD87DE283EE36AA, double noundef 0x3FED906BDDF49264) #1
  %873 = extractvalue { double, double } %872, 0
  %874 = extractvalue { double, double } %872, 1
  %875 = insertelement <2 x double> poison, double %873, i64 0
  %876 = insertelement <2 x double> %875, double %874, i64 1
  br label %877

877:                                              ; preds = %871, %868, %850
  %878 = phi <2 x double> [ %865, %850 ], [ %865, %868 ], [ %876, %871 ]
  %879 = fptrunc <2 x double> %878 to <2 x float>
  %880 = load <2 x float>, ptr %21, align 4
  %881 = fsub <2 x float> %880, %879
  store <2 x float> %881, ptr %44, align 4
  %882 = fadd <2 x float> %880, %879
  store <2 x float> %882, ptr %21, align 4
  %883 = load float, ptr %47, align 4
  %884 = load float, ptr %48, align 4
  %885 = fpext float %883 to double
  %886 = fpext float %884 to double
  %887 = fmul double %886, 0x3FE6A09E607DC426
  %888 = insertelement <2 x double> poison, double %885, i64 0
  %889 = shufflevector <2 x double> %888, <2 x double> poison, <2 x i32> zeroinitializer
  %890 = fmul <2 x double> %889, <double 0xBFE6A09E607DC426, double 0x3FE6A09E607DC426>
  %891 = insertelement <2 x double> poison, double %887, i64 0
  %892 = shufflevector <2 x double> %891, <2 x double> poison, <2 x i32> zeroinitializer
  %893 = fsub <2 x double> %890, %892
  %894 = extractelement <2 x double> %893, i64 0
  %895 = fcmp uno double %894, 0.000000e+00
  br i1 %895, label %896, label %905, !prof !13

896:                                              ; preds = %877
  %897 = extractelement <2 x double> %893, i64 1
  %898 = fcmp uno double %897, 0.000000e+00
  br i1 %898, label %899, label %905, !prof !13

899:                                              ; preds = %896
  %900 = tail call { double, double } @__muldc3(double noundef %885, double noundef %886, double noundef 0xBFE6A09E607DC426, double noundef 0x3FE6A09E607DC426) #1
  %901 = extractvalue { double, double } %900, 0
  %902 = extractvalue { double, double } %900, 1
  %903 = insertelement <2 x double> poison, double %901, i64 0
  %904 = insertelement <2 x double> %903, double %902, i64 1
  br label %905

905:                                              ; preds = %899, %896, %877
  %906 = phi <2 x double> [ %893, %877 ], [ %893, %896 ], [ %904, %899 ]
  %907 = fptrunc <2 x double> %906 to <2 x float>
  %908 = load <2 x float>, ptr %24, align 4
  %909 = fsub <2 x float> %908, %907
  store <2 x float> %909, ptr %47, align 4
  %910 = fadd <2 x float> %908, %907
  store <2 x float> %910, ptr %24, align 4
  %911 = load float, ptr %50, align 4
  %912 = load float, ptr %51, align 4
  %913 = fpext float %911 to double
  %914 = fpext float %912 to double
  %915 = insertelement <2 x double> poison, double %913, i64 0
  %916 = shufflevector <2 x double> %915, <2 x double> poison, <2 x i32> zeroinitializer
  %917 = fmul <2 x double> %916, <double 0xBFED906BBDBE3C10, double 0x3FD87DE2E49139A4>
  %918 = insertelement <2 x double> poison, double %914, i64 0
  %919 = shufflevector <2 x double> %918, <2 x double> poison, <2 x i32> zeroinitializer
  %920 = fmul <2 x double> %919, <double 0x3FD87DE2E49139A4, double 0x3FED906BBDBE3C10>
  %921 = fsub <2 x double> %917, %920
  %922 = extractelement <2 x double> %921, i64 0
  %923 = fcmp uno double %922, 0.000000e+00
  br i1 %923, label %924, label %933, !prof !13

924:                                              ; preds = %905
  %925 = extractelement <2 x double> %921, i64 1
  %926 = fcmp uno double %925, 0.000000e+00
  br i1 %926, label %927, label %933, !prof !13

927:                                              ; preds = %924
  %928 = tail call { double, double } @__muldc3(double noundef %913, double noundef %914, double noundef 0xBFED906BBDBE3C10, double noundef 0x3FD87DE2E49139A4) #1
  %929 = extractvalue { double, double } %928, 0
  %930 = extractvalue { double, double } %928, 1
  %931 = insertelement <2 x double> poison, double %929, i64 0
  %932 = insertelement <2 x double> %931, double %930, i64 1
  br label %933

933:                                              ; preds = %905, %924, %927, %723, %744, %747
  %934 = phi <2 x double> [ %741, %723 ], [ %741, %744 ], [ %754, %747 ], [ %921, %905 ], [ %921, %924 ], [ %932, %927 ]
  %935 = fptrunc <2 x double> %934 to <2 x float>
  %936 = load <2 x float>, ptr %27, align 4
  %937 = fsub <2 x float> %936, %935
  store <2 x float> %937, ptr %50, align 4
  %938 = fadd <2 x float> %936, %935
  store <2 x float> %938, ptr %27, align 4
  ret i32 0
}

declare <2 x float> @__mulsc3(float, float, float, float) local_unnamed_addr

declare { double, double } @__muldc3(double, double, double, double) local_unnamed_addr

attributes #0 = { nounwind uwtable "min-legal-vector-width"="64" "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 = { 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, !10, i64 8}
!6 = !{!"fftplan_s", !7, i64 0, !10, i64 8, !10, i64 16, !7, i64 24, !7, i64 28, !7, i64 32, !7, i64 36, !10, i64 40, !10, i64 48, !10, i64 56, !8, i64 64}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!6, !10, i64 16}
!12 = !{!6, !7, i64 24}
!13 = !{!"branch_weights", i32 1, i32 1048575}


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