; LLVM IR from ryanlayer/giggle :: test/unit (test_leaf_data)

; 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.giggle_def = type { %struct.cache_handler, %struct.cache_handler, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.cache_handler = type { ptr, ptr, ptr }
%struct.cache_def = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.giggle_index = type { ptr, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.bpt_node = type { ptr }
%struct.leaf_data_result = type { i64, ptr, ptr }

@ORDER = external dso_local global i32, align 4
@.str = external hidden unnamed_addr constant [4 x i8], align 1
@giggle_data_handler = external dso_local global %struct.giggle_def, align 8
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@cache = external dso_local global %struct.cache_def, align 8
@bpt_node_cache_handler = external dso_local global %struct.cache_handler, align 8
@__const.test_leaf_data_ops.A_2_11 = external hidden unnamed_addr constant [7 x i32], align 16
@__const.test_leaf_data_ops.A_6_8 = external hidden unnamed_addr constant [6 x i32], align 16
@__const.test_leaf_data_ops.A_10_12 = external hidden unnamed_addr constant [4 x i32], align 16

; Function Attrs: nounwind uwtable
define dso_local void @test_leaf_data_ops() #0 {
  %1 = alloca ptr, align 8
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca ptr, align 8
  %5 = alloca i32, align 4
  %6 = alloca ptr, align 8
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca ptr, align 8
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca ptr, align 8
  %17 = alloca [7 x i32], align 16
  %18 = alloca i32, align 4
  %19 = alloca [6 x i32], align 16
  %20 = alloca [4 x i32], align 16
  store i32 5, ptr @ORDER, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %1) #5
  %21 = call ptr @giggle_init(i32 noundef 23, ptr noundef @.str, i32 noundef 1, ptr noundef @uint64_t_ll_giggle_set_data_handler)
  store ptr %21, ptr %1, align 8, !tbaa !9
  store ptr @giggle_write_tree_leaf_data, ptr getelementptr inbounds (%struct.giggle_def, ptr @giggle_data_handler, i32 0, i32 10), align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %2) #5
  store i32 0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #5
  store i32 0, ptr %3, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #5
  store ptr @.str.1, ptr %4, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #5
  %22 = load ptr, ptr %1, align 8, !tbaa !9
  %23 = load ptr, ptr %4, align 8, !tbaa !9
  %24 = call i32 @giggle_get_chrm_id(ptr noundef %22, ptr noundef %23)
  store i32 %24, ptr %5, align 4, !tbaa !5
  %25 = load i32, ptr %5, align 4, !tbaa !5
  %26 = call i32 @giggle_insert(i32 noundef %25, ptr noundef %3, i32 noundef 1, i32 noundef 9, i64 noundef 1)
  %27 = load i32, ptr %5, align 4, !tbaa !5
  %28 = call i32 @giggle_insert(i32 noundef %27, ptr noundef %3, i32 noundef 2, i32 noundef 4, i64 noundef 2)
  %29 = load i32, ptr %5, align 4, !tbaa !5
  %30 = call i32 @giggle_insert(i32 noundef %29, ptr noundef %3, i32 noundef 3, i32 noundef 6, i64 noundef 3)
  %31 = load i32, ptr %5, align 4, !tbaa !5
  %32 = call i32 @giggle_insert(i32 noundef %31, ptr noundef %3, i32 noundef 4, i32 noundef 14, i64 noundef 4)
  %33 = load i32, ptr %5, align 4, !tbaa !5
  %34 = call i32 @giggle_insert(i32 noundef %33, ptr noundef %3, i32 noundef 5, i32 noundef 10, i64 noundef 5)
  %35 = load i32, ptr %5, align 4, !tbaa !5
  %36 = call i32 @giggle_insert(i32 noundef %35, ptr noundef %3, i32 noundef 7, i32 noundef 13, i64 noundef 6)
  %37 = load i32, ptr %5, align 4, !tbaa !5
  %38 = call i32 @giggle_insert(i32 noundef %37, ptr noundef %3, i32 noundef 7, i32 noundef 11, i64 noundef 7)
  %39 = load i32, ptr %5, align 4, !tbaa !5
  %40 = call i32 @giggle_insert(i32 noundef %39, ptr noundef %3, i32 noundef 12, i32 noundef 15, i64 noundef 8)
  %41 = load i32, ptr %3, align 4, !tbaa !5
  %42 = load ptr, ptr %1, align 8, !tbaa !9
  %43 = getelementptr inbounds %struct.giggle_index, ptr %42, i32 0, i32 0
  %44 = load ptr, ptr %43, align 8, !tbaa !14
  %45 = load i32, ptr %5, align 4, !tbaa !5
  %46 = zext i32 %45 to i64
  %47 = getelementptr inbounds i32, ptr %44, i64 %46
  store i32 %41, ptr %47, align 4, !tbaa !5
  %48 = load ptr, ptr %1, align 8, !tbaa !9
  %49 = call i32 @giggle_store(ptr noundef %48)
  call void @giggle_index_destroy(ptr noundef %1)
  %50 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 6), align 8, !tbaa !16
  call void (...) %50()
  %51 = call ptr @giggle_load(ptr noundef @.str, ptr noundef @uint64_t_ll_giggle_set_data_handler)
  store ptr %51, ptr %1, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #5
  store ptr null, ptr %6, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #5
  store i32 2, ptr %7, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #5
  store i32 11, ptr %8, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  store i32 0, ptr %9, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  store i32 0, ptr %10, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #5
  %52 = load i32, ptr %2, align 4, !tbaa !5
  %53 = load ptr, ptr %1, align 8, !tbaa !9
  %54 = getelementptr inbounds %struct.giggle_index, ptr %53, i32 0, i32 0
  %55 = load ptr, ptr %54, align 8, !tbaa !14
  %56 = load i32, ptr %2, align 4, !tbaa !5
  %57 = zext i32 %56 to i64
  %58 = getelementptr inbounds i32, ptr %55, i64 %57
  %59 = load i32, ptr %58, align 4, !tbaa !5
  %60 = load i32, ptr %7, align 4, !tbaa !5
  %61 = call i32 @bpt_find(i32 noundef %52, i32 noundef %59, ptr noundef %9, ptr noundef %10, i32 noundef %60)
  store i32 %61, ptr %11, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  %62 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %63 = load i32, ptr %2, align 4, !tbaa !5
  %64 = load i32, ptr %9, align 4, !tbaa !5
  %65 = sub i32 %64, 1
  %66 = call ptr %62(i32 noundef %63, i32 noundef %65, ptr noundef @bpt_node_cache_handler)
  store ptr %66, ptr %12, align 8, !tbaa !9
  %67 = load i32, ptr %10, align 4, !tbaa !5
  %68 = icmp eq i32 %67, 0
  br i1 %68, label %69, label %79

69:                                               ; preds = %0
  %70 = load ptr, ptr %12, align 8, !tbaa !9
  %71 = getelementptr inbounds %struct.bpt_node, ptr %70, i32 0, i32 0
  %72 = load ptr, ptr %71, align 8, !tbaa !19
  %73 = getelementptr inbounds i32, ptr %72, i64 6
  %74 = getelementptr inbounds i32, ptr %73, i64 0
  %75 = load i32, ptr %74, align 4, !tbaa !5
  %76 = load i32, ptr %7, align 4, !tbaa !5
  %77 = icmp ne i32 %75, %76
  br i1 %77, label %78, label %79

78:                                               ; preds = %69
  store i32 -1, ptr %10, align 4, !tbaa !5
  br label %105

79:                                               ; preds = %69, %0
  %80 = load i32, ptr %10, align 4, !tbaa !5
  %81 = icmp sge i32 %80, 0
  br i1 %81, label %82, label %104

82:                                               ; preds = %79
  %83 = load i32, ptr %10, align 4, !tbaa !5
  %84 = load ptr, ptr %12, align 8, !tbaa !9
  %85 = getelementptr inbounds %struct.bpt_node, ptr %84, i32 0, i32 0
  %86 = load ptr, ptr %85, align 8, !tbaa !19
  %87 = getelementptr inbounds i32, ptr %86, i64 5
  %88 = load i32, ptr %87, align 4, !tbaa !5
  %89 = icmp ult i32 %83, %88
  br i1 %89, label %90, label %104

90:                                               ; preds = %82
  %91 = load ptr, ptr %12, align 8, !tbaa !9
  %92 = getelementptr inbounds %struct.bpt_node, ptr %91, i32 0, i32 0
  %93 = load ptr, ptr %92, align 8, !tbaa !19
  %94 = getelementptr inbounds i32, ptr %93, i64 6
  %95 = load i32, ptr %10, align 4, !tbaa !5
  %96 = sext i32 %95 to i64
  %97 = getelementptr inbounds i32, ptr %94, i64 %96
  %98 = load i32, ptr %97, align 4, !tbaa !5
  %99 = load i32, ptr %7, align 4, !tbaa !5
  %100 = icmp ugt i32 %98, %99
  br i1 %100, label %101, label %104

101:                                              ; preds = %90
  %102 = load i32, ptr %10, align 4, !tbaa !5
  %103 = sub nsw i32 %102, 1
  store i32 %103, ptr %10, align 4, !tbaa !5
  br label %104

104:                                              ; preds = %101, %90, %82, %79
  br label %105

105:                                              ; preds = %104, %78
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #5
  store i32 0, ptr %13, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #5
  store i32 0, ptr %14, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #5
  %106 = load i32, ptr %2, align 4, !tbaa !5
  %107 = load ptr, ptr %1, align 8, !tbaa !9
  %108 = getelementptr inbounds %struct.giggle_index, ptr %107, i32 0, i32 0
  %109 = load ptr, ptr %108, align 8, !tbaa !14
  %110 = load i32, ptr %2, align 4, !tbaa !5
  %111 = zext i32 %110 to i64
  %112 = getelementptr inbounds i32, ptr %109, i64 %111
  %113 = load i32, ptr %112, align 4, !tbaa !5
  %114 = load i32, ptr %8, align 4, !tbaa !5
  %115 = call i32 @bpt_find(i32 noundef %106, i32 noundef %113, ptr noundef %13, ptr noundef %14, i32 noundef %114)
  store i32 %115, ptr %15, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #5
  %116 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %117 = load i32, ptr %2, align 4, !tbaa !5
  %118 = load i32, ptr %13, align 4, !tbaa !5
  %119 = sub i32 %118, 1
  %120 = call ptr %116(i32 noundef %117, i32 noundef %119, ptr noundef @bpt_node_cache_handler)
  store ptr %120, ptr %16, align 8, !tbaa !9
  %121 = load i32, ptr %14, align 4, !tbaa !5
  %122 = icmp eq i32 %121, 0
  br i1 %122, label %123, label %133

123:                                              ; preds = %105
  %124 = load ptr, ptr %16, align 8, !tbaa !9
  %125 = getelementptr inbounds %struct.bpt_node, ptr %124, i32 0, i32 0
  %126 = load ptr, ptr %125, align 8, !tbaa !19
  %127 = getelementptr inbounds i32, ptr %126, i64 6
  %128 = getelementptr inbounds i32, ptr %127, i64 0
  %129 = load i32, ptr %128, align 4, !tbaa !5
  %130 = load i32, ptr %8, align 4, !tbaa !5
  %131 = icmp ne i32 %129, %130
  br i1 %131, label %132, label %133

132:                                              ; preds = %123
  store i32 -1, ptr %14, align 4, !tbaa !5
  br label %159

133:                                              ; preds = %123, %105
  %134 = load i32, ptr %14, align 4, !tbaa !5
  %135 = icmp sge i32 %134, 0
  br i1 %135, label %136, label %158

136:                                              ; preds = %133
  %137 = load i32, ptr %14, align 4, !tbaa !5
  %138 = load ptr, ptr %16, align 8, !tbaa !9
  %139 = getelementptr inbounds %struct.bpt_node, ptr %138, i32 0, i32 0
  %140 = load ptr, ptr %139, align 8, !tbaa !19
  %141 = getelementptr inbounds i32, ptr %140, i64 5
  %142 = load i32, ptr %141, align 4, !tbaa !5
  %143 = icmp ult i32 %137, %142
  br i1 %143, label %144, label %158

144:                                              ; preds = %136
  %145 = load ptr, ptr %16, align 8, !tbaa !9
  %146 = getelementptr inbounds %struct.bpt_node, ptr %145, i32 0, i32 0
  %147 = load ptr, ptr %146, align 8, !tbaa !19
  %148 = getelementptr inbounds i32, ptr %147, i64 6
  %149 = load i32, ptr %14, align 4, !tbaa !5
  %150 = sext i32 %149 to i64
  %151 = getelementptr inbounds i32, ptr %148, i64 %150
  %152 = load i32, ptr %151, align 4, !tbaa !5
  %153 = load i32, ptr %8, align 4, !tbaa !5
  %154 = icmp ugt i32 %152, %153
  br i1 %154, label %155, label %158

155:                                              ; preds = %144
  %156 = load i32, ptr %14, align 4, !tbaa !5
  %157 = sub nsw i32 %156, 1
  store i32 %157, ptr %14, align 4, !tbaa !5
  br label %158

158:                                              ; preds = %155, %144, %136, %133
  br label %159

159:                                              ; preds = %158, %132
  %160 = load i32, ptr %9, align 4, !tbaa !5
  %161 = load i32, ptr %10, align 4, !tbaa !5
  %162 = load i32, ptr %13, align 4, !tbaa !5
  %163 = load i32, ptr %14, align 4, !tbaa !5
  %164 = load i32, ptr %2, align 4, !tbaa !5
  %165 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %160, i32 noundef %161, i32 noundef %162, i32 noundef %163, i32 noundef %164, ptr noundef null)
  store ptr %165, ptr %6, align 8, !tbaa !9
  %166 = load ptr, ptr %6, align 8, !tbaa !9
  %167 = getelementptr inbounds %struct.leaf_data_result, ptr %166, i32 0, i32 0
  %168 = load i64, ptr %167, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 7, i64 noundef %168, ptr noundef null, i64 noundef 308, i32 noundef 148)
  call void @llvm.lifetime.start.p0(i64 28, ptr %17) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %17, ptr align 16 @__const.test_leaf_data_ops.A_2_11, i64 28, i1 false)
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #5
  store i32 0, ptr %18, align 4, !tbaa !5
  br label %169

169:                                              ; preds = %189, %159
  %170 = load i32, ptr %18, align 4, !tbaa !5
  %171 = zext i32 %170 to i64
  %172 = load ptr, ptr %6, align 8, !tbaa !9
  %173 = getelementptr inbounds %struct.leaf_data_result, ptr %172, i32 0, i32 0
  %174 = load i64, ptr %173, align 8, !tbaa !21
  %175 = icmp ult i64 %171, %174
  br i1 %175, label %176, label %192

176:                                              ; preds = %169
  %177 = load i32, ptr %18, align 4, !tbaa !5
  %178 = zext i32 %177 to i64
  %179 = getelementptr inbounds [7 x i32], ptr %17, i64 0, i64 %178
  %180 = load i32, ptr %179, align 4, !tbaa !5
  %181 = zext i32 %180 to i64
  %182 = load ptr, ptr %6, align 8, !tbaa !9
  %183 = getelementptr inbounds %struct.leaf_data_result, ptr %182, i32 0, i32 1
  %184 = load ptr, ptr %183, align 8, !tbaa !24
  %185 = load i32, ptr %18, align 4, !tbaa !5
  %186 = zext i32 %185 to i64
  %187 = getelementptr inbounds i64, ptr %184, i64 %186
  %188 = load i64, ptr %187, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %181, i64 noundef %188, ptr noundef null, i64 noundef 313, i32 noundef 148)
  br label %189

189:                                              ; preds = %176
  %190 = load i32, ptr %18, align 4, !tbaa !5
  %191 = add i32 %190, 1
  store i32 %191, ptr %18, align 4, !tbaa !5
  br label %169, !llvm.loop !26

192:                                              ; preds = %169
  %193 = load ptr, ptr %6, align 8, !tbaa !9
  %194 = getelementptr inbounds %struct.leaf_data_result, ptr %193, i32 0, i32 1
  %195 = load ptr, ptr %194, align 8, !tbaa !24
  call void @free(ptr noundef %195) #5
  %196 = load ptr, ptr %6, align 8, !tbaa !9
  call void @free(ptr noundef %196) #5
  store i32 6, ptr %7, align 4, !tbaa !5
  store i32 8, ptr %8, align 4, !tbaa !5
  %197 = load i32, ptr %2, align 4, !tbaa !5
  %198 = load ptr, ptr %1, align 8, !tbaa !9
  %199 = getelementptr inbounds %struct.giggle_index, ptr %198, i32 0, i32 0
  %200 = load ptr, ptr %199, align 8, !tbaa !14
  %201 = load i32, ptr %2, align 4, !tbaa !5
  %202 = zext i32 %201 to i64
  %203 = getelementptr inbounds i32, ptr %200, i64 %202
  %204 = load i32, ptr %203, align 4, !tbaa !5
  %205 = load i32, ptr %7, align 4, !tbaa !5
  %206 = call i32 @bpt_find(i32 noundef %197, i32 noundef %204, ptr noundef %9, ptr noundef %10, i32 noundef %205)
  store i32 %206, ptr %11, align 4, !tbaa !5
  %207 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %208 = load i32, ptr %2, align 4, !tbaa !5
  %209 = load i32, ptr %9, align 4, !tbaa !5
  %210 = sub i32 %209, 1
  %211 = call ptr %207(i32 noundef %208, i32 noundef %210, ptr noundef @bpt_node_cache_handler)
  store ptr %211, ptr %12, align 8, !tbaa !9
  %212 = load i32, ptr %10, align 4, !tbaa !5
  %213 = icmp eq i32 %212, 0
  br i1 %213, label %214, label %224

214:                                              ; preds = %192
  %215 = load ptr, ptr %12, align 8, !tbaa !9
  %216 = getelementptr inbounds %struct.bpt_node, ptr %215, i32 0, i32 0
  %217 = load ptr, ptr %216, align 8, !tbaa !19
  %218 = getelementptr inbounds i32, ptr %217, i64 6
  %219 = getelementptr inbounds i32, ptr %218, i64 0
  %220 = load i32, ptr %219, align 4, !tbaa !5
  %221 = load i32, ptr %7, align 4, !tbaa !5
  %222 = icmp ne i32 %220, %221
  br i1 %222, label %223, label %224

223:                                              ; preds = %214
  store i32 -1, ptr %10, align 4, !tbaa !5
  br label %250

224:                                              ; preds = %214, %192
  %225 = load i32, ptr %10, align 4, !tbaa !5
  %226 = icmp sge i32 %225, 0
  br i1 %226, label %227, label %249

227:                                              ; preds = %224
  %228 = load i32, ptr %10, align 4, !tbaa !5
  %229 = load ptr, ptr %12, align 8, !tbaa !9
  %230 = getelementptr inbounds %struct.bpt_node, ptr %229, i32 0, i32 0
  %231 = load ptr, ptr %230, align 8, !tbaa !19
  %232 = getelementptr inbounds i32, ptr %231, i64 5
  %233 = load i32, ptr %232, align 4, !tbaa !5
  %234 = icmp ult i32 %228, %233
  br i1 %234, label %235, label %249

235:                                              ; preds = %227
  %236 = load ptr, ptr %12, align 8, !tbaa !9
  %237 = getelementptr inbounds %struct.bpt_node, ptr %236, i32 0, i32 0
  %238 = load ptr, ptr %237, align 8, !tbaa !19
  %239 = getelementptr inbounds i32, ptr %238, i64 6
  %240 = load i32, ptr %10, align 4, !tbaa !5
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds i32, ptr %239, i64 %241
  %243 = load i32, ptr %242, align 4, !tbaa !5
  %244 = load i32, ptr %7, align 4, !tbaa !5
  %245 = icmp ugt i32 %243, %244
  br i1 %245, label %246, label %249

246:                                              ; preds = %235
  %247 = load i32, ptr %10, align 4, !tbaa !5
  %248 = sub nsw i32 %247, 1
  store i32 %248, ptr %10, align 4, !tbaa !5
  br label %249

249:                                              ; preds = %246, %235, %227, %224
  br label %250

250:                                              ; preds = %249, %223
  %251 = load i32, ptr %2, align 4, !tbaa !5
  %252 = load ptr, ptr %1, align 8, !tbaa !9
  %253 = getelementptr inbounds %struct.giggle_index, ptr %252, i32 0, i32 0
  %254 = load ptr, ptr %253, align 8, !tbaa !14
  %255 = load i32, ptr %2, align 4, !tbaa !5
  %256 = zext i32 %255 to i64
  %257 = getelementptr inbounds i32, ptr %254, i64 %256
  %258 = load i32, ptr %257, align 4, !tbaa !5
  %259 = load i32, ptr %8, align 4, !tbaa !5
  %260 = call i32 @bpt_find(i32 noundef %251, i32 noundef %258, ptr noundef %13, ptr noundef %14, i32 noundef %259)
  store i32 %260, ptr %15, align 4, !tbaa !5
  %261 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %262 = load i32, ptr %2, align 4, !tbaa !5
  %263 = load i32, ptr %13, align 4, !tbaa !5
  %264 = sub i32 %263, 1
  %265 = call ptr %261(i32 noundef %262, i32 noundef %264, ptr noundef @bpt_node_cache_handler)
  store ptr %265, ptr %16, align 8, !tbaa !9
  %266 = load i32, ptr %14, align 4, !tbaa !5
  %267 = icmp eq i32 %266, 0
  br i1 %267, label %268, label %278

268:                                              ; preds = %250
  %269 = load ptr, ptr %16, align 8, !tbaa !9
  %270 = getelementptr inbounds %struct.bpt_node, ptr %269, i32 0, i32 0
  %271 = load ptr, ptr %270, align 8, !tbaa !19
  %272 = getelementptr inbounds i32, ptr %271, i64 6
  %273 = getelementptr inbounds i32, ptr %272, i64 0
  %274 = load i32, ptr %273, align 4, !tbaa !5
  %275 = load i32, ptr %8, align 4, !tbaa !5
  %276 = icmp ne i32 %274, %275
  br i1 %276, label %277, label %278

277:                                              ; preds = %268
  store i32 -1, ptr %14, align 4, !tbaa !5
  br label %304

278:                                              ; preds = %268, %250
  %279 = load i32, ptr %14, align 4, !tbaa !5
  %280 = icmp sge i32 %279, 0
  br i1 %280, label %281, label %303

281:                                              ; preds = %278
  %282 = load i32, ptr %14, align 4, !tbaa !5
  %283 = load ptr, ptr %16, align 8, !tbaa !9
  %284 = getelementptr inbounds %struct.bpt_node, ptr %283, i32 0, i32 0
  %285 = load ptr, ptr %284, align 8, !tbaa !19
  %286 = getelementptr inbounds i32, ptr %285, i64 5
  %287 = load i32, ptr %286, align 4, !tbaa !5
  %288 = icmp ult i32 %282, %287
  br i1 %288, label %289, label %303

289:                                              ; preds = %281
  %290 = load ptr, ptr %16, align 8, !tbaa !9
  %291 = getelementptr inbounds %struct.bpt_node, ptr %290, i32 0, i32 0
  %292 = load ptr, ptr %291, align 8, !tbaa !19
  %293 = getelementptr inbounds i32, ptr %292, i64 6
  %294 = load i32, ptr %14, align 4, !tbaa !5
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds i32, ptr %293, i64 %295
  %297 = load i32, ptr %296, align 4, !tbaa !5
  %298 = load i32, ptr %8, align 4, !tbaa !5
  %299 = icmp ugt i32 %297, %298
  br i1 %299, label %300, label %303

300:                                              ; preds = %289
  %301 = load i32, ptr %14, align 4, !tbaa !5
  %302 = sub nsw i32 %301, 1
  store i32 %302, ptr %14, align 4, !tbaa !5
  br label %303

303:                                              ; preds = %300, %289, %281, %278
  br label %304

304:                                              ; preds = %303, %277
  %305 = load i32, ptr %9, align 4, !tbaa !5
  %306 = load i32, ptr %10, align 4, !tbaa !5
  %307 = load i32, ptr %13, align 4, !tbaa !5
  %308 = load i32, ptr %14, align 4, !tbaa !5
  %309 = load i32, ptr %2, align 4, !tbaa !5
  %310 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %305, i32 noundef %306, i32 noundef %307, i32 noundef %308, i32 noundef %309, ptr noundef null)
  store ptr %310, ptr %6, align 8, !tbaa !9
  %311 = load ptr, ptr %6, align 8, !tbaa !9
  %312 = getelementptr inbounds %struct.leaf_data_result, ptr %311, i32 0, i32 0
  %313 = load i64, ptr %312, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 6, i64 noundef %313, ptr noundef null, i64 noundef 362, i32 noundef 148)
  call void @llvm.lifetime.start.p0(i64 24, ptr %19) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %19, ptr align 16 @__const.test_leaf_data_ops.A_6_8, i64 24, i1 false)
  store i32 0, ptr %18, align 4, !tbaa !5
  br label %314

314:                                              ; preds = %334, %304
  %315 = load i32, ptr %18, align 4, !tbaa !5
  %316 = zext i32 %315 to i64
  %317 = load ptr, ptr %6, align 8, !tbaa !9
  %318 = getelementptr inbounds %struct.leaf_data_result, ptr %317, i32 0, i32 0
  %319 = load i64, ptr %318, align 8, !tbaa !21
  %320 = icmp ult i64 %316, %319
  br i1 %320, label %321, label %337

321:                                              ; preds = %314
  %322 = load i32, ptr %18, align 4, !tbaa !5
  %323 = zext i32 %322 to i64
  %324 = getelementptr inbounds [6 x i32], ptr %19, i64 0, i64 %323
  %325 = load i32, ptr %324, align 4, !tbaa !5
  %326 = zext i32 %325 to i64
  %327 = load ptr, ptr %6, align 8, !tbaa !9
  %328 = getelementptr inbounds %struct.leaf_data_result, ptr %327, i32 0, i32 1
  %329 = load ptr, ptr %328, align 8, !tbaa !24
  %330 = load i32, ptr %18, align 4, !tbaa !5
  %331 = zext i32 %330 to i64
  %332 = getelementptr inbounds i64, ptr %329, i64 %331
  %333 = load i64, ptr %332, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %326, i64 noundef %333, ptr noundef null, i64 noundef 365, i32 noundef 148)
  br label %334

334:                                              ; preds = %321
  %335 = load i32, ptr %18, align 4, !tbaa !5
  %336 = add i32 %335, 1
  store i32 %336, ptr %18, align 4, !tbaa !5
  br label %314, !llvm.loop !28

337:                                              ; preds = %314
  %338 = load ptr, ptr %6, align 8, !tbaa !9
  %339 = getelementptr inbounds %struct.leaf_data_result, ptr %338, i32 0, i32 1
  %340 = load ptr, ptr %339, align 8, !tbaa !24
  call void @free(ptr noundef %340) #5
  %341 = load ptr, ptr %6, align 8, !tbaa !9
  call void @free(ptr noundef %341) #5
  store i32 10, ptr %7, align 4, !tbaa !5
  store i32 11, ptr %8, align 4, !tbaa !5
  %342 = load i32, ptr %2, align 4, !tbaa !5
  %343 = load ptr, ptr %1, align 8, !tbaa !9
  %344 = getelementptr inbounds %struct.giggle_index, ptr %343, i32 0, i32 0
  %345 = load ptr, ptr %344, align 8, !tbaa !14
  %346 = load i32, ptr %2, align 4, !tbaa !5
  %347 = zext i32 %346 to i64
  %348 = getelementptr inbounds i32, ptr %345, i64 %347
  %349 = load i32, ptr %348, align 4, !tbaa !5
  %350 = load i32, ptr %7, align 4, !tbaa !5
  %351 = call i32 @bpt_find(i32 noundef %342, i32 noundef %349, ptr noundef %9, ptr noundef %10, i32 noundef %350)
  store i32 %351, ptr %11, align 4, !tbaa !5
  %352 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %353 = load i32, ptr %2, align 4, !tbaa !5
  %354 = load i32, ptr %9, align 4, !tbaa !5
  %355 = sub i32 %354, 1
  %356 = call ptr %352(i32 noundef %353, i32 noundef %355, ptr noundef @bpt_node_cache_handler)
  store ptr %356, ptr %12, align 8, !tbaa !9
  %357 = load i32, ptr %10, align 4, !tbaa !5
  %358 = icmp eq i32 %357, 0
  br i1 %358, label %359, label %369

359:                                              ; preds = %337
  %360 = load ptr, ptr %12, align 8, !tbaa !9
  %361 = getelementptr inbounds %struct.bpt_node, ptr %360, i32 0, i32 0
  %362 = load ptr, ptr %361, align 8, !tbaa !19
  %363 = getelementptr inbounds i32, ptr %362, i64 6
  %364 = getelementptr inbounds i32, ptr %363, i64 0
  %365 = load i32, ptr %364, align 4, !tbaa !5
  %366 = load i32, ptr %7, align 4, !tbaa !5
  %367 = icmp ne i32 %365, %366
  br i1 %367, label %368, label %369

368:                                              ; preds = %359
  store i32 -1, ptr %10, align 4, !tbaa !5
  br label %395

369:                                              ; preds = %359, %337
  %370 = load i32, ptr %10, align 4, !tbaa !5
  %371 = icmp sge i32 %370, 0
  br i1 %371, label %372, label %394

372:                                              ; preds = %369
  %373 = load i32, ptr %10, align 4, !tbaa !5
  %374 = load ptr, ptr %12, align 8, !tbaa !9
  %375 = getelementptr inbounds %struct.bpt_node, ptr %374, i32 0, i32 0
  %376 = load ptr, ptr %375, align 8, !tbaa !19
  %377 = getelementptr inbounds i32, ptr %376, i64 5
  %378 = load i32, ptr %377, align 4, !tbaa !5
  %379 = icmp ult i32 %373, %378
  br i1 %379, label %380, label %394

380:                                              ; preds = %372
  %381 = load ptr, ptr %12, align 8, !tbaa !9
  %382 = getelementptr inbounds %struct.bpt_node, ptr %381, i32 0, i32 0
  %383 = load ptr, ptr %382, align 8, !tbaa !19
  %384 = getelementptr inbounds i32, ptr %383, i64 6
  %385 = load i32, ptr %10, align 4, !tbaa !5
  %386 = sext i32 %385 to i64
  %387 = getelementptr inbounds i32, ptr %384, i64 %386
  %388 = load i32, ptr %387, align 4, !tbaa !5
  %389 = load i32, ptr %7, align 4, !tbaa !5
  %390 = icmp ugt i32 %388, %389
  br i1 %390, label %391, label %394

391:                                              ; preds = %380
  %392 = load i32, ptr %10, align 4, !tbaa !5
  %393 = sub nsw i32 %392, 1
  store i32 %393, ptr %10, align 4, !tbaa !5
  br label %394

394:                                              ; preds = %391, %380, %372, %369
  br label %395

395:                                              ; preds = %394, %368
  %396 = load i32, ptr %2, align 4, !tbaa !5
  %397 = load ptr, ptr %1, align 8, !tbaa !9
  %398 = getelementptr inbounds %struct.giggle_index, ptr %397, i32 0, i32 0
  %399 = load ptr, ptr %398, align 8, !tbaa !14
  %400 = load i32, ptr %2, align 4, !tbaa !5
  %401 = zext i32 %400 to i64
  %402 = getelementptr inbounds i32, ptr %399, i64 %401
  %403 = load i32, ptr %402, align 4, !tbaa !5
  %404 = load i32, ptr %8, align 4, !tbaa !5
  %405 = call i32 @bpt_find(i32 noundef %396, i32 noundef %403, ptr noundef %13, ptr noundef %14, i32 noundef %404)
  store i32 %405, ptr %15, align 4, !tbaa !5
  %406 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 3), align 8, !tbaa !18
  %407 = load i32, ptr %2, align 4, !tbaa !5
  %408 = load i32, ptr %13, align 4, !tbaa !5
  %409 = sub i32 %408, 1
  %410 = call ptr %406(i32 noundef %407, i32 noundef %409, ptr noundef @bpt_node_cache_handler)
  store ptr %410, ptr %16, align 8, !tbaa !9
  %411 = load i32, ptr %14, align 4, !tbaa !5
  %412 = icmp eq i32 %411, 0
  br i1 %412, label %413, label %423

413:                                              ; preds = %395
  %414 = load ptr, ptr %16, align 8, !tbaa !9
  %415 = getelementptr inbounds %struct.bpt_node, ptr %414, i32 0, i32 0
  %416 = load ptr, ptr %415, align 8, !tbaa !19
  %417 = getelementptr inbounds i32, ptr %416, i64 6
  %418 = getelementptr inbounds i32, ptr %417, i64 0
  %419 = load i32, ptr %418, align 4, !tbaa !5
  %420 = load i32, ptr %8, align 4, !tbaa !5
  %421 = icmp ne i32 %419, %420
  br i1 %421, label %422, label %423

422:                                              ; preds = %413
  store i32 -1, ptr %14, align 4, !tbaa !5
  br label %449

423:                                              ; preds = %413, %395
  %424 = load i32, ptr %14, align 4, !tbaa !5
  %425 = icmp sge i32 %424, 0
  br i1 %425, label %426, label %448

426:                                              ; preds = %423
  %427 = load i32, ptr %14, align 4, !tbaa !5
  %428 = load ptr, ptr %16, align 8, !tbaa !9
  %429 = getelementptr inbounds %struct.bpt_node, ptr %428, i32 0, i32 0
  %430 = load ptr, ptr %429, align 8, !tbaa !19
  %431 = getelementptr inbounds i32, ptr %430, i64 5
  %432 = load i32, ptr %431, align 4, !tbaa !5
  %433 = icmp ult i32 %427, %432
  br i1 %433, label %434, label %448

434:                                              ; preds = %426
  %435 = load ptr, ptr %16, align 8, !tbaa !9
  %436 = getelementptr inbounds %struct.bpt_node, ptr %435, i32 0, i32 0
  %437 = load ptr, ptr %436, align 8, !tbaa !19
  %438 = getelementptr inbounds i32, ptr %437, i64 6
  %439 = load i32, ptr %14, align 4, !tbaa !5
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds i32, ptr %438, i64 %440
  %442 = load i32, ptr %441, align 4, !tbaa !5
  %443 = load i32, ptr %8, align 4, !tbaa !5
  %444 = icmp ugt i32 %442, %443
  br i1 %444, label %445, label %448

445:                                              ; preds = %434
  %446 = load i32, ptr %14, align 4, !tbaa !5
  %447 = sub nsw i32 %446, 1
  store i32 %447, ptr %14, align 4, !tbaa !5
  br label %448

448:                                              ; preds = %445, %434, %426, %423
  br label %449

449:                                              ; preds = %448, %422
  %450 = load i32, ptr %9, align 4, !tbaa !5
  %451 = load i32, ptr %10, align 4, !tbaa !5
  %452 = load i32, ptr %13, align 4, !tbaa !5
  %453 = load i32, ptr %14, align 4, !tbaa !5
  %454 = load i32, ptr %2, align 4, !tbaa !5
  %455 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %450, i32 noundef %451, i32 noundef %452, i32 noundef %453, i32 noundef %454, ptr noundef null)
  store ptr %455, ptr %6, align 8, !tbaa !9
  %456 = load ptr, ptr %6, align 8, !tbaa !9
  %457 = getelementptr inbounds %struct.leaf_data_result, ptr %456, i32 0, i32 0
  %458 = load i64, ptr %457, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 4, i64 noundef %458, ptr noundef null, i64 noundef 416, i32 noundef 148)
  call void @llvm.lifetime.start.p0(i64 16, ptr %20) #5
  call void @llvm.memcpy.p0.p0.i64(ptr align 16 %20, ptr align 16 @__const.test_leaf_data_ops.A_10_12, i64 16, i1 false)
  store i32 0, ptr %18, align 4, !tbaa !5
  br label %459

459:                                              ; preds = %479, %449
  %460 = load i32, ptr %18, align 4, !tbaa !5
  %461 = zext i32 %460 to i64
  %462 = load ptr, ptr %6, align 8, !tbaa !9
  %463 = getelementptr inbounds %struct.leaf_data_result, ptr %462, i32 0, i32 0
  %464 = load i64, ptr %463, align 8, !tbaa !21
  %465 = icmp ult i64 %461, %464
  br i1 %465, label %466, label %482

466:                                              ; preds = %459
  %467 = load i32, ptr %18, align 4, !tbaa !5
  %468 = zext i32 %467 to i64
  %469 = getelementptr inbounds [4 x i32], ptr %20, i64 0, i64 %468
  %470 = load i32, ptr %469, align 4, !tbaa !5
  %471 = zext i32 %470 to i64
  %472 = load ptr, ptr %6, align 8, !tbaa !9
  %473 = getelementptr inbounds %struct.leaf_data_result, ptr %472, i32 0, i32 1
  %474 = load ptr, ptr %473, align 8, !tbaa !24
  %475 = load i32, ptr %18, align 4, !tbaa !5
  %476 = zext i32 %475 to i64
  %477 = getelementptr inbounds i64, ptr %474, i64 %476
  %478 = load i64, ptr %477, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %471, i64 noundef %478, ptr noundef null, i64 noundef 419, i32 noundef 148)
  br label %479

479:                                              ; preds = %466
  %480 = load i32, ptr %18, align 4, !tbaa !5
  %481 = add i32 %480, 1
  store i32 %481, ptr %18, align 4, !tbaa !5
  br label %459, !llvm.loop !29

482:                                              ; preds = %459
  %483 = load ptr, ptr %6, align 8, !tbaa !9
  %484 = getelementptr inbounds %struct.leaf_data_result, ptr %483, i32 0, i32 1
  %485 = load ptr, ptr %484, align 8, !tbaa !24
  call void @free(ptr noundef %485) #5
  %486 = load ptr, ptr %6, align 8, !tbaa !9
  call void @free(ptr noundef %486) #5
  call void @giggle_index_destroy(ptr noundef %1)
  %487 = load ptr, ptr getelementptr inbounds (%struct.cache_def, ptr @cache, i32 0, i32 6), align 8, !tbaa !16
  call void (...) %487()
  %488 = call i32 @rmrf(ptr noundef @.str)
  call void @llvm.lifetime.end.p0(i64 16, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 24, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 28, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %2) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %1) #5
  ret void
}

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

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

declare void @uint64_t_ll_giggle_set_data_handler(...) #2

declare void @giggle_write_tree_leaf_data(ptr noundef) #2

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

declare i32 @giggle_insert(i32 noundef, ptr noundef, i32 noundef, i32 noundef, i64 noundef) #2

declare i32 @giggle_store(ptr noundef) #2

declare void @giggle_index_destroy(ptr noundef) #2

declare ptr @giggle_load(ptr noundef, ptr noundef) #2

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

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

declare void @UnityAssertEqualNumber(i64 noundef, i64 noundef, ptr noundef, i64 noundef, i32 noundef) #2

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

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

declare i32 @rmrf(ptr noundef) #2

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !10, i64 112}
!12 = !{!"giggle_def", !13, i64 0, !13, i64 24, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !10, i64 128}
!13 = !{!"cache_handler", !10, i64 0, !10, i64 8, !10, i64 16}
!14 = !{!15, !10, i64 0}
!15 = !{!"giggle_index", !10, i64 0, !6, i64 8, !6, i64 12, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56}
!16 = !{!17, !10, i64 48}
!17 = !{!"cache_def", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48}
!18 = !{!17, !10, i64 24}
!19 = !{!20, !10, i64 0}
!20 = !{!"bpt_node", !10, i64 0}
!21 = !{!22, !23, i64 0}
!22 = !{!"leaf_data_result", !23, i64 0, !10, i64 8, !10, i64 16}
!23 = !{!"long", !7, i64 0}
!24 = !{!22, !10, i64 8}
!25 = !{!23, !23, i64 0}
!26 = distinct !{!26, !27}
!27 = !{!"llvm.loop.mustprogress"}
!28 = distinct !{!28, !27}
!29 = distinct !{!29, !27}


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

%struct.giggle_def = type { %struct.cache_handler, %struct.cache_handler, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.cache_handler = type { ptr, ptr, ptr }
%struct.cache_def = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr }

@ORDER = external dso_local local_unnamed_addr global i32, align 4
@.str = external hidden unnamed_addr constant [4 x i8], align 1
@giggle_data_handler = external dso_local local_unnamed_addr global %struct.giggle_def, align 8
@.str.1 = external hidden unnamed_addr constant [2 x i8], align 1
@cache = external dso_local local_unnamed_addr global %struct.cache_def, align 8
@bpt_node_cache_handler = external dso_local global %struct.cache_handler, align 8
@__const.test_leaf_data_ops.A_2_11 = external hidden unnamed_addr constant [7 x i32], align 16
@__const.test_leaf_data_ops.A_6_8 = external hidden unnamed_addr constant [6 x i32], align 16
@__const.test_leaf_data_ops.A_10_12 = external hidden unnamed_addr constant [4 x i32], align 16

; Function Attrs: nounwind uwtable
define dso_local void @test_leaf_data_ops() local_unnamed_addr #0 {
  %1 = alloca ptr, align 8
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  store i32 5, ptr @ORDER, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %1) #4
  %7 = tail call ptr @giggle_init(i32 noundef 23, ptr noundef nonnull @.str, i32 noundef 1, ptr noundef nonnull @uint64_t_ll_giggle_set_data_handler) #4
  store ptr %7, ptr %1, align 8, !tbaa !9
  store ptr @giggle_write_tree_leaf_data, ptr getelementptr inbounds (i8, ptr @giggle_data_handler, i64 112), align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %2) #4
  store i32 0, ptr %2, align 4, !tbaa !5
  %8 = tail call i32 @giggle_get_chrm_id(ptr noundef %7, ptr noundef nonnull @.str.1) #4
  %9 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 1, i32 noundef 9, i64 noundef 1) #4
  %10 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 2, i32 noundef 4, i64 noundef 2) #4
  %11 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 3, i32 noundef 6, i64 noundef 3) #4
  %12 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 4, i32 noundef 14, i64 noundef 4) #4
  %13 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 5, i32 noundef 10, i64 noundef 5) #4
  %14 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 7, i32 noundef 13, i64 noundef 6) #4
  %15 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 7, i32 noundef 11, i64 noundef 7) #4
  %16 = call i32 @giggle_insert(i32 noundef %8, ptr noundef nonnull %2, i32 noundef 12, i32 noundef 15, i64 noundef 8) #4
  %17 = load i32, ptr %2, align 4, !tbaa !5
  %18 = load ptr, ptr %7, align 8, !tbaa !14
  %19 = zext i32 %8 to i64
  %20 = getelementptr inbounds i32, ptr %18, i64 %19
  store i32 %17, ptr %20, align 4, !tbaa !5
  %21 = call i32 @giggle_store(ptr noundef nonnull %7) #4
  call void @giggle_index_destroy(ptr noundef nonnull %1) #4
  %22 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 48), align 8, !tbaa !16
  call void (...) %22() #4
  %23 = call ptr @giggle_load(ptr noundef nonnull @.str, ptr noundef nonnull @uint64_t_ll_giggle_set_data_handler) #4
  store ptr %23, ptr %1, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %3) #4
  store i32 0, ptr %3, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %4) #4
  store i32 0, ptr %4, align 4, !tbaa !5
  %24 = load ptr, ptr %23, align 8, !tbaa !14
  %25 = load i32, ptr %24, align 4, !tbaa !5
  %26 = call i32 @bpt_find(i32 noundef 0, i32 noundef %25, ptr noundef nonnull %3, ptr noundef nonnull %4, i32 noundef 2) #4
  %27 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %28 = load i32, ptr %3, align 4, !tbaa !5
  %29 = add i32 %28, -1
  %30 = call ptr %27(i32 noundef 0, i32 noundef %29, ptr noundef nonnull @bpt_node_cache_handler) #4
  %31 = load i32, ptr %4, align 4, !tbaa !5
  %32 = icmp eq i32 %31, 0
  br i1 %32, label %33, label %38

33:                                               ; preds = %0
  %34 = load ptr, ptr %30, align 8, !tbaa !19
  %35 = getelementptr inbounds i8, ptr %34, i64 24
  %36 = load i32, ptr %35, align 4, !tbaa !5
  %.not = icmp eq i32 %36, 2
  br i1 %.not, label %.thread, label %37

37:                                               ; preds = %33
  store i32 -1, ptr %4, align 4, !tbaa !5
  br label %52

38:                                               ; preds = %0
  %39 = icmp sgt i32 %31, -1
  br i1 %39, label %..thread_crit_edge, label %52

..thread_crit_edge:                               ; preds = %38
  %.pre = load ptr, ptr %30, align 8, !tbaa !19
  br label %.thread

.thread:                                          ; preds = %..thread_crit_edge, %33
  %40 = phi ptr [ %.pre, %..thread_crit_edge ], [ %34, %33 ]
  %41 = getelementptr inbounds i8, ptr %40, i64 20
  %42 = load i32, ptr %41, align 4, !tbaa !5
  %43 = icmp ult i32 %31, %42
  br i1 %43, label %44, label %52

44:                                               ; preds = %.thread
  %45 = getelementptr inbounds i8, ptr %40, i64 24
  %46 = zext nneg i32 %31 to i64
  %47 = getelementptr inbounds i32, ptr %45, i64 %46
  %48 = load i32, ptr %47, align 4, !tbaa !5
  %49 = icmp ugt i32 %48, 2
  br i1 %49, label %50, label %52

50:                                               ; preds = %44
  %51 = add nsw i32 %31, -1
  store i32 %51, ptr %4, align 4, !tbaa !5
  br label %52

52:                                               ; preds = %38, %.thread, %44, %50, %37
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %5) #4
  store i32 0, ptr %5, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %6) #4
  store i32 0, ptr %6, align 4, !tbaa !5
  %53 = load ptr, ptr %1, align 8, !tbaa !9
  %54 = load ptr, ptr %53, align 8, !tbaa !14
  %55 = load i32, ptr %54, align 4, !tbaa !5
  %56 = call i32 @bpt_find(i32 noundef 0, i32 noundef %55, ptr noundef nonnull %5, ptr noundef nonnull %6, i32 noundef 11) #4
  %57 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %58 = load i32, ptr %5, align 4, !tbaa !5
  %59 = add i32 %58, -1
  %60 = call ptr %57(i32 noundef 0, i32 noundef %59, ptr noundef nonnull @bpt_node_cache_handler) #4
  %61 = load i32, ptr %6, align 4, !tbaa !5
  %62 = icmp eq i32 %61, 0
  br i1 %62, label %63, label %68

63:                                               ; preds = %52
  %64 = load ptr, ptr %60, align 8, !tbaa !19
  %65 = getelementptr inbounds i8, ptr %64, i64 24
  %66 = load i32, ptr %65, align 4, !tbaa !5
  %.not102 = icmp eq i32 %66, 11
  br i1 %.not102, label %.thread107, label %67

67:                                               ; preds = %63
  store i32 -1, ptr %6, align 4, !tbaa !5
  br label %82

68:                                               ; preds = %52
  %69 = icmp sgt i32 %61, -1
  br i1 %69, label %..thread107_crit_edge, label %82

..thread107_crit_edge:                            ; preds = %68
  %.pre124 = load ptr, ptr %60, align 8, !tbaa !19
  br label %.thread107

.thread107:                                       ; preds = %..thread107_crit_edge, %63
  %70 = phi ptr [ %.pre124, %..thread107_crit_edge ], [ %64, %63 ]
  %71 = getelementptr inbounds i8, ptr %70, i64 20
  %72 = load i32, ptr %71, align 4, !tbaa !5
  %73 = icmp ult i32 %61, %72
  br i1 %73, label %74, label %82

74:                                               ; preds = %.thread107
  %75 = getelementptr inbounds i8, ptr %70, i64 24
  %76 = zext nneg i32 %61 to i64
  %77 = getelementptr inbounds i32, ptr %75, i64 %76
  %78 = load i32, ptr %77, align 4, !tbaa !5
  %79 = icmp ugt i32 %78, 11
  br i1 %79, label %80, label %82

80:                                               ; preds = %74
  %81 = add nsw i32 %61, -1
  store i32 %81, ptr %6, align 4, !tbaa !5
  br label %82

82:                                               ; preds = %68, %.thread107, %74, %80, %67
  %83 = phi i32 [ %61, %68 ], [ %61, %.thread107 ], [ %61, %74 ], [ %81, %80 ], [ -1, %67 ]
  %84 = load i32, ptr %3, align 4, !tbaa !5
  %85 = load i32, ptr %4, align 4, !tbaa !5
  %86 = load i32, ptr %5, align 4, !tbaa !5
  %87 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %84, i32 noundef %85, i32 noundef %86, i32 noundef %83, i32 noundef 0, ptr noundef null) #4
  %88 = load i64, ptr %87, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 7, i64 noundef %88, ptr noundef null, i64 noundef 308, i32 noundef 148) #4
  %89 = load i64, ptr %87, align 8, !tbaa !21
  %.not121 = icmp eq i64 %89, 0
  br i1 %.not121, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %82
  %90 = getelementptr inbounds i8, ptr %87, i64 8
  br label %91

91:                                               ; preds = %.lr.ph, %91
  %92 = phi i64 [ 0, %.lr.ph ], [ %100, %91 ]
  %.0112 = phi i32 [ 0, %.lr.ph ], [ %99, %91 ]
  %93 = getelementptr inbounds [7 x i32], ptr @__const.test_leaf_data_ops.A_2_11, i64 0, i64 %92
  %94 = load i32, ptr %93, align 4, !tbaa !5
  %95 = zext i32 %94 to i64
  %96 = load ptr, ptr %90, align 8, !tbaa !24
  %97 = getelementptr inbounds i64, ptr %96, i64 %92
  %98 = load i64, ptr %97, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %95, i64 noundef %98, ptr noundef null, i64 noundef 313, i32 noundef 148) #4
  %99 = add i32 %.0112, 1
  %100 = zext i32 %99 to i64
  %101 = load i64, ptr %87, align 8, !tbaa !21
  %102 = icmp ugt i64 %101, %100
  br i1 %102, label %91, label %._crit_edge, !llvm.loop !26

._crit_edge:                                      ; preds = %91, %82
  %103 = getelementptr inbounds i8, ptr %87, i64 8
  %104 = load ptr, ptr %103, align 8, !tbaa !24
  call void @free(ptr noundef %104) #4
  call void @free(ptr noundef nonnull %87) #4
  %105 = load ptr, ptr %1, align 8, !tbaa !9
  %106 = load ptr, ptr %105, align 8, !tbaa !14
  %107 = load i32, ptr %106, align 4, !tbaa !5
  %108 = call i32 @bpt_find(i32 noundef 0, i32 noundef %107, ptr noundef nonnull %3, ptr noundef nonnull %4, i32 noundef 6) #4
  %109 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %110 = load i32, ptr %3, align 4, !tbaa !5
  %111 = add i32 %110, -1
  %112 = call ptr %109(i32 noundef 0, i32 noundef %111, ptr noundef nonnull @bpt_node_cache_handler) #4
  %113 = load i32, ptr %4, align 4, !tbaa !5
  %114 = icmp eq i32 %113, 0
  br i1 %114, label %115, label %120

115:                                              ; preds = %._crit_edge
  %116 = load ptr, ptr %112, align 8, !tbaa !19
  %117 = getelementptr inbounds i8, ptr %116, i64 24
  %118 = load i32, ptr %117, align 4, !tbaa !5
  %.not103 = icmp eq i32 %118, 6
  br i1 %.not103, label %.thread108, label %119

119:                                              ; preds = %115
  store i32 -1, ptr %4, align 4, !tbaa !5
  br label %134

120:                                              ; preds = %._crit_edge
  %121 = icmp sgt i32 %113, -1
  br i1 %121, label %..thread108_crit_edge, label %134

..thread108_crit_edge:                            ; preds = %120
  %.pre125 = load ptr, ptr %112, align 8, !tbaa !19
  br label %.thread108

.thread108:                                       ; preds = %..thread108_crit_edge, %115
  %122 = phi ptr [ %.pre125, %..thread108_crit_edge ], [ %116, %115 ]
  %123 = getelementptr inbounds i8, ptr %122, i64 20
  %124 = load i32, ptr %123, align 4, !tbaa !5
  %125 = icmp ult i32 %113, %124
  br i1 %125, label %126, label %134

126:                                              ; preds = %.thread108
  %127 = getelementptr inbounds i8, ptr %122, i64 24
  %128 = zext nneg i32 %113 to i64
  %129 = getelementptr inbounds i32, ptr %127, i64 %128
  %130 = load i32, ptr %129, align 4, !tbaa !5
  %131 = icmp ugt i32 %130, 6
  br i1 %131, label %132, label %134

132:                                              ; preds = %126
  %133 = add nsw i32 %113, -1
  store i32 %133, ptr %4, align 4, !tbaa !5
  br label %134

134:                                              ; preds = %120, %.thread108, %126, %132, %119
  %135 = load ptr, ptr %1, align 8, !tbaa !9
  %136 = load ptr, ptr %135, align 8, !tbaa !14
  %137 = load i32, ptr %136, align 4, !tbaa !5
  %138 = call i32 @bpt_find(i32 noundef 0, i32 noundef %137, ptr noundef nonnull %5, ptr noundef nonnull %6, i32 noundef 8) #4
  %139 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %140 = load i32, ptr %5, align 4, !tbaa !5
  %141 = add i32 %140, -1
  %142 = call ptr %139(i32 noundef 0, i32 noundef %141, ptr noundef nonnull @bpt_node_cache_handler) #4
  %143 = load i32, ptr %6, align 4, !tbaa !5
  %144 = icmp eq i32 %143, 0
  br i1 %144, label %145, label %150

145:                                              ; preds = %134
  %146 = load ptr, ptr %142, align 8, !tbaa !19
  %147 = getelementptr inbounds i8, ptr %146, i64 24
  %148 = load i32, ptr %147, align 4, !tbaa !5
  %.not104 = icmp eq i32 %148, 8
  br i1 %.not104, label %.thread109, label %149

149:                                              ; preds = %145
  store i32 -1, ptr %6, align 4, !tbaa !5
  br label %164

150:                                              ; preds = %134
  %151 = icmp sgt i32 %143, -1
  br i1 %151, label %..thread109_crit_edge, label %164

..thread109_crit_edge:                            ; preds = %150
  %.pre126 = load ptr, ptr %142, align 8, !tbaa !19
  br label %.thread109

.thread109:                                       ; preds = %..thread109_crit_edge, %145
  %152 = phi ptr [ %.pre126, %..thread109_crit_edge ], [ %146, %145 ]
  %153 = getelementptr inbounds i8, ptr %152, i64 20
  %154 = load i32, ptr %153, align 4, !tbaa !5
  %155 = icmp ult i32 %143, %154
  br i1 %155, label %156, label %164

156:                                              ; preds = %.thread109
  %157 = getelementptr inbounds i8, ptr %152, i64 24
  %158 = zext nneg i32 %143 to i64
  %159 = getelementptr inbounds i32, ptr %157, i64 %158
  %160 = load i32, ptr %159, align 4, !tbaa !5
  %161 = icmp ugt i32 %160, 8
  br i1 %161, label %162, label %164

162:                                              ; preds = %156
  %163 = add nsw i32 %143, -1
  store i32 %163, ptr %6, align 4, !tbaa !5
  br label %164

164:                                              ; preds = %150, %.thread109, %156, %162, %149
  %165 = phi i32 [ %143, %150 ], [ %143, %.thread109 ], [ %143, %156 ], [ %163, %162 ], [ -1, %149 ]
  %166 = load i32, ptr %3, align 4, !tbaa !5
  %167 = load i32, ptr %4, align 4, !tbaa !5
  %168 = load i32, ptr %5, align 4, !tbaa !5
  %169 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %166, i32 noundef %167, i32 noundef %168, i32 noundef %165, i32 noundef 0, ptr noundef null) #4
  %170 = load i64, ptr %169, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 6, i64 noundef %170, ptr noundef null, i64 noundef 362, i32 noundef 148) #4
  %171 = load i64, ptr %169, align 8, !tbaa !21
  %.not122 = icmp eq i64 %171, 0
  br i1 %.not122, label %._crit_edge116, label %.lr.ph115

.lr.ph115:                                        ; preds = %164
  %172 = getelementptr inbounds i8, ptr %169, i64 8
  br label %173

173:                                              ; preds = %.lr.ph115, %173
  %174 = phi i64 [ 0, %.lr.ph115 ], [ %182, %173 ]
  %.1113 = phi i32 [ 0, %.lr.ph115 ], [ %181, %173 ]
  %175 = getelementptr inbounds [6 x i32], ptr @__const.test_leaf_data_ops.A_6_8, i64 0, i64 %174
  %176 = load i32, ptr %175, align 4, !tbaa !5
  %177 = zext i32 %176 to i64
  %178 = load ptr, ptr %172, align 8, !tbaa !24
  %179 = getelementptr inbounds i64, ptr %178, i64 %174
  %180 = load i64, ptr %179, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %177, i64 noundef %180, ptr noundef null, i64 noundef 365, i32 noundef 148) #4
  %181 = add i32 %.1113, 1
  %182 = zext i32 %181 to i64
  %183 = load i64, ptr %169, align 8, !tbaa !21
  %184 = icmp ugt i64 %183, %182
  br i1 %184, label %173, label %._crit_edge116, !llvm.loop !28

._crit_edge116:                                   ; preds = %173, %164
  %185 = getelementptr inbounds i8, ptr %169, i64 8
  %186 = load ptr, ptr %185, align 8, !tbaa !24
  call void @free(ptr noundef %186) #4
  call void @free(ptr noundef nonnull %169) #4
  %187 = load ptr, ptr %1, align 8, !tbaa !9
  %188 = load ptr, ptr %187, align 8, !tbaa !14
  %189 = load i32, ptr %188, align 4, !tbaa !5
  %190 = call i32 @bpt_find(i32 noundef 0, i32 noundef %189, ptr noundef nonnull %3, ptr noundef nonnull %4, i32 noundef 10) #4
  %191 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %192 = load i32, ptr %3, align 4, !tbaa !5
  %193 = add i32 %192, -1
  %194 = call ptr %191(i32 noundef 0, i32 noundef %193, ptr noundef nonnull @bpt_node_cache_handler) #4
  %195 = load i32, ptr %4, align 4, !tbaa !5
  %196 = icmp eq i32 %195, 0
  br i1 %196, label %197, label %202

197:                                              ; preds = %._crit_edge116
  %198 = load ptr, ptr %194, align 8, !tbaa !19
  %199 = getelementptr inbounds i8, ptr %198, i64 24
  %200 = load i32, ptr %199, align 4, !tbaa !5
  %.not105 = icmp eq i32 %200, 10
  br i1 %.not105, label %.thread110, label %201

201:                                              ; preds = %197
  store i32 -1, ptr %4, align 4, !tbaa !5
  br label %216

202:                                              ; preds = %._crit_edge116
  %203 = icmp sgt i32 %195, -1
  br i1 %203, label %..thread110_crit_edge, label %216

..thread110_crit_edge:                            ; preds = %202
  %.pre127 = load ptr, ptr %194, align 8, !tbaa !19
  br label %.thread110

.thread110:                                       ; preds = %..thread110_crit_edge, %197
  %204 = phi ptr [ %.pre127, %..thread110_crit_edge ], [ %198, %197 ]
  %205 = getelementptr inbounds i8, ptr %204, i64 20
  %206 = load i32, ptr %205, align 4, !tbaa !5
  %207 = icmp ult i32 %195, %206
  br i1 %207, label %208, label %216

208:                                              ; preds = %.thread110
  %209 = getelementptr inbounds i8, ptr %204, i64 24
  %210 = zext nneg i32 %195 to i64
  %211 = getelementptr inbounds i32, ptr %209, i64 %210
  %212 = load i32, ptr %211, align 4, !tbaa !5
  %213 = icmp ugt i32 %212, 10
  br i1 %213, label %214, label %216

214:                                              ; preds = %208
  %215 = add nsw i32 %195, -1
  store i32 %215, ptr %4, align 4, !tbaa !5
  br label %216

216:                                              ; preds = %202, %.thread110, %208, %214, %201
  %217 = load ptr, ptr %1, align 8, !tbaa !9
  %218 = load ptr, ptr %217, align 8, !tbaa !14
  %219 = load i32, ptr %218, align 4, !tbaa !5
  %220 = call i32 @bpt_find(i32 noundef 0, i32 noundef %219, ptr noundef nonnull %5, ptr noundef nonnull %6, i32 noundef 11) #4
  %221 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 24), align 8, !tbaa !18
  %222 = load i32, ptr %5, align 4, !tbaa !5
  %223 = add i32 %222, -1
  %224 = call ptr %221(i32 noundef 0, i32 noundef %223, ptr noundef nonnull @bpt_node_cache_handler) #4
  %225 = load i32, ptr %6, align 4, !tbaa !5
  %226 = icmp eq i32 %225, 0
  br i1 %226, label %227, label %232

227:                                              ; preds = %216
  %228 = load ptr, ptr %224, align 8, !tbaa !19
  %229 = getelementptr inbounds i8, ptr %228, i64 24
  %230 = load i32, ptr %229, align 4, !tbaa !5
  %.not106 = icmp eq i32 %230, 11
  br i1 %.not106, label %.thread111, label %231

231:                                              ; preds = %227
  store i32 -1, ptr %6, align 4, !tbaa !5
  br label %246

232:                                              ; preds = %216
  %233 = icmp sgt i32 %225, -1
  br i1 %233, label %..thread111_crit_edge, label %246

..thread111_crit_edge:                            ; preds = %232
  %.pre128 = load ptr, ptr %224, align 8, !tbaa !19
  br label %.thread111

.thread111:                                       ; preds = %..thread111_crit_edge, %227
  %234 = phi ptr [ %.pre128, %..thread111_crit_edge ], [ %228, %227 ]
  %235 = getelementptr inbounds i8, ptr %234, i64 20
  %236 = load i32, ptr %235, align 4, !tbaa !5
  %237 = icmp ult i32 %225, %236
  br i1 %237, label %238, label %246

238:                                              ; preds = %.thread111
  %239 = getelementptr inbounds i8, ptr %234, i64 24
  %240 = zext nneg i32 %225 to i64
  %241 = getelementptr inbounds i32, ptr %239, i64 %240
  %242 = load i32, ptr %241, align 4, !tbaa !5
  %243 = icmp ugt i32 %242, 11
  br i1 %243, label %244, label %246

244:                                              ; preds = %238
  %245 = add nsw i32 %225, -1
  store i32 %245, ptr %6, align 4, !tbaa !5
  br label %246

246:                                              ; preds = %232, %.thread111, %238, %244, %231
  %247 = phi i32 [ %225, %232 ], [ %225, %.thread111 ], [ %225, %238 ], [ %245, %244 ], [ -1, %231 ]
  %248 = load i32, ptr %3, align 4, !tbaa !5
  %249 = load i32, ptr %4, align 4, !tbaa !5
  %250 = load i32, ptr %5, align 4, !tbaa !5
  %251 = call ptr @giggle_collect_intersection_data_in_block(i32 noundef %248, i32 noundef %249, i32 noundef %250, i32 noundef %247, i32 noundef 0, ptr noundef null) #4
  %252 = load i64, ptr %251, align 8, !tbaa !21
  call void @UnityAssertEqualNumber(i64 noundef 4, i64 noundef %252, ptr noundef null, i64 noundef 416, i32 noundef 148) #4
  %253 = load i64, ptr %251, align 8, !tbaa !21
  %.not123 = icmp eq i64 %253, 0
  br i1 %.not123, label %._crit_edge120, label %.lr.ph119

.lr.ph119:                                        ; preds = %246
  %254 = getelementptr inbounds i8, ptr %251, i64 8
  br label %255

255:                                              ; preds = %.lr.ph119, %255
  %256 = phi i64 [ 0, %.lr.ph119 ], [ %264, %255 ]
  %.2117 = phi i32 [ 0, %.lr.ph119 ], [ %263, %255 ]
  %257 = getelementptr inbounds [4 x i32], ptr @__const.test_leaf_data_ops.A_10_12, i64 0, i64 %256
  %258 = load i32, ptr %257, align 4, !tbaa !5
  %259 = zext i32 %258 to i64
  %260 = load ptr, ptr %254, align 8, !tbaa !24
  %261 = getelementptr inbounds i64, ptr %260, i64 %256
  %262 = load i64, ptr %261, align 8, !tbaa !25
  call void @UnityAssertEqualNumber(i64 noundef %259, i64 noundef %262, ptr noundef null, i64 noundef 419, i32 noundef 148) #4
  %263 = add i32 %.2117, 1
  %264 = zext i32 %263 to i64
  %265 = load i64, ptr %251, align 8, !tbaa !21
  %266 = icmp ugt i64 %265, %264
  br i1 %266, label %255, label %._crit_edge120, !llvm.loop !29

._crit_edge120:                                   ; preds = %255, %246
  %267 = getelementptr inbounds i8, ptr %251, i64 8
  %268 = load ptr, ptr %267, align 8, !tbaa !24
  call void @free(ptr noundef %268) #4
  call void @free(ptr noundef nonnull %251) #4
  call void @giggle_index_destroy(ptr noundef nonnull %1) #4
  %269 = load ptr, ptr getelementptr inbounds (i8, ptr @cache, i64 48), align 8, !tbaa !16
  call void (...) %269() #4
  %270 = call i32 @rmrf(ptr noundef nonnull @.str) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %6) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %5) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %4) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %3) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %2) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %1) #4
  ret void
}

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

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

declare void @uint64_t_ll_giggle_set_data_handler(...) #2

declare void @giggle_write_tree_leaf_data(ptr noundef) #2

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

declare i32 @giggle_insert(i32 noundef, ptr noundef, i32 noundef, i32 noundef, i64 noundef) local_unnamed_addr #2

declare i32 @giggle_store(ptr noundef) local_unnamed_addr #2

declare void @giggle_index_destroy(ptr noundef) local_unnamed_addr #2

declare ptr @giggle_load(ptr noundef, ptr noundef) local_unnamed_addr #2

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

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

declare void @UnityAssertEqualNumber(i64 noundef, i64 noundef, ptr noundef, i64 noundef, i32 noundef) local_unnamed_addr #2

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

declare i32 @rmrf(ptr noundef) local_unnamed_addr #2

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !10, i64 112}
!12 = !{!"giggle_def", !13, i64 0, !13, i64 24, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !10, i64 104, !10, i64 112, !10, i64 120, !10, i64 128}
!13 = !{!"cache_handler", !10, i64 0, !10, i64 8, !10, i64 16}
!14 = !{!15, !10, i64 0}
!15 = !{!"giggle_index", !10, i64 0, !6, i64 8, !6, i64 12, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !10, i64 56}
!16 = !{!17, !10, i64 48}
!17 = !{!"cache_def", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48}
!18 = !{!17, !10, i64 24}
!19 = !{!20, !10, i64 0}
!20 = !{!"bpt_node", !10, i64 0}
!21 = !{!22, !23, i64 0}
!22 = !{!"leaf_data_result", !23, i64 0, !10, i64 8, !10, i64 16}
!23 = !{!"long", !7, i64 0}
!24 = !{!22, !10, i64 8}
!25 = !{!23, !23, i64 0}
!26 = distinct !{!26, !27}
!27 = !{!"llvm.loop.mustprogress"}
!28 = distinct !{!28, !27}
!29 = distinct !{!29, !27}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,SROAPass,SimplifyCFGPass,TailCallElimPass