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

; 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_malloced_chunk(ptr noundef, ptr noundef, i64 noundef) #0

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local ptr @mspace_malloc(ptr noundef %0, i64 noundef %1) #0 {
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca i64, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca i64, align 8
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca i32, align 4
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca i64, align 8
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca ptr, align 8
  %24 = alloca i64, align 8
  %25 = alloca ptr, align 8
  %26 = alloca i32, align 4
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca i64, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca i64, align 8
  %33 = alloca i64, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  store ptr %0, ptr %4, align 8, !tbaa !5
  store i64 %1, ptr %5, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #5
  %36 = load ptr, ptr %4, align 8, !tbaa !5
  store ptr %36, ptr %6, align 8, !tbaa !5
  %37 = load ptr, ptr %6, align 8, !tbaa !5
  %38 = getelementptr inbounds %struct.malloc_state, ptr %37, i32 0, i32 15
  %39 = load i32, ptr %38, align 8, !tbaa !11
  %40 = and i32 %39, 2
  %41 = icmp ne i32 %40, 0
  br i1 %41, label %42, label %53

42:                                               ; preds = %2
  %43 = load ptr, ptr %6, align 8, !tbaa !5
  %44 = getelementptr inbounds %struct.malloc_state, ptr %43, i32 0, i32 16
  %45 = atomicrmw xchg ptr %44, i32 1 seq_cst, align 4
  %46 = icmp ne i32 %45, 0
  br i1 %46, label %47, label %52

47:                                               ; preds = %42
  %48 = load ptr, ptr %6, align 8, !tbaa !5
  %49 = getelementptr inbounds %struct.malloc_state, ptr %48, i32 0, i32 16
  %50 = call i32 @spin_acquire_lock(ptr noundef %49)
  %51 = icmp ne i32 %50, 0
  br i1 %51, label %590, label %54

52:                                               ; preds = %42
  br i1 false, label %590, label %54

53:                                               ; preds = %2
  br i1 false, label %590, label %54

54:                                               ; preds = %53, %52, %47
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #5
  %55 = load i64, ptr %5, align 8, !tbaa !9
  %56 = icmp ule i64 %55, 232
  br i1 %56, label %57, label %444

57:                                               ; preds = %54
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  %58 = load i64, ptr %5, align 8, !tbaa !9
  %59 = icmp ult i64 %58, 23
  br i1 %59, label %60, label %61

60:                                               ; preds = %57
  br label %66

61:                                               ; preds = %57
  %62 = load i64, ptr %5, align 8, !tbaa !9
  %63 = add i64 %62, 8
  %64 = add i64 %63, 15
  %65 = and i64 %64, -16
  br label %66

66:                                               ; preds = %61, %60
  %67 = phi i64 [ 32, %60 ], [ %65, %61 ]
  store i64 %67, ptr %8, align 8, !tbaa !9
  %68 = load i64, ptr %8, align 8, !tbaa !9
  %69 = lshr i64 %68, 3
  %70 = trunc i64 %69 to i32
  store i32 %70, ptr %9, align 4, !tbaa !15
  %71 = load ptr, ptr %6, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.malloc_state, ptr %71, i32 0, i32 0
  %73 = load i32, ptr %72, align 8, !tbaa !16
  %74 = load i32, ptr %9, align 4, !tbaa !15
  %75 = lshr i32 %73, %74
  store i32 %75, ptr %10, align 4, !tbaa !15
  %76 = load i32, ptr %10, align 4, !tbaa !15
  %77 = and i32 %76, 3
  %78 = icmp ne i32 %77, 0
  br i1 %78, label %79, label %186

79:                                               ; preds = %66
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  %80 = load i32, ptr %10, align 4, !tbaa !15
  %81 = xor i32 %80, -1
  %82 = and i32 %81, 1
  %83 = load i32, ptr %9, align 4, !tbaa !15
  %84 = add i32 %83, %82
  store i32 %84, ptr %9, align 4, !tbaa !15
  %85 = load ptr, ptr %6, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.malloc_state, ptr %85, i32 0, i32 10
  %87 = load i32, ptr %9, align 4, !tbaa !15
  %88 = shl i32 %87, 1
  %89 = zext i32 %88 to i64
  %90 = getelementptr inbounds [66 x ptr], ptr %86, i64 0, i64 %89
  store ptr %90, ptr %11, align 8, !tbaa !5
  %91 = load ptr, ptr %11, align 8, !tbaa !5
  %92 = getelementptr inbounds %struct.malloc_chunk, ptr %91, i32 0, i32 2
  %93 = load ptr, ptr %92, align 8, !tbaa !17
  store ptr %93, ptr %12, align 8, !tbaa !5
  %94 = load ptr, ptr %12, align 8, !tbaa !5
  %95 = getelementptr inbounds %struct.malloc_chunk, ptr %94, i32 0, i32 1
  %96 = load i64, ptr %95, align 8, !tbaa !19
  %97 = and i64 %96, -8
  %98 = load i32, ptr %9, align 4, !tbaa !15
  %99 = shl i32 %98, 3
  %100 = zext i32 %99 to i64
  %101 = icmp eq i64 %97, %100
  br i1 %101, label %103, label %102

102:                                              ; preds = %79
  call void @abort() #6
  unreachable

103:                                              ; preds = %79
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  %104 = load ptr, ptr %12, align 8, !tbaa !5
  %105 = getelementptr inbounds %struct.malloc_chunk, ptr %104, i32 0, i32 2
  %106 = load ptr, ptr %105, align 8, !tbaa !17
  store ptr %106, ptr %13, align 8, !tbaa !5
  %107 = load ptr, ptr %12, align 8, !tbaa !5
  %108 = load ptr, ptr %11, align 8, !tbaa !5
  %109 = icmp ne ptr %107, %108
  br i1 %109, label %111, label %110

110:                                              ; preds = %103
  call void @abort() #6
  unreachable

111:                                              ; preds = %103
  %112 = load ptr, ptr %12, align 8, !tbaa !5
  %113 = load ptr, ptr %13, align 8, !tbaa !5
  %114 = icmp ne ptr %112, %113
  br i1 %114, label %116, label %115

115:                                              ; preds = %111
  call void @abort() #6
  unreachable

116:                                              ; preds = %111
  %117 = load ptr, ptr %12, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.malloc_chunk, ptr %117, i32 0, i32 1
  %119 = load i64, ptr %118, align 8, !tbaa !19
  %120 = and i64 %119, -8
  %121 = load i32, ptr %9, align 4, !tbaa !15
  %122 = shl i32 %121, 3
  %123 = zext i32 %122 to i64
  %124 = icmp eq i64 %120, %123
  br i1 %124, label %126, label %125

125:                                              ; preds = %116
  call void @abort() #6
  unreachable

126:                                              ; preds = %116
  %127 = load ptr, ptr %11, align 8, !tbaa !5
  %128 = load ptr, ptr %13, align 8, !tbaa !5
  %129 = icmp eq ptr %127, %128
  br i1 %129, label %130, label %138

130:                                              ; preds = %126
  %131 = load i32, ptr %9, align 4, !tbaa !15
  %132 = shl i32 1, %131
  %133 = xor i32 %132, -1
  %134 = load ptr, ptr %6, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.malloc_state, ptr %134, i32 0, i32 0
  %136 = load i32, ptr %135, align 8, !tbaa !16
  %137 = and i32 %136, %133
  store i32 %137, ptr %135, align 8, !tbaa !16
  br label %165

138:                                              ; preds = %126
  %139 = load ptr, ptr %13, align 8, !tbaa !5
  %140 = load ptr, ptr %6, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.malloc_state, ptr %140, i32 0, i32 4
  %142 = load ptr, ptr %141, align 8, !tbaa !20
  %143 = icmp uge ptr %139, %142
  br i1 %143, label %144, label %150

144:                                              ; preds = %138
  %145 = load ptr, ptr %13, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct.malloc_chunk, ptr %145, i32 0, i32 3
  %147 = load ptr, ptr %146, align 8, !tbaa !21
  %148 = load ptr, ptr %12, align 8, !tbaa !5
  %149 = icmp eq ptr %147, %148
  br label %150

150:                                              ; preds = %144, %138
  %151 = phi i1 [ false, %138 ], [ %149, %144 ]
  %152 = zext i1 %151 to i32
  %153 = sext i32 %152 to i64
  %154 = call i64 @llvm.expect.i64(i64 %153, i64 1)
  %155 = icmp ne i64 %154, 0
  br i1 %155, label %156, label %163

156:                                              ; preds = %150
  %157 = load ptr, ptr %11, align 8, !tbaa !5
  %158 = load ptr, ptr %13, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.malloc_chunk, ptr %158, i32 0, i32 3
  store ptr %157, ptr %159, align 8, !tbaa !21
  %160 = load ptr, ptr %13, align 8, !tbaa !5
  %161 = load ptr, ptr %11, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.malloc_chunk, ptr %161, i32 0, i32 2
  store ptr %160, ptr %162, align 8, !tbaa !17
  br label %164

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

164:                                              ; preds = %156
  br label %165

165:                                              ; preds = %164, %130
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  %166 = load i32, ptr %9, align 4, !tbaa !15
  %167 = shl i32 %166, 3
  %168 = zext i32 %167 to i64
  %169 = or i64 %168, 1
  %170 = or i64 %169, 2
  %171 = load ptr, ptr %12, align 8, !tbaa !5
  %172 = getelementptr inbounds %struct.malloc_chunk, ptr %171, i32 0, i32 1
  store i64 %170, ptr %172, align 8, !tbaa !19
  %173 = load ptr, ptr %12, align 8, !tbaa !5
  %174 = load i32, ptr %9, align 4, !tbaa !15
  %175 = shl i32 %174, 3
  %176 = zext i32 %175 to i64
  %177 = getelementptr inbounds i8, ptr %173, i64 %176
  %178 = getelementptr inbounds %struct.malloc_chunk, ptr %177, i32 0, i32 1
  %179 = load i64, ptr %178, align 8, !tbaa !19
  %180 = or i64 %179, 1
  store i64 %180, ptr %178, align 8, !tbaa !19
  %181 = load ptr, ptr %12, align 8, !tbaa !5
  %182 = getelementptr inbounds i8, ptr %181, i64 16
  store ptr %182, ptr %7, align 8, !tbaa !5
  %183 = load ptr, ptr %6, align 8, !tbaa !5
  %184 = load ptr, ptr %7, align 8, !tbaa !5
  %185 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %183, ptr noundef %184, i64 noundef %185)
  store i32 2, ptr %14, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #5
  br label %441

186:                                              ; preds = %66
  %187 = load i64, ptr %8, align 8, !tbaa !9
  %188 = load ptr, ptr %6, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.malloc_state, ptr %188, i32 0, i32 2
  %190 = load i64, ptr %189, align 8, !tbaa !22
  %191 = icmp ugt i64 %187, %190
  br i1 %191, label %192, label %439

192:                                              ; preds = %186
  %193 = load i32, ptr %10, align 4, !tbaa !15
  %194 = icmp ne i32 %193, 0
  br i1 %194, label %195, label %423

195:                                              ; preds = %192
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #5
  %196 = load i32, ptr %10, align 4, !tbaa !15
  %197 = load i32, ptr %9, align 4, !tbaa !15
  %198 = shl i32 %196, %197
  %199 = load i32, ptr %9, align 4, !tbaa !15
  %200 = shl i32 1, %199
  %201 = shl i32 %200, 1
  %202 = load i32, ptr %9, align 4, !tbaa !15
  %203 = shl i32 1, %202
  %204 = shl i32 %203, 1
  %205 = sub i32 0, %204
  %206 = or i32 %201, %205
  %207 = and i32 %198, %206
  store i32 %207, ptr %20, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #5
  %208 = load i32, ptr %20, align 4, !tbaa !15
  %209 = load i32, ptr %20, align 4, !tbaa !15
  %210 = sub i32 0, %209
  %211 = and i32 %208, %210
  store i32 %211, ptr %21, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #5
  %212 = load i32, ptr %21, align 4, !tbaa !15
  %213 = call i32 @llvm.cttz.i32(i32 %212, i1 true)
  store i32 %213, ptr %22, align 4, !tbaa !15
  %214 = load i32, ptr %22, align 4, !tbaa !15
  store i32 %214, ptr %19, align 4, !tbaa !15
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  %215 = load ptr, ptr %6, align 8, !tbaa !5
  %216 = getelementptr inbounds %struct.malloc_state, ptr %215, i32 0, i32 10
  %217 = load i32, ptr %19, align 4, !tbaa !15
  %218 = shl i32 %217, 1
  %219 = zext i32 %218 to i64
  %220 = getelementptr inbounds [66 x ptr], ptr %216, i64 0, i64 %219
  store ptr %220, ptr %15, align 8, !tbaa !5
  %221 = load ptr, ptr %15, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.malloc_chunk, ptr %221, i32 0, i32 2
  %223 = load ptr, ptr %222, align 8, !tbaa !17
  store ptr %223, ptr %16, align 8, !tbaa !5
  %224 = load ptr, ptr %16, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.malloc_chunk, ptr %224, i32 0, i32 1
  %226 = load i64, ptr %225, align 8, !tbaa !19
  %227 = and i64 %226, -8
  %228 = load i32, ptr %19, align 4, !tbaa !15
  %229 = shl i32 %228, 3
  %230 = zext i32 %229 to i64
  %231 = icmp eq i64 %227, %230
  br i1 %231, label %233, label %232

232:                                              ; preds = %195
  call void @abort() #6
  unreachable

233:                                              ; preds = %195
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #5
  %234 = load ptr, ptr %16, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.malloc_chunk, ptr %234, i32 0, i32 2
  %236 = load ptr, ptr %235, align 8, !tbaa !17
  store ptr %236, ptr %23, align 8, !tbaa !5
  %237 = load ptr, ptr %16, align 8, !tbaa !5
  %238 = load ptr, ptr %15, align 8, !tbaa !5
  %239 = icmp ne ptr %237, %238
  br i1 %239, label %241, label %240

240:                                              ; preds = %233
  call void @abort() #6
  unreachable

241:                                              ; preds = %233
  %242 = load ptr, ptr %16, align 8, !tbaa !5
  %243 = load ptr, ptr %23, align 8, !tbaa !5
  %244 = icmp ne ptr %242, %243
  br i1 %244, label %246, label %245

245:                                              ; preds = %241
  call void @abort() #6
  unreachable

246:                                              ; preds = %241
  %247 = load ptr, ptr %16, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.malloc_chunk, ptr %247, i32 0, i32 1
  %249 = load i64, ptr %248, align 8, !tbaa !19
  %250 = and i64 %249, -8
  %251 = load i32, ptr %19, align 4, !tbaa !15
  %252 = shl i32 %251, 3
  %253 = zext i32 %252 to i64
  %254 = icmp eq i64 %250, %253
  br i1 %254, label %256, label %255

255:                                              ; preds = %246
  call void @abort() #6
  unreachable

256:                                              ; preds = %246
  %257 = load ptr, ptr %15, align 8, !tbaa !5
  %258 = load ptr, ptr %23, align 8, !tbaa !5
  %259 = icmp eq ptr %257, %258
  br i1 %259, label %260, label %268

260:                                              ; preds = %256
  %261 = load i32, ptr %19, align 4, !tbaa !15
  %262 = shl i32 1, %261
  %263 = xor i32 %262, -1
  %264 = load ptr, ptr %6, align 8, !tbaa !5
  %265 = getelementptr inbounds %struct.malloc_state, ptr %264, i32 0, i32 0
  %266 = load i32, ptr %265, align 8, !tbaa !16
  %267 = and i32 %266, %263
  store i32 %267, ptr %265, align 8, !tbaa !16
  br label %295

268:                                              ; preds = %256
  %269 = load ptr, ptr %23, align 8, !tbaa !5
  %270 = load ptr, ptr %6, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.malloc_state, ptr %270, i32 0, i32 4
  %272 = load ptr, ptr %271, align 8, !tbaa !20
  %273 = icmp uge ptr %269, %272
  br i1 %273, label %274, label %280

274:                                              ; preds = %268
  %275 = load ptr, ptr %23, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.malloc_chunk, ptr %275, i32 0, i32 3
  %277 = load ptr, ptr %276, align 8, !tbaa !21
  %278 = load ptr, ptr %16, align 8, !tbaa !5
  %279 = icmp eq ptr %277, %278
  br label %280

280:                                              ; preds = %274, %268
  %281 = phi i1 [ false, %268 ], [ %279, %274 ]
  %282 = zext i1 %281 to i32
  %283 = sext i32 %282 to i64
  %284 = call i64 @llvm.expect.i64(i64 %283, i64 1)
  %285 = icmp ne i64 %284, 0
  br i1 %285, label %286, label %293

286:                                              ; preds = %280
  %287 = load ptr, ptr %15, align 8, !tbaa !5
  %288 = load ptr, ptr %23, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.malloc_chunk, ptr %288, i32 0, i32 3
  store ptr %287, ptr %289, align 8, !tbaa !21
  %290 = load ptr, ptr %23, align 8, !tbaa !5
  %291 = load ptr, ptr %15, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.malloc_chunk, ptr %291, i32 0, i32 2
  store ptr %290, ptr %292, align 8, !tbaa !17
  br label %294

293:                                              ; preds = %280
  call void @abort() #6
  unreachable

294:                                              ; preds = %286
  br label %295

295:                                              ; preds = %294, %260
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #5
  %296 = load i32, ptr %19, align 4, !tbaa !15
  %297 = shl i32 %296, 3
  %298 = zext i32 %297 to i64
  %299 = load i64, ptr %8, align 8, !tbaa !9
  %300 = sub i64 %298, %299
  store i64 %300, ptr %18, align 8, !tbaa !9
  %301 = load i64, ptr %18, align 8, !tbaa !9
  %302 = icmp ult i64 %301, 32
  br i1 %302, label %303, label %319

303:                                              ; preds = %295
  %304 = load i32, ptr %19, align 4, !tbaa !15
  %305 = shl i32 %304, 3
  %306 = zext i32 %305 to i64
  %307 = or i64 %306, 1
  %308 = or i64 %307, 2
  %309 = load ptr, ptr %16, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.malloc_chunk, ptr %309, i32 0, i32 1
  store i64 %308, ptr %310, align 8, !tbaa !19
  %311 = load ptr, ptr %16, align 8, !tbaa !5
  %312 = load i32, ptr %19, align 4, !tbaa !15
  %313 = shl i32 %312, 3
  %314 = zext i32 %313 to i64
  %315 = getelementptr inbounds i8, ptr %311, i64 %314
  %316 = getelementptr inbounds %struct.malloc_chunk, ptr %315, i32 0, i32 1
  %317 = load i64, ptr %316, align 8, !tbaa !19
  %318 = or i64 %317, 1
  store i64 %318, ptr %316, align 8, !tbaa !19
  br label %417

319:                                              ; preds = %295
  %320 = load i64, ptr %8, align 8, !tbaa !9
  %321 = or i64 %320, 1
  %322 = or i64 %321, 2
  %323 = load ptr, ptr %16, align 8, !tbaa !5
  %324 = getelementptr inbounds %struct.malloc_chunk, ptr %323, i32 0, i32 1
  store i64 %322, ptr %324, align 8, !tbaa !19
  %325 = load ptr, ptr %16, align 8, !tbaa !5
  %326 = load i64, ptr %8, align 8, !tbaa !9
  %327 = getelementptr inbounds i8, ptr %325, i64 %326
  store ptr %327, ptr %17, align 8, !tbaa !5
  %328 = load i64, ptr %18, align 8, !tbaa !9
  %329 = or i64 %328, 1
  %330 = load ptr, ptr %17, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.malloc_chunk, ptr %330, i32 0, i32 1
  store i64 %329, ptr %331, align 8, !tbaa !19
  %332 = load i64, ptr %18, align 8, !tbaa !9
  %333 = load ptr, ptr %17, align 8, !tbaa !5
  %334 = load i64, ptr %18, align 8, !tbaa !9
  %335 = getelementptr inbounds i8, ptr %333, i64 %334
  %336 = getelementptr inbounds %struct.malloc_chunk, ptr %335, i32 0, i32 0
  store i64 %332, ptr %336, align 8, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #5
  %337 = load ptr, ptr %6, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.malloc_state, ptr %337, i32 0, i32 2
  %339 = load i64, ptr %338, align 8, !tbaa !22
  store i64 %339, ptr %24, align 8, !tbaa !9
  %340 = load i64, ptr %24, align 8, !tbaa !9
  %341 = lshr i64 %340, 3
  %342 = icmp ult i64 %341, 32
  br i1 %342, label %344, label %343

343:                                              ; preds = %319
  call void @abort() #6
  unreachable

344:                                              ; preds = %319
  %345 = load i64, ptr %24, align 8, !tbaa !9
  %346 = icmp ne i64 %345, 0
  br i1 %346, label %347, label %410

347:                                              ; preds = %344
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #5
  %348 = load ptr, ptr %6, align 8, !tbaa !5
  %349 = getelementptr inbounds %struct.malloc_state, ptr %348, i32 0, i32 5
  %350 = load ptr, ptr %349, align 8, !tbaa !24
  store ptr %350, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #5
  %351 = load i64, ptr %24, align 8, !tbaa !9
  %352 = lshr i64 %351, 3
  %353 = trunc i64 %352 to i32
  store i32 %353, ptr %26, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #5
  %354 = load ptr, ptr %6, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.malloc_state, ptr %354, i32 0, i32 10
  %356 = load i32, ptr %26, align 4, !tbaa !15
  %357 = shl i32 %356, 1
  %358 = zext i32 %357 to i64
  %359 = getelementptr inbounds [66 x ptr], ptr %355, i64 0, i64 %358
  store ptr %359, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #5
  %360 = load ptr, ptr %27, align 8, !tbaa !5
  store ptr %360, ptr %28, align 8, !tbaa !5
  %361 = load i64, ptr %24, align 8, !tbaa !9
  %362 = icmp uge i64 %361, 32
  br i1 %362, label %364, label %363

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

364:                                              ; preds = %347
  %365 = load ptr, ptr %6, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.malloc_state, ptr %365, i32 0, i32 0
  %367 = load i32, ptr %366, align 8, !tbaa !16
  %368 = load i32, ptr %26, align 4, !tbaa !15
  %369 = shl i32 1, %368
  %370 = and i32 %367, %369
  %371 = icmp ne i32 %370, 0
  br i1 %371, label %379, label %372

372:                                              ; preds = %364
  %373 = load i32, ptr %26, align 4, !tbaa !15
  %374 = shl i32 1, %373
  %375 = load ptr, ptr %6, align 8, !tbaa !5
  %376 = getelementptr inbounds %struct.malloc_state, ptr %375, i32 0, i32 0
  %377 = load i32, ptr %376, align 8, !tbaa !16
  %378 = or i32 %377, %374
  store i32 %378, ptr %376, align 8, !tbaa !16
  br label %397

379:                                              ; preds = %364
  %380 = load ptr, ptr %27, align 8, !tbaa !5
  %381 = getelementptr inbounds %struct.malloc_chunk, ptr %380, i32 0, i32 2
  %382 = load ptr, ptr %381, align 8, !tbaa !17
  %383 = load ptr, ptr %6, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.malloc_state, ptr %383, i32 0, i32 4
  %385 = load ptr, ptr %384, align 8, !tbaa !20
  %386 = icmp uge ptr %382, %385
  %387 = zext i1 %386 to i32
  %388 = sext i32 %387 to i64
  %389 = call i64 @llvm.expect.i64(i64 %388, i64 1)
  %390 = icmp ne i64 %389, 0
  br i1 %390, label %391, label %395

391:                                              ; preds = %379
  %392 = load ptr, ptr %27, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.malloc_chunk, ptr %392, i32 0, i32 2
  %394 = load ptr, ptr %393, align 8, !tbaa !17
  store ptr %394, ptr %28, align 8, !tbaa !5
  br label %396

395:                                              ; preds = %379
  call void @abort() #6
  unreachable

396:                                              ; preds = %391
  br label %397

397:                                              ; preds = %396, %372
  %398 = load ptr, ptr %25, align 8, !tbaa !5
  %399 = load ptr, ptr %27, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.malloc_chunk, ptr %399, i32 0, i32 2
  store ptr %398, ptr %400, align 8, !tbaa !17
  %401 = load ptr, ptr %25, align 8, !tbaa !5
  %402 = load ptr, ptr %28, align 8, !tbaa !5
  %403 = getelementptr inbounds %struct.malloc_chunk, ptr %402, i32 0, i32 3
  store ptr %401, ptr %403, align 8, !tbaa !21
  %404 = load ptr, ptr %28, align 8, !tbaa !5
  %405 = load ptr, ptr %25, align 8, !tbaa !5
  %406 = getelementptr inbounds %struct.malloc_chunk, ptr %405, i32 0, i32 2
  store ptr %404, ptr %406, align 8, !tbaa !17
  %407 = load ptr, ptr %27, align 8, !tbaa !5
  %408 = load ptr, ptr %25, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.malloc_chunk, ptr %408, i32 0, i32 3
  store ptr %407, ptr %409, align 8, !tbaa !21
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #5
  br label %410

410:                                              ; preds = %397, %344
  %411 = load i64, ptr %18, align 8, !tbaa !9
  %412 = load ptr, ptr %6, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.malloc_state, ptr %412, i32 0, i32 2
  store i64 %411, ptr %413, align 8, !tbaa !22
  %414 = load ptr, ptr %17, align 8, !tbaa !5
  %415 = load ptr, ptr %6, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.malloc_state, ptr %415, i32 0, i32 5
  store ptr %414, ptr %416, align 8, !tbaa !24
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #5
  br label %417

417:                                              ; preds = %410, %303
  %418 = load ptr, ptr %16, align 8, !tbaa !5
  %419 = getelementptr inbounds i8, ptr %418, i64 16
  store ptr %419, ptr %7, align 8, !tbaa !5
  %420 = load ptr, ptr %6, align 8, !tbaa !5
  %421 = load ptr, ptr %7, align 8, !tbaa !5
  %422 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %420, ptr noundef %421, i64 noundef %422)
  store i32 2, ptr %14, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #5
  br label %441

423:                                              ; preds = %192
  %424 = load ptr, ptr %6, align 8, !tbaa !5
  %425 = getelementptr inbounds %struct.malloc_state, ptr %424, i32 0, i32 1
  %426 = load i32, ptr %425, align 4, !tbaa !25
  %427 = icmp ne i32 %426, 0
  br i1 %427, label %428, label %437

428:                                              ; preds = %423
  %429 = load ptr, ptr %6, align 8, !tbaa !5
  %430 = load i64, ptr %8, align 8, !tbaa !9
  %431 = call ptr @tmalloc_small(ptr noundef %429, i64 noundef %430)
  store ptr %431, ptr %7, align 8, !tbaa !5
  %432 = icmp ne ptr %431, null
  br i1 %432, label %433, label %437

433:                                              ; preds = %428
  %434 = load ptr, ptr %6, align 8, !tbaa !5
  %435 = load ptr, ptr %7, align 8, !tbaa !5
  %436 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %434, ptr noundef %435, i64 noundef %436)
  store i32 2, ptr %14, align 4
  br label %441

437:                                              ; preds = %428, %423
  br label %438

438:                                              ; preds = %437
  br label %439

439:                                              ; preds = %438, %186
  br label %440

440:                                              ; preds = %439
  store i32 0, ptr %14, align 4
  br label %441

441:                                              ; preds = %440, %433, %417, %165
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  %442 = load i32, ptr %14, align 4
  switch i32 %442, label %589 [
    i32 0, label %443
    i32 2, label %578
  ]

443:                                              ; preds = %441
  br label %468

444:                                              ; preds = %54
  %445 = load i64, ptr %5, align 8, !tbaa !9
  %446 = icmp uge i64 %445, -128
  br i1 %446, label %447, label %448

447:                                              ; preds = %444
  store i64 -1, ptr %8, align 8, !tbaa !9
  br label %467

448:                                              ; preds = %444
  %449 = load i64, ptr %5, align 8, !tbaa !9
  %450 = add i64 %449, 8
  %451 = add i64 %450, 15
  %452 = and i64 %451, -16
  store i64 %452, ptr %8, align 8, !tbaa !9
  %453 = load ptr, ptr %6, align 8, !tbaa !5
  %454 = getelementptr inbounds %struct.malloc_state, ptr %453, i32 0, i32 1
  %455 = load i32, ptr %454, align 4, !tbaa !25
  %456 = icmp ne i32 %455, 0
  br i1 %456, label %457, label %466

457:                                              ; preds = %448
  %458 = load ptr, ptr %6, align 8, !tbaa !5
  %459 = load i64, ptr %8, align 8, !tbaa !9
  %460 = call ptr @tmalloc_large(ptr noundef %458, i64 noundef %459)
  store ptr %460, ptr %7, align 8, !tbaa !5
  %461 = icmp ne ptr %460, null
  br i1 %461, label %462, label %466

462:                                              ; preds = %457
  %463 = load ptr, ptr %6, align 8, !tbaa !5
  %464 = load ptr, ptr %7, align 8, !tbaa !5
  %465 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %463, ptr noundef %464, i64 noundef %465)
  br label %578

466:                                              ; preds = %457, %448
  br label %467

467:                                              ; preds = %466, %447
  br label %468

468:                                              ; preds = %467, %443
  %469 = load i64, ptr %8, align 8, !tbaa !9
  %470 = load ptr, ptr %6, align 8, !tbaa !5
  %471 = getelementptr inbounds %struct.malloc_state, ptr %470, i32 0, i32 2
  %472 = load i64, ptr %471, align 8, !tbaa !22
  %473 = icmp ule i64 %469, %472
  br i1 %473, label %474, label %534

474:                                              ; preds = %468
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #5
  %475 = load ptr, ptr %6, align 8, !tbaa !5
  %476 = getelementptr inbounds %struct.malloc_state, ptr %475, i32 0, i32 2
  %477 = load i64, ptr %476, align 8, !tbaa !22
  %478 = load i64, ptr %8, align 8, !tbaa !9
  %479 = sub i64 %477, %478
  store i64 %479, ptr %29, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #5
  %480 = load ptr, ptr %6, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.malloc_state, ptr %480, i32 0, i32 5
  %482 = load ptr, ptr %481, align 8, !tbaa !24
  store ptr %482, ptr %30, align 8, !tbaa !5
  %483 = load i64, ptr %29, align 8, !tbaa !9
  %484 = icmp uge i64 %483, 32
  br i1 %484, label %485, label %508

485:                                              ; preds = %474
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #5
  %486 = load ptr, ptr %30, align 8, !tbaa !5
  %487 = load i64, ptr %8, align 8, !tbaa !9
  %488 = getelementptr inbounds i8, ptr %486, i64 %487
  %489 = load ptr, ptr %6, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.malloc_state, ptr %489, i32 0, i32 5
  store ptr %488, ptr %490, align 8, !tbaa !24
  store ptr %488, ptr %31, align 8, !tbaa !5
  %491 = load i64, ptr %29, align 8, !tbaa !9
  %492 = load ptr, ptr %6, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.malloc_state, ptr %492, i32 0, i32 2
  store i64 %491, ptr %493, align 8, !tbaa !22
  %494 = load i64, ptr %29, align 8, !tbaa !9
  %495 = or i64 %494, 1
  %496 = load ptr, ptr %31, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.malloc_chunk, ptr %496, i32 0, i32 1
  store i64 %495, ptr %497, align 8, !tbaa !19
  %498 = load i64, ptr %29, align 8, !tbaa !9
  %499 = load ptr, ptr %31, align 8, !tbaa !5
  %500 = load i64, ptr %29, align 8, !tbaa !9
  %501 = getelementptr inbounds i8, ptr %499, i64 %500
  %502 = getelementptr inbounds %struct.malloc_chunk, ptr %501, i32 0, i32 0
  store i64 %498, ptr %502, align 8, !tbaa !23
  %503 = load i64, ptr %8, align 8, !tbaa !9
  %504 = or i64 %503, 1
  %505 = or i64 %504, 2
  %506 = load ptr, ptr %30, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.malloc_chunk, ptr %506, i32 0, i32 1
  store i64 %505, ptr %507, align 8, !tbaa !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #5
  br label %527

508:                                              ; preds = %474
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #5
  %509 = load ptr, ptr %6, align 8, !tbaa !5
  %510 = getelementptr inbounds %struct.malloc_state, ptr %509, i32 0, i32 2
  %511 = load i64, ptr %510, align 8, !tbaa !22
  store i64 %511, ptr %32, align 8, !tbaa !9
  %512 = load ptr, ptr %6, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.malloc_state, ptr %512, i32 0, i32 2
  store i64 0, ptr %513, align 8, !tbaa !22
  %514 = load ptr, ptr %6, align 8, !tbaa !5
  %515 = getelementptr inbounds %struct.malloc_state, ptr %514, i32 0, i32 5
  store ptr null, ptr %515, align 8, !tbaa !24
  %516 = load i64, ptr %32, align 8, !tbaa !9
  %517 = or i64 %516, 1
  %518 = or i64 %517, 2
  %519 = load ptr, ptr %30, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.malloc_chunk, ptr %519, i32 0, i32 1
  store i64 %518, ptr %520, align 8, !tbaa !19
  %521 = load ptr, ptr %30, align 8, !tbaa !5
  %522 = load i64, ptr %32, align 8, !tbaa !9
  %523 = getelementptr inbounds i8, ptr %521, i64 %522
  %524 = getelementptr inbounds %struct.malloc_chunk, ptr %523, i32 0, i32 1
  %525 = load i64, ptr %524, align 8, !tbaa !19
  %526 = or i64 %525, 1
  store i64 %526, ptr %524, align 8, !tbaa !19
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  br label %527

527:                                              ; preds = %508, %485
  %528 = load ptr, ptr %30, align 8, !tbaa !5
  %529 = getelementptr inbounds i8, ptr %528, i64 16
  store ptr %529, ptr %7, align 8, !tbaa !5
  %530 = load ptr, ptr %6, align 8, !tbaa !5
  %531 = load ptr, ptr %7, align 8, !tbaa !5
  %532 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %530, ptr noundef %531, i64 noundef %532)
  store i32 2, ptr %14, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #5
  %533 = load i32, ptr %14, align 4
  switch i32 %533, label %589 [
    i32 2, label %578
  ]

534:                                              ; preds = %468
  %535 = load i64, ptr %8, align 8, !tbaa !9
  %536 = load ptr, ptr %6, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.malloc_state, ptr %536, i32 0, i32 3
  %538 = load i64, ptr %537, align 8, !tbaa !26
  %539 = icmp ult i64 %535, %538
  br i1 %539, label %540, label %573

540:                                              ; preds = %534
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #5
  %541 = load i64, ptr %8, align 8, !tbaa !9
  %542 = load ptr, ptr %6, align 8, !tbaa !5
  %543 = getelementptr inbounds %struct.malloc_state, ptr %542, i32 0, i32 3
  %544 = load i64, ptr %543, align 8, !tbaa !26
  %545 = sub i64 %544, %541
  store i64 %545, ptr %543, align 8, !tbaa !26
  store i64 %545, ptr %33, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #5
  %546 = load ptr, ptr %6, align 8, !tbaa !5
  %547 = getelementptr inbounds %struct.malloc_state, ptr %546, i32 0, i32 6
  %548 = load ptr, ptr %547, align 8, !tbaa !27
  store ptr %548, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #5
  %549 = load ptr, ptr %34, align 8, !tbaa !5
  %550 = load i64, ptr %8, align 8, !tbaa !9
  %551 = getelementptr inbounds i8, ptr %549, i64 %550
  %552 = load ptr, ptr %6, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.malloc_state, ptr %552, i32 0, i32 6
  store ptr %551, ptr %553, align 8, !tbaa !27
  store ptr %551, ptr %35, align 8, !tbaa !5
  %554 = load i64, ptr %33, align 8, !tbaa !9
  %555 = or i64 %554, 1
  %556 = load ptr, ptr %35, align 8, !tbaa !5
  %557 = getelementptr inbounds %struct.malloc_chunk, ptr %556, i32 0, i32 1
  store i64 %555, ptr %557, align 8, !tbaa !19
  %558 = load i64, ptr %8, align 8, !tbaa !9
  %559 = or i64 %558, 1
  %560 = or i64 %559, 2
  %561 = load ptr, ptr %34, align 8, !tbaa !5
  %562 = getelementptr inbounds %struct.malloc_chunk, ptr %561, i32 0, i32 1
  store i64 %560, ptr %562, align 8, !tbaa !19
  %563 = load ptr, ptr %34, align 8, !tbaa !5
  %564 = getelementptr inbounds i8, ptr %563, i64 16
  store ptr %564, ptr %7, align 8, !tbaa !5
  %565 = load ptr, ptr %6, align 8, !tbaa !5
  %566 = load ptr, ptr %6, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.malloc_state, ptr %566, i32 0, i32 6
  %568 = load ptr, ptr %567, align 8, !tbaa !27
  call void @do_check_top_chunk(ptr noundef %565, ptr noundef %568)
  %569 = load ptr, ptr %6, align 8, !tbaa !5
  %570 = load ptr, ptr %7, align 8, !tbaa !5
  %571 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %569, ptr noundef %570, i64 noundef %571)
  store i32 2, ptr %14, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #5
  %572 = load i32, ptr %14, align 4
  switch i32 %572, label %589 [
    i32 2, label %578
  ]

573:                                              ; preds = %534
  br label %574

574:                                              ; preds = %573
  %575 = load ptr, ptr %6, align 8, !tbaa !5
  %576 = load i64, ptr %8, align 8, !tbaa !9
  %577 = call ptr @sys_alloc(ptr noundef %575, i64 noundef %576)
  store ptr %577, ptr %7, align 8, !tbaa !5
  br label %578

578:                                              ; preds = %574, %540, %527, %462, %441
  %579 = load ptr, ptr %6, align 8, !tbaa !5
  %580 = getelementptr inbounds %struct.malloc_state, ptr %579, i32 0, i32 15
  %581 = load i32, ptr %580, align 8, !tbaa !11
  %582 = and i32 %581, 2
  %583 = icmp ne i32 %582, 0
  br i1 %583, label %584, label %587

584:                                              ; preds = %578
  %585 = load ptr, ptr %6, align 8, !tbaa !5
  %586 = getelementptr inbounds %struct.malloc_state, ptr %585, i32 0, i32 16
  store atomic i32 0, ptr %586 release, align 4
  br label %587

587:                                              ; preds = %584, %578
  %588 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %588, ptr %3, align 8
  store i32 1, ptr %14, align 4
  br label %589

589:                                              ; preds = %587, %540, %527, %441
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #5
  br label %591

590:                                              ; preds = %53, %52, %47
  store ptr null, ptr %3, align 8
  store i32 1, ptr %14, align 4
  br label %591

591:                                              ; preds = %590, %589
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #5
  %592 = load ptr, ptr %3, align 8
  ret ptr %592
}

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 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"long", !7, i64 0}
!11 = !{!12, !13, i64 880}
!12 = !{!"malloc_state", !13, i64 0, !13, i64 4, !10, i64 8, !10, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !7, i64 72, !7, i64 600, !10, i64 856, !10, i64 864, !10, i64 872, !13, i64 880, !13, i64 884, !14, i64 888, !6, i64 920, !10, i64 928}
!13 = !{!"int", !7, i64 0}
!14 = !{!"malloc_segment", !6, i64 0, !10, i64 8, !6, i64 16, !13, i64 24}
!15 = !{!13, !13, i64 0}
!16 = !{!12, !13, i64 0}
!17 = !{!18, !6, i64 16}
!18 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !6, i64 16, !6, i64 24}
!19 = !{!18, !10, i64 8}
!20 = !{!12, !6, i64 24}
!21 = !{!18, !6, i64 24}
!22 = !{!12, !10, i64 8}
!23 = !{!18, !10, i64 0}
!24 = !{!12, !6, i64 32}
!25 = !{!12, !13, i64 4}
!26 = !{!12, !10, i64 16}
!27 = !{!12, !6, i64 40}


; 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_malloced_chunk(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #0

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local ptr @mspace_malloc(ptr noundef %0, i64 noundef %1) local_unnamed_addr #0 {
  %3 = getelementptr inbounds i8, ptr %0, i64 880
  %4 = load i32, ptr %3, align 8, !tbaa !5
  %5 = and i32 %4, 2
  %.not = icmp eq i32 %5, 0
  br i1 %.not, label %11, label %6

6:                                                ; preds = %2
  %7 = getelementptr inbounds i8, ptr %0, i64 884
  %8 = atomicrmw xchg ptr %7, i32 1 seq_cst, align 4
  %.not225 = icmp eq i32 %8, 0
  br i1 %.not225, label %11, label %9

9:                                                ; preds = %6
  %10 = tail call i32 @spin_acquire_lock(ptr noundef nonnull %7)
  %.not226 = icmp eq i32 %10, 0
  br i1 %.not226, label %11, label %215

11:                                               ; preds = %2, %6, %9
  %12 = icmp ult i64 %1, 233
  br i1 %12, label %13, label %161

13:                                               ; preds = %11
  %14 = icmp ult i64 %1, 23
  %15 = add nuw nsw i64 %1, 23
  %16 = and i64 %15, 496
  %17 = select i1 %14, i64 32, i64 %16
  %18 = lshr exact i64 %17, 3
  %19 = trunc nuw nsw i64 %18 to i32
  %20 = load i32, ptr %0, align 8, !tbaa !13
  %21 = lshr i32 %20, %19
  %22 = and i32 %21, 3
  %.not229 = icmp eq i32 %22, 0
  br i1 %.not229, label %66, label %23

23:                                               ; preds = %13
  %24 = and i32 %21, 1
  %25 = or disjoint i32 %24, %19
  %26 = xor i32 %25, 1
  %27 = getelementptr inbounds i8, ptr %0, i64 72
  %28 = shl nuw nsw i32 %26, 1
  %29 = zext nneg i32 %28 to i64
  %30 = getelementptr inbounds [66 x ptr], ptr %27, i64 0, i64 %29
  %31 = getelementptr inbounds i8, ptr %30, i64 16
  %32 = load ptr, ptr %31, align 8, !tbaa !14
  %33 = getelementptr inbounds i8, ptr %32, i64 8
  %34 = load i64, ptr %33, align 8, !tbaa !16
  %35 = and i64 %34, -8
  %36 = shl nuw nsw i32 %26, 3
  %37 = zext nneg i32 %36 to i64
  %38 = icmp eq i64 %35, %37
  br i1 %38, label %40, label %39

39:                                               ; preds = %23
  tail call void @abort() #3
  unreachable

40:                                               ; preds = %23
  %41 = getelementptr inbounds i8, ptr %32, i64 16
  %42 = load ptr, ptr %41, align 8, !tbaa !14
  %.not239 = icmp eq ptr %32, %30
  br i1 %.not239, label %43, label %44

43:                                               ; preds = %40
  tail call void @abort() #3
  unreachable

44:                                               ; preds = %40
  %.not240 = icmp eq ptr %32, %42
  br i1 %.not240, label %45, label %46

45:                                               ; preds = %44
  tail call void @abort() #3
  unreachable

46:                                               ; preds = %44
  %47 = icmp eq ptr %30, %42
  br i1 %47, label %48, label %52

48:                                               ; preds = %46
  %49 = shl nuw i32 1, %26
  %50 = xor i32 %49, -1
  %51 = and i32 %20, %50
  store i32 %51, ptr %0, align 8, !tbaa !13
  br label %60

52:                                               ; preds = %46
  %53 = getelementptr inbounds i8, ptr %0, i64 24
  %54 = load ptr, ptr %53, align 8, !tbaa !17
  %.not241 = icmp ult ptr %42, %54
  br i1 %.not241, label %.critedge, label %55, !prof !18

55:                                               ; preds = %52
  %56 = getelementptr inbounds i8, ptr %42, i64 24
  %57 = load ptr, ptr %56, align 8, !tbaa !19
  %58 = icmp eq ptr %57, %32
  br i1 %58, label %59, label %.critedge, !prof !20

59:                                               ; preds = %55
  store ptr %30, ptr %56, align 8, !tbaa !19
  store ptr %42, ptr %31, align 8, !tbaa !14
  br label %60

.critedge:                                        ; preds = %52, %55
  tail call void @abort() #3
  unreachable

60:                                               ; preds = %59, %48
  %61 = or disjoint i64 %35, 3
  store i64 %61, ptr %33, align 8, !tbaa !16
  %62 = getelementptr inbounds i8, ptr %32, i64 %35
  %63 = getelementptr inbounds i8, ptr %62, i64 8
  %64 = load i64, ptr %63, align 8, !tbaa !16
  %65 = or i64 %64, 1
  store i64 %65, ptr %63, align 8, !tbaa !16
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %41, i64 noundef %17)
  br label %210

66:                                               ; preds = %13
  %67 = getelementptr inbounds i8, ptr %0, i64 8
  %68 = load i64, ptr %67, align 8, !tbaa !21
  %69 = icmp ugt i64 %17, %68
  br i1 %69, label %70, label %.thread

70:                                               ; preds = %66
  %.not230 = icmp eq i32 %21, 0
  br i1 %.not230, label %155, label %71

71:                                               ; preds = %70
  %72 = shl i32 %21, %19
  %73 = shl nuw i32 2, %19
  %74 = sub i32 0, %73
  %75 = or i32 %73, %74
  %76 = and i32 %72, %75
  %77 = tail call range(i32 2, 33) i32 @llvm.cttz.i32(i32 %76, i1 true)
  %78 = getelementptr inbounds i8, ptr %0, i64 72
  %79 = shl nuw nsw i32 %77, 1
  %80 = zext nneg i32 %79 to i64
  %81 = getelementptr inbounds [66 x ptr], ptr %78, i64 0, i64 %80
  %82 = getelementptr inbounds i8, ptr %81, i64 16
  %83 = load ptr, ptr %82, align 8, !tbaa !14
  %84 = getelementptr inbounds i8, ptr %83, i64 8
  %85 = load i64, ptr %84, align 8, !tbaa !16
  %86 = and i64 %85, -8
  %87 = shl nuw nsw i32 %77, 3
  %88 = zext nneg i32 %87 to i64
  %89 = icmp eq i64 %86, %88
  br i1 %89, label %91, label %90

90:                                               ; preds = %71
  tail call void @abort() #3
  unreachable

91:                                               ; preds = %71
  %92 = getelementptr inbounds i8, ptr %83, i64 16
  %93 = load ptr, ptr %92, align 8, !tbaa !14
  %.not233 = icmp eq ptr %83, %81
  br i1 %.not233, label %94, label %95

94:                                               ; preds = %91
  tail call void @abort() #3
  unreachable

95:                                               ; preds = %91
  %.not234 = icmp eq ptr %83, %93
  br i1 %.not234, label %96, label %97

96:                                               ; preds = %95
  tail call void @abort() #3
  unreachable

97:                                               ; preds = %95
  %98 = icmp eq ptr %81, %93
  br i1 %98, label %99, label %103

99:                                               ; preds = %97
  %100 = shl nuw i32 1, %77
  %101 = xor i32 %100, -1
  %102 = and i32 %20, %101
  store i32 %102, ptr %0, align 8, !tbaa !13
  br label %111

103:                                              ; preds = %97
  %104 = getelementptr inbounds i8, ptr %0, i64 24
  %105 = load ptr, ptr %104, align 8, !tbaa !17
  %.not235 = icmp ult ptr %93, %105
  br i1 %.not235, label %.critedge245, label %106, !prof !18

106:                                              ; preds = %103
  %107 = getelementptr inbounds i8, ptr %93, i64 24
  %108 = load ptr, ptr %107, align 8, !tbaa !19
  %109 = icmp eq ptr %108, %83
  br i1 %109, label %110, label %.critedge245, !prof !20

110:                                              ; preds = %106
  store ptr %81, ptr %107, align 8, !tbaa !19
  store ptr %93, ptr %82, align 8, !tbaa !14
  br label %111

.critedge245:                                     ; preds = %103, %106
  tail call void @abort() #3
  unreachable

111:                                              ; preds = %110, %99
  %112 = phi i32 [ %20, %110 ], [ %102, %99 ]
  %113 = sub nsw i64 %86, %17
  %114 = icmp ult i64 %113, 32
  br i1 %114, label %115, label %121

115:                                              ; preds = %111
  %116 = or disjoint i64 %86, 3
  store i64 %116, ptr %84, align 8, !tbaa !16
  %117 = getelementptr inbounds i8, ptr %83, i64 %86
  %118 = getelementptr inbounds i8, ptr %117, i64 8
  %119 = load i64, ptr %118, align 8, !tbaa !16
  %120 = or i64 %119, 1
  store i64 %120, ptr %118, align 8, !tbaa !16
  br label %154

121:                                              ; preds = %111
  %122 = or disjoint i64 %17, 3
  store i64 %122, ptr %84, align 8, !tbaa !16
  %123 = getelementptr inbounds i8, ptr %83, i64 %17
  %124 = or disjoint i64 %113, 1
  %125 = getelementptr inbounds i8, ptr %123, i64 8
  store i64 %124, ptr %125, align 8, !tbaa !16
  %126 = getelementptr inbounds i8, ptr %83, i64 %86
  store i64 %113, ptr %126, align 8, !tbaa !22
  %127 = lshr i64 %68, 3
  %.not236 = icmp eq i64 %68, 0
  br i1 %.not236, label %152, label %128

128:                                              ; preds = %121
  %129 = getelementptr inbounds i8, ptr %0, i64 32
  %130 = load ptr, ptr %129, align 8, !tbaa !23
  %131 = shl nuw nsw i64 %127, 1
  %132 = getelementptr inbounds [66 x ptr], ptr %78, i64 0, i64 %131
  %133 = icmp ugt i64 %68, 31
  br i1 %133, label %135, label %134

134:                                              ; preds = %128
  tail call void @abort() #3
  unreachable

135:                                              ; preds = %128
  %136 = trunc nuw nsw i64 %127 to i32
  %137 = shl nuw nsw i32 1, %136
  %138 = and i32 %112, %137
  %.not237 = icmp eq i32 %138, 0
  br i1 %.not237, label %139, label %141

139:                                              ; preds = %135
  %140 = or i32 %112, %137
  store i32 %140, ptr %0, align 8, !tbaa !13
  br label %147

141:                                              ; preds = %135
  %142 = getelementptr inbounds i8, ptr %132, i64 16
  %143 = load ptr, ptr %142, align 8, !tbaa !14
  %144 = getelementptr inbounds i8, ptr %0, i64 24
  %145 = load ptr, ptr %144, align 8, !tbaa !17
  %.not238 = icmp ult ptr %143, %145
  br i1 %.not238, label %146, label %147, !prof !18

146:                                              ; preds = %141
  tail call void @abort() #3
  unreachable

147:                                              ; preds = %141, %139
  %.0202 = phi ptr [ %132, %139 ], [ %143, %141 ]
  %148 = getelementptr inbounds i8, ptr %132, i64 16
  store ptr %130, ptr %148, align 8, !tbaa !14
  %149 = getelementptr inbounds i8, ptr %.0202, i64 24
  store ptr %130, ptr %149, align 8, !tbaa !19
  %150 = getelementptr inbounds i8, ptr %130, i64 16
  store ptr %.0202, ptr %150, align 8, !tbaa !14
  %151 = getelementptr inbounds i8, ptr %130, i64 24
  store ptr %132, ptr %151, align 8, !tbaa !19
  br label %152

152:                                              ; preds = %147, %121
  store i64 %113, ptr %67, align 8, !tbaa !21
  %153 = getelementptr inbounds i8, ptr %0, i64 32
  store ptr %123, ptr %153, align 8, !tbaa !23
  br label %154

154:                                              ; preds = %152, %115
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %92, i64 noundef %17)
  br label %210

155:                                              ; preds = %70
  %156 = getelementptr inbounds i8, ptr %0, i64 4
  %157 = load i32, ptr %156, align 4, !tbaa !24
  %.not231 = icmp eq i32 %157, 0
  br i1 %.not231, label %.thread, label %158

158:                                              ; preds = %155
  %159 = tail call ptr @tmalloc_small(ptr noundef nonnull %0, i64 noundef %17)
  %.not232 = icmp eq ptr %159, null
  br i1 %.not232, label %.thread, label %160

160:                                              ; preds = %158
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %159, i64 noundef %17)
  br label %210

161:                                              ; preds = %11
  %162 = icmp ugt i64 %1, -129
  br i1 %162, label %.thread, label %163

163:                                              ; preds = %161
  %164 = add nuw i64 %1, 23
  %165 = and i64 %164, -16
  %166 = getelementptr inbounds i8, ptr %0, i64 4
  %167 = load i32, ptr %166, align 4, !tbaa !24
  %.not227 = icmp eq i32 %167, 0
  br i1 %.not227, label %.thread, label %168

168:                                              ; preds = %163
  %169 = tail call ptr @tmalloc_large(ptr noundef nonnull %0, i64 noundef %165)
  %.not228 = icmp eq ptr %169, null
  br i1 %.not228, label %.thread, label %170

170:                                              ; preds = %168
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %169, i64 noundef %165)
  br label %210

.thread:                                          ; preds = %158, %155, %66, %161, %168, %163
  %.0200 = phi i64 [ %165, %168 ], [ %165, %163 ], [ -1, %161 ], [ %17, %66 ], [ %17, %155 ], [ %17, %158 ]
  %171 = getelementptr inbounds i8, ptr %0, i64 8
  %172 = load i64, ptr %171, align 8, !tbaa !21
  %.not242 = icmp ugt i64 %.0200, %172
  br i1 %.not242, label %194, label %173

173:                                              ; preds = %.thread
  %174 = sub i64 %172, %.0200
  %175 = getelementptr inbounds i8, ptr %0, i64 32
  %176 = load ptr, ptr %175, align 8, !tbaa !23
  %177 = icmp ugt i64 %174, 31
  br i1 %177, label %178, label %185

178:                                              ; preds = %173
  %179 = getelementptr inbounds i8, ptr %176, i64 %.0200
  %180 = or i64 %174, 1
  %181 = getelementptr inbounds i8, ptr %179, i64 8
  store i64 %180, ptr %181, align 8, !tbaa !16
  %182 = getelementptr inbounds i8, ptr %176, i64 %172
  store i64 %174, ptr %182, align 8, !tbaa !22
  %183 = or i64 %.0200, 3
  %184 = getelementptr inbounds i8, ptr %176, i64 8
  store i64 %183, ptr %184, align 8, !tbaa !16
  br label %192

185:                                              ; preds = %173
  %186 = or i64 %172, 3
  %187 = getelementptr inbounds i8, ptr %176, i64 8
  store i64 %186, ptr %187, align 8, !tbaa !16
  %188 = getelementptr inbounds i8, ptr %176, i64 %172
  %189 = getelementptr inbounds i8, ptr %188, i64 8
  %190 = load i64, ptr %189, align 8, !tbaa !16
  %191 = or i64 %190, 1
  store i64 %191, ptr %189, align 8, !tbaa !16
  br label %192

192:                                              ; preds = %185, %178
  %.sink250 = phi ptr [ %179, %178 ], [ null, %185 ]
  %.sink = phi i64 [ %174, %178 ], [ 0, %185 ]
  store ptr %.sink250, ptr %175, align 8
  store i64 %.sink, ptr %171, align 8
  %193 = getelementptr inbounds i8, ptr %176, i64 16
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %193, i64 noundef %.0200)
  br label %210

194:                                              ; preds = %.thread
  %195 = getelementptr inbounds i8, ptr %0, i64 16
  %196 = load i64, ptr %195, align 8, !tbaa !25
  %197 = icmp ult i64 %.0200, %196
  br i1 %197, label %198, label %208

198:                                              ; preds = %194
  %199 = sub i64 %196, %.0200
  store i64 %199, ptr %195, align 8, !tbaa !25
  %200 = getelementptr inbounds i8, ptr %0, i64 40
  %201 = load ptr, ptr %200, align 8, !tbaa !26
  %202 = getelementptr inbounds i8, ptr %201, i64 %.0200
  store ptr %202, ptr %200, align 8, !tbaa !26
  %203 = or i64 %199, 1
  %204 = getelementptr inbounds i8, ptr %202, i64 8
  store i64 %203, ptr %204, align 8, !tbaa !16
  %205 = or i64 %.0200, 3
  %206 = getelementptr inbounds i8, ptr %201, i64 8
  store i64 %205, ptr %206, align 8, !tbaa !16
  %207 = getelementptr inbounds i8, ptr %201, i64 16
  tail call void @do_check_top_chunk(ptr noundef nonnull %0, ptr noundef nonnull %202)
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %207, i64 noundef %.0200)
  br label %210

208:                                              ; preds = %194
  %209 = tail call ptr @sys_alloc(ptr noundef nonnull %0, i64 noundef %.0200)
  br label %210

210:                                              ; preds = %60, %154, %160, %198, %192, %208, %170
  %.2 = phi ptr [ %193, %192 ], [ %207, %198 ], [ %209, %208 ], [ %169, %170 ], [ %41, %60 ], [ %92, %154 ], [ %159, %160 ]
  %211 = load i32, ptr %3, align 8, !tbaa !5
  %212 = and i32 %211, 2
  %.not243 = icmp eq i32 %212, 0
  br i1 %.not243, label %215, label %213

213:                                              ; preds = %210
  %214 = getelementptr inbounds i8, ptr %0, i64 884
  store atomic i32 0, ptr %214 release, align 4
  br label %215

215:                                              ; preds = %9, %213, %210
  %.1 = phi ptr [ %.2, %210 ], [ %.2, %213 ], [ null, %9 ]
  ret ptr %.1
}

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { 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 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #3 = { 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, !7, i64 0}
!14 = !{!15, !11, i64 16}
!15 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24}
!16 = !{!15, !10, i64 8}
!17 = !{!6, !11, i64 24}
!18 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!19 = !{!15, !11, i64 24}
!20 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!21 = !{!6, !10, i64 8}
!22 = !{!15, !10, i64 0}
!23 = !{!6, !11, i64 32}
!24 = !{!6, !7, i64 4}
!25 = !{!6, !10, i64 16}
!26 = !{!6, !11, i64 40}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LowerExpectIntrinsicPass,MergedLoadStoreMotionPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass