; LLVM IR from stan-dev/math :: lib/sundials_6.1.1/src/sunlinsol/sptfqmr (sunlinsol_sptfqmr)

; 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._generic_SUNLinearSolver = type { ptr, ptr, ptr }
%struct._SUNLinearSolverContent_SPTFQMR = type { i32, i32, i32, i32, double, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, ptr }

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

; Function Attrs: nounwind uwtable
define dso_local i32 @SUNLinSolSolve_SPTFQMR(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, double noundef %4) #1 {
  %6 = alloca i32, align 4
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca double, align 8
  %12 = alloca double, align 8
  %13 = alloca double, align 8
  %14 = alloca double, align 8
  %15 = alloca double, align 8
  %16 = alloca double, align 8
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca double, align 8
  %20 = alloca [2 x double], align 16
  %21 = alloca double, align 8
  %22 = alloca double, align 8
  %23 = alloca double, align 8
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca ptr, align 8
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca i32, align 4
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca ptr, align 8
  %44 = alloca ptr, align 8
  %45 = alloca ptr, align 8
  %46 = alloca ptr, align 8
  %47 = alloca ptr, align 8
  %48 = alloca ptr, align 8
  %49 = alloca ptr, align 8
  %50 = alloca ptr, align 8
  %51 = alloca ptr, align 8
  %52 = alloca ptr, align 8
  %53 = alloca [3 x double], align 16
  %54 = alloca [3 x ptr], align 16
  %55 = alloca i32, align 4
  store ptr %0, ptr %7, align 8, !tbaa !5
  store ptr %1, ptr %8, align 8, !tbaa !5
  store ptr %2, ptr %9, align 8, !tbaa !5
  store ptr %3, ptr %10, align 8, !tbaa !5
  store double %4, ptr %11, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #5
  call void @llvm.lifetime.start.p0(i64 16, ptr %20) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #5
  call void @llvm.lifetime.start.p0(i64 24, ptr %53) #5
  call void @llvm.lifetime.start.p0(i64 24, ptr %54) #5
  %56 = load ptr, ptr %7, align 8, !tbaa !5
  %57 = icmp eq ptr %56, null
  br i1 %57, label %58, label %59

58:                                               ; preds = %5
  store i32 -801, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

59:                                               ; preds = %5
  %60 = load ptr, ptr %7, align 8, !tbaa !5
  %61 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %60, i32 0, i32 0
  %62 = load ptr, ptr %61, align 8, !tbaa !11
  %63 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %62, i32 0, i32 0
  %64 = load i32, ptr %63, align 8, !tbaa !13
  store i32 %64, ptr %34, align 4, !tbaa !16
  %65 = load ptr, ptr %7, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %65, i32 0, i32 0
  %67 = load ptr, ptr %66, align 8, !tbaa !11
  %68 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %67, i32 0, i32 13
  %69 = load ptr, ptr %68, align 8, !tbaa !17
  store ptr %69, ptr %43, align 8, !tbaa !5
  %70 = load ptr, ptr %7, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %70, i32 0, i32 0
  %72 = load ptr, ptr %71, align 8, !tbaa !11
  %73 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %72, i32 0, i32 14
  %74 = load ptr, ptr %73, align 8, !tbaa !18
  store ptr %74, ptr %44, align 8, !tbaa !5
  %75 = load ptr, ptr %7, align 8, !tbaa !5
  %76 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %75, i32 0, i32 0
  %77 = load ptr, ptr %76, align 8, !tbaa !11
  %78 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %77, i32 0, i32 15
  %79 = load ptr, ptr %78, align 8, !tbaa !19
  store ptr %79, ptr %45, align 8, !tbaa !5
  %80 = load ptr, ptr %7, align 8, !tbaa !5
  %81 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %80, i32 0, i32 0
  %82 = load ptr, ptr %81, align 8, !tbaa !11
  %83 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %82, i32 0, i32 16
  %84 = load ptr, ptr %83, align 8, !tbaa !20
  store ptr %84, ptr %46, align 8, !tbaa !5
  %85 = load ptr, ptr %7, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %85, i32 0, i32 0
  %87 = load ptr, ptr %86, align 8, !tbaa !11
  %88 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %87, i32 0, i32 17
  %89 = load ptr, ptr %88, align 8, !tbaa !21
  store ptr %89, ptr %47, align 8, !tbaa !5
  %90 = load ptr, ptr %7, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %90, i32 0, i32 0
  %92 = load ptr, ptr %91, align 8, !tbaa !11
  %93 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %92, i32 0, i32 18
  %94 = load ptr, ptr %93, align 8, !tbaa !22
  store ptr %94, ptr %48, align 8, !tbaa !5
  %95 = load ptr, ptr %7, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %95, i32 0, i32 0
  %97 = load ptr, ptr %96, align 8, !tbaa !11
  %98 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %97, i32 0, i32 19
  %99 = load ptr, ptr %98, align 8, !tbaa !23
  store ptr %99, ptr %49, align 8, !tbaa !5
  %100 = load ptr, ptr %7, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %100, i32 0, i32 0
  %102 = load ptr, ptr %101, align 8, !tbaa !11
  %103 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %102, i32 0, i32 20
  %104 = load ptr, ptr %103, align 8, !tbaa !24
  store ptr %104, ptr %50, align 8, !tbaa !5
  %105 = load ptr, ptr %7, align 8, !tbaa !5
  %106 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %105, i32 0, i32 0
  %107 = load ptr, ptr %106, align 8, !tbaa !11
  %108 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %107, i32 0, i32 21
  %109 = load ptr, ptr %108, align 8, !tbaa !25
  store ptr %109, ptr %51, align 8, !tbaa !5
  %110 = load ptr, ptr %7, align 8, !tbaa !5
  %111 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %110, i32 0, i32 0
  %112 = load ptr, ptr %111, align 8, !tbaa !11
  %113 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %112, i32 0, i32 22
  %114 = load ptr, ptr %113, align 8, !tbaa !26
  store ptr %114, ptr %52, align 8, !tbaa !5
  %115 = load ptr, ptr %7, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %115, i32 0, i32 0
  %117 = load ptr, ptr %116, align 8, !tbaa !11
  %118 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %117, i32 0, i32 11
  %119 = load ptr, ptr %118, align 8, !tbaa !27
  store ptr %119, ptr %42, align 8, !tbaa !5
  %120 = load ptr, ptr %7, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %120, i32 0, i32 0
  %122 = load ptr, ptr %121, align 8, !tbaa !11
  %123 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %122, i32 0, i32 12
  %124 = load ptr, ptr %123, align 8, !tbaa !28
  store ptr %124, ptr %41, align 8, !tbaa !5
  %125 = load ptr, ptr %7, align 8, !tbaa !5
  %126 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %125, i32 0, i32 0
  %127 = load ptr, ptr %126, align 8, !tbaa !11
  %128 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %127, i32 0, i32 7
  %129 = load ptr, ptr %128, align 8, !tbaa !29
  store ptr %129, ptr %35, align 8, !tbaa !5
  %130 = load ptr, ptr %7, align 8, !tbaa !5
  %131 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %130, i32 0, i32 0
  %132 = load ptr, ptr %131, align 8, !tbaa !11
  %133 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %132, i32 0, i32 10
  %134 = load ptr, ptr %133, align 8, !tbaa !30
  store ptr %134, ptr %36, align 8, !tbaa !5
  %135 = load ptr, ptr %7, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %135, i32 0, i32 0
  %137 = load ptr, ptr %136, align 8, !tbaa !11
  %138 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %137, i32 0, i32 6
  %139 = load ptr, ptr %138, align 8, !tbaa !31
  store ptr %139, ptr %37, align 8, !tbaa !5
  %140 = load ptr, ptr %7, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %140, i32 0, i32 0
  %142 = load ptr, ptr %141, align 8, !tbaa !11
  %143 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %142, i32 0, i32 9
  %144 = load ptr, ptr %143, align 8, !tbaa !32
  store ptr %144, ptr %38, align 8, !tbaa !5
  %145 = load ptr, ptr %7, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %145, i32 0, i32 0
  %147 = load ptr, ptr %146, align 8, !tbaa !11
  %148 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %147, i32 0, i32 2
  store ptr %148, ptr %30, align 8, !tbaa !5
  %149 = load ptr, ptr %7, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %149, i32 0, i32 0
  %151 = load ptr, ptr %150, align 8, !tbaa !11
  %152 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %151, i32 0, i32 3
  store ptr %152, ptr %40, align 8, !tbaa !5
  %153 = load ptr, ptr %7, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %153, i32 0, i32 0
  %155 = load ptr, ptr %154, align 8, !tbaa !11
  %156 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %155, i32 0, i32 4
  store ptr %156, ptr %39, align 8, !tbaa !5
  store double -1.000000e+00, ptr %22, align 8, !tbaa !9
  store double -1.000000e+00, ptr %23, align 8, !tbaa !9
  %157 = load ptr, ptr %40, align 8, !tbaa !5
  store i32 0, ptr %157, align 4, !tbaa !16
  store i32 0, ptr %28, align 4, !tbaa !16
  store i32 0, ptr %29, align 4, !tbaa !16
  %158 = load ptr, ptr %7, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %158, i32 0, i32 0
  %160 = load ptr, ptr %159, align 8, !tbaa !11
  %161 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %160, i32 0, i32 1
  %162 = load i32, ptr %161, align 4, !tbaa !33
  %163 = icmp eq i32 %162, 1
  br i1 %163, label %171, label %164

164:                                              ; preds = %59
  %165 = load ptr, ptr %7, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %165, i32 0, i32 0
  %167 = load ptr, ptr %166, align 8, !tbaa !11
  %168 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %167, i32 0, i32 1
  %169 = load i32, ptr %168, align 4, !tbaa !33
  %170 = icmp eq i32 %169, 3
  br label %171

171:                                              ; preds = %164, %59
  %172 = phi i1 [ true, %59 ], [ %170, %164 ]
  %173 = zext i1 %172 to i32
  store i32 %173, ptr %24, align 4, !tbaa !16
  %174 = load ptr, ptr %7, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %174, i32 0, i32 0
  %176 = load ptr, ptr %175, align 8, !tbaa !11
  %177 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %176, i32 0, i32 1
  %178 = load i32, ptr %177, align 4, !tbaa !33
  %179 = icmp eq i32 %178, 2
  br i1 %179, label %187, label %180

180:                                              ; preds = %171
  %181 = load ptr, ptr %7, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %181, i32 0, i32 0
  %183 = load ptr, ptr %182, align 8, !tbaa !11
  %184 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %183, i32 0, i32 1
  %185 = load i32, ptr %184, align 4, !tbaa !33
  %186 = icmp eq i32 %185, 3
  br label %187

187:                                              ; preds = %180, %171
  %188 = phi i1 [ true, %171 ], [ %186, %180 ]
  %189 = zext i1 %188 to i32
  store i32 %189, ptr %25, align 4, !tbaa !16
  %190 = load ptr, ptr %41, align 8, !tbaa !5
  %191 = icmp ne ptr %190, null
  %192 = zext i1 %191 to i32
  store i32 %192, ptr %26, align 4, !tbaa !16
  %193 = load ptr, ptr %42, align 8, !tbaa !5
  %194 = icmp ne ptr %193, null
  %195 = zext i1 %194 to i32
  store i32 %195, ptr %27, align 4, !tbaa !16
  %196 = load i32, ptr %25, align 4, !tbaa !16
  %197 = icmp ne i32 %196, 0
  br i1 %197, label %198, label %208

198:                                              ; preds = %187
  %199 = load ptr, ptr %30, align 8, !tbaa !5
  %200 = load i32, ptr %199, align 4, !tbaa !16
  %201 = icmp ne i32 %200, 0
  br i1 %201, label %208, label %202

202:                                              ; preds = %198
  %203 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %203, align 4, !tbaa !16
  %204 = load ptr, ptr %7, align 8, !tbaa !5
  %205 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %204, i32 0, i32 0
  %206 = load ptr, ptr %205, align 8, !tbaa !11
  %207 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %206, i32 0, i32 5
  store i32 -802, ptr %207, align 8, !tbaa !34
  store i32 -802, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

208:                                              ; preds = %198, %187
  %209 = load ptr, ptr %37, align 8, !tbaa !5
  %210 = icmp eq ptr %209, null
  br i1 %210, label %211, label %222

211:                                              ; preds = %208
  %212 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %212, align 4, !tbaa !16
  %213 = load ptr, ptr %7, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %213, i32 0, i32 0
  %215 = load ptr, ptr %214, align 8, !tbaa !11
  %216 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %215, i32 0, i32 5
  store i32 -804, ptr %216, align 8, !tbaa !34
  %217 = load ptr, ptr %7, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %217, i32 0, i32 0
  %219 = load ptr, ptr %218, align 8, !tbaa !11
  %220 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %219, i32 0, i32 5
  %221 = load i32, ptr %220, align 8, !tbaa !34
  store i32 %221, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

222:                                              ; preds = %208
  %223 = load i32, ptr %24, align 4, !tbaa !16
  %224 = icmp ne i32 %223, 0
  br i1 %224, label %228, label %225

225:                                              ; preds = %222
  %226 = load i32, ptr %25, align 4, !tbaa !16
  %227 = icmp ne i32 %226, 0
  br i1 %227, label %228, label %242

228:                                              ; preds = %225, %222
  %229 = load ptr, ptr %38, align 8, !tbaa !5
  %230 = icmp eq ptr %229, null
  br i1 %230, label %231, label %242

231:                                              ; preds = %228
  %232 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %232, align 4, !tbaa !16
  %233 = load ptr, ptr %7, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %233, i32 0, i32 0
  %235 = load ptr, ptr %234, align 8, !tbaa !11
  %236 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %235, i32 0, i32 5
  store i32 -807, ptr %236, align 8, !tbaa !34
  %237 = load ptr, ptr %7, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %237, i32 0, i32 0
  %239 = load ptr, ptr %238, align 8, !tbaa !11
  %240 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %239, i32 0, i32 5
  %241 = load i32, ptr %240, align 8, !tbaa !34
  store i32 %241, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

242:                                              ; preds = %228, %225
  %243 = load ptr, ptr %30, align 8, !tbaa !5
  %244 = load i32, ptr %243, align 4, !tbaa !16
  %245 = icmp ne i32 %244, 0
  br i1 %245, label %246, label %249

246:                                              ; preds = %242
  %247 = load ptr, ptr %10, align 8, !tbaa !5
  %248 = load ptr, ptr %43, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %247, ptr noundef %248)
  br label %276

249:                                              ; preds = %242
  %250 = load ptr, ptr %37, align 8, !tbaa !5
  %251 = load ptr, ptr %35, align 8, !tbaa !5
  %252 = load ptr, ptr %9, align 8, !tbaa !5
  %253 = load ptr, ptr %43, align 8, !tbaa !5
  %254 = call i32 %250(ptr noundef %251, ptr noundef %252, ptr noundef %253)
  store i32 %254, ptr %33, align 4, !tbaa !16
  %255 = load i32, ptr %33, align 4, !tbaa !16
  %256 = icmp ne i32 %255, 0
  br i1 %256, label %257, label %272

257:                                              ; preds = %249
  %258 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %258, align 4, !tbaa !16
  %259 = load i32, ptr %33, align 4, !tbaa !16
  %260 = icmp slt i32 %259, 0
  %261 = zext i1 %260 to i64
  %262 = select i1 %260, i32 -805, i32 803
  %263 = load ptr, ptr %7, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %263, i32 0, i32 0
  %265 = load ptr, ptr %264, align 8, !tbaa !11
  %266 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %265, i32 0, i32 5
  store i32 %262, ptr %266, align 8, !tbaa !34
  %267 = load ptr, ptr %7, align 8, !tbaa !5
  %268 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %267, i32 0, i32 0
  %269 = load ptr, ptr %268, align 8, !tbaa !11
  %270 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %269, i32 0, i32 5
  %271 = load i32, ptr %270, align 8, !tbaa !34
  store i32 %271, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

272:                                              ; preds = %249
  %273 = load ptr, ptr %10, align 8, !tbaa !5
  %274 = load ptr, ptr %43, align 8, !tbaa !5
  %275 = load ptr, ptr %43, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %273, double noundef -1.000000e+00, ptr noundef %274, ptr noundef %275)
  br label %276

276:                                              ; preds = %272, %246
  %277 = load i32, ptr %24, align 4, !tbaa !16
  %278 = icmp ne i32 %277, 0
  br i1 %278, label %279, label %304

279:                                              ; preds = %276
  %280 = load ptr, ptr %38, align 8, !tbaa !5
  %281 = load ptr, ptr %36, align 8, !tbaa !5
  %282 = load ptr, ptr %43, align 8, !tbaa !5
  %283 = load ptr, ptr %50, align 8, !tbaa !5
  %284 = load double, ptr %11, align 8, !tbaa !9
  %285 = call i32 %280(ptr noundef %281, ptr noundef %282, ptr noundef %283, double noundef %284, i32 noundef 1)
  store i32 %285, ptr %33, align 4, !tbaa !16
  %286 = load i32, ptr %33, align 4, !tbaa !16
  %287 = icmp ne i32 %286, 0
  br i1 %287, label %288, label %303

288:                                              ; preds = %279
  %289 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %289, align 4, !tbaa !16
  %290 = load i32, ptr %33, align 4, !tbaa !16
  %291 = icmp slt i32 %290, 0
  %292 = zext i1 %291 to i64
  %293 = select i1 %291, i32 -808, i32 805
  %294 = load ptr, ptr %7, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %294, i32 0, i32 0
  %296 = load ptr, ptr %295, align 8, !tbaa !11
  %297 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %296, i32 0, i32 5
  store i32 %293, ptr %297, align 8, !tbaa !34
  %298 = load ptr, ptr %7, align 8, !tbaa !5
  %299 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %298, i32 0, i32 0
  %300 = load ptr, ptr %299, align 8, !tbaa !11
  %301 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %300, i32 0, i32 5
  %302 = load i32, ptr %301, align 8, !tbaa !34
  store i32 %302, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

303:                                              ; preds = %279
  br label %307

304:                                              ; preds = %276
  %305 = load ptr, ptr %43, align 8, !tbaa !5
  %306 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %305, ptr noundef %306)
  br label %307

307:                                              ; preds = %304, %303
  %308 = load i32, ptr %27, align 4, !tbaa !16
  %309 = icmp ne i32 %308, 0
  br i1 %309, label %310, label %314

310:                                              ; preds = %307
  %311 = load ptr, ptr %42, align 8, !tbaa !5
  %312 = load ptr, ptr %50, align 8, !tbaa !5
  %313 = load ptr, ptr %43, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %311, ptr noundef %312, ptr noundef %313)
  br label %317

314:                                              ; preds = %307
  %315 = load ptr, ptr %50, align 8, !tbaa !5
  %316 = load ptr, ptr %43, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %315, ptr noundef %316)
  br label %317

317:                                              ; preds = %314, %310
  %318 = load ptr, ptr %43, align 8, !tbaa !5
  %319 = load ptr, ptr %43, align 8, !tbaa !5
  %320 = call double @N_VDotProd(ptr noundef %318, ptr noundef %319)
  %321 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  store double %320, ptr %321, align 16, !tbaa !9
  %322 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  %323 = load double, ptr %322, align 16, !tbaa !9
  %324 = fcmp ole double %323, 0.000000e+00
  br i1 %324, label %325, label %326

325:                                              ; preds = %317
  br label %330

326:                                              ; preds = %317
  %327 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  %328 = load double, ptr %327, align 16, !tbaa !9
  %329 = call double @sqrt(double noundef %328) #5
  br label %330

330:                                              ; preds = %326, %325
  %331 = phi double [ 0.000000e+00, %325 ], [ %329, %326 ]
  store double %331, ptr %21, align 8, !tbaa !9
  %332 = load ptr, ptr %39, align 8, !tbaa !5
  store double %331, ptr %332, align 8, !tbaa !9
  %333 = load double, ptr %21, align 8, !tbaa !9
  %334 = load double, ptr %11, align 8, !tbaa !9
  %335 = fcmp ole double %333, %334
  br i1 %335, label %336, label %347

336:                                              ; preds = %330
  %337 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %337, align 4, !tbaa !16
  %338 = load ptr, ptr %7, align 8, !tbaa !5
  %339 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %338, i32 0, i32 0
  %340 = load ptr, ptr %339, align 8, !tbaa !11
  %341 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %340, i32 0, i32 5
  store i32 0, ptr %341, align 8, !tbaa !34
  %342 = load ptr, ptr %7, align 8, !tbaa !5
  %343 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %342, i32 0, i32 0
  %344 = load ptr, ptr %343, align 8, !tbaa !11
  %345 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %344, i32 0, i32 5
  %346 = load i32, ptr %345, align 8, !tbaa !34
  store i32 %346, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

347:                                              ; preds = %330
  %348 = load i32, ptr %26, align 4, !tbaa !16
  %349 = icmp ne i32 %348, 0
  br i1 %349, label %350, label %354

350:                                              ; preds = %347
  %351 = load ptr, ptr %43, align 8, !tbaa !5
  %352 = load ptr, ptr %41, align 8, !tbaa !5
  %353 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VDiv(ptr noundef %351, ptr noundef %352, ptr noundef %353)
  br label %357

354:                                              ; preds = %347
  %355 = load ptr, ptr %43, align 8, !tbaa !5
  %356 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %355, ptr noundef %356)
  br label %357

357:                                              ; preds = %354, %350
  %358 = load i32, ptr %25, align 4, !tbaa !16
  %359 = icmp ne i32 %358, 0
  br i1 %359, label %360, label %387

360:                                              ; preds = %357
  %361 = load ptr, ptr %50, align 8, !tbaa !5
  %362 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %361, ptr noundef %362)
  %363 = load ptr, ptr %38, align 8, !tbaa !5
  %364 = load ptr, ptr %36, align 8, !tbaa !5
  %365 = load ptr, ptr %46, align 8, !tbaa !5
  %366 = load ptr, ptr %50, align 8, !tbaa !5
  %367 = load double, ptr %11, align 8, !tbaa !9
  %368 = call i32 %363(ptr noundef %364, ptr noundef %365, ptr noundef %366, double noundef %367, i32 noundef 2)
  store i32 %368, ptr %33, align 4, !tbaa !16
  %369 = load i32, ptr %33, align 4, !tbaa !16
  %370 = icmp ne i32 %369, 0
  br i1 %370, label %371, label %386

371:                                              ; preds = %360
  %372 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %372, align 4, !tbaa !16
  %373 = load i32, ptr %33, align 4, !tbaa !16
  %374 = icmp slt i32 %373, 0
  %375 = zext i1 %374 to i64
  %376 = select i1 %374, i32 -808, i32 805
  %377 = load ptr, ptr %7, align 8, !tbaa !5
  %378 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %377, i32 0, i32 0
  %379 = load ptr, ptr %378, align 8, !tbaa !11
  %380 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %379, i32 0, i32 5
  store i32 %376, ptr %380, align 8, !tbaa !34
  %381 = load ptr, ptr %7, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %381, i32 0, i32 0
  %383 = load ptr, ptr %382, align 8, !tbaa !11
  %384 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %383, i32 0, i32 5
  %385 = load i32, ptr %384, align 8, !tbaa !34
  store i32 %385, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

386:                                              ; preds = %360
  br label %387

387:                                              ; preds = %386, %357
  %388 = load ptr, ptr %37, align 8, !tbaa !5
  %389 = load ptr, ptr %35, align 8, !tbaa !5
  %390 = load ptr, ptr %50, align 8, !tbaa !5
  %391 = load ptr, ptr %46, align 8, !tbaa !5
  %392 = call i32 %388(ptr noundef %389, ptr noundef %390, ptr noundef %391)
  store i32 %392, ptr %33, align 4, !tbaa !16
  %393 = load i32, ptr %33, align 4, !tbaa !16
  %394 = icmp ne i32 %393, 0
  br i1 %394, label %395, label %410

395:                                              ; preds = %387
  %396 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %396, align 4, !tbaa !16
  %397 = load i32, ptr %33, align 4, !tbaa !16
  %398 = icmp slt i32 %397, 0
  %399 = zext i1 %398 to i64
  %400 = select i1 %398, i32 -805, i32 803
  %401 = load ptr, ptr %7, align 8, !tbaa !5
  %402 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %401, i32 0, i32 0
  %403 = load ptr, ptr %402, align 8, !tbaa !11
  %404 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %403, i32 0, i32 5
  store i32 %400, ptr %404, align 8, !tbaa !34
  %405 = load ptr, ptr %7, align 8, !tbaa !5
  %406 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %405, i32 0, i32 0
  %407 = load ptr, ptr %406, align 8, !tbaa !11
  %408 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %407, i32 0, i32 5
  %409 = load i32, ptr %408, align 8, !tbaa !34
  store i32 %409, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

410:                                              ; preds = %387
  %411 = load i32, ptr %24, align 4, !tbaa !16
  %412 = icmp ne i32 %411, 0
  br i1 %412, label %413, label %438

413:                                              ; preds = %410
  %414 = load ptr, ptr %38, align 8, !tbaa !5
  %415 = load ptr, ptr %36, align 8, !tbaa !5
  %416 = load ptr, ptr %46, align 8, !tbaa !5
  %417 = load ptr, ptr %50, align 8, !tbaa !5
  %418 = load double, ptr %11, align 8, !tbaa !9
  %419 = call i32 %414(ptr noundef %415, ptr noundef %416, ptr noundef %417, double noundef %418, i32 noundef 1)
  store i32 %419, ptr %33, align 4, !tbaa !16
  %420 = load i32, ptr %33, align 4, !tbaa !16
  %421 = icmp ne i32 %420, 0
  br i1 %421, label %422, label %437

422:                                              ; preds = %413
  %423 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %423, align 4, !tbaa !16
  %424 = load i32, ptr %33, align 4, !tbaa !16
  %425 = icmp slt i32 %424, 0
  %426 = zext i1 %425 to i64
  %427 = select i1 %425, i32 -808, i32 805
  %428 = load ptr, ptr %7, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %428, i32 0, i32 0
  %430 = load ptr, ptr %429, align 8, !tbaa !11
  %431 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %430, i32 0, i32 5
  store i32 %427, ptr %431, align 8, !tbaa !34
  %432 = load ptr, ptr %7, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %432, i32 0, i32 0
  %434 = load ptr, ptr %433, align 8, !tbaa !11
  %435 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %434, i32 0, i32 5
  %436 = load i32, ptr %435, align 8, !tbaa !34
  store i32 %436, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

437:                                              ; preds = %413
  br label %441

438:                                              ; preds = %410
  %439 = load ptr, ptr %46, align 8, !tbaa !5
  %440 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %439, ptr noundef %440)
  br label %441

441:                                              ; preds = %438, %437
  %442 = load i32, ptr %27, align 4, !tbaa !16
  %443 = icmp ne i32 %442, 0
  br i1 %443, label %444, label %448

444:                                              ; preds = %441
  %445 = load ptr, ptr %42, align 8, !tbaa !5
  %446 = load ptr, ptr %50, align 8, !tbaa !5
  %447 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %445, ptr noundef %446, ptr noundef %447)
  br label %451

448:                                              ; preds = %441
  %449 = load ptr, ptr %50, align 8, !tbaa !5
  %450 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %449, ptr noundef %450)
  br label %451

451:                                              ; preds = %448, %444
  %452 = load ptr, ptr %43, align 8, !tbaa !5
  %453 = load ptr, ptr %48, align 8, !tbaa !5
  %454 = getelementptr inbounds ptr, ptr %453, i64 0
  %455 = load ptr, ptr %454, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %452, ptr noundef %455)
  %456 = load ptr, ptr %43, align 8, !tbaa !5
  %457 = load ptr, ptr %49, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %456, ptr noundef %457)
  %458 = load ptr, ptr %43, align 8, !tbaa !5
  %459 = load ptr, ptr %47, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %458, ptr noundef %459)
  %460 = load ptr, ptr %45, align 8, !tbaa !5
  call void @N_VConst(double noundef 0.000000e+00, ptr noundef %460)
  %461 = load i32, ptr %26, align 4, !tbaa !16
  %462 = icmp ne i32 %461, 0
  br i1 %462, label %463, label %471

463:                                              ; preds = %451
  %464 = load ptr, ptr %30, align 8, !tbaa !5
  %465 = load i32, ptr %464, align 4, !tbaa !16
  %466 = icmp ne i32 %465, 0
  br i1 %466, label %471, label %467

467:                                              ; preds = %463
  %468 = load ptr, ptr %41, align 8, !tbaa !5
  %469 = load ptr, ptr %9, align 8, !tbaa !5
  %470 = load ptr, ptr %9, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %468, ptr noundef %469, ptr noundef %470)
  br label %471

471:                                              ; preds = %467, %463, %451
  %472 = load double, ptr %21, align 8, !tbaa !9
  store double %472, ptr %13, align 8, !tbaa !9
  store double 0.000000e+00, ptr %14, align 8, !tbaa !9
  store double 0.000000e+00, ptr %18, align 8, !tbaa !9
  store i32 0, ptr %31, align 4, !tbaa !16
  br label %473

473:                                              ; preds = %1138, %471
  %474 = load i32, ptr %31, align 4, !tbaa !16
  %475 = load i32, ptr %34, align 4, !tbaa !16
  %476 = icmp slt i32 %474, %475
  br i1 %476, label %477, label %1141

477:                                              ; preds = %473
  %478 = load ptr, ptr %40, align 8, !tbaa !5
  %479 = load i32, ptr %478, align 4, !tbaa !16
  %480 = add nsw i32 %479, 1
  store i32 %480, ptr %478, align 4, !tbaa !16
  %481 = load ptr, ptr %43, align 8, !tbaa !5
  %482 = load ptr, ptr %46, align 8, !tbaa !5
  %483 = call double @N_VDotProd(ptr noundef %481, ptr noundef %482)
  store double %483, ptr %17, align 8, !tbaa !9
  %484 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  %485 = load double, ptr %484, align 16, !tbaa !9
  %486 = load double, ptr %17, align 8, !tbaa !9
  %487 = fdiv double %485, %486
  store double %487, ptr %12, align 8, !tbaa !9
  %488 = load ptr, ptr %49, align 8, !tbaa !5
  %489 = load double, ptr %12, align 8, !tbaa !9
  %490 = fneg double %489
  %491 = load ptr, ptr %46, align 8, !tbaa !5
  %492 = load ptr, ptr %44, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %488, double noundef %490, ptr noundef %491, ptr noundef %492)
  %493 = load ptr, ptr %49, align 8, !tbaa !5
  %494 = load ptr, ptr %44, align 8, !tbaa !5
  %495 = load ptr, ptr %48, align 8, !tbaa !5
  %496 = getelementptr inbounds ptr, ptr %495, i64 1
  %497 = load ptr, ptr %496, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %493, double noundef 1.000000e+00, ptr noundef %494, ptr noundef %497)
  %498 = load i32, ptr %26, align 4, !tbaa !16
  %499 = icmp ne i32 %498, 0
  br i1 %499, label %500, label %508

500:                                              ; preds = %477
  %501 = load ptr, ptr %48, align 8, !tbaa !5
  %502 = getelementptr inbounds ptr, ptr %501, i64 1
  %503 = load ptr, ptr %502, align 8, !tbaa !5
  %504 = load ptr, ptr %41, align 8, !tbaa !5
  %505 = load ptr, ptr %48, align 8, !tbaa !5
  %506 = getelementptr inbounds ptr, ptr %505, i64 1
  %507 = load ptr, ptr %506, align 8, !tbaa !5
  call void @N_VDiv(ptr noundef %503, ptr noundef %504, ptr noundef %507)
  br label %508

508:                                              ; preds = %500, %477
  %509 = load i32, ptr %25, align 4, !tbaa !16
  %510 = icmp ne i32 %509, 0
  br i1 %510, label %511, label %542

511:                                              ; preds = %508
  %512 = load ptr, ptr %48, align 8, !tbaa !5
  %513 = getelementptr inbounds ptr, ptr %512, i64 1
  %514 = load ptr, ptr %513, align 8, !tbaa !5
  %515 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %514, ptr noundef %515)
  %516 = load ptr, ptr %38, align 8, !tbaa !5
  %517 = load ptr, ptr %36, align 8, !tbaa !5
  %518 = load ptr, ptr %50, align 8, !tbaa !5
  %519 = load ptr, ptr %48, align 8, !tbaa !5
  %520 = getelementptr inbounds ptr, ptr %519, i64 1
  %521 = load ptr, ptr %520, align 8, !tbaa !5
  %522 = load double, ptr %11, align 8, !tbaa !9
  %523 = call i32 %516(ptr noundef %517, ptr noundef %518, ptr noundef %521, double noundef %522, i32 noundef 2)
  store i32 %523, ptr %33, align 4, !tbaa !16
  %524 = load i32, ptr %33, align 4, !tbaa !16
  %525 = icmp ne i32 %524, 0
  br i1 %525, label %526, label %541

526:                                              ; preds = %511
  %527 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %527, align 4, !tbaa !16
  %528 = load i32, ptr %33, align 4, !tbaa !16
  %529 = icmp slt i32 %528, 0
  %530 = zext i1 %529 to i64
  %531 = select i1 %529, i32 -808, i32 805
  %532 = load ptr, ptr %7, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %532, i32 0, i32 0
  %534 = load ptr, ptr %533, align 8, !tbaa !11
  %535 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %534, i32 0, i32 5
  store i32 %531, ptr %535, align 8, !tbaa !34
  %536 = load ptr, ptr %7, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %536, i32 0, i32 0
  %538 = load ptr, ptr %537, align 8, !tbaa !11
  %539 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %538, i32 0, i32 5
  %540 = load i32, ptr %539, align 8, !tbaa !34
  store i32 %540, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

541:                                              ; preds = %511
  br label %542

542:                                              ; preds = %541, %508
  %543 = load ptr, ptr %37, align 8, !tbaa !5
  %544 = load ptr, ptr %35, align 8, !tbaa !5
  %545 = load ptr, ptr %48, align 8, !tbaa !5
  %546 = getelementptr inbounds ptr, ptr %545, i64 1
  %547 = load ptr, ptr %546, align 8, !tbaa !5
  %548 = load ptr, ptr %50, align 8, !tbaa !5
  %549 = call i32 %543(ptr noundef %544, ptr noundef %547, ptr noundef %548)
  store i32 %549, ptr %33, align 4, !tbaa !16
  %550 = load i32, ptr %33, align 4, !tbaa !16
  %551 = icmp ne i32 %550, 0
  br i1 %551, label %552, label %567

552:                                              ; preds = %542
  %553 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %553, align 4, !tbaa !16
  %554 = load i32, ptr %33, align 4, !tbaa !16
  %555 = icmp slt i32 %554, 0
  %556 = zext i1 %555 to i64
  %557 = select i1 %555, i32 -805, i32 803
  %558 = load ptr, ptr %7, align 8, !tbaa !5
  %559 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %558, i32 0, i32 0
  %560 = load ptr, ptr %559, align 8, !tbaa !11
  %561 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %560, i32 0, i32 5
  store i32 %557, ptr %561, align 8, !tbaa !34
  %562 = load ptr, ptr %7, align 8, !tbaa !5
  %563 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %562, i32 0, i32 0
  %564 = load ptr, ptr %563, align 8, !tbaa !11
  %565 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %564, i32 0, i32 5
  %566 = load i32, ptr %565, align 8, !tbaa !34
  store i32 %566, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

567:                                              ; preds = %542
  %568 = load i32, ptr %24, align 4, !tbaa !16
  %569 = icmp ne i32 %568, 0
  br i1 %569, label %570, label %597

570:                                              ; preds = %567
  %571 = load ptr, ptr %38, align 8, !tbaa !5
  %572 = load ptr, ptr %36, align 8, !tbaa !5
  %573 = load ptr, ptr %50, align 8, !tbaa !5
  %574 = load ptr, ptr %48, align 8, !tbaa !5
  %575 = getelementptr inbounds ptr, ptr %574, i64 1
  %576 = load ptr, ptr %575, align 8, !tbaa !5
  %577 = load double, ptr %11, align 8, !tbaa !9
  %578 = call i32 %571(ptr noundef %572, ptr noundef %573, ptr noundef %576, double noundef %577, i32 noundef 1)
  store i32 %578, ptr %33, align 4, !tbaa !16
  %579 = load i32, ptr %33, align 4, !tbaa !16
  %580 = icmp ne i32 %579, 0
  br i1 %580, label %581, label %596

581:                                              ; preds = %570
  %582 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %582, align 4, !tbaa !16
  %583 = load i32, ptr %33, align 4, !tbaa !16
  %584 = icmp slt i32 %583, 0
  %585 = zext i1 %584 to i64
  %586 = select i1 %584, i32 -808, i32 805
  %587 = load ptr, ptr %7, align 8, !tbaa !5
  %588 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %587, i32 0, i32 0
  %589 = load ptr, ptr %588, align 8, !tbaa !11
  %590 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %589, i32 0, i32 5
  store i32 %586, ptr %590, align 8, !tbaa !34
  %591 = load ptr, ptr %7, align 8, !tbaa !5
  %592 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %591, i32 0, i32 0
  %593 = load ptr, ptr %592, align 8, !tbaa !11
  %594 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %593, i32 0, i32 5
  %595 = load i32, ptr %594, align 8, !tbaa !34
  store i32 %595, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

596:                                              ; preds = %570
  br label %602

597:                                              ; preds = %567
  %598 = load ptr, ptr %50, align 8, !tbaa !5
  %599 = load ptr, ptr %48, align 8, !tbaa !5
  %600 = getelementptr inbounds ptr, ptr %599, i64 1
  %601 = load ptr, ptr %600, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %598, ptr noundef %601)
  br label %602

602:                                              ; preds = %597, %596
  %603 = load i32, ptr %27, align 4, !tbaa !16
  %604 = icmp ne i32 %603, 0
  br i1 %604, label %605, label %611

605:                                              ; preds = %602
  %606 = load ptr, ptr %42, align 8, !tbaa !5
  %607 = load ptr, ptr %48, align 8, !tbaa !5
  %608 = getelementptr inbounds ptr, ptr %607, i64 1
  %609 = load ptr, ptr %608, align 8, !tbaa !5
  %610 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %606, ptr noundef %609, ptr noundef %610)
  br label %616

611:                                              ; preds = %602
  %612 = load ptr, ptr %48, align 8, !tbaa !5
  %613 = getelementptr inbounds ptr, ptr %612, i64 1
  %614 = load ptr, ptr %613, align 8, !tbaa !5
  %615 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %614, ptr noundef %615)
  br label %616

616:                                              ; preds = %611, %605
  %617 = load ptr, ptr %48, align 8, !tbaa !5
  %618 = getelementptr inbounds ptr, ptr %617, i64 0
  %619 = load ptr, ptr %618, align 8, !tbaa !5
  %620 = load double, ptr %12, align 8, !tbaa !9
  %621 = fneg double %620
  %622 = load ptr, ptr %50, align 8, !tbaa !5
  %623 = load ptr, ptr %48, align 8, !tbaa !5
  %624 = getelementptr inbounds ptr, ptr %623, i64 1
  %625 = load ptr, ptr %624, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %619, double noundef %621, ptr noundef %622, ptr noundef %625)
  store i32 0, ptr %32, align 4, !tbaa !16
  br label %626

626:                                              ; preds = %974, %616
  %627 = load i32, ptr %32, align 4, !tbaa !16
  %628 = icmp slt i32 %627, 2
  br i1 %628, label %629, label %977

629:                                              ; preds = %626
  %630 = load i32, ptr %32, align 4, !tbaa !16
  %631 = icmp eq i32 %630, 0
  br i1 %631, label %632, label %713

632:                                              ; preds = %629
  %633 = load ptr, ptr %48, align 8, !tbaa !5
  %634 = getelementptr inbounds ptr, ptr %633, i64 1
  %635 = load ptr, ptr %634, align 8, !tbaa !5
  %636 = load ptr, ptr %48, align 8, !tbaa !5
  %637 = getelementptr inbounds ptr, ptr %636, i64 1
  %638 = load ptr, ptr %637, align 8, !tbaa !5
  %639 = call double @N_VDotProd(ptr noundef %635, ptr noundef %638)
  %640 = fcmp ole double %639, 0.000000e+00
  br i1 %640, label %641, label %642

641:                                              ; preds = %632
  br label %651

642:                                              ; preds = %632
  %643 = load ptr, ptr %48, align 8, !tbaa !5
  %644 = getelementptr inbounds ptr, ptr %643, i64 1
  %645 = load ptr, ptr %644, align 8, !tbaa !5
  %646 = load ptr, ptr %48, align 8, !tbaa !5
  %647 = getelementptr inbounds ptr, ptr %646, i64 1
  %648 = load ptr, ptr %647, align 8, !tbaa !5
  %649 = call double @N_VDotProd(ptr noundef %645, ptr noundef %648)
  %650 = call double @sqrt(double noundef %649) #5
  br label %651

651:                                              ; preds = %642, %641
  %652 = phi double [ 0.000000e+00, %641 ], [ %650, %642 ]
  store double %652, ptr %23, align 8, !tbaa !9
  %653 = load ptr, ptr %48, align 8, !tbaa !5
  %654 = getelementptr inbounds ptr, ptr %653, i64 0
  %655 = load ptr, ptr %654, align 8, !tbaa !5
  %656 = load ptr, ptr %48, align 8, !tbaa !5
  %657 = getelementptr inbounds ptr, ptr %656, i64 0
  %658 = load ptr, ptr %657, align 8, !tbaa !5
  %659 = call double @N_VDotProd(ptr noundef %655, ptr noundef %658)
  %660 = fcmp ole double %659, 0.000000e+00
  br i1 %660, label %661, label %662

661:                                              ; preds = %651
  br label %671

662:                                              ; preds = %651
  %663 = load ptr, ptr %48, align 8, !tbaa !5
  %664 = getelementptr inbounds ptr, ptr %663, i64 0
  %665 = load ptr, ptr %664, align 8, !tbaa !5
  %666 = load ptr, ptr %48, align 8, !tbaa !5
  %667 = getelementptr inbounds ptr, ptr %666, i64 0
  %668 = load ptr, ptr %667, align 8, !tbaa !5
  %669 = call double @N_VDotProd(ptr noundef %665, ptr noundef %668)
  %670 = call double @sqrt(double noundef %669) #5
  br label %671

671:                                              ; preds = %662, %661
  %672 = phi double [ 0.000000e+00, %661 ], [ %670, %662 ]
  %673 = load double, ptr %23, align 8, !tbaa !9
  %674 = fmul double %672, %673
  %675 = fcmp ole double %674, 0.000000e+00
  br i1 %675, label %676, label %677

676:                                              ; preds = %671
  br label %701

677:                                              ; preds = %671
  %678 = load ptr, ptr %48, align 8, !tbaa !5
  %679 = getelementptr inbounds ptr, ptr %678, i64 0
  %680 = load ptr, ptr %679, align 8, !tbaa !5
  %681 = load ptr, ptr %48, align 8, !tbaa !5
  %682 = getelementptr inbounds ptr, ptr %681, i64 0
  %683 = load ptr, ptr %682, align 8, !tbaa !5
  %684 = call double @N_VDotProd(ptr noundef %680, ptr noundef %683)
  %685 = fcmp ole double %684, 0.000000e+00
  br i1 %685, label %686, label %687

686:                                              ; preds = %677
  br label %696

687:                                              ; preds = %677
  %688 = load ptr, ptr %48, align 8, !tbaa !5
  %689 = getelementptr inbounds ptr, ptr %688, i64 0
  %690 = load ptr, ptr %689, align 8, !tbaa !5
  %691 = load ptr, ptr %48, align 8, !tbaa !5
  %692 = getelementptr inbounds ptr, ptr %691, i64 0
  %693 = load ptr, ptr %692, align 8, !tbaa !5
  %694 = call double @N_VDotProd(ptr noundef %690, ptr noundef %693)
  %695 = call double @sqrt(double noundef %694) #5
  br label %696

696:                                              ; preds = %687, %686
  %697 = phi double [ 0.000000e+00, %686 ], [ %695, %687 ]
  %698 = load double, ptr %23, align 8, !tbaa !9
  %699 = fmul double %697, %698
  %700 = call double @sqrt(double noundef %699) #5
  br label %701

701:                                              ; preds = %696, %676
  %702 = phi double [ 0.000000e+00, %676 ], [ %700, %696 ]
  store double %702, ptr %19, align 8, !tbaa !9
  %703 = load ptr, ptr %49, align 8, !tbaa !5
  %704 = load double, ptr %18, align 8, !tbaa !9
  %705 = load double, ptr %18, align 8, !tbaa !9
  %706 = fmul double %704, %705
  %707 = load double, ptr %14, align 8, !tbaa !9
  %708 = fmul double %706, %707
  %709 = load double, ptr %12, align 8, !tbaa !9
  %710 = fdiv double %708, %709
  %711 = load ptr, ptr %45, align 8, !tbaa !5
  %712 = load ptr, ptr %45, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %703, double noundef %710, ptr noundef %711, ptr noundef %712)
  br label %725

713:                                              ; preds = %629
  %714 = load double, ptr %23, align 8, !tbaa !9
  store double %714, ptr %19, align 8, !tbaa !9
  %715 = load ptr, ptr %44, align 8, !tbaa !5
  %716 = load double, ptr %18, align 8, !tbaa !9
  %717 = load double, ptr %18, align 8, !tbaa !9
  %718 = fmul double %716, %717
  %719 = load double, ptr %14, align 8, !tbaa !9
  %720 = fmul double %718, %719
  %721 = load double, ptr %12, align 8, !tbaa !9
  %722 = fdiv double %720, %721
  %723 = load ptr, ptr %45, align 8, !tbaa !5
  %724 = load ptr, ptr %45, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %715, double noundef %722, ptr noundef %723, ptr noundef %724)
  br label %725

725:                                              ; preds = %713, %701
  %726 = load double, ptr %19, align 8, !tbaa !9
  %727 = load double, ptr %13, align 8, !tbaa !9
  %728 = fdiv double %726, %727
  store double %728, ptr %18, align 8, !tbaa !9
  %729 = load double, ptr %18, align 8, !tbaa !9
  %730 = load double, ptr %18, align 8, !tbaa !9
  %731 = call double @llvm.fmuladd.f64(double %729, double %730, double 1.000000e+00)
  %732 = fcmp ole double %731, 0.000000e+00
  br i1 %732, label %733, label %734

733:                                              ; preds = %725
  br label %739

734:                                              ; preds = %725
  %735 = load double, ptr %18, align 8, !tbaa !9
  %736 = load double, ptr %18, align 8, !tbaa !9
  %737 = call double @llvm.fmuladd.f64(double %735, double %736, double 1.000000e+00)
  %738 = call double @sqrt(double noundef %737) #5
  br label %739

739:                                              ; preds = %734, %733
  %740 = phi double [ 0.000000e+00, %733 ], [ %738, %734 ]
  %741 = fdiv double 1.000000e+00, %740
  store double %741, ptr %16, align 8, !tbaa !9
  %742 = load double, ptr %13, align 8, !tbaa !9
  %743 = load double, ptr %18, align 8, !tbaa !9
  %744 = fmul double %742, %743
  %745 = load double, ptr %16, align 8, !tbaa !9
  %746 = fmul double %744, %745
  store double %746, ptr %13, align 8, !tbaa !9
  %747 = load double, ptr %16, align 8, !tbaa !9
  %748 = load double, ptr %16, align 8, !tbaa !9
  %749 = fmul double %747, %748
  %750 = load double, ptr %12, align 8, !tbaa !9
  %751 = fmul double %749, %750
  store double %751, ptr %14, align 8, !tbaa !9
  %752 = load i32, ptr %31, align 4, !tbaa !16
  %753 = icmp eq i32 %752, 0
  br i1 %753, label %754, label %765

754:                                              ; preds = %739
  %755 = load i32, ptr %32, align 4, !tbaa !16
  %756 = icmp eq i32 %755, 0
  br i1 %756, label %757, label %765

757:                                              ; preds = %754
  %758 = load ptr, ptr %30, align 8, !tbaa !5
  %759 = load i32, ptr %758, align 4, !tbaa !16
  %760 = icmp ne i32 %759, 0
  br i1 %760, label %761, label %765

761:                                              ; preds = %757
  %762 = load double, ptr %14, align 8, !tbaa !9
  %763 = load ptr, ptr %45, align 8, !tbaa !5
  %764 = load ptr, ptr %9, align 8, !tbaa !5
  call void @N_VScale(double noundef %762, ptr noundef %763, ptr noundef %764)
  br label %770

765:                                              ; preds = %757, %754, %739
  %766 = load ptr, ptr %9, align 8, !tbaa !5
  %767 = load double, ptr %14, align 8, !tbaa !9
  %768 = load ptr, ptr %45, align 8, !tbaa !5
  %769 = load ptr, ptr %9, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %766, double noundef %767, ptr noundef %768, ptr noundef %769)
  br label %770

770:                                              ; preds = %765, %761
  %771 = load double, ptr %13, align 8, !tbaa !9
  %772 = load i32, ptr %32, align 4, !tbaa !16
  %773 = add nsw i32 %772, 1
  %774 = sitofp i32 %773 to double
  %775 = fcmp ole double %774, 0.000000e+00
  br i1 %775, label %776, label %777

776:                                              ; preds = %770
  br label %782

777:                                              ; preds = %770
  %778 = load i32, ptr %32, align 4, !tbaa !16
  %779 = add nsw i32 %778, 1
  %780 = sitofp i32 %779 to double
  %781 = call double @sqrt(double noundef %780) #5
  br label %782

782:                                              ; preds = %777, %776
  %783 = phi double [ 0.000000e+00, %776 ], [ %781, %777 ]
  %784 = fmul double %771, %783
  store double %784, ptr %22, align 8, !tbaa !9
  %785 = load ptr, ptr %39, align 8, !tbaa !5
  store double %784, ptr %785, align 8, !tbaa !9
  %786 = load double, ptr %22, align 8, !tbaa !9
  %787 = load double, ptr %11, align 8, !tbaa !9
  %788 = fcmp ole double %786, %787
  br i1 %788, label %789, label %790

789:                                              ; preds = %782
  store i32 1, ptr %28, align 4, !tbaa !16
  br label %977

790:                                              ; preds = %782
  %791 = load double, ptr %22, align 8, !tbaa !9
  %792 = load double, ptr %11, align 8, !tbaa !9
  %793 = fcmp ogt double %791, %792
  br i1 %793, label %805, label %794

794:                                              ; preds = %790
  %795 = load double, ptr %22, align 8, !tbaa !9
  %796 = load double, ptr %21, align 8, !tbaa !9
  %797 = fcmp oge double %795, %796
  br i1 %797, label %798, label %973

798:                                              ; preds = %794
  %799 = load i32, ptr %32, align 4, !tbaa !16
  %800 = icmp eq i32 %799, 1
  br i1 %800, label %801, label %973

801:                                              ; preds = %798
  %802 = load i32, ptr %31, align 4, !tbaa !16
  %803 = load i32, ptr %34, align 4, !tbaa !16
  %804 = icmp eq i32 %802, %803
  br i1 %804, label %805, label %973

805:                                              ; preds = %801, %790
  %806 = load i32, ptr %26, align 4, !tbaa !16
  %807 = icmp ne i32 %806, 0
  br i1 %807, label %808, label %812

808:                                              ; preds = %805
  %809 = load ptr, ptr %9, align 8, !tbaa !5
  %810 = load ptr, ptr %41, align 8, !tbaa !5
  %811 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VDiv(ptr noundef %809, ptr noundef %810, ptr noundef %811)
  br label %815

812:                                              ; preds = %805
  %813 = load ptr, ptr %9, align 8, !tbaa !5
  %814 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %813, ptr noundef %814)
  br label %815

815:                                              ; preds = %812, %808
  %816 = load i32, ptr %25, align 4, !tbaa !16
  %817 = icmp ne i32 %816, 0
  br i1 %817, label %818, label %845

818:                                              ; preds = %815
  %819 = load ptr, ptr %38, align 8, !tbaa !5
  %820 = load ptr, ptr %36, align 8, !tbaa !5
  %821 = load ptr, ptr %50, align 8, !tbaa !5
  %822 = load ptr, ptr %51, align 8, !tbaa !5
  %823 = load double, ptr %11, align 8, !tbaa !9
  %824 = call i32 %819(ptr noundef %820, ptr noundef %821, ptr noundef %822, double noundef %823, i32 noundef 2)
  store i32 %824, ptr %33, align 4, !tbaa !16
  %825 = load i32, ptr %33, align 4, !tbaa !16
  %826 = icmp ne i32 %825, 0
  br i1 %826, label %827, label %842

827:                                              ; preds = %818
  %828 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %828, align 4, !tbaa !16
  %829 = load i32, ptr %33, align 4, !tbaa !16
  %830 = icmp slt i32 %829, 0
  %831 = zext i1 %830 to i64
  %832 = select i1 %830, i32 -808, i32 -808
  %833 = load ptr, ptr %7, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %833, i32 0, i32 0
  %835 = load ptr, ptr %834, align 8, !tbaa !11
  %836 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %835, i32 0, i32 5
  store i32 %832, ptr %836, align 8, !tbaa !34
  %837 = load ptr, ptr %7, align 8, !tbaa !5
  %838 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %837, i32 0, i32 0
  %839 = load ptr, ptr %838, align 8, !tbaa !11
  %840 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %839, i32 0, i32 5
  %841 = load i32, ptr %840, align 8, !tbaa !34
  store i32 %841, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

842:                                              ; preds = %818
  %843 = load ptr, ptr %51, align 8, !tbaa !5
  %844 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %843, ptr noundef %844)
  br label %845

845:                                              ; preds = %842, %815
  %846 = load ptr, ptr %37, align 8, !tbaa !5
  %847 = load ptr, ptr %35, align 8, !tbaa !5
  %848 = load ptr, ptr %50, align 8, !tbaa !5
  %849 = load ptr, ptr %51, align 8, !tbaa !5
  %850 = call i32 %846(ptr noundef %847, ptr noundef %848, ptr noundef %849)
  store i32 %850, ptr %33, align 4, !tbaa !16
  %851 = load i32, ptr %33, align 4, !tbaa !16
  %852 = icmp ne i32 %851, 0
  br i1 %852, label %853, label %868

853:                                              ; preds = %845
  %854 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %854, align 4, !tbaa !16
  %855 = load i32, ptr %33, align 4, !tbaa !16
  %856 = icmp slt i32 %855, 0
  %857 = zext i1 %856 to i64
  %858 = select i1 %856, i32 -805, i32 803
  %859 = load ptr, ptr %7, align 8, !tbaa !5
  %860 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %859, i32 0, i32 0
  %861 = load ptr, ptr %860, align 8, !tbaa !11
  %862 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %861, i32 0, i32 5
  store i32 %858, ptr %862, align 8, !tbaa !34
  %863 = load ptr, ptr %7, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %863, i32 0, i32 0
  %865 = load ptr, ptr %864, align 8, !tbaa !11
  %866 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %865, i32 0, i32 5
  %867 = load i32, ptr %866, align 8, !tbaa !34
  store i32 %867, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

868:                                              ; preds = %845
  %869 = load i32, ptr %24, align 4, !tbaa !16
  %870 = icmp ne i32 %869, 0
  br i1 %870, label %871, label %896

871:                                              ; preds = %868
  %872 = load ptr, ptr %38, align 8, !tbaa !5
  %873 = load ptr, ptr %36, align 8, !tbaa !5
  %874 = load ptr, ptr %51, align 8, !tbaa !5
  %875 = load ptr, ptr %50, align 8, !tbaa !5
  %876 = load double, ptr %11, align 8, !tbaa !9
  %877 = call i32 %872(ptr noundef %873, ptr noundef %874, ptr noundef %875, double noundef %876, i32 noundef 1)
  store i32 %877, ptr %33, align 4, !tbaa !16
  %878 = load i32, ptr %33, align 4, !tbaa !16
  %879 = icmp ne i32 %878, 0
  br i1 %879, label %880, label %895

880:                                              ; preds = %871
  %881 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %881, align 4, !tbaa !16
  %882 = load i32, ptr %33, align 4, !tbaa !16
  %883 = icmp slt i32 %882, 0
  %884 = zext i1 %883 to i64
  %885 = select i1 %883, i32 -808, i32 805
  %886 = load ptr, ptr %7, align 8, !tbaa !5
  %887 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %886, i32 0, i32 0
  %888 = load ptr, ptr %887, align 8, !tbaa !11
  %889 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %888, i32 0, i32 5
  store i32 %885, ptr %889, align 8, !tbaa !34
  %890 = load ptr, ptr %7, align 8, !tbaa !5
  %891 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %890, i32 0, i32 0
  %892 = load ptr, ptr %891, align 8, !tbaa !11
  %893 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %892, i32 0, i32 5
  %894 = load i32, ptr %893, align 8, !tbaa !34
  store i32 %894, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

895:                                              ; preds = %871
  br label %899

896:                                              ; preds = %868
  %897 = load ptr, ptr %51, align 8, !tbaa !5
  %898 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %897, ptr noundef %898)
  br label %899

899:                                              ; preds = %896, %895
  %900 = load i32, ptr %27, align 4, !tbaa !16
  %901 = icmp ne i32 %900, 0
  br i1 %901, label %902, label %906

902:                                              ; preds = %899
  %903 = load ptr, ptr %42, align 8, !tbaa !5
  %904 = load ptr, ptr %50, align 8, !tbaa !5
  %905 = load ptr, ptr %51, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %903, ptr noundef %904, ptr noundef %905)
  br label %909

906:                                              ; preds = %899
  %907 = load ptr, ptr %50, align 8, !tbaa !5
  %908 = load ptr, ptr %51, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %907, ptr noundef %908)
  br label %909

909:                                              ; preds = %906, %902
  %910 = load i32, ptr %29, align 4, !tbaa !16
  %911 = icmp ne i32 %910, 0
  br i1 %911, label %951, label %912

912:                                              ; preds = %909
  store i32 1, ptr %29, align 4, !tbaa !16
  %913 = load i32, ptr %24, align 4, !tbaa !16
  %914 = icmp ne i32 %913, 0
  br i1 %914, label %915, label %940

915:                                              ; preds = %912
  %916 = load ptr, ptr %38, align 8, !tbaa !5
  %917 = load ptr, ptr %36, align 8, !tbaa !5
  %918 = load ptr, ptr %10, align 8, !tbaa !5
  %919 = load ptr, ptr %52, align 8, !tbaa !5
  %920 = load double, ptr %11, align 8, !tbaa !9
  %921 = call i32 %916(ptr noundef %917, ptr noundef %918, ptr noundef %919, double noundef %920, i32 noundef 1)
  store i32 %921, ptr %33, align 4, !tbaa !16
  %922 = load i32, ptr %33, align 4, !tbaa !16
  %923 = icmp ne i32 %922, 0
  br i1 %923, label %924, label %939

924:                                              ; preds = %915
  %925 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %925, align 4, !tbaa !16
  %926 = load i32, ptr %33, align 4, !tbaa !16
  %927 = icmp slt i32 %926, 0
  %928 = zext i1 %927 to i64
  %929 = select i1 %927, i32 -808, i32 805
  %930 = load ptr, ptr %7, align 8, !tbaa !5
  %931 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %930, i32 0, i32 0
  %932 = load ptr, ptr %931, align 8, !tbaa !11
  %933 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %932, i32 0, i32 5
  store i32 %929, ptr %933, align 8, !tbaa !34
  %934 = load ptr, ptr %7, align 8, !tbaa !5
  %935 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %934, i32 0, i32 0
  %936 = load ptr, ptr %935, align 8, !tbaa !11
  %937 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %936, i32 0, i32 5
  %938 = load i32, ptr %937, align 8, !tbaa !34
  store i32 %938, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

939:                                              ; preds = %915
  br label %943

940:                                              ; preds = %912
  %941 = load ptr, ptr %10, align 8, !tbaa !5
  %942 = load ptr, ptr %52, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %941, ptr noundef %942)
  br label %943

943:                                              ; preds = %940, %939
  %944 = load i32, ptr %27, align 4, !tbaa !16
  %945 = icmp ne i32 %944, 0
  br i1 %945, label %946, label %950

946:                                              ; preds = %943
  %947 = load ptr, ptr %42, align 8, !tbaa !5
  %948 = load ptr, ptr %52, align 8, !tbaa !5
  %949 = load ptr, ptr %52, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %947, ptr noundef %948, ptr noundef %949)
  br label %950

950:                                              ; preds = %946, %943
  br label %951

951:                                              ; preds = %950, %909
  %952 = load ptr, ptr %52, align 8, !tbaa !5
  %953 = load ptr, ptr %51, align 8, !tbaa !5
  %954 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %952, double noundef -1.000000e+00, ptr noundef %953, ptr noundef %954)
  %955 = load ptr, ptr %50, align 8, !tbaa !5
  %956 = load ptr, ptr %50, align 8, !tbaa !5
  %957 = call double @N_VDotProd(ptr noundef %955, ptr noundef %956)
  %958 = fcmp ole double %957, 0.000000e+00
  br i1 %958, label %959, label %960

959:                                              ; preds = %951
  br label %965

960:                                              ; preds = %951
  %961 = load ptr, ptr %50, align 8, !tbaa !5
  %962 = load ptr, ptr %50, align 8, !tbaa !5
  %963 = call double @N_VDotProd(ptr noundef %961, ptr noundef %962)
  %964 = call double @sqrt(double noundef %963) #5
  br label %965

965:                                              ; preds = %960, %959
  %966 = phi double [ 0.000000e+00, %959 ], [ %964, %960 ]
  store double %966, ptr %22, align 8, !tbaa !9
  %967 = load ptr, ptr %39, align 8, !tbaa !5
  store double %966, ptr %967, align 8, !tbaa !9
  %968 = load double, ptr %22, align 8, !tbaa !9
  %969 = load double, ptr %11, align 8, !tbaa !9
  %970 = fcmp ole double %968, %969
  br i1 %970, label %971, label %972

971:                                              ; preds = %965
  store i32 1, ptr %28, align 4, !tbaa !16
  br label %977

972:                                              ; preds = %965
  br label %973

973:                                              ; preds = %972, %801, %798, %794
  br label %974

974:                                              ; preds = %973
  %975 = load i32, ptr %32, align 4, !tbaa !16
  %976 = add nsw i32 %975, 1
  store i32 %976, ptr %32, align 4, !tbaa !16
  br label %626, !llvm.loop !35

977:                                              ; preds = %971, %789, %626
  %978 = load i32, ptr %28, align 4, !tbaa !16
  %979 = icmp eq i32 %978, 1
  br i1 %979, label %980, label %981

980:                                              ; preds = %977
  br label %1141

981:                                              ; preds = %977
  %982 = load ptr, ptr %43, align 8, !tbaa !5
  %983 = load ptr, ptr %48, align 8, !tbaa !5
  %984 = getelementptr inbounds ptr, ptr %983, i64 1
  %985 = load ptr, ptr %984, align 8, !tbaa !5
  %986 = call double @N_VDotProd(ptr noundef %982, ptr noundef %985)
  %987 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 1
  store double %986, ptr %987, align 8, !tbaa !9
  %988 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 1
  %989 = load double, ptr %988, align 8, !tbaa !9
  %990 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  %991 = load double, ptr %990, align 16, !tbaa !9
  %992 = fdiv double %989, %991
  store double %992, ptr %15, align 8, !tbaa !9
  %993 = load ptr, ptr %48, align 8, !tbaa !5
  %994 = getelementptr inbounds ptr, ptr %993, i64 1
  %995 = load ptr, ptr %994, align 8, !tbaa !5
  %996 = load double, ptr %15, align 8, !tbaa !9
  %997 = load ptr, ptr %44, align 8, !tbaa !5
  %998 = load ptr, ptr %49, align 8, !tbaa !5
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %995, double noundef %996, ptr noundef %997, ptr noundef %998)
  %999 = load double, ptr %15, align 8, !tbaa !9
  %1000 = load double, ptr %15, align 8, !tbaa !9
  %1001 = fmul double %999, %1000
  %1002 = getelementptr inbounds [3 x double], ptr %53, i64 0, i64 0
  store double %1001, ptr %1002, align 16, !tbaa !9
  %1003 = load ptr, ptr %47, align 8, !tbaa !5
  %1004 = getelementptr inbounds [3 x ptr], ptr %54, i64 0, i64 0
  store ptr %1003, ptr %1004, align 16, !tbaa !5
  %1005 = load double, ptr %15, align 8, !tbaa !9
  %1006 = getelementptr inbounds [3 x double], ptr %53, i64 0, i64 1
  store double %1005, ptr %1006, align 8, !tbaa !9
  %1007 = load ptr, ptr %44, align 8, !tbaa !5
  %1008 = getelementptr inbounds [3 x ptr], ptr %54, i64 0, i64 1
  store ptr %1007, ptr %1008, align 8, !tbaa !5
  %1009 = getelementptr inbounds [3 x double], ptr %53, i64 0, i64 2
  store double 1.000000e+00, ptr %1009, align 16, !tbaa !9
  %1010 = load ptr, ptr %49, align 8, !tbaa !5
  %1011 = getelementptr inbounds [3 x ptr], ptr %54, i64 0, i64 2
  store ptr %1010, ptr %1011, align 16, !tbaa !5
  %1012 = getelementptr inbounds [3 x double], ptr %53, i64 0, i64 0
  %1013 = getelementptr inbounds [3 x ptr], ptr %54, i64 0, i64 0
  %1014 = load ptr, ptr %47, align 8, !tbaa !5
  %1015 = call i32 @N_VLinearCombination(i32 noundef 3, ptr noundef %1012, ptr noundef %1013, ptr noundef %1014)
  store i32 %1015, ptr %33, align 4, !tbaa !16
  %1016 = load i32, ptr %33, align 4, !tbaa !16
  %1017 = icmp ne i32 %1016, 0
  br i1 %1017, label %1018, label %1024

1018:                                             ; preds = %981
  %1019 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1019, align 4, !tbaa !16
  %1020 = load ptr, ptr %7, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1020, i32 0, i32 0
  %1022 = load ptr, ptr %1021, align 8, !tbaa !11
  %1023 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1022, i32 0, i32 5
  store i32 -812, ptr %1023, align 8, !tbaa !34
  store i32 -812, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1024:                                             ; preds = %981
  %1025 = load i32, ptr %26, align 4, !tbaa !16
  %1026 = icmp ne i32 %1025, 0
  br i1 %1026, label %1027, label %1031

1027:                                             ; preds = %1024
  %1028 = load ptr, ptr %47, align 8, !tbaa !5
  %1029 = load ptr, ptr %41, align 8, !tbaa !5
  %1030 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VDiv(ptr noundef %1028, ptr noundef %1029, ptr noundef %1030)
  br label %1034

1031:                                             ; preds = %1024
  %1032 = load ptr, ptr %47, align 8, !tbaa !5
  %1033 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1032, ptr noundef %1033)
  br label %1034

1034:                                             ; preds = %1031, %1027
  %1035 = load i32, ptr %25, align 4, !tbaa !16
  %1036 = icmp ne i32 %1035, 0
  br i1 %1036, label %1037, label %1064

1037:                                             ; preds = %1034
  %1038 = load ptr, ptr %50, align 8, !tbaa !5
  %1039 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1038, ptr noundef %1039)
  %1040 = load ptr, ptr %38, align 8, !tbaa !5
  %1041 = load ptr, ptr %36, align 8, !tbaa !5
  %1042 = load ptr, ptr %46, align 8, !tbaa !5
  %1043 = load ptr, ptr %50, align 8, !tbaa !5
  %1044 = load double, ptr %11, align 8, !tbaa !9
  %1045 = call i32 %1040(ptr noundef %1041, ptr noundef %1042, ptr noundef %1043, double noundef %1044, i32 noundef 2)
  store i32 %1045, ptr %33, align 4, !tbaa !16
  %1046 = load i32, ptr %33, align 4, !tbaa !16
  %1047 = icmp ne i32 %1046, 0
  br i1 %1047, label %1048, label %1063

1048:                                             ; preds = %1037
  %1049 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1049, align 4, !tbaa !16
  %1050 = load i32, ptr %33, align 4, !tbaa !16
  %1051 = icmp slt i32 %1050, 0
  %1052 = zext i1 %1051 to i64
  %1053 = select i1 %1051, i32 -808, i32 805
  %1054 = load ptr, ptr %7, align 8, !tbaa !5
  %1055 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1054, i32 0, i32 0
  %1056 = load ptr, ptr %1055, align 8, !tbaa !11
  %1057 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1056, i32 0, i32 5
  store i32 %1053, ptr %1057, align 8, !tbaa !34
  %1058 = load ptr, ptr %7, align 8, !tbaa !5
  %1059 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1058, i32 0, i32 0
  %1060 = load ptr, ptr %1059, align 8, !tbaa !11
  %1061 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1060, i32 0, i32 5
  %1062 = load i32, ptr %1061, align 8, !tbaa !34
  store i32 %1062, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1063:                                             ; preds = %1037
  br label %1064

1064:                                             ; preds = %1063, %1034
  %1065 = load ptr, ptr %37, align 8, !tbaa !5
  %1066 = load ptr, ptr %35, align 8, !tbaa !5
  %1067 = load ptr, ptr %50, align 8, !tbaa !5
  %1068 = load ptr, ptr %46, align 8, !tbaa !5
  %1069 = call i32 %1065(ptr noundef %1066, ptr noundef %1067, ptr noundef %1068)
  store i32 %1069, ptr %33, align 4, !tbaa !16
  %1070 = load i32, ptr %33, align 4, !tbaa !16
  %1071 = icmp ne i32 %1070, 0
  br i1 %1071, label %1072, label %1087

1072:                                             ; preds = %1064
  %1073 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1073, align 4, !tbaa !16
  %1074 = load i32, ptr %33, align 4, !tbaa !16
  %1075 = icmp slt i32 %1074, 0
  %1076 = zext i1 %1075 to i64
  %1077 = select i1 %1075, i32 -805, i32 803
  %1078 = load ptr, ptr %7, align 8, !tbaa !5
  %1079 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1078, i32 0, i32 0
  %1080 = load ptr, ptr %1079, align 8, !tbaa !11
  %1081 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1080, i32 0, i32 5
  store i32 %1077, ptr %1081, align 8, !tbaa !34
  %1082 = load ptr, ptr %7, align 8, !tbaa !5
  %1083 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1082, i32 0, i32 0
  %1084 = load ptr, ptr %1083, align 8, !tbaa !11
  %1085 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1084, i32 0, i32 5
  %1086 = load i32, ptr %1085, align 8, !tbaa !34
  store i32 %1086, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1087:                                             ; preds = %1064
  %1088 = load i32, ptr %24, align 4, !tbaa !16
  %1089 = icmp ne i32 %1088, 0
  br i1 %1089, label %1090, label %1115

1090:                                             ; preds = %1087
  %1091 = load ptr, ptr %38, align 8, !tbaa !5
  %1092 = load ptr, ptr %36, align 8, !tbaa !5
  %1093 = load ptr, ptr %46, align 8, !tbaa !5
  %1094 = load ptr, ptr %50, align 8, !tbaa !5
  %1095 = load double, ptr %11, align 8, !tbaa !9
  %1096 = call i32 %1091(ptr noundef %1092, ptr noundef %1093, ptr noundef %1094, double noundef %1095, i32 noundef 1)
  store i32 %1096, ptr %33, align 4, !tbaa !16
  %1097 = load i32, ptr %33, align 4, !tbaa !16
  %1098 = icmp ne i32 %1097, 0
  br i1 %1098, label %1099, label %1114

1099:                                             ; preds = %1090
  %1100 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1100, align 4, !tbaa !16
  %1101 = load i32, ptr %33, align 4, !tbaa !16
  %1102 = icmp slt i32 %1101, 0
  %1103 = zext i1 %1102 to i64
  %1104 = select i1 %1102, i32 -808, i32 805
  %1105 = load ptr, ptr %7, align 8, !tbaa !5
  %1106 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1105, i32 0, i32 0
  %1107 = load ptr, ptr %1106, align 8, !tbaa !11
  %1108 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1107, i32 0, i32 5
  store i32 %1104, ptr %1108, align 8, !tbaa !34
  %1109 = load ptr, ptr %7, align 8, !tbaa !5
  %1110 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1109, i32 0, i32 0
  %1111 = load ptr, ptr %1110, align 8, !tbaa !11
  %1112 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1111, i32 0, i32 5
  %1113 = load i32, ptr %1112, align 8, !tbaa !34
  store i32 %1113, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1114:                                             ; preds = %1090
  br label %1118

1115:                                             ; preds = %1087
  %1116 = load ptr, ptr %46, align 8, !tbaa !5
  %1117 = load ptr, ptr %50, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1116, ptr noundef %1117)
  br label %1118

1118:                                             ; preds = %1115, %1114
  %1119 = load i32, ptr %27, align 4, !tbaa !16
  %1120 = icmp ne i32 %1119, 0
  br i1 %1120, label %1121, label %1125

1121:                                             ; preds = %1118
  %1122 = load ptr, ptr %42, align 8, !tbaa !5
  %1123 = load ptr, ptr %50, align 8, !tbaa !5
  %1124 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VProd(ptr noundef %1122, ptr noundef %1123, ptr noundef %1124)
  br label %1128

1125:                                             ; preds = %1118
  %1126 = load ptr, ptr %50, align 8, !tbaa !5
  %1127 = load ptr, ptr %46, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1126, ptr noundef %1127)
  br label %1128

1128:                                             ; preds = %1125, %1121
  %1129 = load ptr, ptr %48, align 8, !tbaa !5
  %1130 = getelementptr inbounds ptr, ptr %1129, i64 1
  %1131 = load ptr, ptr %1130, align 8, !tbaa !5
  %1132 = load ptr, ptr %48, align 8, !tbaa !5
  %1133 = getelementptr inbounds ptr, ptr %1132, i64 0
  %1134 = load ptr, ptr %1133, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1131, ptr noundef %1134)
  %1135 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 1
  %1136 = load double, ptr %1135, align 8, !tbaa !9
  %1137 = getelementptr inbounds [2 x double], ptr %20, i64 0, i64 0
  store double %1136, ptr %1137, align 16, !tbaa !9
  br label %1138

1138:                                             ; preds = %1128
  %1139 = load i32, ptr %31, align 4, !tbaa !16
  %1140 = add nsw i32 %1139, 1
  store i32 %1140, ptr %31, align 4, !tbaa !16
  br label %473, !llvm.loop !37

1141:                                             ; preds = %980, %473
  %1142 = load i32, ptr %28, align 4, !tbaa !16
  %1143 = icmp eq i32 %1142, 1
  br i1 %1143, label %1148, label %1144

1144:                                             ; preds = %1141
  %1145 = load double, ptr %22, align 8, !tbaa !9
  %1146 = load double, ptr %21, align 8, !tbaa !9
  %1147 = fcmp olt double %1145, %1146
  br i1 %1147, label %1148, label %1205

1148:                                             ; preds = %1144, %1141
  %1149 = load i32, ptr %26, align 4, !tbaa !16
  %1150 = icmp ne i32 %1149, 0
  br i1 %1150, label %1151, label %1155

1151:                                             ; preds = %1148
  %1152 = load ptr, ptr %9, align 8, !tbaa !5
  %1153 = load ptr, ptr %41, align 8, !tbaa !5
  %1154 = load ptr, ptr %9, align 8, !tbaa !5
  call void @N_VDiv(ptr noundef %1152, ptr noundef %1153, ptr noundef %1154)
  br label %1155

1155:                                             ; preds = %1151, %1148
  %1156 = load i32, ptr %25, align 4, !tbaa !16
  %1157 = icmp ne i32 %1156, 0
  br i1 %1157, label %1158, label %1185

1158:                                             ; preds = %1155
  %1159 = load ptr, ptr %38, align 8, !tbaa !5
  %1160 = load ptr, ptr %36, align 8, !tbaa !5
  %1161 = load ptr, ptr %9, align 8, !tbaa !5
  %1162 = load ptr, ptr %50, align 8, !tbaa !5
  %1163 = load double, ptr %11, align 8, !tbaa !9
  %1164 = call i32 %1159(ptr noundef %1160, ptr noundef %1161, ptr noundef %1162, double noundef %1163, i32 noundef 2)
  store i32 %1164, ptr %33, align 4, !tbaa !16
  %1165 = load i32, ptr %33, align 4, !tbaa !16
  %1166 = icmp ne i32 %1165, 0
  br i1 %1166, label %1167, label %1182

1167:                                             ; preds = %1158
  %1168 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1168, align 4, !tbaa !16
  %1169 = load i32, ptr %33, align 4, !tbaa !16
  %1170 = icmp slt i32 %1169, 0
  %1171 = zext i1 %1170 to i64
  %1172 = select i1 %1170, i32 -808, i32 -808
  %1173 = load ptr, ptr %7, align 8, !tbaa !5
  %1174 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1173, i32 0, i32 0
  %1175 = load ptr, ptr %1174, align 8, !tbaa !11
  %1176 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1175, i32 0, i32 5
  store i32 %1172, ptr %1176, align 8, !tbaa !34
  %1177 = load ptr, ptr %7, align 8, !tbaa !5
  %1178 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1177, i32 0, i32 0
  %1179 = load ptr, ptr %1178, align 8, !tbaa !11
  %1180 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1179, i32 0, i32 5
  %1181 = load i32, ptr %1180, align 8, !tbaa !34
  store i32 %1181, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1182:                                             ; preds = %1158
  %1183 = load ptr, ptr %50, align 8, !tbaa !5
  %1184 = load ptr, ptr %9, align 8, !tbaa !5
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %1183, ptr noundef %1184)
  br label %1185

1185:                                             ; preds = %1182, %1155
  %1186 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1186, align 4, !tbaa !16
  %1187 = load i32, ptr %28, align 4, !tbaa !16
  %1188 = icmp eq i32 %1187, 1
  br i1 %1188, label %1189, label %1194

1189:                                             ; preds = %1185
  %1190 = load ptr, ptr %7, align 8, !tbaa !5
  %1191 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1190, i32 0, i32 0
  %1192 = load ptr, ptr %1191, align 8, !tbaa !11
  %1193 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1192, i32 0, i32 5
  store i32 0, ptr %1193, align 8, !tbaa !34
  br label %1199

1194:                                             ; preds = %1185
  %1195 = load ptr, ptr %7, align 8, !tbaa !5
  %1196 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1195, i32 0, i32 0
  %1197 = load ptr, ptr %1196, align 8, !tbaa !11
  %1198 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1197, i32 0, i32 5
  store i32 801, ptr %1198, align 8, !tbaa !34
  br label %1199

1199:                                             ; preds = %1194, %1189
  %1200 = load ptr, ptr %7, align 8, !tbaa !5
  %1201 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1200, i32 0, i32 0
  %1202 = load ptr, ptr %1201, align 8, !tbaa !11
  %1203 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1202, i32 0, i32 5
  %1204 = load i32, ptr %1203, align 8, !tbaa !34
  store i32 %1204, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1205:                                             ; preds = %1144
  %1206 = load ptr, ptr %30, align 8, !tbaa !5
  store i32 0, ptr %1206, align 4, !tbaa !16
  %1207 = load ptr, ptr %7, align 8, !tbaa !5
  %1208 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1207, i32 0, i32 0
  %1209 = load ptr, ptr %1208, align 8, !tbaa !11
  %1210 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1209, i32 0, i32 5
  store i32 802, ptr %1210, align 8, !tbaa !34
  %1211 = load ptr, ptr %7, align 8, !tbaa !5
  %1212 = getelementptr inbounds %struct._generic_SUNLinearSolver, ptr %1211, i32 0, i32 0
  %1213 = load ptr, ptr %1212, align 8, !tbaa !11
  %1214 = getelementptr inbounds %struct._SUNLinearSolverContent_SPTFQMR, ptr %1213, i32 0, i32 5
  %1215 = load i32, ptr %1214, align 8, !tbaa !34
  store i32 %1215, ptr %6, align 4
  store i32 1, ptr %55, align 4
  br label %1216

1216:                                             ; preds = %1205, %1199, %1167, %1099, %1072, %1048, %1018, %924, %880, %853, %827, %581, %552, %526, %422, %395, %371, %336, %288, %257, %231, %211, %202, %58
  call void @llvm.lifetime.end.p0(i64 24, ptr %54) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %53) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #5
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #5
  %1217 = load i32, ptr %6, align 4
  ret i32 %1217
}

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

declare void @N_VScale(double noundef, ptr noundef, ptr noundef) #2

declare void @N_VLinearSum(double noundef, ptr noundef, double noundef, ptr noundef, ptr noundef) #2

declare void @N_VProd(ptr noundef, ptr noundef, ptr noundef) #2

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

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

declare void @N_VDiv(ptr noundef, ptr noundef, ptr noundef) #2

declare void @N_VConst(double noundef, ptr noundef) #2

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

declare i32 @N_VLinearCombination(i32 noundef, ptr noundef, ptr noundef, ptr noundef) #2

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { 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, !6, i64 0}
!12 = !{!"_generic_SUNLinearSolver", !6, i64 0, !6, i64 8, !6, i64 16}
!13 = !{!14, !15, i64 0}
!14 = !{!"_SUNLinearSolverContent_SPTFQMR", !15, i64 0, !15, i64 4, !15, i64 8, !15, i64 12, !10, i64 16, !15, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !6, i64 104, !6, i64 112, !6, i64 120, !6, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !6, i64 160, !15, i64 168, !6, i64 176}
!15 = !{!"int", !7, i64 0}
!16 = !{!15, !15, i64 0}
!17 = !{!14, !6, i64 88}
!18 = !{!14, !6, i64 96}
!19 = !{!14, !6, i64 104}
!20 = !{!14, !6, i64 112}
!21 = !{!14, !6, i64 120}
!22 = !{!14, !6, i64 128}
!23 = !{!14, !6, i64 136}
!24 = !{!14, !6, i64 144}
!25 = !{!14, !6, i64 152}
!26 = !{!14, !6, i64 160}
!27 = !{!14, !6, i64 72}
!28 = !{!14, !6, i64 80}
!29 = !{!14, !6, i64 40}
!30 = !{!14, !6, i64 64}
!31 = !{!14, !6, i64 32}
!32 = !{!14, !6, i64 56}
!33 = !{!14, !15, i64 4}
!34 = !{!14, !15, i64 24}
!35 = distinct !{!35, !36}
!36 = !{!"llvm.loop.mustprogress"}
!37 = distinct !{!37, !36}


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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @SUNLinSolSolve_SPTFQMR(ptr noundef readonly %0, ptr nocapture noundef readnone %1, ptr noundef %2, ptr noundef %3, double noundef %4) local_unnamed_addr #1 {
  %6 = alloca [3 x double], align 16
  %7 = alloca [3 x ptr], align 16
  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %6) #6
  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %7) #6
  %8 = icmp eq ptr %0, null
  br i1 %8, label %361, label %9

9:                                                ; preds = %5
  %10 = load ptr, ptr %0, align 8, !tbaa !5
  %11 = load i32, ptr %10, align 8, !tbaa !10
  %12 = getelementptr inbounds i8, ptr %10, i64 88
  %13 = load ptr, ptr %12, align 8, !tbaa !14
  %14 = getelementptr inbounds i8, ptr %10, i64 96
  %15 = load ptr, ptr %14, align 8, !tbaa !15
  %16 = getelementptr inbounds i8, ptr %10, i64 104
  %17 = load ptr, ptr %16, align 8, !tbaa !16
  %18 = getelementptr inbounds i8, ptr %10, i64 112
  %19 = load ptr, ptr %18, align 8, !tbaa !17
  %20 = getelementptr inbounds i8, ptr %10, i64 120
  %21 = load ptr, ptr %20, align 8, !tbaa !18
  %22 = getelementptr inbounds i8, ptr %10, i64 128
  %23 = load ptr, ptr %22, align 8, !tbaa !19
  %24 = getelementptr inbounds i8, ptr %10, i64 136
  %25 = load ptr, ptr %24, align 8, !tbaa !20
  %26 = getelementptr inbounds i8, ptr %10, i64 144
  %27 = load ptr, ptr %26, align 8, !tbaa !21
  %28 = getelementptr inbounds i8, ptr %10, i64 152
  %29 = load ptr, ptr %28, align 8, !tbaa !22
  %30 = getelementptr inbounds i8, ptr %10, i64 160
  %31 = load ptr, ptr %30, align 8, !tbaa !23
  %32 = getelementptr inbounds i8, ptr %10, i64 72
  %33 = load ptr, ptr %32, align 8, !tbaa !24
  %34 = getelementptr inbounds i8, ptr %10, i64 80
  %35 = load ptr, ptr %34, align 8, !tbaa !25
  %36 = getelementptr inbounds i8, ptr %10, i64 40
  %37 = load ptr, ptr %36, align 8, !tbaa !26
  %38 = getelementptr inbounds i8, ptr %10, i64 64
  %39 = load ptr, ptr %38, align 8, !tbaa !27
  %40 = getelementptr inbounds i8, ptr %10, i64 32
  %41 = load ptr, ptr %40, align 8, !tbaa !28
  %42 = getelementptr inbounds i8, ptr %10, i64 56
  %43 = load ptr, ptr %42, align 8, !tbaa !29
  %44 = getelementptr inbounds i8, ptr %10, i64 8
  %45 = getelementptr inbounds i8, ptr %10, i64 12
  %46 = getelementptr inbounds i8, ptr %10, i64 16
  store i32 0, ptr %45, align 4, !tbaa !30
  %47 = getelementptr inbounds i8, ptr %10, i64 4
  %48 = load i32, ptr %47, align 4, !tbaa !31
  %49 = and i32 %48, -3
  %spec.select = icmp eq i32 %49, 1
  %50 = and i32 %48, -2
  %51 = icmp eq i32 %50, 2
  %.not = icmp eq ptr %35, null
  %.not520 = icmp eq ptr %33, null
  br i1 %51, label %52, label %56

52:                                               ; preds = %9
  %53 = load i32, ptr %44, align 4, !tbaa !30
  %.not521 = icmp eq i32 %53, 0
  br i1 %.not521, label %54, label %56

54:                                               ; preds = %52
  %55 = getelementptr inbounds i8, ptr %10, i64 24
  store i32 -802, ptr %55, align 8, !tbaa !32
  br label %361

56:                                               ; preds = %9, %52
  %57 = icmp eq ptr %41, null
  br i1 %57, label %58, label %60

58:                                               ; preds = %56
  store i32 0, ptr %44, align 4, !tbaa !30
  %59 = getelementptr inbounds i8, ptr %10, i64 24
  store i32 -804, ptr %59, align 8, !tbaa !32
  br label %361

60:                                               ; preds = %56
  %or.cond = or i1 %spec.select, %51
  %61 = icmp eq ptr %43, null
  %or.cond3 = select i1 %or.cond, i1 %61, i1 false
  br i1 %or.cond3, label %62, label %64

62:                                               ; preds = %60
  store i32 0, ptr %44, align 4, !tbaa !30
  %63 = getelementptr inbounds i8, ptr %10, i64 24
  store i32 -807, ptr %63, align 8, !tbaa !32
  br label %361

64:                                               ; preds = %60
  %65 = load i32, ptr %44, align 4, !tbaa !30
  %.not522 = icmp eq i32 %65, 0
  br i1 %.not522, label %67, label %66

66:                                               ; preds = %64
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %3, ptr noundef %13) #6
  br label %75

67:                                               ; preds = %64
  %68 = tail call i32 %41(ptr noundef %37, ptr noundef %2, ptr noundef %13) #6
  %.not523 = icmp eq i32 %68, 0
  br i1 %.not523, label %74, label %69

69:                                               ; preds = %67
  store i32 0, ptr %44, align 4, !tbaa !30
  %70 = icmp slt i32 %68, 0
  %71 = select i1 %70, i32 -805, i32 803
  %72 = load ptr, ptr %0, align 8, !tbaa !5
  %73 = getelementptr inbounds i8, ptr %72, i64 24
  store i32 %71, ptr %73, align 8, !tbaa !32
  br label %361

74:                                               ; preds = %67
  tail call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %3, double noundef -1.000000e+00, ptr noundef %13, ptr noundef %13) #6
  br label %75

75:                                               ; preds = %74, %66
  switch i32 %48, label %83 [
    i32 3, label %76
    i32 1, label %76
  ]

76:                                               ; preds = %75, %75
  %77 = tail call i32 %43(ptr noundef %39, ptr noundef %13, ptr noundef %27, double noundef %4, i32 noundef 1) #6
  %.not524 = icmp eq i32 %77, 0
  br i1 %.not524, label %84, label %78

78:                                               ; preds = %76
  store i32 0, ptr %44, align 4, !tbaa !30
  %79 = icmp slt i32 %77, 0
  %80 = select i1 %79, i32 -808, i32 805
  %81 = load ptr, ptr %0, align 8, !tbaa !5
  %82 = getelementptr inbounds i8, ptr %81, i64 24
  store i32 %80, ptr %82, align 8, !tbaa !32
  br label %361

83:                                               ; preds = %75
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %13, ptr noundef %27) #6
  br label %84

84:                                               ; preds = %76, %83
  br i1 %.not520, label %86, label %85

85:                                               ; preds = %84
  tail call void @N_VProd(ptr noundef nonnull %33, ptr noundef %27, ptr noundef %13) #6
  br label %87

86:                                               ; preds = %84
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %13) #6
  br label %87

87:                                               ; preds = %86, %85
  %88 = tail call double @N_VDotProd(ptr noundef %13, ptr noundef %13) #6
  %89 = fcmp ugt double %88, 0.000000e+00
  br i1 %89, label %90, label %92

90:                                               ; preds = %87
  %91 = tail call double @sqrt(double noundef %88) #6
  br label %92

92:                                               ; preds = %87, %90
  %93 = phi double [ %91, %90 ], [ 0.000000e+00, %87 ]
  store double %93, ptr %46, align 8, !tbaa !33
  %94 = fcmp ugt double %93, %4
  br i1 %94, label %98, label %95

95:                                               ; preds = %92
  store i32 0, ptr %44, align 4, !tbaa !30
  %96 = load ptr, ptr %0, align 8, !tbaa !5
  %97 = getelementptr inbounds i8, ptr %96, i64 24
  store i32 0, ptr %97, align 8, !tbaa !32
  br label %361

98:                                               ; preds = %92
  br i1 %.not, label %100, label %99

99:                                               ; preds = %98
  tail call void @N_VDiv(ptr noundef %13, ptr noundef nonnull %35, ptr noundef %27) #6
  br label %101

100:                                              ; preds = %98
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %13, ptr noundef %27) #6
  br label %101

101:                                              ; preds = %100, %99
  br i1 %51, label %102, label %109

102:                                              ; preds = %101
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %19) #6
  %103 = tail call i32 %43(ptr noundef %39, ptr noundef %19, ptr noundef %27, double noundef %4, i32 noundef 2) #6
  %.not525 = icmp eq i32 %103, 0
  br i1 %.not525, label %109, label %104

104:                                              ; preds = %102
  store i32 0, ptr %44, align 4, !tbaa !30
  %105 = icmp slt i32 %103, 0
  %106 = select i1 %105, i32 -808, i32 805
  %107 = load ptr, ptr %0, align 8, !tbaa !5
  %108 = getelementptr inbounds i8, ptr %107, i64 24
  store i32 %106, ptr %108, align 8, !tbaa !32
  br label %361

109:                                              ; preds = %101, %102
  %110 = tail call i32 %41(ptr noundef %37, ptr noundef %27, ptr noundef %19) #6
  %.not526 = icmp eq i32 %110, 0
  br i1 %.not526, label %116, label %111

111:                                              ; preds = %109
  store i32 0, ptr %44, align 4, !tbaa !30
  %112 = icmp slt i32 %110, 0
  %113 = select i1 %112, i32 -805, i32 803
  %114 = load ptr, ptr %0, align 8, !tbaa !5
  %115 = getelementptr inbounds i8, ptr %114, i64 24
  store i32 %113, ptr %115, align 8, !tbaa !32
  br label %361

116:                                              ; preds = %109
  switch i32 %48, label %124 [
    i32 3, label %117
    i32 1, label %117
  ]

117:                                              ; preds = %116, %116
  %118 = tail call i32 %43(ptr noundef %39, ptr noundef %19, ptr noundef %27, double noundef %4, i32 noundef 1) #6
  %.not527 = icmp eq i32 %118, 0
  br i1 %.not527, label %125, label %119

119:                                              ; preds = %117
  store i32 0, ptr %44, align 4, !tbaa !30
  %120 = icmp slt i32 %118, 0
  %121 = select i1 %120, i32 -808, i32 805
  %122 = load ptr, ptr %0, align 8, !tbaa !5
  %123 = getelementptr inbounds i8, ptr %122, i64 24
  store i32 %121, ptr %123, align 8, !tbaa !32
  br label %361

124:                                              ; preds = %116
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %19, ptr noundef %27) #6
  br label %125

125:                                              ; preds = %117, %124
  br i1 %.not520, label %127, label %126

126:                                              ; preds = %125
  tail call void @N_VProd(ptr noundef nonnull %33, ptr noundef %27, ptr noundef %19) #6
  br label %128

127:                                              ; preds = %125
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %19) #6
  br label %128

128:                                              ; preds = %127, %126
  %129 = load ptr, ptr %23, align 8, !tbaa !34
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %13, ptr noundef %129) #6
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %13, ptr noundef %25) #6
  tail call void @N_VScale(double noundef 1.000000e+00, ptr noundef %13, ptr noundef %21) #6
  tail call void @N_VConst(double noundef 0.000000e+00, ptr noundef %17) #6
  br i1 %.not, label %133, label %130

130:                                              ; preds = %128
  %131 = load i32, ptr %44, align 4, !tbaa !30
  %.not528 = icmp eq i32 %131, 0
  br i1 %.not528, label %132, label %133

132:                                              ; preds = %130
  tail call void @N_VProd(ptr noundef nonnull %35, ptr noundef %2, ptr noundef %2) #6
  br label %133

133:                                              ; preds = %132, %130, %128
  %134 = icmp sgt i32 %11, 0
  br i1 %134, label %.lr.ph, label %.thread

.lr.ph:                                           ; preds = %133
  %135 = getelementptr inbounds i8, ptr %23, i64 8
  %136 = getelementptr inbounds i8, ptr %6, i64 8
  %137 = getelementptr inbounds i8, ptr %7, i64 8
  %138 = getelementptr inbounds i8, ptr %6, i64 16
  %139 = getelementptr inbounds i8, ptr %7, i64 16
  br label %140

140:                                              ; preds = %.lr.ph, %337
  %141 = phi i1 [ true, %.lr.ph ], [ %341, %337 ]
  %.0454651 = phi double [ %93, %.lr.ph ], [ %231, %337 ]
  %.0455650 = phi double [ 0.000000e+00, %.lr.ph ], [ %233, %337 ]
  %.0458649 = phi double [ 0.000000e+00, %.lr.ph ], [ %225, %337 ]
  %.sroa.0.0648 = phi double [ %88, %.lr.ph ], [ %299, %337 ]
  %.0465647 = phi double [ -1.000000e+00, %.lr.ph ], [ %.2467, %337 ]
  %.0472646 = phi i32 [ 0, %.lr.ph ], [ %.3475, %337 ]
  %.0477645 = phi i32 [ 0, %.lr.ph ], [ %340, %337 ]
  %142 = load i32, ptr %45, align 4, !tbaa !30
  %143 = add nsw i32 %142, 1
  store i32 %143, ptr %45, align 4, !tbaa !30
  %144 = call double @N_VDotProd(ptr noundef %13, ptr noundef %19) #6
  %145 = fdiv double %.sroa.0.0648, %144
  %146 = fneg double %145
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %25, double noundef %146, ptr noundef %19, ptr noundef %15) #6
  %147 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %25, double noundef 1.000000e+00, ptr noundef %15, ptr noundef %147) #6
  br i1 %.not, label %150, label %148

148:                                              ; preds = %140
  %149 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VDiv(ptr noundef %149, ptr noundef nonnull %35, ptr noundef %149) #6
  br label %150

150:                                              ; preds = %148, %140
  br i1 %51, label %151, label %160

151:                                              ; preds = %150
  %152 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %152, ptr noundef %27) #6
  %153 = load ptr, ptr %135, align 8, !tbaa !34
  %154 = call i32 %43(ptr noundef %39, ptr noundef %27, ptr noundef %153, double noundef %4, i32 noundef 2) #6
  %.not529 = icmp eq i32 %154, 0
  br i1 %.not529, label %160, label %155

155:                                              ; preds = %151
  store i32 0, ptr %44, align 4, !tbaa !30
  %156 = icmp slt i32 %154, 0
  %157 = select i1 %156, i32 -808, i32 805
  %158 = load ptr, ptr %0, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i64 24
  store i32 %157, ptr %159, align 8, !tbaa !32
  br label %361

160:                                              ; preds = %150, %151
  %161 = load ptr, ptr %135, align 8, !tbaa !34
  %162 = call i32 %41(ptr noundef %37, ptr noundef %161, ptr noundef %27) #6
  %.not530 = icmp eq i32 %162, 0
  br i1 %.not530, label %168, label %163

163:                                              ; preds = %160
  store i32 0, ptr %44, align 4, !tbaa !30
  %164 = icmp slt i32 %162, 0
  %165 = select i1 %164, i32 -805, i32 803
  %166 = load ptr, ptr %0, align 8, !tbaa !5
  %167 = getelementptr inbounds i8, ptr %166, i64 24
  store i32 %165, ptr %167, align 8, !tbaa !32
  br label %361

168:                                              ; preds = %160
  switch i32 %48, label %177 [
    i32 3, label %169
    i32 1, label %169
  ]

169:                                              ; preds = %168, %168
  %170 = load ptr, ptr %135, align 8, !tbaa !34
  %171 = call i32 %43(ptr noundef %39, ptr noundef %27, ptr noundef %170, double noundef %4, i32 noundef 1) #6
  %.not531 = icmp eq i32 %171, 0
  br i1 %.not531, label %179, label %172

172:                                              ; preds = %169
  store i32 0, ptr %44, align 4, !tbaa !30
  %173 = icmp slt i32 %171, 0
  %174 = select i1 %173, i32 -808, i32 805
  %175 = load ptr, ptr %0, align 8, !tbaa !5
  %176 = getelementptr inbounds i8, ptr %175, i64 24
  store i32 %174, ptr %176, align 8, !tbaa !32
  br label %361

177:                                              ; preds = %168
  %178 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %178) #6
  br label %179

179:                                              ; preds = %169, %177
  %180 = load ptr, ptr %135, align 8, !tbaa !34
  br i1 %.not520, label %182, label %181

181:                                              ; preds = %179
  call void @N_VProd(ptr noundef nonnull %33, ptr noundef %180, ptr noundef %27) #6
  br label %183

182:                                              ; preds = %179
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %180, ptr noundef %27) #6
  br label %183

183:                                              ; preds = %182, %181
  %184 = load ptr, ptr %23, align 8, !tbaa !34
  %185 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %184, double noundef %146, ptr noundef %27, ptr noundef %185) #6
  br label %186

186:                                              ; preds = %183, %296
  %.1644 = phi double [ %.0454651, %183 ], [ %231, %296 ]
  %.1456643 = phi double [ %.0455650, %183 ], [ %233, %296 ]
  %.1459642 = phi double [ %.0458649, %183 ], [ %225, %296 ]
  %.1466641 = phi double [ %.0465647, %183 ], [ %.2467, %296 ]
  %.1473640 = phi i32 [ %.0472646, %183 ], [ %.3475, %296 ]
  %187 = phi i1 [ true, %183 ], [ false, %296 ]
  %.0478639 = phi i32 [ 0, %183 ], [ 1, %296 ]
  br i1 %187, label %188, label %221

188:                                              ; preds = %186
  %189 = load ptr, ptr %135, align 8, !tbaa !34
  %190 = call double @N_VDotProd(ptr noundef %189, ptr noundef %189) #6
  %191 = fcmp ugt double %190, 0.000000e+00
  br i1 %191, label %192, label %196

192:                                              ; preds = %188
  %193 = load ptr, ptr %135, align 8, !tbaa !34
  %194 = call double @N_VDotProd(ptr noundef %193, ptr noundef %193) #6
  %195 = call double @sqrt(double noundef %194) #6
  br label %196

196:                                              ; preds = %188, %192
  %197 = phi double [ %195, %192 ], [ 0.000000e+00, %188 ]
  %198 = load ptr, ptr %23, align 8, !tbaa !34
  %199 = call double @N_VDotProd(ptr noundef %198, ptr noundef %198) #6
  %200 = fcmp ugt double %199, 0.000000e+00
  br i1 %200, label %201, label %205

201:                                              ; preds = %196
  %202 = load ptr, ptr %23, align 8, !tbaa !34
  %203 = call double @N_VDotProd(ptr noundef %202, ptr noundef %202) #6
  %204 = call double @sqrt(double noundef %203) #6
  br label %205

205:                                              ; preds = %196, %201
  %206 = phi double [ %204, %201 ], [ 0.000000e+00, %196 ]
  %207 = fmul double %197, %206
  %208 = fcmp ugt double %207, 0.000000e+00
  br i1 %208, label %209, label %221

209:                                              ; preds = %205
  %210 = load ptr, ptr %23, align 8, !tbaa !34
  %211 = call double @N_VDotProd(ptr noundef %210, ptr noundef %210) #6
  %212 = fcmp ugt double %211, 0.000000e+00
  br i1 %212, label %213, label %217

213:                                              ; preds = %209
  %214 = load ptr, ptr %23, align 8, !tbaa !34
  %215 = call double @N_VDotProd(ptr noundef %214, ptr noundef %214) #6
  %216 = call double @sqrt(double noundef %215) #6
  br label %217

217:                                              ; preds = %209, %213
  %218 = phi double [ %216, %213 ], [ 0.000000e+00, %209 ]
  %219 = fmul double %197, %218
  %220 = call double @sqrt(double noundef %219) #6
  br label %221

221:                                              ; preds = %186, %217, %205
  %.sink = phi ptr [ %25, %205 ], [ %25, %217 ], [ %15, %186 ]
  %.2467 = phi double [ %197, %205 ], [ %197, %217 ], [ %.1466641, %186 ]
  %.0461 = phi double [ 0.000000e+00, %205 ], [ %220, %217 ], [ %.1466641, %186 ]
  %222 = fmul double %.1459642, %.1459642
  %223 = fmul double %222, %.1456643
  %224 = fdiv double %223, %145
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %.sink, double noundef %224, ptr noundef %17, ptr noundef %17) #6
  %225 = fdiv double %.0461, %.1644
  %226 = call double @llvm.fmuladd.f64(double %225, double %225, double 1.000000e+00)
  %227 = fcmp ugt double %226, 0.000000e+00
  %sqrt = call double @llvm.sqrt.f64(double %226)
  %228 = fdiv double 1.000000e+00, %sqrt
  %229 = select i1 %227, double %228, double 0x7FF0000000000000
  %230 = fmul double %.1644, %225
  %231 = fmul double %230, %229
  %232 = fmul double %229, %229
  %233 = fmul double %145, %232
  %234 = or i32 %.0478639, %.0477645
  %or.cond5 = icmp eq i32 %234, 0
  br i1 %or.cond5, label %235, label %238

235:                                              ; preds = %221
  %236 = load i32, ptr %44, align 4, !tbaa !30
  %.not532 = icmp eq i32 %236, 0
  br i1 %.not532, label %238, label %237

237:                                              ; preds = %235
  call void @N_VScale(double noundef %233, ptr noundef %17, ptr noundef %2) #6
  br label %239

238:                                              ; preds = %235, %221
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %2, double noundef %233, ptr noundef %17, ptr noundef %2) #6
  br label %239

239:                                              ; preds = %238, %237
  %240 = add nuw nsw i32 %.0478639, 1
  %241 = uitofp nneg i32 %240 to double
  %sqrt561 = call double @llvm.sqrt.f64(double %241)
  %242 = fmul double %sqrt561, %231
  store double %242, ptr %46, align 8, !tbaa !33
  %243 = fcmp ugt double %242, %4
  br i1 %243, label %244, label %.thread

244:                                              ; preds = %239
  %245 = fcmp ogt double %242, %4
  br i1 %245, label %246, label %296

246:                                              ; preds = %244
  br i1 %.not, label %248, label %247

247:                                              ; preds = %246
  call void @N_VDiv(ptr noundef %2, ptr noundef nonnull %35, ptr noundef %27) #6
  br label %249

248:                                              ; preds = %246
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %2, ptr noundef %27) #6
  br label %249

249:                                              ; preds = %248, %247
  br i1 %51, label %250, label %256

250:                                              ; preds = %249
  %251 = call i32 %43(ptr noundef %39, ptr noundef %27, ptr noundef %29, double noundef %4, i32 noundef 2) #6
  %.not533 = icmp eq i32 %251, 0
  br i1 %.not533, label %255, label %252

252:                                              ; preds = %250
  store i32 0, ptr %44, align 4, !tbaa !30
  %253 = load ptr, ptr %0, align 8, !tbaa !5
  %254 = getelementptr inbounds i8, ptr %253, i64 24
  store i32 -808, ptr %254, align 8, !tbaa !32
  br label %361

255:                                              ; preds = %250
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %29, ptr noundef %27) #6
  br label %256

256:                                              ; preds = %249, %255
  %257 = call i32 %41(ptr noundef %37, ptr noundef %27, ptr noundef %29) #6
  %.not534 = icmp eq i32 %257, 0
  br i1 %.not534, label %263, label %258

258:                                              ; preds = %256
  store i32 0, ptr %44, align 4, !tbaa !30
  %259 = icmp slt i32 %257, 0
  %260 = select i1 %259, i32 -805, i32 803
  %261 = load ptr, ptr %0, align 8, !tbaa !5
  %262 = getelementptr inbounds i8, ptr %261, i64 24
  store i32 %260, ptr %262, align 8, !tbaa !32
  br label %361

263:                                              ; preds = %256
  switch i32 %48, label %271 [
    i32 3, label %264
    i32 1, label %264
  ]

264:                                              ; preds = %263, %263
  %265 = call i32 %43(ptr noundef %39, ptr noundef %29, ptr noundef %27, double noundef %4, i32 noundef 1) #6
  %.not535 = icmp eq i32 %265, 0
  br i1 %.not535, label %272, label %266

266:                                              ; preds = %264
  store i32 0, ptr %44, align 4, !tbaa !30
  %267 = icmp slt i32 %265, 0
  %268 = select i1 %267, i32 -808, i32 805
  %269 = load ptr, ptr %0, align 8, !tbaa !5
  %270 = getelementptr inbounds i8, ptr %269, i64 24
  store i32 %268, ptr %270, align 8, !tbaa !32
  br label %361

271:                                              ; preds = %263
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %29, ptr noundef %27) #6
  br label %272

272:                                              ; preds = %264, %271
  br i1 %.not520, label %274, label %273

273:                                              ; preds = %272
  call void @N_VProd(ptr noundef nonnull %33, ptr noundef %27, ptr noundef %29) #6
  br label %275

274:                                              ; preds = %272
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %29) #6
  br label %275

275:                                              ; preds = %274, %273
  %.not536 = icmp eq i32 %.1473640, 0
  br i1 %.not536, label %276, label %287

276:                                              ; preds = %275
  switch i32 %48, label %284 [
    i32 3, label %277
    i32 1, label %277
  ]

277:                                              ; preds = %276, %276
  %278 = call i32 %43(ptr noundef %39, ptr noundef %3, ptr noundef %31, double noundef %4, i32 noundef 1) #6
  %.not537 = icmp eq i32 %278, 0
  br i1 %.not537, label %285, label %279

279:                                              ; preds = %277
  store i32 0, ptr %44, align 4, !tbaa !30
  %280 = icmp slt i32 %278, 0
  %281 = select i1 %280, i32 -808, i32 805
  %282 = load ptr, ptr %0, align 8, !tbaa !5
  %283 = getelementptr inbounds i8, ptr %282, i64 24
  store i32 %281, ptr %283, align 8, !tbaa !32
  br label %361

284:                                              ; preds = %276
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %3, ptr noundef %31) #6
  br label %285

285:                                              ; preds = %277, %284
  br i1 %.not520, label %287, label %286

286:                                              ; preds = %285
  call void @N_VProd(ptr noundef nonnull %33, ptr noundef %31, ptr noundef %31) #6
  br label %287

287:                                              ; preds = %285, %286, %275
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %31, double noundef -1.000000e+00, ptr noundef %29, ptr noundef %27) #6
  %288 = call double @N_VDotProd(ptr noundef %27, ptr noundef %27) #6
  %289 = fcmp ugt double %288, 0.000000e+00
  br i1 %289, label %290, label %293

290:                                              ; preds = %287
  %291 = call double @N_VDotProd(ptr noundef %27, ptr noundef %27) #6
  %292 = call double @sqrt(double noundef %291) #6
  br label %293

293:                                              ; preds = %287, %290
  %294 = phi double [ %292, %290 ], [ 0.000000e+00, %287 ]
  store double %294, ptr %46, align 8, !tbaa !33
  %295 = fcmp ugt double %294, %4
  br i1 %295, label %296, label %.thread

296:                                              ; preds = %244, %293
  %.3475 = phi i32 [ 1, %293 ], [ %.1473640, %244 ]
  %.2464 = phi double [ %294, %293 ], [ %242, %244 ]
  br i1 %187, label %186, label %297, !llvm.loop !35

297:                                              ; preds = %296
  %298 = load ptr, ptr %135, align 8, !tbaa !34
  %299 = call double @N_VDotProd(ptr noundef %13, ptr noundef %298) #6
  %300 = fdiv double %299, %.sroa.0.0648
  %301 = load ptr, ptr %135, align 8, !tbaa !34
  call void @N_VLinearSum(double noundef 1.000000e+00, ptr noundef %301, double noundef %300, ptr noundef %15, ptr noundef %25) #6
  %302 = fmul double %300, %300
  store double %302, ptr %6, align 16, !tbaa !33
  store ptr %21, ptr %7, align 16, !tbaa !34
  store double %300, ptr %136, align 8, !tbaa !33
  store ptr %15, ptr %137, align 8, !tbaa !34
  store double 1.000000e+00, ptr %138, align 16, !tbaa !33
  store ptr %25, ptr %139, align 16, !tbaa !34
  %303 = call i32 @N_VLinearCombination(i32 noundef 3, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef %21) #6
  %.not538 = icmp eq i32 %303, 0
  br i1 %.not538, label %307, label %304

304:                                              ; preds = %297
  store i32 0, ptr %44, align 4, !tbaa !30
  %305 = load ptr, ptr %0, align 8, !tbaa !5
  %306 = getelementptr inbounds i8, ptr %305, i64 24
  store i32 -812, ptr %306, align 8, !tbaa !32
  br label %361

307:                                              ; preds = %297
  br i1 %.not, label %309, label %308

308:                                              ; preds = %307
  call void @N_VDiv(ptr noundef %21, ptr noundef nonnull %35, ptr noundef %27) #6
  br label %310

309:                                              ; preds = %307
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %21, ptr noundef %27) #6
  br label %310

310:                                              ; preds = %309, %308
  br i1 %51, label %311, label %318

311:                                              ; preds = %310
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %19) #6
  %312 = call i32 %43(ptr noundef %39, ptr noundef %19, ptr noundef %27, double noundef %4, i32 noundef 2) #6
  %.not539 = icmp eq i32 %312, 0
  br i1 %.not539, label %318, label %313

313:                                              ; preds = %311
  store i32 0, ptr %44, align 4, !tbaa !30
  %314 = icmp slt i32 %312, 0
  %315 = select i1 %314, i32 -808, i32 805
  %316 = load ptr, ptr %0, align 8, !tbaa !5
  %317 = getelementptr inbounds i8, ptr %316, i64 24
  store i32 %315, ptr %317, align 8, !tbaa !32
  br label %361

318:                                              ; preds = %310, %311
  %319 = call i32 %41(ptr noundef %37, ptr noundef %27, ptr noundef %19) #6
  %.not540 = icmp eq i32 %319, 0
  br i1 %.not540, label %325, label %320

320:                                              ; preds = %318
  store i32 0, ptr %44, align 4, !tbaa !30
  %321 = icmp slt i32 %319, 0
  %322 = select i1 %321, i32 -805, i32 803
  %323 = load ptr, ptr %0, align 8, !tbaa !5
  %324 = getelementptr inbounds i8, ptr %323, i64 24
  store i32 %322, ptr %324, align 8, !tbaa !32
  br label %361

325:                                              ; preds = %318
  switch i32 %48, label %333 [
    i32 3, label %326
    i32 1, label %326
  ]

326:                                              ; preds = %325, %325
  %327 = call i32 %43(ptr noundef %39, ptr noundef %19, ptr noundef %27, double noundef %4, i32 noundef 1) #6
  %.not541 = icmp eq i32 %327, 0
  br i1 %.not541, label %334, label %328

328:                                              ; preds = %326
  store i32 0, ptr %44, align 4, !tbaa !30
  %329 = icmp slt i32 %327, 0
  %330 = select i1 %329, i32 -808, i32 805
  %331 = load ptr, ptr %0, align 8, !tbaa !5
  %332 = getelementptr inbounds i8, ptr %331, i64 24
  store i32 %330, ptr %332, align 8, !tbaa !32
  br label %361

333:                                              ; preds = %325
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %19, ptr noundef %27) #6
  br label %334

334:                                              ; preds = %326, %333
  br i1 %.not520, label %336, label %335

335:                                              ; preds = %334
  call void @N_VProd(ptr noundef nonnull %33, ptr noundef %27, ptr noundef %19) #6
  br label %337

336:                                              ; preds = %334
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %19) #6
  br label %337

337:                                              ; preds = %336, %335
  %338 = load ptr, ptr %135, align 8, !tbaa !34
  %339 = load ptr, ptr %23, align 8, !tbaa !34
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %338, ptr noundef %339) #6
  %340 = add nuw nsw i32 %.0477645, 1
  %341 = icmp slt i32 %340, %11
  %exitcond.not = icmp eq i32 %340, %11
  br i1 %exitcond.not, label %.thread, label %140, !llvm.loop !37

.thread:                                          ; preds = %337, %239, %293, %133
  %342 = phi i1 [ false, %133 ], [ %141, %293 ], [ %141, %239 ], [ %341, %337 ]
  %.4 = phi double [ -1.000000e+00, %133 ], [ %242, %239 ], [ %294, %293 ], [ %.2464, %337 ]
  %343 = fcmp olt double %.4, %93
  %or.cond544 = or i1 %342, %343
  br i1 %or.cond544, label %344, label %358

344:                                              ; preds = %.thread
  br i1 %.not, label %346, label %345

345:                                              ; preds = %344
  call void @N_VDiv(ptr noundef %2, ptr noundef nonnull %35, ptr noundef %2) #6
  br label %346

346:                                              ; preds = %345, %344
  br i1 %51, label %347, label %353

347:                                              ; preds = %346
  %348 = call i32 %43(ptr noundef %39, ptr noundef %2, ptr noundef %27, double noundef %4, i32 noundef 2) #6
  %.not542 = icmp eq i32 %348, 0
  br i1 %.not542, label %352, label %349

349:                                              ; preds = %347
  store i32 0, ptr %44, align 4, !tbaa !30
  %350 = load ptr, ptr %0, align 8, !tbaa !5
  %351 = getelementptr inbounds i8, ptr %350, i64 24
  store i32 -808, ptr %351, align 8, !tbaa !32
  br label %361

352:                                              ; preds = %347
  call void @N_VScale(double noundef 1.000000e+00, ptr noundef %27, ptr noundef %2) #6
  br label %353

353:                                              ; preds = %346, %352
  store i32 0, ptr %44, align 4, !tbaa !30
  %354 = load ptr, ptr %0, align 8, !tbaa !5
  %355 = getelementptr inbounds i8, ptr %354, i64 24
  br i1 %342, label %356, label %357

356:                                              ; preds = %353
  store i32 0, ptr %355, align 8, !tbaa !32
  br label %361

357:                                              ; preds = %353
  store i32 801, ptr %355, align 8, !tbaa !32
  br label %361

358:                                              ; preds = %.thread
  store i32 0, ptr %44, align 4, !tbaa !30
  %359 = load ptr, ptr %0, align 8, !tbaa !5
  %360 = getelementptr inbounds i8, ptr %359, i64 24
  store i32 802, ptr %360, align 8, !tbaa !32
  br label %361

361:                                              ; preds = %356, %357, %5, %358, %349, %328, %320, %313, %304, %279, %266, %258, %252, %172, %163, %155, %119, %111, %104, %95, %78, %69, %62, %58, %54
  %.0 = phi i32 [ -804, %58 ], [ -807, %62 ], [ %80, %78 ], [ 0, %95 ], [ %106, %104 ], [ %113, %111 ], [ %121, %119 ], [ %157, %155 ], [ %165, %163 ], [ %174, %172 ], [ -808, %349 ], [ 802, %358 ], [ -812, %304 ], [ %315, %313 ], [ %322, %320 ], [ %330, %328 ], [ -808, %252 ], [ %260, %258 ], [ %268, %266 ], [ %281, %279 ], [ %71, %69 ], [ -802, %54 ], [ -801, %5 ], [ 801, %357 ], [ 0, %356 ]
  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %7) #6
  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %6) #6
  ret i32 %.0
}

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

declare void @N_VScale(double noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @N_VLinearSum(double noundef, ptr noundef, double noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @N_VProd(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

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

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

declare void @N_VDiv(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

declare void @N_VConst(double noundef, ptr noundef) local_unnamed_addr #2

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

declare i32 @N_VLinearCombination(i32 noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { 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 #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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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, !7, i64 0}
!6 = !{!"_generic_SUNLinearSolver", !7, i64 0, !7, i64 8, !7, i64 16}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!11, !12, i64 0}
!11 = !{!"_SUNLinearSolverContent_SPTFQMR", !12, i64 0, !12, i64 4, !12, i64 8, !12, i64 12, !13, i64 16, !12, i64 24, !7, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !7, i64 64, !7, i64 72, !7, i64 80, !7, i64 88, !7, i64 96, !7, i64 104, !7, i64 112, !7, i64 120, !7, i64 128, !7, i64 136, !7, i64 144, !7, i64 152, !7, i64 160, !12, i64 168, !7, i64 176}
!12 = !{!"int", !8, i64 0}
!13 = !{!"double", !8, i64 0}
!14 = !{!11, !7, i64 88}
!15 = !{!11, !7, i64 96}
!16 = !{!11, !7, i64 104}
!17 = !{!11, !7, i64 112}
!18 = !{!11, !7, i64 120}
!19 = !{!11, !7, i64 128}
!20 = !{!11, !7, i64 136}
!21 = !{!11, !7, i64 144}
!22 = !{!11, !7, i64 152}
!23 = !{!11, !7, i64 160}
!24 = !{!11, !7, i64 72}
!25 = !{!11, !7, i64 80}
!26 = !{!11, !7, i64 40}
!27 = !{!11, !7, i64 64}
!28 = !{!11, !7, i64 32}
!29 = !{!11, !7, i64 56}
!30 = !{!12, !12, i64 0}
!31 = !{!11, !12, i64 4}
!32 = !{!11, !12, i64 24}
!33 = !{!13, !13, i64 0}
!34 = !{!7, !7, i64 0}
!35 = distinct !{!35, !36}
!36 = !{!"llvm.loop.mustprogress"}
!37 = distinct !{!37, !36}


; Effective O3 passes: AggressiveInstCombinePass,BDCEPass,ConstraintEliminationPass,CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass