; LLVM IR from CLASS-SZ/class_sz :: class-sz/tools (hyperspherical)

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

@.str = external hidden unnamed_addr constant [35 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [13 x i8], align 1
@__func__.hyperspherical_HIS_create = external hidden unnamed_addr constant [26 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [5 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local i32 @hyperspherical_HIS_create(i32 noundef %0, double noundef %1, i32 noundef %2, ptr noundef %3, double noundef %4, double noundef %5, double noundef %6, i32 noundef %7, double noundef %8, ptr noundef %9, ptr noundef %10) #0 {
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca double, align 8
  %15 = alloca i32, align 4
  %16 = alloca ptr, align 8
  %17 = alloca double, align 8
  %18 = alloca double, align 8
  %19 = alloca double, align 8
  %20 = alloca i32, align 4
  %21 = alloca double, align 8
  %22 = alloca ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca double, align 8
  %25 = alloca double, align 8
  %26 = alloca double, align 8
  %27 = alloca double, align 8
  %28 = alloca double, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca i32, align 4
  %35 = alloca i32, align 4
  %36 = alloca i32, align 4
  %37 = alloca i32, align 4
  %38 = alloca i32, align 4
  %39 = alloca i32, align 4
  %40 = alloca i32, align 4
  %41 = alloca i32, align 4
  %42 = alloca [2048 x i8], align 16
  %43 = alloca i32, align 4
  %44 = alloca i32, align 4
  %45 = alloca [2048 x i8], align 16
  %46 = alloca i32, align 4
  %47 = alloca [2048 x i8], align 16
  %48 = alloca i32, align 4
  %49 = alloca [2048 x i8], align 16
  %50 = alloca i32, align 4
  %51 = alloca [2048 x i8], align 16
  %52 = alloca i32, align 4
  %53 = alloca [2048 x i8], align 16
  %54 = alloca i32, align 4
  %55 = alloca [2048 x i8], align 16
  %56 = alloca i32, align 4
  %57 = alloca [2048 x i8], align 16
  %58 = alloca i32, align 4
  %59 = alloca [2048 x i8], align 16
  %60 = alloca i32, align 4
  %61 = alloca i32, align 4
  %62 = alloca i32, align 4
  %63 = alloca [2048 x i8], align 16
  store i32 %0, ptr %13, align 4, !tbaa !5
  store double %1, ptr %14, align 8, !tbaa !9
  store i32 %2, ptr %15, align 4, !tbaa !5
  store ptr %3, ptr %16, align 8, !tbaa !11
  store double %4, ptr %17, align 8, !tbaa !9
  store double %5, ptr %18, align 8, !tbaa !9
  store double %6, ptr %19, align 8, !tbaa !9
  store i32 %7, ptr %20, align 4, !tbaa !5
  store double %8, ptr %21, align 8, !tbaa !9
  store ptr %9, ptr %22, align 8, !tbaa !11
  store ptr %10, ptr %23, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #6
  %64 = load double, ptr %14, align 8, !tbaa !9
  %65 = load double, ptr %14, align 8, !tbaa !9
  %66 = fmul double %64, %65
  store double %66, ptr %25, align 8, !tbaa !9
  %67 = load ptr, ptr %16, align 8, !tbaa !11
  %68 = load i32, ptr %15, align 4, !tbaa !5
  %69 = sub nsw i32 %68, 1
  %70 = sext i32 %69 to i64
  %71 = getelementptr inbounds i32, ptr %67, i64 %70
  %72 = load i32, ptr %71, align 4, !tbaa !5
  store i32 %72, ptr %36, align 4, !tbaa !5
  %73 = load double, ptr %14, align 8, !tbaa !9
  %74 = fdiv double 0x401921FB54442D18, %73
  store double %74, ptr %26, align 8, !tbaa !9
  %75 = load double, ptr %18, align 8, !tbaa !9
  %76 = load double, ptr %17, align 8, !tbaa !9
  %77 = fsub double %75, %76
  %78 = load double, ptr %19, align 8, !tbaa !9
  %79 = fmul double %77, %78
  %80 = load double, ptr %26, align 8, !tbaa !9
  %81 = fdiv double %79, %80
  %82 = fptosi double %81 to i32
  store i32 %82, ptr %35, align 4, !tbaa !5
  %83 = load i32, ptr %35, align 4, !tbaa !5
  %84 = icmp slt i32 %83, 2
  br i1 %84, label %85, label %86

85:                                               ; preds = %11
  br label %88

86:                                               ; preds = %11
  %87 = load i32, ptr %35, align 4, !tbaa !5
  br label %88

88:                                               ; preds = %86, %85
  %89 = phi i32 [ 2, %85 ], [ %87, %86 ]
  store i32 %89, ptr %35, align 4, !tbaa !5
  %90 = load double, ptr %18, align 8, !tbaa !9
  %91 = load double, ptr %17, align 8, !tbaa !9
  %92 = fsub double %90, %91
  %93 = load i32, ptr %35, align 4, !tbaa !5
  %94 = sitofp i32 %93 to double
  %95 = fsub double %94, 1.000000e+00
  %96 = fdiv double %92, %95
  store double %96, ptr %24, align 8, !tbaa !9
  %97 = load double, ptr %14, align 8, !tbaa !9
  %98 = load ptr, ptr %22, align 8, !tbaa !11
  %99 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %98, i32 0, i32 1
  store double %97, ptr %99, align 8, !tbaa !13
  %100 = load double, ptr %24, align 8, !tbaa !9
  %101 = load ptr, ptr %22, align 8, !tbaa !11
  %102 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %101, i32 0, i32 2
  store double %100, ptr %102, align 8, !tbaa !15
  %103 = load i32, ptr %15, align 4, !tbaa !5
  %104 = load ptr, ptr %22, align 8, !tbaa !11
  %105 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %104, i32 0, i32 4
  store i32 %103, ptr %105, align 4, !tbaa !16
  %106 = load i32, ptr %35, align 4, !tbaa !5
  %107 = load ptr, ptr %22, align 8, !tbaa !11
  %108 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %107, i32 0, i32 7
  store i32 %106, ptr %108, align 8, !tbaa !17
  %109 = load i32, ptr %13, align 4, !tbaa !5
  %110 = load ptr, ptr %22, align 8, !tbaa !11
  %111 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %110, i32 0, i32 0
  store i32 %109, ptr %111, align 8, !tbaa !18
  %112 = load i32, ptr %15, align 4, !tbaa !5
  %113 = sext i32 %112 to i64
  %114 = mul i64 4, %113
  %115 = call noalias ptr @malloc(i64 noundef %114) #7
  %116 = load ptr, ptr %22, align 8, !tbaa !11
  %117 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %116, i32 0, i32 5
  store ptr %115, ptr %117, align 8, !tbaa !19
  %118 = load ptr, ptr %22, align 8, !tbaa !11
  %119 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %118, i32 0, i32 5
  %120 = load ptr, ptr %119, align 8, !tbaa !19
  %121 = icmp eq ptr %120, null
  br i1 %121, label %122, label %131

122:                                              ; preds = %88
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  %123 = load i32, ptr %15, align 4, !tbaa !5
  %124 = sext i32 %123 to i64
  %125 = mul i64 4, %124
  %126 = trunc i64 %125 to i32
  store i32 %126, ptr %41, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %42) #6
  %127 = getelementptr inbounds [2048 x i8], ptr %42, i64 0, i64 0
  %128 = load i32, ptr %41, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %127, ptr noundef @.str, ptr noundef @.str.1, i32 noundef %128)
  %129 = load ptr, ptr %23, align 8, !tbaa !11
  %130 = getelementptr inbounds [2048 x i8], ptr %42, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %129, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 50, ptr noundef %130)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %42) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  br label %953

131:                                              ; preds = %88
  %132 = load i32, ptr %15, align 4, !tbaa !5
  %133 = sext i32 %132 to i64
  %134 = mul i64 8, %133
  %135 = call noalias ptr @malloc(i64 noundef %134) #7
  %136 = load ptr, ptr %22, align 8, !tbaa !11
  %137 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %136, i32 0, i32 6
  store ptr %135, ptr %137, align 8, !tbaa !20
  %138 = load ptr, ptr %22, align 8, !tbaa !11
  %139 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %138, i32 0, i32 6
  %140 = load ptr, ptr %139, align 8, !tbaa !20
  %141 = icmp eq ptr %140, null
  br i1 %141, label %142, label %151

142:                                              ; preds = %131
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  %143 = load i32, ptr %15, align 4, !tbaa !5
  %144 = sext i32 %143 to i64
  %145 = mul i64 8, %144
  %146 = trunc i64 %145 to i32
  store i32 %146, ptr %44, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %45) #6
  %147 = getelementptr inbounds [2048 x i8], ptr %45, i64 0, i64 0
  %148 = load i32, ptr %44, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %147, ptr noundef @.str, ptr noundef @.str.3, i32 noundef %148)
  %149 = load ptr, ptr %23, align 8, !tbaa !11
  %150 = getelementptr inbounds [2048 x i8], ptr %45, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %149, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 51, ptr noundef %150)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %45) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  br label %953

151:                                              ; preds = %131
  %152 = load i32, ptr %35, align 4, !tbaa !5
  %153 = sext i32 %152 to i64
  %154 = mul i64 8, %153
  %155 = call noalias ptr @malloc(i64 noundef %154) #7
  %156 = load ptr, ptr %22, align 8, !tbaa !11
  %157 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %156, i32 0, i32 8
  store ptr %155, ptr %157, align 8, !tbaa !21
  %158 = load ptr, ptr %22, align 8, !tbaa !11
  %159 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %158, i32 0, i32 8
  %160 = load ptr, ptr %159, align 8, !tbaa !21
  %161 = icmp eq ptr %160, null
  br i1 %161, label %162, label %171

162:                                              ; preds = %151
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %163 = load i32, ptr %35, align 4, !tbaa !5
  %164 = sext i32 %163 to i64
  %165 = mul i64 8, %164
  %166 = trunc i64 %165 to i32
  store i32 %166, ptr %46, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %47) #6
  %167 = getelementptr inbounds [2048 x i8], ptr %47, i64 0, i64 0
  %168 = load i32, ptr %46, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %167, ptr noundef @.str, ptr noundef @.str.4, i32 noundef %168)
  %169 = load ptr, ptr %23, align 8, !tbaa !11
  %170 = getelementptr inbounds [2048 x i8], ptr %47, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %169, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 52, ptr noundef %170)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %47) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  br label %953

171:                                              ; preds = %151
  %172 = load i32, ptr %35, align 4, !tbaa !5
  %173 = sext i32 %172 to i64
  %174 = mul i64 8, %173
  %175 = call noalias ptr @malloc(i64 noundef %174) #7
  %176 = load ptr, ptr %22, align 8, !tbaa !11
  %177 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %176, i32 0, i32 9
  store ptr %175, ptr %177, align 8, !tbaa !22
  %178 = load ptr, ptr %22, align 8, !tbaa !11
  %179 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %178, i32 0, i32 9
  %180 = load ptr, ptr %179, align 8, !tbaa !22
  %181 = icmp eq ptr %180, null
  br i1 %181, label %182, label %191

182:                                              ; preds = %171
  call void @llvm.lifetime.start.p0(i64 4, ptr %48) #6
  %183 = load i32, ptr %35, align 4, !tbaa !5
  %184 = sext i32 %183 to i64
  %185 = mul i64 8, %184
  %186 = trunc i64 %185 to i32
  store i32 %186, ptr %48, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %49) #6
  %187 = getelementptr inbounds [2048 x i8], ptr %49, i64 0, i64 0
  %188 = load i32, ptr %48, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %187, ptr noundef @.str, ptr noundef @.str.5, i32 noundef %188)
  %189 = load ptr, ptr %23, align 8, !tbaa !11
  %190 = getelementptr inbounds [2048 x i8], ptr %49, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %189, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 53, ptr noundef %190)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %49) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %48) #6
  br label %953

191:                                              ; preds = %171
  %192 = load i32, ptr %35, align 4, !tbaa !5
  %193 = sext i32 %192 to i64
  %194 = mul i64 8, %193
  %195 = call noalias ptr @malloc(i64 noundef %194) #7
  %196 = load ptr, ptr %22, align 8, !tbaa !11
  %197 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %196, i32 0, i32 10
  store ptr %195, ptr %197, align 8, !tbaa !23
  %198 = load ptr, ptr %22, align 8, !tbaa !11
  %199 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %198, i32 0, i32 10
  %200 = load ptr, ptr %199, align 8, !tbaa !23
  %201 = icmp eq ptr %200, null
  br i1 %201, label %202, label %211

202:                                              ; preds = %191
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #6
  %203 = load i32, ptr %35, align 4, !tbaa !5
  %204 = sext i32 %203 to i64
  %205 = mul i64 8, %204
  %206 = trunc i64 %205 to i32
  store i32 %206, ptr %50, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %51) #6
  %207 = getelementptr inbounds [2048 x i8], ptr %51, i64 0, i64 0
  %208 = load i32, ptr %50, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %207, ptr noundef @.str, ptr noundef @.str.6, i32 noundef %208)
  %209 = load ptr, ptr %23, align 8, !tbaa !11
  %210 = getelementptr inbounds [2048 x i8], ptr %51, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %209, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 54, ptr noundef %210)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %51) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #6
  br label %953

211:                                              ; preds = %191
  %212 = load i32, ptr %35, align 4, !tbaa !5
  %213 = sext i32 %212 to i64
  %214 = mul i64 8, %213
  %215 = load i32, ptr %15, align 4, !tbaa !5
  %216 = sext i32 %215 to i64
  %217 = mul i64 %214, %216
  %218 = call noalias ptr @malloc(i64 noundef %217) #7
  %219 = load ptr, ptr %22, align 8, !tbaa !11
  %220 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %219, i32 0, i32 11
  store ptr %218, ptr %220, align 8, !tbaa !24
  %221 = load ptr, ptr %22, align 8, !tbaa !11
  %222 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %221, i32 0, i32 11
  %223 = load ptr, ptr %222, align 8, !tbaa !24
  %224 = icmp eq ptr %223, null
  br i1 %224, label %225, label %237

225:                                              ; preds = %211
  call void @llvm.lifetime.start.p0(i64 4, ptr %52) #6
  %226 = load i32, ptr %35, align 4, !tbaa !5
  %227 = sext i32 %226 to i64
  %228 = mul i64 8, %227
  %229 = load i32, ptr %15, align 4, !tbaa !5
  %230 = sext i32 %229 to i64
  %231 = mul i64 %228, %230
  %232 = trunc i64 %231 to i32
  store i32 %232, ptr %52, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %53) #6
  %233 = getelementptr inbounds [2048 x i8], ptr %53, i64 0, i64 0
  %234 = load i32, ptr %52, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %233, ptr noundef @.str, ptr noundef @.str.7, i32 noundef %234)
  %235 = load ptr, ptr %23, align 8, !tbaa !11
  %236 = getelementptr inbounds [2048 x i8], ptr %53, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %235, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 55, ptr noundef %236)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %53) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %52) #6
  br label %953

237:                                              ; preds = %211
  %238 = load i32, ptr %35, align 4, !tbaa !5
  %239 = sext i32 %238 to i64
  %240 = mul i64 8, %239
  %241 = load i32, ptr %15, align 4, !tbaa !5
  %242 = sext i32 %241 to i64
  %243 = mul i64 %240, %242
  %244 = call noalias ptr @malloc(i64 noundef %243) #7
  %245 = load ptr, ptr %22, align 8, !tbaa !11
  %246 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %245, i32 0, i32 12
  store ptr %244, ptr %246, align 8, !tbaa !25
  %247 = load ptr, ptr %22, align 8, !tbaa !11
  %248 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %247, i32 0, i32 12
  %249 = load ptr, ptr %248, align 8, !tbaa !25
  %250 = icmp eq ptr %249, null
  br i1 %250, label %251, label %263

251:                                              ; preds = %237
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #6
  %252 = load i32, ptr %35, align 4, !tbaa !5
  %253 = sext i32 %252 to i64
  %254 = mul i64 8, %253
  %255 = load i32, ptr %15, align 4, !tbaa !5
  %256 = sext i32 %255 to i64
  %257 = mul i64 %254, %256
  %258 = trunc i64 %257 to i32
  store i32 %258, ptr %54, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %55) #6
  %259 = getelementptr inbounds [2048 x i8], ptr %55, i64 0, i64 0
  %260 = load i32, ptr %54, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %259, ptr noundef @.str, ptr noundef @.str.8, i32 noundef %260)
  %261 = load ptr, ptr %23, align 8, !tbaa !11
  %262 = getelementptr inbounds [2048 x i8], ptr %55, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %261, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 56, ptr noundef %262)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %55) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #6
  br label %953

263:                                              ; preds = %237
  %264 = load double, ptr %24, align 8, !tbaa !9
  %265 = fmul double 5.000000e-01, %264
  %266 = load double, ptr %24, align 8, !tbaa !9
  %267 = fmul double %265, %266
  %268 = fcmp olt double %267, 0x3E7AD7F29ABCAF48
  br i1 %268, label %269, label %272

269:                                              ; preds = %263
  %270 = load ptr, ptr %22, align 8, !tbaa !11
  %271 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %270, i32 0, i32 3
  store i32 1, ptr %271, align 8, !tbaa !26
  br label %284

272:                                              ; preds = %263
  %273 = load double, ptr %24, align 8, !tbaa !9
  %274 = call double @pow(double noundef %273, double noundef 4.000000e+00) #6
  %275 = fdiv double %274, 2.400000e+01
  %276 = fcmp olt double %275, 0x3E7AD7F29ABCAF48
  br i1 %276, label %277, label %280

277:                                              ; preds = %272
  %278 = load ptr, ptr %22, align 8, !tbaa !11
  %279 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %278, i32 0, i32 3
  store i32 3, ptr %279, align 8, !tbaa !26
  br label %283

280:                                              ; preds = %272
  %281 = load ptr, ptr %22, align 8, !tbaa !11
  %282 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %281, i32 0, i32 3
  store i32 5, ptr %282, align 8, !tbaa !26
  br label %283

283:                                              ; preds = %280, %277
  br label %284

284:                                              ; preds = %283, %269
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %285

285:                                              ; preds = %301, %284
  %286 = load i32, ptr %32, align 4, !tbaa !5
  %287 = load i32, ptr %15, align 4, !tbaa !5
  %288 = icmp slt i32 %286, %287
  br i1 %288, label %289, label %304

289:                                              ; preds = %285
  %290 = load ptr, ptr %16, align 8, !tbaa !11
  %291 = load i32, ptr %32, align 4, !tbaa !5
  %292 = sext i32 %291 to i64
  %293 = getelementptr inbounds i32, ptr %290, i64 %292
  %294 = load i32, ptr %293, align 4, !tbaa !5
  %295 = load ptr, ptr %22, align 8, !tbaa !11
  %296 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %295, i32 0, i32 5
  %297 = load ptr, ptr %296, align 8, !tbaa !19
  %298 = load i32, ptr %32, align 4, !tbaa !5
  %299 = sext i32 %298 to i64
  %300 = getelementptr inbounds i32, ptr %297, i64 %299
  store i32 %294, ptr %300, align 4, !tbaa !5
  br label %301

301:                                              ; preds = %289
  %302 = load i32, ptr %32, align 4, !tbaa !5
  %303 = add nsw i32 %302, 1
  store i32 %303, ptr %32, align 4, !tbaa !5
  br label %285, !llvm.loop !27

304:                                              ; preds = %285
  %305 = load i32, ptr %36, align 4, !tbaa !5
  %306 = add nsw i32 %305, 3
  %307 = sext i32 %306 to i64
  %308 = mul i64 %307, 8
  %309 = call noalias ptr @malloc(i64 noundef %308) #7
  store ptr %309, ptr %29, align 8, !tbaa !11
  %310 = load ptr, ptr %29, align 8, !tbaa !11
  %311 = icmp eq ptr %310, null
  br i1 %311, label %312, label %322

312:                                              ; preds = %304
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #6
  %313 = load i32, ptr %36, align 4, !tbaa !5
  %314 = add nsw i32 %313, 3
  %315 = sext i32 %314 to i64
  %316 = mul i64 %315, 8
  %317 = trunc i64 %316 to i32
  store i32 %317, ptr %56, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %57) #6
  %318 = getelementptr inbounds [2048 x i8], ptr %57, i64 0, i64 0
  %319 = load i32, ptr %56, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %318, ptr noundef @.str, ptr noundef @.str.9, i32 noundef %319)
  %320 = load ptr, ptr %23, align 8, !tbaa !11
  %321 = getelementptr inbounds [2048 x i8], ptr %57, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %320, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 71, ptr noundef %321)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %57) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #6
  br label %953

322:                                              ; preds = %304
  %323 = load i32, ptr %36, align 4, !tbaa !5
  %324 = add nsw i32 %323, 3
  %325 = sext i32 %324 to i64
  %326 = mul i64 %325, 8
  %327 = call noalias ptr @malloc(i64 noundef %326) #7
  store ptr %327, ptr %30, align 8, !tbaa !11
  %328 = load ptr, ptr %30, align 8, !tbaa !11
  %329 = icmp eq ptr %328, null
  br i1 %329, label %330, label %340

330:                                              ; preds = %322
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #6
  %331 = load i32, ptr %36, align 4, !tbaa !5
  %332 = add nsw i32 %331, 3
  %333 = sext i32 %332 to i64
  %334 = mul i64 %333, 8
  %335 = trunc i64 %334 to i32
  store i32 %335, ptr %58, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %59) #6
  %336 = getelementptr inbounds [2048 x i8], ptr %59, i64 0, i64 0
  %337 = load i32, ptr %58, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %336, ptr noundef @.str, ptr noundef @.str.10, i32 noundef %337)
  %338 = load ptr, ptr %23, align 8, !tbaa !11
  %339 = getelementptr inbounds [2048 x i8], ptr %59, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %338, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 72, ptr noundef %339)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %59) #6
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #6
  br label %953

340:                                              ; preds = %322
  store i32 -10, ptr %37, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %60) #6
  store i32 -10, ptr %60, align 4, !tbaa !5
  %341 = load i32, ptr %15, align 4, !tbaa !5
  %342 = sub nsw i32 %341, 1
  store i32 %342, ptr %33, align 4, !tbaa !5
  br label %343

343:                                              ; preds = %359, %340
  %344 = load i32, ptr %33, align 4, !tbaa !5
  %345 = icmp sge i32 %344, 0
  br i1 %345, label %346, label %362

346:                                              ; preds = %343
  %347 = load ptr, ptr %16, align 8, !tbaa !11
  %348 = load i32, ptr %33, align 4, !tbaa !5
  %349 = sext i32 %348 to i64
  %350 = getelementptr inbounds i32, ptr %347, i64 %349
  %351 = load i32, ptr %350, align 4, !tbaa !5
  store i32 %351, ptr %34, align 4, !tbaa !5
  %352 = load i32, ptr %34, align 4, !tbaa !5
  %353 = load i32, ptr %20, align 4, !tbaa !5
  %354 = icmp slt i32 %352, %353
  br i1 %354, label %355, label %358

355:                                              ; preds = %346
  %356 = load i32, ptr %34, align 4, !tbaa !5
  store i32 %356, ptr %37, align 4, !tbaa !5
  %357 = load i32, ptr %33, align 4, !tbaa !5
  store i32 %357, ptr %60, align 4, !tbaa !5
  br label %362

358:                                              ; preds = %346
  br label %359

359:                                              ; preds = %358
  %360 = load i32, ptr %33, align 4, !tbaa !5
  %361 = add nsw i32 %360, -1
  store i32 %361, ptr %33, align 4, !tbaa !5
  br label %343, !llvm.loop !29

362:                                              ; preds = %355, %343
  %363 = load i32, ptr %13, align 4, !tbaa !5
  switch i32 %363, label %595 [
    i32 0, label %364
    i32 1, label %435
    i32 -1, label %515
  ]

364:                                              ; preds = %362
  %365 = load i32, ptr %37, align 4, !tbaa !5
  %366 = sitofp i32 %365 to double
  %367 = load i32, ptr %37, align 4, !tbaa !5
  %368 = sitofp i32 %367 to double
  %369 = fadd double %368, 1.000000e+00
  %370 = fmul double %366, %369
  %371 = call double @sqrt(double noundef %370) #6
  %372 = load double, ptr %14, align 8, !tbaa !9
  %373 = fdiv double %371, %372
  store double %373, ptr %28, align 8, !tbaa !9
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %374

374:                                              ; preds = %406, %364
  %375 = load i32, ptr %32, align 4, !tbaa !5
  %376 = load i32, ptr %35, align 4, !tbaa !5
  %377 = icmp slt i32 %375, %376
  br i1 %377, label %378, label %409

378:                                              ; preds = %374
  %379 = load double, ptr %17, align 8, !tbaa !9
  %380 = load i32, ptr %32, align 4, !tbaa !5
  %381 = sitofp i32 %380 to double
  %382 = load double, ptr %24, align 8, !tbaa !9
  %383 = call double @llvm.fmuladd.f64(double %381, double %382, double %379)
  store double %383, ptr %27, align 8, !tbaa !9
  %384 = load double, ptr %27, align 8, !tbaa !9
  %385 = load ptr, ptr %22, align 8, !tbaa !11
  %386 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %385, i32 0, i32 8
  %387 = load ptr, ptr %386, align 8, !tbaa !21
  %388 = load i32, ptr %32, align 4, !tbaa !5
  %389 = sext i32 %388 to i64
  %390 = getelementptr inbounds double, ptr %387, i64 %389
  store double %384, ptr %390, align 8, !tbaa !9
  %391 = load double, ptr %27, align 8, !tbaa !9
  %392 = load ptr, ptr %22, align 8, !tbaa !11
  %393 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %392, i32 0, i32 9
  %394 = load ptr, ptr %393, align 8, !tbaa !22
  %395 = load i32, ptr %32, align 4, !tbaa !5
  %396 = sext i32 %395 to i64
  %397 = getelementptr inbounds double, ptr %394, i64 %396
  store double %391, ptr %397, align 8, !tbaa !9
  %398 = load double, ptr %27, align 8, !tbaa !9
  %399 = fdiv double 1.000000e+00, %398
  %400 = load ptr, ptr %22, align 8, !tbaa !11
  %401 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %400, i32 0, i32 10
  %402 = load ptr, ptr %401, align 8, !tbaa !23
  %403 = load i32, ptr %32, align 4, !tbaa !5
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds double, ptr %402, i64 %404
  store double %399, ptr %405, align 8, !tbaa !9
  br label %406

406:                                              ; preds = %378
  %407 = load i32, ptr %32, align 4, !tbaa !5
  %408 = add nsw i32 %407, 1
  store i32 %408, ptr %32, align 4, !tbaa !5
  br label %374, !llvm.loop !30

409:                                              ; preds = %374
  store i32 0, ptr %34, align 4, !tbaa !5
  br label %410

410:                                              ; preds = %431, %409
  %411 = load i32, ptr %34, align 4, !tbaa !5
  %412 = load i32, ptr %36, align 4, !tbaa !5
  %413 = add nsw i32 %412, 2
  %414 = icmp sle i32 %411, %413
  br i1 %414, label %415, label %434

415:                                              ; preds = %410
  %416 = load double, ptr %14, align 8, !tbaa !9
  %417 = load ptr, ptr %29, align 8, !tbaa !11
  %418 = load i32, ptr %34, align 4, !tbaa !5
  %419 = sext i32 %418 to i64
  %420 = getelementptr inbounds double, ptr %417, i64 %419
  store double %416, ptr %420, align 8, !tbaa !9
  %421 = load ptr, ptr %29, align 8, !tbaa !11
  %422 = load i32, ptr %34, align 4, !tbaa !5
  %423 = sext i32 %422 to i64
  %424 = getelementptr inbounds double, ptr %421, i64 %423
  %425 = load double, ptr %424, align 8, !tbaa !9
  %426 = fdiv double 1.000000e+00, %425
  %427 = load ptr, ptr %30, align 8, !tbaa !11
  %428 = load i32, ptr %34, align 4, !tbaa !5
  %429 = sext i32 %428 to i64
  %430 = getelementptr inbounds double, ptr %427, i64 %429
  store double %426, ptr %430, align 8, !tbaa !9
  br label %431

431:                                              ; preds = %415
  %432 = load i32, ptr %34, align 4, !tbaa !5
  %433 = add nsw i32 %432, 1
  store i32 %433, ptr %34, align 4, !tbaa !5
  br label %410, !llvm.loop !31

434:                                              ; preds = %410
  br label %596

435:                                              ; preds = %362
  %436 = load i32, ptr %37, align 4, !tbaa !5
  %437 = sitofp i32 %436 to double
  %438 = load i32, ptr %37, align 4, !tbaa !5
  %439 = sitofp i32 %438 to double
  %440 = fadd double %439, 1.000000e+00
  %441 = fmul double %437, %440
  %442 = call double @sqrt(double noundef %441) #6
  %443 = load double, ptr %14, align 8, !tbaa !9
  %444 = fdiv double %442, %443
  %445 = call double @asin(double noundef %444) #6
  store double %445, ptr %28, align 8, !tbaa !9
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %446

446:                                              ; preds = %480, %435
  %447 = load i32, ptr %32, align 4, !tbaa !5
  %448 = load i32, ptr %35, align 4, !tbaa !5
  %449 = icmp slt i32 %447, %448
  br i1 %449, label %450, label %483

450:                                              ; preds = %446
  %451 = load double, ptr %17, align 8, !tbaa !9
  %452 = load i32, ptr %32, align 4, !tbaa !5
  %453 = sitofp i32 %452 to double
  %454 = load double, ptr %24, align 8, !tbaa !9
  %455 = call double @llvm.fmuladd.f64(double %453, double %454, double %451)
  store double %455, ptr %27, align 8, !tbaa !9
  %456 = load double, ptr %27, align 8, !tbaa !9
  %457 = load ptr, ptr %22, align 8, !tbaa !11
  %458 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %457, i32 0, i32 8
  %459 = load ptr, ptr %458, align 8, !tbaa !21
  %460 = load i32, ptr %32, align 4, !tbaa !5
  %461 = sext i32 %460 to i64
  %462 = getelementptr inbounds double, ptr %459, i64 %461
  store double %456, ptr %462, align 8, !tbaa !9
  %463 = load double, ptr %27, align 8, !tbaa !9
  %464 = call double @sin(double noundef %463) #6
  %465 = load ptr, ptr %22, align 8, !tbaa !11
  %466 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %465, i32 0, i32 9
  %467 = load ptr, ptr %466, align 8, !tbaa !22
  %468 = load i32, ptr %32, align 4, !tbaa !5
  %469 = sext i32 %468 to i64
  %470 = getelementptr inbounds double, ptr %467, i64 %469
  store double %464, ptr %470, align 8, !tbaa !9
  %471 = load double, ptr %27, align 8, !tbaa !9
  %472 = call double @tan(double noundef %471) #6
  %473 = fdiv double 1.000000e+00, %472
  %474 = load ptr, ptr %22, align 8, !tbaa !11
  %475 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %474, i32 0, i32 10
  %476 = load ptr, ptr %475, align 8, !tbaa !23
  %477 = load i32, ptr %32, align 4, !tbaa !5
  %478 = sext i32 %477 to i64
  %479 = getelementptr inbounds double, ptr %476, i64 %478
  store double %473, ptr %479, align 8, !tbaa !9
  br label %480

480:                                              ; preds = %450
  %481 = load i32, ptr %32, align 4, !tbaa !5
  %482 = add nsw i32 %481, 1
  store i32 %482, ptr %32, align 4, !tbaa !5
  br label %446, !llvm.loop !32

483:                                              ; preds = %446
  store i32 0, ptr %34, align 4, !tbaa !5
  br label %484

484:                                              ; preds = %511, %483
  %485 = load i32, ptr %34, align 4, !tbaa !5
  %486 = load i32, ptr %36, align 4, !tbaa !5
  %487 = add nsw i32 %486, 2
  %488 = icmp sle i32 %485, %487
  br i1 %488, label %489, label %514

489:                                              ; preds = %484
  %490 = load double, ptr %25, align 8, !tbaa !9
  %491 = load i32, ptr %34, align 4, !tbaa !5
  %492 = load i32, ptr %34, align 4, !tbaa !5
  %493 = mul nsw i32 %491, %492
  %494 = sitofp i32 %493 to double
  %495 = fsub double %490, %494
  %496 = call double @sqrt(double noundef %495) #6
  %497 = load ptr, ptr %29, align 8, !tbaa !11
  %498 = load i32, ptr %34, align 4, !tbaa !5
  %499 = sext i32 %498 to i64
  %500 = getelementptr inbounds double, ptr %497, i64 %499
  store double %496, ptr %500, align 8, !tbaa !9
  %501 = load ptr, ptr %29, align 8, !tbaa !11
  %502 = load i32, ptr %34, align 4, !tbaa !5
  %503 = sext i32 %502 to i64
  %504 = getelementptr inbounds double, ptr %501, i64 %503
  %505 = load double, ptr %504, align 8, !tbaa !9
  %506 = fdiv double 1.000000e+00, %505
  %507 = load ptr, ptr %30, align 8, !tbaa !11
  %508 = load i32, ptr %34, align 4, !tbaa !5
  %509 = sext i32 %508 to i64
  %510 = getelementptr inbounds double, ptr %507, i64 %509
  store double %506, ptr %510, align 8, !tbaa !9
  br label %511

511:                                              ; preds = %489
  %512 = load i32, ptr %34, align 4, !tbaa !5
  %513 = add nsw i32 %512, 1
  store i32 %513, ptr %34, align 4, !tbaa !5
  br label %484, !llvm.loop !33

514:                                              ; preds = %484
  br label %596

515:                                              ; preds = %362
  %516 = load i32, ptr %37, align 4, !tbaa !5
  %517 = sitofp i32 %516 to double
  %518 = load i32, ptr %37, align 4, !tbaa !5
  %519 = sitofp i32 %518 to double
  %520 = fadd double %519, 1.000000e+00
  %521 = fmul double %517, %520
  %522 = call double @sqrt(double noundef %521) #6
  %523 = load double, ptr %14, align 8, !tbaa !9
  %524 = fdiv double %522, %523
  %525 = call double @asinh(double noundef %524) #6
  store double %525, ptr %28, align 8, !tbaa !9
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %526

526:                                              ; preds = %560, %515
  %527 = load i32, ptr %32, align 4, !tbaa !5
  %528 = load i32, ptr %35, align 4, !tbaa !5
  %529 = icmp slt i32 %527, %528
  br i1 %529, label %530, label %563

530:                                              ; preds = %526
  %531 = load double, ptr %17, align 8, !tbaa !9
  %532 = load i32, ptr %32, align 4, !tbaa !5
  %533 = sitofp i32 %532 to double
  %534 = load double, ptr %24, align 8, !tbaa !9
  %535 = call double @llvm.fmuladd.f64(double %533, double %534, double %531)
  store double %535, ptr %27, align 8, !tbaa !9
  %536 = load double, ptr %27, align 8, !tbaa !9
  %537 = load ptr, ptr %22, align 8, !tbaa !11
  %538 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %537, i32 0, i32 8
  %539 = load ptr, ptr %538, align 8, !tbaa !21
  %540 = load i32, ptr %32, align 4, !tbaa !5
  %541 = sext i32 %540 to i64
  %542 = getelementptr inbounds double, ptr %539, i64 %541
  store double %536, ptr %542, align 8, !tbaa !9
  %543 = load double, ptr %27, align 8, !tbaa !9
  %544 = call double @sinh(double noundef %543) #6
  %545 = load ptr, ptr %22, align 8, !tbaa !11
  %546 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %545, i32 0, i32 9
  %547 = load ptr, ptr %546, align 8, !tbaa !22
  %548 = load i32, ptr %32, align 4, !tbaa !5
  %549 = sext i32 %548 to i64
  %550 = getelementptr inbounds double, ptr %547, i64 %549
  store double %544, ptr %550, align 8, !tbaa !9
  %551 = load double, ptr %27, align 8, !tbaa !9
  %552 = call double @tanh(double noundef %551) #6
  %553 = fdiv double 1.000000e+00, %552
  %554 = load ptr, ptr %22, align 8, !tbaa !11
  %555 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %554, i32 0, i32 10
  %556 = load ptr, ptr %555, align 8, !tbaa !23
  %557 = load i32, ptr %32, align 4, !tbaa !5
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds double, ptr %556, i64 %558
  store double %553, ptr %559, align 8, !tbaa !9
  br label %560

560:                                              ; preds = %530
  %561 = load i32, ptr %32, align 4, !tbaa !5
  %562 = add nsw i32 %561, 1
  store i32 %562, ptr %32, align 4, !tbaa !5
  br label %526, !llvm.loop !34

563:                                              ; preds = %526
  store i32 0, ptr %34, align 4, !tbaa !5
  br label %564

564:                                              ; preds = %591, %563
  %565 = load i32, ptr %34, align 4, !tbaa !5
  %566 = load i32, ptr %36, align 4, !tbaa !5
  %567 = add nsw i32 %566, 2
  %568 = icmp sle i32 %565, %567
  br i1 %568, label %569, label %594

569:                                              ; preds = %564
  %570 = load double, ptr %25, align 8, !tbaa !9
  %571 = load i32, ptr %34, align 4, !tbaa !5
  %572 = load i32, ptr %34, align 4, !tbaa !5
  %573 = mul nsw i32 %571, %572
  %574 = sitofp i32 %573 to double
  %575 = fadd double %570, %574
  %576 = call double @sqrt(double noundef %575) #6
  %577 = load ptr, ptr %29, align 8, !tbaa !11
  %578 = load i32, ptr %34, align 4, !tbaa !5
  %579 = sext i32 %578 to i64
  %580 = getelementptr inbounds double, ptr %577, i64 %579
  store double %576, ptr %580, align 8, !tbaa !9
  %581 = load ptr, ptr %29, align 8, !tbaa !11
  %582 = load i32, ptr %34, align 4, !tbaa !5
  %583 = sext i32 %582 to i64
  %584 = getelementptr inbounds double, ptr %581, i64 %583
  %585 = load double, ptr %584, align 8, !tbaa !9
  %586 = fdiv double 1.000000e+00, %585
  %587 = load ptr, ptr %30, align 8, !tbaa !11
  %588 = load i32, ptr %34, align 4, !tbaa !5
  %589 = sext i32 %588 to i64
  %590 = getelementptr inbounds double, ptr %587, i64 %589
  store double %586, ptr %590, align 8, !tbaa !9
  br label %591

591:                                              ; preds = %569
  %592 = load i32, ptr %34, align 4, !tbaa !5
  %593 = add nsw i32 %592, 1
  store i32 %593, ptr %34, align 4, !tbaa !5
  br label %564, !llvm.loop !35

594:                                              ; preds = %564
  br label %596

595:                                              ; preds = %362
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  br label %952

596:                                              ; preds = %594, %514, %434
  call void @llvm.lifetime.start.p0(i64 4, ptr %61) #6
  %597 = load double, ptr %28, align 8, !tbaa !9
  %598 = load double, ptr %17, align 8, !tbaa !9
  %599 = fsub double %597, %598
  %600 = load double, ptr %24, align 8, !tbaa !9
  %601 = fdiv double %599, %600
  %602 = fptosi double %601 to i32
  store i32 %602, ptr %61, align 4, !tbaa !5
  store i32 0, ptr %38, align 4, !tbaa !5
  store ptr null, ptr %31, align 8, !tbaa !11
  %603 = load i32, ptr %38, align 4, !tbaa !5
  %604 = icmp eq i32 %603, 0
  br i1 %604, label %605, label %626

605:                                              ; preds = %596
  %606 = load i32, ptr %36, align 4, !tbaa !5
  %607 = add nsw i32 %606, 2
  %608 = sext i32 %607 to i64
  %609 = mul i64 %608, 8
  %610 = mul i64 %609, 16
  %611 = call noalias ptr @malloc(i64 noundef %610) #7
  store ptr %611, ptr %31, align 8, !tbaa !11
  %612 = load ptr, ptr %31, align 8, !tbaa !11
  %613 = icmp eq ptr %612, null
  br i1 %613, label %614, label %625

614:                                              ; preds = %605
  call void @llvm.lifetime.start.p0(i64 4, ptr %62) #6
  %615 = load i32, ptr %36, align 4, !tbaa !5
  %616 = add nsw i32 %615, 2
  %617 = sext i32 %616 to i64
  %618 = mul i64 %617, 8
  %619 = mul i64 %618, 16
  %620 = trunc i64 %619 to i32
  store i32 %620, ptr %62, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2048, ptr %63) #6
  %621 = getelementptr inbounds [2048 x i8], ptr %63, i64 0, i64 0
  %622 = load i32, ptr %62, align 4, !tbaa !5
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %621, ptr noundef @.str, ptr noundef @.str.11, i32 noundef %622)
  %623 = load ptr, ptr %23, align 8, !tbaa !11
  %624 = getelementptr inbounds [2048 x i8], ptr %63, i64 0, i64 0
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %623, ptr noundef @.str.2, ptr noundef @__func__.hyperspherical_HIS_create, i32 noundef 142, ptr noundef %624)
  call void @llvm.lifetime.end.p0(i64 2048, ptr %63) #6
  store i32 1, ptr %38, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 4, ptr %62) #6
  br label %625

625:                                              ; preds = %614, %605
  br label %626

626:                                              ; preds = %625, %596
  %627 = load i32, ptr %13, align 4, !tbaa !5
  %628 = icmp eq i32 %627, 1
  br i1 %628, label %629, label %644

629:                                              ; preds = %626
  %630 = load double, ptr %14, align 8, !tbaa !9
  %631 = fadd double %630, 2.000000e-01
  %632 = fptosi double %631 to i32
  %633 = load i32, ptr %36, align 4, !tbaa !5
  %634 = add nsw i32 %633, 1
  %635 = icmp eq i32 %632, %634
  br i1 %635, label %636, label %644

636:                                              ; preds = %629
  %637 = load ptr, ptr %31, align 8, !tbaa !11
  %638 = load i32, ptr %36, align 4, !tbaa !5
  %639 = add nsw i32 %638, 1
  %640 = sext i32 %639 to i64
  %641 = getelementptr inbounds double, ptr %637, i64 %640
  store double 0.000000e+00, ptr %641, align 8, !tbaa !9
  %642 = load i32, ptr %36, align 4, !tbaa !5
  %643 = add nsw i32 %642, -1
  store i32 %643, ptr %36, align 4, !tbaa !5
  br label %644

644:                                              ; preds = %636, %629, %626
  store i32 0, ptr %32, align 4, !tbaa !5
  br label %645

645:                                              ; preds = %764, %644
  %646 = load i32, ptr %32, align 4, !tbaa !5
  %647 = load i32, ptr %35, align 4, !tbaa !5
  %648 = load i32, ptr %61, align 4, !tbaa !5
  %649 = icmp slt i32 %647, %648
  br i1 %649, label %650, label %652

650:                                              ; preds = %645
  %651 = load i32, ptr %35, align 4, !tbaa !5
  br label %654

652:                                              ; preds = %645
  %653 = load i32, ptr %61, align 4, !tbaa !5
  br label %654

654:                                              ; preds = %652, %650
  %655 = phi i32 [ %651, %650 ], [ %653, %652 ]
  %656 = icmp slt i32 %646, %655
  br i1 %656, label %657, label %767

657:                                              ; preds = %654
  %658 = load i32, ptr %13, align 4, !tbaa !5
  %659 = load i32, ptr %37, align 4, !tbaa !5
  %660 = load i32, ptr %36, align 4, !tbaa !5
  %661 = icmp slt i32 %659, %660
  br i1 %661, label %662, label %664

662:                                              ; preds = %657
  %663 = load i32, ptr %37, align 4, !tbaa !5
  br label %666

664:                                              ; preds = %657
  %665 = load i32, ptr %36, align 4, !tbaa !5
  br label %666

666:                                              ; preds = %664, %662
  %667 = phi i32 [ %663, %662 ], [ %665, %664 ]
  %668 = add nsw i32 %667, 1
  %669 = load double, ptr %14, align 8, !tbaa !9
  %670 = load ptr, ptr %22, align 8, !tbaa !11
  %671 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %670, i32 0, i32 8
  %672 = load ptr, ptr %671, align 8, !tbaa !21
  %673 = load i32, ptr %32, align 4, !tbaa !5
  %674 = sext i32 %673 to i64
  %675 = getelementptr inbounds double, ptr %672, i64 %674
  %676 = load double, ptr %675, align 8, !tbaa !9
  %677 = load ptr, ptr %22, align 8, !tbaa !11
  %678 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %677, i32 0, i32 9
  %679 = load ptr, ptr %678, align 8, !tbaa !22
  %680 = load i32, ptr %32, align 4, !tbaa !5
  %681 = sext i32 %680 to i64
  %682 = getelementptr inbounds double, ptr %679, i64 %681
  %683 = load double, ptr %682, align 8, !tbaa !9
  %684 = load ptr, ptr %22, align 8, !tbaa !11
  %685 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %684, i32 0, i32 10
  %686 = load ptr, ptr %685, align 8, !tbaa !23
  %687 = load i32, ptr %32, align 4, !tbaa !5
  %688 = sext i32 %687 to i64
  %689 = getelementptr inbounds double, ptr %686, i64 %688
  %690 = load double, ptr %689, align 8, !tbaa !9
  %691 = load ptr, ptr %29, align 8, !tbaa !11
  %692 = load ptr, ptr %30, align 8, !tbaa !11
  %693 = load ptr, ptr %31, align 8, !tbaa !11
  %694 = call i32 @hyperspherical_backwards_recurrence(i32 noundef %658, i32 noundef %668, double noundef %669, double noundef %676, double noundef %683, double noundef %690, ptr noundef %691, ptr noundef %692, ptr noundef %693)
  store i32 0, ptr %33, align 4, !tbaa !5
  br label %695

695:                                              ; preds = %760, %666
  %696 = load i32, ptr %33, align 4, !tbaa !5
  %697 = load i32, ptr %60, align 4, !tbaa !5
  %698 = icmp sle i32 %696, %697
  br i1 %698, label %699, label %763

699:                                              ; preds = %695
  %700 = load ptr, ptr %16, align 8, !tbaa !11
  %701 = load i32, ptr %33, align 4, !tbaa !5
  %702 = sext i32 %701 to i64
  %703 = getelementptr inbounds i32, ptr %700, i64 %702
  %704 = load i32, ptr %703, align 4, !tbaa !5
  store i32 %704, ptr %34, align 4, !tbaa !5
  %705 = load ptr, ptr %31, align 8, !tbaa !11
  %706 = load i32, ptr %34, align 4, !tbaa !5
  %707 = sext i32 %706 to i64
  %708 = getelementptr inbounds double, ptr %705, i64 %707
  %709 = load double, ptr %708, align 8, !tbaa !9
  %710 = load ptr, ptr %22, align 8, !tbaa !11
  %711 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %710, i32 0, i32 11
  %712 = load ptr, ptr %711, align 8, !tbaa !24
  %713 = load i32, ptr %33, align 4, !tbaa !5
  %714 = load i32, ptr %35, align 4, !tbaa !5
  %715 = mul nsw i32 %713, %714
  %716 = load i32, ptr %32, align 4, !tbaa !5
  %717 = add nsw i32 %715, %716
  %718 = sext i32 %717 to i64
  %719 = getelementptr inbounds double, ptr %712, i64 %718
  store double %709, ptr %719, align 8, !tbaa !9
  %720 = load i32, ptr %34, align 4, !tbaa !5
  %721 = sitofp i32 %720 to double
  %722 = load ptr, ptr %22, align 8, !tbaa !11
  %723 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %722, i32 0, i32 10
  %724 = load ptr, ptr %723, align 8, !tbaa !23
  %725 = load i32, ptr %32, align 4, !tbaa !5
  %726 = sext i32 %725 to i64
  %727 = getelementptr inbounds double, ptr %724, i64 %726
  %728 = load double, ptr %727, align 8, !tbaa !9
  %729 = fmul double %721, %728
  %730 = load ptr, ptr %31, align 8, !tbaa !11
  %731 = load i32, ptr %34, align 4, !tbaa !5
  %732 = sext i32 %731 to i64
  %733 = getelementptr inbounds double, ptr %730, i64 %732
  %734 = load double, ptr %733, align 8, !tbaa !9
  %735 = load ptr, ptr %29, align 8, !tbaa !11
  %736 = load i32, ptr %34, align 4, !tbaa !5
  %737 = add nsw i32 %736, 1
  %738 = sext i32 %737 to i64
  %739 = getelementptr inbounds double, ptr %735, i64 %738
  %740 = load double, ptr %739, align 8, !tbaa !9
  %741 = load ptr, ptr %31, align 8, !tbaa !11
  %742 = load i32, ptr %34, align 4, !tbaa !5
  %743 = add nsw i32 %742, 1
  %744 = sext i32 %743 to i64
  %745 = getelementptr inbounds double, ptr %741, i64 %744
  %746 = load double, ptr %745, align 8, !tbaa !9
  %747 = fmul double %740, %746
  %748 = fneg double %747
  %749 = call double @llvm.fmuladd.f64(double %729, double %734, double %748)
  %750 = load ptr, ptr %22, align 8, !tbaa !11
  %751 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %750, i32 0, i32 12
  %752 = load ptr, ptr %751, align 8, !tbaa !25
  %753 = load i32, ptr %33, align 4, !tbaa !5
  %754 = load i32, ptr %35, align 4, !tbaa !5
  %755 = mul nsw i32 %753, %754
  %756 = load i32, ptr %32, align 4, !tbaa !5
  %757 = add nsw i32 %755, %756
  %758 = sext i32 %757 to i64
  %759 = getelementptr inbounds double, ptr %752, i64 %758
  store double %749, ptr %759, align 8, !tbaa !9
  br label %760

760:                                              ; preds = %699
  %761 = load i32, ptr %33, align 4, !tbaa !5
  %762 = add nsw i32 %761, 1
  store i32 %762, ptr %33, align 4, !tbaa !5
  br label %695, !llvm.loop !36

763:                                              ; preds = %695
  br label %764

764:                                              ; preds = %763
  %765 = load i32, ptr %32, align 4, !tbaa !5
  %766 = add nsw i32 %765, 1
  store i32 %766, ptr %32, align 4, !tbaa !5
  br label %645, !llvm.loop !37

767:                                              ; preds = %654
  %768 = load i32, ptr %61, align 4, !tbaa !5
  store i32 %768, ptr %32, align 4, !tbaa !5
  br label %769

769:                                              ; preds = %916, %767
  %770 = load i32, ptr %32, align 4, !tbaa !5
  %771 = load i32, ptr %35, align 4, !tbaa !5
  %772 = icmp slt i32 %770, %771
  br i1 %772, label %773, label %919

773:                                              ; preds = %769
  %774 = load i32, ptr %35, align 4, !tbaa !5
  %775 = load i32, ptr %32, align 4, !tbaa !5
  %776 = sub nsw i32 %774, %775
  %777 = icmp slt i32 16, %776
  br i1 %777, label %778, label %779

778:                                              ; preds = %773
  br label %783

779:                                              ; preds = %773
  %780 = load i32, ptr %35, align 4, !tbaa !5
  %781 = load i32, ptr %32, align 4, !tbaa !5
  %782 = sub nsw i32 %780, %781
  br label %783

783:                                              ; preds = %779, %778
  %784 = phi i32 [ 16, %778 ], [ %782, %779 ]
  store i32 %784, ptr %39, align 4, !tbaa !5
  %785 = load i32, ptr %13, align 4, !tbaa !5
  %786 = load i32, ptr %37, align 4, !tbaa !5
  %787 = load i32, ptr %36, align 4, !tbaa !5
  %788 = icmp slt i32 %786, %787
  br i1 %788, label %789, label %791

789:                                              ; preds = %783
  %790 = load i32, ptr %37, align 4, !tbaa !5
  br label %793

791:                                              ; preds = %783
  %792 = load i32, ptr %36, align 4, !tbaa !5
  br label %793

793:                                              ; preds = %791, %789
  %794 = phi i32 [ %790, %789 ], [ %792, %791 ]
  %795 = add nsw i32 %794, 1
  %796 = load double, ptr %14, align 8, !tbaa !9
  %797 = load ptr, ptr %22, align 8, !tbaa !11
  %798 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %797, i32 0, i32 8
  %799 = load ptr, ptr %798, align 8, !tbaa !21
  %800 = load i32, ptr %32, align 4, !tbaa !5
  %801 = sext i32 %800 to i64
  %802 = getelementptr inbounds double, ptr %799, i64 %801
  %803 = load ptr, ptr %22, align 8, !tbaa !11
  %804 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %803, i32 0, i32 9
  %805 = load ptr, ptr %804, align 8, !tbaa !22
  %806 = load i32, ptr %32, align 4, !tbaa !5
  %807 = sext i32 %806 to i64
  %808 = getelementptr inbounds double, ptr %805, i64 %807
  %809 = load ptr, ptr %22, align 8, !tbaa !11
  %810 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %809, i32 0, i32 10
  %811 = load ptr, ptr %810, align 8, !tbaa !23
  %812 = load i32, ptr %32, align 4, !tbaa !5
  %813 = sext i32 %812 to i64
  %814 = getelementptr inbounds double, ptr %811, i64 %813
  %815 = load i32, ptr %39, align 4, !tbaa !5
  %816 = load ptr, ptr %29, align 8, !tbaa !11
  %817 = load ptr, ptr %30, align 8, !tbaa !11
  %818 = load ptr, ptr %31, align 8, !tbaa !11
  %819 = call i32 @hyperspherical_forwards_recurrence_chunk(i32 noundef %785, i32 noundef %795, double noundef %796, ptr noundef %802, ptr noundef %808, ptr noundef %814, i32 noundef %815, ptr noundef %816, ptr noundef %817, ptr noundef %818)
  store i32 0, ptr %33, align 4, !tbaa !5
  br label %820

820:                                              ; preds = %912, %793
  %821 = load i32, ptr %33, align 4, !tbaa !5
  %822 = load i32, ptr %60, align 4, !tbaa !5
  %823 = icmp sle i32 %821, %822
  br i1 %823, label %824, label %915

824:                                              ; preds = %820
  %825 = load ptr, ptr %16, align 8, !tbaa !11
  %826 = load i32, ptr %33, align 4, !tbaa !5
  %827 = sext i32 %826 to i64
  %828 = getelementptr inbounds i32, ptr %825, i64 %827
  %829 = load i32, ptr %828, align 4, !tbaa !5
  store i32 %829, ptr %34, align 4, !tbaa !5
  store i32 0, ptr %40, align 4, !tbaa !5
  br label %830

830:                                              ; preds = %908, %824
  %831 = load i32, ptr %40, align 4, !tbaa !5
  %832 = load i32, ptr %39, align 4, !tbaa !5
  %833 = icmp slt i32 %831, %832
  br i1 %833, label %834, label %911

834:                                              ; preds = %830
  %835 = load ptr, ptr %31, align 8, !tbaa !11
  %836 = load i32, ptr %34, align 4, !tbaa !5
  %837 = load i32, ptr %39, align 4, !tbaa !5
  %838 = mul nsw i32 %836, %837
  %839 = load i32, ptr %40, align 4, !tbaa !5
  %840 = add nsw i32 %838, %839
  %841 = sext i32 %840 to i64
  %842 = getelementptr inbounds double, ptr %835, i64 %841
  %843 = load double, ptr %842, align 8, !tbaa !9
  %844 = load ptr, ptr %22, align 8, !tbaa !11
  %845 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %844, i32 0, i32 11
  %846 = load ptr, ptr %845, align 8, !tbaa !24
  %847 = load i32, ptr %33, align 4, !tbaa !5
  %848 = load i32, ptr %35, align 4, !tbaa !5
  %849 = mul nsw i32 %847, %848
  %850 = load i32, ptr %32, align 4, !tbaa !5
  %851 = add nsw i32 %849, %850
  %852 = load i32, ptr %40, align 4, !tbaa !5
  %853 = add nsw i32 %851, %852
  %854 = sext i32 %853 to i64
  %855 = getelementptr inbounds double, ptr %846, i64 %854
  store double %843, ptr %855, align 8, !tbaa !9
  %856 = load i32, ptr %34, align 4, !tbaa !5
  %857 = sitofp i32 %856 to double
  %858 = load ptr, ptr %22, align 8, !tbaa !11
  %859 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %858, i32 0, i32 10
  %860 = load ptr, ptr %859, align 8, !tbaa !23
  %861 = load i32, ptr %32, align 4, !tbaa !5
  %862 = load i32, ptr %40, align 4, !tbaa !5
  %863 = add nsw i32 %861, %862
  %864 = sext i32 %863 to i64
  %865 = getelementptr inbounds double, ptr %860, i64 %864
  %866 = load double, ptr %865, align 8, !tbaa !9
  %867 = fmul double %857, %866
  %868 = load ptr, ptr %31, align 8, !tbaa !11
  %869 = load i32, ptr %34, align 4, !tbaa !5
  %870 = load i32, ptr %39, align 4, !tbaa !5
  %871 = mul nsw i32 %869, %870
  %872 = load i32, ptr %40, align 4, !tbaa !5
  %873 = add nsw i32 %871, %872
  %874 = sext i32 %873 to i64
  %875 = getelementptr inbounds double, ptr %868, i64 %874
  %876 = load double, ptr %875, align 8, !tbaa !9
  %877 = load ptr, ptr %29, align 8, !tbaa !11
  %878 = load i32, ptr %34, align 4, !tbaa !5
  %879 = add nsw i32 %878, 1
  %880 = sext i32 %879 to i64
  %881 = getelementptr inbounds double, ptr %877, i64 %880
  %882 = load double, ptr %881, align 8, !tbaa !9
  %883 = load ptr, ptr %31, align 8, !tbaa !11
  %884 = load i32, ptr %34, align 4, !tbaa !5
  %885 = add nsw i32 %884, 1
  %886 = load i32, ptr %39, align 4, !tbaa !5
  %887 = mul nsw i32 %885, %886
  %888 = load i32, ptr %40, align 4, !tbaa !5
  %889 = add nsw i32 %887, %888
  %890 = sext i32 %889 to i64
  %891 = getelementptr inbounds double, ptr %883, i64 %890
  %892 = load double, ptr %891, align 8, !tbaa !9
  %893 = fmul double %882, %892
  %894 = fneg double %893
  %895 = call double @llvm.fmuladd.f64(double %867, double %876, double %894)
  %896 = load ptr, ptr %22, align 8, !tbaa !11
  %897 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %896, i32 0, i32 12
  %898 = load ptr, ptr %897, align 8, !tbaa !25
  %899 = load i32, ptr %33, align 4, !tbaa !5
  %900 = load i32, ptr %35, align 4, !tbaa !5
  %901 = mul nsw i32 %899, %900
  %902 = load i32, ptr %32, align 4, !tbaa !5
  %903 = add nsw i32 %901, %902
  %904 = load i32, ptr %40, align 4, !tbaa !5
  %905 = add nsw i32 %903, %904
  %906 = sext i32 %905 to i64
  %907 = getelementptr inbounds double, ptr %898, i64 %906
  store double %895, ptr %907, align 8, !tbaa !9
  br label %908

908:                                              ; preds = %834
  %909 = load i32, ptr %40, align 4, !tbaa !5
  %910 = add nsw i32 %909, 1
  store i32 %910, ptr %40, align 4, !tbaa !5
  br label %830, !llvm.loop !38

911:                                              ; preds = %830
  br label %912

912:                                              ; preds = %911
  %913 = load i32, ptr %33, align 4, !tbaa !5
  %914 = add nsw i32 %913, 1
  store i32 %914, ptr %33, align 4, !tbaa !5
  br label %820, !llvm.loop !39

915:                                              ; preds = %820
  br label %916

916:                                              ; preds = %915
  %917 = load i32, ptr %32, align 4, !tbaa !5
  %918 = add nsw i32 %917, 16
  store i32 %918, ptr %32, align 4, !tbaa !5
  br label %769, !llvm.loop !40

919:                                              ; preds = %769
  %920 = load ptr, ptr %31, align 8, !tbaa !11
  call void @free(ptr noundef %920) #6
  %921 = load i32, ptr %38, align 4, !tbaa !5
  %922 = icmp eq i32 %921, 1
  br i1 %922, label %923, label %924

923:                                              ; preds = %919
  store i32 1, ptr %12, align 4
  store i32 1, ptr %43, align 4
  br label %951

924:                                              ; preds = %919
  %925 = load ptr, ptr %29, align 8, !tbaa !11
  call void @free(ptr noundef %925) #6
  %926 = load ptr, ptr %30, align 8, !tbaa !11
  call void @free(ptr noundef %926) #6
  store i32 0, ptr %33, align 4, !tbaa !5
  br label %927

927:                                              ; preds = %947, %924
  %928 = load i32, ptr %33, align 4, !tbaa !5
  %929 = load i32, ptr %15, align 4, !tbaa !5
  %930 = icmp slt i32 %928, %929
  br i1 %930, label %931, label %950

931:                                              ; preds = %927
  %932 = load i32, ptr %13, align 4, !tbaa !5
  %933 = load ptr, ptr %16, align 8, !tbaa !11
  %934 = load i32, ptr %33, align 4, !tbaa !5
  %935 = sext i32 %934 to i64
  %936 = getelementptr inbounds i32, ptr %933, i64 %935
  %937 = load i32, ptr %936, align 4, !tbaa !5
  %938 = load double, ptr %14, align 8, !tbaa !9
  %939 = load double, ptr %21, align 8, !tbaa !9
  %940 = load ptr, ptr %22, align 8, !tbaa !11
  %941 = getelementptr inbounds %struct.HypersphericalInterpolationStructure, ptr %940, i32 0, i32 6
  %942 = load ptr, ptr %941, align 8, !tbaa !20
  %943 = load i32, ptr %33, align 4, !tbaa !5
  %944 = sext i32 %943 to i64
  %945 = getelementptr inbounds double, ptr %942, i64 %944
  %946 = call i32 @hyperspherical_get_xmin_from_approx(i32 noundef %932, i32 noundef %937, double noundef %938, double noundef 0.000000e+00, double noundef %939, ptr noundef %945, ptr noundef null)
  br label %947

947:                                              ; preds = %931
  %948 = load i32, ptr %33, align 4, !tbaa !5
  %949 = add nsw i32 %948, 1
  store i32 %949, ptr %33, align 4, !tbaa !5
  br label %927, !llvm.loop !41

950:                                              ; preds = %927
  store i32 0, ptr %12, align 4
  store i32 1, ptr %43, align 4
  br label %951

951:                                              ; preds = %950, %923
  call void @llvm.lifetime.end.p0(i64 4, ptr %61) #6
  br label %952

952:                                              ; preds = %951, %595
  call void @llvm.lifetime.end.p0(i64 4, ptr %60) #6
  br label %953

953:                                              ; preds = %952, %330, %312, %251, %225, %202, %182, %162, %142, %122
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  %954 = load i32, ptr %12, align 4
  ret i32 %954
}

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

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

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

; 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 @pow(double noundef, double noundef) #4

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

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

; Function Attrs: nounwind
declare double @asin(double noundef) #4

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

; Function Attrs: nounwind
declare double @tan(double noundef) #4

; Function Attrs: nounwind
declare double @asinh(double noundef) #4

; Function Attrs: nounwind
declare double @sinh(double noundef) #4

; Function Attrs: nounwind
declare double @tanh(double noundef) #4

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

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

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

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

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 = { 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 #3 = { "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 "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { nounwind }
attributes #7 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = !{!14, !10, i64 8}
!14 = !{!"HypersphericalInterpolationStructure", !6, i64 0, !10, i64 8, !10, i64 16, !6, i64 24, !6, i64 28, !12, i64 32, !12, i64 40, !6, i64 48, !12, i64 56, !12, i64 64, !12, i64 72, !12, i64 80, !12, i64 88}
!15 = !{!14, !10, i64 16}
!16 = !{!14, !6, i64 28}
!17 = !{!14, !6, i64 48}
!18 = !{!14, !6, i64 0}
!19 = !{!14, !12, i64 32}
!20 = !{!14, !12, i64 40}
!21 = !{!14, !12, i64 56}
!22 = !{!14, !12, i64 64}
!23 = !{!14, !12, i64 72}
!24 = !{!14, !12, i64 80}
!25 = !{!14, !12, i64 88}
!26 = !{!14, !6, i64 24}
!27 = distinct !{!27, !28}
!28 = !{!"llvm.loop.mustprogress"}
!29 = distinct !{!29, !28}
!30 = distinct !{!30, !28}
!31 = distinct !{!31, !28}
!32 = distinct !{!32, !28}
!33 = distinct !{!33, !28}
!34 = distinct !{!34, !28}
!35 = distinct !{!35, !28}
!36 = distinct !{!36, !28}
!37 = distinct !{!37, !28}
!38 = distinct !{!38, !28}
!39 = distinct !{!39, !28}
!40 = distinct !{!40, !28}
!41 = distinct !{!41, !28}


; 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 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [13 x i8], align 1
@__func__.hyperspherical_HIS_create = external hidden unnamed_addr constant [26 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [11 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [5 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local range(i32 0, 2) i32 @hyperspherical_HIS_create(i32 noundef %0, double noundef %1, i32 noundef %2, ptr nocapture noundef readonly %3, double noundef %4, double noundef %5, double noundef %6, i32 noundef %7, double noundef %8, ptr nocapture noundef %9, ptr noundef %10) local_unnamed_addr #0 {
  %12 = ptrtoint ptr %3 to i64
  %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 = fmul double %1, %1
  %24 = add nsw i32 %2, -1
  %25 = sext i32 %24 to i64
  %26 = getelementptr inbounds i32, ptr %3, i64 %25
  %27 = load i32, ptr %26, align 4, !tbaa !5
  %28 = fdiv double 0x401921FB54442D18, %1
  %29 = fsub double %5, %4
  %30 = fmul double %29, %6
  %31 = fdiv double %30, %28
  %32 = fptosi double %31 to i32
  %33 = tail call i32 @llvm.smax.i32(i32 %32, i32 2)
  %34 = add nsw i32 %33, -1
  %35 = uitofp nneg i32 %34 to double
  %36 = fdiv double %29, %35
  %37 = getelementptr inbounds i8, ptr %9, i64 8
  store double %1, ptr %37, align 8, !tbaa !9
  %38 = getelementptr inbounds i8, ptr %9, i64 16
  store double %36, ptr %38, align 8, !tbaa !13
  %39 = getelementptr inbounds i8, ptr %9, i64 28
  store i32 %2, ptr %39, align 4, !tbaa !14
  %40 = getelementptr inbounds i8, ptr %9, i64 48
  store i32 %33, ptr %40, align 8, !tbaa !15
  store i32 %0, ptr %9, align 8, !tbaa !16
  %41 = sext i32 %2 to i64
  %42 = shl nsw i64 %41, 2
  %43 = tail call noalias ptr @malloc(i64 noundef %42) #8
  %44 = getelementptr inbounds i8, ptr %9, i64 32
  store ptr %43, ptr %44, align 8, !tbaa !17
  %45 = icmp eq ptr %43, null
  br i1 %45, label %46, label %48

46:                                               ; preds = %11
  %47 = trunc i64 %42 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %13) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %13, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef %47) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 50, ptr noundef nonnull %13) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %13) #9
  br label %.loopexit

48:                                               ; preds = %11
  %49 = shl nsw i64 %41, 3
  %50 = tail call noalias ptr @malloc(i64 noundef %49) #8
  %51 = getelementptr inbounds i8, ptr %9, i64 40
  store ptr %50, ptr %51, align 8, !tbaa !18
  %52 = icmp eq ptr %50, null
  br i1 %52, label %53, label %55

53:                                               ; preds = %48
  %54 = trunc i64 %49 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %14) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %14, ptr noundef nonnull @.str, ptr noundef nonnull @.str.3, i32 noundef %54) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 51, ptr noundef nonnull %14) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %14) #9
  br label %.loopexit

55:                                               ; preds = %48
  %56 = zext nneg i32 %33 to i64
  %57 = shl nuw nsw i64 %56, 3
  %58 = tail call noalias ptr @malloc(i64 noundef %57) #8
  %59 = getelementptr inbounds i8, ptr %9, i64 56
  store ptr %58, ptr %59, align 8, !tbaa !19
  %60 = icmp eq ptr %58, null
  br i1 %60, label %61, label %63

61:                                               ; preds = %55
  %62 = trunc i64 %57 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %15) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %15, ptr noundef nonnull @.str, ptr noundef nonnull @.str.4, i32 noundef %62) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 52, ptr noundef nonnull %15) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %15) #9
  br label %.loopexit

63:                                               ; preds = %55
  %64 = tail call noalias ptr @malloc(i64 noundef %57) #8
  %65 = getelementptr inbounds i8, ptr %9, i64 64
  store ptr %64, ptr %65, align 8, !tbaa !20
  %66 = icmp eq ptr %64, null
  br i1 %66, label %67, label %69

67:                                               ; preds = %63
  %68 = trunc i64 %57 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %16) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %16, ptr noundef nonnull @.str, ptr noundef nonnull @.str.5, i32 noundef %68) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 53, ptr noundef nonnull %16) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %16) #9
  br label %.loopexit

69:                                               ; preds = %63
  %70 = tail call noalias ptr @malloc(i64 noundef %57) #8
  %71 = getelementptr inbounds i8, ptr %9, i64 72
  store ptr %70, ptr %71, align 8, !tbaa !21
  %72 = icmp eq ptr %70, null
  br i1 %72, label %73, label %75

73:                                               ; preds = %69
  %74 = trunc i64 %57 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %17) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %17, ptr noundef nonnull @.str, ptr noundef nonnull @.str.6, i32 noundef %74) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 54, ptr noundef nonnull %17) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %17) #9
  br label %.loopexit

75:                                               ; preds = %69
  %76 = mul i64 %57, %41
  %77 = tail call noalias ptr @malloc(i64 noundef %76) #8
  %78 = getelementptr inbounds i8, ptr %9, i64 80
  store ptr %77, ptr %78, align 8, !tbaa !22
  %79 = icmp eq ptr %77, null
  br i1 %79, label %80, label %82

80:                                               ; preds = %75
  %81 = trunc i64 %76 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %18) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %18, ptr noundef nonnull @.str, ptr noundef nonnull @.str.7, i32 noundef %81) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 55, ptr noundef nonnull %18) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %18) #9
  br label %.loopexit

82:                                               ; preds = %75
  %83 = tail call noalias ptr @malloc(i64 noundef %76) #8
  %84 = getelementptr inbounds i8, ptr %9, i64 88
  store ptr %83, ptr %84, align 8, !tbaa !23
  %85 = icmp eq ptr %83, null
  br i1 %85, label %86, label %88

86:                                               ; preds = %82
  %87 = trunc i64 %76 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %19) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %19, ptr noundef nonnull @.str, ptr noundef nonnull @.str.8, i32 noundef %87) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 56, ptr noundef nonnull %19) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %19) #9
  br label %.loopexit

88:                                               ; preds = %82
  %89 = fmul double %36, 5.000000e-01
  %90 = fmul double %36, %89
  %91 = fcmp olt double %90, 0x3E7AD7F29ABCAF48
  br i1 %91, label %92, label %94

92:                                               ; preds = %88
  %93 = getelementptr inbounds i8, ptr %9, i64 24
  store i32 1, ptr %93, align 8, !tbaa !24
  br label %101

94:                                               ; preds = %88
  %95 = tail call double @pow(double noundef %36, double noundef 4.000000e+00) #9
  %96 = fdiv double %95, 2.400000e+01
  %97 = fcmp olt double %96, 0x3E7AD7F29ABCAF48
  %98 = getelementptr inbounds i8, ptr %9, i64 24
  br i1 %97, label %99, label %100

99:                                               ; preds = %94
  store i32 3, ptr %98, align 8, !tbaa !24
  br label %101

100:                                              ; preds = %94
  store i32 5, ptr %98, align 8, !tbaa !24
  br label %101

101:                                              ; preds = %99, %100, %92
  %102 = icmp sgt i32 %2, 0
  br i1 %102, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %101
  %103 = load ptr, ptr %44, align 8, !tbaa !17
  %wide.trip.count = zext nneg i32 %2 to i64
  %min.iters.check = icmp ult i32 %2, 8
  %104 = ptrtoint ptr %103 to i64
  %105 = sub i64 %104, %12
  %diff.check = icmp ult i64 %105, 32
  %or.cond593 = select i1 %min.iters.check, i1 true, i1 %diff.check
  br i1 %or.cond593, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph
  %n.vec = and i64 %wide.trip.count, 2147483640
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %106 = getelementptr inbounds i32, ptr %3, i64 %index
  %107 = getelementptr inbounds i8, ptr %106, i64 16
  %wide.load = load <4 x i32>, ptr %106, align 4, !tbaa !5
  %wide.load478 = load <4 x i32>, ptr %107, align 4, !tbaa !5
  %108 = getelementptr inbounds i32, ptr %103, i64 %index
  %109 = getelementptr inbounds i8, ptr %108, i64 16
  store <4 x i32> %wide.load, ptr %108, align 4, !tbaa !5
  store <4 x i32> %wide.load478, ptr %109, align 4, !tbaa !5
  %index.next = add nuw i64 %index, 8
  %110 = icmp eq i64 %index.next, %n.vec
  br i1 %110, label %middle.block, label %vector.body, !llvm.loop !25

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %n.vec, %wide.trip.count
  br i1 %cmp.n, label %._crit_edge, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %.lr.ph
  %indvars.iv.ph = phi i64 [ 0, %.lr.ph ], [ %n.vec, %middle.block ]
  %xtraiter = and i64 %wide.trip.count, 3
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader, %scalar.ph.prol
  %indvars.iv.prol = phi i64 [ %indvars.iv.next.prol, %scalar.ph.prol ], [ %indvars.iv.ph, %scalar.ph.preheader ]
  %prol.iter = phi i64 [ %prol.iter.next, %scalar.ph.prol ], [ 0, %scalar.ph.preheader ]
  %111 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv.prol
  %112 = load i32, ptr %111, align 4, !tbaa !5
  %113 = getelementptr inbounds i32, ptr %103, i64 %indvars.iv.prol
  store i32 %112, ptr %113, align 4, !tbaa !5
  %indvars.iv.next.prol = add nuw nsw i64 %indvars.iv.prol, 1
  %prol.iter.next = add i64 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i64 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol, !llvm.loop !29

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %scalar.ph.preheader
  %indvars.iv.unr = phi i64 [ %indvars.iv.ph, %scalar.ph.preheader ], [ %indvars.iv.next.prol, %scalar.ph.prol ]
  %114 = sub nsw i64 %indvars.iv.ph, %wide.trip.count
  %115 = icmp ugt i64 %114, -4
  br i1 %115, label %._crit_edge, label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.prol.loopexit, %scalar.ph
  %indvars.iv = phi i64 [ %indvars.iv.next.3, %scalar.ph ], [ %indvars.iv.unr, %scalar.ph.prol.loopexit ]
  %116 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv
  %117 = load i32, ptr %116, align 4, !tbaa !5
  %118 = getelementptr inbounds i32, ptr %103, i64 %indvars.iv
  store i32 %117, ptr %118, align 4, !tbaa !5
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %119 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv.next
  %120 = load i32, ptr %119, align 4, !tbaa !5
  %121 = getelementptr inbounds i32, ptr %103, i64 %indvars.iv.next
  store i32 %120, ptr %121, align 4, !tbaa !5
  %indvars.iv.next.1 = add nuw nsw i64 %indvars.iv, 2
  %122 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv.next.1
  %123 = load i32, ptr %122, align 4, !tbaa !5
  %124 = getelementptr inbounds i32, ptr %103, i64 %indvars.iv.next.1
  store i32 %123, ptr %124, align 4, !tbaa !5
  %indvars.iv.next.2 = add nuw nsw i64 %indvars.iv, 3
  %125 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv.next.2
  %126 = load i32, ptr %125, align 4, !tbaa !5
  %127 = getelementptr inbounds i32, ptr %103, i64 %indvars.iv.next.2
  store i32 %126, ptr %127, align 4, !tbaa !5
  %indvars.iv.next.3 = add nuw nsw i64 %indvars.iv, 4
  %exitcond.not.3 = icmp eq i64 %indvars.iv.next.3, %wide.trip.count
  br i1 %exitcond.not.3, label %._crit_edge, label %scalar.ph, !llvm.loop !31

._crit_edge:                                      ; preds = %scalar.ph.prol.loopexit, %scalar.ph, %middle.block, %101
  %128 = add nsw i32 %27, 3
  %129 = sext i32 %128 to i64
  %130 = shl nsw i64 %129, 3
  %131 = tail call noalias ptr @malloc(i64 noundef %130) #8
  %132 = icmp eq ptr %131, null
  br i1 %132, label %133, label %135

133:                                              ; preds = %._crit_edge
  %134 = trunc i64 %130 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %20) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %20, ptr noundef nonnull @.str, ptr noundef nonnull @.str.9, i32 noundef %134) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 71, ptr noundef nonnull %20) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %20) #9
  br label %.loopexit

135:                                              ; preds = %._crit_edge
  %136 = tail call noalias ptr @malloc(i64 noundef %130) #8
  %137 = icmp eq ptr %136, null
  br i1 %137, label %138, label %.preheader361

.preheader361:                                    ; preds = %135
  br i1 %102, label %.lr.ph364, label %._crit_edge365

138:                                              ; preds = %135
  %139 = trunc i64 %130 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %21) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %21, ptr noundef nonnull @.str, ptr noundef nonnull @.str.10, i32 noundef %139) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 72, ptr noundef nonnull %21) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %21) #9
  br label %.loopexit

.lr.ph364:                                        ; preds = %.preheader361, %144
  %.0331363 = phi i32 [ %145, %144 ], [ %24, %.preheader361 ]
  %140 = zext nneg i32 %.0331363 to i64
  %141 = getelementptr inbounds i32, ptr %3, i64 %140
  %142 = load i32, ptr %141, align 4, !tbaa !5
  %143 = icmp slt i32 %142, %7
  br i1 %143, label %._crit_edge365, label %144

144:                                              ; preds = %.lr.ph364
  %145 = add nsw i32 %.0331363, -1
  %146 = icmp sgt i32 %.0331363, 0
  br i1 %146, label %.lr.ph364, label %._crit_edge365, !llvm.loop !32

._crit_edge365:                                   ; preds = %144, %.lr.ph364, %.preheader361
  %.0339 = phi i32 [ -10, %.preheader361 ], [ %142, %.lr.ph364 ], [ -10, %144 ]
  %.0325 = phi i32 [ -10, %.preheader361 ], [ %.0331363, %.lr.ph364 ], [ -10, %144 ]
  switch i32 %0, label %.loopexit [
    i32 0, label %vector.memcheck490
    i32 1, label %201
    i32 -1, label %240
  ]

vector.memcheck490:                               ; preds = %._crit_edge365
  %147 = sitofp i32 %.0339 to double
  %148 = fadd double %147, 1.000000e+00
  %149 = fmul double %148, %147
  %150 = tail call double @sqrt(double noundef %149) #9
  %151 = load ptr, ptr %59, align 8, !tbaa !19
  %152 = load ptr, ptr %65, align 8, !tbaa !20
  %153 = load ptr, ptr %71, align 8, !tbaa !21
  %154 = ptrtoint ptr %153 to i64
  %155 = ptrtoint ptr %152 to i64
  %156 = ptrtoint ptr %151 to i64
  %157 = sub i64 %155, %156
  %diff.check491 = icmp ult i64 %157, 16
  %158 = sub i64 %154, %156
  %diff.check492 = icmp ult i64 %158, 16
  %conflict.rdx = or i1 %diff.check491, %diff.check492
  %159 = sub i64 %154, %155
  %diff.check493 = icmp ult i64 %159, 16
  %conflict.rdx494 = or i1 %conflict.rdx, %diff.check493
  br i1 %conflict.rdx494, label %scalar.ph496.preheader, label %vector.ph498

scalar.ph496.preheader:                           ; preds = %middle.block495, %vector.memcheck490
  %indvars.iv431.ph = phi i64 [ 0, %vector.memcheck490 ], [ %n.vec500, %middle.block495 ]
  %xtraiter599 = and i64 %56, 1
  %lcmp.mod600.not = icmp eq i64 %xtraiter599, 0
  br i1 %lcmp.mod600.not, label %scalar.ph496.prol.loopexit, label %scalar.ph496.prol

scalar.ph496.prol:                                ; preds = %scalar.ph496.preheader
  %160 = trunc nuw nsw i64 %indvars.iv431.ph to i32
  %161 = uitofp nneg i32 %160 to double
  %162 = tail call double @llvm.fmuladd.f64(double %161, double %36, double %4)
  %163 = getelementptr inbounds double, ptr %151, i64 %indvars.iv431.ph
  store double %162, ptr %163, align 8, !tbaa !33
  %164 = getelementptr inbounds double, ptr %152, i64 %indvars.iv431.ph
  store double %162, ptr %164, align 8, !tbaa !33
  %165 = fdiv double 1.000000e+00, %162
  %166 = getelementptr inbounds double, ptr %153, i64 %indvars.iv431.ph
  store double %165, ptr %166, align 8, !tbaa !33
  %indvars.iv.next432.prol = or disjoint i64 %indvars.iv431.ph, 1
  br label %scalar.ph496.prol.loopexit

scalar.ph496.prol.loopexit:                       ; preds = %scalar.ph496.prol, %scalar.ph496.preheader
  %indvars.iv431.unr = phi i64 [ %indvars.iv431.ph, %scalar.ph496.preheader ], [ %indvars.iv.next432.prol, %scalar.ph496.prol ]
  %167 = add nsw i64 %56, -1
  %168 = icmp eq i64 %indvars.iv431.ph, %167
  br i1 %168, label %.preheader355, label %scalar.ph496

vector.ph498:                                     ; preds = %vector.memcheck490
  %n.vec500 = and i64 %56, 2147483646
  %broadcast.splatinsert506 = insertelement <2 x double> poison, double %36, i64 0
  %broadcast.splat507 = shufflevector <2 x double> %broadcast.splatinsert506, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert508 = insertelement <2 x double> poison, double %4, i64 0
  %broadcast.splat509 = shufflevector <2 x double> %broadcast.splatinsert508, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body502

vector.body502:                                   ; preds = %vector.body502, %vector.ph498
  %index503 = phi i64 [ 0, %vector.ph498 ], [ %index.next510, %vector.body502 ]
  %vec.ind504 = phi <2 x i32> [ <i32 0, i32 1>, %vector.ph498 ], [ %vec.ind.next505, %vector.body502 ]
  %169 = uitofp <2 x i32> %vec.ind504 to <2 x double>
  %170 = tail call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %169, <2 x double> %broadcast.splat507, <2 x double> %broadcast.splat509)
  %171 = getelementptr inbounds double, ptr %151, i64 %index503
  store <2 x double> %170, ptr %171, align 8, !tbaa !33
  %172 = getelementptr inbounds double, ptr %152, i64 %index503
  store <2 x double> %170, ptr %172, align 8, !tbaa !33
  %173 = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, %170
  %174 = getelementptr inbounds double, ptr %153, i64 %index503
  store <2 x double> %173, ptr %174, align 8, !tbaa !33
  %index.next510 = add nuw i64 %index503, 2
  %vec.ind.next505 = add <2 x i32> %vec.ind504, <i32 2, i32 2>
  %175 = icmp eq i64 %index.next510, %n.vec500
  br i1 %175, label %middle.block495, label %vector.body502, !llvm.loop !34

middle.block495:                                  ; preds = %vector.body502
  %cmp.n511 = icmp eq i64 %n.vec500, %56
  br i1 %cmp.n511, label %.preheader355, label %scalar.ph496.preheader

.preheader355:                                    ; preds = %scalar.ph496.prol.loopexit, %scalar.ph496, %middle.block495
  %176 = fdiv double %150, %1
  %177 = add i32 %27, 2
  %.not352379 = icmp slt i32 %27, -2
  br i1 %.not352379, label %.loopexit356, label %.lr.ph381

.lr.ph381:                                        ; preds = %.preheader355
  %178 = fdiv double 1.000000e+00, %1
  %smax439 = tail call i32 @llvm.smax.i32(i32 %177, i32 0)
  %179 = add nuw i32 %smax439, 1
  %wide.trip.count440 = zext i32 %179 to i64
  %min.iters.check514 = icmp slt i32 %177, 3
  br i1 %min.iters.check514, label %scalar.ph513.preheader, label %vector.ph515

scalar.ph513.preheader:                           ; preds = %middle.block512, %.lr.ph381
  %indvars.iv436.ph = phi i64 [ 0, %.lr.ph381 ], [ %n.vec517, %middle.block512 ]
  br label %scalar.ph513

vector.ph515:                                     ; preds = %.lr.ph381
  %n.vec517 = and i64 %wide.trip.count440, 4294967292
  %broadcast.splatinsert521 = insertelement <2 x double> poison, double %1, i64 0
  %broadcast.splat522 = shufflevector <2 x double> %broadcast.splatinsert521, <2 x double> poison, <2 x i32> zeroinitializer
  %broadcast.splatinsert523 = insertelement <2 x double> poison, double %178, i64 0
  %broadcast.splat524 = shufflevector <2 x double> %broadcast.splatinsert523, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body519

vector.body519:                                   ; preds = %vector.body519, %vector.ph515
  %index520 = phi i64 [ 0, %vector.ph515 ], [ %index.next525, %vector.body519 ]
  %180 = getelementptr inbounds double, ptr %131, i64 %index520
  %181 = getelementptr inbounds i8, ptr %180, i64 16
  store <2 x double> %broadcast.splat522, ptr %180, align 8, !tbaa !33
  store <2 x double> %broadcast.splat522, ptr %181, align 8, !tbaa !33
  %182 = getelementptr inbounds double, ptr %136, i64 %index520
  %183 = getelementptr inbounds i8, ptr %182, i64 16
  store <2 x double> %broadcast.splat524, ptr %182, align 8, !tbaa !33
  store <2 x double> %broadcast.splat524, ptr %183, align 8, !tbaa !33
  %index.next525 = add nuw i64 %index520, 4
  %184 = icmp eq i64 %index.next525, %n.vec517
  br i1 %184, label %middle.block512, label %vector.body519, !llvm.loop !35

middle.block512:                                  ; preds = %vector.body519
  %cmp.n526 = icmp eq i64 %n.vec517, %wide.trip.count440
  br i1 %cmp.n526, label %.loopexit356, label %scalar.ph513.preheader

scalar.ph496:                                     ; preds = %scalar.ph496.prol.loopexit, %scalar.ph496
  %indvars.iv431 = phi i64 [ %indvars.iv.next432.1, %scalar.ph496 ], [ %indvars.iv431.unr, %scalar.ph496.prol.loopexit ]
  %185 = trunc nuw nsw i64 %indvars.iv431 to i32
  %186 = uitofp nneg i32 %185 to double
  %187 = tail call double @llvm.fmuladd.f64(double %186, double %36, double %4)
  %188 = getelementptr inbounds double, ptr %151, i64 %indvars.iv431
  store double %187, ptr %188, align 8, !tbaa !33
  %189 = getelementptr inbounds double, ptr %152, i64 %indvars.iv431
  store double %187, ptr %189, align 8, !tbaa !33
  %190 = fdiv double 1.000000e+00, %187
  %191 = getelementptr inbounds double, ptr %153, i64 %indvars.iv431
  store double %190, ptr %191, align 8, !tbaa !33
  %indvars.iv.next432 = add nuw nsw i64 %indvars.iv431, 1
  %192 = trunc nuw nsw i64 %indvars.iv.next432 to i32
  %193 = uitofp nneg i32 %192 to double
  %194 = tail call double @llvm.fmuladd.f64(double %193, double %36, double %4)
  %195 = getelementptr inbounds double, ptr %151, i64 %indvars.iv.next432
  store double %194, ptr %195, align 8, !tbaa !33
  %196 = getelementptr inbounds double, ptr %152, i64 %indvars.iv.next432
  store double %194, ptr %196, align 8, !tbaa !33
  %197 = fdiv double 1.000000e+00, %194
  %198 = getelementptr inbounds double, ptr %153, i64 %indvars.iv.next432
  store double %197, ptr %198, align 8, !tbaa !33
  %indvars.iv.next432.1 = add nuw nsw i64 %indvars.iv431, 2
  %exitcond435.not.1 = icmp eq i64 %indvars.iv.next432.1, %56
  br i1 %exitcond435.not.1, label %.preheader355, label %scalar.ph496, !llvm.loop !36

scalar.ph513:                                     ; preds = %scalar.ph513.preheader, %scalar.ph513
  %indvars.iv436 = phi i64 [ %indvars.iv.next437, %scalar.ph513 ], [ %indvars.iv436.ph, %scalar.ph513.preheader ]
  %199 = getelementptr inbounds double, ptr %131, i64 %indvars.iv436
  store double %1, ptr %199, align 8, !tbaa !33
  %200 = getelementptr inbounds double, ptr %136, i64 %indvars.iv436
  store double %178, ptr %200, align 8, !tbaa !33
  %indvars.iv.next437 = add nuw nsw i64 %indvars.iv436, 1
  %exitcond441.not = icmp eq i64 %indvars.iv.next437, %wide.trip.count440
  br i1 %exitcond441.not, label %.loopexit356, label %scalar.ph513, !llvm.loop !37

201:                                              ; preds = %._crit_edge365
  %202 = sitofp i32 %.0339 to double
  %203 = fadd double %202, 1.000000e+00
  %204 = fmul double %203, %202
  %205 = tail call double @sqrt(double noundef %204) #9
  %206 = fdiv double %205, %1
  %207 = tail call double @asin(double noundef %206) #9
  br label %211

.preheader357:                                    ; preds = %211
  %208 = add i32 %27, 2
  %.not351375 = icmp slt i32 %27, -2
  br i1 %.not351375, label %.loopexit356, label %.lr.ph377.preheader

.lr.ph377.preheader:                              ; preds = %.preheader357
  %smax428 = tail call i32 @llvm.smax.i32(i32 %208, i32 0)
  %209 = add nuw i32 %smax428, 1
  %wide.trip.count429 = zext i32 %209 to i64
  %xtraiter597 = and i64 %wide.trip.count429, 1
  %210 = icmp slt i32 %208, 1
  br i1 %210, label %.loopexit356.loopexit594.unr-lcssa, label %.lr.ph377.preheader.new

.lr.ph377.preheader.new:                          ; preds = %.lr.ph377.preheader
  %unroll_iter = and i64 %wide.trip.count429, 4294967294
  br label %.lr.ph377

211:                                              ; preds = %201, %211
  %indvars.iv420 = phi i64 [ 0, %201 ], [ %indvars.iv.next421, %211 ]
  %212 = trunc nuw nsw i64 %indvars.iv420 to i32
  %213 = uitofp nneg i32 %212 to double
  %214 = tail call double @llvm.fmuladd.f64(double %213, double %36, double %4)
  %215 = load ptr, ptr %59, align 8, !tbaa !19
  %216 = getelementptr inbounds double, ptr %215, i64 %indvars.iv420
  store double %214, ptr %216, align 8, !tbaa !33
  %217 = tail call double @sin(double noundef %214) #9
  %218 = load ptr, ptr %65, align 8, !tbaa !20
  %219 = getelementptr inbounds double, ptr %218, i64 %indvars.iv420
  store double %217, ptr %219, align 8, !tbaa !33
  %220 = tail call double @tan(double noundef %214) #9
  %221 = fdiv double 1.000000e+00, %220
  %222 = load ptr, ptr %71, align 8, !tbaa !21
  %223 = getelementptr inbounds double, ptr %222, i64 %indvars.iv420
  store double %221, ptr %223, align 8, !tbaa !33
  %indvars.iv.next421 = add nuw nsw i64 %indvars.iv420, 1
  %exitcond424.not = icmp eq i64 %indvars.iv.next421, %56
  br i1 %exitcond424.not, label %.preheader357, label %211, !llvm.loop !38

.lr.ph377:                                        ; preds = %.lr.ph377, %.lr.ph377.preheader.new
  %indvars.iv425 = phi i64 [ 0, %.lr.ph377.preheader.new ], [ %indvars.iv.next426.1, %.lr.ph377 ]
  %niter = phi i64 [ 0, %.lr.ph377.preheader.new ], [ %niter.next.1, %.lr.ph377 ]
  %224 = mul nuw nsw i64 %indvars.iv425, %indvars.iv425
  %225 = trunc nuw i64 %224 to i32
  %226 = uitofp nneg i32 %225 to double
  %227 = fsub double %23, %226
  %228 = tail call double @sqrt(double noundef %227) #9
  %229 = getelementptr inbounds double, ptr %131, i64 %indvars.iv425
  store double %228, ptr %229, align 8, !tbaa !33
  %230 = fdiv double 1.000000e+00, %228
  %231 = getelementptr inbounds double, ptr %136, i64 %indvars.iv425
  store double %230, ptr %231, align 8, !tbaa !33
  %indvars.iv.next426 = or disjoint i64 %indvars.iv425, 1
  %232 = mul nuw nsw i64 %indvars.iv.next426, %indvars.iv.next426
  %233 = trunc nuw i64 %232 to i32
  %234 = uitofp nneg i32 %233 to double
  %235 = fsub double %23, %234
  %236 = tail call double @sqrt(double noundef %235) #9
  %237 = getelementptr inbounds double, ptr %131, i64 %indvars.iv.next426
  store double %236, ptr %237, align 8, !tbaa !33
  %238 = fdiv double 1.000000e+00, %236
  %239 = getelementptr inbounds double, ptr %136, i64 %indvars.iv.next426
  store double %238, ptr %239, align 8, !tbaa !33
  %indvars.iv.next426.1 = add nuw nsw i64 %indvars.iv425, 2
  %niter.next.1 = add i64 %niter, 2
  %niter.ncmp.1 = icmp eq i64 %niter.next.1, %unroll_iter
  br i1 %niter.ncmp.1, label %.loopexit356.loopexit594.unr-lcssa, label %.lr.ph377, !llvm.loop !39

240:                                              ; preds = %._crit_edge365
  %241 = sitofp i32 %.0339 to double
  %242 = fadd double %241, 1.000000e+00
  %243 = fmul double %242, %241
  %244 = tail call double @sqrt(double noundef %243) #9
  %245 = fdiv double %244, %1
  %246 = tail call double @asinh(double noundef %245) #9
  br label %258

.preheader359:                                    ; preds = %258
  %247 = add i32 %27, 2
  %.not371 = icmp slt i32 %27, -2
  br i1 %.not371, label %.loopexit356, label %.lr.ph373.preheader

.lr.ph373.preheader:                              ; preds = %.preheader359
  %smax = tail call i32 @llvm.smax.i32(i32 %247, i32 0)
  %248 = add nuw i32 %smax, 1
  %wide.trip.count418 = zext i32 %248 to i64
  %min.iters.check481 = icmp slt i32 %247, 1
  br i1 %min.iters.check481, label %.lr.ph373.preheader595, label %vector.ph482

.lr.ph373.preheader595:                           ; preds = %middle.block479, %.lr.ph373.preheader
  %indvars.iv415.ph = phi i64 [ 0, %.lr.ph373.preheader ], [ %n.vec484, %middle.block479 ]
  br label %.lr.ph373

vector.ph482:                                     ; preds = %.lr.ph373.preheader
  %n.vec484 = and i64 %wide.trip.count418, 4294967294
  %broadcast.splatinsert = insertelement <2 x double> poison, double %23, i64 0
  %broadcast.splat = shufflevector <2 x double> %broadcast.splatinsert, <2 x double> poison, <2 x i32> zeroinitializer
  br label %vector.body486

vector.body486:                                   ; preds = %vector.body486, %vector.ph482
  %index487 = phi i64 [ 0, %vector.ph482 ], [ %index.next488, %vector.body486 ]
  %vec.ind = phi <2 x i64> [ <i64 0, i64 1>, %vector.ph482 ], [ %vec.ind.next, %vector.body486 ]
  %249 = mul nuw nsw <2 x i64> %vec.ind, %vec.ind
  %250 = trunc <2 x i64> %249 to <2 x i32>
  %251 = uitofp <2 x i32> %250 to <2 x double>
  %252 = fadd <2 x double> %broadcast.splat, %251
  %253 = tail call <2 x double> @llvm.sqrt.v2f64(<2 x double> %252)
  %254 = getelementptr inbounds double, ptr %131, i64 %index487
  store <2 x double> %253, ptr %254, align 8, !tbaa !33
  %255 = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, %253
  %256 = getelementptr inbounds double, ptr %136, i64 %index487
  store <2 x double> %255, ptr %256, align 8, !tbaa !33
  %index.next488 = add nuw i64 %index487, 2
  %vec.ind.next = add <2 x i64> %vec.ind, <i64 2, i64 2>
  %257 = icmp eq i64 %index.next488, %n.vec484
  br i1 %257, label %middle.block479, label %vector.body486, !llvm.loop !40

middle.block479:                                  ; preds = %vector.body486
  %cmp.n489 = icmp eq i64 %n.vec484, %wide.trip.count418
  br i1 %cmp.n489, label %.loopexit356, label %.lr.ph373.preheader595

258:                                              ; preds = %240, %258
  %indvars.iv410 = phi i64 [ 0, %240 ], [ %indvars.iv.next411, %258 ]
  %259 = trunc nuw nsw i64 %indvars.iv410 to i32
  %260 = uitofp nneg i32 %259 to double
  %261 = tail call double @llvm.fmuladd.f64(double %260, double %36, double %4)
  %262 = load ptr, ptr %59, align 8, !tbaa !19
  %263 = getelementptr inbounds double, ptr %262, i64 %indvars.iv410
  store double %261, ptr %263, align 8, !tbaa !33
  %264 = tail call double @sinh(double noundef %261) #9
  %265 = load ptr, ptr %65, align 8, !tbaa !20
  %266 = getelementptr inbounds double, ptr %265, i64 %indvars.iv410
  store double %264, ptr %266, align 8, !tbaa !33
  %267 = tail call double @tanh(double noundef %261) #9
  %268 = fdiv double 1.000000e+00, %267
  %269 = load ptr, ptr %71, align 8, !tbaa !21
  %270 = getelementptr inbounds double, ptr %269, i64 %indvars.iv410
  store double %268, ptr %270, align 8, !tbaa !33
  %indvars.iv.next411 = add nuw nsw i64 %indvars.iv410, 1
  %exitcond414.not = icmp eq i64 %indvars.iv.next411, %56
  br i1 %exitcond414.not, label %.preheader359, label %258, !llvm.loop !41

.lr.ph373:                                        ; preds = %.lr.ph373.preheader595, %.lr.ph373
  %indvars.iv415 = phi i64 [ %indvars.iv.next416, %.lr.ph373 ], [ %indvars.iv415.ph, %.lr.ph373.preheader595 ]
  %271 = mul nuw nsw i64 %indvars.iv415, %indvars.iv415
  %272 = trunc nuw i64 %271 to i32
  %273 = uitofp nneg i32 %272 to double
  %274 = fadd double %23, %273
  %sqrt = tail call double @llvm.sqrt.f64(double %274)
  %275 = getelementptr inbounds double, ptr %131, i64 %indvars.iv415
  store double %sqrt, ptr %275, align 8, !tbaa !33
  %276 = fdiv double 1.000000e+00, %sqrt
  %277 = getelementptr inbounds double, ptr %136, i64 %indvars.iv415
  store double %276, ptr %277, align 8, !tbaa !33
  %indvars.iv.next416 = add nuw nsw i64 %indvars.iv415, 1
  %exitcond419.not = icmp eq i64 %indvars.iv.next416, %wide.trip.count418
  br i1 %exitcond419.not, label %.loopexit356, label %.lr.ph373, !llvm.loop !42

.loopexit356.loopexit594.unr-lcssa:               ; preds = %.lr.ph377, %.lr.ph377.preheader
  %indvars.iv425.unr = phi i64 [ 0, %.lr.ph377.preheader ], [ %indvars.iv.next426.1, %.lr.ph377 ]
  %lcmp.mod598.not = icmp eq i64 %xtraiter597, 0
  br i1 %lcmp.mod598.not, label %.loopexit356, label %.lr.ph377.epil

.lr.ph377.epil:                                   ; preds = %.loopexit356.loopexit594.unr-lcssa
  %278 = mul nuw nsw i64 %indvars.iv425.unr, %indvars.iv425.unr
  %279 = trunc nuw i64 %278 to i32
  %280 = uitofp nneg i32 %279 to double
  %281 = fsub double %23, %280
  %282 = tail call double @sqrt(double noundef %281) #9
  %283 = getelementptr inbounds double, ptr %131, i64 %indvars.iv425.unr
  store double %282, ptr %283, align 8, !tbaa !33
  %284 = fdiv double 1.000000e+00, %282
  %285 = getelementptr inbounds double, ptr %136, i64 %indvars.iv425.unr
  store double %284, ptr %285, align 8, !tbaa !33
  br label %.loopexit356

.loopexit356:                                     ; preds = %.lr.ph373, %.lr.ph377.epil, %.loopexit356.loopexit594.unr-lcssa, %scalar.ph513, %middle.block479, %middle.block512, %.preheader359, %.preheader357, %.preheader355
  %.pre-phi = phi i32 [ %247, %.preheader359 ], [ %208, %.preheader357 ], [ %177, %.preheader355 ], [ %177, %middle.block512 ], [ %247, %middle.block479 ], [ %177, %scalar.ph513 ], [ %208, %.loopexit356.loopexit594.unr-lcssa ], [ %208, %.lr.ph377.epil ], [ %247, %.lr.ph373 ]
  %.0326 = phi double [ %246, %.preheader359 ], [ %207, %.preheader357 ], [ %176, %.preheader355 ], [ %176, %middle.block512 ], [ %246, %middle.block479 ], [ %176, %scalar.ph513 ], [ %207, %.loopexit356.loopexit594.unr-lcssa ], [ %207, %.lr.ph377.epil ], [ %246, %.lr.ph373 ]
  %286 = fsub double %.0326, %4
  %287 = fdiv double %286, %36
  %288 = fptosi double %287 to i32
  %289 = sext i32 %.pre-phi to i64
  %290 = shl nsw i64 %289, 7
  %291 = tail call noalias ptr @malloc(i64 noundef %290) #8
  %292 = icmp eq ptr %291, null
  br i1 %292, label %293, label %295

293:                                              ; preds = %.loopexit356
  %294 = trunc i64 %290 to i32
  call void @llvm.lifetime.start.p0(i64 2048, ptr nonnull %22) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef nonnull %22, ptr noundef nonnull @.str, ptr noundef nonnull @.str.11, i32 noundef %294) #9
  call void (ptr, ptr, ...) @class_protect_sprintf(ptr noundef %10, ptr noundef nonnull @.str.2, ptr noundef nonnull @__func__.hyperspherical_HIS_create, i32 noundef 142, ptr noundef nonnull %22) #9
  call void @llvm.lifetime.end.p0(i64 2048, ptr nonnull %22) #9
  br label %295

295:                                              ; preds = %.loopexit356, %293
  %296 = icmp eq i32 %0, 1
  br i1 %296, label %297, label %306

297:                                              ; preds = %295
  %298 = fadd double %1, 2.000000e-01
  %299 = fptosi double %298 to i32
  %300 = add nsw i32 %27, 1
  %301 = icmp eq i32 %300, %299
  br i1 %301, label %302, label %306

302:                                              ; preds = %297
  %303 = sext i32 %299 to i64
  %304 = getelementptr inbounds double, ptr %291, i64 %303
  store double 0.000000e+00, ptr %304, align 8, !tbaa !33
  %305 = add nsw i32 %27, -1
  br label %306

306:                                              ; preds = %302, %297, %295
  %.0338 = phi i32 [ %305, %302 ], [ %27, %297 ], [ %27, %295 ]
  %307 = icmp sgt i32 %288, 0
  br i1 %307, label %.lr.ph389, label %.preheader

.lr.ph389:                                        ; preds = %306
  %308 = call i32 @llvm.smin.i32(i32 %33, i32 %288)
  %309 = call i32 @llvm.smin.i32(i32 %.0339, i32 %.0338)
  %310 = add nsw i32 %309, 1
  %.not354382 = icmp slt i32 %.0325, 0
  %311 = add nsw i32 %.0325, 1
  %wide.trip.count450 = zext nneg i32 %308 to i64
  %wide.trip.count445 = zext nneg i32 %311 to i64
  br label %324

.preheader:                                       ; preds = %._crit_edge386, %306
  %312 = icmp sgt i32 %33, %288
  br i1 %312, label %.lr.ph401, label %._crit_edge402

.lr.ph401:                                        ; preds = %.preheader
  %313 = call i32 @llvm.smin.i32(i32 %.0339, i32 %.0338)
  %314 = add nsw i32 %313, 1
  %.not353394 = icmp sgt i32 %.0325, -1
  %315 = zext nneg i32 %33 to i64
  %316 = add nsw i32 %.0325, 1
  %317 = sext i32 %288 to i64
  %wide.trip.count460 = zext i32 %316 to i64
  %318 = shl nsw i64 %317, 3
  %319 = add nuw nsw i64 %wide.trip.count460, 2305843009213693951
  %320 = mul i64 %319, %56
  %321 = add i64 %320, %317
  %322 = shl i64 %321, 3
  %323 = sub i32 %33, %288
  %scevgep537 = getelementptr i8, ptr %131, i64 16
  br label %361

324:                                              ; preds = %.lr.ph389, %._crit_edge386
  %indvars.iv447 = phi i64 [ 0, %.lr.ph389 ], [ %indvars.iv.next448, %._crit_edge386 ]
  %325 = load ptr, ptr %59, align 8, !tbaa !19
  %326 = getelementptr inbounds double, ptr %325, i64 %indvars.iv447
  %327 = load double, ptr %326, align 8, !tbaa !33
  %328 = load ptr, ptr %65, align 8, !tbaa !20
  %329 = getelementptr inbounds double, ptr %328, i64 %indvars.iv447
  %330 = load double, ptr %329, align 8, !tbaa !33
  %331 = load ptr, ptr %71, align 8, !tbaa !21
  %332 = getelementptr inbounds double, ptr %331, i64 %indvars.iv447
  %333 = load double, ptr %332, align 8, !tbaa !33
  %334 = call i32 @hyperspherical_backwards_recurrence(i32 noundef %0, i32 noundef %310, double noundef %1, double noundef %327, double noundef %330, double noundef %333, ptr noundef nonnull %131, ptr noundef nonnull %136, ptr noundef %291)
  br i1 %.not354382, label %._crit_edge386, label %.lr.ph385

.lr.ph385:                                        ; preds = %324
  %335 = load ptr, ptr %78, align 8, !tbaa !22
  %336 = load ptr, ptr %71, align 8, !tbaa !21
  %337 = getelementptr inbounds double, ptr %336, i64 %indvars.iv447
  %338 = load ptr, ptr %84, align 8, !tbaa !23
  br label %339

339:                                              ; preds = %.lr.ph385, %339
  %indvars.iv442 = phi i64 [ 0, %.lr.ph385 ], [ %indvars.iv.next443, %339 ]
  %340 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv442
  %341 = load i32, ptr %340, align 4, !tbaa !5
  %342 = sext i32 %341 to i64
  %343 = getelementptr inbounds double, ptr %291, i64 %342
  %344 = load double, ptr %343, align 8, !tbaa !33
  %345 = mul nuw nsw i64 %indvars.iv442, %56
  %346 = add nuw nsw i64 %345, %indvars.iv447
  %347 = getelementptr inbounds double, ptr %335, i64 %346
  store double %344, ptr %347, align 8, !tbaa !33
  %348 = sitofp i32 %341 to double
  %349 = load double, ptr %337, align 8, !tbaa !33
  %350 = fmul double %349, %348
  %351 = add nsw i32 %341, 1
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds double, ptr %131, i64 %352
  %354 = load double, ptr %353, align 8, !tbaa !33
  %355 = getelementptr inbounds double, ptr %291, i64 %352
  %356 = load double, ptr %355, align 8, !tbaa !33
  %357 = fneg double %354
  %358 = fmul double %356, %357
  %359 = call double @llvm.fmuladd.f64(double %350, double %344, double %358)
  %360 = getelementptr inbounds double, ptr %338, i64 %346
  store double %359, ptr %360, align 8, !tbaa !33
  %indvars.iv.next443 = add nuw nsw i64 %indvars.iv442, 1
  %exitcond446.not = icmp eq i64 %indvars.iv.next443, %wide.trip.count445
  br i1 %exitcond446.not, label %._crit_edge386, label %339, !llvm.loop !43

._crit_edge386:                                   ; preds = %339, %324
  %indvars.iv.next448 = add nuw nsw i64 %indvars.iv447, 1
  %exitcond451.not = icmp eq i64 %indvars.iv.next448, %wide.trip.count450
  br i1 %exitcond451.not, label %.preheader, label %324, !llvm.loop !44

361:                                              ; preds = %.lr.ph401, %._crit_edge398
  %indvar = phi i64 [ 0, %.lr.ph401 ], [ %indvar.next, %._crit_edge398 ]
  %indvars.iv462 = phi i64 [ %317, %.lr.ph401 ], [ %indvars.iv.next463, %._crit_edge398 ]
  %indvar.tr = trunc i64 %indvar to i32
  %362 = shl i32 %indvar.tr, 4
  %363 = sub i32 %323, %362
  %364 = call i32 @llvm.smin.i32(i32 %363, i32 16)
  %365 = call i32 @llvm.smax.i32(i32 %364, i32 1)
  %smax572 = zext nneg i32 %365 to i64
  %366 = sub nsw i64 %315, %indvars.iv462
  %367 = trunc nsw i64 %366 to i32
  %368 = call i32 @llvm.smin.i32(i32 %367, i32 16)
  %369 = load ptr, ptr %59, align 8, !tbaa !19
  %370 = getelementptr inbounds double, ptr %369, i64 %indvars.iv462
  %371 = load ptr, ptr %65, align 8, !tbaa !20
  %372 = getelementptr inbounds double, ptr %371, i64 %indvars.iv462
  %373 = load ptr, ptr %71, align 8, !tbaa !21
  %374 = getelementptr inbounds double, ptr %373, i64 %indvars.iv462
  %375 = call i32 @hyperspherical_forwards_recurrence_chunk(i32 noundef %0, i32 noundef %314, double noundef %1, ptr noundef %370, ptr noundef %372, ptr noundef %374, i32 noundef %368, ptr noundef nonnull %131, ptr noundef nonnull %136, ptr noundef %291)
  %376 = icmp sgt i64 %366, 0
  %or.cond = and i1 %.not353394, %376
  br i1 %or.cond, label %.lr.ph397.split.us, label %._crit_edge398

.lr.ph397.split.us:                               ; preds = %361
  %377 = shl nuw nsw i64 %indvar, 7
  %378 = add i64 %318, %377
  %indvar.tr591 = trunc i64 %indvar to i32
  %379 = shl i32 %indvar.tr591, 4
  %380 = sub i32 %323, %379
  %381 = call i32 @llvm.smin.i32(i32 %380, i32 16)
  %382 = call i32 @llvm.smax.i32(i32 %381, i32 1)
  %smax528 = zext nneg i32 %382 to i64
  %383 = shl nuw nsw i64 %smax528, 3
  %384 = add i64 %322, %377
  %385 = add i64 %384, %383
  %386 = load ptr, ptr %78, align 8, !tbaa !22
  %387 = load ptr, ptr %71, align 8, !tbaa !21
  %388 = load ptr, ptr %84, align 8, !tbaa !23
  %389 = sext i32 %368 to i64
  %invariant.gep472 = getelementptr double, ptr %387, i64 %indvars.iv462
  %scevgep = getelementptr i8, ptr %386, i64 %378
  %scevgep529 = getelementptr i8, ptr %386, i64 %385
  %scevgep530 = getelementptr i8, ptr %388, i64 %378
  %scevgep531 = getelementptr i8, ptr %388, i64 %385
  %scevgep532 = getelementptr i8, ptr %291, i64 %383
  %scevgep534 = getelementptr i8, ptr %291, i64 %383
  %390 = getelementptr i8, ptr %387, i64 %378
  %scevgep536 = getelementptr i8, ptr %390, i64 %383
  %min.iters.check575 = icmp slt i32 %363, 12
  %bound0 = icmp ult ptr %scevgep, %scevgep531
  %bound1 = icmp ult ptr %scevgep530, %scevgep529
  %found.conflict = and i1 %bound0, %bound1
  %bound0547 = icmp ult ptr %scevgep, %scevgep536
  %bound1548 = icmp ult ptr %invariant.gep472, %scevgep529
  %found.conflict549 = and i1 %bound0547, %bound1548
  %bound0563 = icmp ult ptr %scevgep530, %scevgep536
  %bound1564 = icmp ult ptr %invariant.gep472, %scevgep531
  %found.conflict565 = and i1 %bound0563, %bound1564
  %n.vec578 = and i64 %smax572, 30
  %cmp.n590 = icmp eq i64 %n.vec578, %smax572
  br label %.lr.ph392.us

.lr.ph392.us:                                     ; preds = %._crit_edge393.us, %.lr.ph397.split.us
  %indvars.iv457 = phi i64 [ %indvars.iv.next458, %._crit_edge393.us ], [ 0, %.lr.ph397.split.us ]
  %391 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv457
  %392 = load i32, ptr %391, align 4, !tbaa !5
  %393 = mul nsw i32 %392, %368
  %394 = mul nuw nsw i64 %indvars.iv457, %315
  %395 = add nsw i64 %394, %indvars.iv462
  %396 = sitofp i32 %392 to double
  %397 = add nsw i32 %392, 1
  %398 = sext i32 %397 to i64
  %399 = getelementptr inbounds double, ptr %131, i64 %398
  %400 = mul nsw i32 %397, %368
  %401 = sext i32 %393 to i64
  %402 = sext i32 %400 to i64
  %invariant.gep = getelementptr double, ptr %291, i64 %401
  %invariant.gep474 = getelementptr double, ptr %291, i64 %402
  br i1 %min.iters.check575, label %scalar.ph574.preheader, label %vector.memcheck527

vector.memcheck527:                               ; preds = %.lr.ph392.us
  %403 = shl nsw i64 %402, 3
  %scevgep533 = getelementptr i8, ptr %scevgep532, i64 %403
  %404 = shl nsw i64 %401, 3
  %scevgep535 = getelementptr i8, ptr %scevgep534, i64 %404
  %405 = sext i32 %392 to i64
  %406 = shl nsw i64 %405, 3
  %scevgep538 = getelementptr i8, ptr %scevgep537, i64 %406
  %bound0539 = icmp ult ptr %scevgep, %scevgep533
  %bound1540 = icmp ult ptr %invariant.gep474, %scevgep529
  %found.conflict541 = and i1 %bound0539, %bound1540
  %conflict.rdx542 = or i1 %found.conflict, %found.conflict541
  %bound0543 = icmp ult ptr %scevgep, %scevgep535
  %bound1544 = icmp ult ptr %invariant.gep, %scevgep529
  %found.conflict545 = and i1 %bound0543, %bound1544
  %conflict.rdx546 = or i1 %conflict.rdx542, %found.conflict545
  %conflict.rdx550 = or i1 %conflict.rdx546, %found.conflict549
  %bound0551 = icmp ult ptr %scevgep, %scevgep538
  %bound1552 = icmp ult ptr %399, %scevgep529
  %found.conflict553 = and i1 %bound0551, %bound1552
  %conflict.rdx554 = or i1 %conflict.rdx550, %found.conflict553
  %bound0555 = icmp ult ptr %scevgep530, %scevgep533
  %bound1556 = icmp ult ptr %invariant.gep474, %scevgep531
  %found.conflict557 = and i1 %bound0555, %bound1556
  %conflict.rdx558 = or i1 %conflict.rdx554, %found.conflict557
  %bound0559 = icmp ult ptr %scevgep530, %scevgep535
  %bound1560 = icmp ult ptr %invariant.gep, %scevgep531
  %found.conflict561 = and i1 %bound0559, %bound1560
  %conflict.rdx562 = or i1 %conflict.rdx558, %found.conflict561
  %conflict.rdx566 = or i1 %conflict.rdx562, %found.conflict565
  %bound0567 = icmp ult ptr %scevgep530, %scevgep538
  %bound1568 = icmp ult ptr %399, %scevgep531
  %found.conflict569 = and i1 %bound0567, %bound1568
  %conflict.rdx570 = or i1 %conflict.rdx566, %found.conflict569
  br i1 %conflict.rdx570, label %scalar.ph574.preheader, label %vector.ph576

vector.ph576:                                     ; preds = %vector.memcheck527
  %broadcast.splatinsert584 = insertelement <2 x double> poison, double %396, i64 0
  %broadcast.splat585 = shufflevector <2 x double> %broadcast.splatinsert584, <2 x double> poison, <2 x i32> zeroinitializer
  %407 = load double, ptr %399, align 8, !tbaa !33, !alias.scope !45
  %broadcast.splatinsert587 = insertelement <2 x double> poison, double %407, i64 0
  %broadcast.splat588 = shufflevector <2 x double> %broadcast.splatinsert587, <2 x double> poison, <2 x i32> zeroinitializer
  %408 = fneg <2 x double> %broadcast.splat588
  br label %vector.body580

vector.body580:                                   ; preds = %vector.body580, %vector.ph576
  %index581 = phi i64 [ 0, %vector.ph576 ], [ %index.next589, %vector.body580 ]
  %409 = getelementptr double, ptr %invariant.gep, i64 %index581
  %wide.load582 = load <2 x double>, ptr %409, align 8, !tbaa !33, !alias.scope !48
  %410 = add nsw i64 %395, %index581
  %411 = getelementptr inbounds double, ptr %386, i64 %410
  store <2 x double> %wide.load582, ptr %411, align 8, !tbaa !33, !alias.scope !50, !noalias !52
  %412 = getelementptr double, ptr %invariant.gep472, i64 %index581
  %wide.load583 = load <2 x double>, ptr %412, align 8, !tbaa !33, !alias.scope !56
  %413 = fmul <2 x double> %wide.load583, %broadcast.splat585
  %414 = getelementptr double, ptr %invariant.gep474, i64 %index581
  %wide.load586 = load <2 x double>, ptr %414, align 8, !tbaa !33, !alias.scope !57
  %415 = fmul <2 x double> %wide.load586, %408
  %416 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %413, <2 x double> %wide.load582, <2 x double> %415)
  %417 = getelementptr inbounds double, ptr %388, i64 %410
  store <2 x double> %416, ptr %417, align 8, !tbaa !33, !alias.scope !58, !noalias !59
  %index.next589 = add nuw i64 %index581, 2
  %418 = icmp eq i64 %index.next589, %n.vec578
  br i1 %418, label %middle.block573, label %vector.body580, !llvm.loop !60

middle.block573:                                  ; preds = %vector.body580
  br i1 %cmp.n590, label %._crit_edge393.us, label %scalar.ph574.preheader

scalar.ph574.preheader:                           ; preds = %middle.block573, %vector.memcheck527, %.lr.ph392.us
  %indvars.iv454.ph = phi i64 [ 0, %vector.memcheck527 ], [ 0, %.lr.ph392.us ], [ %n.vec578, %middle.block573 ]
  br label %scalar.ph574

scalar.ph574:                                     ; preds = %scalar.ph574.preheader, %scalar.ph574
  %indvars.iv454 = phi i64 [ %indvars.iv.next455, %scalar.ph574 ], [ %indvars.iv454.ph, %scalar.ph574.preheader ]
  %gep = getelementptr double, ptr %invariant.gep, i64 %indvars.iv454
  %419 = load double, ptr %gep, align 8, !tbaa !33
  %420 = add nsw i64 %395, %indvars.iv454
  %421 = getelementptr inbounds double, ptr %386, i64 %420
  store double %419, ptr %421, align 8, !tbaa !33
  %gep473 = getelementptr double, ptr %invariant.gep472, i64 %indvars.iv454
  %422 = load double, ptr %gep473, align 8, !tbaa !33
  %423 = fmul double %422, %396
  %424 = load double, ptr %399, align 8, !tbaa !33
  %gep475 = getelementptr double, ptr %invariant.gep474, i64 %indvars.iv454
  %425 = load double, ptr %gep475, align 8, !tbaa !33
  %426 = fneg double %424
  %427 = fmul double %425, %426
  %428 = call double @llvm.fmuladd.f64(double %423, double %419, double %427)
  %429 = getelementptr inbounds double, ptr %388, i64 %420
  store double %428, ptr %429, align 8, !tbaa !33
  %indvars.iv.next455 = add nuw nsw i64 %indvars.iv454, 1
  %430 = icmp slt i64 %indvars.iv.next455, %389
  br i1 %430, label %scalar.ph574, label %._crit_edge393.us, !llvm.loop !61

._crit_edge393.us:                                ; preds = %scalar.ph574, %middle.block573
  %indvars.iv.next458 = add nuw nsw i64 %indvars.iv457, 1
  %exitcond461.not = icmp eq i64 %indvars.iv.next458, %wide.trip.count460
  br i1 %exitcond461.not, label %._crit_edge398, label %.lr.ph392.us, !llvm.loop !62

._crit_edge398:                                   ; preds = %._crit_edge393.us, %361
  %indvars.iv.next463 = add nsw i64 %indvars.iv462, 16
  %431 = icmp slt i64 %indvars.iv.next463, %315
  %indvar.next = add i64 %indvar, 1
  br i1 %431, label %361, label %._crit_edge402, !llvm.loop !63

._crit_edge402:                                   ; preds = %._crit_edge398, %.preheader
  call void @free(ptr noundef %291) #9
  br i1 %292, label %.loopexit, label %432

432:                                              ; preds = %._crit_edge402
  call void @free(ptr noundef %131) #9
  call void @free(ptr noundef %136) #9
  br i1 %102, label %.lr.ph405.preheader, label %.loopexit

.lr.ph405.preheader:                              ; preds = %432
  %wide.trip.count468 = zext nneg i32 %2 to i64
  br label %.lr.ph405

.lr.ph405:                                        ; preds = %.lr.ph405.preheader, %.lr.ph405
  %indvars.iv465 = phi i64 [ 0, %.lr.ph405.preheader ], [ %indvars.iv.next466, %.lr.ph405 ]
  %433 = getelementptr inbounds i32, ptr %3, i64 %indvars.iv465
  %434 = load i32, ptr %433, align 4, !tbaa !5
  %435 = load ptr, ptr %51, align 8, !tbaa !18
  %436 = getelementptr inbounds double, ptr %435, i64 %indvars.iv465
  %437 = call i32 @hyperspherical_get_xmin_from_approx(i32 noundef %0, i32 noundef %434, double noundef %1, double noundef 0.000000e+00, double noundef %8, ptr noundef %436, ptr noundef null)
  %indvars.iv.next466 = add nuw nsw i64 %indvars.iv465, 1
  %exitcond469.not = icmp eq i64 %indvars.iv.next466, %wide.trip.count468
  br i1 %exitcond469.not, label %.loopexit, label %.lr.ph405, !llvm.loop !64

.loopexit:                                        ; preds = %.lr.ph405, %432, %._crit_edge365, %._crit_edge402, %138, %133, %86, %80, %73, %67, %61, %53, %46
  %.2 = phi i32 [ 1, %46 ], [ 1, %53 ], [ 1, %61 ], [ 1, %67 ], [ 1, %73 ], [ 1, %80 ], [ 1, %86 ], [ 1, %133 ], [ 1, %138 ], [ 1, %._crit_edge365 ], [ 1, %._crit_edge402 ], [ 0, %432 ], [ 0, %.lr.ph405 ]
  ret i32 %.2
}

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

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

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

; 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 @pow(double noundef, double noundef) local_unnamed_addr #4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare <2 x double> @llvm.sqrt.v2f64(<2 x double>) #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 = { 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 #3 = { "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 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 #5 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #6 = { 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 #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #8 = { nounwind allocsize(0) }
attributes #9 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !11, i64 8}
!10 = !{!"HypersphericalInterpolationStructure", !6, i64 0, !11, i64 8, !11, i64 16, !6, i64 24, !6, i64 28, !12, i64 32, !12, i64 40, !6, i64 48, !12, i64 56, !12, i64 64, !12, i64 72, !12, i64 80, !12, i64 88}
!11 = !{!"double", !7, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = !{!10, !11, i64 16}
!14 = !{!10, !6, i64 28}
!15 = !{!10, !6, i64 48}
!16 = !{!10, !6, i64 0}
!17 = !{!10, !12, i64 32}
!18 = !{!10, !12, i64 40}
!19 = !{!10, !12, i64 56}
!20 = !{!10, !12, i64 64}
!21 = !{!10, !12, i64 72}
!22 = !{!10, !12, i64 80}
!23 = !{!10, !12, i64 88}
!24 = !{!10, !6, i64 24}
!25 = distinct !{!25, !26, !27, !28}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!"llvm.loop.isvectorized", i32 1}
!28 = !{!"llvm.loop.unroll.runtime.disable"}
!29 = distinct !{!29, !30}
!30 = !{!"llvm.loop.unroll.disable"}
!31 = distinct !{!31, !26, !27}
!32 = distinct !{!32, !26}
!33 = !{!11, !11, i64 0}
!34 = distinct !{!34, !26, !27, !28}
!35 = distinct !{!35, !26, !27, !28}
!36 = distinct !{!36, !26, !27}
!37 = distinct !{!37, !26, !28, !27}
!38 = distinct !{!38, !26}
!39 = distinct !{!39, !26}
!40 = distinct !{!40, !26, !27, !28}
!41 = distinct !{!41, !26}
!42 = distinct !{!42, !26, !28, !27}
!43 = distinct !{!43, !26}
!44 = distinct !{!44, !26}
!45 = !{!46}
!46 = distinct !{!46, !47}
!47 = distinct !{!47, !"LVerDomain"}
!48 = !{!49}
!49 = distinct !{!49, !47}
!50 = !{!51}
!51 = distinct !{!51, !47}
!52 = !{!53, !54, !49, !55, !46}
!53 = distinct !{!53, !47}
!54 = distinct !{!54, !47}
!55 = distinct !{!55, !47}
!56 = !{!55}
!57 = !{!54}
!58 = !{!53}
!59 = !{!54, !49, !55, !46}
!60 = distinct !{!60, !26, !27, !28}
!61 = distinct !{!61, !26, !27}
!62 = distinct !{!62, !26}
!63 = distinct !{!63, !26}
!64 = distinct !{!64, !26}


; Effective O3 passes: AggressiveInstCombinePass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalDCEPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,PostOrderFunctionAttrsPass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass