; LLVM IR from stan-dev/math :: lib/boost_1.84.0/libs/container/src (alloc_lib)

; 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.malloc_state = type { i32, i32, i64, i64, ptr, ptr, ptr, i64, i64, i64, [66 x ptr], [32 x ptr], i64, i64, i64, i32, i32, %struct.malloc_segment, ptr, i64 }
%struct.malloc_segment = type { ptr, i64, ptr, i32 }
%struct.malloc_chunk = type { i64, i64, ptr, ptr }
%struct.malloc_tree_chunk = type { i64, i64, ptr, ptr, [2 x ptr], ptr, i32 }

; Function Attrs: nounwind uwtable
declare hidden i32 @spin_acquire_lock(ptr noundef) #0

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

; Function Attrs: noreturn nounwind
declare void @abort() #2

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.i64(i64, i64) #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 uwtable
declare hidden void @do_check_inuse_chunk(ptr noundef, ptr noundef) #0

; Function Attrs: nounwind
declare i32 @munmap(ptr noundef, i64 noundef) #4

; Function Attrs: nounwind uwtable
declare hidden i32 @sys_trim(ptr noundef, i64 noundef) #0

; Function Attrs: nounwind uwtable
declare hidden void @do_check_free_chunk(ptr noundef, ptr noundef) #0

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.ctlz.i32(i32, i1 immarg) #5

; Function Attrs: nounwind uwtable
declare hidden i64 @release_unused_segments(ptr noundef) #0

; Function Attrs: nounwind uwtable
define dso_local void @mspace_free(ptr noundef %0, ptr noundef %1) #0 {
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca i64, align 8
  %8 = alloca ptr, align 8
  %9 = alloca i64, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca i32, align 4
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  %23 = alloca i32, align 4
  %24 = alloca i64, align 8
  %25 = alloca i64, align 8
  %26 = alloca i64, align 8
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca i32, align 4
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca i32, align 4
  %40 = alloca ptr, align 8
  %41 = alloca ptr, align 8
  %42 = alloca ptr, align 8
  %43 = alloca ptr, align 8
  %44 = alloca i32, align 4
  %45 = alloca i32, align 4
  %46 = alloca i32, align 4
  %47 = alloca ptr, align 8
  %48 = alloca i64, align 8
  %49 = alloca ptr, align 8
  %50 = alloca ptr, align 8
  store ptr %0, ptr %3, align 8, !tbaa !5
  store ptr %1, ptr %4, align 8, !tbaa !5
  %51 = load ptr, ptr %4, align 8, !tbaa !5
  %52 = icmp ne ptr %51, null
  br i1 %52, label %53, label %1275

53:                                               ; preds = %2
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #6
  %54 = load ptr, ptr %4, align 8, !tbaa !5
  %55 = getelementptr inbounds i8, ptr %54, i64 -16
  store ptr %55, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #6
  %56 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %56, ptr %6, align 8, !tbaa !5
  %57 = load ptr, ptr %6, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.malloc_state, ptr %57, i32 0, i32 15
  %59 = load i32, ptr %58, align 8, !tbaa !9
  %60 = and i32 %59, 2
  %61 = icmp ne i32 %60, 0
  br i1 %61, label %62, label %73

62:                                               ; preds = %53
  %63 = load ptr, ptr %6, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.malloc_state, ptr %63, i32 0, i32 16
  %65 = atomicrmw xchg ptr %64, i32 1 seq_cst, align 4
  %66 = icmp ne i32 %65, 0
  br i1 %66, label %67, label %72

67:                                               ; preds = %62
  %68 = load ptr, ptr %6, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.malloc_state, ptr %68, i32 0, i32 16
  %70 = call i32 @spin_acquire_lock(ptr noundef %69)
  %71 = icmp ne i32 %70, 0
  br i1 %71, label %1274, label %74

72:                                               ; preds = %62
  br i1 false, label %1274, label %74

73:                                               ; preds = %53
  br i1 false, label %1274, label %74

74:                                               ; preds = %73, %72, %67
  %75 = load ptr, ptr %6, align 8, !tbaa !5
  %76 = load ptr, ptr %5, align 8, !tbaa !5
  call void @do_check_inuse_chunk(ptr noundef %75, ptr noundef %76)
  %77 = load ptr, ptr %5, align 8, !tbaa !5
  %78 = load ptr, ptr %6, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.malloc_state, ptr %78, i32 0, i32 4
  %80 = load ptr, ptr %79, align 8, !tbaa !14
  %81 = icmp uge ptr %77, %80
  br i1 %81, label %82, label %88

82:                                               ; preds = %74
  %83 = load ptr, ptr %5, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.malloc_chunk, ptr %83, i32 0, i32 1
  %85 = load i64, ptr %84, align 8, !tbaa !15
  %86 = and i64 %85, 3
  %87 = icmp ne i64 %86, 1
  br label %88

88:                                               ; preds = %82, %74
  %89 = phi i1 [ false, %74 ], [ %87, %82 ]
  %90 = zext i1 %89 to i32
  %91 = sext i32 %90 to i64
  %92 = call i64 @llvm.expect.i64(i64 %91, i64 1)
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %94, label %1262

94:                                               ; preds = %88
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %95 = load ptr, ptr %5, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.malloc_chunk, ptr %95, i32 0, i32 1
  %97 = load i64, ptr %96, align 8, !tbaa !15
  %98 = and i64 %97, -8
  store i64 %98, ptr %7, align 8, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #6
  %99 = load ptr, ptr %5, align 8, !tbaa !5
  %100 = load i64, ptr %7, align 8, !tbaa !17
  %101 = getelementptr inbounds i8, ptr %99, i64 %100
  store ptr %101, ptr %8, align 8, !tbaa !5
  %102 = load ptr, ptr %5, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.malloc_chunk, ptr %102, i32 0, i32 1
  %104 = load i64, ptr %103, align 8, !tbaa !15
  %105 = and i64 %104, 1
  %106 = icmp ne i64 %105, 0
  br i1 %106, label %536, label %107

107:                                              ; preds = %94
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  %108 = load ptr, ptr %5, align 8, !tbaa !5
  %109 = getelementptr inbounds %struct.malloc_chunk, ptr %108, i32 0, i32 0
  %110 = load i64, ptr %109, align 8, !tbaa !18
  store i64 %110, ptr %9, align 8, !tbaa !17
  %111 = load ptr, ptr %5, align 8, !tbaa !5
  %112 = getelementptr inbounds %struct.malloc_chunk, ptr %111, i32 0, i32 1
  %113 = load i64, ptr %112, align 8, !tbaa !15
  %114 = and i64 %113, 3
  %115 = icmp eq i64 %114, 0
  br i1 %115, label %116, label %135

116:                                              ; preds = %107
  %117 = load i64, ptr %9, align 8, !tbaa !17
  %118 = add i64 %117, 32
  %119 = load i64, ptr %7, align 8, !tbaa !17
  %120 = add i64 %119, %118
  store i64 %120, ptr %7, align 8, !tbaa !17
  %121 = load ptr, ptr %5, align 8, !tbaa !5
  %122 = load i64, ptr %9, align 8, !tbaa !17
  %123 = sub i64 0, %122
  %124 = getelementptr inbounds i8, ptr %121, i64 %123
  %125 = load i64, ptr %7, align 8, !tbaa !17
  %126 = call i32 @munmap(ptr noundef %124, i64 noundef %125) #6
  %127 = icmp eq i32 %126, 0
  br i1 %127, label %128, label %134

128:                                              ; preds = %116
  %129 = load i64, ptr %7, align 8, !tbaa !17
  %130 = load ptr, ptr %6, align 8, !tbaa !5
  %131 = getelementptr inbounds %struct.malloc_state, ptr %130, i32 0, i32 12
  %132 = load i64, ptr %131, align 8, !tbaa !19
  %133 = sub i64 %132, %129
  store i64 %133, ptr %131, align 8, !tbaa !19
  br label %134

134:                                              ; preds = %128, %116
  store i32 2, ptr %23, align 4
  br label %533

135:                                              ; preds = %107
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #6
  %136 = load ptr, ptr %5, align 8, !tbaa !5
  %137 = load i64, ptr %9, align 8, !tbaa !17
  %138 = sub i64 0, %137
  %139 = getelementptr inbounds i8, ptr %136, i64 %138
  store ptr %139, ptr %10, align 8, !tbaa !5
  %140 = load i64, ptr %9, align 8, !tbaa !17
  %141 = load i64, ptr %7, align 8, !tbaa !17
  %142 = add i64 %141, %140
  store i64 %142, ptr %7, align 8, !tbaa !17
  %143 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %143, ptr %5, align 8, !tbaa !5
  %144 = load ptr, ptr %10, align 8, !tbaa !5
  %145 = load ptr, ptr %6, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct.malloc_state, ptr %145, i32 0, i32 4
  %147 = load ptr, ptr %146, align 8, !tbaa !14
  %148 = icmp uge ptr %144, %147
  %149 = zext i1 %148 to i32
  %150 = sext i32 %149 to i64
  %151 = call i64 @llvm.expect.i64(i64 %150, i64 1)
  %152 = icmp ne i64 %151, 0
  br i1 %152, label %153, label %527

153:                                              ; preds = %135
  %154 = load ptr, ptr %5, align 8, !tbaa !5
  %155 = load ptr, ptr %6, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.malloc_state, ptr %155, i32 0, i32 5
  %157 = load ptr, ptr %156, align 8, !tbaa !20
  %158 = icmp ne ptr %154, %157
  br i1 %158, label %159, label %502

159:                                              ; preds = %153
  %160 = load i64, ptr %9, align 8, !tbaa !17
  %161 = lshr i64 %160, 3
  %162 = icmp ult i64 %161, 32
  br i1 %162, label %163, label %274

163:                                              ; preds = %159
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  %164 = load ptr, ptr %5, align 8, !tbaa !5
  %165 = getelementptr inbounds %struct.malloc_chunk, ptr %164, i32 0, i32 2
  %166 = load ptr, ptr %165, align 8, !tbaa !21
  store ptr %166, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %167 = load ptr, ptr %5, align 8, !tbaa !5
  %168 = getelementptr inbounds %struct.malloc_chunk, ptr %167, i32 0, i32 3
  %169 = load ptr, ptr %168, align 8, !tbaa !22
  store ptr %169, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  %170 = load i64, ptr %9, align 8, !tbaa !17
  %171 = lshr i64 %170, 3
  %172 = trunc i64 %171 to i32
  store i32 %172, ptr %13, align 4, !tbaa !23
  %173 = load ptr, ptr %5, align 8, !tbaa !5
  %174 = load ptr, ptr %12, align 8, !tbaa !5
  %175 = icmp ne ptr %173, %174
  br i1 %175, label %177, label %176

176:                                              ; preds = %163
  call void @abort() #7
  unreachable

177:                                              ; preds = %163
  %178 = load ptr, ptr %5, align 8, !tbaa !5
  %179 = load ptr, ptr %11, align 8, !tbaa !5
  %180 = icmp ne ptr %178, %179
  br i1 %180, label %182, label %181

181:                                              ; preds = %177
  call void @abort() #7
  unreachable

182:                                              ; preds = %177
  %183 = load ptr, ptr %5, align 8, !tbaa !5
  %184 = getelementptr inbounds %struct.malloc_chunk, ptr %183, i32 0, i32 1
  %185 = load i64, ptr %184, align 8, !tbaa !15
  %186 = and i64 %185, -8
  %187 = load i32, ptr %13, align 4, !tbaa !23
  %188 = shl i32 %187, 3
  %189 = zext i32 %188 to i64
  %190 = icmp eq i64 %186, %189
  br i1 %190, label %192, label %191

191:                                              ; preds = %182
  call void @abort() #7
  unreachable

192:                                              ; preds = %182
  %193 = load ptr, ptr %11, align 8, !tbaa !5
  %194 = load ptr, ptr %6, align 8, !tbaa !5
  %195 = getelementptr inbounds %struct.malloc_state, ptr %194, i32 0, i32 10
  %196 = load i32, ptr %13, align 4, !tbaa !23
  %197 = shl i32 %196, 1
  %198 = zext i32 %197 to i64
  %199 = getelementptr inbounds [66 x ptr], ptr %195, i64 0, i64 %198
  %200 = icmp eq ptr %193, %199
  br i1 %200, label %215, label %201

201:                                              ; preds = %192
  %202 = load ptr, ptr %11, align 8, !tbaa !5
  %203 = load ptr, ptr %6, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.malloc_state, ptr %203, i32 0, i32 4
  %205 = load ptr, ptr %204, align 8, !tbaa !14
  %206 = icmp uge ptr %202, %205
  br i1 %206, label %207, label %213

207:                                              ; preds = %201
  %208 = load ptr, ptr %11, align 8, !tbaa !5
  %209 = getelementptr inbounds %struct.malloc_chunk, ptr %208, i32 0, i32 3
  %210 = load ptr, ptr %209, align 8, !tbaa !22
  %211 = load ptr, ptr %5, align 8, !tbaa !5
  %212 = icmp eq ptr %210, %211
  br label %213

213:                                              ; preds = %207, %201
  %214 = phi i1 [ false, %201 ], [ %212, %207 ]
  br label %215

215:                                              ; preds = %213, %192
  %216 = phi i1 [ true, %192 ], [ %214, %213 ]
  %217 = zext i1 %216 to i32
  %218 = sext i32 %217 to i64
  %219 = call i64 @llvm.expect.i64(i64 %218, i64 1)
  %220 = icmp ne i64 %219, 0
  br i1 %220, label %221, label %272

221:                                              ; preds = %215
  %222 = load ptr, ptr %12, align 8, !tbaa !5
  %223 = load ptr, ptr %11, align 8, !tbaa !5
  %224 = icmp eq ptr %222, %223
  br i1 %224, label %225, label %233

225:                                              ; preds = %221
  %226 = load i32, ptr %13, align 4, !tbaa !23
  %227 = shl i32 1, %226
  %228 = xor i32 %227, -1
  %229 = load ptr, ptr %6, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.malloc_state, ptr %229, i32 0, i32 0
  %231 = load i32, ptr %230, align 8, !tbaa !24
  %232 = and i32 %231, %228
  store i32 %232, ptr %230, align 8, !tbaa !24
  br label %271

233:                                              ; preds = %221
  %234 = load ptr, ptr %12, align 8, !tbaa !5
  %235 = load ptr, ptr %6, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.malloc_state, ptr %235, i32 0, i32 10
  %237 = load i32, ptr %13, align 4, !tbaa !23
  %238 = shl i32 %237, 1
  %239 = zext i32 %238 to i64
  %240 = getelementptr inbounds [66 x ptr], ptr %236, i64 0, i64 %239
  %241 = icmp eq ptr %234, %240
  br i1 %241, label %256, label %242

242:                                              ; preds = %233
  %243 = load ptr, ptr %12, align 8, !tbaa !5
  %244 = load ptr, ptr %6, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.malloc_state, ptr %244, i32 0, i32 4
  %246 = load ptr, ptr %245, align 8, !tbaa !14
  %247 = icmp uge ptr %243, %246
  br i1 %247, label %248, label %254

248:                                              ; preds = %242
  %249 = load ptr, ptr %12, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.malloc_chunk, ptr %249, i32 0, i32 2
  %251 = load ptr, ptr %250, align 8, !tbaa !21
  %252 = load ptr, ptr %5, align 8, !tbaa !5
  %253 = icmp eq ptr %251, %252
  br label %254

254:                                              ; preds = %248, %242
  %255 = phi i1 [ false, %242 ], [ %253, %248 ]
  br label %256

256:                                              ; preds = %254, %233
  %257 = phi i1 [ true, %233 ], [ %255, %254 ]
  %258 = zext i1 %257 to i32
  %259 = sext i32 %258 to i64
  %260 = call i64 @llvm.expect.i64(i64 %259, i64 1)
  %261 = icmp ne i64 %260, 0
  br i1 %261, label %262, label %269

262:                                              ; preds = %256
  %263 = load ptr, ptr %12, align 8, !tbaa !5
  %264 = load ptr, ptr %11, align 8, !tbaa !5
  %265 = getelementptr inbounds %struct.malloc_chunk, ptr %264, i32 0, i32 3
  store ptr %263, ptr %265, align 8, !tbaa !22
  %266 = load ptr, ptr %11, align 8, !tbaa !5
  %267 = load ptr, ptr %12, align 8, !tbaa !5
  %268 = getelementptr inbounds %struct.malloc_chunk, ptr %267, i32 0, i32 2
  store ptr %266, ptr %268, align 8, !tbaa !21
  br label %270

269:                                              ; preds = %256
  call void @abort() #7
  unreachable

270:                                              ; preds = %262
  br label %271

271:                                              ; preds = %270, %225
  br label %273

272:                                              ; preds = %215
  call void @abort() #7
  unreachable

273:                                              ; preds = %271
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #6
  br label %501

274:                                              ; preds = %159
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #6
  %275 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %275, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  %276 = load ptr, ptr %14, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %276, i32 0, i32 5
  %278 = load ptr, ptr %277, align 8, !tbaa !25
  store ptr %278, ptr %15, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #6
  %279 = load ptr, ptr %14, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %279, i32 0, i32 3
  %281 = load ptr, ptr %280, align 8, !tbaa !27
  %282 = load ptr, ptr %14, align 8, !tbaa !5
  %283 = icmp ne ptr %281, %282
  br i1 %283, label %284, label %323

284:                                              ; preds = %274
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  %285 = load ptr, ptr %14, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %285, i32 0, i32 2
  %287 = load ptr, ptr %286, align 8, !tbaa !28
  store ptr %287, ptr %17, align 8, !tbaa !5
  %288 = load ptr, ptr %14, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %288, i32 0, i32 3
  %290 = load ptr, ptr %289, align 8, !tbaa !27
  store ptr %290, ptr %16, align 8, !tbaa !5
  %291 = load ptr, ptr %17, align 8, !tbaa !5
  %292 = load ptr, ptr %6, align 8, !tbaa !5
  %293 = getelementptr inbounds %struct.malloc_state, ptr %292, i32 0, i32 4
  %294 = load ptr, ptr %293, align 8, !tbaa !14
  %295 = icmp uge ptr %291, %294
  br i1 %295, label %296, label %308

296:                                              ; preds = %284
  %297 = load ptr, ptr %17, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %297, i32 0, i32 3
  %299 = load ptr, ptr %298, align 8, !tbaa !27
  %300 = load ptr, ptr %14, align 8, !tbaa !5
  %301 = icmp eq ptr %299, %300
  br i1 %301, label %302, label %308

302:                                              ; preds = %296
  %303 = load ptr, ptr %16, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %303, i32 0, i32 2
  %305 = load ptr, ptr %304, align 8, !tbaa !28
  %306 = load ptr, ptr %14, align 8, !tbaa !5
  %307 = icmp eq ptr %305, %306
  br label %308

308:                                              ; preds = %302, %296, %284
  %309 = phi i1 [ false, %296 ], [ false, %284 ], [ %307, %302 ]
  %310 = zext i1 %309 to i32
  %311 = sext i32 %310 to i64
  %312 = call i64 @llvm.expect.i64(i64 %311, i64 1)
  %313 = icmp ne i64 %312, 0
  br i1 %313, label %314, label %321

314:                                              ; preds = %308
  %315 = load ptr, ptr %16, align 8, !tbaa !5
  %316 = load ptr, ptr %17, align 8, !tbaa !5
  %317 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %316, i32 0, i32 3
  store ptr %315, ptr %317, align 8, !tbaa !27
  %318 = load ptr, ptr %17, align 8, !tbaa !5
  %319 = load ptr, ptr %16, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %319, i32 0, i32 2
  store ptr %318, ptr %320, align 8, !tbaa !28
  br label %322

321:                                              ; preds = %308
  call void @abort() #7
  unreachable

322:                                              ; preds = %314
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  br label %368

323:                                              ; preds = %274
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  %324 = load ptr, ptr %14, align 8, !tbaa !5
  %325 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %324, i32 0, i32 4
  %326 = getelementptr inbounds [2 x ptr], ptr %325, i64 0, i64 1
  store ptr %326, ptr %18, align 8, !tbaa !5
  %327 = load ptr, ptr %326, align 8, !tbaa !5
  store ptr %327, ptr %16, align 8, !tbaa !5
  %328 = icmp ne ptr %327, null
  br i1 %328, label %335, label %329

329:                                              ; preds = %323
  %330 = load ptr, ptr %14, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %330, i32 0, i32 4
  %332 = getelementptr inbounds [2 x ptr], ptr %331, i64 0, i64 0
  store ptr %332, ptr %18, align 8, !tbaa !5
  %333 = load ptr, ptr %332, align 8, !tbaa !5
  store ptr %333, ptr %16, align 8, !tbaa !5
  %334 = icmp ne ptr %333, null
  br i1 %334, label %335, label %367

335:                                              ; preds = %329, %323
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  br label %336

336:                                              ; preds = %350, %335
  %337 = load ptr, ptr %16, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %337, i32 0, i32 4
  %339 = getelementptr inbounds [2 x ptr], ptr %338, i64 0, i64 1
  store ptr %339, ptr %19, align 8, !tbaa !5
  %340 = load ptr, ptr %339, align 8, !tbaa !5
  %341 = icmp ne ptr %340, null
  br i1 %341, label %348, label %342

342:                                              ; preds = %336
  %343 = load ptr, ptr %16, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %343, i32 0, i32 4
  %345 = getelementptr inbounds [2 x ptr], ptr %344, i64 0, i64 0
  store ptr %345, ptr %19, align 8, !tbaa !5
  %346 = load ptr, ptr %345, align 8, !tbaa !5
  %347 = icmp ne ptr %346, null
  br label %348

348:                                              ; preds = %342, %336
  %349 = phi i1 [ true, %336 ], [ %347, %342 ]
  br i1 %349, label %350, label %353

350:                                              ; preds = %348
  %351 = load ptr, ptr %19, align 8, !tbaa !5
  store ptr %351, ptr %18, align 8, !tbaa !5
  %352 = load ptr, ptr %351, align 8, !tbaa !5
  store ptr %352, ptr %16, align 8, !tbaa !5
  br label %336, !llvm.loop !29

353:                                              ; preds = %348
  %354 = load ptr, ptr %18, align 8, !tbaa !5
  %355 = load ptr, ptr %6, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.malloc_state, ptr %355, i32 0, i32 4
  %357 = load ptr, ptr %356, align 8, !tbaa !14
  %358 = icmp uge ptr %354, %357
  %359 = zext i1 %358 to i32
  %360 = sext i32 %359 to i64
  %361 = call i64 @llvm.expect.i64(i64 %360, i64 1)
  %362 = icmp ne i64 %361, 0
  br i1 %362, label %363, label %365

363:                                              ; preds = %353
  %364 = load ptr, ptr %18, align 8, !tbaa !5
  store ptr null, ptr %364, align 8, !tbaa !5
  br label %366

365:                                              ; preds = %353
  call void @abort() #7
  unreachable

366:                                              ; preds = %363
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  br label %367

367:                                              ; preds = %366, %329
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  br label %368

368:                                              ; preds = %367, %322
  %369 = load ptr, ptr %15, align 8, !tbaa !5
  %370 = icmp ne ptr %369, null
  br i1 %370, label %371, label %500

371:                                              ; preds = %368
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #6
  %372 = load ptr, ptr %6, align 8, !tbaa !5
  %373 = getelementptr inbounds %struct.malloc_state, ptr %372, i32 0, i32 11
  %374 = load ptr, ptr %14, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %374, i32 0, i32 6
  %376 = load i32, ptr %375, align 8, !tbaa !31
  %377 = zext i32 %376 to i64
  %378 = getelementptr inbounds [32 x ptr], ptr %373, i64 0, i64 %377
  store ptr %378, ptr %20, align 8, !tbaa !5
  %379 = load ptr, ptr %14, align 8, !tbaa !5
  %380 = load ptr, ptr %20, align 8, !tbaa !5
  %381 = load ptr, ptr %380, align 8, !tbaa !5
  %382 = icmp eq ptr %379, %381
  br i1 %382, label %383, label %398

383:                                              ; preds = %371
  %384 = load ptr, ptr %16, align 8, !tbaa !5
  %385 = load ptr, ptr %20, align 8, !tbaa !5
  store ptr %384, ptr %385, align 8, !tbaa !5
  %386 = icmp eq ptr %384, null
  br i1 %386, label %387, label %397

387:                                              ; preds = %383
  %388 = load ptr, ptr %14, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %388, i32 0, i32 6
  %390 = load i32, ptr %389, align 8, !tbaa !31
  %391 = shl i32 1, %390
  %392 = xor i32 %391, -1
  %393 = load ptr, ptr %6, align 8, !tbaa !5
  %394 = getelementptr inbounds %struct.malloc_state, ptr %393, i32 0, i32 1
  %395 = load i32, ptr %394, align 4, !tbaa !32
  %396 = and i32 %395, %392
  store i32 %396, ptr %394, align 4, !tbaa !32
  br label %397

397:                                              ; preds = %387, %383
  br label %428

398:                                              ; preds = %371
  %399 = load ptr, ptr %15, align 8, !tbaa !5
  %400 = load ptr, ptr %6, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.malloc_state, ptr %400, i32 0, i32 4
  %402 = load ptr, ptr %401, align 8, !tbaa !14
  %403 = icmp uge ptr %399, %402
  %404 = zext i1 %403 to i32
  %405 = sext i32 %404 to i64
  %406 = call i64 @llvm.expect.i64(i64 %405, i64 1)
  %407 = icmp ne i64 %406, 0
  br i1 %407, label %408, label %426

408:                                              ; preds = %398
  %409 = load ptr, ptr %15, align 8, !tbaa !5
  %410 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %409, i32 0, i32 4
  %411 = getelementptr inbounds [2 x ptr], ptr %410, i64 0, i64 0
  %412 = load ptr, ptr %411, align 8, !tbaa !5
  %413 = load ptr, ptr %14, align 8, !tbaa !5
  %414 = icmp eq ptr %412, %413
  br i1 %414, label %415, label %420

415:                                              ; preds = %408
  %416 = load ptr, ptr %16, align 8, !tbaa !5
  %417 = load ptr, ptr %15, align 8, !tbaa !5
  %418 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %417, i32 0, i32 4
  %419 = getelementptr inbounds [2 x ptr], ptr %418, i64 0, i64 0
  store ptr %416, ptr %419, align 8, !tbaa !5
  br label %425

420:                                              ; preds = %408
  %421 = load ptr, ptr %16, align 8, !tbaa !5
  %422 = load ptr, ptr %15, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %422, i32 0, i32 4
  %424 = getelementptr inbounds [2 x ptr], ptr %423, i64 0, i64 1
  store ptr %421, ptr %424, align 8, !tbaa !5
  br label %425

425:                                              ; preds = %420, %415
  br label %427

426:                                              ; preds = %398
  call void @abort() #7
  unreachable

427:                                              ; preds = %425
  br label %428

428:                                              ; preds = %427, %397
  %429 = load ptr, ptr %16, align 8, !tbaa !5
  %430 = icmp ne ptr %429, null
  br i1 %430, label %431, label %499

431:                                              ; preds = %428
  %432 = load ptr, ptr %16, align 8, !tbaa !5
  %433 = load ptr, ptr %6, align 8, !tbaa !5
  %434 = getelementptr inbounds %struct.malloc_state, ptr %433, i32 0, i32 4
  %435 = load ptr, ptr %434, align 8, !tbaa !14
  %436 = icmp uge ptr %432, %435
  %437 = zext i1 %436 to i32
  %438 = sext i32 %437 to i64
  %439 = call i64 @llvm.expect.i64(i64 %438, i64 1)
  %440 = icmp ne i64 %439, 0
  br i1 %440, label %441, label %497

441:                                              ; preds = %431
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  %442 = load ptr, ptr %15, align 8, !tbaa !5
  %443 = load ptr, ptr %16, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %443, i32 0, i32 5
  store ptr %442, ptr %444, align 8, !tbaa !25
  %445 = load ptr, ptr %14, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %445, i32 0, i32 4
  %447 = getelementptr inbounds [2 x ptr], ptr %446, i64 0, i64 0
  %448 = load ptr, ptr %447, align 8, !tbaa !5
  store ptr %448, ptr %21, align 8, !tbaa !5
  %449 = icmp ne ptr %448, null
  br i1 %449, label %450, label %470

450:                                              ; preds = %441
  %451 = load ptr, ptr %21, align 8, !tbaa !5
  %452 = load ptr, ptr %6, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.malloc_state, ptr %452, i32 0, i32 4
  %454 = load ptr, ptr %453, align 8, !tbaa !14
  %455 = icmp uge ptr %451, %454
  %456 = zext i1 %455 to i32
  %457 = sext i32 %456 to i64
  %458 = call i64 @llvm.expect.i64(i64 %457, i64 1)
  %459 = icmp ne i64 %458, 0
  br i1 %459, label %460, label %468

460:                                              ; preds = %450
  %461 = load ptr, ptr %21, align 8, !tbaa !5
  %462 = load ptr, ptr %16, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %462, i32 0, i32 4
  %464 = getelementptr inbounds [2 x ptr], ptr %463, i64 0, i64 0
  store ptr %461, ptr %464, align 8, !tbaa !5
  %465 = load ptr, ptr %16, align 8, !tbaa !5
  %466 = load ptr, ptr %21, align 8, !tbaa !5
  %467 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %466, i32 0, i32 5
  store ptr %465, ptr %467, align 8, !tbaa !25
  br label %469

468:                                              ; preds = %450
  call void @abort() #7
  unreachable

469:                                              ; preds = %460
  br label %470

470:                                              ; preds = %469, %441
  %471 = load ptr, ptr %14, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %471, i32 0, i32 4
  %473 = getelementptr inbounds [2 x ptr], ptr %472, i64 0, i64 1
  %474 = load ptr, ptr %473, align 8, !tbaa !5
  store ptr %474, ptr %22, align 8, !tbaa !5
  %475 = icmp ne ptr %474, null
  br i1 %475, label %476, label %496

476:                                              ; preds = %470
  %477 = load ptr, ptr %22, align 8, !tbaa !5
  %478 = load ptr, ptr %6, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.malloc_state, ptr %478, i32 0, i32 4
  %480 = load ptr, ptr %479, align 8, !tbaa !14
  %481 = icmp uge ptr %477, %480
  %482 = zext i1 %481 to i32
  %483 = sext i32 %482 to i64
  %484 = call i64 @llvm.expect.i64(i64 %483, i64 1)
  %485 = icmp ne i64 %484, 0
  br i1 %485, label %486, label %494

486:                                              ; preds = %476
  %487 = load ptr, ptr %22, align 8, !tbaa !5
  %488 = load ptr, ptr %16, align 8, !tbaa !5
  %489 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %488, i32 0, i32 4
  %490 = getelementptr inbounds [2 x ptr], ptr %489, i64 0, i64 1
  store ptr %487, ptr %490, align 8, !tbaa !5
  %491 = load ptr, ptr %16, align 8, !tbaa !5
  %492 = load ptr, ptr %22, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %492, i32 0, i32 5
  store ptr %491, ptr %493, align 8, !tbaa !25
  br label %495

494:                                              ; preds = %476
  call void @abort() #7
  unreachable

495:                                              ; preds = %486
  br label %496

496:                                              ; preds = %495, %470
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  br label %498

497:                                              ; preds = %431
  call void @abort() #7
  unreachable

498:                                              ; preds = %496
  br label %499

499:                                              ; preds = %498, %428
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #6
  br label %500

500:                                              ; preds = %499, %368
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #6
  br label %501

501:                                              ; preds = %500, %273
  br label %526

502:                                              ; preds = %153
  %503 = load ptr, ptr %8, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct.malloc_chunk, ptr %503, i32 0, i32 1
  %505 = load i64, ptr %504, align 8, !tbaa !15
  %506 = and i64 %505, 3
  %507 = icmp eq i64 %506, 3
  br i1 %507, label %508, label %525

508:                                              ; preds = %502
  %509 = load i64, ptr %7, align 8, !tbaa !17
  %510 = load ptr, ptr %6, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.malloc_state, ptr %510, i32 0, i32 2
  store i64 %509, ptr %511, align 8, !tbaa !33
  %512 = load ptr, ptr %8, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.malloc_chunk, ptr %512, i32 0, i32 1
  %514 = load i64, ptr %513, align 8, !tbaa !15
  %515 = and i64 %514, -2
  store i64 %515, ptr %513, align 8, !tbaa !15
  %516 = load i64, ptr %7, align 8, !tbaa !17
  %517 = or i64 %516, 1
  %518 = load ptr, ptr %5, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.malloc_chunk, ptr %518, i32 0, i32 1
  store i64 %517, ptr %519, align 8, !tbaa !15
  %520 = load i64, ptr %7, align 8, !tbaa !17
  %521 = load ptr, ptr %5, align 8, !tbaa !5
  %522 = load i64, ptr %7, align 8, !tbaa !17
  %523 = getelementptr inbounds i8, ptr %521, i64 %522
  %524 = getelementptr inbounds %struct.malloc_chunk, ptr %523, i32 0, i32 0
  store i64 %520, ptr %524, align 8, !tbaa !18
  store i32 2, ptr %23, align 4
  br label %529

525:                                              ; preds = %502
  br label %526

526:                                              ; preds = %525, %501
  br label %528

527:                                              ; preds = %135
  store i32 5, ptr %23, align 4
  br label %529

528:                                              ; preds = %526
  store i32 0, ptr %23, align 4
  br label %529

529:                                              ; preds = %528, %527, %508
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #6
  %530 = load i32, ptr %23, align 4
  switch i32 %530, label %533 [
    i32 0, label %531
  ]

531:                                              ; preds = %529
  br label %532

532:                                              ; preds = %531
  store i32 0, ptr %23, align 4
  br label %533

533:                                              ; preds = %532, %529, %134
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #6
  %534 = load i32, ptr %23, align 4
  switch i32 %534, label %1259 [
    i32 0, label %535
  ]

535:                                              ; preds = %533
  br label %536

536:                                              ; preds = %535, %94
  %537 = load ptr, ptr %5, align 8, !tbaa !5
  %538 = load ptr, ptr %8, align 8, !tbaa !5
  %539 = icmp ult ptr %537, %538
  br i1 %539, label %540, label %546

540:                                              ; preds = %536
  %541 = load ptr, ptr %8, align 8, !tbaa !5
  %542 = getelementptr inbounds %struct.malloc_chunk, ptr %541, i32 0, i32 1
  %543 = load i64, ptr %542, align 8, !tbaa !15
  %544 = and i64 %543, 1
  %545 = icmp ne i64 %544, 0
  br label %546

546:                                              ; preds = %540, %536
  %547 = phi i1 [ false, %536 ], [ %545, %540 ]
  %548 = zext i1 %547 to i32
  %549 = sext i32 %548 to i64
  %550 = call i64 @llvm.expect.i64(i64 %549, i64 1)
  %551 = icmp ne i64 %550, 0
  br i1 %551, label %552, label %1258

552:                                              ; preds = %546
  %553 = load ptr, ptr %8, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.malloc_chunk, ptr %553, i32 0, i32 1
  %555 = load i64, ptr %554, align 8, !tbaa !15
  %556 = and i64 %555, 2
  %557 = icmp ne i64 %556, 0
  br i1 %557, label %995, label %558

558:                                              ; preds = %552
  %559 = load ptr, ptr %8, align 8, !tbaa !5
  %560 = load ptr, ptr %6, align 8, !tbaa !5
  %561 = getelementptr inbounds %struct.malloc_state, ptr %560, i32 0, i32 6
  %562 = load ptr, ptr %561, align 8, !tbaa !34
  %563 = icmp eq ptr %559, %562
  br i1 %563, label %564, label %597

564:                                              ; preds = %558
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  %565 = load i64, ptr %7, align 8, !tbaa !17
  %566 = load ptr, ptr %6, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.malloc_state, ptr %566, i32 0, i32 3
  %568 = load i64, ptr %567, align 8, !tbaa !35
  %569 = add i64 %568, %565
  store i64 %569, ptr %567, align 8, !tbaa !35
  store i64 %569, ptr %24, align 8, !tbaa !17
  %570 = load ptr, ptr %5, align 8, !tbaa !5
  %571 = load ptr, ptr %6, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.malloc_state, ptr %571, i32 0, i32 6
  store ptr %570, ptr %572, align 8, !tbaa !34
  %573 = load i64, ptr %24, align 8, !tbaa !17
  %574 = or i64 %573, 1
  %575 = load ptr, ptr %5, align 8, !tbaa !5
  %576 = getelementptr inbounds %struct.malloc_chunk, ptr %575, i32 0, i32 1
  store i64 %574, ptr %576, align 8, !tbaa !15
  %577 = load ptr, ptr %5, align 8, !tbaa !5
  %578 = load ptr, ptr %6, align 8, !tbaa !5
  %579 = getelementptr inbounds %struct.malloc_state, ptr %578, i32 0, i32 5
  %580 = load ptr, ptr %579, align 8, !tbaa !20
  %581 = icmp eq ptr %577, %580
  br i1 %581, label %582, label %587

582:                                              ; preds = %564
  %583 = load ptr, ptr %6, align 8, !tbaa !5
  %584 = getelementptr inbounds %struct.malloc_state, ptr %583, i32 0, i32 5
  store ptr null, ptr %584, align 8, !tbaa !20
  %585 = load ptr, ptr %6, align 8, !tbaa !5
  %586 = getelementptr inbounds %struct.malloc_state, ptr %585, i32 0, i32 2
  store i64 0, ptr %586, align 8, !tbaa !33
  br label %587

587:                                              ; preds = %582, %564
  %588 = load i64, ptr %24, align 8, !tbaa !17
  %589 = load ptr, ptr %6, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.malloc_state, ptr %589, i32 0, i32 7
  %591 = load i64, ptr %590, align 8, !tbaa !36
  %592 = icmp ugt i64 %588, %591
  br i1 %592, label %593, label %596

593:                                              ; preds = %587
  %594 = load ptr, ptr %6, align 8, !tbaa !5
  %595 = call i32 @sys_trim(ptr noundef %594, i64 noundef 0)
  br label %596

596:                                              ; preds = %593, %587
  store i32 2, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  br label %1259

597:                                              ; preds = %558
  %598 = load ptr, ptr %8, align 8, !tbaa !5
  %599 = load ptr, ptr %6, align 8, !tbaa !5
  %600 = getelementptr inbounds %struct.malloc_state, ptr %599, i32 0, i32 5
  %601 = load ptr, ptr %600, align 8, !tbaa !20
  %602 = icmp eq ptr %598, %601
  br i1 %602, label %603, label %621

603:                                              ; preds = %597
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %604 = load i64, ptr %7, align 8, !tbaa !17
  %605 = load ptr, ptr %6, align 8, !tbaa !5
  %606 = getelementptr inbounds %struct.malloc_state, ptr %605, i32 0, i32 2
  %607 = load i64, ptr %606, align 8, !tbaa !33
  %608 = add i64 %607, %604
  store i64 %608, ptr %606, align 8, !tbaa !33
  store i64 %608, ptr %25, align 8, !tbaa !17
  %609 = load ptr, ptr %5, align 8, !tbaa !5
  %610 = load ptr, ptr %6, align 8, !tbaa !5
  %611 = getelementptr inbounds %struct.malloc_state, ptr %610, i32 0, i32 5
  store ptr %609, ptr %611, align 8, !tbaa !20
  %612 = load i64, ptr %25, align 8, !tbaa !17
  %613 = or i64 %612, 1
  %614 = load ptr, ptr %5, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.malloc_chunk, ptr %614, i32 0, i32 1
  store i64 %613, ptr %615, align 8, !tbaa !15
  %616 = load i64, ptr %25, align 8, !tbaa !17
  %617 = load ptr, ptr %5, align 8, !tbaa !5
  %618 = load i64, ptr %25, align 8, !tbaa !17
  %619 = getelementptr inbounds i8, ptr %617, i64 %618
  %620 = getelementptr inbounds %struct.malloc_chunk, ptr %619, i32 0, i32 0
  store i64 %616, ptr %620, align 8, !tbaa !18
  store i32 2, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  br label %1259

621:                                              ; preds = %597
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #6
  %622 = load ptr, ptr %8, align 8, !tbaa !5
  %623 = getelementptr inbounds %struct.malloc_chunk, ptr %622, i32 0, i32 1
  %624 = load i64, ptr %623, align 8, !tbaa !15
  %625 = and i64 %624, -8
  store i64 %625, ptr %26, align 8, !tbaa !17
  %626 = load i64, ptr %26, align 8, !tbaa !17
  %627 = load i64, ptr %7, align 8, !tbaa !17
  %628 = add i64 %627, %626
  store i64 %628, ptr %7, align 8, !tbaa !17
  %629 = load i64, ptr %26, align 8, !tbaa !17
  %630 = lshr i64 %629, 3
  %631 = icmp ult i64 %630, 32
  br i1 %631, label %632, label %743

632:                                              ; preds = %621
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  %633 = load ptr, ptr %8, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.malloc_chunk, ptr %633, i32 0, i32 2
  %635 = load ptr, ptr %634, align 8, !tbaa !21
  store ptr %635, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  %636 = load ptr, ptr %8, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.malloc_chunk, ptr %636, i32 0, i32 3
  %638 = load ptr, ptr %637, align 8, !tbaa !22
  store ptr %638, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #6
  %639 = load i64, ptr %26, align 8, !tbaa !17
  %640 = lshr i64 %639, 3
  %641 = trunc i64 %640 to i32
  store i32 %641, ptr %29, align 4, !tbaa !23
  %642 = load ptr, ptr %8, align 8, !tbaa !5
  %643 = load ptr, ptr %28, align 8, !tbaa !5
  %644 = icmp ne ptr %642, %643
  br i1 %644, label %646, label %645

645:                                              ; preds = %632
  call void @abort() #7
  unreachable

646:                                              ; preds = %632
  %647 = load ptr, ptr %8, align 8, !tbaa !5
  %648 = load ptr, ptr %27, align 8, !tbaa !5
  %649 = icmp ne ptr %647, %648
  br i1 %649, label %651, label %650

650:                                              ; preds = %646
  call void @abort() #7
  unreachable

651:                                              ; preds = %646
  %652 = load ptr, ptr %8, align 8, !tbaa !5
  %653 = getelementptr inbounds %struct.malloc_chunk, ptr %652, i32 0, i32 1
  %654 = load i64, ptr %653, align 8, !tbaa !15
  %655 = and i64 %654, -8
  %656 = load i32, ptr %29, align 4, !tbaa !23
  %657 = shl i32 %656, 3
  %658 = zext i32 %657 to i64
  %659 = icmp eq i64 %655, %658
  br i1 %659, label %661, label %660

660:                                              ; preds = %651
  call void @abort() #7
  unreachable

661:                                              ; preds = %651
  %662 = load ptr, ptr %27, align 8, !tbaa !5
  %663 = load ptr, ptr %6, align 8, !tbaa !5
  %664 = getelementptr inbounds %struct.malloc_state, ptr %663, i32 0, i32 10
  %665 = load i32, ptr %29, align 4, !tbaa !23
  %666 = shl i32 %665, 1
  %667 = zext i32 %666 to i64
  %668 = getelementptr inbounds [66 x ptr], ptr %664, i64 0, i64 %667
  %669 = icmp eq ptr %662, %668
  br i1 %669, label %684, label %670

670:                                              ; preds = %661
  %671 = load ptr, ptr %27, align 8, !tbaa !5
  %672 = load ptr, ptr %6, align 8, !tbaa !5
  %673 = getelementptr inbounds %struct.malloc_state, ptr %672, i32 0, i32 4
  %674 = load ptr, ptr %673, align 8, !tbaa !14
  %675 = icmp uge ptr %671, %674
  br i1 %675, label %676, label %682

676:                                              ; preds = %670
  %677 = load ptr, ptr %27, align 8, !tbaa !5
  %678 = getelementptr inbounds %struct.malloc_chunk, ptr %677, i32 0, i32 3
  %679 = load ptr, ptr %678, align 8, !tbaa !22
  %680 = load ptr, ptr %8, align 8, !tbaa !5
  %681 = icmp eq ptr %679, %680
  br label %682

682:                                              ; preds = %676, %670
  %683 = phi i1 [ false, %670 ], [ %681, %676 ]
  br label %684

684:                                              ; preds = %682, %661
  %685 = phi i1 [ true, %661 ], [ %683, %682 ]
  %686 = zext i1 %685 to i32
  %687 = sext i32 %686 to i64
  %688 = call i64 @llvm.expect.i64(i64 %687, i64 1)
  %689 = icmp ne i64 %688, 0
  br i1 %689, label %690, label %741

690:                                              ; preds = %684
  %691 = load ptr, ptr %28, align 8, !tbaa !5
  %692 = load ptr, ptr %27, align 8, !tbaa !5
  %693 = icmp eq ptr %691, %692
  br i1 %693, label %694, label %702

694:                                              ; preds = %690
  %695 = load i32, ptr %29, align 4, !tbaa !23
  %696 = shl i32 1, %695
  %697 = xor i32 %696, -1
  %698 = load ptr, ptr %6, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.malloc_state, ptr %698, i32 0, i32 0
  %700 = load i32, ptr %699, align 8, !tbaa !24
  %701 = and i32 %700, %697
  store i32 %701, ptr %699, align 8, !tbaa !24
  br label %740

702:                                              ; preds = %690
  %703 = load ptr, ptr %28, align 8, !tbaa !5
  %704 = load ptr, ptr %6, align 8, !tbaa !5
  %705 = getelementptr inbounds %struct.malloc_state, ptr %704, i32 0, i32 10
  %706 = load i32, ptr %29, align 4, !tbaa !23
  %707 = shl i32 %706, 1
  %708 = zext i32 %707 to i64
  %709 = getelementptr inbounds [66 x ptr], ptr %705, i64 0, i64 %708
  %710 = icmp eq ptr %703, %709
  br i1 %710, label %725, label %711

711:                                              ; preds = %702
  %712 = load ptr, ptr %28, align 8, !tbaa !5
  %713 = load ptr, ptr %6, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.malloc_state, ptr %713, i32 0, i32 4
  %715 = load ptr, ptr %714, align 8, !tbaa !14
  %716 = icmp uge ptr %712, %715
  br i1 %716, label %717, label %723

717:                                              ; preds = %711
  %718 = load ptr, ptr %28, align 8, !tbaa !5
  %719 = getelementptr inbounds %struct.malloc_chunk, ptr %718, i32 0, i32 2
  %720 = load ptr, ptr %719, align 8, !tbaa !21
  %721 = load ptr, ptr %8, align 8, !tbaa !5
  %722 = icmp eq ptr %720, %721
  br label %723

723:                                              ; preds = %717, %711
  %724 = phi i1 [ false, %711 ], [ %722, %717 ]
  br label %725

725:                                              ; preds = %723, %702
  %726 = phi i1 [ true, %702 ], [ %724, %723 ]
  %727 = zext i1 %726 to i32
  %728 = sext i32 %727 to i64
  %729 = call i64 @llvm.expect.i64(i64 %728, i64 1)
  %730 = icmp ne i64 %729, 0
  br i1 %730, label %731, label %738

731:                                              ; preds = %725
  %732 = load ptr, ptr %28, align 8, !tbaa !5
  %733 = load ptr, ptr %27, align 8, !tbaa !5
  %734 = getelementptr inbounds %struct.malloc_chunk, ptr %733, i32 0, i32 3
  store ptr %732, ptr %734, align 8, !tbaa !22
  %735 = load ptr, ptr %27, align 8, !tbaa !5
  %736 = load ptr, ptr %28, align 8, !tbaa !5
  %737 = getelementptr inbounds %struct.malloc_chunk, ptr %736, i32 0, i32 2
  store ptr %735, ptr %737, align 8, !tbaa !21
  br label %739

738:                                              ; preds = %725
  call void @abort() #7
  unreachable

739:                                              ; preds = %731
  br label %740

740:                                              ; preds = %739, %694
  br label %742

741:                                              ; preds = %684
  call void @abort() #7
  unreachable

742:                                              ; preds = %740
  call void @llvm.lifetime.end.p0(i64 4, 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
  br label %970

743:                                              ; preds = %621
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  %744 = load ptr, ptr %8, align 8, !tbaa !5
  store ptr %744, ptr %30, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  %745 = load ptr, ptr %30, align 8, !tbaa !5
  %746 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %745, i32 0, i32 5
  %747 = load ptr, ptr %746, align 8, !tbaa !25
  store ptr %747, ptr %31, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  %748 = load ptr, ptr %30, align 8, !tbaa !5
  %749 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %748, i32 0, i32 3
  %750 = load ptr, ptr %749, align 8, !tbaa !27
  %751 = load ptr, ptr %30, align 8, !tbaa !5
  %752 = icmp ne ptr %750, %751
  br i1 %752, label %753, label %792

753:                                              ; preds = %743
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %754 = load ptr, ptr %30, align 8, !tbaa !5
  %755 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %754, i32 0, i32 2
  %756 = load ptr, ptr %755, align 8, !tbaa !28
  store ptr %756, ptr %33, align 8, !tbaa !5
  %757 = load ptr, ptr %30, align 8, !tbaa !5
  %758 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %757, i32 0, i32 3
  %759 = load ptr, ptr %758, align 8, !tbaa !27
  store ptr %759, ptr %32, align 8, !tbaa !5
  %760 = load ptr, ptr %33, align 8, !tbaa !5
  %761 = load ptr, ptr %6, align 8, !tbaa !5
  %762 = getelementptr inbounds %struct.malloc_state, ptr %761, i32 0, i32 4
  %763 = load ptr, ptr %762, align 8, !tbaa !14
  %764 = icmp uge ptr %760, %763
  br i1 %764, label %765, label %777

765:                                              ; preds = %753
  %766 = load ptr, ptr %33, align 8, !tbaa !5
  %767 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %766, i32 0, i32 3
  %768 = load ptr, ptr %767, align 8, !tbaa !27
  %769 = load ptr, ptr %30, align 8, !tbaa !5
  %770 = icmp eq ptr %768, %769
  br i1 %770, label %771, label %777

771:                                              ; preds = %765
  %772 = load ptr, ptr %32, align 8, !tbaa !5
  %773 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %772, i32 0, i32 2
  %774 = load ptr, ptr %773, align 8, !tbaa !28
  %775 = load ptr, ptr %30, align 8, !tbaa !5
  %776 = icmp eq ptr %774, %775
  br label %777

777:                                              ; preds = %771, %765, %753
  %778 = phi i1 [ false, %765 ], [ false, %753 ], [ %776, %771 ]
  %779 = zext i1 %778 to i32
  %780 = sext i32 %779 to i64
  %781 = call i64 @llvm.expect.i64(i64 %780, i64 1)
  %782 = icmp ne i64 %781, 0
  br i1 %782, label %783, label %790

783:                                              ; preds = %777
  %784 = load ptr, ptr %32, align 8, !tbaa !5
  %785 = load ptr, ptr %33, align 8, !tbaa !5
  %786 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %785, i32 0, i32 3
  store ptr %784, ptr %786, align 8, !tbaa !27
  %787 = load ptr, ptr %33, align 8, !tbaa !5
  %788 = load ptr, ptr %32, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %788, i32 0, i32 2
  store ptr %787, ptr %789, align 8, !tbaa !28
  br label %791

790:                                              ; preds = %777
  call void @abort() #7
  unreachable

791:                                              ; preds = %783
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  br label %837

792:                                              ; preds = %743
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  %793 = load ptr, ptr %30, align 8, !tbaa !5
  %794 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %793, i32 0, i32 4
  %795 = getelementptr inbounds [2 x ptr], ptr %794, i64 0, i64 1
  store ptr %795, ptr %34, align 8, !tbaa !5
  %796 = load ptr, ptr %795, align 8, !tbaa !5
  store ptr %796, ptr %32, align 8, !tbaa !5
  %797 = icmp ne ptr %796, null
  br i1 %797, label %804, label %798

798:                                              ; preds = %792
  %799 = load ptr, ptr %30, align 8, !tbaa !5
  %800 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %799, i32 0, i32 4
  %801 = getelementptr inbounds [2 x ptr], ptr %800, i64 0, i64 0
  store ptr %801, ptr %34, align 8, !tbaa !5
  %802 = load ptr, ptr %801, align 8, !tbaa !5
  store ptr %802, ptr %32, align 8, !tbaa !5
  %803 = icmp ne ptr %802, null
  br i1 %803, label %804, label %836

804:                                              ; preds = %798, %792
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  br label %805

805:                                              ; preds = %819, %804
  %806 = load ptr, ptr %32, align 8, !tbaa !5
  %807 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %806, i32 0, i32 4
  %808 = getelementptr inbounds [2 x ptr], ptr %807, i64 0, i64 1
  store ptr %808, ptr %35, align 8, !tbaa !5
  %809 = load ptr, ptr %808, align 8, !tbaa !5
  %810 = icmp ne ptr %809, null
  br i1 %810, label %817, label %811

811:                                              ; preds = %805
  %812 = load ptr, ptr %32, align 8, !tbaa !5
  %813 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %812, i32 0, i32 4
  %814 = getelementptr inbounds [2 x ptr], ptr %813, i64 0, i64 0
  store ptr %814, ptr %35, align 8, !tbaa !5
  %815 = load ptr, ptr %814, align 8, !tbaa !5
  %816 = icmp ne ptr %815, null
  br label %817

817:                                              ; preds = %811, %805
  %818 = phi i1 [ true, %805 ], [ %816, %811 ]
  br i1 %818, label %819, label %822

819:                                              ; preds = %817
  %820 = load ptr, ptr %35, align 8, !tbaa !5
  store ptr %820, ptr %34, align 8, !tbaa !5
  %821 = load ptr, ptr %820, align 8, !tbaa !5
  store ptr %821, ptr %32, align 8, !tbaa !5
  br label %805, !llvm.loop !37

822:                                              ; preds = %817
  %823 = load ptr, ptr %34, align 8, !tbaa !5
  %824 = load ptr, ptr %6, align 8, !tbaa !5
  %825 = getelementptr inbounds %struct.malloc_state, ptr %824, i32 0, i32 4
  %826 = load ptr, ptr %825, align 8, !tbaa !14
  %827 = icmp uge ptr %823, %826
  %828 = zext i1 %827 to i32
  %829 = sext i32 %828 to i64
  %830 = call i64 @llvm.expect.i64(i64 %829, i64 1)
  %831 = icmp ne i64 %830, 0
  br i1 %831, label %832, label %834

832:                                              ; preds = %822
  %833 = load ptr, ptr %34, align 8, !tbaa !5
  store ptr null, ptr %833, align 8, !tbaa !5
  br label %835

834:                                              ; preds = %822
  call void @abort() #7
  unreachable

835:                                              ; preds = %832
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  br label %836

836:                                              ; preds = %835, %798
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  br label %837

837:                                              ; preds = %836, %791
  %838 = load ptr, ptr %31, align 8, !tbaa !5
  %839 = icmp ne ptr %838, null
  br i1 %839, label %840, label %969

840:                                              ; preds = %837
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #6
  %841 = load ptr, ptr %6, align 8, !tbaa !5
  %842 = getelementptr inbounds %struct.malloc_state, ptr %841, i32 0, i32 11
  %843 = load ptr, ptr %30, align 8, !tbaa !5
  %844 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %843, i32 0, i32 6
  %845 = load i32, ptr %844, align 8, !tbaa !31
  %846 = zext i32 %845 to i64
  %847 = getelementptr inbounds [32 x ptr], ptr %842, i64 0, i64 %846
  store ptr %847, ptr %36, align 8, !tbaa !5
  %848 = load ptr, ptr %30, align 8, !tbaa !5
  %849 = load ptr, ptr %36, align 8, !tbaa !5
  %850 = load ptr, ptr %849, align 8, !tbaa !5
  %851 = icmp eq ptr %848, %850
  br i1 %851, label %852, label %867

852:                                              ; preds = %840
  %853 = load ptr, ptr %32, align 8, !tbaa !5
  %854 = load ptr, ptr %36, align 8, !tbaa !5
  store ptr %853, ptr %854, align 8, !tbaa !5
  %855 = icmp eq ptr %853, null
  br i1 %855, label %856, label %866

856:                                              ; preds = %852
  %857 = load ptr, ptr %30, align 8, !tbaa !5
  %858 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %857, i32 0, i32 6
  %859 = load i32, ptr %858, align 8, !tbaa !31
  %860 = shl i32 1, %859
  %861 = xor i32 %860, -1
  %862 = load ptr, ptr %6, align 8, !tbaa !5
  %863 = getelementptr inbounds %struct.malloc_state, ptr %862, i32 0, i32 1
  %864 = load i32, ptr %863, align 4, !tbaa !32
  %865 = and i32 %864, %861
  store i32 %865, ptr %863, align 4, !tbaa !32
  br label %866

866:                                              ; preds = %856, %852
  br label %897

867:                                              ; preds = %840
  %868 = load ptr, ptr %31, align 8, !tbaa !5
  %869 = load ptr, ptr %6, align 8, !tbaa !5
  %870 = getelementptr inbounds %struct.malloc_state, ptr %869, i32 0, i32 4
  %871 = load ptr, ptr %870, align 8, !tbaa !14
  %872 = icmp uge ptr %868, %871
  %873 = zext i1 %872 to i32
  %874 = sext i32 %873 to i64
  %875 = call i64 @llvm.expect.i64(i64 %874, i64 1)
  %876 = icmp ne i64 %875, 0
  br i1 %876, label %877, label %895

877:                                              ; preds = %867
  %878 = load ptr, ptr %31, align 8, !tbaa !5
  %879 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %878, i32 0, i32 4
  %880 = getelementptr inbounds [2 x ptr], ptr %879, i64 0, i64 0
  %881 = load ptr, ptr %880, align 8, !tbaa !5
  %882 = load ptr, ptr %30, align 8, !tbaa !5
  %883 = icmp eq ptr %881, %882
  br i1 %883, label %884, label %889

884:                                              ; preds = %877
  %885 = load ptr, ptr %32, align 8, !tbaa !5
  %886 = load ptr, ptr %31, align 8, !tbaa !5
  %887 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %886, i32 0, i32 4
  %888 = getelementptr inbounds [2 x ptr], ptr %887, i64 0, i64 0
  store ptr %885, ptr %888, align 8, !tbaa !5
  br label %894

889:                                              ; preds = %877
  %890 = load ptr, ptr %32, align 8, !tbaa !5
  %891 = load ptr, ptr %31, align 8, !tbaa !5
  %892 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %891, i32 0, i32 4
  %893 = getelementptr inbounds [2 x ptr], ptr %892, i64 0, i64 1
  store ptr %890, ptr %893, align 8, !tbaa !5
  br label %894

894:                                              ; preds = %889, %884
  br label %896

895:                                              ; preds = %867
  call void @abort() #7
  unreachable

896:                                              ; preds = %894
  br label %897

897:                                              ; preds = %896, %866
  %898 = load ptr, ptr %32, align 8, !tbaa !5
  %899 = icmp ne ptr %898, null
  br i1 %899, label %900, label %968

900:                                              ; preds = %897
  %901 = load ptr, ptr %32, align 8, !tbaa !5
  %902 = load ptr, ptr %6, align 8, !tbaa !5
  %903 = getelementptr inbounds %struct.malloc_state, ptr %902, i32 0, i32 4
  %904 = load ptr, ptr %903, align 8, !tbaa !14
  %905 = icmp uge ptr %901, %904
  %906 = zext i1 %905 to i32
  %907 = sext i32 %906 to i64
  %908 = call i64 @llvm.expect.i64(i64 %907, i64 1)
  %909 = icmp ne i64 %908, 0
  br i1 %909, label %910, label %966

910:                                              ; preds = %900
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %911 = load ptr, ptr %31, align 8, !tbaa !5
  %912 = load ptr, ptr %32, align 8, !tbaa !5
  %913 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %912, i32 0, i32 5
  store ptr %911, ptr %913, align 8, !tbaa !25
  %914 = load ptr, ptr %30, align 8, !tbaa !5
  %915 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %914, i32 0, i32 4
  %916 = getelementptr inbounds [2 x ptr], ptr %915, i64 0, i64 0
  %917 = load ptr, ptr %916, align 8, !tbaa !5
  store ptr %917, ptr %37, align 8, !tbaa !5
  %918 = icmp ne ptr %917, null
  br i1 %918, label %919, label %939

919:                                              ; preds = %910
  %920 = load ptr, ptr %37, align 8, !tbaa !5
  %921 = load ptr, ptr %6, align 8, !tbaa !5
  %922 = getelementptr inbounds %struct.malloc_state, ptr %921, i32 0, i32 4
  %923 = load ptr, ptr %922, align 8, !tbaa !14
  %924 = icmp uge ptr %920, %923
  %925 = zext i1 %924 to i32
  %926 = sext i32 %925 to i64
  %927 = call i64 @llvm.expect.i64(i64 %926, i64 1)
  %928 = icmp ne i64 %927, 0
  br i1 %928, label %929, label %937

929:                                              ; preds = %919
  %930 = load ptr, ptr %37, align 8, !tbaa !5
  %931 = load ptr, ptr %32, align 8, !tbaa !5
  %932 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %931, i32 0, i32 4
  %933 = getelementptr inbounds [2 x ptr], ptr %932, i64 0, i64 0
  store ptr %930, ptr %933, align 8, !tbaa !5
  %934 = load ptr, ptr %32, align 8, !tbaa !5
  %935 = load ptr, ptr %37, align 8, !tbaa !5
  %936 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %935, i32 0, i32 5
  store ptr %934, ptr %936, align 8, !tbaa !25
  br label %938

937:                                              ; preds = %919
  call void @abort() #7
  unreachable

938:                                              ; preds = %929
  br label %939

939:                                              ; preds = %938, %910
  %940 = load ptr, ptr %30, align 8, !tbaa !5
  %941 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %940, i32 0, i32 4
  %942 = getelementptr inbounds [2 x ptr], ptr %941, i64 0, i64 1
  %943 = load ptr, ptr %942, align 8, !tbaa !5
  store ptr %943, ptr %38, align 8, !tbaa !5
  %944 = icmp ne ptr %943, null
  br i1 %944, label %945, label %965

945:                                              ; preds = %939
  %946 = load ptr, ptr %38, align 8, !tbaa !5
  %947 = load ptr, ptr %6, align 8, !tbaa !5
  %948 = getelementptr inbounds %struct.malloc_state, ptr %947, i32 0, i32 4
  %949 = load ptr, ptr %948, align 8, !tbaa !14
  %950 = icmp uge ptr %946, %949
  %951 = zext i1 %950 to i32
  %952 = sext i32 %951 to i64
  %953 = call i64 @llvm.expect.i64(i64 %952, i64 1)
  %954 = icmp ne i64 %953, 0
  br i1 %954, label %955, label %963

955:                                              ; preds = %945
  %956 = load ptr, ptr %38, align 8, !tbaa !5
  %957 = load ptr, ptr %32, align 8, !tbaa !5
  %958 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %957, i32 0, i32 4
  %959 = getelementptr inbounds [2 x ptr], ptr %958, i64 0, i64 1
  store ptr %956, ptr %959, align 8, !tbaa !5
  %960 = load ptr, ptr %32, align 8, !tbaa !5
  %961 = load ptr, ptr %38, align 8, !tbaa !5
  %962 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %961, i32 0, i32 5
  store ptr %960, ptr %962, align 8, !tbaa !25
  br label %964

963:                                              ; preds = %945
  call void @abort() #7
  unreachable

964:                                              ; preds = %955
  br label %965

965:                                              ; preds = %964, %939
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  br label %967

966:                                              ; preds = %900
  call void @abort() #7
  unreachable

967:                                              ; preds = %965
  br label %968

968:                                              ; preds = %967, %897
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #6
  br label %969

969:                                              ; preds = %968, %837
  call void @llvm.lifetime.end.p0(i64 8, 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
  br label %970

970:                                              ; preds = %969, %742
  %971 = load i64, ptr %7, align 8, !tbaa !17
  %972 = or i64 %971, 1
  %973 = load ptr, ptr %5, align 8, !tbaa !5
  %974 = getelementptr inbounds %struct.malloc_chunk, ptr %973, i32 0, i32 1
  store i64 %972, ptr %974, align 8, !tbaa !15
  %975 = load i64, ptr %7, align 8, !tbaa !17
  %976 = load ptr, ptr %5, align 8, !tbaa !5
  %977 = load i64, ptr %7, align 8, !tbaa !17
  %978 = getelementptr inbounds i8, ptr %976, i64 %977
  %979 = getelementptr inbounds %struct.malloc_chunk, ptr %978, i32 0, i32 0
  store i64 %975, ptr %979, align 8, !tbaa !18
  %980 = load ptr, ptr %5, align 8, !tbaa !5
  %981 = load ptr, ptr %6, align 8, !tbaa !5
  %982 = getelementptr inbounds %struct.malloc_state, ptr %981, i32 0, i32 5
  %983 = load ptr, ptr %982, align 8, !tbaa !20
  %984 = icmp eq ptr %980, %983
  br i1 %984, label %985, label %989

985:                                              ; preds = %970
  %986 = load i64, ptr %7, align 8, !tbaa !17
  %987 = load ptr, ptr %6, align 8, !tbaa !5
  %988 = getelementptr inbounds %struct.malloc_state, ptr %987, i32 0, i32 2
  store i64 %986, ptr %988, align 8, !tbaa !33
  store i32 2, ptr %23, align 4
  br label %990

989:                                              ; preds = %970
  store i32 0, ptr %23, align 4
  br label %990

990:                                              ; preds = %989, %985
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #6
  %991 = load i32, ptr %23, align 4
  switch i32 %991, label %1259 [
    i32 0, label %992
  ]

992:                                              ; preds = %990
  br label %993

993:                                              ; preds = %992
  br label %994

994:                                              ; preds = %993
  br label %1009

995:                                              ; preds = %552
  %996 = load ptr, ptr %8, align 8, !tbaa !5
  %997 = getelementptr inbounds %struct.malloc_chunk, ptr %996, i32 0, i32 1
  %998 = load i64, ptr %997, align 8, !tbaa !15
  %999 = and i64 %998, -2
  store i64 %999, ptr %997, align 8, !tbaa !15
  %1000 = load i64, ptr %7, align 8, !tbaa !17
  %1001 = or i64 %1000, 1
  %1002 = load ptr, ptr %5, align 8, !tbaa !5
  %1003 = getelementptr inbounds %struct.malloc_chunk, ptr %1002, i32 0, i32 1
  store i64 %1001, ptr %1003, align 8, !tbaa !15
  %1004 = load i64, ptr %7, align 8, !tbaa !17
  %1005 = load ptr, ptr %5, align 8, !tbaa !5
  %1006 = load i64, ptr %7, align 8, !tbaa !17
  %1007 = getelementptr inbounds i8, ptr %1005, i64 %1006
  %1008 = getelementptr inbounds %struct.malloc_chunk, ptr %1007, i32 0, i32 0
  store i64 %1004, ptr %1008, align 8, !tbaa !18
  br label %1009

1009:                                             ; preds = %995, %994
  %1010 = load i64, ptr %7, align 8, !tbaa !17
  %1011 = lshr i64 %1010, 3
  %1012 = icmp ult i64 %1011, 32
  br i1 %1012, label %1013, label %1075

1013:                                             ; preds = %1009
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #6
  %1014 = load i64, ptr %7, align 8, !tbaa !17
  %1015 = lshr i64 %1014, 3
  %1016 = trunc i64 %1015 to i32
  store i32 %1016, ptr %39, align 4, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #6
  %1017 = load ptr, ptr %6, align 8, !tbaa !5
  %1018 = getelementptr inbounds %struct.malloc_state, ptr %1017, i32 0, i32 10
  %1019 = load i32, ptr %39, align 4, !tbaa !23
  %1020 = shl i32 %1019, 1
  %1021 = zext i32 %1020 to i64
  %1022 = getelementptr inbounds [66 x ptr], ptr %1018, i64 0, i64 %1021
  store ptr %1022, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #6
  %1023 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1023, ptr %41, align 8, !tbaa !5
  %1024 = load i64, ptr %7, align 8, !tbaa !17
  %1025 = icmp uge i64 %1024, 32
  br i1 %1025, label %1027, label %1026

1026:                                             ; preds = %1013
  call void @abort() #7
  unreachable

1027:                                             ; preds = %1013
  %1028 = load ptr, ptr %6, align 8, !tbaa !5
  %1029 = getelementptr inbounds %struct.malloc_state, ptr %1028, i32 0, i32 0
  %1030 = load i32, ptr %1029, align 8, !tbaa !24
  %1031 = load i32, ptr %39, align 4, !tbaa !23
  %1032 = shl i32 1, %1031
  %1033 = and i32 %1030, %1032
  %1034 = icmp ne i32 %1033, 0
  br i1 %1034, label %1042, label %1035

1035:                                             ; preds = %1027
  %1036 = load i32, ptr %39, align 4, !tbaa !23
  %1037 = shl i32 1, %1036
  %1038 = load ptr, ptr %6, align 8, !tbaa !5
  %1039 = getelementptr inbounds %struct.malloc_state, ptr %1038, i32 0, i32 0
  %1040 = load i32, ptr %1039, align 8, !tbaa !24
  %1041 = or i32 %1040, %1037
  store i32 %1041, ptr %1039, align 8, !tbaa !24
  br label %1060

1042:                                             ; preds = %1027
  %1043 = load ptr, ptr %40, align 8, !tbaa !5
  %1044 = getelementptr inbounds %struct.malloc_chunk, ptr %1043, i32 0, i32 2
  %1045 = load ptr, ptr %1044, align 8, !tbaa !21
  %1046 = load ptr, ptr %6, align 8, !tbaa !5
  %1047 = getelementptr inbounds %struct.malloc_state, ptr %1046, i32 0, i32 4
  %1048 = load ptr, ptr %1047, align 8, !tbaa !14
  %1049 = icmp uge ptr %1045, %1048
  %1050 = zext i1 %1049 to i32
  %1051 = sext i32 %1050 to i64
  %1052 = call i64 @llvm.expect.i64(i64 %1051, i64 1)
  %1053 = icmp ne i64 %1052, 0
  br i1 %1053, label %1054, label %1058

1054:                                             ; preds = %1042
  %1055 = load ptr, ptr %40, align 8, !tbaa !5
  %1056 = getelementptr inbounds %struct.malloc_chunk, ptr %1055, i32 0, i32 2
  %1057 = load ptr, ptr %1056, align 8, !tbaa !21
  store ptr %1057, ptr %41, align 8, !tbaa !5
  br label %1059

1058:                                             ; preds = %1042
  call void @abort() #7
  unreachable

1059:                                             ; preds = %1054
  br label %1060

1060:                                             ; preds = %1059, %1035
  %1061 = load ptr, ptr %5, align 8, !tbaa !5
  %1062 = load ptr, ptr %40, align 8, !tbaa !5
  %1063 = getelementptr inbounds %struct.malloc_chunk, ptr %1062, i32 0, i32 2
  store ptr %1061, ptr %1063, align 8, !tbaa !21
  %1064 = load ptr, ptr %5, align 8, !tbaa !5
  %1065 = load ptr, ptr %41, align 8, !tbaa !5
  %1066 = getelementptr inbounds %struct.malloc_chunk, ptr %1065, i32 0, i32 3
  store ptr %1064, ptr %1066, align 8, !tbaa !22
  %1067 = load ptr, ptr %41, align 8, !tbaa !5
  %1068 = load ptr, ptr %5, align 8, !tbaa !5
  %1069 = getelementptr inbounds %struct.malloc_chunk, ptr %1068, i32 0, i32 2
  store ptr %1067, ptr %1069, align 8, !tbaa !21
  %1070 = load ptr, ptr %40, align 8, !tbaa !5
  %1071 = load ptr, ptr %5, align 8, !tbaa !5
  %1072 = getelementptr inbounds %struct.malloc_chunk, ptr %1071, i32 0, i32 3
  store ptr %1070, ptr %1072, align 8, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #6
  %1073 = load ptr, ptr %6, align 8, !tbaa !5
  %1074 = load ptr, ptr %5, align 8, !tbaa !5
  call void @do_check_free_chunk(ptr noundef %1073, ptr noundef %1074)
  br label %1257

1075:                                             ; preds = %1009
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #6
  %1076 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %1076, ptr %42, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %43) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %45) #6
  %1077 = load i64, ptr %7, align 8, !tbaa !17
  %1078 = lshr i64 %1077, 8
  %1079 = trunc i64 %1078 to i32
  store i32 %1079, ptr %45, align 4, !tbaa !23
  %1080 = load i32, ptr %45, align 4, !tbaa !23
  %1081 = icmp eq i32 %1080, 0
  br i1 %1081, label %1082, label %1083

1082:                                             ; preds = %1075
  store i32 0, ptr %44, align 4, !tbaa !23
  br label %1103

1083:                                             ; preds = %1075
  %1084 = load i32, ptr %45, align 4, !tbaa !23
  %1085 = icmp ugt i32 %1084, 65535
  br i1 %1085, label %1086, label %1087

1086:                                             ; preds = %1083
  store i32 31, ptr %44, align 4, !tbaa !23
  br label %1102

1087:                                             ; preds = %1083
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #6
  %1088 = load i32, ptr %45, align 4, !tbaa !23
  %1089 = call i32 @llvm.ctlz.i32(i32 %1088, i1 true)
  %1090 = sub i32 31, %1089
  store i32 %1090, ptr %46, align 4, !tbaa !23
  %1091 = load i32, ptr %46, align 4, !tbaa !23
  %1092 = shl i32 %1091, 1
  %1093 = zext i32 %1092 to i64
  %1094 = load i64, ptr %7, align 8, !tbaa !17
  %1095 = load i32, ptr %46, align 4, !tbaa !23
  %1096 = add i32 %1095, 7
  %1097 = zext i32 %1096 to i64
  %1098 = lshr i64 %1094, %1097
  %1099 = and i64 %1098, 1
  %1100 = add i64 %1093, %1099
  %1101 = trunc i64 %1100 to i32
  store i32 %1101, ptr %44, align 4, !tbaa !23
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #6
  br label %1102

1102:                                             ; preds = %1087, %1086
  br label %1103

1103:                                             ; preds = %1102, %1082
  call void @llvm.lifetime.end.p0(i64 4, ptr %45) #6
  %1104 = load ptr, ptr %6, align 8, !tbaa !5
  %1105 = getelementptr inbounds %struct.malloc_state, ptr %1104, i32 0, i32 11
  %1106 = load i32, ptr %44, align 4, !tbaa !23
  %1107 = zext i32 %1106 to i64
  %1108 = getelementptr inbounds [32 x ptr], ptr %1105, i64 0, i64 %1107
  store ptr %1108, ptr %43, align 8, !tbaa !5
  %1109 = load i32, ptr %44, align 4, !tbaa !23
  %1110 = load ptr, ptr %42, align 8, !tbaa !5
  %1111 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1110, i32 0, i32 6
  store i32 %1109, ptr %1111, align 8, !tbaa !31
  %1112 = load ptr, ptr %42, align 8, !tbaa !5
  %1113 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1112, i32 0, i32 4
  %1114 = getelementptr inbounds [2 x ptr], ptr %1113, i64 0, i64 1
  store ptr null, ptr %1114, align 8, !tbaa !5
  %1115 = load ptr, ptr %42, align 8, !tbaa !5
  %1116 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1115, i32 0, i32 4
  %1117 = getelementptr inbounds [2 x ptr], ptr %1116, i64 0, i64 0
  store ptr null, ptr %1117, align 8, !tbaa !5
  %1118 = load ptr, ptr %6, align 8, !tbaa !5
  %1119 = getelementptr inbounds %struct.malloc_state, ptr %1118, i32 0, i32 1
  %1120 = load i32, ptr %1119, align 4, !tbaa !32
  %1121 = load i32, ptr %44, align 4, !tbaa !23
  %1122 = shl i32 1, %1121
  %1123 = and i32 %1120, %1122
  %1124 = icmp ne i32 %1123, 0
  br i1 %1124, label %1142, label %1125

1125:                                             ; preds = %1103
  %1126 = load i32, ptr %44, align 4, !tbaa !23
  %1127 = shl i32 1, %1126
  %1128 = load ptr, ptr %6, align 8, !tbaa !5
  %1129 = getelementptr inbounds %struct.malloc_state, ptr %1128, i32 0, i32 1
  %1130 = load i32, ptr %1129, align 4, !tbaa !32
  %1131 = or i32 %1130, %1127
  store i32 %1131, ptr %1129, align 4, !tbaa !32
  %1132 = load ptr, ptr %42, align 8, !tbaa !5
  %1133 = load ptr, ptr %43, align 8, !tbaa !5
  store ptr %1132, ptr %1133, align 8, !tbaa !5
  %1134 = load ptr, ptr %43, align 8, !tbaa !5
  %1135 = load ptr, ptr %42, align 8, !tbaa !5
  %1136 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1135, i32 0, i32 5
  store ptr %1134, ptr %1136, align 8, !tbaa !25
  %1137 = load ptr, ptr %42, align 8, !tbaa !5
  %1138 = load ptr, ptr %42, align 8, !tbaa !5
  %1139 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1138, i32 0, i32 3
  store ptr %1137, ptr %1139, align 8, !tbaa !27
  %1140 = load ptr, ptr %42, align 8, !tbaa !5
  %1141 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1140, i32 0, i32 2
  store ptr %1137, ptr %1141, align 8, !tbaa !28
  br label %1245

1142:                                             ; preds = %1103
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  %1143 = load ptr, ptr %43, align 8, !tbaa !5
  %1144 = load ptr, ptr %1143, align 8, !tbaa !5
  store ptr %1144, ptr %47, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #6
  %1145 = load i64, ptr %7, align 8, !tbaa !17
  %1146 = load i32, ptr %44, align 4, !tbaa !23
  %1147 = icmp eq i32 %1146, 31
  br i1 %1147, label %1148, label %1149

1148:                                             ; preds = %1142
  br label %1156

1149:                                             ; preds = %1142
  %1150 = load i32, ptr %44, align 4, !tbaa !23
  %1151 = lshr i32 %1150, 1
  %1152 = add i32 %1151, 8
  %1153 = sub i32 %1152, 2
  %1154 = zext i32 %1153 to i64
  %1155 = sub i64 63, %1154
  br label %1156

1156:                                             ; preds = %1149, %1148
  %1157 = phi i64 [ 0, %1148 ], [ %1155, %1149 ]
  %1158 = shl i64 %1145, %1157
  store i64 %1158, ptr %48, align 8, !tbaa !17
  br label %1159

1159:                                             ; preds = %1243, %1156
  %1160 = load ptr, ptr %47, align 8, !tbaa !5
  %1161 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1160, i32 0, i32 1
  %1162 = load i64, ptr %1161, align 8, !tbaa !38
  %1163 = and i64 %1162, -8
  %1164 = load i64, ptr %7, align 8, !tbaa !17
  %1165 = icmp ne i64 %1163, %1164
  br i1 %1165, label %1166, label %1207

1166:                                             ; preds = %1159
  call void @llvm.lifetime.start.p0(i64 8, ptr %49) #6
  %1167 = load ptr, ptr %47, align 8, !tbaa !5
  %1168 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1167, i32 0, i32 4
  %1169 = load i64, ptr %48, align 8, !tbaa !17
  %1170 = lshr i64 %1169, 63
  %1171 = and i64 %1170, 1
  %1172 = getelementptr inbounds [2 x ptr], ptr %1168, i64 0, i64 %1171
  store ptr %1172, ptr %49, align 8, !tbaa !5
  %1173 = load i64, ptr %48, align 8, !tbaa !17
  %1174 = shl i64 %1173, 1
  store i64 %1174, ptr %48, align 8, !tbaa !17
  %1175 = load ptr, ptr %49, align 8, !tbaa !5
  %1176 = load ptr, ptr %1175, align 8, !tbaa !5
  %1177 = icmp ne ptr %1176, null
  br i1 %1177, label %1178, label %1181

1178:                                             ; preds = %1166
  %1179 = load ptr, ptr %49, align 8, !tbaa !5
  %1180 = load ptr, ptr %1179, align 8, !tbaa !5
  store ptr %1180, ptr %47, align 8, !tbaa !5
  br label %1203

1181:                                             ; preds = %1166
  %1182 = load ptr, ptr %49, align 8, !tbaa !5
  %1183 = load ptr, ptr %6, align 8, !tbaa !5
  %1184 = getelementptr inbounds %struct.malloc_state, ptr %1183, i32 0, i32 4
  %1185 = load ptr, ptr %1184, align 8, !tbaa !14
  %1186 = icmp uge ptr %1182, %1185
  %1187 = zext i1 %1186 to i32
  %1188 = sext i32 %1187 to i64
  %1189 = call i64 @llvm.expect.i64(i64 %1188, i64 1)
  %1190 = icmp ne i64 %1189, 0
  br i1 %1190, label %1191, label %1202

1191:                                             ; preds = %1181
  %1192 = load ptr, ptr %42, align 8, !tbaa !5
  %1193 = load ptr, ptr %49, align 8, !tbaa !5
  store ptr %1192, ptr %1193, align 8, !tbaa !5
  %1194 = load ptr, ptr %47, align 8, !tbaa !5
  %1195 = load ptr, ptr %42, align 8, !tbaa !5
  %1196 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1195, i32 0, i32 5
  store ptr %1194, ptr %1196, align 8, !tbaa !25
  %1197 = load ptr, ptr %42, align 8, !tbaa !5
  %1198 = load ptr, ptr %42, align 8, !tbaa !5
  %1199 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1198, i32 0, i32 3
  store ptr %1197, ptr %1199, align 8, !tbaa !27
  %1200 = load ptr, ptr %42, align 8, !tbaa !5
  %1201 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1200, i32 0, i32 2
  store ptr %1197, ptr %1201, align 8, !tbaa !28
  store i32 8, ptr %23, align 4
  br label %1204

1202:                                             ; preds = %1181
  call void @abort() #7
  unreachable

1203:                                             ; preds = %1178
  store i32 0, ptr %23, align 4
  br label %1204

1204:                                             ; preds = %1203, %1191
  call void @llvm.lifetime.end.p0(i64 8, ptr %49) #6
  %1205 = load i32, ptr %23, align 4
  switch i32 %1205, label %1276 [
    i32 0, label %1206
    i32 8, label %1244
  ]

1206:                                             ; preds = %1204
  br label %1243

1207:                                             ; preds = %1159
  call void @llvm.lifetime.start.p0(i64 8, ptr %50) #6
  %1208 = load ptr, ptr %47, align 8, !tbaa !5
  %1209 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1208, i32 0, i32 2
  %1210 = load ptr, ptr %1209, align 8, !tbaa !28
  store ptr %1210, ptr %50, align 8, !tbaa !5
  %1211 = load ptr, ptr %47, align 8, !tbaa !5
  %1212 = load ptr, ptr %6, align 8, !tbaa !5
  %1213 = getelementptr inbounds %struct.malloc_state, ptr %1212, i32 0, i32 4
  %1214 = load ptr, ptr %1213, align 8, !tbaa !14
  %1215 = icmp uge ptr %1211, %1214
  br i1 %1215, label %1216, label %1222

1216:                                             ; preds = %1207
  %1217 = load ptr, ptr %50, align 8, !tbaa !5
  %1218 = load ptr, ptr %6, align 8, !tbaa !5
  %1219 = getelementptr inbounds %struct.malloc_state, ptr %1218, i32 0, i32 4
  %1220 = load ptr, ptr %1219, align 8, !tbaa !14
  %1221 = icmp uge ptr %1217, %1220
  br label %1222

1222:                                             ; preds = %1216, %1207
  %1223 = phi i1 [ false, %1207 ], [ %1221, %1216 ]
  %1224 = zext i1 %1223 to i32
  %1225 = sext i32 %1224 to i64
  %1226 = call i64 @llvm.expect.i64(i64 %1225, i64 1)
  %1227 = icmp ne i64 %1226, 0
  br i1 %1227, label %1228, label %1242

1228:                                             ; preds = %1222
  %1229 = load ptr, ptr %42, align 8, !tbaa !5
  %1230 = load ptr, ptr %50, align 8, !tbaa !5
  %1231 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1230, i32 0, i32 3
  store ptr %1229, ptr %1231, align 8, !tbaa !27
  %1232 = load ptr, ptr %47, align 8, !tbaa !5
  %1233 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1232, i32 0, i32 2
  store ptr %1229, ptr %1233, align 8, !tbaa !28
  %1234 = load ptr, ptr %50, align 8, !tbaa !5
  %1235 = load ptr, ptr %42, align 8, !tbaa !5
  %1236 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1235, i32 0, i32 2
  store ptr %1234, ptr %1236, align 8, !tbaa !28
  %1237 = load ptr, ptr %47, align 8, !tbaa !5
  %1238 = load ptr, ptr %42, align 8, !tbaa !5
  %1239 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1238, i32 0, i32 3
  store ptr %1237, ptr %1239, align 8, !tbaa !27
  %1240 = load ptr, ptr %42, align 8, !tbaa !5
  %1241 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1240, i32 0, i32 5
  store ptr null, ptr %1241, align 8, !tbaa !25
  store i32 8, ptr %23, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %50) #6
  br label %1244

1242:                                             ; preds = %1222
  call void @abort() #7
  unreachable

1243:                                             ; preds = %1206
  br label %1159

1244:                                             ; preds = %1228, %1204
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  br label %1245

1245:                                             ; preds = %1244, %1125
  call void @llvm.lifetime.end.p0(i64 4, ptr %44) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %43) #6
  %1246 = load ptr, ptr %6, align 8, !tbaa !5
  %1247 = load ptr, ptr %5, align 8, !tbaa !5
  call void @do_check_free_chunk(ptr noundef %1246, ptr noundef %1247)
  %1248 = load ptr, ptr %6, align 8, !tbaa !5
  %1249 = getelementptr inbounds %struct.malloc_state, ptr %1248, i32 0, i32 8
  %1250 = load i64, ptr %1249, align 8, !tbaa !39
  %1251 = add i64 %1250, -1
  store i64 %1251, ptr %1249, align 8, !tbaa !39
  %1252 = icmp eq i64 %1251, 0
  br i1 %1252, label %1253, label %1256

1253:                                             ; preds = %1245
  %1254 = load ptr, ptr %6, align 8, !tbaa !5
  %1255 = call i64 @release_unused_segments(ptr noundef %1254)
  br label %1256

1256:                                             ; preds = %1253, %1245
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #6
  br label %1257

1257:                                             ; preds = %1256, %1060
  store i32 2, ptr %23, align 4
  br label %1259

1258:                                             ; preds = %546
  store i32 0, ptr %23, align 4
  br label %1259

1259:                                             ; preds = %1258, %1257, %990, %603, %596, %533
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  %1260 = load i32, ptr %23, align 4
  switch i32 %1260, label %1276 [
    i32 0, label %1261
    i32 5, label %1263
    i32 2, label %1264
  ]

1261:                                             ; preds = %1259
  br label %1262

1262:                                             ; preds = %1261, %88
  br label %1263

1263:                                             ; preds = %1262, %1259
  call void @abort() #7
  unreachable

1264:                                             ; preds = %1259
  %1265 = load ptr, ptr %6, align 8, !tbaa !5
  %1266 = getelementptr inbounds %struct.malloc_state, ptr %1265, i32 0, i32 15
  %1267 = load i32, ptr %1266, align 8, !tbaa !9
  %1268 = and i32 %1267, 2
  %1269 = icmp ne i32 %1268, 0
  br i1 %1269, label %1270, label %1273

1270:                                             ; preds = %1264
  %1271 = load ptr, ptr %6, align 8, !tbaa !5
  %1272 = getelementptr inbounds %struct.malloc_state, ptr %1271, i32 0, i32 16
  store atomic i32 0, ptr %1272 release, align 4
  br label %1273

1273:                                             ; preds = %1270, %1264
  br label %1274

1274:                                             ; preds = %1273, %73, %72, %67
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  br label %1275

1275:                                             ; preds = %1274, %2
  ret void

1276:                                             ; preds = %1259, %1204
  unreachable
}

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 = { noreturn 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 #3 = { nocallback nofree nosync nounwind willreturn memory(none) }
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 = { noreturn nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !11, i64 880}
!10 = !{!"malloc_state", !11, i64 0, !11, i64 4, !12, i64 8, !12, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !12, i64 48, !12, i64 56, !12, i64 64, !7, i64 72, !7, i64 600, !12, i64 856, !12, i64 864, !12, i64 872, !11, i64 880, !11, i64 884, !13, i64 888, !6, i64 920, !12, i64 928}
!11 = !{!"int", !7, i64 0}
!12 = !{!"long", !7, i64 0}
!13 = !{!"malloc_segment", !6, i64 0, !12, i64 8, !6, i64 16, !11, i64 24}
!14 = !{!10, !6, i64 24}
!15 = !{!16, !12, i64 8}
!16 = !{!"malloc_chunk", !12, i64 0, !12, i64 8, !6, i64 16, !6, i64 24}
!17 = !{!12, !12, i64 0}
!18 = !{!16, !12, i64 0}
!19 = !{!10, !12, i64 856}
!20 = !{!10, !6, i64 32}
!21 = !{!16, !6, i64 16}
!22 = !{!16, !6, i64 24}
!23 = !{!11, !11, i64 0}
!24 = !{!10, !11, i64 0}
!25 = !{!26, !6, i64 48}
!26 = !{!"malloc_tree_chunk", !12, i64 0, !12, i64 8, !6, i64 16, !6, i64 24, !7, i64 32, !6, i64 48, !11, i64 56}
!27 = !{!26, !6, i64 24}
!28 = !{!26, !6, i64 16}
!29 = distinct !{!29, !30}
!30 = !{!"llvm.loop.mustprogress"}
!31 = !{!26, !11, i64 56}
!32 = !{!10, !11, i64 4}
!33 = !{!10, !12, i64 8}
!34 = !{!10, !6, i64 40}
!35 = !{!10, !12, i64 16}
!36 = !{!10, !12, i64 48}
!37 = distinct !{!37, !30}
!38 = !{!26, !12, i64 8}
!39 = !{!10, !12, i64 56}


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

; Function Attrs: nounwind uwtable
declare hidden i32 @spin_acquire_lock(ptr noundef) local_unnamed_addr #0

; Function Attrs: noreturn nounwind
declare void @abort() local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden void @do_check_inuse_chunk(ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind
declare i32 @munmap(ptr noundef, i64 noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare hidden i32 @sys_trim(ptr noundef, i64 noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @do_check_free_chunk(ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.ctlz.i32(i32, i1 immarg) #3

; Function Attrs: nounwind uwtable
declare hidden i64 @release_unused_segments(ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
define dso_local void @mspace_free(ptr noundef %0, ptr noundef %1) local_unnamed_addr #0 {
  %.not = icmp eq ptr %1, null
  br i1 %.not, label %442, label %3

3:                                                ; preds = %2
  %4 = getelementptr inbounds i8, ptr %1, i64 -16
  %5 = getelementptr inbounds i8, ptr %0, i64 880
  %6 = load i32, ptr %5, align 8, !tbaa !5
  %7 = and i32 %6, 2
  %.not427 = icmp eq i32 %7, 0
  br i1 %.not427, label %13, label %8

8:                                                ; preds = %3
  %9 = getelementptr inbounds i8, ptr %0, i64 884
  %10 = atomicrmw xchg ptr %9, i32 1 seq_cst, align 4
  %.not428 = icmp eq i32 %10, 0
  br i1 %.not428, label %13, label %11

11:                                               ; preds = %8
  %12 = tail call i32 @spin_acquire_lock(ptr noundef nonnull %9)
  %.not429 = icmp eq i32 %12, 0
  br i1 %.not429, label %13, label %442

13:                                               ; preds = %3, %8, %11
  tail call void @do_check_inuse_chunk(ptr noundef nonnull %0, ptr noundef nonnull %4)
  %14 = getelementptr inbounds i8, ptr %0, i64 24
  %15 = load ptr, ptr %14, align 8, !tbaa !13
  %.not430 = icmp ult ptr %4, %15
  br i1 %.not430, label %.critedge483, label %16, !prof !14

16:                                               ; preds = %13
  %17 = getelementptr inbounds i8, ptr %1, i64 -8
  %18 = load i64, ptr %17, align 8, !tbaa !15
  %19 = and i64 %18, 3
  %.not522 = icmp eq i64 %19, 1
  br i1 %.not522, label %.critedge483, label %20, !prof !14

20:                                               ; preds = %16
  %21 = and i64 %18, -8
  %22 = getelementptr inbounds i8, ptr %4, i64 %21
  %23 = and i64 %18, 1
  %.not431 = icmp eq i64 %23, 0
  br i1 %.not431, label %24, label %.thread

24:                                               ; preds = %20
  %25 = load i64, ptr %4, align 8, !tbaa !17
  %26 = and i64 %18, 2
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %28, label %39

28:                                               ; preds = %24
  %29 = add i64 %21, 32
  %30 = add i64 %29, %25
  %31 = sub i64 0, %25
  %32 = getelementptr inbounds i8, ptr %4, i64 %31
  %33 = tail call i32 @munmap(ptr noundef nonnull %32, i64 noundef %30) #5
  %34 = icmp eq i32 %33, 0
  br i1 %34, label %35, label %437

35:                                               ; preds = %28
  %36 = getelementptr inbounds i8, ptr %0, i64 856
  %37 = load i64, ptr %36, align 8, !tbaa !18
  %38 = sub i64 %37, %30
  store i64 %38, ptr %36, align 8, !tbaa !18
  br label %437

39:                                               ; preds = %24
  %40 = sub i64 0, %25
  %41 = getelementptr inbounds i8, ptr %4, i64 %40
  %42 = add i64 %25, %21
  %.not432 = icmp ult ptr %41, %15
  br i1 %.not432, label %.critedge483, label %43, !prof !14

43:                                               ; preds = %39
  %44 = getelementptr inbounds i8, ptr %0, i64 32
  %45 = load ptr, ptr %44, align 8, !tbaa !19
  %.not433 = icmp eq ptr %41, %45
  br i1 %.not433, label %165, label %46

46:                                               ; preds = %43
  %47 = icmp ult i64 %25, 256
  br i1 %47, label %48, label %90

48:                                               ; preds = %46
  %49 = lshr i64 %25, 3
  %50 = getelementptr inbounds i8, ptr %41, i64 16
  %51 = load ptr, ptr %50, align 8, !tbaa !20
  %52 = getelementptr inbounds i8, ptr %41, i64 24
  %53 = load ptr, ptr %52, align 8, !tbaa !21
  %54 = trunc nuw nsw i64 %49 to i32
  %.not449 = icmp eq ptr %41, %53
  br i1 %.not449, label %55, label %56

55:                                               ; preds = %48
  tail call void @abort() #6
  unreachable

56:                                               ; preds = %48
  %.not450 = icmp eq ptr %41, %51
  br i1 %.not450, label %57, label %58

57:                                               ; preds = %56
  tail call void @abort() #6
  unreachable

58:                                               ; preds = %56
  %59 = getelementptr inbounds i8, ptr %41, i64 8
  %60 = load i64, ptr %59, align 8, !tbaa !15
  %61 = and i64 %60, -8
  %62 = and i64 %25, 248
  %63 = icmp eq i64 %61, %62
  br i1 %63, label %65, label %64

64:                                               ; preds = %58
  tail call void @abort() #6
  unreachable

65:                                               ; preds = %58
  %66 = getelementptr inbounds i8, ptr %0, i64 72
  %67 = shl nuw nsw i64 %49, 1
  %68 = getelementptr inbounds [66 x ptr], ptr %66, i64 0, i64 %67
  %69 = icmp eq ptr %51, %68
  br i1 %69, label %.critedge485, label %70

70:                                               ; preds = %65
  %.not451 = icmp ult ptr %51, %15
  br i1 %.not451, label %.critedge487, label %71

71:                                               ; preds = %70
  %72 = getelementptr inbounds i8, ptr %51, i64 24
  %73 = load ptr, ptr %72, align 8, !tbaa !21
  %74 = icmp eq ptr %73, %41
  br i1 %74, label %.critedge485, label %.critedge487, !prof !22

.critedge485:                                     ; preds = %65, %71
  %75 = icmp eq ptr %53, %51
  br i1 %75, label %76, label %81

76:                                               ; preds = %.critedge485
  %77 = shl nuw i32 1, %54
  %78 = xor i32 %77, -1
  %79 = load i32, ptr %0, align 8, !tbaa !23
  %80 = and i32 %79, %78
  store i32 %80, ptr %0, align 8, !tbaa !23
  br label %.thread

81:                                               ; preds = %.critedge485
  %82 = icmp eq ptr %53, %68
  br i1 %82, label %.critedge489, label %83

83:                                               ; preds = %81
  %.not452 = icmp ult ptr %53, %15
  br i1 %.not452, label %.critedge491, label %84

84:                                               ; preds = %83
  %85 = getelementptr inbounds i8, ptr %53, i64 16
  %86 = load ptr, ptr %85, align 8, !tbaa !20
  %87 = icmp eq ptr %86, %41
  br i1 %87, label %.critedge489, label %.critedge491, !prof !22

.critedge489:                                     ; preds = %81, %84
  %88 = getelementptr inbounds i8, ptr %51, i64 24
  store ptr %53, ptr %88, align 8, !tbaa !21
  %89 = getelementptr inbounds i8, ptr %53, i64 16
  store ptr %51, ptr %89, align 8, !tbaa !20
  br label %.thread

.critedge491:                                     ; preds = %83, %84
  tail call void @abort() #6
  unreachable

.critedge487:                                     ; preds = %70, %71
  tail call void @abort() #6
  unreachable

90:                                               ; preds = %46
  %91 = getelementptr inbounds i8, ptr %41, i64 48
  %92 = load ptr, ptr %91, align 8, !tbaa !24
  %93 = getelementptr inbounds i8, ptr %41, i64 24
  %94 = load ptr, ptr %93, align 8, !tbaa !26
  %.not434 = icmp eq ptr %94, %41
  br i1 %.not434, label %107, label %95

95:                                               ; preds = %90
  %96 = getelementptr inbounds i8, ptr %41, i64 16
  %97 = load ptr, ptr %96, align 8, !tbaa !27
  %.not440 = icmp ult ptr %97, %15
  br i1 %.not440, label %.critedge493, label %98, !prof !14

98:                                               ; preds = %95
  %99 = getelementptr inbounds i8, ptr %97, i64 24
  %100 = load ptr, ptr %99, align 8, !tbaa !26
  %101 = icmp eq ptr %100, %41
  br i1 %101, label %102, label %.critedge493, !prof !22

102:                                              ; preds = %98
  %103 = getelementptr inbounds i8, ptr %94, i64 16
  %104 = load ptr, ptr %103, align 8, !tbaa !27
  %105 = icmp eq ptr %104, %41
  br i1 %105, label %106, label %.critedge493, !prof !22

106:                                              ; preds = %102
  store ptr %94, ptr %99, align 8, !tbaa !26
  store ptr %97, ptr %103, align 8, !tbaa !27
  br label %121

.critedge493:                                     ; preds = %98, %95, %102
  tail call void @abort() #6
  unreachable

107:                                              ; preds = %90
  %108 = getelementptr inbounds i8, ptr %41, i64 40
  %109 = load ptr, ptr %108, align 8, !tbaa !28
  %.not435 = icmp eq ptr %109, null
  br i1 %.not435, label %110, label %.critedge.preheader

110:                                              ; preds = %107
  %111 = getelementptr inbounds i8, ptr %41, i64 32
  %112 = load ptr, ptr %111, align 8, !tbaa !28
  %.not436 = icmp eq ptr %112, null
  br i1 %.not436, label %121, label %.critedge.preheader

.critedge.preheader:                              ; preds = %110, %107
  %.1378.ph = phi ptr [ %111, %110 ], [ %108, %107 ]
  %.1375.ph = phi ptr [ %112, %110 ], [ %109, %107 ]
  br label %.critedge

.critedge:                                        ; preds = %.critedge.backedge, %.critedge.preheader
  %.1378 = phi ptr [ %.1378.ph, %.critedge.preheader ], [ %.1378.be, %.critedge.backedge ]
  %.1375 = phi ptr [ %.1375.ph, %.critedge.preheader ], [ %.1375.be, %.critedge.backedge ]
  %113 = getelementptr inbounds i8, ptr %.1375, i64 40
  %114 = load ptr, ptr %113, align 8, !tbaa !28
  %.not437 = icmp eq ptr %114, null
  br i1 %.not437, label %115, label %.critedge.backedge

.critedge.backedge:                               ; preds = %.critedge, %115
  %.1378.be = phi ptr [ %113, %.critedge ], [ %116, %115 ]
  %.1375.be = phi ptr [ %114, %.critedge ], [ %117, %115 ]
  br label %.critedge, !llvm.loop !29

115:                                              ; preds = %.critedge
  %116 = getelementptr inbounds i8, ptr %.1375, i64 32
  %117 = load ptr, ptr %116, align 8, !tbaa !28
  %.not438 = icmp eq ptr %117, null
  br i1 %.not438, label %118, label %.critedge.backedge

118:                                              ; preds = %115
  %.not439 = icmp ult ptr %.1378, %15
  br i1 %.not439, label %120, label %119, !prof !14

119:                                              ; preds = %118
  store ptr null, ptr %.1378, align 8, !tbaa !28
  br label %121

120:                                              ; preds = %118
  tail call void @abort() #6
  unreachable

121:                                              ; preds = %110, %119, %106
  %.3 = phi ptr [ %94, %106 ], [ %.1375, %119 ], [ null, %110 ]
  %.not441 = icmp eq ptr %92, null
  br i1 %.not441, label %.thread, label %122

122:                                              ; preds = %121
  %123 = getelementptr inbounds i8, ptr %0, i64 600
  %124 = getelementptr inbounds i8, ptr %41, i64 56
  %125 = load i32, ptr %124, align 8, !tbaa !31
  %126 = zext i32 %125 to i64
  %127 = getelementptr inbounds [32 x ptr], ptr %123, i64 0, i64 %126
  %128 = load ptr, ptr %127, align 8, !tbaa !28
  %129 = icmp eq ptr %41, %128
  br i1 %129, label %130, label %136

130:                                              ; preds = %122
  store ptr %.3, ptr %127, align 8, !tbaa !28
  %cond = icmp eq ptr %.3, null
  br i1 %cond, label %.thread529, label %144

.thread529:                                       ; preds = %130
  %131 = shl nuw i32 1, %125
  %132 = xor i32 %131, -1
  %133 = getelementptr inbounds i8, ptr %0, i64 4
  %134 = load i32, ptr %133, align 4, !tbaa !32
  %135 = and i32 %134, %132
  store i32 %135, ptr %133, align 4, !tbaa !32
  br label %.thread

136:                                              ; preds = %122
  %137 = load ptr, ptr %14, align 8, !tbaa !13
  %.not442 = icmp ult ptr %92, %137
  br i1 %.not442, label %143, label %138, !prof !14

138:                                              ; preds = %136
  %139 = getelementptr inbounds i8, ptr %92, i64 32
  %140 = load ptr, ptr %139, align 8, !tbaa !28
  %141 = icmp eq ptr %140, %41
  %142 = getelementptr inbounds i8, ptr %92, i64 40
  %.sink = select i1 %141, ptr %139, ptr %142
  store ptr %.3, ptr %.sink, align 8, !tbaa !28
  %.not443 = icmp eq ptr %.3, null
  br i1 %.not443, label %.thread, label %144

143:                                              ; preds = %136
  tail call void @abort() #6
  unreachable

144:                                              ; preds = %130, %138
  %145 = load ptr, ptr %14, align 8, !tbaa !13
  %.not444 = icmp ult ptr %.3, %145
  br i1 %.not444, label %164, label %146, !prof !14

146:                                              ; preds = %144
  %147 = getelementptr inbounds i8, ptr %.3, i64 48
  store ptr %92, ptr %147, align 8, !tbaa !24
  %148 = getelementptr inbounds i8, ptr %41, i64 32
  %149 = load ptr, ptr %148, align 8, !tbaa !28
  %.not445 = icmp eq ptr %149, null
  br i1 %.not445, label %155, label %150

150:                                              ; preds = %146
  %.not446 = icmp ult ptr %149, %145
  br i1 %.not446, label %154, label %151, !prof !14

151:                                              ; preds = %150
  %152 = getelementptr inbounds i8, ptr %.3, i64 32
  store ptr %149, ptr %152, align 8, !tbaa !28
  %153 = getelementptr inbounds i8, ptr %149, i64 48
  store ptr %.3, ptr %153, align 8, !tbaa !24
  br label %155

154:                                              ; preds = %150
  tail call void @abort() #6
  unreachable

155:                                              ; preds = %151, %146
  %156 = getelementptr inbounds i8, ptr %41, i64 40
  %157 = load ptr, ptr %156, align 8, !tbaa !28
  %.not447 = icmp eq ptr %157, null
  br i1 %.not447, label %.thread, label %158

158:                                              ; preds = %155
  %159 = load ptr, ptr %14, align 8, !tbaa !13
  %.not448 = icmp ult ptr %157, %159
  br i1 %.not448, label %163, label %160, !prof !14

160:                                              ; preds = %158
  %161 = getelementptr inbounds i8, ptr %.3, i64 40
  store ptr %157, ptr %161, align 8, !tbaa !28
  %162 = getelementptr inbounds i8, ptr %157, i64 48
  store ptr %.3, ptr %162, align 8, !tbaa !24
  br label %.thread

163:                                              ; preds = %158
  tail call void @abort() #6
  unreachable

164:                                              ; preds = %144
  tail call void @abort() #6
  unreachable

165:                                              ; preds = %43
  %166 = getelementptr inbounds i8, ptr %22, i64 8
  %167 = load i64, ptr %166, align 8, !tbaa !15
  %168 = and i64 %167, 3
  %169 = icmp eq i64 %168, 3
  br i1 %169, label %170, label %.thread

170:                                              ; preds = %165
  %171 = getelementptr inbounds i8, ptr %0, i64 8
  store i64 %42, ptr %171, align 8, !tbaa !33
  %172 = and i64 %167, -2
  store i64 %172, ptr %166, align 8, !tbaa !15
  %173 = or i64 %42, 1
  %174 = getelementptr inbounds i8, ptr %41, i64 8
  store i64 %173, ptr %174, align 8, !tbaa !15
  store i64 %42, ptr %22, align 8, !tbaa !17
  br label %437

.thread:                                          ; preds = %.thread529, %165, %76, %.critedge489, %138, %160, %155, %121, %20
  %.1370 = phi i64 [ %21, %20 ], [ %42, %121 ], [ %42, %155 ], [ %42, %160 ], [ %42, %138 ], [ %42, %.critedge489 ], [ %42, %76 ], [ %42, %165 ], [ %42, %.thread529 ]
  %.1 = phi ptr [ %4, %20 ], [ %41, %121 ], [ %41, %155 ], [ %41, %160 ], [ %41, %138 ], [ %41, %.critedge489 ], [ %41, %76 ], [ %41, %165 ], [ %41, %.thread529 ]
  %175 = icmp ult ptr %.1, %22
  br i1 %175, label %176, label %.critedge483, !prof !22

176:                                              ; preds = %.thread
  %177 = getelementptr inbounds i8, ptr %22, i64 8
  %178 = load i64, ptr %177, align 8, !tbaa !15
  %179 = and i64 %178, 1
  %.not523 = icmp eq i64 %179, 0
  br i1 %.not523, label %.critedge483, label %180, !prof !14

180:                                              ; preds = %176
  %181 = and i64 %178, 2
  %.not453 = icmp eq i64 %181, 0
  br i1 %.not453, label %182, label %338

182:                                              ; preds = %180
  %183 = getelementptr inbounds i8, ptr %0, i64 40
  %184 = load ptr, ptr %183, align 8, !tbaa !34
  %185 = icmp eq ptr %22, %184
  br i1 %185, label %186, label %203

186:                                              ; preds = %182
  %187 = getelementptr inbounds i8, ptr %0, i64 16
  %188 = load i64, ptr %187, align 8, !tbaa !35
  %189 = add i64 %188, %.1370
  store i64 %189, ptr %187, align 8, !tbaa !35
  store ptr %.1, ptr %183, align 8, !tbaa !34
  %190 = or i64 %189, 1
  %191 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %190, ptr %191, align 8, !tbaa !15
  %192 = getelementptr inbounds i8, ptr %0, i64 32
  %193 = load ptr, ptr %192, align 8, !tbaa !19
  %194 = icmp eq ptr %.1, %193
  br i1 %194, label %195, label %197

195:                                              ; preds = %186
  store ptr null, ptr %192, align 8, !tbaa !19
  %196 = getelementptr inbounds i8, ptr %0, i64 8
  store i64 0, ptr %196, align 8, !tbaa !33
  br label %197

197:                                              ; preds = %195, %186
  %198 = getelementptr inbounds i8, ptr %0, i64 48
  %199 = load i64, ptr %198, align 8, !tbaa !36
  %200 = icmp ugt i64 %189, %199
  br i1 %200, label %201, label %437

201:                                              ; preds = %197
  %202 = tail call i32 @sys_trim(ptr noundef nonnull %0, i64 noundef 0)
  br label %437

203:                                              ; preds = %182
  %204 = getelementptr inbounds i8, ptr %0, i64 32
  %205 = load ptr, ptr %204, align 8, !tbaa !19
  %206 = icmp eq ptr %22, %205
  br i1 %206, label %207, label %214

207:                                              ; preds = %203
  %208 = getelementptr inbounds i8, ptr %0, i64 8
  %209 = load i64, ptr %208, align 8, !tbaa !33
  %210 = add i64 %209, %.1370
  store i64 %210, ptr %208, align 8, !tbaa !33
  store ptr %.1, ptr %204, align 8, !tbaa !19
  %211 = or i64 %210, 1
  %212 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %211, ptr %212, align 8, !tbaa !15
  %213 = getelementptr inbounds i8, ptr %.1, i64 %210
  store i64 %210, ptr %213, align 8, !tbaa !17
  br label %437

214:                                              ; preds = %203
  %215 = and i64 %178, -8
  %216 = add i64 %215, %.1370
  %217 = icmp ult i64 %178, 256
  br i1 %217, label %218, label %255

218:                                              ; preds = %214
  %219 = lshr i64 %178, 3
  %220 = getelementptr inbounds i8, ptr %22, i64 16
  %221 = load ptr, ptr %220, align 8, !tbaa !20
  %222 = getelementptr inbounds i8, ptr %22, i64 24
  %223 = load ptr, ptr %222, align 8, !tbaa !21
  %224 = trunc nuw nsw i64 %219 to i32
  %.not469 = icmp eq ptr %22, %223
  br i1 %.not469, label %225, label %226

225:                                              ; preds = %218
  tail call void @abort() #6
  unreachable

226:                                              ; preds = %218
  %.not470 = icmp eq ptr %22, %221
  br i1 %.not470, label %227, label %228

227:                                              ; preds = %226
  tail call void @abort() #6
  unreachable

228:                                              ; preds = %226
  %229 = getelementptr inbounds i8, ptr %0, i64 72
  %230 = shl nuw nsw i64 %219, 1
  %231 = getelementptr inbounds [66 x ptr], ptr %229, i64 0, i64 %230
  %232 = icmp eq ptr %221, %231
  br i1 %232, label %.critedge497, label %233

233:                                              ; preds = %228
  %234 = load ptr, ptr %14, align 8, !tbaa !13
  %.not471 = icmp ult ptr %221, %234
  br i1 %.not471, label %.critedge499, label %235

235:                                              ; preds = %233
  %236 = getelementptr inbounds i8, ptr %221, i64 24
  %237 = load ptr, ptr %236, align 8, !tbaa !21
  %238 = icmp eq ptr %237, %22
  br i1 %238, label %.critedge497, label %.critedge499, !prof !22

.critedge497:                                     ; preds = %228, %235
  %239 = icmp eq ptr %223, %221
  br i1 %239, label %240, label %245

240:                                              ; preds = %.critedge497
  %241 = shl nuw i32 1, %224
  %242 = xor i32 %241, -1
  %243 = load i32, ptr %0, align 8, !tbaa !23
  %244 = and i32 %243, %242
  store i32 %244, ptr %0, align 8, !tbaa !23
  br label %332

245:                                              ; preds = %.critedge497
  %246 = icmp eq ptr %223, %231
  br i1 %246, label %.critedge501, label %247

247:                                              ; preds = %245
  %248 = load ptr, ptr %14, align 8, !tbaa !13
  %.not472 = icmp ult ptr %223, %248
  br i1 %.not472, label %.critedge503, label %249

249:                                              ; preds = %247
  %250 = getelementptr inbounds i8, ptr %223, i64 16
  %251 = load ptr, ptr %250, align 8, !tbaa !20
  %252 = icmp eq ptr %251, %22
  br i1 %252, label %.critedge501, label %.critedge503, !prof !22

.critedge501:                                     ; preds = %245, %249
  %253 = getelementptr inbounds i8, ptr %221, i64 24
  store ptr %223, ptr %253, align 8, !tbaa !21
  %254 = getelementptr inbounds i8, ptr %223, i64 16
  store ptr %221, ptr %254, align 8, !tbaa !20
  br label %332

.critedge503:                                     ; preds = %247, %249
  tail call void @abort() #6
  unreachable

.critedge499:                                     ; preds = %233, %235
  tail call void @abort() #6
  unreachable

255:                                              ; preds = %214
  %256 = getelementptr inbounds i8, ptr %22, i64 48
  %257 = load ptr, ptr %256, align 8, !tbaa !24
  %258 = getelementptr inbounds i8, ptr %22, i64 24
  %259 = load ptr, ptr %258, align 8, !tbaa !26
  %.not454 = icmp eq ptr %259, %22
  br i1 %.not454, label %273, label %260

260:                                              ; preds = %255
  %261 = getelementptr inbounds i8, ptr %22, i64 16
  %262 = load ptr, ptr %261, align 8, !tbaa !27
  %263 = load ptr, ptr %14, align 8, !tbaa !13
  %.not460 = icmp ult ptr %262, %263
  br i1 %.not460, label %.critedge505, label %264, !prof !14

264:                                              ; preds = %260
  %265 = getelementptr inbounds i8, ptr %262, i64 24
  %266 = load ptr, ptr %265, align 8, !tbaa !26
  %267 = icmp eq ptr %266, %22
  br i1 %267, label %268, label %.critedge505, !prof !22

268:                                              ; preds = %264
  %269 = getelementptr inbounds i8, ptr %259, i64 16
  %270 = load ptr, ptr %269, align 8, !tbaa !27
  %271 = icmp eq ptr %270, %22
  br i1 %271, label %272, label %.critedge505, !prof !22

272:                                              ; preds = %268
  store ptr %259, ptr %265, align 8, !tbaa !26
  store ptr %262, ptr %269, align 8, !tbaa !27
  br label %288

.critedge505:                                     ; preds = %264, %260, %268
  tail call void @abort() #6
  unreachable

273:                                              ; preds = %255
  %274 = getelementptr inbounds i8, ptr %22, i64 40
  %275 = load ptr, ptr %274, align 8, !tbaa !28
  %.not455 = icmp eq ptr %275, null
  br i1 %.not455, label %276, label %.critedge4.preheader

276:                                              ; preds = %273
  %277 = getelementptr inbounds i8, ptr %22, i64 32
  %278 = load ptr, ptr %277, align 8, !tbaa !28
  %.not456 = icmp eq ptr %278, null
  br i1 %.not456, label %288, label %.critedge4.preheader

.critedge4.preheader:                             ; preds = %276, %273
  %.1391.ph = phi ptr [ %277, %276 ], [ %274, %273 ]
  %.1387.ph = phi ptr [ %278, %276 ], [ %275, %273 ]
  br label %.critedge4

.critedge4:                                       ; preds = %.critedge4.backedge, %.critedge4.preheader
  %.1391 = phi ptr [ %.1391.ph, %.critedge4.preheader ], [ %.1391.be, %.critedge4.backedge ]
  %.1387 = phi ptr [ %.1387.ph, %.critedge4.preheader ], [ %.1387.be, %.critedge4.backedge ]
  %279 = getelementptr inbounds i8, ptr %.1387, i64 40
  %280 = load ptr, ptr %279, align 8, !tbaa !28
  %.not457 = icmp eq ptr %280, null
  br i1 %.not457, label %281, label %.critedge4.backedge

.critedge4.backedge:                              ; preds = %.critedge4, %281
  %.1391.be = phi ptr [ %279, %.critedge4 ], [ %282, %281 ]
  %.1387.be = phi ptr [ %280, %.critedge4 ], [ %283, %281 ]
  br label %.critedge4, !llvm.loop !37

281:                                              ; preds = %.critedge4
  %282 = getelementptr inbounds i8, ptr %.1387, i64 32
  %283 = load ptr, ptr %282, align 8, !tbaa !28
  %.not458 = icmp eq ptr %283, null
  br i1 %.not458, label %284, label %.critedge4.backedge

284:                                              ; preds = %281
  %285 = load ptr, ptr %14, align 8, !tbaa !13
  %.not459 = icmp ult ptr %.1391, %285
  br i1 %.not459, label %287, label %286, !prof !14

286:                                              ; preds = %284
  store ptr null, ptr %.1391, align 8, !tbaa !28
  br label %288

287:                                              ; preds = %284
  tail call void @abort() #6
  unreachable

288:                                              ; preds = %276, %286, %272
  %.3389 = phi ptr [ %259, %272 ], [ %.1387, %286 ], [ null, %276 ]
  %.not461 = icmp eq ptr %257, null
  br i1 %.not461, label %332, label %289

289:                                              ; preds = %288
  %290 = getelementptr inbounds i8, ptr %0, i64 600
  %291 = getelementptr inbounds i8, ptr %22, i64 56
  %292 = load i32, ptr %291, align 8, !tbaa !31
  %293 = zext i32 %292 to i64
  %294 = getelementptr inbounds [32 x ptr], ptr %290, i64 0, i64 %293
  %295 = load ptr, ptr %294, align 8, !tbaa !28
  %296 = icmp eq ptr %22, %295
  br i1 %296, label %297, label %303

297:                                              ; preds = %289
  store ptr %.3389, ptr %294, align 8, !tbaa !28
  %cond508 = icmp eq ptr %.3389, null
  br i1 %cond508, label %.thread531, label %311

.thread531:                                       ; preds = %297
  %298 = shl nuw i32 1, %292
  %299 = xor i32 %298, -1
  %300 = getelementptr inbounds i8, ptr %0, i64 4
  %301 = load i32, ptr %300, align 4, !tbaa !32
  %302 = and i32 %301, %299
  store i32 %302, ptr %300, align 4, !tbaa !32
  br label %332

303:                                              ; preds = %289
  %304 = load ptr, ptr %14, align 8, !tbaa !13
  %.not462 = icmp ult ptr %257, %304
  br i1 %.not462, label %310, label %305, !prof !14

305:                                              ; preds = %303
  %306 = getelementptr inbounds i8, ptr %257, i64 32
  %307 = load ptr, ptr %306, align 8, !tbaa !28
  %308 = icmp eq ptr %307, %22
  %309 = getelementptr inbounds i8, ptr %257, i64 40
  %.sink536 = select i1 %308, ptr %306, ptr %309
  store ptr %.3389, ptr %.sink536, align 8, !tbaa !28
  %.not463 = icmp eq ptr %.3389, null
  br i1 %.not463, label %332, label %311

310:                                              ; preds = %303
  tail call void @abort() #6
  unreachable

311:                                              ; preds = %297, %305
  %312 = load ptr, ptr %14, align 8, !tbaa !13
  %.not464 = icmp ult ptr %.3389, %312
  br i1 %.not464, label %331, label %313, !prof !14

313:                                              ; preds = %311
  %314 = getelementptr inbounds i8, ptr %.3389, i64 48
  store ptr %257, ptr %314, align 8, !tbaa !24
  %315 = getelementptr inbounds i8, ptr %22, i64 32
  %316 = load ptr, ptr %315, align 8, !tbaa !28
  %.not465 = icmp eq ptr %316, null
  br i1 %.not465, label %322, label %317

317:                                              ; preds = %313
  %.not466 = icmp ult ptr %316, %312
  br i1 %.not466, label %321, label %318, !prof !14

318:                                              ; preds = %317
  %319 = getelementptr inbounds i8, ptr %.3389, i64 32
  store ptr %316, ptr %319, align 8, !tbaa !28
  %320 = getelementptr inbounds i8, ptr %316, i64 48
  store ptr %.3389, ptr %320, align 8, !tbaa !24
  br label %322

321:                                              ; preds = %317
  tail call void @abort() #6
  unreachable

322:                                              ; preds = %318, %313
  %323 = getelementptr inbounds i8, ptr %22, i64 40
  %324 = load ptr, ptr %323, align 8, !tbaa !28
  %.not467 = icmp eq ptr %324, null
  br i1 %.not467, label %332, label %325

325:                                              ; preds = %322
  %326 = load ptr, ptr %14, align 8, !tbaa !13
  %.not468 = icmp ult ptr %324, %326
  br i1 %.not468, label %330, label %327, !prof !14

327:                                              ; preds = %325
  %328 = getelementptr inbounds i8, ptr %.3389, i64 40
  store ptr %324, ptr %328, align 8, !tbaa !28
  %329 = getelementptr inbounds i8, ptr %324, i64 48
  store ptr %.3389, ptr %329, align 8, !tbaa !24
  br label %332

330:                                              ; preds = %325
  tail call void @abort() #6
  unreachable

331:                                              ; preds = %311
  tail call void @abort() #6
  unreachable

332:                                              ; preds = %.thread531, %288, %322, %327, %305, %.critedge501, %240
  %333 = or i64 %216, 1
  %334 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %333, ptr %334, align 8, !tbaa !15
  %335 = getelementptr inbounds i8, ptr %.1, i64 %216
  store i64 %216, ptr %335, align 8, !tbaa !17
  %336 = load ptr, ptr %204, align 8, !tbaa !19
  %.not473 = icmp eq ptr %.1, %336
  br i1 %.not473, label %.thread513, label %343

.thread513:                                       ; preds = %332
  %337 = getelementptr inbounds i8, ptr %0, i64 8
  store i64 %216, ptr %337, align 8, !tbaa !33
  br label %437

338:                                              ; preds = %180
  %339 = and i64 %178, -2
  store i64 %339, ptr %177, align 8, !tbaa !15
  %340 = or i64 %.1370, 1
  %341 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %340, ptr %341, align 8, !tbaa !15
  %342 = getelementptr inbounds i8, ptr %.1, i64 %.1370
  store i64 %.1370, ptr %342, align 8, !tbaa !17
  br label %343

343:                                              ; preds = %332, %338
  %.2 = phi i64 [ %.1370, %338 ], [ %216, %332 ]
  %344 = icmp ult i64 %.2, 256
  br i1 %344, label %345, label %369

345:                                              ; preds = %343
  %346 = lshr i64 %.2, 3
  %347 = getelementptr inbounds i8, ptr %0, i64 72
  %348 = shl nuw nsw i64 %346, 1
  %349 = getelementptr inbounds [66 x ptr], ptr %347, i64 0, i64 %348
  %350 = icmp ugt i64 %.2, 31
  br i1 %350, label %352, label %351

351:                                              ; preds = %345
  tail call void @abort() #6
  unreachable

352:                                              ; preds = %345
  %353 = trunc nuw nsw i64 %346 to i32
  %354 = load i32, ptr %0, align 8, !tbaa !23
  %355 = shl nuw i32 1, %353
  %356 = and i32 %354, %355
  %.not479 = icmp eq i32 %356, 0
  br i1 %.not479, label %357, label %359

357:                                              ; preds = %352
  %358 = or i32 %354, %355
  store i32 %358, ptr %0, align 8, !tbaa !23
  br label %364

359:                                              ; preds = %352
  %360 = getelementptr inbounds i8, ptr %349, i64 16
  %361 = load ptr, ptr %360, align 8, !tbaa !20
  %362 = load ptr, ptr %14, align 8, !tbaa !13
  %.not480 = icmp ult ptr %361, %362
  br i1 %.not480, label %363, label %364, !prof !14

363:                                              ; preds = %359
  tail call void @abort() #6
  unreachable

364:                                              ; preds = %359, %357
  %.0385 = phi ptr [ %349, %357 ], [ %361, %359 ]
  %365 = getelementptr inbounds i8, ptr %349, i64 16
  store ptr %.1, ptr %365, align 8, !tbaa !20
  %366 = getelementptr inbounds i8, ptr %.0385, i64 24
  store ptr %.1, ptr %366, align 8, !tbaa !21
  %367 = getelementptr inbounds i8, ptr %.1, i64 16
  store ptr %.0385, ptr %367, align 8, !tbaa !20
  %368 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %349, ptr %368, align 8, !tbaa !21
  tail call void @do_check_free_chunk(ptr noundef nonnull %0, ptr noundef nonnull %.1)
  br label %437

369:                                              ; preds = %343
  %370 = lshr i64 %.2, 8
  %371 = trunc i64 %370 to i32
  %372 = icmp eq i32 %371, 0
  br i1 %372, label %385, label %373

373:                                              ; preds = %369
  %374 = icmp ugt i32 %371, 65535
  br i1 %374, label %385, label %375

375:                                              ; preds = %373
  %376 = tail call range(i32 16, 33) i32 @llvm.ctlz.i32(i32 %371, i1 true)
  %377 = shl nuw nsw i32 %376, 1
  %378 = sub nuw nsw i32 38, %376
  %379 = zext nneg i32 %378 to i64
  %380 = lshr i64 %.2, %379
  %381 = trunc i64 %380 to i32
  %382 = and i32 %381, 1
  %383 = or disjoint i32 %382, %377
  %384 = xor i32 %383, 62
  br label %385

385:                                              ; preds = %373, %369, %375
  %.0379 = phi i32 [ %384, %375 ], [ 0, %369 ], [ 31, %373 ]
  %386 = getelementptr inbounds i8, ptr %0, i64 600
  %387 = zext nneg i32 %.0379 to i64
  %388 = getelementptr inbounds [32 x ptr], ptr %386, i64 0, i64 %387
  %389 = getelementptr inbounds i8, ptr %.1, i64 56
  store i32 %.0379, ptr %389, align 8, !tbaa !31
  %390 = getelementptr inbounds i8, ptr %.1, i64 32
  %391 = getelementptr inbounds i8, ptr %0, i64 4
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %390, i8 0, i64 16, i1 false)
  %392 = load i32, ptr %391, align 4, !tbaa !32
  %393 = shl nuw i32 1, %.0379
  %394 = and i32 %392, %393
  %.not474 = icmp eq i32 %394, 0
  br i1 %.not474, label %395, label %397

395:                                              ; preds = %385
  %396 = or i32 %392, %393
  store i32 %396, ptr %391, align 4, !tbaa !32
  br label %.thread515

397:                                              ; preds = %385
  %398 = load ptr, ptr %388, align 8, !tbaa !28
  %399 = icmp eq i32 %.0379, 31
  %400 = lshr i32 %.0379, 1
  %401 = add nuw nsw i32 %400, 6
  %402 = zext nneg i32 %401 to i64
  %403 = sub nuw nsw i64 63, %402
  %404 = select i1 %399, i64 0, i64 %403
  %405 = shl i64 %.2, %404
  br label %406

406:                                              ; preds = %410, %397
  %.0372 = phi ptr [ %398, %397 ], [ %415, %410 ]
  %.0371 = phi i64 [ %405, %397 ], [ %414, %410 ]
  %407 = getelementptr inbounds i8, ptr %.0372, i64 8
  %408 = load i64, ptr %407, align 8, !tbaa !38
  %409 = and i64 %408, -8
  %.not475 = icmp eq i64 %409, %.2
  br i1 %.not475, label %420, label %410

410:                                              ; preds = %406
  %411 = getelementptr inbounds i8, ptr %.0372, i64 32
  %412 = lshr i64 %.0371, 63
  %413 = getelementptr inbounds [2 x ptr], ptr %411, i64 0, i64 %412
  %414 = shl i64 %.0371, 1
  %415 = load ptr, ptr %413, align 8, !tbaa !28
  %.not477 = icmp eq ptr %415, null
  br i1 %.not477, label %416, label %406

416:                                              ; preds = %410
  %417 = getelementptr inbounds [2 x ptr], ptr %411, i64 0, i64 %412
  %418 = load ptr, ptr %14, align 8, !tbaa !13
  %.not478 = icmp ult ptr %417, %418
  br i1 %.not478, label %419, label %.thread515, !prof !14

419:                                              ; preds = %416
  tail call void @abort() #6
  unreachable

420:                                              ; preds = %406
  %421 = getelementptr inbounds i8, ptr %.0372, i64 16
  %422 = load ptr, ptr %421, align 8, !tbaa !27
  %423 = load ptr, ptr %14, align 8, !tbaa !13
  %.not476 = icmp uge ptr %.0372, %423
  %424 = icmp uge ptr %422, %423
  %spec.select = select i1 %.not476, i1 %424, i1 false
  br i1 %spec.select, label %425, label %427, !prof !22

425:                                              ; preds = %420
  %426 = getelementptr inbounds i8, ptr %422, i64 24
  store ptr %.1, ptr %426, align 8, !tbaa !26
  br label %.thread515

427:                                              ; preds = %420
  tail call void @abort() #6
  unreachable

.thread515:                                       ; preds = %416, %425, %395
  %.sink543 = phi ptr [ %421, %425 ], [ %388, %395 ], [ %417, %416 ]
  %.sink542 = phi i64 [ 16, %425 ], [ 48, %395 ], [ 48, %416 ]
  %.0372.lcssa533.sink = phi ptr [ %422, %425 ], [ %388, %395 ], [ %.0372, %416 ]
  %.1.sink539 = phi ptr [ %.0372, %425 ], [ %.1, %395 ], [ %.1, %416 ]
  %.sink538 = phi i64 [ 48, %425 ], [ 16, %395 ], [ 16, %416 ]
  %.1.sink = phi ptr [ null, %425 ], [ %.1, %395 ], [ %.1, %416 ]
  store ptr %.1, ptr %.sink543, align 8, !tbaa !28
  %428 = getelementptr inbounds i8, ptr %.1, i64 %.sink542
  store ptr %.0372.lcssa533.sink, ptr %428, align 8, !tbaa !28
  %429 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %.1.sink539, ptr %429, align 8, !tbaa !26
  %430 = getelementptr inbounds i8, ptr %.1, i64 %.sink538
  store ptr %.1.sink, ptr %430, align 8, !tbaa !28
  tail call void @do_check_free_chunk(ptr noundef nonnull %0, ptr noundef nonnull %.1)
  %431 = getelementptr inbounds i8, ptr %0, i64 56
  %432 = load i64, ptr %431, align 8, !tbaa !39
  %433 = add i64 %432, -1
  store i64 %433, ptr %431, align 8, !tbaa !39
  %434 = icmp eq i64 %433, 0
  br i1 %434, label %435, label %437

435:                                              ; preds = %.thread515
  %436 = tail call i64 @release_unused_segments(ptr noundef nonnull %0)
  br label %437

.critedge483:                                     ; preds = %.thread, %176, %39, %13, %16
  tail call void @abort() #6
  unreachable

437:                                              ; preds = %207, %201, %197, %.thread515, %435, %364, %35, %28, %170, %.thread513
  %438 = load i32, ptr %5, align 8, !tbaa !5
  %439 = and i32 %438, 2
  %.not481 = icmp eq i32 %439, 0
  br i1 %.not481, label %442, label %440

440:                                              ; preds = %437
  %441 = getelementptr inbounds i8, ptr %0, i64 884
  store atomic i32 0, ptr %441 release, align 4
  br label %442

442:                                              ; preds = %11, %440, %437, %2
  ret void
}

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

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 = { noreturn 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 #2 = { 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 #3 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { nounwind }
attributes #6 = { noreturn nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 880}
!6 = !{!"malloc_state", !7, i64 0, !7, i64 4, !10, i64 8, !10, i64 16, !11, i64 24, !11, i64 32, !11, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !8, i64 72, !8, i64 600, !10, i64 856, !10, i64 864, !10, i64 872, !7, i64 880, !7, i64 884, !12, i64 888, !11, i64 920, !10, i64 928}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"long", !8, i64 0}
!11 = !{!"any pointer", !8, i64 0}
!12 = !{!"malloc_segment", !11, i64 0, !10, i64 8, !11, i64 16, !7, i64 24}
!13 = !{!6, !11, i64 24}
!14 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!15 = !{!16, !10, i64 8}
!16 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24}
!17 = !{!16, !10, i64 0}
!18 = !{!6, !10, i64 856}
!19 = !{!6, !11, i64 32}
!20 = !{!16, !11, i64 16}
!21 = !{!16, !11, i64 24}
!22 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!23 = !{!6, !7, i64 0}
!24 = !{!25, !11, i64 48}
!25 = !{!"malloc_tree_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24, !8, i64 32, !11, i64 48, !7, i64 56}
!26 = !{!25, !11, i64 24}
!27 = !{!25, !11, i64 16}
!28 = !{!11, !11, i64 0}
!29 = distinct !{!29, !30}
!30 = !{!"llvm.loop.mustprogress"}
!31 = !{!25, !7, i64 56}
!32 = !{!6, !7, i64 4}
!33 = !{!6, !10, i64 8}
!34 = !{!6, !11, i64 40}
!35 = !{!6, !10, i64 16}
!36 = !{!6, !10, i64 48}
!37 = distinct !{!37, !30}
!38 = !{!25, !10, i64 8}
!39 = !{!6, !10, i64 56}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopUnrollPass,LowerExpectIntrinsicPass,MemCpyOptPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass