; LLVM IR from OpenMathLib/OpenBLAS :: lapack-netlib/SRC (zlargv)

; 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.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zlargv_(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4, ptr noundef %5, ptr noundef %6) #0 {
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca double, align 8
  %20 = alloca double, align 8
  %21 = alloca double, align 8
  %22 = alloca double, align 8
  %23 = alloca double, align 8
  %24 = alloca double, align 8
  %25 = alloca double, align 8
  %26 = alloca double, align 8
  %27 = alloca %struct.doublecomplex, align 8
  %28 = alloca %struct.doublecomplex, align 8
  %29 = alloca %struct.doublecomplex, align 8
  %30 = alloca double, align 8
  %31 = alloca %struct.doublecomplex, align 8
  %32 = alloca %struct.doublecomplex, align 8
  %33 = alloca i32, align 4
  %34 = alloca i32, align 4
  %35 = alloca %struct.doublecomplex, align 8
  %36 = alloca double, align 8
  %37 = alloca i32, align 4
  %38 = alloca double, align 8
  %39 = alloca double, align 8
  %40 = alloca double, align 8
  %41 = alloca double, align 8
  %42 = alloca i32, align 4
  %43 = alloca double, align 8
  %44 = alloca %struct.doublecomplex, align 8
  %45 = alloca double, align 8
  %46 = alloca double, align 8
  %47 = alloca %struct.doublecomplex, align 8
  %48 = alloca %struct.doublecomplex, align 8
  %49 = alloca i32, align 4
  %50 = alloca i32, align 4
  %51 = alloca %struct.doublecomplex, align 8
  %52 = alloca double, align 8
  %53 = alloca double, align 8
  %54 = alloca double, align 8
  %55 = alloca double, align 8
  store ptr %0, ptr %8, align 8, !tbaa !5
  store ptr %1, ptr %9, align 8, !tbaa !5
  store ptr %2, ptr %10, align 8, !tbaa !5
  store ptr %3, ptr %11, align 8, !tbaa !5
  store ptr %4, ptr %12, align 8, !tbaa !5
  store ptr %5, ptr %13, align 8, !tbaa !5
  store ptr %6, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %28) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %31) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %32) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %44) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %47) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %48) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.start.p0(i64 16, ptr %51) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %53) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %54) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #6
  %56 = load ptr, ptr %13, align 8, !tbaa !5
  %57 = getelementptr inbounds double, ptr %56, i32 -1
  store ptr %57, ptr %13, align 8, !tbaa !5
  %58 = load ptr, ptr %11, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.doublecomplex, ptr %58, i32 -1
  store ptr %59, ptr %11, align 8, !tbaa !5
  %60 = load ptr, ptr %9, align 8, !tbaa !5
  %61 = getelementptr inbounds %struct.doublecomplex, ptr %60, i32 -1
  store ptr %61, ptr %9, align 8, !tbaa !5
  %62 = call double @dlamch_(ptr noundef @.str)
  store double %62, ptr %52, align 8, !tbaa !9
  %63 = call double @dlamch_(ptr noundef @.str.1)
  store double %63, ptr %55, align 8, !tbaa !9
  %64 = call double @dlamch_(ptr noundef @.str.2)
  store double %64, ptr %17, align 8, !tbaa !9
  %65 = load double, ptr %52, align 8, !tbaa !9
  %66 = load double, ptr %55, align 8, !tbaa !9
  %67 = fdiv double %65, %66
  %68 = call double @log(double noundef %67) #6
  %69 = call double @dlamch_(ptr noundef @.str.2)
  %70 = call double @log(double noundef %69) #6
  %71 = fdiv double %68, %70
  %72 = fdiv double %71, 2.000000e+00
  %73 = fptosi double %72 to i32
  store i32 %73, ptr %15, align 4, !tbaa !11
  %74 = load double, ptr %17, align 8, !tbaa !9
  %75 = load i32, ptr %15, align 4, !tbaa !11
  %76 = call double @dpow_ui(double noundef %74, i32 noundef %75)
  store double %76, ptr %40, align 8, !tbaa !9
  %77 = load double, ptr %40, align 8, !tbaa !9
  %78 = fdiv double 1.000000e+00, %77
  store double %78, ptr %41, align 8, !tbaa !9
  store i32 1, ptr %49, align 4, !tbaa !11
  store i32 1, ptr %50, align 4, !tbaa !11
  store i32 1, ptr %42, align 4, !tbaa !11
  %79 = load ptr, ptr %8, align 8, !tbaa !5
  %80 = load i32, ptr %79, align 4, !tbaa !11
  store i32 %80, ptr %15, align 4, !tbaa !11
  store i32 1, ptr %33, align 4, !tbaa !11
  br label %81

81:                                               ; preds = %784, %7
  %82 = load i32, ptr %33, align 4, !tbaa !11
  %83 = load i32, ptr %15, align 4, !tbaa !11
  %84 = icmp sle i32 %82, %83
  br i1 %84, label %85, label %787

85:                                               ; preds = %81
  %86 = load i32, ptr %49, align 4, !tbaa !11
  store i32 %86, ptr %16, align 4, !tbaa !11
  %87 = load ptr, ptr %9, align 8, !tbaa !5
  %88 = load i32, ptr %16, align 4, !tbaa !11
  %89 = sext i32 %88 to i64
  %90 = getelementptr inbounds %struct.doublecomplex, ptr %87, i64 %89
  %91 = getelementptr inbounds %struct.doublecomplex, ptr %90, i32 0, i32 0
  %92 = load double, ptr %91, align 8, !tbaa !13
  %93 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  store double %92, ptr %93, align 8, !tbaa !13
  %94 = load ptr, ptr %9, align 8, !tbaa !5
  %95 = load i32, ptr %16, align 4, !tbaa !11
  %96 = sext i32 %95 to i64
  %97 = getelementptr inbounds %struct.doublecomplex, ptr %94, i64 %96
  %98 = getelementptr inbounds %struct.doublecomplex, ptr %97, i32 0, i32 1
  %99 = load double, ptr %98, align 8, !tbaa !15
  %100 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  store double %99, ptr %100, align 8, !tbaa !15
  %101 = load i32, ptr %50, align 4, !tbaa !11
  store i32 %101, ptr %16, align 4, !tbaa !11
  %102 = load ptr, ptr %11, align 8, !tbaa !5
  %103 = load i32, ptr %16, align 4, !tbaa !11
  %104 = sext i32 %103 to i64
  %105 = getelementptr inbounds %struct.doublecomplex, ptr %102, i64 %104
  %106 = getelementptr inbounds %struct.doublecomplex, ptr %105, i32 0, i32 0
  %107 = load double, ptr %106, align 8, !tbaa !13
  %108 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  store double %107, ptr %108, align 8, !tbaa !13
  %109 = load ptr, ptr %11, align 8, !tbaa !5
  %110 = load i32, ptr %16, align 4, !tbaa !11
  %111 = sext i32 %110 to i64
  %112 = getelementptr inbounds %struct.doublecomplex, ptr %109, i64 %111
  %113 = getelementptr inbounds %struct.doublecomplex, ptr %112, i32 0, i32 1
  %114 = load double, ptr %113, align 8, !tbaa !15
  %115 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  store double %114, ptr %115, align 8, !tbaa !15
  %116 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %117 = load double, ptr %116, align 8, !tbaa !13
  store double %117, ptr %17, align 8, !tbaa !9
  %118 = load double, ptr %17, align 8, !tbaa !9
  %119 = fcmp oge double %118, 0.000000e+00
  br i1 %119, label %120, label %122

120:                                              ; preds = %85
  %121 = load double, ptr %17, align 8, !tbaa !9
  br label %125

122:                                              ; preds = %85
  %123 = load double, ptr %17, align 8, !tbaa !9
  %124 = fneg double %123
  br label %125

125:                                              ; preds = %122, %120
  %126 = phi double [ %121, %120 ], [ %124, %122 ]
  store double %126, ptr %23, align 8, !tbaa !9
  %127 = call { double, double } @Cd(ptr noundef %31)
  %128 = extractvalue { double, double } %127, 0
  %129 = extractvalue { double, double } %127, 1
  store double %129, ptr %18, align 8, !tbaa !9
  %130 = load double, ptr %18, align 8, !tbaa !9
  %131 = fcmp oge double %130, 0.000000e+00
  br i1 %131, label %132, label %134

132:                                              ; preds = %125
  %133 = load double, ptr %18, align 8, !tbaa !9
  br label %137

134:                                              ; preds = %125
  %135 = load double, ptr %18, align 8, !tbaa !9
  %136 = fneg double %135
  br label %137

137:                                              ; preds = %134, %132
  %138 = phi double [ %133, %132 ], [ %136, %134 ]
  store double %138, ptr %24, align 8, !tbaa !9
  %139 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %140 = load double, ptr %139, align 8, !tbaa !13
  store double %140, ptr %19, align 8, !tbaa !9
  %141 = load double, ptr %19, align 8, !tbaa !9
  %142 = fcmp oge double %141, 0.000000e+00
  br i1 %142, label %143, label %145

143:                                              ; preds = %137
  %144 = load double, ptr %19, align 8, !tbaa !9
  br label %148

145:                                              ; preds = %137
  %146 = load double, ptr %19, align 8, !tbaa !9
  %147 = fneg double %146
  br label %148

148:                                              ; preds = %145, %143
  %149 = phi double [ %144, %143 ], [ %147, %145 ]
  store double %149, ptr %25, align 8, !tbaa !9
  %150 = call { double, double } @Cd(ptr noundef %32)
  %151 = extractvalue { double, double } %150, 0
  %152 = extractvalue { double, double } %150, 1
  store double %152, ptr %20, align 8, !tbaa !9
  %153 = load double, ptr %20, align 8, !tbaa !9
  %154 = fcmp oge double %153, 0.000000e+00
  br i1 %154, label %155, label %157

155:                                              ; preds = %148
  %156 = load double, ptr %20, align 8, !tbaa !9
  br label %160

157:                                              ; preds = %148
  %158 = load double, ptr %20, align 8, !tbaa !9
  %159 = fneg double %158
  br label %160

160:                                              ; preds = %157, %155
  %161 = phi double [ %156, %155 ], [ %159, %157 ]
  store double %161, ptr %26, align 8, !tbaa !9
  %162 = load double, ptr %23, align 8, !tbaa !9
  %163 = load double, ptr %24, align 8, !tbaa !9
  %164 = fcmp oge double %162, %163
  br i1 %164, label %165, label %167

165:                                              ; preds = %160
  %166 = load double, ptr %23, align 8, !tbaa !9
  br label %169

167:                                              ; preds = %160
  %168 = load double, ptr %24, align 8, !tbaa !9
  br label %169

169:                                              ; preds = %167, %165
  %170 = phi double [ %166, %165 ], [ %168, %167 ]
  store double %170, ptr %21, align 8, !tbaa !9
  %171 = load double, ptr %25, align 8, !tbaa !9
  %172 = load double, ptr %26, align 8, !tbaa !9
  %173 = fcmp oge double %171, %172
  br i1 %173, label %174, label %176

174:                                              ; preds = %169
  %175 = load double, ptr %25, align 8, !tbaa !9
  br label %178

176:                                              ; preds = %169
  %177 = load double, ptr %26, align 8, !tbaa !9
  br label %178

178:                                              ; preds = %176, %174
  %179 = phi double [ %175, %174 ], [ %177, %176 ]
  store double %179, ptr %22, align 8, !tbaa !9
  %180 = load double, ptr %21, align 8, !tbaa !9
  %181 = load double, ptr %22, align 8, !tbaa !9
  %182 = fcmp oge double %180, %181
  br i1 %182, label %183, label %185

183:                                              ; preds = %178
  %184 = load double, ptr %21, align 8, !tbaa !9
  br label %187

185:                                              ; preds = %178
  %186 = load double, ptr %22, align 8, !tbaa !9
  br label %187

187:                                              ; preds = %185, %183
  %188 = phi double [ %184, %183 ], [ %186, %185 ]
  store double %188, ptr %36, align 8, !tbaa !9
  %189 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %190 = load double, ptr %189, align 8, !tbaa !13
  %191 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  store double %190, ptr %191, align 8, !tbaa !13
  %192 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %193 = load double, ptr %192, align 8, !tbaa !15
  %194 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  store double %193, ptr %194, align 8, !tbaa !15
  %195 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %196 = load double, ptr %195, align 8, !tbaa !13
  %197 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  store double %196, ptr %197, align 8, !tbaa !13
  %198 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %199 = load double, ptr %198, align 8, !tbaa !15
  %200 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  store double %199, ptr %200, align 8, !tbaa !15
  store i32 0, ptr %37, align 4, !tbaa !11
  %201 = load double, ptr %36, align 8, !tbaa !9
  %202 = load double, ptr %41, align 8, !tbaa !9
  %203 = fcmp oge double %201, %202
  br i1 %203, label %204, label %251

204:                                              ; preds = %187
  br label %205

205:                                              ; preds = %249, %204
  %206 = load i32, ptr %37, align 4, !tbaa !11
  %207 = add nsw i32 %206, 1
  store i32 %207, ptr %37, align 4, !tbaa !11
  %208 = load double, ptr %40, align 8, !tbaa !9
  %209 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %210 = load double, ptr %209, align 8, !tbaa !13
  %211 = fmul double %208, %210
  %212 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %211, ptr %212, align 8, !tbaa !13
  %213 = load double, ptr %40, align 8, !tbaa !9
  %214 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %215 = load double, ptr %214, align 8, !tbaa !15
  %216 = fmul double %213, %215
  %217 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %216, ptr %217, align 8, !tbaa !15
  %218 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %219 = load double, ptr %218, align 8, !tbaa !13
  %220 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  store double %219, ptr %220, align 8, !tbaa !13
  %221 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %222 = load double, ptr %221, align 8, !tbaa !15
  %223 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  store double %222, ptr %223, align 8, !tbaa !15
  %224 = load double, ptr %40, align 8, !tbaa !9
  %225 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %226 = load double, ptr %225, align 8, !tbaa !13
  %227 = fmul double %224, %226
  %228 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %227, ptr %228, align 8, !tbaa !13
  %229 = load double, ptr %40, align 8, !tbaa !9
  %230 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  %231 = load double, ptr %230, align 8, !tbaa !15
  %232 = fmul double %229, %231
  %233 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %232, ptr %233, align 8, !tbaa !15
  %234 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %235 = load double, ptr %234, align 8, !tbaa !13
  %236 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  store double %235, ptr %236, align 8, !tbaa !13
  %237 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %238 = load double, ptr %237, align 8, !tbaa !15
  %239 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  store double %238, ptr %239, align 8, !tbaa !15
  %240 = load double, ptr %40, align 8, !tbaa !9
  %241 = load double, ptr %36, align 8, !tbaa !9
  %242 = fmul double %241, %240
  store double %242, ptr %36, align 8, !tbaa !9
  %243 = load double, ptr %36, align 8, !tbaa !9
  %244 = load double, ptr %41, align 8, !tbaa !9
  %245 = fcmp oge double %243, %244
  br i1 %245, label %246, label %250

246:                                              ; preds = %205
  %247 = load i32, ptr %37, align 4, !tbaa !11
  %248 = icmp slt i32 %247, 20
  br i1 %248, label %249, label %250

249:                                              ; preds = %246
  br label %205

250:                                              ; preds = %246, %205
  br label %317

251:                                              ; preds = %187
  %252 = load double, ptr %36, align 8, !tbaa !9
  %253 = load double, ptr %40, align 8, !tbaa !9
  %254 = fcmp ole double %252, %253
  br i1 %254, label %255, label %316

255:                                              ; preds = %251
  %256 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %257 = load double, ptr %256, align 8, !tbaa !13
  %258 = fcmp oeq double %257, 0.000000e+00
  br i1 %258, label %259, label %272

259:                                              ; preds = %255
  %260 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %261 = load double, ptr %260, align 8, !tbaa !15
  %262 = fcmp oeq double %261, 0.000000e+00
  br i1 %262, label %263, label %272

263:                                              ; preds = %259
  store double 1.000000e+00, ptr %45, align 8, !tbaa !9
  %264 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  store double 0.000000e+00, ptr %264, align 8, !tbaa !13
  %265 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  store double 0.000000e+00, ptr %265, align 8, !tbaa !15
  %266 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %267 = load double, ptr %266, align 8, !tbaa !13
  %268 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %267, ptr %268, align 8, !tbaa !13
  %269 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %270 = load double, ptr %269, align 8, !tbaa !15
  %271 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %270, ptr %271, align 8, !tbaa !15
  br label %736

272:                                              ; preds = %259, %255
  br label %273

273:                                              ; preds = %314, %272
  %274 = load i32, ptr %37, align 4, !tbaa !11
  %275 = add nsw i32 %274, -1
  store i32 %275, ptr %37, align 4, !tbaa !11
  %276 = load double, ptr %41, align 8, !tbaa !9
  %277 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %278 = load double, ptr %277, align 8, !tbaa !13
  %279 = fmul double %276, %278
  %280 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %279, ptr %280, align 8, !tbaa !13
  %281 = load double, ptr %41, align 8, !tbaa !9
  %282 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  %283 = load double, ptr %282, align 8, !tbaa !15
  %284 = fmul double %281, %283
  %285 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %284, ptr %285, align 8, !tbaa !15
  %286 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %287 = load double, ptr %286, align 8, !tbaa !13
  %288 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  store double %287, ptr %288, align 8, !tbaa !13
  %289 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %290 = load double, ptr %289, align 8, !tbaa !15
  %291 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 1
  store double %290, ptr %291, align 8, !tbaa !15
  %292 = load double, ptr %41, align 8, !tbaa !9
  %293 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %294 = load double, ptr %293, align 8, !tbaa !13
  %295 = fmul double %292, %294
  %296 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %295, ptr %296, align 8, !tbaa !13
  %297 = load double, ptr %41, align 8, !tbaa !9
  %298 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  %299 = load double, ptr %298, align 8, !tbaa !15
  %300 = fmul double %297, %299
  %301 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %300, ptr %301, align 8, !tbaa !15
  %302 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %303 = load double, ptr %302, align 8, !tbaa !13
  %304 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  store double %303, ptr %304, align 8, !tbaa !13
  %305 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %306 = load double, ptr %305, align 8, !tbaa !15
  %307 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 1
  store double %306, ptr %307, align 8, !tbaa !15
  %308 = load double, ptr %41, align 8, !tbaa !9
  %309 = load double, ptr %36, align 8, !tbaa !9
  %310 = fmul double %309, %308
  store double %310, ptr %36, align 8, !tbaa !9
  %311 = load double, ptr %36, align 8, !tbaa !9
  %312 = load double, ptr %40, align 8, !tbaa !9
  %313 = fcmp ole double %311, %312
  br i1 %313, label %314, label %315

314:                                              ; preds = %273
  br label %273

315:                                              ; preds = %273
  br label %316

316:                                              ; preds = %315, %251
  br label %317

317:                                              ; preds = %316, %250
  %318 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %319 = load double, ptr %318, align 8, !tbaa !13
  store double %319, ptr %17, align 8, !tbaa !9
  %320 = call { double, double } @Cd(ptr noundef %47)
  %321 = extractvalue { double, double } %320, 0
  %322 = extractvalue { double, double } %320, 1
  store double %322, ptr %18, align 8, !tbaa !9
  %323 = load double, ptr %17, align 8, !tbaa !9
  %324 = load double, ptr %17, align 8, !tbaa !9
  %325 = load double, ptr %18, align 8, !tbaa !9
  %326 = load double, ptr %18, align 8, !tbaa !9
  %327 = fmul double %325, %326
  %328 = call double @llvm.fmuladd.f64(double %323, double %324, double %327)
  store double %328, ptr %38, align 8, !tbaa !9
  %329 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %330 = load double, ptr %329, align 8, !tbaa !13
  store double %330, ptr %17, align 8, !tbaa !9
  %331 = call { double, double } @Cd(ptr noundef %48)
  %332 = extractvalue { double, double } %331, 0
  %333 = extractvalue { double, double } %331, 1
  store double %333, ptr %18, align 8, !tbaa !9
  %334 = load double, ptr %17, align 8, !tbaa !9
  %335 = load double, ptr %17, align 8, !tbaa !9
  %336 = load double, ptr %18, align 8, !tbaa !9
  %337 = load double, ptr %18, align 8, !tbaa !9
  %338 = fmul double %336, %337
  %339 = call double @llvm.fmuladd.f64(double %334, double %335, double %338)
  store double %339, ptr %39, align 8, !tbaa !9
  %340 = load double, ptr %38, align 8, !tbaa !9
  %341 = load double, ptr %39, align 8, !tbaa !9
  %342 = fcmp oge double %341, 1.000000e+00
  br i1 %342, label %343, label %345

343:                                              ; preds = %317
  %344 = load double, ptr %39, align 8, !tbaa !9
  br label %346

345:                                              ; preds = %317
  br label %346

346:                                              ; preds = %345, %343
  %347 = phi double [ %344, %343 ], [ 1.000000e+00, %345 ]
  %348 = load double, ptr %52, align 8, !tbaa !9
  %349 = fmul double %347, %348
  %350 = fcmp ole double %340, %349
  br i1 %350, label %351, label %588

351:                                              ; preds = %346
  %352 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %353 = load double, ptr %352, align 8, !tbaa !13
  %354 = fcmp oeq double %353, 0.000000e+00
  br i1 %354, label %355, label %395

355:                                              ; preds = %351
  %356 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %357 = load double, ptr %356, align 8, !tbaa !15
  %358 = fcmp oeq double %357, 0.000000e+00
  br i1 %358, label %359, label %395

359:                                              ; preds = %355
  store double 0.000000e+00, ptr %45, align 8, !tbaa !9
  %360 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %361 = load double, ptr %360, align 8, !tbaa !13
  store double %361, ptr %18, align 8, !tbaa !9
  %362 = call { double, double } @Cd(ptr noundef %32)
  %363 = extractvalue { double, double } %362, 0
  %364 = extractvalue { double, double } %362, 1
  store double %364, ptr %19, align 8, !tbaa !9
  %365 = call double @dlapy2_(ptr noundef %18, ptr noundef %19)
  store double %365, ptr %17, align 8, !tbaa !9
  %366 = load double, ptr %17, align 8, !tbaa !9
  %367 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %366, ptr %367, align 8, !tbaa !13
  %368 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double 0.000000e+00, ptr %368, align 8, !tbaa !15
  %369 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %370 = load double, ptr %369, align 8, !tbaa !13
  store double %370, ptr %17, align 8, !tbaa !9
  %371 = call { double, double } @Cd(ptr noundef %48)
  %372 = extractvalue { double, double } %371, 0
  %373 = extractvalue { double, double } %371, 1
  store double %373, ptr %18, align 8, !tbaa !9
  %374 = call double @dlapy2_(ptr noundef %17, ptr noundef %18)
  store double %374, ptr %30, align 8, !tbaa !9
  %375 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %376 = load double, ptr %375, align 8, !tbaa !13
  %377 = load double, ptr %30, align 8, !tbaa !9
  %378 = fdiv double %376, %377
  store double %378, ptr %17, align 8, !tbaa !9
  %379 = call { double, double } @Cd(ptr noundef %48)
  %380 = extractvalue { double, double } %379, 0
  %381 = extractvalue { double, double } %379, 1
  %382 = fneg double %381
  %383 = load double, ptr %30, align 8, !tbaa !9
  %384 = fdiv double %382, %383
  store double %384, ptr %18, align 8, !tbaa !9
  %385 = load double, ptr %17, align 8, !tbaa !9
  %386 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %385, ptr %386, align 8, !tbaa !13
  %387 = load double, ptr %18, align 8, !tbaa !9
  %388 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %387, ptr %388, align 8, !tbaa !15
  %389 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %390 = load double, ptr %389, align 8, !tbaa !13
  %391 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  store double %390, ptr %391, align 8, !tbaa !13
  %392 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %393 = load double, ptr %392, align 8, !tbaa !15
  %394 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  store double %393, ptr %394, align 8, !tbaa !15
  br label %736

395:                                              ; preds = %355, %351
  %396 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %397 = load double, ptr %396, align 8, !tbaa !13
  store double %397, ptr %17, align 8, !tbaa !9
  %398 = call { double, double } @Cd(ptr noundef %47)
  %399 = extractvalue { double, double } %398, 0
  %400 = extractvalue { double, double } %398, 1
  store double %400, ptr %18, align 8, !tbaa !9
  %401 = call double @dlapy2_(ptr noundef %17, ptr noundef %18)
  store double %401, ptr %53, align 8, !tbaa !9
  %402 = load double, ptr %39, align 8, !tbaa !9
  %403 = call double @sqrt(double noundef %402) #6
  store double %403, ptr %54, align 8, !tbaa !9
  %404 = load double, ptr %53, align 8, !tbaa !9
  %405 = load double, ptr %54, align 8, !tbaa !9
  %406 = fdiv double %404, %405
  store double %406, ptr %45, align 8, !tbaa !9
  %407 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %408 = load double, ptr %407, align 8, !tbaa !13
  store double %408, ptr %17, align 8, !tbaa !9
  %409 = load double, ptr %17, align 8, !tbaa !9
  %410 = fcmp oge double %409, 0.000000e+00
  br i1 %410, label %411, label %413

411:                                              ; preds = %395
  %412 = load double, ptr %17, align 8, !tbaa !9
  br label %416

413:                                              ; preds = %395
  %414 = load double, ptr %17, align 8, !tbaa !9
  %415 = fneg double %414
  br label %416

416:                                              ; preds = %413, %411
  %417 = phi double [ %412, %411 ], [ %415, %413 ]
  store double %417, ptr %19, align 8, !tbaa !9
  %418 = call { double, double } @Cd(ptr noundef %31)
  %419 = extractvalue { double, double } %418, 0
  %420 = extractvalue { double, double } %418, 1
  store double %420, ptr %18, align 8, !tbaa !9
  %421 = load double, ptr %18, align 8, !tbaa !9
  %422 = fcmp oge double %421, 0.000000e+00
  br i1 %422, label %423, label %425

423:                                              ; preds = %416
  %424 = load double, ptr %18, align 8, !tbaa !9
  br label %428

425:                                              ; preds = %416
  %426 = load double, ptr %18, align 8, !tbaa !9
  %427 = fneg double %426
  br label %428

428:                                              ; preds = %425, %423
  %429 = phi double [ %424, %423 ], [ %427, %425 ]
  store double %429, ptr %20, align 8, !tbaa !9
  %430 = load double, ptr %19, align 8, !tbaa !9
  %431 = load double, ptr %20, align 8, !tbaa !9
  %432 = fcmp oge double %430, %431
  br i1 %432, label %433, label %435

433:                                              ; preds = %428
  %434 = load double, ptr %19, align 8, !tbaa !9
  br label %437

435:                                              ; preds = %428
  %436 = load double, ptr %20, align 8, !tbaa !9
  br label %437

437:                                              ; preds = %435, %433
  %438 = phi double [ %434, %433 ], [ %436, %435 ]
  %439 = fcmp ogt double %438, 1.000000e+00
  br i1 %439, label %440, label %466

440:                                              ; preds = %437
  %441 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %442 = load double, ptr %441, align 8, !tbaa !13
  store double %442, ptr %17, align 8, !tbaa !9
  %443 = call { double, double } @Cd(ptr noundef %31)
  %444 = extractvalue { double, double } %443, 0
  %445 = extractvalue { double, double } %443, 1
  store double %445, ptr %18, align 8, !tbaa !9
  %446 = call double @dlapy2_(ptr noundef %17, ptr noundef %18)
  store double %446, ptr %30, align 8, !tbaa !9
  %447 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %448 = load double, ptr %447, align 8, !tbaa !13
  %449 = load double, ptr %30, align 8, !tbaa !9
  %450 = fdiv double %448, %449
  store double %450, ptr %17, align 8, !tbaa !9
  %451 = call { double, double } @Cd(ptr noundef %31)
  %452 = extractvalue { double, double } %451, 0
  %453 = extractvalue { double, double } %451, 1
  %454 = load double, ptr %30, align 8, !tbaa !9
  %455 = fdiv double %453, %454
  store double %455, ptr %18, align 8, !tbaa !9
  %456 = load double, ptr %17, align 8, !tbaa !9
  %457 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %456, ptr %457, align 8, !tbaa !13
  %458 = load double, ptr %18, align 8, !tbaa !9
  %459 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %458, ptr %459, align 8, !tbaa !15
  %460 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %461 = load double, ptr %460, align 8, !tbaa !13
  %462 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %461, ptr %462, align 8, !tbaa !13
  %463 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %464 = load double, ptr %463, align 8, !tbaa !15
  %465 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %464, ptr %465, align 8, !tbaa !15
  br label %493

466:                                              ; preds = %437
  %467 = load double, ptr %41, align 8, !tbaa !9
  %468 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %469 = load double, ptr %468, align 8, !tbaa !13
  %470 = fmul double %467, %469
  store double %470, ptr %46, align 8, !tbaa !9
  %471 = load double, ptr %41, align 8, !tbaa !9
  %472 = call { double, double } @Cd(ptr noundef %31)
  %473 = extractvalue { double, double } %472, 0
  %474 = extractvalue { double, double } %472, 1
  %475 = fmul double %471, %474
  store double %475, ptr %43, align 8, !tbaa !9
  %476 = call double @dlapy2_(ptr noundef %46, ptr noundef %43)
  store double %476, ptr %30, align 8, !tbaa !9
  %477 = load double, ptr %46, align 8, !tbaa !9
  %478 = load double, ptr %30, align 8, !tbaa !9
  %479 = fdiv double %477, %478
  store double %479, ptr %17, align 8, !tbaa !9
  %480 = load double, ptr %43, align 8, !tbaa !9
  %481 = load double, ptr %30, align 8, !tbaa !9
  %482 = fdiv double %480, %481
  store double %482, ptr %18, align 8, !tbaa !9
  %483 = load double, ptr %17, align 8, !tbaa !9
  %484 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %483, ptr %484, align 8, !tbaa !13
  %485 = load double, ptr %18, align 8, !tbaa !9
  %486 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %485, ptr %486, align 8, !tbaa !15
  %487 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %488 = load double, ptr %487, align 8, !tbaa !13
  %489 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  store double %488, ptr %489, align 8, !tbaa !13
  %490 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %491 = load double, ptr %490, align 8, !tbaa !15
  %492 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  store double %491, ptr %492, align 8, !tbaa !15
  br label %493

493:                                              ; preds = %466, %440
  %494 = getelementptr inbounds %struct.doublecomplex, ptr %48, i32 0, i32 0
  %495 = load double, ptr %494, align 8, !tbaa !13
  %496 = load double, ptr %54, align 8, !tbaa !9
  %497 = fdiv double %495, %496
  store double %497, ptr %17, align 8, !tbaa !9
  %498 = call { double, double } @Cd(ptr noundef %48)
  %499 = extractvalue { double, double } %498, 0
  %500 = extractvalue { double, double } %498, 1
  %501 = fneg double %500
  %502 = load double, ptr %54, align 8, !tbaa !9
  %503 = fdiv double %501, %502
  store double %503, ptr %18, align 8, !tbaa !9
  %504 = load double, ptr %17, align 8, !tbaa !9
  %505 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %504, ptr %505, align 8, !tbaa !13
  %506 = load double, ptr %18, align 8, !tbaa !9
  %507 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %506, ptr %507, align 8, !tbaa !15
  %508 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %509 = load double, ptr %508, align 8, !tbaa !13
  %510 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %511 = load double, ptr %510, align 8, !tbaa !13
  %512 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %513 = load double, ptr %512, align 8, !tbaa !15
  %514 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %515 = load double, ptr %514, align 8, !tbaa !15
  %516 = fmul double %513, %515
  %517 = fneg double %516
  %518 = call double @llvm.fmuladd.f64(double %509, double %511, double %517)
  %519 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %518, ptr %519, align 8, !tbaa !13
  %520 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 0
  %521 = load double, ptr %520, align 8, !tbaa !13
  %522 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %523 = load double, ptr %522, align 8, !tbaa !15
  %524 = getelementptr inbounds %struct.doublecomplex, ptr %44, i32 0, i32 1
  %525 = load double, ptr %524, align 8, !tbaa !15
  %526 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %527 = load double, ptr %526, align 8, !tbaa !13
  %528 = fmul double %525, %527
  %529 = call double @llvm.fmuladd.f64(double %521, double %523, double %528)
  %530 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %529, ptr %530, align 8, !tbaa !15
  %531 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %532 = load double, ptr %531, align 8, !tbaa !13
  %533 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  store double %532, ptr %533, align 8, !tbaa !13
  %534 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %535 = load double, ptr %534, align 8, !tbaa !15
  %536 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  store double %535, ptr %536, align 8, !tbaa !15
  %537 = load double, ptr %45, align 8, !tbaa !9
  %538 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 0
  %539 = load double, ptr %538, align 8, !tbaa !13
  %540 = fmul double %537, %539
  %541 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  store double %540, ptr %541, align 8, !tbaa !13
  %542 = load double, ptr %45, align 8, !tbaa !9
  %543 = getelementptr inbounds %struct.doublecomplex, ptr %31, i32 0, i32 1
  %544 = load double, ptr %543, align 8, !tbaa !15
  %545 = fmul double %542, %544
  %546 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  store double %545, ptr %546, align 8, !tbaa !15
  %547 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  %548 = load double, ptr %547, align 8, !tbaa !13
  %549 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %550 = load double, ptr %549, align 8, !tbaa !13
  %551 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  %552 = load double, ptr %551, align 8, !tbaa !15
  %553 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %554 = load double, ptr %553, align 8, !tbaa !15
  %555 = fmul double %552, %554
  %556 = fneg double %555
  %557 = call double @llvm.fmuladd.f64(double %548, double %550, double %556)
  %558 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  store double %557, ptr %558, align 8, !tbaa !13
  %559 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  %560 = load double, ptr %559, align 8, !tbaa !13
  %561 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 1
  %562 = load double, ptr %561, align 8, !tbaa !15
  %563 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  %564 = load double, ptr %563, align 8, !tbaa !15
  %565 = getelementptr inbounds %struct.doublecomplex, ptr %32, i32 0, i32 0
  %566 = load double, ptr %565, align 8, !tbaa !13
  %567 = fmul double %564, %566
  %568 = call double @llvm.fmuladd.f64(double %560, double %562, double %567)
  %569 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  store double %568, ptr %569, align 8, !tbaa !15
  %570 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %571 = load double, ptr %570, align 8, !tbaa !13
  %572 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 0
  %573 = load double, ptr %572, align 8, !tbaa !13
  %574 = fadd double %571, %573
  %575 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %574, ptr %575, align 8, !tbaa !13
  %576 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %577 = load double, ptr %576, align 8, !tbaa !15
  %578 = getelementptr inbounds %struct.doublecomplex, ptr %29, i32 0, i32 1
  %579 = load double, ptr %578, align 8, !tbaa !15
  %580 = fadd double %577, %579
  %581 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %580, ptr %581, align 8, !tbaa !15
  %582 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %583 = load double, ptr %582, align 8, !tbaa !13
  %584 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %583, ptr %584, align 8, !tbaa !13
  %585 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %586 = load double, ptr %585, align 8, !tbaa !15
  %587 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %586, ptr %587, align 8, !tbaa !15
  br label %735

588:                                              ; preds = %346
  %589 = load double, ptr %39, align 8, !tbaa !9
  %590 = load double, ptr %38, align 8, !tbaa !9
  %591 = fdiv double %589, %590
  %592 = fadd double %591, 1.000000e+00
  %593 = call double @sqrt(double noundef %592) #6
  store double %593, ptr %53, align 8, !tbaa !9
  %594 = load double, ptr %53, align 8, !tbaa !9
  %595 = getelementptr inbounds %struct.doublecomplex, ptr %47, i32 0, i32 0
  %596 = load double, ptr %595, align 8, !tbaa !13
  %597 = fmul double %594, %596
  store double %597, ptr %17, align 8, !tbaa !9
  %598 = load double, ptr %53, align 8, !tbaa !9
  %599 = call { double, double } @Cd(ptr noundef %47)
  %600 = extractvalue { double, double } %599, 0
  %601 = extractvalue { double, double } %599, 1
  %602 = fmul double %598, %601
  store double %602, ptr %18, align 8, !tbaa !9
  %603 = load double, ptr %17, align 8, !tbaa !9
  %604 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %603, ptr %604, align 8, !tbaa !13
  %605 = load double, ptr %18, align 8, !tbaa !9
  %606 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %605, ptr %606, align 8, !tbaa !15
  %607 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %608 = load double, ptr %607, align 8, !tbaa !13
  %609 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %608, ptr %609, align 8, !tbaa !13
  %610 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %611 = load double, ptr %610, align 8, !tbaa !15
  %612 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %611, ptr %612, align 8, !tbaa !15
  %613 = load double, ptr %53, align 8, !tbaa !9
  %614 = fdiv double 1.000000e+00, %613
  store double %614, ptr %45, align 8, !tbaa !9
  %615 = load double, ptr %38, align 8, !tbaa !9
  %616 = load double, ptr %39, align 8, !tbaa !9
  %617 = fadd double %615, %616
  store double %617, ptr %30, align 8, !tbaa !9
  %618 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %619 = load double, ptr %618, align 8, !tbaa !13
  %620 = load double, ptr %30, align 8, !tbaa !9
  %621 = fdiv double %619, %620
  store double %621, ptr %17, align 8, !tbaa !9
  %622 = call { double, double } @Cd(ptr noundef %35)
  %623 = extractvalue { double, double } %622, 0
  %624 = extractvalue { double, double } %622, 1
  %625 = load double, ptr %30, align 8, !tbaa !9
  %626 = fdiv double %624, %625
  store double %626, ptr %18, align 8, !tbaa !9
  %627 = load double, ptr %17, align 8, !tbaa !9
  %628 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %627, ptr %628, align 8, !tbaa !13
  %629 = load double, ptr %18, align 8, !tbaa !9
  %630 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %629, ptr %630, align 8, !tbaa !15
  %631 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %632 = load double, ptr %631, align 8, !tbaa !13
  %633 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  store double %632, ptr %633, align 8, !tbaa !13
  %634 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %635 = load double, ptr %634, align 8, !tbaa !15
  %636 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  store double %635, ptr %636, align 8, !tbaa !15
  %637 = call { double, double } @Cd(ptr noundef %48)
  %638 = extractvalue { double, double } %637, 0
  %639 = extractvalue { double, double } %637, 1
  %640 = fneg double %639
  %641 = call ptr @_pCd(ptr noundef %28)
  %642 = getelementptr inbounds { double, double }, ptr %641, i32 0, i32 0
  %643 = getelementptr inbounds { double, double }, ptr %641, i32 0, i32 1
  store double %638, ptr %642, align 8
  store double %640, ptr %643, align 8
  %644 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  %645 = load double, ptr %644, align 8, !tbaa !13
  %646 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %647 = load double, ptr %646, align 8, !tbaa !13
  %648 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  %649 = load double, ptr %648, align 8, !tbaa !15
  %650 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %651 = load double, ptr %650, align 8, !tbaa !15
  %652 = fmul double %649, %651
  %653 = fneg double %652
  %654 = call double @llvm.fmuladd.f64(double %645, double %647, double %653)
  %655 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %654, ptr %655, align 8, !tbaa !13
  %656 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  %657 = load double, ptr %656, align 8, !tbaa !13
  %658 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 1
  %659 = load double, ptr %658, align 8, !tbaa !15
  %660 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  %661 = load double, ptr %660, align 8, !tbaa !15
  %662 = getelementptr inbounds %struct.doublecomplex, ptr %28, i32 0, i32 0
  %663 = load double, ptr %662, align 8, !tbaa !13
  %664 = fmul double %661, %663
  %665 = call double @llvm.fmuladd.f64(double %657, double %659, double %664)
  %666 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %665, ptr %666, align 8, !tbaa !15
  %667 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %668 = load double, ptr %667, align 8, !tbaa !13
  %669 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  store double %668, ptr %669, align 8, !tbaa !13
  %670 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %671 = load double, ptr %670, align 8, !tbaa !15
  %672 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  store double %671, ptr %672, align 8, !tbaa !15
  %673 = load i32, ptr %37, align 4, !tbaa !11
  %674 = icmp ne i32 %673, 0
  br i1 %674, label %675, label %734

675:                                              ; preds = %588
  %676 = load i32, ptr %37, align 4, !tbaa !11
  %677 = icmp sgt i32 %676, 0
  br i1 %677, label %678, label %705

678:                                              ; preds = %675
  %679 = load i32, ptr %37, align 4, !tbaa !11
  store i32 %679, ptr %16, align 4, !tbaa !11
  store i32 1, ptr %34, align 4, !tbaa !11
  br label %680

680:                                              ; preds = %701, %678
  %681 = load i32, ptr %34, align 4, !tbaa !11
  %682 = load i32, ptr %16, align 4, !tbaa !11
  %683 = icmp sle i32 %681, %682
  br i1 %683, label %684, label %704

684:                                              ; preds = %680
  %685 = load double, ptr %41, align 8, !tbaa !9
  %686 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %687 = load double, ptr %686, align 8, !tbaa !13
  %688 = fmul double %685, %687
  %689 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %688, ptr %689, align 8, !tbaa !13
  %690 = load double, ptr %41, align 8, !tbaa !9
  %691 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %692 = load double, ptr %691, align 8, !tbaa !15
  %693 = fmul double %690, %692
  %694 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %693, ptr %694, align 8, !tbaa !15
  %695 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %696 = load double, ptr %695, align 8, !tbaa !13
  %697 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %696, ptr %697, align 8, !tbaa !13
  %698 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %699 = load double, ptr %698, align 8, !tbaa !15
  %700 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %699, ptr %700, align 8, !tbaa !15
  br label %701

701:                                              ; preds = %684
  %702 = load i32, ptr %34, align 4, !tbaa !11
  %703 = add nsw i32 %702, 1
  store i32 %703, ptr %34, align 4, !tbaa !11
  br label %680, !llvm.loop !16

704:                                              ; preds = %680
  br label %733

705:                                              ; preds = %675
  %706 = load i32, ptr %37, align 4, !tbaa !11
  %707 = sub nsw i32 0, %706
  store i32 %707, ptr %16, align 4, !tbaa !11
  store i32 1, ptr %34, align 4, !tbaa !11
  br label %708

708:                                              ; preds = %729, %705
  %709 = load i32, ptr %34, align 4, !tbaa !11
  %710 = load i32, ptr %16, align 4, !tbaa !11
  %711 = icmp sle i32 %709, %710
  br i1 %711, label %712, label %732

712:                                              ; preds = %708
  %713 = load double, ptr %40, align 8, !tbaa !9
  %714 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %715 = load double, ptr %714, align 8, !tbaa !13
  %716 = fmul double %713, %715
  %717 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  store double %716, ptr %717, align 8, !tbaa !13
  %718 = load double, ptr %40, align 8, !tbaa !9
  %719 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %720 = load double, ptr %719, align 8, !tbaa !15
  %721 = fmul double %718, %720
  %722 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  store double %721, ptr %722, align 8, !tbaa !15
  %723 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 0
  %724 = load double, ptr %723, align 8, !tbaa !13
  %725 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  store double %724, ptr %725, align 8, !tbaa !13
  %726 = getelementptr inbounds %struct.doublecomplex, ptr %27, i32 0, i32 1
  %727 = load double, ptr %726, align 8, !tbaa !15
  %728 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  store double %727, ptr %728, align 8, !tbaa !15
  br label %729

729:                                              ; preds = %712
  %730 = load i32, ptr %34, align 4, !tbaa !11
  %731 = add nsw i32 %730, 1
  store i32 %731, ptr %34, align 4, !tbaa !11
  br label %708, !llvm.loop !18

732:                                              ; preds = %708
  br label %733

733:                                              ; preds = %732, %704
  br label %734

734:                                              ; preds = %733, %588
  br label %735

735:                                              ; preds = %734, %493
  br label %736

736:                                              ; preds = %735, %359, %263
  %737 = load double, ptr %45, align 8, !tbaa !9
  %738 = load ptr, ptr %13, align 8, !tbaa !5
  %739 = load i32, ptr %42, align 4, !tbaa !11
  %740 = sext i32 %739 to i64
  %741 = getelementptr inbounds double, ptr %738, i64 %740
  store double %737, ptr %741, align 8, !tbaa !9
  %742 = load i32, ptr %50, align 4, !tbaa !11
  store i32 %742, ptr %16, align 4, !tbaa !11
  %743 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 0
  %744 = load double, ptr %743, align 8, !tbaa !13
  %745 = load ptr, ptr %11, align 8, !tbaa !5
  %746 = load i32, ptr %16, align 4, !tbaa !11
  %747 = sext i32 %746 to i64
  %748 = getelementptr inbounds %struct.doublecomplex, ptr %745, i64 %747
  %749 = getelementptr inbounds %struct.doublecomplex, ptr %748, i32 0, i32 0
  store double %744, ptr %749, align 8, !tbaa !13
  %750 = getelementptr inbounds %struct.doublecomplex, ptr %51, i32 0, i32 1
  %751 = load double, ptr %750, align 8, !tbaa !15
  %752 = load ptr, ptr %11, align 8, !tbaa !5
  %753 = load i32, ptr %16, align 4, !tbaa !11
  %754 = sext i32 %753 to i64
  %755 = getelementptr inbounds %struct.doublecomplex, ptr %752, i64 %754
  %756 = getelementptr inbounds %struct.doublecomplex, ptr %755, i32 0, i32 1
  store double %751, ptr %756, align 8, !tbaa !15
  %757 = load i32, ptr %49, align 4, !tbaa !11
  store i32 %757, ptr %16, align 4, !tbaa !11
  %758 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 0
  %759 = load double, ptr %758, align 8, !tbaa !13
  %760 = load ptr, ptr %9, align 8, !tbaa !5
  %761 = load i32, ptr %16, align 4, !tbaa !11
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds %struct.doublecomplex, ptr %760, i64 %762
  %764 = getelementptr inbounds %struct.doublecomplex, ptr %763, i32 0, i32 0
  store double %759, ptr %764, align 8, !tbaa !13
  %765 = getelementptr inbounds %struct.doublecomplex, ptr %35, i32 0, i32 1
  %766 = load double, ptr %765, align 8, !tbaa !15
  %767 = load ptr, ptr %9, align 8, !tbaa !5
  %768 = load i32, ptr %16, align 4, !tbaa !11
  %769 = sext i32 %768 to i64
  %770 = getelementptr inbounds %struct.doublecomplex, ptr %767, i64 %769
  %771 = getelementptr inbounds %struct.doublecomplex, ptr %770, i32 0, i32 1
  store double %766, ptr %771, align 8, !tbaa !15
  %772 = load ptr, ptr %14, align 8, !tbaa !5
  %773 = load i32, ptr %772, align 4, !tbaa !11
  %774 = load i32, ptr %42, align 4, !tbaa !11
  %775 = add nsw i32 %774, %773
  store i32 %775, ptr %42, align 4, !tbaa !11
  %776 = load ptr, ptr %12, align 8, !tbaa !5
  %777 = load i32, ptr %776, align 4, !tbaa !11
  %778 = load i32, ptr %50, align 4, !tbaa !11
  %779 = add nsw i32 %778, %777
  store i32 %779, ptr %50, align 4, !tbaa !11
  %780 = load ptr, ptr %10, align 8, !tbaa !5
  %781 = load i32, ptr %780, align 4, !tbaa !11
  %782 = load i32, ptr %49, align 4, !tbaa !11
  %783 = add nsw i32 %782, %781
  store i32 %783, ptr %49, align 4, !tbaa !11
  br label %784

784:                                              ; preds = %736
  %785 = load i32, ptr %33, align 4, !tbaa !11
  %786 = add nsw i32 %785, 1
  store i32 %786, ptr %33, align 4, !tbaa !11
  br label %81, !llvm.loop !19

787:                                              ; preds = %81
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %54) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %53) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %51) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %47) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 16, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #6
  ret void
}

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

declare double @dlamch_(ptr noundef) #2

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

; Function Attrs: nounwind uwtable
declare hidden double @dpow_ui(double noundef, i32 noundef) #0

; Function Attrs: inlinehint nounwind uwtable
declare hidden { double, double } @Cd(ptr noundef) #4

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

declare double @dlapy2_(ptr noundef, ptr noundef) #2

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(ptr noundef) #4

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

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

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

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


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

%struct.doublecomplex = type { double, double }

@.str = external hidden unnamed_addr constant [2 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @zlargv_(ptr nocapture noundef readonly %0, ptr nocapture noundef %1, ptr nocapture noundef readonly %2, ptr nocapture noundef %3, ptr nocapture noundef readonly %4, ptr nocapture noundef writeonly %5, ptr nocapture noundef readonly %6) local_unnamed_addr #0 {
  %8 = alloca double, align 8
  %9 = alloca double, align 8
  %10 = alloca double, align 8
  %11 = alloca %struct.doublecomplex, align 16
  %12 = alloca %struct.doublecomplex, align 16
  %13 = alloca %struct.doublecomplex, align 16
  %14 = alloca %struct.doublecomplex, align 16
  %15 = alloca double, align 8
  %16 = alloca double, align 8
  %17 = alloca %struct.doublecomplex, align 16
  %18 = alloca %struct.doublecomplex, align 16
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %8) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %9) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %10) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %11) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %12) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %13) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %14) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %15) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %16) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %17) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %18) #7
  %19 = getelementptr inbounds i8, ptr %5, i64 -8
  %20 = getelementptr inbounds i8, ptr %3, i64 -16
  %21 = getelementptr inbounds i8, ptr %1, i64 -16
  %22 = tail call double @dlamch_(ptr noundef nonnull @.str) #7
  %23 = tail call double @dlamch_(ptr noundef nonnull @.str.1) #7
  %24 = tail call double @dlamch_(ptr noundef nonnull @.str.2) #7
  %25 = fdiv double %22, %23
  %26 = tail call double @log(double noundef %25) #7
  %27 = tail call double @dlamch_(ptr noundef nonnull @.str.2) #7
  %28 = tail call double @log(double noundef %27) #7
  %29 = fdiv double %26, %28
  %30 = fmul double %29, 5.000000e-01
  %31 = fptosi double %30 to i32
  %32 = tail call double @dpow_ui(double noundef %24, i32 noundef %31)
  %33 = fdiv double 1.000000e+00, %32
  %34 = load i32, ptr %0, align 4, !tbaa !5
  %.not217 = icmp slt i32 %34, 1
  br i1 %.not217, label %._crit_edge, label %.lr.ph222

.lr.ph222:                                        ; preds = %7
  %35 = getelementptr inbounds i8, ptr %12, i64 8
  %36 = getelementptr inbounds i8, ptr %14, i64 8
  %37 = insertelement <2 x double> poison, double %32, i64 0
  %38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> zeroinitializer
  %39 = insertelement <2 x double> poison, double %33, i64 0
  %40 = shufflevector <2 x double> %39, <2 x double> poison, <2 x i32> zeroinitializer
  %41 = insertelement <2 x double> poison, double %32, i64 0
  %42 = shufflevector <2 x double> %41, <2 x double> poison, <2 x i32> zeroinitializer
  %43 = insertelement <2 x double> poison, double %33, i64 0
  %44 = shufflevector <2 x double> %43, <2 x double> poison, <2 x i32> zeroinitializer
  br label %45

45:                                               ; preds = %.lr.ph222, %.loopexit185
  %.0221 = phi i32 [ 1, %.lr.ph222 ], [ %288, %.loopexit185 ]
  %.0167220 = phi i32 [ 1, %.lr.ph222 ], [ %290, %.loopexit185 ]
  %.0169219 = phi i32 [ 1, %.lr.ph222 ], [ %286, %.loopexit185 ]
  %.0175218 = phi i32 [ 1, %.lr.ph222 ], [ %291, %.loopexit185 ]
  %46 = sext i32 %.0167220 to i64
  %47 = getelementptr inbounds %struct.doublecomplex, ptr %21, i64 %46
  %48 = load <2 x double>, ptr %47, align 8, !tbaa !9
  store <2 x double> %48, ptr %12, align 16, !tbaa !9
  %49 = sext i32 %.0221 to i64
  %50 = getelementptr inbounds %struct.doublecomplex, ptr %20, i64 %49
  %51 = load <2 x double>, ptr %50, align 8, !tbaa !9
  store <2 x double> %51, ptr %13, align 16, !tbaa !9
  %52 = extractelement <2 x double> %48, i64 0
  store double %52, ptr %8, align 8, !tbaa !9
  %53 = call { double, double } @Cd(ptr noundef nonnull %12)
  %54 = extractvalue { double, double } %53, 1
  store double %54, ptr %9, align 8, !tbaa !9
  %55 = load double, ptr %13, align 16, !tbaa !11
  store double %55, ptr %10, align 8, !tbaa !9
  %56 = call { double, double } @Cd(ptr noundef nonnull %13)
  %57 = extractvalue { double, double } %56, 1
  %58 = insertelement <2 x double> %48, double %55, i64 1
  %59 = fcmp oge <2 x double> %58, zeroinitializer
  %60 = fneg <2 x double> %58
  %61 = select <2 x i1> %59, <2 x double> %58, <2 x double> %60
  %62 = insertelement <2 x double> poison, double %54, i64 0
  %63 = insertelement <2 x double> %62, double %57, i64 1
  %64 = fcmp oge <2 x double> %63, zeroinitializer
  %65 = fneg <2 x double> %63
  %66 = select <2 x i1> %64, <2 x double> %63, <2 x double> %65
  %67 = fcmp oge <2 x double> %61, %66
  %68 = select <2 x i1> %67, <2 x double> %61, <2 x double> %66
  %69 = extractelement <2 x double> %68, i64 0
  %70 = extractelement <2 x double> %68, i64 1
  %71 = fcmp oge double %69, %70
  %72 = select i1 %71, double %69, double %70
  %73 = load <2 x double>, ptr %12, align 16, !tbaa !9
  store <2 x double> %73, ptr %17, align 16, !tbaa !9
  %74 = load <2 x double>, ptr %13, align 16
  store <2 x double> %74, ptr %18, align 16, !tbaa !9
  %75 = fcmp ult double %72, %33
  br i1 %75, label %84, label %.preheader188

.preheader188:                                    ; preds = %45, %.preheader188
  %.0171 = phi double [ %81, %.preheader188 ], [ %72, %45 ]
  %.0170 = phi i32 [ %78, %.preheader188 ], [ 0, %45 ]
  %76 = phi <2 x double> [ %79, %.preheader188 ], [ %73, %45 ]
  %77 = phi <2 x double> [ %80, %.preheader188 ], [ %74, %45 ]
  %78 = add nuw nsw i32 %.0170, 1
  %79 = fmul <2 x double> %38, %76
  %80 = fmul <2 x double> %38, %77
  %81 = fmul double %32, %.0171
  %82 = fcmp oge double %81, %33
  %83 = icmp ult i32 %.0170, 19
  %or.cond = select i1 %82, i1 %83, i1 false
  br i1 %or.cond, label %.preheader188, label %.sink.split

84:                                               ; preds = %45
  %85 = fcmp ugt double %72, %32
  %86 = extractelement <2 x double> %73, i64 0
  br i1 %85, label %103, label %87

87:                                               ; preds = %84
  %88 = extractelement <2 x double> %74, i64 0
  %89 = fcmp oeq double %88, 0.000000e+00
  %90 = extractelement <2 x double> %74, i64 1
  %91 = fcmp oeq double %90, 0.000000e+00
  %or.cond4 = select i1 %89, i1 %91, i1 false
  br i1 %or.cond4, label %92, label %.preheader186

92:                                               ; preds = %87
  store <2 x double> %73, ptr %14, align 16, !tbaa !9
  br label %.loopexit185

.preheader186:                                    ; preds = %87, %.preheader186
  %.1172 = phi double [ %98, %.preheader186 ], [ %72, %87 ]
  %.1 = phi i32 [ %95, %.preheader186 ], [ 0, %87 ]
  %93 = phi <2 x double> [ %96, %.preheader186 ], [ %73, %87 ]
  %94 = phi <2 x double> [ %97, %.preheader186 ], [ %74, %87 ]
  %95 = add nsw i32 %.1, -1
  %96 = fmul <2 x double> %40, %93
  %97 = fmul <2 x double> %40, %94
  %98 = fmul double %33, %.1172
  %99 = fcmp ugt double %98, %32
  br i1 %99, label %.sink.split, label %.preheader186

.sink.split:                                      ; preds = %.preheader188, %.preheader186
  %.2.ph = phi i32 [ %95, %.preheader186 ], [ %78, %.preheader188 ]
  %100 = phi <2 x double> [ %96, %.preheader186 ], [ %79, %.preheader188 ]
  %101 = phi <2 x double> [ %97, %.preheader186 ], [ %80, %.preheader188 ]
  store <2 x double> %100, ptr %17, align 16, !tbaa !9
  store <2 x double> %101, ptr %18, align 16, !tbaa !9
  %102 = extractelement <2 x double> %100, i64 0
  br label %103

103:                                              ; preds = %.sink.split, %84
  %104 = phi double [ %86, %84 ], [ %102, %.sink.split ]
  %.2 = phi i32 [ 0, %84 ], [ %.2.ph, %.sink.split ]
  store double %104, ptr %8, align 8, !tbaa !9
  %105 = call { double, double } @Cd(ptr noundef nonnull %17)
  %106 = extractvalue { double, double } %105, 1
  store double %106, ptr %9, align 8, !tbaa !9
  %107 = load double, ptr %8, align 8, !tbaa !9
  %108 = fmul double %106, %106
  %109 = call double @llvm.fmuladd.f64(double %107, double %107, double %108)
  %110 = load double, ptr %18, align 16, !tbaa !11
  store double %110, ptr %8, align 8, !tbaa !9
  %111 = call { double, double } @Cd(ptr noundef nonnull %18)
  %112 = extractvalue { double, double } %111, 1
  store double %112, ptr %9, align 8, !tbaa !9
  %113 = load double, ptr %8, align 8, !tbaa !9
  %114 = fmul double %112, %112
  %115 = call double @llvm.fmuladd.f64(double %113, double %113, double %114)
  %116 = fcmp oge double %115, 1.000000e+00
  %117 = select i1 %116, double %115, double 1.000000e+00
  %118 = fmul double %22, %117
  %119 = fcmp ugt double %109, %118
  br i1 %119, label %219, label %120

120:                                              ; preds = %103
  %121 = load double, ptr %12, align 16, !tbaa !11
  %122 = fcmp oeq double %121, 0.000000e+00
  %123 = load double, ptr %35, align 8
  %124 = fcmp oeq double %123, 0.000000e+00
  %or.cond7 = select i1 %122, i1 %124, i1 false
  br i1 %or.cond7, label %125, label %143

125:                                              ; preds = %120
  %126 = load double, ptr %13, align 16, !tbaa !11
  store double %126, ptr %9, align 8, !tbaa !9
  %127 = call { double, double } @Cd(ptr noundef nonnull %13)
  %128 = extractvalue { double, double } %127, 1
  store double %128, ptr %10, align 8, !tbaa !9
  %129 = call double @dlapy2_(ptr noundef nonnull %9, ptr noundef nonnull %10) #7
  store double %129, ptr %14, align 16, !tbaa !11
  store double 0.000000e+00, ptr %36, align 8, !tbaa !13
  %130 = load double, ptr %18, align 16, !tbaa !11
  store double %130, ptr %8, align 8, !tbaa !9
  %131 = call { double, double } @Cd(ptr noundef nonnull %18)
  %132 = extractvalue { double, double } %131, 1
  store double %132, ptr %9, align 8, !tbaa !9
  %133 = call double @dlapy2_(ptr noundef nonnull %8, ptr noundef nonnull %9) #7
  %134 = load double, ptr %18, align 16, !tbaa !11
  %135 = fdiv double %134, %133
  store double %135, ptr %8, align 8, !tbaa !9
  %136 = call { double, double } @Cd(ptr noundef nonnull %18)
  %137 = extractvalue { double, double } %136, 1
  %138 = fneg double %137
  %139 = fdiv double %138, %133
  store double %139, ptr %9, align 8, !tbaa !9
  %140 = load double, ptr %8, align 8, !tbaa !9
  %141 = insertelement <2 x double> poison, double %140, i64 0
  %142 = insertelement <2 x double> %141, double %139, i64 1
  br label %.loopexit185

143:                                              ; preds = %120
  %144 = load double, ptr %17, align 16, !tbaa !11
  store double %144, ptr %8, align 8, !tbaa !9
  %145 = call { double, double } @Cd(ptr noundef nonnull %17)
  %146 = extractvalue { double, double } %145, 1
  store double %146, ptr %9, align 8, !tbaa !9
  %147 = call double @dlapy2_(ptr noundef nonnull %8, ptr noundef nonnull %9) #7
  %sqrt = call double @llvm.sqrt.f64(double %115)
  %148 = fdiv double %147, %sqrt
  %149 = load double, ptr %12, align 16, !tbaa !11
  store double %149, ptr %8, align 8, !tbaa !9
  %150 = fcmp oge double %149, 0.000000e+00
  %151 = fneg double %149
  %152 = select i1 %150, double %149, double %151
  store double %152, ptr %10, align 8, !tbaa !9
  %153 = call { double, double } @Cd(ptr noundef nonnull %12)
  %154 = extractvalue { double, double } %153, 1
  store double %154, ptr %9, align 8, !tbaa !9
  %155 = fcmp oge double %154, 0.000000e+00
  %156 = fneg double %154
  %157 = select i1 %155, double %154, double %156
  %158 = load double, ptr %10, align 8
  %159 = fcmp oge double %158, %157
  %160 = select i1 %159, double %158, double %157
  %161 = fcmp ogt double %160, 1.000000e+00
  %162 = load double, ptr %12, align 16, !tbaa !11
  br i1 %161, label %163, label %175

163:                                              ; preds = %143
  store double %162, ptr %8, align 8, !tbaa !9
  %164 = call { double, double } @Cd(ptr noundef nonnull %12)
  %165 = extractvalue { double, double } %164, 1
  store double %165, ptr %9, align 8, !tbaa !9
  %166 = call double @dlapy2_(ptr noundef nonnull %8, ptr noundef nonnull %9) #7
  %167 = load double, ptr %12, align 16, !tbaa !11
  %168 = fdiv double %167, %166
  store double %168, ptr %8, align 8, !tbaa !9
  %169 = call { double, double } @Cd(ptr noundef nonnull %12)
  %170 = extractvalue { double, double } %169, 1
  %171 = fdiv double %170, %166
  %172 = load double, ptr %8, align 8, !tbaa !9
  %173 = insertelement <2 x double> poison, double %172, i64 0
  %174 = insertelement <2 x double> %173, double %171, i64 1
  br label %188

175:                                              ; preds = %143
  %176 = fmul double %33, %162
  store double %176, ptr %16, align 8, !tbaa !9
  %177 = call { double, double } @Cd(ptr noundef nonnull %12)
  %178 = extractvalue { double, double } %177, 1
  %179 = fmul double %33, %178
  store double %179, ptr %15, align 8, !tbaa !9
  %180 = call double @dlapy2_(ptr noundef nonnull %16, ptr noundef nonnull %15) #7
  %181 = load double, ptr %16, align 8, !tbaa !9
  %182 = load double, ptr %15, align 8, !tbaa !9
  %183 = insertelement <2 x double> poison, double %181, i64 0
  %184 = insertelement <2 x double> %183, double %182, i64 1
  %185 = insertelement <2 x double> poison, double %180, i64 0
  %186 = shufflevector <2 x double> %185, <2 x double> poison, <2 x i32> zeroinitializer
  %187 = fdiv <2 x double> %184, %186
  br label %188

188:                                              ; preds = %175, %163
  %189 = phi <2 x double> [ %174, %163 ], [ %187, %175 ]
  %190 = extractelement <2 x double> %189, i64 1
  store double %190, ptr %9, align 8
  %191 = load double, ptr %18, align 16, !tbaa !11
  %192 = fdiv double %191, %sqrt
  store double %192, ptr %8, align 8, !tbaa !9
  %193 = call { double, double } @Cd(ptr noundef nonnull %18)
  %194 = extractvalue { double, double } %193, 1
  %195 = fneg double %194
  %196 = fdiv double %195, %sqrt
  store double %196, ptr %9, align 8, !tbaa !9
  %197 = load double, ptr %8, align 8, !tbaa !9
  %198 = fneg double %190
  %199 = insertelement <2 x double> %189, double %196, i64 0
  %200 = insertelement <2 x double> poison, double %198, i64 0
  %201 = insertelement <2 x double> %200, double %197, i64 1
  %202 = fmul <2 x double> %199, %201
  %203 = shufflevector <2 x double> %189, <2 x double> poison, <2 x i32> zeroinitializer
  %204 = shufflevector <2 x double> %201, <2 x double> %199, <2 x i32> <i32 1, i32 2>
  %205 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %203, <2 x double> %204, <2 x double> %202)
  %206 = load <2 x double>, ptr %12, align 16, !tbaa !9
  %207 = insertelement <2 x double> poison, double %148, i64 0
  %208 = shufflevector <2 x double> %207, <2 x double> poison, <2 x i32> zeroinitializer
  %209 = fmul <2 x double> %208, %206
  store <2 x double> %209, ptr %11, align 16, !tbaa !9
  %210 = load <2 x double>, ptr %13, align 16, !tbaa !9
  %211 = shufflevector <2 x double> %205, <2 x double> poison, <2 x i32> <i32 1, i32 poison>
  %212 = fneg <2 x double> %205
  %213 = shufflevector <2 x double> %211, <2 x double> %212, <2 x i32> <i32 0, i32 3>
  %214 = fmul <2 x double> %210, %213
  %215 = shufflevector <2 x double> %214, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %216 = shufflevector <2 x double> %205, <2 x double> poison, <2 x i32> zeroinitializer
  %217 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %216, <2 x double> %210, <2 x double> %215)
  %218 = fadd <2 x double> %209, %217
  store <2 x double> %218, ptr %14, align 16, !tbaa !9
  br label %.loopexit185

219:                                              ; preds = %103
  %220 = fdiv double %115, %109
  %221 = fadd double %220, 1.000000e+00
  %sqrt184 = call double @llvm.sqrt.f64(double %221)
  %222 = load double, ptr %17, align 16, !tbaa !11
  %223 = fmul double %sqrt184, %222
  store double %223, ptr %8, align 8, !tbaa !9
  %224 = call { double, double } @Cd(ptr noundef nonnull %17)
  %225 = extractvalue { double, double } %224, 1
  %226 = fmul double %sqrt184, %225
  store double %226, ptr %9, align 8, !tbaa !9
  %227 = load double, ptr %8, align 8, !tbaa !9
  store double %227, ptr %14, align 16, !tbaa !11
  store double %226, ptr %36, align 8, !tbaa !13
  %228 = fdiv double 1.000000e+00, %sqrt184
  %229 = fadd double %109, %115
  %230 = fdiv double %227, %229
  store double %230, ptr %8, align 8, !tbaa !9
  %231 = call { double, double } @Cd(ptr noundef nonnull %14)
  %232 = extractvalue { double, double } %231, 1
  %233 = fdiv double %232, %229
  store double %233, ptr %9, align 8, !tbaa !9
  %234 = load double, ptr %8, align 8, !tbaa !9
  %235 = call { double, double } @Cd(ptr noundef nonnull %18)
  %236 = extractvalue { double, double } %235, 0
  %237 = extractvalue { double, double } %235, 1
  %238 = fneg double %237
  %239 = call ptr @_pCd(ptr noundef nonnull %11)
  %240 = getelementptr inbounds i8, ptr %239, i64 8
  store double %236, ptr %239, align 8
  store double %238, ptr %240, align 8
  %241 = fneg double %233
  %242 = load <2 x double>, ptr %11, align 16, !tbaa !9
  %243 = insertelement <2 x double> poison, double %233, i64 0
  %244 = insertelement <2 x double> %243, double %241, i64 1
  %245 = fmul <2 x double> %242, %244
  %246 = shufflevector <2 x double> %245, <2 x double> poison, <2 x i32> <i32 1, i32 0>
  %247 = insertelement <2 x double> poison, double %234, i64 0
  %248 = shufflevector <2 x double> %247, <2 x double> poison, <2 x i32> zeroinitializer
  %249 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %248, <2 x double> %242, <2 x double> %246)
  %.not181 = icmp eq i32 %.2, 0
  br i1 %.not181, label %.loopexit185, label %250

250:                                              ; preds = %219
  %251 = icmp sgt i32 %.2, 0
  br i1 %251, label %.preheader, label %264

.preheader:                                       ; preds = %250
  %252 = load <2 x double>, ptr %14, align 16, !tbaa !9
  %xtraiter275 = and i32 %.2, 7
  %253 = icmp ult i32 %.2, 8
  br i1 %253, label %.loopexit.unr-lcssa, label %.preheader.new

.preheader.new:                                   ; preds = %.preheader
  %unroll_iter280 = and i32 %.2, 2147483640
  br label %254

254:                                              ; preds = %254, %.preheader.new
  %255 = phi <2 x double> [ %252, %.preheader.new ], [ %263, %254 ]
  %niter281 = phi i32 [ 0, %.preheader.new ], [ %niter281.next.7, %254 ]
  %256 = fmul <2 x double> %44, %255
  %257 = fmul <2 x double> %44, %256
  %258 = fmul <2 x double> %44, %257
  %259 = fmul <2 x double> %44, %258
  %260 = fmul <2 x double> %44, %259
  %261 = fmul <2 x double> %44, %260
  %262 = fmul <2 x double> %44, %261
  %263 = fmul <2 x double> %44, %262
  %niter281.next.7 = add i32 %niter281, 8
  %niter281.ncmp.7 = icmp eq i32 %niter281.next.7, %unroll_iter280
  br i1 %niter281.ncmp.7, label %.loopexit.unr-lcssa, label %254, !llvm.loop !14

264:                                              ; preds = %250
  %.not182208 = icmp sgt i32 %.2, -1
  br i1 %.not182208, label %.loopexit185, label %.lr.ph.preheader

.lr.ph.preheader:                                 ; preds = %264
  %265 = load <2 x double>, ptr %14, align 16, !tbaa !9
  %266 = sub i32 0, %.2
  %smax = call i32 @llvm.smax.i32(i32 %266, i32 1)
  %xtraiter = and i32 %smax, 7
  %267 = icmp slt i32 %266, 8
  br i1 %267, label %..loopexit185_crit_edge.unr-lcssa, label %.lr.ph.preheader.new

.lr.ph.preheader.new:                             ; preds = %.lr.ph.preheader
  %unroll_iter = and i32 %smax, 2147483640
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph, %.lr.ph.preheader.new
  %268 = phi <2 x double> [ %265, %.lr.ph.preheader.new ], [ %276, %.lr.ph ]
  %niter = phi i32 [ 0, %.lr.ph.preheader.new ], [ %niter.next.7, %.lr.ph ]
  %269 = fmul <2 x double> %42, %268
  %270 = fmul <2 x double> %42, %269
  %271 = fmul <2 x double> %42, %270
  %272 = fmul <2 x double> %42, %271
  %273 = fmul <2 x double> %42, %272
  %274 = fmul <2 x double> %42, %273
  %275 = fmul <2 x double> %42, %274
  %276 = fmul <2 x double> %42, %275
  %niter.next.7 = add i32 %niter, 8
  %niter.ncmp.7 = icmp eq i32 %niter.next.7, %unroll_iter
  br i1 %niter.ncmp.7, label %..loopexit185_crit_edge.unr-lcssa, label %.lr.ph, !llvm.loop !16

.loopexit.unr-lcssa:                              ; preds = %254, %.preheader
  %.lcssa273.ph = phi <2 x double> [ poison, %.preheader ], [ %263, %254 ]
  %.unr277 = phi <2 x double> [ %252, %.preheader ], [ %263, %254 ]
  %lcmp.mod278.not = icmp eq i32 %xtraiter275, 0
  br i1 %lcmp.mod278.not, label %.loopexit, label %.epil.preheader

.epil.preheader:                                  ; preds = %.loopexit.unr-lcssa, %.epil.preheader
  %277 = phi <2 x double> [ %278, %.epil.preheader ], [ %.unr277, %.loopexit.unr-lcssa ]
  %epil.iter276 = phi i32 [ %epil.iter276.next, %.epil.preheader ], [ 0, %.loopexit.unr-lcssa ]
  %278 = fmul <2 x double> %44, %277
  %epil.iter276.next = add i32 %epil.iter276, 1
  %epil.iter276.cmp.not = icmp eq i32 %epil.iter276.next, %xtraiter275
  br i1 %epil.iter276.cmp.not, label %.loopexit, label %.epil.preheader, !llvm.loop !17

.loopexit:                                        ; preds = %.epil.preheader, %.loopexit.unr-lcssa
  %.lcssa273 = phi <2 x double> [ %.lcssa273.ph, %.loopexit.unr-lcssa ], [ %278, %.epil.preheader ]
  store <2 x double> %.lcssa273, ptr %14, align 16, !tbaa !9
  br label %.loopexit185

..loopexit185_crit_edge.unr-lcssa:                ; preds = %.lr.ph, %.lr.ph.preheader
  %.lcssa272.ph = phi <2 x double> [ poison, %.lr.ph.preheader ], [ %276, %.lr.ph ]
  %.unr = phi <2 x double> [ %265, %.lr.ph.preheader ], [ %276, %.lr.ph ]
  %lcmp.mod.not = icmp eq i32 %xtraiter, 0
  br i1 %lcmp.mod.not, label %..loopexit185_crit_edge, label %.lr.ph.epil

.lr.ph.epil:                                      ; preds = %..loopexit185_crit_edge.unr-lcssa, %.lr.ph.epil
  %279 = phi <2 x double> [ %280, %.lr.ph.epil ], [ %.unr, %..loopexit185_crit_edge.unr-lcssa ]
  %epil.iter = phi i32 [ %epil.iter.next, %.lr.ph.epil ], [ 0, %..loopexit185_crit_edge.unr-lcssa ]
  %280 = fmul <2 x double> %42, %279
  %epil.iter.next = add i32 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i32 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %..loopexit185_crit_edge, label %.lr.ph.epil, !llvm.loop !19

..loopexit185_crit_edge:                          ; preds = %.lr.ph.epil, %..loopexit185_crit_edge.unr-lcssa
  %.lcssa272 = phi <2 x double> [ %.lcssa272.ph, %..loopexit185_crit_edge.unr-lcssa ], [ %280, %.lr.ph.epil ]
  store <2 x double> %.lcssa272, ptr %14, align 16, !tbaa !9
  br label %.loopexit185

.loopexit185:                                     ; preds = %264, %..loopexit185_crit_edge, %.loopexit, %188, %219, %125, %92
  %.0168 = phi double [ 0.000000e+00, %125 ], [ %148, %188 ], [ %228, %219 ], [ 1.000000e+00, %92 ], [ %228, %.loopexit ], [ %228, %..loopexit185_crit_edge ], [ %228, %264 ]
  %281 = phi <2 x double> [ %142, %125 ], [ %205, %188 ], [ %249, %219 ], [ zeroinitializer, %92 ], [ %249, %.loopexit ], [ %249, %..loopexit185_crit_edge ], [ %249, %264 ]
  %282 = sext i32 %.0169219 to i64
  %283 = getelementptr inbounds double, ptr %19, i64 %282
  store double %.0168, ptr %283, align 8, !tbaa !9
  store <2 x double> %281, ptr %50, align 8, !tbaa !9
  %284 = load <2 x double>, ptr %14, align 16, !tbaa !9
  store <2 x double> %284, ptr %47, align 8, !tbaa !9
  %285 = load i32, ptr %6, align 4, !tbaa !5
  %286 = add nsw i32 %285, %.0169219
  %287 = load i32, ptr %4, align 4, !tbaa !5
  %288 = add nsw i32 %287, %.0221
  %289 = load i32, ptr %2, align 4, !tbaa !5
  %290 = add nsw i32 %289, %.0167220
  %291 = add nuw i32 %.0175218, 1
  %exitcond237.not = icmp eq i32 %.0175218, %34
  br i1 %exitcond237.not, label %._crit_edge, label %45, !llvm.loop !20

._crit_edge:                                      ; preds = %.loopexit185, %7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %18) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %17) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %16) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %15) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %14) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %13) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %12) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %11) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %9) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %8) #7
  ret void
}

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

declare double @dlamch_(ptr noundef) local_unnamed_addr #2

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

; Function Attrs: nounwind uwtable
declare hidden double @dpow_ui(double noundef, i32 noundef) local_unnamed_addr #0

; Function Attrs: inlinehint nounwind uwtable
declare hidden { double, double } @Cd(ptr noundef) local_unnamed_addr #4

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

declare double @dlapy2_(ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @_pCd(ptr noundef) local_unnamed_addr #4

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.sqrt.f64(double) #6

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

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

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

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

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


; Effective O3 passes: AggressiveInstCombinePass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MergedLoadStoreMotionPass,PostOrderFunctionAttrsPass,ReassociatePass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass,VectorCombinePass