; LLVM IR from CLASS-SZ/class_sz :: class-sz/source (nonlinear)

; 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.nonlinear = type { i32, i32, i32, double, double, double, i16, i32, i32, i32, ptr, i16, i16, i32, i32, i32, i32, i32, i16, i32, ptr, ptr, ptr, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, ptr, ptr, ptr, i32, i32, i32, i32, i32, ptr, ptr, ptr, i16, [2048 x i8] }
%struct.primordial = type { double, i32, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, i32, double, double, double, double, double, double, double, double, double, double, double, i32, double, i32, ptr, double, double, double, double, double, double, double, double, double, double, i32, ptr, ptr, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, double, double, double, double, i16, [2048 x i8] }

@.str.3 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [12 x i8], align 1
@__func__.nonlinear_pk_at_k_and_z = external hidden unnamed_addr constant [24 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [95 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [103 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [132 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [123 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [169 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [90 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [81 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [87 x i8], align 1

; Function Attrs: nounwind uwtable
declare dso_local i32 @nonlinear_pk_at_z(ptr noundef, ptr noundef, i32 noundef, i32 noundef, double noundef, i32 noundef, ptr noundef, ptr noundef) #0

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

declare void @class_protect_sprintf(ptr noundef, ptr noundef, ...) #2

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

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

declare i32 @array_interpolate_spline(ptr noundef, i32 noundef, ptr noundef, ptr noundef, i32 noundef, double noundef, ptr noundef, ptr noundef, i32 noundef, ptr noundef) #2

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

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

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

57:                                               ; preds = %9
  %58 = load ptr, ptr %13, align 8, !tbaa !5
  %59 = getelementptr inbounds %struct.nonlinear, ptr %58, i32 0, i32 8
  %60 = load i32, ptr %59, align 8, !tbaa !15
  %61 = icmp sgt i32 %60, 1
  br i1 %61, label %62, label %66

62:                                               ; preds = %57
  %63 = load ptr, ptr %19, align 8, !tbaa !5
  %64 = icmp ne ptr %63, null
  br i1 %64, label %65, label %66

65:                                               ; preds = %62
  store i16 1, ptr %33, align 2, !tbaa !13
  br label %66

66:                                               ; preds = %65, %62, %57, %9
  %67 = load double, ptr %15, align 8, !tbaa !11
  %68 = fcmp oeq double %67, 0.000000e+00
  br i1 %68, label %69, label %91

69:                                               ; preds = %66
  %70 = load ptr, ptr %18, align 8, !tbaa !5
  store double 0.000000e+00, ptr %70, align 8, !tbaa !11
  %71 = load i16, ptr %33, align 2, !tbaa !13
  %72 = sext i16 %71 to i32
  %73 = icmp eq i32 %72, 1
  br i1 %73, label %74, label %90

74:                                               ; preds = %69
  store i32 0, ptr %29, align 4, !tbaa !9
  br label %75

75:                                               ; preds = %86, %74
  %76 = load i32, ptr %29, align 4, !tbaa !9
  %77 = load ptr, ptr %13, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.nonlinear, ptr %77, i32 0, i32 9
  %79 = load i32, ptr %78, align 4, !tbaa !17
  %80 = icmp slt i32 %76, %79
  br i1 %80, label %81, label %89

81:                                               ; preds = %75
  %82 = load ptr, ptr %19, align 8, !tbaa !5
  %83 = load i32, ptr %29, align 4, !tbaa !9
  %84 = sext i32 %83 to i64
  %85 = getelementptr inbounds double, ptr %82, i64 %84
  store double 0.000000e+00, ptr %85, align 8, !tbaa !11
  br label %86

86:                                               ; preds = %81
  %87 = load i32, ptr %29, align 4, !tbaa !9
  %88 = add nsw i32 %87, 1
  store i32 %88, ptr %29, align 4, !tbaa !9
  br label %75, !llvm.loop !18

89:                                               ; preds = %75
  br label %90

90:                                               ; preds = %89, %69
  br label %782

91:                                               ; preds = %66
  %92 = load double, ptr %15, align 8, !tbaa !11
  %93 = fcmp olt double %92, 0.000000e+00
  br i1 %93, label %108, label %94

94:                                               ; preds = %91
  %95 = load double, ptr %15, align 8, !tbaa !11
  %96 = load ptr, ptr %13, align 8, !tbaa !5
  %97 = getelementptr inbounds %struct.nonlinear, ptr %96, i32 0, i32 21
  %98 = load ptr, ptr %97, align 8, !tbaa !20
  %99 = load ptr, ptr %13, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.nonlinear, ptr %99, i32 0, i32 19
  %101 = load i32, ptr %100, align 4, !tbaa !21
  %102 = sub nsw i32 %101, 1
  %103 = sext i32 %102 to i64
  %104 = getelementptr inbounds double, ptr %98, i64 %103
  %105 = load double, ptr %104, align 8, !tbaa !11
  %106 = call double @exp(double noundef %105) #5
  %107 = fcmp ogt double %95, %106
  br i1 %107, label %108, label %130

108:                                              ; preds = %94, %91
  %109 = load ptr, ptr %18, align 8, !tbaa !5
  store double 0.000000e+00, ptr %109, align 8, !tbaa !11
  %110 = load i16, ptr %33, align 2, !tbaa !13
  %111 = sext i16 %110 to i32
  %112 = icmp eq i32 %111, 1
  br i1 %112, label %113, label %129

113:                                              ; preds = %108
  store i32 0, ptr %29, align 4, !tbaa !9
  br label %114

114:                                              ; preds = %125, %113
  %115 = load i32, ptr %29, align 4, !tbaa !9
  %116 = load ptr, ptr %13, align 8, !tbaa !5
  %117 = getelementptr inbounds %struct.nonlinear, ptr %116, i32 0, i32 9
  %118 = load i32, ptr %117, align 4, !tbaa !17
  %119 = icmp slt i32 %115, %118
  br i1 %119, label %120, label %128

120:                                              ; preds = %114
  %121 = load ptr, ptr %19, align 8, !tbaa !5
  %122 = load i32, ptr %29, align 4, !tbaa !9
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds double, ptr %121, i64 %123
  store double 0.000000e+00, ptr %124, align 8, !tbaa !11
  br label %125

125:                                              ; preds = %120
  %126 = load i32, ptr %29, align 4, !tbaa !9
  %127 = add nsw i32 %126, 1
  store i32 %127, ptr %29, align 4, !tbaa !9
  br label %114, !llvm.loop !22

128:                                              ; preds = %114
  br label %129

129:                                              ; preds = %128, %108
  br label %781

130:                                              ; preds = %94
  %131 = load ptr, ptr %13, align 8, !tbaa !5
  %132 = getelementptr inbounds %struct.nonlinear, ptr %131, i32 0, i32 19
  %133 = load i32, ptr %132, align 4, !tbaa !21
  %134 = sext i32 %133 to i64
  %135 = mul i64 %134, 8
  %136 = call noalias ptr @malloc(i64 noundef %135) #6
  store ptr %136, ptr %20, align 8, !tbaa !5
  %137 = load ptr, ptr %20, align 8, !tbaa !5
  %138 = icmp eq ptr %137, null
  br i1 %138, label %139, label %152

139:                                              ; preds = %130
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #5
  %140 = load ptr, ptr %13, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.nonlinear, ptr %140, i32 0, i32 19
  %142 = load i32, ptr %141, align 4, !tbaa !21
  %143 = sext i32 %142 to i64
  %144 = mul i64 %143, 8
  %145 = trunc i64 %144 to i32
  store i32 %145, ptr %34, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %35) #5
  %146 = getelementptr inbounds [2048 x i8], ptr %35, i64 0, i64 0
  %147 = load i32, ptr %34, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %146, ptr noundef @.str.15, ptr noundef @.str.16, i32 noundef %147)
  %148 = load ptr, ptr %13, align 8, !tbaa !5
  %149 = getelementptr inbounds %struct.nonlinear, ptr %148, i32 0, i32 45
  %150 = getelementptr inbounds [2048 x i8], ptr %149, i64 0, i64 0
  %151 = getelementptr inbounds [2048 x i8], ptr %35, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %150, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 445, ptr noundef %151)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %35) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #5
  br label %783

152:                                              ; preds = %130
  %153 = load i16, ptr %33, align 2, !tbaa !13
  %154 = sext i16 %153 to i32
  %155 = icmp eq i32 %154, 1
  br i1 %155, label %156, label %187

156:                                              ; preds = %152
  %157 = load ptr, ptr %13, align 8, !tbaa !5
  %158 = getelementptr inbounds %struct.nonlinear, ptr %157, i32 0, i32 19
  %159 = load i32, ptr %158, align 4, !tbaa !21
  %160 = load ptr, ptr %13, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.nonlinear, ptr %160, i32 0, i32 9
  %162 = load i32, ptr %161, align 4, !tbaa !17
  %163 = mul nsw i32 %159, %162
  %164 = sext i32 %163 to i64
  %165 = mul i64 %164, 8
  %166 = call noalias ptr @malloc(i64 noundef %165) #6
  store ptr %166, ptr %21, align 8, !tbaa !5
  %167 = load ptr, ptr %21, align 8, !tbaa !5
  %168 = icmp eq ptr %167, null
  br i1 %168, label %169, label %186

169:                                              ; preds = %156
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #5
  %170 = load ptr, ptr %13, align 8, !tbaa !5
  %171 = getelementptr inbounds %struct.nonlinear, ptr %170, i32 0, i32 19
  %172 = load i32, ptr %171, align 4, !tbaa !21
  %173 = load ptr, ptr %13, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.nonlinear, ptr %173, i32 0, i32 9
  %175 = load i32, ptr %174, align 4, !tbaa !17
  %176 = mul nsw i32 %172, %175
  %177 = sext i32 %176 to i64
  %178 = mul i64 %177, 8
  %179 = trunc i64 %178 to i32
  store i32 %179, ptr %37, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %38) #5
  %180 = getelementptr inbounds [2048 x i8], ptr %38, i64 0, i64 0
  %181 = load i32, ptr %37, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %180, ptr noundef @.str.15, ptr noundef @.str.17, i32 noundef %181)
  %182 = load ptr, ptr %13, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.nonlinear, ptr %182, i32 0, i32 45
  %184 = getelementptr inbounds [2048 x i8], ptr %183, i64 0, i64 0
  %185 = getelementptr inbounds [2048 x i8], ptr %38, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %184, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 450, ptr noundef %185)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %38) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #5
  br label %783

186:                                              ; preds = %156
  br label %187

187:                                              ; preds = %186, %152
  %188 = load double, ptr %15, align 8, !tbaa !11
  %189 = load ptr, ptr %13, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.nonlinear, ptr %189, i32 0, i32 21
  %191 = load ptr, ptr %190, align 8, !tbaa !20
  %192 = getelementptr inbounds double, ptr %191, i64 0
  %193 = load double, ptr %192, align 8, !tbaa !11
  %194 = call double @exp(double noundef %193) #5
  %195 = fcmp ogt double %188, %194
  br i1 %195, label %196, label %585

196:                                              ; preds = %187
  %197 = load ptr, ptr %11, align 8, !tbaa !5
  %198 = load ptr, ptr %13, align 8, !tbaa !5
  %199 = load i32, ptr %14, align 4, !tbaa !9
  %200 = load double, ptr %16, align 8, !tbaa !11
  %201 = load i32, ptr %17, align 4, !tbaa !9
  %202 = load ptr, ptr %20, align 8, !tbaa !5
  %203 = load ptr, ptr %21, align 8, !tbaa !5
  %204 = call i32 @nonlinear_pk_at_z(ptr noundef %197, ptr noundef %198, i32 noundef 1, i32 noundef %199, double noundef %200, i32 noundef %201, ptr noundef %202, ptr noundef %203)
  %205 = icmp eq i32 %204, 1
  br i1 %205, label %206, label %215

206:                                              ; preds = %196
  call void @llvm.lifetime.start.p0(i64 2048, ptr %39) #5
  %207 = getelementptr inbounds [2048 x i8], ptr %39, i64 0, i64 0
  %208 = load ptr, ptr %13, align 8, !tbaa !5
  %209 = getelementptr inbounds %struct.nonlinear, ptr %208, i32 0, i32 45
  %210 = getelementptr inbounds [2048 x i8], ptr %209, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %207, ptr noundef @.str.4, ptr noundef @.str.18, ptr noundef %210)
  %211 = load ptr, ptr %13, align 8, !tbaa !5
  %212 = getelementptr inbounds %struct.nonlinear, ptr %211, i32 0, i32 45
  %213 = getelementptr inbounds [2048 x i8], ptr %212, i64 0, i64 0
  %214 = getelementptr inbounds [2048 x i8], ptr %39, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %213, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 469, ptr noundef %214)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %39) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

215:                                              ; preds = %196
  %216 = load ptr, ptr %13, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.nonlinear, ptr %216, i32 0, i32 19
  %218 = load i32, ptr %217, align 4, !tbaa !21
  %219 = sext i32 %218 to i64
  %220 = mul i64 %219, 8
  %221 = call noalias ptr @malloc(i64 noundef %220) #6
  store ptr %221, ptr %22, align 8, !tbaa !5
  %222 = load ptr, ptr %22, align 8, !tbaa !5
  %223 = icmp eq ptr %222, null
  br i1 %223, label %224, label %237

224:                                              ; preds = %215
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #5
  %225 = load ptr, ptr %13, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.nonlinear, ptr %225, i32 0, i32 19
  %227 = load i32, ptr %226, align 4, !tbaa !21
  %228 = sext i32 %227 to i64
  %229 = mul i64 %228, 8
  %230 = trunc i64 %229 to i32
  store i32 %230, ptr %40, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %41) #5
  %231 = getelementptr inbounds [2048 x i8], ptr %41, i64 0, i64 0
  %232 = load i32, ptr %40, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %231, ptr noundef @.str.15, ptr noundef @.str.19, i32 noundef %232)
  %233 = load ptr, ptr %13, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.nonlinear, ptr %233, i32 0, i32 45
  %235 = getelementptr inbounds [2048 x i8], ptr %234, i64 0, i64 0
  %236 = getelementptr inbounds [2048 x i8], ptr %41, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %235, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 475, ptr noundef %236)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %41) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #5
  br label %783

237:                                              ; preds = %215
  %238 = load ptr, ptr %13, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.nonlinear, ptr %238, i32 0, i32 21
  %240 = load ptr, ptr %239, align 8, !tbaa !20
  %241 = load ptr, ptr %13, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.nonlinear, ptr %241, i32 0, i32 19
  %243 = load i32, ptr %242, align 4, !tbaa !21
  %244 = load ptr, ptr %20, align 8, !tbaa !5
  %245 = load ptr, ptr %22, align 8, !tbaa !5
  %246 = load ptr, ptr %13, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.nonlinear, ptr %246, i32 0, i32 45
  %248 = getelementptr inbounds [2048 x i8], ptr %247, i64 0, i64 0
  %249 = call i32 @array_spline_table_lines(ptr noundef %240, i32 noundef %243, ptr noundef %244, i32 noundef 1, ptr noundef %245, i16 noundef signext 0, ptr noundef %248)
  %250 = icmp eq i32 %249, 1
  br i1 %250, label %251, label %260

251:                                              ; preds = %237
  call void @llvm.lifetime.start.p0(i64 2048, ptr %42) #5
  %252 = getelementptr inbounds [2048 x i8], ptr %42, i64 0, i64 0
  %253 = load ptr, ptr %13, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.nonlinear, ptr %253, i32 0, i32 45
  %255 = getelementptr inbounds [2048 x i8], ptr %254, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %252, ptr noundef @.str.4, ptr noundef @.str.20, ptr noundef %255)
  %256 = load ptr, ptr %13, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.nonlinear, ptr %256, i32 0, i32 45
  %258 = getelementptr inbounds [2048 x i8], ptr %257, i64 0, i64 0
  %259 = getelementptr inbounds [2048 x i8], ptr %42, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %258, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 485, ptr noundef %259)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %42) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

260:                                              ; preds = %237
  %261 = load ptr, ptr %13, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.nonlinear, ptr %261, i32 0, i32 21
  %263 = load ptr, ptr %262, align 8, !tbaa !20
  %264 = load ptr, ptr %13, align 8, !tbaa !5
  %265 = getelementptr inbounds %struct.nonlinear, ptr %264, i32 0, i32 19
  %266 = load i32, ptr %265, align 4, !tbaa !21
  %267 = load ptr, ptr %20, align 8, !tbaa !5
  %268 = load ptr, ptr %22, align 8, !tbaa !5
  %269 = load double, ptr %15, align 8, !tbaa !11
  %270 = call double @log(double noundef %269) #5
  %271 = load ptr, ptr %18, align 8, !tbaa !5
  %272 = load ptr, ptr %13, align 8, !tbaa !5
  %273 = getelementptr inbounds %struct.nonlinear, ptr %272, i32 0, i32 45
  %274 = getelementptr inbounds [2048 x i8], ptr %273, i64 0, i64 0
  %275 = call i32 @array_interpolate_spline(ptr noundef %263, i32 noundef %266, ptr noundef %267, ptr noundef %268, i32 noundef 1, double noundef %270, ptr noundef %24, ptr noundef %271, i32 noundef 1, ptr noundef %274)
  %276 = icmp eq i32 %275, 1
  br i1 %276, label %277, label %286

277:                                              ; preds = %260
  call void @llvm.lifetime.start.p0(i64 2048, ptr %43) #5
  %278 = getelementptr inbounds [2048 x i8], ptr %43, i64 0, i64 0
  %279 = load ptr, ptr %13, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.nonlinear, ptr %279, i32 0, i32 45
  %281 = getelementptr inbounds [2048 x i8], ptr %280, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %278, ptr noundef @.str.4, ptr noundef @.str.21, ptr noundef %281)
  %282 = load ptr, ptr %13, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct.nonlinear, ptr %282, i32 0, i32 45
  %284 = getelementptr inbounds [2048 x i8], ptr %283, i64 0, i64 0
  %285 = getelementptr inbounds [2048 x i8], ptr %43, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %284, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 498, ptr noundef %285)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %43) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

286:                                              ; preds = %260
  %287 = load ptr, ptr %22, align 8, !tbaa !5
  call void @free(ptr noundef %287) #5
  %288 = load ptr, ptr %18, align 8, !tbaa !5
  %289 = load double, ptr %288, align 8, !tbaa !11
  %290 = call double @exp(double noundef %289) #5
  %291 = load ptr, ptr %18, align 8, !tbaa !5
  store double %290, ptr %291, align 8, !tbaa !11
  %292 = load i16, ptr %33, align 2, !tbaa !13
  %293 = sext i16 %292 to i32
  %294 = icmp eq i32 %293, 1
  br i1 %294, label %295, label %584

295:                                              ; preds = %286
  %296 = load ptr, ptr %13, align 8, !tbaa !5
  %297 = getelementptr inbounds %struct.nonlinear, ptr %296, i32 0, i32 19
  %298 = load i32, ptr %297, align 4, !tbaa !21
  %299 = load ptr, ptr %13, align 8, !tbaa !5
  %300 = getelementptr inbounds %struct.nonlinear, ptr %299, i32 0, i32 9
  %301 = load i32, ptr %300, align 4, !tbaa !17
  %302 = mul nsw i32 %298, %301
  %303 = sext i32 %302 to i64
  %304 = mul i64 %303, 8
  %305 = call noalias ptr @malloc(i64 noundef %304) #6
  store ptr %305, ptr %23, align 8, !tbaa !5
  %306 = load ptr, ptr %23, align 8, !tbaa !5
  %307 = icmp eq ptr %306, null
  br i1 %307, label %308, label %325

308:                                              ; preds = %295
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #5
  %309 = load ptr, ptr %13, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.nonlinear, ptr %309, i32 0, i32 19
  %311 = load i32, ptr %310, align 4, !tbaa !21
  %312 = load ptr, ptr %13, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.nonlinear, ptr %312, i32 0, i32 9
  %314 = load i32, ptr %313, align 4, !tbaa !17
  %315 = mul nsw i32 %311, %314
  %316 = sext i32 %315 to i64
  %317 = mul i64 %316, 8
  %318 = trunc i64 %317 to i32
  store i32 %318, ptr %44, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %45) #5
  %319 = getelementptr inbounds [2048 x i8], ptr %45, i64 0, i64 0
  %320 = load i32, ptr %44, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %319, ptr noundef @.str.15, ptr noundef @.str.22, i32 noundef %320)
  %321 = load ptr, ptr %13, align 8, !tbaa !5
  %322 = getelementptr inbounds %struct.nonlinear, ptr %321, i32 0, i32 45
  %323 = getelementptr inbounds [2048 x i8], ptr %322, i64 0, i64 0
  %324 = getelementptr inbounds [2048 x i8], ptr %45, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %323, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 528, ptr noundef %324)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %45) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #5
  br label %783

325:                                              ; preds = %295
  %326 = load ptr, ptr %13, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.nonlinear, ptr %326, i32 0, i32 21
  %328 = load ptr, ptr %327, align 8, !tbaa !20
  %329 = load ptr, ptr %13, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.nonlinear, ptr %329, i32 0, i32 19
  %331 = load i32, ptr %330, align 4, !tbaa !21
  %332 = load ptr, ptr %21, align 8, !tbaa !5
  %333 = load ptr, ptr %13, align 8, !tbaa !5
  %334 = getelementptr inbounds %struct.nonlinear, ptr %333, i32 0, i32 9
  %335 = load i32, ptr %334, align 4, !tbaa !17
  %336 = load ptr, ptr %23, align 8, !tbaa !5
  %337 = load ptr, ptr %13, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.nonlinear, ptr %337, i32 0, i32 45
  %339 = getelementptr inbounds [2048 x i8], ptr %338, i64 0, i64 0
  %340 = call i32 @array_spline_table_lines(ptr noundef %328, i32 noundef %331, ptr noundef %332, i32 noundef %335, ptr noundef %336, i16 noundef signext 0, ptr noundef %339)
  %341 = icmp eq i32 %340, 1
  br i1 %341, label %342, label %351

342:                                              ; preds = %325
  call void @llvm.lifetime.start.p0(i64 2048, ptr %46) #5
  %343 = getelementptr inbounds [2048 x i8], ptr %46, i64 0, i64 0
  %344 = load ptr, ptr %13, align 8, !tbaa !5
  %345 = getelementptr inbounds %struct.nonlinear, ptr %344, i32 0, i32 45
  %346 = getelementptr inbounds [2048 x i8], ptr %345, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %343, ptr noundef @.str.4, ptr noundef @.str.23, ptr noundef %346)
  %347 = load ptr, ptr %13, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.nonlinear, ptr %347, i32 0, i32 45
  %349 = getelementptr inbounds [2048 x i8], ptr %348, i64 0, i64 0
  %350 = getelementptr inbounds [2048 x i8], ptr %46, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %349, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 538, ptr noundef %350)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %46) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

351:                                              ; preds = %325
  %352 = load ptr, ptr %13, align 8, !tbaa !5
  %353 = getelementptr inbounds %struct.nonlinear, ptr %352, i32 0, i32 21
  %354 = load ptr, ptr %353, align 8, !tbaa !20
  %355 = load ptr, ptr %13, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.nonlinear, ptr %355, i32 0, i32 19
  %357 = load i32, ptr %356, align 4, !tbaa !21
  %358 = load ptr, ptr %21, align 8, !tbaa !5
  %359 = load ptr, ptr %23, align 8, !tbaa !5
  %360 = load ptr, ptr %13, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.nonlinear, ptr %360, i32 0, i32 9
  %362 = load i32, ptr %361, align 4, !tbaa !17
  %363 = load double, ptr %15, align 8, !tbaa !11
  %364 = call double @log(double noundef %363) #5
  %365 = load ptr, ptr %19, align 8, !tbaa !5
  %366 = load ptr, ptr %13, align 8, !tbaa !5
  %367 = getelementptr inbounds %struct.nonlinear, ptr %366, i32 0, i32 9
  %368 = load i32, ptr %367, align 4, !tbaa !17
  %369 = load ptr, ptr %13, align 8, !tbaa !5
  %370 = getelementptr inbounds %struct.nonlinear, ptr %369, i32 0, i32 45
  %371 = getelementptr inbounds [2048 x i8], ptr %370, i64 0, i64 0
  %372 = call i32 @array_interpolate_spline(ptr noundef %354, i32 noundef %357, ptr noundef %358, ptr noundef %359, i32 noundef %362, double noundef %364, ptr noundef %24, ptr noundef %365, i32 noundef %368, ptr noundef %371)
  %373 = icmp eq i32 %372, 1
  br i1 %373, label %374, label %383

374:                                              ; preds = %351
  call void @llvm.lifetime.start.p0(i64 2048, ptr %47) #5
  %375 = getelementptr inbounds [2048 x i8], ptr %47, i64 0, i64 0
  %376 = load ptr, ptr %13, align 8, !tbaa !5
  %377 = getelementptr inbounds %struct.nonlinear, ptr %376, i32 0, i32 45
  %378 = getelementptr inbounds [2048 x i8], ptr %377, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %375, ptr noundef @.str.4, ptr noundef @.str.24, ptr noundef %378)
  %379 = load ptr, ptr %13, align 8, !tbaa !5
  %380 = getelementptr inbounds %struct.nonlinear, ptr %379, i32 0, i32 45
  %381 = getelementptr inbounds [2048 x i8], ptr %380, i64 0, i64 0
  %382 = getelementptr inbounds [2048 x i8], ptr %47, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %381, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 551, ptr noundef %382)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %47) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

383:                                              ; preds = %351
  %384 = load ptr, ptr %23, align 8, !tbaa !5
  call void @free(ptr noundef %384) #5
  store i32 0, ptr %25, align 4, !tbaa !9
  br label %385

385:                                              ; preds = %435, %383
  %386 = load i32, ptr %25, align 4, !tbaa !9
  %387 = load ptr, ptr %13, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.nonlinear, ptr %387, i32 0, i32 8
  %389 = load i32, ptr %388, align 8, !tbaa !15
  %390 = icmp slt i32 %386, %389
  br i1 %390, label %391, label %438

391:                                              ; preds = %385
  %392 = load i32, ptr %25, align 4, !tbaa !9
  %393 = load i32, ptr %25, align 4, !tbaa !9
  %394 = icmp sle i32 %392, %393
  br i1 %394, label %395, label %409

395:                                              ; preds = %391
  %396 = load i32, ptr %25, align 4, !tbaa !9
  %397 = load ptr, ptr %13, align 8, !tbaa !5
  %398 = getelementptr inbounds %struct.nonlinear, ptr %397, i32 0, i32 8
  %399 = load i32, ptr %398, align 8, !tbaa !15
  %400 = load i32, ptr %25, align 4, !tbaa !9
  %401 = mul nsw i32 %399, %400
  %402 = add nsw i32 %396, %401
  %403 = load i32, ptr %25, align 4, !tbaa !9
  %404 = load i32, ptr %25, align 4, !tbaa !9
  %405 = add nsw i32 %404, 1
  %406 = mul nsw i32 %403, %405
  %407 = sdiv i32 %406, 2
  %408 = sub nsw i32 %402, %407
  br label %423

409:                                              ; preds = %391
  %410 = load i32, ptr %25, align 4, !tbaa !9
  %411 = load ptr, ptr %13, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.nonlinear, ptr %411, i32 0, i32 8
  %413 = load i32, ptr %412, align 8, !tbaa !15
  %414 = load i32, ptr %25, align 4, !tbaa !9
  %415 = mul nsw i32 %413, %414
  %416 = add nsw i32 %410, %415
  %417 = load i32, ptr %25, align 4, !tbaa !9
  %418 = load i32, ptr %25, align 4, !tbaa !9
  %419 = add nsw i32 %418, 1
  %420 = mul nsw i32 %417, %419
  %421 = sdiv i32 %420, 2
  %422 = sub nsw i32 %416, %421
  br label %423

423:                                              ; preds = %409, %395
  %424 = phi i32 [ %408, %395 ], [ %422, %409 ]
  store i32 %424, ptr %27, align 4, !tbaa !9
  %425 = load ptr, ptr %19, align 8, !tbaa !5
  %426 = load i32, ptr %27, align 4, !tbaa !9
  %427 = sext i32 %426 to i64
  %428 = getelementptr inbounds double, ptr %425, i64 %427
  %429 = load double, ptr %428, align 8, !tbaa !11
  %430 = call double @exp(double noundef %429) #5
  %431 = load ptr, ptr %19, align 8, !tbaa !5
  %432 = load i32, ptr %27, align 4, !tbaa !9
  %433 = sext i32 %432 to i64
  %434 = getelementptr inbounds double, ptr %431, i64 %433
  store double %430, ptr %434, align 8, !tbaa !11
  br label %435

435:                                              ; preds = %423
  %436 = load i32, ptr %25, align 4, !tbaa !9
  %437 = add nsw i32 %436, 1
  store i32 %437, ptr %25, align 4, !tbaa !9
  br label %385, !llvm.loop !23

438:                                              ; preds = %385
  store i32 0, ptr %25, align 4, !tbaa !9
  br label %439

439:                                              ; preds = %580, %438
  %440 = load i32, ptr %25, align 4, !tbaa !9
  %441 = load ptr, ptr %13, align 8, !tbaa !5
  %442 = getelementptr inbounds %struct.nonlinear, ptr %441, i32 0, i32 8
  %443 = load i32, ptr %442, align 8, !tbaa !15
  %444 = icmp slt i32 %440, %443
  br i1 %444, label %445, label %583

445:                                              ; preds = %439
  %446 = load i32, ptr %25, align 4, !tbaa !9
  %447 = add nsw i32 %446, 1
  store i32 %447, ptr %26, align 4, !tbaa !9
  br label %448

448:                                              ; preds = %576, %445
  %449 = load i32, ptr %26, align 4, !tbaa !9
  %450 = load ptr, ptr %13, align 8, !tbaa !5
  %451 = getelementptr inbounds %struct.nonlinear, ptr %450, i32 0, i32 8
  %452 = load i32, ptr %451, align 8, !tbaa !15
  %453 = icmp slt i32 %449, %452
  br i1 %453, label %454, label %579

454:                                              ; preds = %448
  %455 = load i32, ptr %25, align 4, !tbaa !9
  %456 = load i32, ptr %25, align 4, !tbaa !9
  %457 = icmp sle i32 %455, %456
  br i1 %457, label %458, label %472

458:                                              ; preds = %454
  %459 = load i32, ptr %25, align 4, !tbaa !9
  %460 = load ptr, ptr %13, align 8, !tbaa !5
  %461 = getelementptr inbounds %struct.nonlinear, ptr %460, i32 0, i32 8
  %462 = load i32, ptr %461, align 8, !tbaa !15
  %463 = load i32, ptr %25, align 4, !tbaa !9
  %464 = mul nsw i32 %462, %463
  %465 = add nsw i32 %459, %464
  %466 = load i32, ptr %25, align 4, !tbaa !9
  %467 = load i32, ptr %25, align 4, !tbaa !9
  %468 = add nsw i32 %467, 1
  %469 = mul nsw i32 %466, %468
  %470 = sdiv i32 %469, 2
  %471 = sub nsw i32 %465, %470
  br label %486

472:                                              ; preds = %454
  %473 = load i32, ptr %25, align 4, !tbaa !9
  %474 = load ptr, ptr %13, align 8, !tbaa !5
  %475 = getelementptr inbounds %struct.nonlinear, ptr %474, i32 0, i32 8
  %476 = load i32, ptr %475, align 8, !tbaa !15
  %477 = load i32, ptr %25, align 4, !tbaa !9
  %478 = mul nsw i32 %476, %477
  %479 = add nsw i32 %473, %478
  %480 = load i32, ptr %25, align 4, !tbaa !9
  %481 = load i32, ptr %25, align 4, !tbaa !9
  %482 = add nsw i32 %481, 1
  %483 = mul nsw i32 %480, %482
  %484 = sdiv i32 %483, 2
  %485 = sub nsw i32 %479, %484
  br label %486

486:                                              ; preds = %472, %458
  %487 = phi i32 [ %471, %458 ], [ %485, %472 ]
  store i32 %487, ptr %27, align 4, !tbaa !9
  %488 = load i32, ptr %26, align 4, !tbaa !9
  %489 = load i32, ptr %26, align 4, !tbaa !9
  %490 = icmp sle i32 %488, %489
  br i1 %490, label %491, label %505

491:                                              ; preds = %486
  %492 = load i32, ptr %26, align 4, !tbaa !9
  %493 = load ptr, ptr %13, align 8, !tbaa !5
  %494 = getelementptr inbounds %struct.nonlinear, ptr %493, i32 0, i32 8
  %495 = load i32, ptr %494, align 8, !tbaa !15
  %496 = load i32, ptr %26, align 4, !tbaa !9
  %497 = mul nsw i32 %495, %496
  %498 = add nsw i32 %492, %497
  %499 = load i32, ptr %26, align 4, !tbaa !9
  %500 = load i32, ptr %26, align 4, !tbaa !9
  %501 = add nsw i32 %500, 1
  %502 = mul nsw i32 %499, %501
  %503 = sdiv i32 %502, 2
  %504 = sub nsw i32 %498, %503
  br label %519

505:                                              ; preds = %486
  %506 = load i32, ptr %26, align 4, !tbaa !9
  %507 = load ptr, ptr %13, align 8, !tbaa !5
  %508 = getelementptr inbounds %struct.nonlinear, ptr %507, i32 0, i32 8
  %509 = load i32, ptr %508, align 8, !tbaa !15
  %510 = load i32, ptr %26, align 4, !tbaa !9
  %511 = mul nsw i32 %509, %510
  %512 = add nsw i32 %506, %511
  %513 = load i32, ptr %26, align 4, !tbaa !9
  %514 = load i32, ptr %26, align 4, !tbaa !9
  %515 = add nsw i32 %514, 1
  %516 = mul nsw i32 %513, %515
  %517 = sdiv i32 %516, 2
  %518 = sub nsw i32 %512, %517
  br label %519

519:                                              ; preds = %505, %491
  %520 = phi i32 [ %504, %491 ], [ %518, %505 ]
  store i32 %520, ptr %28, align 4, !tbaa !9
  %521 = load i32, ptr %25, align 4, !tbaa !9
  %522 = load i32, ptr %26, align 4, !tbaa !9
  %523 = icmp sle i32 %521, %522
  br i1 %523, label %524, label %538

524:                                              ; preds = %519
  %525 = load i32, ptr %26, align 4, !tbaa !9
  %526 = load ptr, ptr %13, align 8, !tbaa !5
  %527 = getelementptr inbounds %struct.nonlinear, ptr %526, i32 0, i32 8
  %528 = load i32, ptr %527, align 8, !tbaa !15
  %529 = load i32, ptr %25, align 4, !tbaa !9
  %530 = mul nsw i32 %528, %529
  %531 = add nsw i32 %525, %530
  %532 = load i32, ptr %25, align 4, !tbaa !9
  %533 = load i32, ptr %25, align 4, !tbaa !9
  %534 = add nsw i32 %533, 1
  %535 = mul nsw i32 %532, %534
  %536 = sdiv i32 %535, 2
  %537 = sub nsw i32 %531, %536
  br label %552

538:                                              ; preds = %519
  %539 = load i32, ptr %25, align 4, !tbaa !9
  %540 = load ptr, ptr %13, align 8, !tbaa !5
  %541 = getelementptr inbounds %struct.nonlinear, ptr %540, i32 0, i32 8
  %542 = load i32, ptr %541, align 8, !tbaa !15
  %543 = load i32, ptr %26, align 4, !tbaa !9
  %544 = mul nsw i32 %542, %543
  %545 = add nsw i32 %539, %544
  %546 = load i32, ptr %26, align 4, !tbaa !9
  %547 = load i32, ptr %26, align 4, !tbaa !9
  %548 = add nsw i32 %547, 1
  %549 = mul nsw i32 %546, %548
  %550 = sdiv i32 %549, 2
  %551 = sub nsw i32 %545, %550
  br label %552

552:                                              ; preds = %538, %524
  %553 = phi i32 [ %537, %524 ], [ %551, %538 ]
  store i32 %553, ptr %29, align 4, !tbaa !9
  %554 = load ptr, ptr %19, align 8, !tbaa !5
  %555 = load i32, ptr %29, align 4, !tbaa !9
  %556 = sext i32 %555 to i64
  %557 = getelementptr inbounds double, ptr %554, i64 %556
  %558 = load double, ptr %557, align 8, !tbaa !11
  %559 = load ptr, ptr %19, align 8, !tbaa !5
  %560 = load i32, ptr %27, align 4, !tbaa !9
  %561 = sext i32 %560 to i64
  %562 = getelementptr inbounds double, ptr %559, i64 %561
  %563 = load double, ptr %562, align 8, !tbaa !11
  %564 = load ptr, ptr %19, align 8, !tbaa !5
  %565 = load i32, ptr %28, align 4, !tbaa !9
  %566 = sext i32 %565 to i64
  %567 = getelementptr inbounds double, ptr %564, i64 %566
  %568 = load double, ptr %567, align 8, !tbaa !11
  %569 = fmul double %563, %568
  %570 = call double @sqrt(double noundef %569) #5
  %571 = fmul double %558, %570
  %572 = load ptr, ptr %19, align 8, !tbaa !5
  %573 = load i32, ptr %29, align 4, !tbaa !9
  %574 = sext i32 %573 to i64
  %575 = getelementptr inbounds double, ptr %572, i64 %574
  store double %571, ptr %575, align 8, !tbaa !11
  br label %576

576:                                              ; preds = %552
  %577 = load i32, ptr %26, align 4, !tbaa !9
  %578 = add nsw i32 %577, 1
  store i32 %578, ptr %26, align 4, !tbaa !9
  br label %448, !llvm.loop !24

579:                                              ; preds = %448
  br label %580

580:                                              ; preds = %579
  %581 = load i32, ptr %25, align 4, !tbaa !9
  %582 = add nsw i32 %581, 1
  store i32 %582, ptr %25, align 4, !tbaa !9
  br label %439, !llvm.loop !25

583:                                              ; preds = %439
  br label %584

584:                                              ; preds = %583, %286
  br label %773

585:                                              ; preds = %187
  %586 = load ptr, ptr %11, align 8, !tbaa !5
  %587 = load ptr, ptr %13, align 8, !tbaa !5
  %588 = load i32, ptr %14, align 4, !tbaa !9
  %589 = load double, ptr %16, align 8, !tbaa !11
  %590 = load i32, ptr %17, align 4, !tbaa !9
  %591 = load ptr, ptr %20, align 8, !tbaa !5
  %592 = load ptr, ptr %21, align 8, !tbaa !5
  %593 = call i32 @nonlinear_pk_at_z(ptr noundef %586, ptr noundef %587, i32 noundef 0, i32 noundef %588, double noundef %589, i32 noundef %590, ptr noundef %591, ptr noundef %592)
  %594 = icmp eq i32 %593, 1
  br i1 %594, label %595, label %604

595:                                              ; preds = %585
  call void @llvm.lifetime.start.p0(i64 2048, ptr %48) #5
  %596 = getelementptr inbounds [2048 x i8], ptr %48, i64 0, i64 0
  %597 = load ptr, ptr %13, align 8, !tbaa !5
  %598 = getelementptr inbounds %struct.nonlinear, ptr %597, i32 0, i32 45
  %599 = getelementptr inbounds [2048 x i8], ptr %598, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %596, ptr noundef @.str.4, ptr noundef @.str.25, ptr noundef %599)
  %600 = load ptr, ptr %13, align 8, !tbaa !5
  %601 = getelementptr inbounds %struct.nonlinear, ptr %600, i32 0, i32 45
  %602 = getelementptr inbounds [2048 x i8], ptr %601, i64 0, i64 0
  %603 = getelementptr inbounds [2048 x i8], ptr %48, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %602, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 600, ptr noundef %603)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %48) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

604:                                              ; preds = %585
  %605 = load ptr, ptr %20, align 8, !tbaa !5
  %606 = getelementptr inbounds double, ptr %605, i64 0
  %607 = load double, ptr %606, align 8, !tbaa !11
  %608 = load ptr, ptr %18, align 8, !tbaa !5
  store double %607, ptr %608, align 8, !tbaa !11
  %609 = load i16, ptr %33, align 2, !tbaa !13
  %610 = sext i16 %609 to i32
  %611 = icmp eq i32 %610, 1
  br i1 %611, label %612, label %633

612:                                              ; preds = %604
  store i32 0, ptr %29, align 4, !tbaa !9
  br label %613

613:                                              ; preds = %629, %612
  %614 = load i32, ptr %29, align 4, !tbaa !9
  %615 = load ptr, ptr %13, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.nonlinear, ptr %615, i32 0, i32 9
  %617 = load i32, ptr %616, align 4, !tbaa !17
  %618 = icmp slt i32 %614, %617
  br i1 %618, label %619, label %632

619:                                              ; preds = %613
  %620 = load ptr, ptr %21, align 8, !tbaa !5
  %621 = load i32, ptr %29, align 4, !tbaa !9
  %622 = sext i32 %621 to i64
  %623 = getelementptr inbounds double, ptr %620, i64 %622
  %624 = load double, ptr %623, align 8, !tbaa !11
  %625 = load ptr, ptr %19, align 8, !tbaa !5
  %626 = load i32, ptr %29, align 4, !tbaa !9
  %627 = sext i32 %626 to i64
  %628 = getelementptr inbounds double, ptr %625, i64 %627
  store double %624, ptr %628, align 8, !tbaa !11
  br label %629

629:                                              ; preds = %619
  %630 = load i32, ptr %29, align 4, !tbaa !9
  %631 = add nsw i32 %630, 1
  store i32 %631, ptr %29, align 4, !tbaa !9
  br label %613, !llvm.loop !26

632:                                              ; preds = %613
  br label %633

633:                                              ; preds = %632, %604
  %634 = load ptr, ptr %13, align 8, !tbaa !5
  %635 = getelementptr inbounds %struct.nonlinear, ptr %634, i32 0, i32 9
  %636 = load i32, ptr %635, align 4, !tbaa !17
  %637 = sext i32 %636 to i64
  %638 = mul i64 8, %637
  %639 = call noalias ptr @malloc(i64 noundef %638) #6
  store ptr %639, ptr %31, align 8, !tbaa !5
  %640 = load ptr, ptr %31, align 8, !tbaa !5
  %641 = icmp eq ptr %640, null
  br i1 %641, label %642, label %655

642:                                              ; preds = %633
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #5
  %643 = load ptr, ptr %13, align 8, !tbaa !5
  %644 = getelementptr inbounds %struct.nonlinear, ptr %643, i32 0, i32 9
  %645 = load i32, ptr %644, align 4, !tbaa !17
  %646 = sext i32 %645 to i64
  %647 = mul i64 8, %646
  %648 = trunc i64 %647 to i32
  store i32 %648, ptr %49, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %50) #5
  %649 = getelementptr inbounds [2048 x i8], ptr %50, i64 0, i64 0
  %650 = load i32, ptr %49, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %649, ptr noundef @.str.15, ptr noundef @.str.26, i32 noundef %650)
  %651 = load ptr, ptr %13, align 8, !tbaa !5
  %652 = getelementptr inbounds %struct.nonlinear, ptr %651, i32 0, i32 45
  %653 = getelementptr inbounds [2048 x i8], ptr %652, i64 0, i64 0
  %654 = getelementptr inbounds [2048 x i8], ptr %50, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %653, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 615, ptr noundef %654)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %50) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #5
  br label %783

655:                                              ; preds = %633
  %656 = load ptr, ptr %12, align 8, !tbaa !5
  %657 = load ptr, ptr %13, align 8, !tbaa !5
  %658 = getelementptr inbounds %struct.nonlinear, ptr %657, i32 0, i32 7
  %659 = load i32, ptr %658, align 4, !tbaa !27
  %660 = load double, ptr %15, align 8, !tbaa !11
  %661 = load ptr, ptr %31, align 8, !tbaa !5
  %662 = call i32 @primordial_spectrum_at_k(ptr noundef %656, i32 noundef %659, i32 noundef 0, double noundef %660, ptr noundef %661)
  %663 = icmp eq i32 %662, 1
  br i1 %663, label %664, label %673

664:                                              ; preds = %655
  call void @llvm.lifetime.start.p0(i64 2048, ptr %51) #5
  %665 = getelementptr inbounds [2048 x i8], ptr %51, i64 0, i64 0
  %666 = load ptr, ptr %12, align 8, !tbaa !5
  %667 = getelementptr inbounds %struct.primordial, ptr %666, i32 0, i32 106
  %668 = getelementptr inbounds [2048 x i8], ptr %667, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %665, ptr noundef @.str.4, ptr noundef @.str.27, ptr noundef %668)
  %669 = load ptr, ptr %13, align 8, !tbaa !5
  %670 = getelementptr inbounds %struct.nonlinear, ptr %669, i32 0, i32 45
  %671 = getelementptr inbounds [2048 x i8], ptr %670, i64 0, i64 0
  %672 = getelementptr inbounds [2048 x i8], ptr %51, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %671, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 623, ptr noundef %672)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %51) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

673:                                              ; preds = %655
  %674 = load ptr, ptr %13, align 8, !tbaa !5
  %675 = getelementptr inbounds %struct.nonlinear, ptr %674, i32 0, i32 21
  %676 = load ptr, ptr %675, align 8, !tbaa !20
  %677 = getelementptr inbounds double, ptr %676, i64 0
  %678 = load double, ptr %677, align 8, !tbaa !11
  %679 = call double @exp(double noundef %678) #5
  store double %679, ptr %30, align 8, !tbaa !11
  %680 = load ptr, ptr %13, align 8, !tbaa !5
  %681 = getelementptr inbounds %struct.nonlinear, ptr %680, i32 0, i32 9
  %682 = load i32, ptr %681, align 4, !tbaa !17
  %683 = sext i32 %682 to i64
  %684 = mul i64 8, %683
  %685 = call noalias ptr @malloc(i64 noundef %684) #6
  store ptr %685, ptr %32, align 8, !tbaa !5
  %686 = load ptr, ptr %32, align 8, !tbaa !5
  %687 = icmp eq ptr %686, null
  br i1 %687, label %688, label %701

688:                                              ; preds = %673
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #5
  %689 = load ptr, ptr %13, align 8, !tbaa !5
  %690 = getelementptr inbounds %struct.nonlinear, ptr %689, i32 0, i32 9
  %691 = load i32, ptr %690, align 4, !tbaa !17
  %692 = sext i32 %691 to i64
  %693 = mul i64 8, %692
  %694 = trunc i64 %693 to i32
  store i32 %694, ptr %52, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2048, ptr %53) #5
  %695 = getelementptr inbounds [2048 x i8], ptr %53, i64 0, i64 0
  %696 = load i32, ptr %52, align 4, !tbaa !9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %695, ptr noundef @.str.15, ptr noundef @.str.28, i32 noundef %696)
  %697 = load ptr, ptr %13, align 8, !tbaa !5
  %698 = getelementptr inbounds %struct.nonlinear, ptr %697, i32 0, i32 45
  %699 = getelementptr inbounds [2048 x i8], ptr %698, i64 0, i64 0
  %700 = getelementptr inbounds [2048 x i8], ptr %53, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %699, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 631, ptr noundef %700)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %53) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #5
  br label %783

701:                                              ; preds = %673
  %702 = load ptr, ptr %12, align 8, !tbaa !5
  %703 = load ptr, ptr %13, align 8, !tbaa !5
  %704 = getelementptr inbounds %struct.nonlinear, ptr %703, i32 0, i32 7
  %705 = load i32, ptr %704, align 4, !tbaa !27
  %706 = load double, ptr %30, align 8, !tbaa !11
  %707 = load ptr, ptr %32, align 8, !tbaa !5
  %708 = call i32 @primordial_spectrum_at_k(ptr noundef %702, i32 noundef %705, i32 noundef 0, double noundef %706, ptr noundef %707)
  %709 = icmp eq i32 %708, 1
  br i1 %709, label %710, label %719

710:                                              ; preds = %701
  call void @llvm.lifetime.start.p0(i64 2048, ptr %54) #5
  %711 = getelementptr inbounds [2048 x i8], ptr %54, i64 0, i64 0
  %712 = load ptr, ptr %12, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.primordial, ptr %712, i32 0, i32 106
  %714 = getelementptr inbounds [2048 x i8], ptr %713, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %711, ptr noundef @.str.4, ptr noundef @.str.29, ptr noundef %714)
  %715 = load ptr, ptr %13, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.nonlinear, ptr %715, i32 0, i32 45
  %717 = getelementptr inbounds [2048 x i8], ptr %716, i64 0, i64 0
  %718 = getelementptr inbounds [2048 x i8], ptr %54, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %717, ptr noundef @.str.3, ptr noundef @__func__.nonlinear_pk_at_k_and_z, i32 noundef 639, ptr noundef %718)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %54) #5
  store i32 1, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

719:                                              ; preds = %701
  %720 = load double, ptr %15, align 8, !tbaa !11
  %721 = load ptr, ptr %31, align 8, !tbaa !5
  %722 = getelementptr inbounds double, ptr %721, i64 0
  %723 = load double, ptr %722, align 8, !tbaa !11
  %724 = fmul double %720, %723
  %725 = load double, ptr %30, align 8, !tbaa !11
  %726 = fdiv double %724, %725
  %727 = load ptr, ptr %32, align 8, !tbaa !5
  %728 = getelementptr inbounds double, ptr %727, i64 0
  %729 = load double, ptr %728, align 8, !tbaa !11
  %730 = fdiv double %726, %729
  %731 = load ptr, ptr %18, align 8, !tbaa !5
  %732 = load double, ptr %731, align 8, !tbaa !11
  %733 = fmul double %732, %730
  store double %733, ptr %731, align 8, !tbaa !11
  %734 = load i16, ptr %33, align 2, !tbaa !13
  %735 = sext i16 %734 to i32
  %736 = icmp eq i32 %735, 1
  br i1 %736, label %737, label %770

737:                                              ; preds = %719
  store i32 0, ptr %29, align 4, !tbaa !9
  br label %738

738:                                              ; preds = %766, %737
  %739 = load i32, ptr %29, align 4, !tbaa !9
  %740 = load ptr, ptr %13, align 8, !tbaa !5
  %741 = getelementptr inbounds %struct.nonlinear, ptr %740, i32 0, i32 9
  %742 = load i32, ptr %741, align 4, !tbaa !17
  %743 = icmp slt i32 %739, %742
  br i1 %743, label %744, label %769

744:                                              ; preds = %738
  %745 = load double, ptr %15, align 8, !tbaa !11
  %746 = load ptr, ptr %31, align 8, !tbaa !5
  %747 = load i32, ptr %29, align 4, !tbaa !9
  %748 = sext i32 %747 to i64
  %749 = getelementptr inbounds double, ptr %746, i64 %748
  %750 = load double, ptr %749, align 8, !tbaa !11
  %751 = fmul double %745, %750
  %752 = load double, ptr %30, align 8, !tbaa !11
  %753 = fdiv double %751, %752
  %754 = load ptr, ptr %32, align 8, !tbaa !5
  %755 = load i32, ptr %29, align 4, !tbaa !9
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds double, ptr %754, i64 %756
  %758 = load double, ptr %757, align 8, !tbaa !11
  %759 = fdiv double %753, %758
  %760 = load ptr, ptr %19, align 8, !tbaa !5
  %761 = load i32, ptr %29, align 4, !tbaa !9
  %762 = sext i32 %761 to i64
  %763 = getelementptr inbounds double, ptr %760, i64 %762
  %764 = load double, ptr %763, align 8, !tbaa !11
  %765 = fmul double %764, %759
  store double %765, ptr %763, align 8, !tbaa !11
  br label %766

766:                                              ; preds = %744
  %767 = load i32, ptr %29, align 4, !tbaa !9
  %768 = add nsw i32 %767, 1
  store i32 %768, ptr %29, align 4, !tbaa !9
  br label %738, !llvm.loop !28

769:                                              ; preds = %738
  br label %770

770:                                              ; preds = %769, %719
  %771 = load ptr, ptr %31, align 8, !tbaa !5
  call void @free(ptr noundef %771) #5
  %772 = load ptr, ptr %32, align 8, !tbaa !5
  call void @free(ptr noundef %772) #5
  br label %773

773:                                              ; preds = %770, %584
  %774 = load ptr, ptr %20, align 8, !tbaa !5
  call void @free(ptr noundef %774) #5
  %775 = load i16, ptr %33, align 2, !tbaa !13
  %776 = sext i16 %775 to i32
  %777 = icmp eq i32 %776, 1
  br i1 %777, label %778, label %780

778:                                              ; preds = %773
  %779 = load ptr, ptr %21, align 8, !tbaa !5
  call void @free(ptr noundef %779) #5
  br label %780

780:                                              ; preds = %778, %773
  br label %781

781:                                              ; preds = %780, %129
  br label %782

782:                                              ; preds = %781, %90
  store i32 0, ptr %10, align 4
  store i32 1, ptr %36, align 4
  br label %783

783:                                              ; preds = %782, %710, %688, %664, %642, %595, %374, %342, %308, %277, %251, %224, %206, %169, %139
  call void @llvm.lifetime.end.p0(i64 2, ptr %33) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  call void @llvm.lifetime.end.p0(i64 8, 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 8, ptr %20) #5
  %784 = load i32, ptr %10, align 4
  ret i32 %784
}

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #4

declare i32 @array_spline_table_lines(ptr noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, i16 noundef signext, ptr noundef) #2

; Function Attrs: nounwind
declare void @free(ptr noundef) #3

declare i32 @primordial_spectrum_at_k(ptr noundef, i32 noundef, i32 noundef, double noundef, ptr noundef) #2

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

!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 = !{!"int", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"double", !7, i64 0}
!13 = !{!14, !14, i64 0}
!14 = !{!"short", !7, i64 0}
!15 = !{!16, !10, i64 48}
!16 = !{!"nonlinear", !10, i64 0, !10, i64 4, !10, i64 8, !12, i64 16, !12, i64 24, !12, i64 32, !14, i64 40, !10, i64 44, !10, i64 48, !10, i64 52, !6, i64 56, !14, i64 64, !14, i64 66, !10, i64 68, !10, i64 72, !10, i64 76, !10, i64 80, !10, i64 84, !14, i64 88, !10, i64 92, !6, i64 96, !6, i64 104, !6, i64 112, !10, i64 120, !6, i64 128, !6, i64 136, !6, i64 144, !6, i64 152, !6, i64 160, !6, i64 168, !6, i64 176, !10, i64 184, !10, i64 188, !6, i64 192, !6, i64 200, !6, i64 208, !10, i64 216, !10, i64 220, !10, i64 224, !10, i64 228, !10, i64 232, !6, i64 240, !6, i64 248, !6, i64 256, !14, i64 264, !7, i64 266}
!17 = !{!16, !10, i64 52}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!16, !6, i64 104}
!21 = !{!16, !10, i64 92}
!22 = distinct !{!22, !19}
!23 = distinct !{!23, !19}
!24 = distinct !{!24, !19}
!25 = distinct !{!25, !19}
!26 = distinct !{!26, !19}
!27 = !{!16, !10, i64 44}
!28 = distinct !{!28, !19}


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

@.str.3 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [12 x i8], align 1
@__func__.nonlinear_pk_at_k_and_z = external hidden unnamed_addr constant [24 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [95 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [103 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [132 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [123 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [169 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [90 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [81 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [87 x i8], align 1

; Function Attrs: nounwind uwtable
declare dso_local i32 @nonlinear_pk_at_z(ptr noundef, ptr noundef, i32 noundef, i32 noundef, double noundef, i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

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

declare void @class_protect_sprintf(ptr noundef, ptr noundef, ...) local_unnamed_addr #2

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

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

declare i32 @array_interpolate_spline(ptr noundef, i32 noundef, ptr noundef, ptr noundef, i32 noundef, double noundef, ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #2

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

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

; Function Attrs: nounwind uwtable
define dso_local range(i32 0, 2) i32 @nonlinear_pk_at_k_and_z(ptr noundef %0, ptr noundef %1, ptr noundef %2, i32 noundef %3, double noundef %4, double noundef %5, i32 noundef %6, ptr noundef %7, ptr noundef %8) local_unnamed_addr #0 {
  %10 = alloca i32, align 4
  %11 = alloca [2048 x i8], align 16
  %12 = alloca [2048 x i8], align 16
  %13 = alloca [2048 x i8], align 16
  %14 = alloca [2048 x i8], align 16
  %15 = alloca [2048 x i8], align 16
  %16 = alloca [2048 x i8], align 16
  %17 = alloca [2048 x i8], align 16
  %18 = alloca [2048 x i8], align 16
  %19 = alloca [2048 x i8], align 16
  %20 = alloca [2048 x i8], align 16
  %21 = alloca [2048 x i8], align 16
  %22 = alloca [2048 x i8], align 16
  %23 = alloca [2048 x i8], align 16
  %24 = alloca [2048 x i8], align 16
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %10) #8
  %25 = icmp eq i32 %3, 0
  br i1 %25, label %26, label %.thread

26:                                               ; preds = %9
  %27 = getelementptr inbounds i8, ptr %2, i64 48
  %28 = load i32, ptr %27, align 8, !tbaa !5
  %29 = icmp sgt i32 %28, 1
  %30 = icmp ne ptr %8, null
  %or.cond = and i1 %30, %29
  %31 = fcmp oeq double %4, 0.000000e+00
  br i1 %31, label %33, label %39

.thread:                                          ; preds = %9
  %32 = fcmp oeq double %4, 0.000000e+00
  br i1 %32, label %.thread248, label %39

.thread248:                                       ; preds = %.thread
  store double 0.000000e+00, ptr %7, align 8, !tbaa !13
  br label %.loopexit

33:                                               ; preds = %26
  store double 0.000000e+00, ptr %7, align 8, !tbaa !13
  br i1 %or.cond, label %.preheader, label %.loopexit

.preheader:                                       ; preds = %33
  %34 = getelementptr inbounds i8, ptr %2, i64 52
  %35 = load i32, ptr %34, align 4, !tbaa !14
  %36 = icmp sgt i32 %35, 0
  br i1 %36, label %.lr.ph271.preheader, label %.loopexit

.lr.ph271.preheader:                              ; preds = %.preheader
  %37 = zext nneg i32 %35 to i64
  %38 = shl nuw nsw i64 %37, 3
  tail call void @llvm.memset.p0.i64(ptr nonnull align 8 %8, i8 0, i64 %38, i1 false), !tbaa !13
  br label %.loopexit

39:                                               ; preds = %.thread, %26
  %40 = phi i1 [ false, %.thread ], [ %or.cond, %26 ]
  %41 = fcmp olt double %4, 0.000000e+00
  br i1 %41, label %53, label %42

42:                                               ; preds = %39
  %43 = getelementptr inbounds i8, ptr %2, i64 104
  %44 = load ptr, ptr %43, align 8, !tbaa !15
  %45 = getelementptr inbounds i8, ptr %2, i64 92
  %46 = load i32, ptr %45, align 4, !tbaa !16
  %47 = sext i32 %46 to i64
  %48 = getelementptr double, ptr %44, i64 %47
  %49 = getelementptr i8, ptr %48, i64 -8
  %50 = load double, ptr %49, align 8, !tbaa !13
  %51 = tail call double @exp(double noundef %50) #8
  %52 = fcmp olt double %51, %4
  br i1 %52, label %53, label %59

53:                                               ; preds = %42, %39
  store double 0.000000e+00, ptr %7, align 8, !tbaa !13
  br i1 %40, label %.preheader250, label %.loopexit

.preheader250:                                    ; preds = %53
  %54 = getelementptr inbounds i8, ptr %2, i64 52
  %55 = load i32, ptr %54, align 4, !tbaa !14
  %56 = icmp sgt i32 %55, 0
  br i1 %56, label %.lr.ph269.preheader, label %.loopexit

.lr.ph269.preheader:                              ; preds = %.preheader250
  %57 = zext nneg i32 %55 to i64
  %58 = shl nuw nsw i64 %57, 3
  tail call void @llvm.memset.p0.i64(ptr align 8 %8, i8 0, i64 %58, i1 false), !tbaa !13
  br label %.loopexit

59:                                               ; preds = %42
  %60 = load i32, ptr %45, align 4, !tbaa !16
  %61 = sext i32 %60 to i64
  %62 = shl nsw i64 %61, 3
  %63 = tail call noalias ptr @malloc(i64 noundef %62) #9
  %64 = icmp eq ptr %63, null
  br i1 %64, label %65, label %68

65:                                               ; preds = %59
  %66 = shl i32 %60, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %11) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %11, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.16, i32 noundef %66) #8
  %67 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %67, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 445, ptr noundef nonnull %11) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %11) #8
  br label %.loopexit

68:                                               ; preds = %59
  br i1 %40, label %69, label %80

69:                                               ; preds = %68
  %70 = getelementptr inbounds i8, ptr %2, i64 52
  %71 = load i32, ptr %70, align 4, !tbaa !14
  %72 = mul nsw i32 %71, %60
  %73 = sext i32 %72 to i64
  %74 = shl nsw i64 %73, 3
  %75 = tail call noalias ptr @malloc(i64 noundef %74) #9
  %76 = icmp eq ptr %75, null
  br i1 %76, label %77, label %80

77:                                               ; preds = %69
  %78 = shl i32 %72, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %12) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %12, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.17, i32 noundef %78) #8
  %79 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %79, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 450, ptr noundef nonnull %12) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %12) #8
  br label %.loopexit

80:                                               ; preds = %69, %68
  %.0233 = phi ptr [ %75, %69 ], [ null, %68 ]
  %81 = load ptr, ptr %43, align 8, !tbaa !15
  %82 = load double, ptr %81, align 8, !tbaa !13
  %83 = tail call double @exp(double noundef %82) #8
  %84 = fcmp olt double %83, %4
  br i1 %84, label %85, label %199

85:                                               ; preds = %80
  %86 = tail call i32 @nonlinear_pk_at_z(ptr noundef %0, ptr noundef nonnull %2, i32 noundef 1, i32 noundef %3, double noundef %5, i32 noundef %6, ptr noundef nonnull %63, ptr noundef %.0233)
  %87 = icmp eq i32 %86, 1
  br i1 %87, label %88, label %90

88:                                               ; preds = %85
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %13) #8
  %89 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %13, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.18, ptr noundef nonnull %89) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %89, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 469, ptr noundef nonnull %13) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %13) #8
  br label %.loopexit

90:                                               ; preds = %85
  %91 = load i32, ptr %45, align 4, !tbaa !16
  %92 = sext i32 %91 to i64
  %93 = shl nsw i64 %92, 3
  %94 = tail call noalias ptr @malloc(i64 noundef %93) #9
  %95 = icmp eq ptr %94, null
  br i1 %95, label %96, label %99

96:                                               ; preds = %90
  %97 = shl i32 %91, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %14) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %14, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.19, i32 noundef %97) #8
  %98 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %98, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 475, ptr noundef nonnull %14) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %14) #8
  br label %.loopexit

99:                                               ; preds = %90
  %100 = load ptr, ptr %43, align 8, !tbaa !15
  %101 = getelementptr inbounds i8, ptr %2, i64 266
  %102 = tail call i32 @array_spline_table_lines(ptr noundef %100, i32 noundef %91, ptr noundef nonnull %63, i32 noundef 1, ptr noundef nonnull %94, i16 noundef signext 0, ptr noundef nonnull %101) #8
  %103 = icmp eq i32 %102, 1
  br i1 %103, label %104, label %105

104:                                              ; preds = %99
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %15) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %15, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.20, ptr noundef nonnull %101) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %101, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 485, ptr noundef nonnull %15) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %15) #8
  br label %.loopexit

105:                                              ; preds = %99
  %106 = load ptr, ptr %43, align 8, !tbaa !15
  %107 = load i32, ptr %45, align 4, !tbaa !16
  %108 = tail call double @log(double noundef %4) #8
  %109 = call i32 @array_interpolate_spline(ptr noundef %106, i32 noundef %107, ptr noundef nonnull %63, ptr noundef nonnull %94, i32 noundef 1, double noundef %108, ptr noundef nonnull %10, ptr noundef %7, i32 noundef 1, ptr noundef nonnull %101) #8
  %110 = icmp eq i32 %109, 1
  br i1 %110, label %111, label %112

111:                                              ; preds = %105
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %16) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %16, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.21, ptr noundef nonnull %101) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %101, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 498, ptr noundef nonnull %16) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %16) #8
  br label %.loopexit

112:                                              ; preds = %105
  call void @free(ptr noundef nonnull %94) #8
  %113 = load double, ptr %7, align 8, !tbaa !13
  %114 = call double @exp(double noundef %113) #8
  store double %114, ptr %7, align 8, !tbaa !13
  br i1 %40, label %115, label %.critedge

115:                                              ; preds = %112
  %116 = load i32, ptr %45, align 4, !tbaa !16
  %117 = getelementptr inbounds i8, ptr %2, i64 52
  %118 = load i32, ptr %117, align 4, !tbaa !14
  %119 = mul nsw i32 %118, %116
  %120 = sext i32 %119 to i64
  %121 = shl nsw i64 %120, 3
  %122 = call noalias ptr @malloc(i64 noundef %121) #9
  %123 = icmp eq ptr %122, null
  br i1 %123, label %124, label %126

124:                                              ; preds = %115
  %125 = shl i32 %119, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %17) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %17, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.22, i32 noundef %125) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %101, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 528, ptr noundef nonnull %17) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %17) #8
  br label %.loopexit

126:                                              ; preds = %115
  %127 = load ptr, ptr %43, align 8, !tbaa !15
  %128 = call i32 @array_spline_table_lines(ptr noundef %127, i32 noundef %116, ptr noundef %.0233, i32 noundef %118, ptr noundef nonnull %122, i16 noundef signext 0, ptr noundef nonnull %101) #8
  %129 = icmp eq i32 %128, 1
  br i1 %129, label %130, label %131

130:                                              ; preds = %126
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %18) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %18, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.23, ptr noundef nonnull %101) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %101, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 538, ptr noundef nonnull %18) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %18) #8
  br label %.loopexit

131:                                              ; preds = %126
  %132 = load ptr, ptr %43, align 8, !tbaa !15
  %133 = load i32, ptr %45, align 4, !tbaa !16
  %134 = load i32, ptr %117, align 4, !tbaa !14
  %135 = call double @log(double noundef %4) #8
  %136 = load i32, ptr %117, align 4, !tbaa !14
  %137 = call i32 @array_interpolate_spline(ptr noundef %132, i32 noundef %133, ptr noundef %.0233, ptr noundef nonnull %122, i32 noundef %134, double noundef %135, ptr noundef nonnull %10, ptr noundef %8, i32 noundef %136, ptr noundef nonnull %101) #8
  %138 = icmp eq i32 %137, 1
  br i1 %138, label %139, label %140

139:                                              ; preds = %131
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %19) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %19, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.24, ptr noundef nonnull %101) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %101, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 551, ptr noundef nonnull %19) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %19) #8
  br label %.loopexit

140:                                              ; preds = %131
  call void @free(ptr noundef nonnull %122) #8
  %141 = getelementptr inbounds i8, ptr %2, i64 48
  %142 = load i32, ptr %141, align 8, !tbaa !5
  %143 = icmp sgt i32 %142, 0
  br i1 %143, label %.lr.ph263, label %.loopexit254.thread

.loopexit254.thread:                              ; preds = %140
  call void @free(ptr noundef nonnull %63) #8
  br label %274

.preheader253:                                    ; preds = %.lr.ph263
  %144 = icmp sgt i32 %156, 0
  br i1 %144, label %.lr.ph267, label %.loopexit254

.lr.ph263:                                        ; preds = %140, %.lr.ph263
  %145 = phi i32 [ %156, %.lr.ph263 ], [ %142, %140 ]
  %.0234262 = phi i32 [ %148, %.lr.ph263 ], [ 0, %140 ]
  %146 = add i32 %145, 1
  %147 = mul i32 %146, %.0234262
  %148 = add nuw nsw i32 %.0234262, 1
  %149 = mul nuw nsw i32 %148, %.0234262
  %150 = lshr i32 %149, 1
  %151 = sub nsw i32 %147, %150
  %152 = sext i32 %151 to i64
  %153 = getelementptr inbounds double, ptr %8, i64 %152
  %154 = load double, ptr %153, align 8, !tbaa !13
  %155 = call double @exp(double noundef %154) #8
  store double %155, ptr %153, align 8, !tbaa !13
  %156 = load i32, ptr %141, align 8, !tbaa !5
  %157 = icmp slt i32 %148, %156
  br i1 %157, label %.lr.ph263, label %.preheader253, !llvm.loop !17

.loopexit252:                                     ; preds = %183, %.lr.ph267
  %158 = phi i32 [ %160, %.lr.ph267 ], [ %197, %183 ]
  %159 = icmp slt i32 %161, %158
  br i1 %159, label %.lr.ph267, label %.loopexit254, !llvm.loop !19

.lr.ph267:                                        ; preds = %.preheader253, %.loopexit252
  %160 = phi i32 [ %158, %.loopexit252 ], [ %156, %.preheader253 ]
  %.1266 = phi i32 [ %161, %.loopexit252 ], [ 0, %.preheader253 ]
  %161 = add nuw nsw i32 %.1266, 1
  %162 = icmp slt i32 %161, %160
  br i1 %162, label %.lr.ph265, label %.loopexit252

.lr.ph265:                                        ; preds = %.lr.ph267
  %163 = mul nuw nsw i32 %161, %.1266
  %164 = lshr i32 %163, 1
  br label %165

165:                                              ; preds = %.lr.ph265, %183
  %166 = phi i32 [ %160, %.lr.ph265 ], [ %197, %183 ]
  %.0235264 = phi i32 [ %161, %.lr.ph265 ], [ %171, %183 ]
  %167 = add i32 %166, 1
  %168 = mul i32 %167, %.1266
  %169 = sub nsw i32 %168, %164
  %170 = mul i32 %167, %.0235264
  %171 = add nuw nsw i32 %.0235264, 1
  %172 = mul nuw nsw i32 %171, %.0235264
  %173 = lshr i32 %172, 1
  %174 = sub nsw i32 %170, %173
  %.not = icmp ugt i32 %.1266, %.0235264
  br i1 %.not, label %179, label %175

175:                                              ; preds = %165
  %176 = mul nsw i32 %166, %.1266
  %177 = sub nsw i32 %.0235264, %164
  %178 = add i32 %177, %176
  br label %183

179:                                              ; preds = %165
  %180 = mul nsw i32 %166, %.0235264
  %181 = add nsw i32 %180, %.1266
  %182 = sub i32 %181, %173
  br label %183

183:                                              ; preds = %179, %175
  %184 = phi i32 [ %178, %175 ], [ %182, %179 ]
  %185 = sext i32 %184 to i64
  %186 = getelementptr inbounds double, ptr %8, i64 %185
  %187 = load double, ptr %186, align 8, !tbaa !13
  %188 = sext i32 %169 to i64
  %189 = getelementptr inbounds double, ptr %8, i64 %188
  %190 = load double, ptr %189, align 8, !tbaa !13
  %191 = sext i32 %174 to i64
  %192 = getelementptr inbounds double, ptr %8, i64 %191
  %193 = load double, ptr %192, align 8, !tbaa !13
  %194 = fmul double %190, %193
  %195 = call double @sqrt(double noundef %194) #8
  %196 = fmul double %187, %195
  store double %196, ptr %186, align 8, !tbaa !13
  %197 = load i32, ptr %141, align 8, !tbaa !5
  %198 = icmp slt i32 %171, %197
  br i1 %198, label %165, label %.loopexit252, !llvm.loop !20

199:                                              ; preds = %80
  %200 = tail call i32 @nonlinear_pk_at_z(ptr noundef %0, ptr noundef nonnull %2, i32 noundef 0, i32 noundef %3, double noundef %5, i32 noundef %6, ptr noundef nonnull %63, ptr noundef %.0233)
  %201 = icmp eq i32 %200, 1
  br i1 %201, label %202, label %204

202:                                              ; preds = %199
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %20) #8
  %203 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %20, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.25, ptr noundef nonnull %203) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %203, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 600, ptr noundef nonnull %20) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %20) #8
  br label %.loopexit

204:                                              ; preds = %199
  %205 = load double, ptr %63, align 8, !tbaa !13
  store double %205, ptr %7, align 8, !tbaa !13
  %206 = getelementptr inbounds i8, ptr %2, i64 52
  %207 = load i32, ptr %206, align 4, !tbaa !14
  %208 = icmp sgt i32 %207, 0
  %or.cond282 = select i1 %40, i1 %208, i1 false
  br i1 %or.cond282, label %.lr.ph.preheader, label %.loopexit258

.lr.ph.preheader:                                 ; preds = %204
  %209 = zext nneg i32 %207 to i64
  %210 = shl nuw nsw i64 %209, 3
  tail call void @llvm.memcpy.p0.p0.i64(ptr align 8 %8, ptr align 8 %.0233, i64 %210, i1 false), !tbaa !13
  br label %.loopexit258

.loopexit258:                                     ; preds = %204, %.lr.ph.preheader
  %211 = getelementptr inbounds i8, ptr %2, i64 52
  %212 = sext i32 %207 to i64
  %213 = shl nsw i64 %212, 3
  %214 = tail call noalias ptr @malloc(i64 noundef %213) #9
  %215 = icmp eq ptr %214, null
  br i1 %215, label %216, label %219

216:                                              ; preds = %.loopexit258
  %217 = shl i32 %207, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %21) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %21, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.26, i32 noundef %217) #8
  %218 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %218, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 615, ptr noundef nonnull %21) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %21) #8
  br label %.loopexit

219:                                              ; preds = %.loopexit258
  %220 = getelementptr inbounds i8, ptr %2, i64 44
  %221 = load i32, ptr %220, align 4, !tbaa !21
  %222 = tail call i32 @primordial_spectrum_at_k(ptr noundef %1, i32 noundef %221, i32 noundef 0, double noundef %4, ptr noundef nonnull %214) #8
  %223 = icmp eq i32 %222, 1
  br i1 %223, label %224, label %227

224:                                              ; preds = %219
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %22) #8
  %225 = getelementptr inbounds i8, ptr %1, i64 794
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %22, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.27, ptr noundef nonnull %225) #8
  %226 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %226, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 623, ptr noundef nonnull %22) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %22) #8
  br label %.loopexit

227:                                              ; preds = %219
  %228 = load ptr, ptr %43, align 8, !tbaa !15
  %229 = load double, ptr %228, align 8, !tbaa !13
  %230 = tail call double @exp(double noundef %229) #8
  %231 = load i32, ptr %211, align 4, !tbaa !14
  %232 = sext i32 %231 to i64
  %233 = shl nsw i64 %232, 3
  %234 = tail call noalias ptr @malloc(i64 noundef %233) #9
  %235 = icmp eq ptr %234, null
  br i1 %235, label %236, label %239

236:                                              ; preds = %227
  %237 = shl i32 %231, 3
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %23) #8
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %23, ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.28, i32 noundef %237) #8
  %238 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %238, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 631, ptr noundef nonnull %23) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %23) #8
  br label %.loopexit

239:                                              ; preds = %227
  %240 = load i32, ptr %220, align 4, !tbaa !21
  %241 = tail call i32 @primordial_spectrum_at_k(ptr noundef %1, i32 noundef %240, i32 noundef 0, double noundef %230, ptr noundef nonnull %234) #8
  %242 = icmp eq i32 %241, 1
  br i1 %242, label %243, label %246

243:                                              ; preds = %239
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %24) #8
  %244 = getelementptr inbounds i8, ptr %1, i64 794
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %24, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.29, ptr noundef nonnull %244) #8
  %245 = getelementptr inbounds i8, ptr %2, i64 266
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %245, ptr noundef nonnull @.str.3, ptr noundef nonnull @__func__.nonlinear_pk_at_k_and_z, i32 noundef 639, ptr noundef nonnull %24) #8
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %24) #8
  br label %.loopexit

246:                                              ; preds = %239
  %247 = load double, ptr %214, align 8, !tbaa !13
  %248 = fmul double %247, %4
  %249 = fdiv double %248, %230
  %250 = load double, ptr %234, align 8, !tbaa !13
  %251 = fdiv double %249, %250
  %252 = load double, ptr %7, align 8, !tbaa !13
  %253 = fmul double %252, %251
  store double %253, ptr %7, align 8, !tbaa !13
  br i1 %40, label %.preheader255, label %.loopexit256

.preheader255:                                    ; preds = %246
  %254 = load i32, ptr %211, align 4, !tbaa !14
  %255 = icmp sgt i32 %254, 0
  br i1 %255, label %.lr.ph261.preheader, label %.loopexit256

.lr.ph261.preheader:                              ; preds = %.preheader255
  %wide.trip.count = zext nneg i32 %254 to i64
  %min.iters.check = icmp eq i32 %254, 1
  br i1 %min.iters.check, label %.lr.ph261.preheader289, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph261.preheader
  %n.vec = and i64 %wide.trip.count, 2147483646
  %broadcast.splatinsert = insertelement <2 x double> poison, double %4, i64 0
  %broadcast.splat = shufflevector <2 x double> %broadcast.splatinsert, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert284 = insertelement <2 x double> poison, double %230, i64 0
  %broadcast.splat285 = shufflevector <2 x double> %broadcast.splatinsert284, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %256 = getelementptr inbounds double, ptr %214, i64 %index
  %wide.load = load <2 x double>, ptr %256, align 8, !tbaa !13
  %257 = fmul <2 x double> %wide.load, %broadcast.splat
  %258 = fdiv <2 x double> %257, %broadcast.splat285
  %259 = getelementptr inbounds double, ptr %234, i64 %index
  %wide.load286 = load <2 x double>, ptr %259, align 8, !tbaa !13
  %260 = fdiv <2 x double> %258, %wide.load286
  %261 = getelementptr inbounds double, ptr %8, i64 %index
  %wide.load287 = load <2 x double>, ptr %261, align 8, !tbaa !13
  %262 = fmul <2 x double> %wide.load287, %260
  store <2 x double> %262, ptr %261, align 8, !tbaa !13
  %index.next = add nuw i64 %index, 2
  %263 = icmp eq i64 %index.next, %n.vec
  br i1 %263, label %middle.block, label %vector.body, !llvm.loop !22

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %.loopexit256, label %.lr.ph261.preheader289

.lr.ph261.preheader289:                           ; preds = %middle.block, %.lr.ph261.preheader
  %indvars.iv.ph = phi i64 [ 0, %.lr.ph261.preheader ], [ %n.vec, %middle.block ]
  br label %.lr.ph261

.lr.ph261:                                        ; preds = %.lr.ph261.preheader289, %.lr.ph261
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph261 ], [ %indvars.iv.ph, %.lr.ph261.preheader289 ]
  %264 = getelementptr inbounds double, ptr %214, i64 %indvars.iv
  %265 = load double, ptr %264, align 8, !tbaa !13
  %266 = fmul double %265, %4
  %267 = fdiv double %266, %230
  %268 = getelementptr inbounds double, ptr %234, i64 %indvars.iv
  %269 = load double, ptr %268, align 8, !tbaa !13
  %270 = fdiv double %267, %269
  %271 = getelementptr inbounds double, ptr %8, i64 %indvars.iv
  %272 = load double, ptr %271, align 8, !tbaa !13
  %273 = fmul double %272, %270
  store double %273, ptr %271, align 8, !tbaa !13
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %.loopexit256, label %.lr.ph261, !llvm.loop !25

.loopexit256:                                     ; preds = %.lr.ph261, %middle.block, %.preheader255, %246
  tail call void @free(ptr noundef nonnull %214) #8
  tail call void @free(ptr noundef nonnull %234) #8
  br label %.loopexit254

.loopexit254:                                     ; preds = %.loopexit252, %.preheader253, %.loopexit256
  call void @free(ptr noundef %63) #8
  br i1 %40, label %274, label %.loopexit

274:                                              ; preds = %.loopexit254.thread, %.loopexit254
  call void @free(ptr noundef %.0233) #8
  br label %.loopexit

.critedge:                                        ; preds = %112
  call void @free(ptr noundef nonnull %63) #8
  br label %.loopexit

.loopexit:                                        ; preds = %.lr.ph269.preheader, %.lr.ph271.preheader, %.preheader250, %.preheader, %.thread248, %33, %.loopexit254, %274, %53, %.critedge, %243, %236, %224, %216, %202, %139, %130, %124, %111, %104, %96, %88, %77, %65
  %.0 = phi i32 [ 1, %65 ], [ 1, %77 ], [ 1, %88 ], [ 1, %96 ], [ 1, %104 ], [ 1, %111 ], [ 1, %124 ], [ 1, %130 ], [ 1, %139 ], [ 1, %202 ], [ 1, %216 ], [ 1, %224 ], [ 1, %236 ], [ 1, %243 ], [ 0, %.critedge ], [ 0, %53 ], [ 0, %274 ], [ 0, %.loopexit254 ], [ 0, %33 ], [ 0, %.thread248 ], [ 0, %.preheader ], [ 0, %.preheader250 ], [ 0, %.lr.ph271.preheader ], [ 0, %.lr.ph269.preheader ]
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #8
  ret i32 %.0
}

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #4

declare i32 @array_spline_table_lines(ptr noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, i16 noundef signext, ptr noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #5

declare i32 @primordial_spectrum_at_k(ptr noundef, i32 noundef, i32 noundef, double noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #6

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { mustprogress nofree nounwind willreturn memory(write) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "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 #6 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #7 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #8 = { nounwind }
attributes #9 = { nounwind allocsize(0) }

!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 48}
!6 = !{!"nonlinear", !7, i64 0, !7, i64 4, !7, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !11, i64 40, !7, i64 44, !7, i64 48, !7, i64 52, !12, i64 56, !11, i64 64, !11, i64 66, !7, i64 68, !7, i64 72, !7, i64 76, !7, i64 80, !7, i64 84, !11, i64 88, !7, i64 92, !12, i64 96, !12, i64 104, !12, i64 112, !7, i64 120, !12, i64 128, !12, i64 136, !12, i64 144, !12, i64 152, !12, i64 160, !12, i64 168, !12, i64 176, !7, i64 184, !7, i64 188, !12, i64 192, !12, i64 200, !12, i64 208, !7, i64 216, !7, i64 220, !7, i64 224, !7, i64 228, !7, i64 232, !12, i64 240, !12, i64 248, !12, i64 256, !11, i64 264, !8, i64 266}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"double", !8, i64 0}
!11 = !{!"short", !8, i64 0}
!12 = !{!"any pointer", !8, i64 0}
!13 = !{!10, !10, i64 0}
!14 = !{!6, !7, i64 52}
!15 = !{!6, !12, i64 104}
!16 = !{!6, !7, i64 92}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = distinct !{!19, !18}
!20 = distinct !{!20, !18}
!21 = !{!6, !7, i64 44}
!22 = distinct !{!22, !18, !23, !24}
!23 = !{!"llvm.loop.isvectorized", i32 1}
!24 = !{!"llvm.loop.unroll.runtime.disable"}
!25 = distinct !{!25, !18, !24, !23}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopIdiomRecognizePass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass