; 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: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

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

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.i64(i64, i64) #2

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

; Function Attrs: nounwind uwtable
declare hidden void @do_check_malloced_chunk(ptr noundef, ptr noundef, i64 noundef) #3

; 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) #3

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

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

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

; Function Attrs: nounwind uwtable
define dso_local ptr @mspace_malloc_lockless(ptr noundef %0, i64 noundef %1) #3 {
  %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
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #5
  %37 = load i64, ptr %5, align 8, !tbaa !9
  %38 = icmp ule i64 %37, 232
  br i1 %38, label %39, label %426

39:                                               ; preds = %2
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #5
  %40 = load i64, ptr %5, align 8, !tbaa !9
  %41 = icmp ult i64 %40, 23
  br i1 %41, label %42, label %43

42:                                               ; preds = %39
  br label %48

43:                                               ; preds = %39
  %44 = load i64, ptr %5, align 8, !tbaa !9
  %45 = add i64 %44, 8
  %46 = add i64 %45, 15
  %47 = and i64 %46, -16
  br label %48

48:                                               ; preds = %43, %42
  %49 = phi i64 [ 32, %42 ], [ %47, %43 ]
  store i64 %49, ptr %8, align 8, !tbaa !9
  %50 = load i64, ptr %8, align 8, !tbaa !9
  %51 = lshr i64 %50, 3
  %52 = trunc i64 %51 to i32
  store i32 %52, ptr %9, align 4, !tbaa !11
  %53 = load ptr, ptr %6, align 8, !tbaa !5
  %54 = getelementptr inbounds %struct.malloc_state, ptr %53, i32 0, i32 0
  %55 = load i32, ptr %54, align 8, !tbaa !13
  %56 = load i32, ptr %9, align 4, !tbaa !11
  %57 = lshr i32 %55, %56
  store i32 %57, ptr %10, align 4, !tbaa !11
  %58 = load i32, ptr %10, align 4, !tbaa !11
  %59 = and i32 %58, 3
  %60 = icmp ne i32 %59, 0
  br i1 %60, label %61, label %168

61:                                               ; preds = %48
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #5
  %62 = load i32, ptr %10, align 4, !tbaa !11
  %63 = xor i32 %62, -1
  %64 = and i32 %63, 1
  %65 = load i32, ptr %9, align 4, !tbaa !11
  %66 = add i32 %65, %64
  store i32 %66, ptr %9, align 4, !tbaa !11
  %67 = load ptr, ptr %6, align 8, !tbaa !5
  %68 = getelementptr inbounds %struct.malloc_state, ptr %67, i32 0, i32 10
  %69 = load i32, ptr %9, align 4, !tbaa !11
  %70 = shl i32 %69, 1
  %71 = zext i32 %70 to i64
  %72 = getelementptr inbounds [66 x ptr], ptr %68, i64 0, i64 %71
  store ptr %72, ptr %11, align 8, !tbaa !5
  %73 = load ptr, ptr %11, align 8, !tbaa !5
  %74 = getelementptr inbounds %struct.malloc_chunk, ptr %73, i32 0, i32 2
  %75 = load ptr, ptr %74, align 8, !tbaa !16
  store ptr %75, ptr %12, align 8, !tbaa !5
  %76 = load ptr, ptr %12, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.malloc_chunk, ptr %76, i32 0, i32 1
  %78 = load i64, ptr %77, align 8, !tbaa !18
  %79 = and i64 %78, -8
  %80 = load i32, ptr %9, align 4, !tbaa !11
  %81 = shl i32 %80, 3
  %82 = zext i32 %81 to i64
  %83 = icmp eq i64 %79, %82
  br i1 %83, label %85, label %84

84:                                               ; preds = %61
  call void @abort() #6
  unreachable

85:                                               ; preds = %61
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #5
  %86 = load ptr, ptr %12, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.malloc_chunk, ptr %86, i32 0, i32 2
  %88 = load ptr, ptr %87, align 8, !tbaa !16
  store ptr %88, ptr %13, align 8, !tbaa !5
  %89 = load ptr, ptr %12, align 8, !tbaa !5
  %90 = load ptr, ptr %11, align 8, !tbaa !5
  %91 = icmp ne ptr %89, %90
  br i1 %91, label %93, label %92

92:                                               ; preds = %85
  call void @abort() #6
  unreachable

93:                                               ; preds = %85
  %94 = load ptr, ptr %12, align 8, !tbaa !5
  %95 = load ptr, ptr %13, align 8, !tbaa !5
  %96 = icmp ne ptr %94, %95
  br i1 %96, label %98, label %97

97:                                               ; preds = %93
  call void @abort() #6
  unreachable

98:                                               ; preds = %93
  %99 = load ptr, ptr %12, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.malloc_chunk, ptr %99, i32 0, i32 1
  %101 = load i64, ptr %100, align 8, !tbaa !18
  %102 = and i64 %101, -8
  %103 = load i32, ptr %9, align 4, !tbaa !11
  %104 = shl i32 %103, 3
  %105 = zext i32 %104 to i64
  %106 = icmp eq i64 %102, %105
  br i1 %106, label %108, label %107

107:                                              ; preds = %98
  call void @abort() #6
  unreachable

108:                                              ; preds = %98
  %109 = load ptr, ptr %11, align 8, !tbaa !5
  %110 = load ptr, ptr %13, align 8, !tbaa !5
  %111 = icmp eq ptr %109, %110
  br i1 %111, label %112, label %120

112:                                              ; preds = %108
  %113 = load i32, ptr %9, align 4, !tbaa !11
  %114 = shl i32 1, %113
  %115 = xor i32 %114, -1
  %116 = load ptr, ptr %6, align 8, !tbaa !5
  %117 = getelementptr inbounds %struct.malloc_state, ptr %116, i32 0, i32 0
  %118 = load i32, ptr %117, align 8, !tbaa !13
  %119 = and i32 %118, %115
  store i32 %119, ptr %117, align 8, !tbaa !13
  br label %147

120:                                              ; preds = %108
  %121 = load ptr, ptr %13, align 8, !tbaa !5
  %122 = load ptr, ptr %6, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.malloc_state, ptr %122, i32 0, i32 4
  %124 = load ptr, ptr %123, align 8, !tbaa !19
  %125 = icmp uge ptr %121, %124
  br i1 %125, label %126, label %132

126:                                              ; preds = %120
  %127 = load ptr, ptr %13, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.malloc_chunk, ptr %127, i32 0, i32 3
  %129 = load ptr, ptr %128, align 8, !tbaa !20
  %130 = load ptr, ptr %12, align 8, !tbaa !5
  %131 = icmp eq ptr %129, %130
  br label %132

132:                                              ; preds = %126, %120
  %133 = phi i1 [ false, %120 ], [ %131, %126 ]
  %134 = zext i1 %133 to i32
  %135 = sext i32 %134 to i64
  %136 = call i64 @llvm.expect.i64(i64 %135, i64 1)
  %137 = icmp ne i64 %136, 0
  br i1 %137, label %138, label %145

138:                                              ; preds = %132
  %139 = load ptr, ptr %11, align 8, !tbaa !5
  %140 = load ptr, ptr %13, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.malloc_chunk, ptr %140, i32 0, i32 3
  store ptr %139, ptr %141, align 8, !tbaa !20
  %142 = load ptr, ptr %13, align 8, !tbaa !5
  %143 = load ptr, ptr %11, align 8, !tbaa !5
  %144 = getelementptr inbounds %struct.malloc_chunk, ptr %143, i32 0, i32 2
  store ptr %142, ptr %144, align 8, !tbaa !16
  br label %146

145:                                              ; preds = %132
  call void @abort() #6
  unreachable

146:                                              ; preds = %138
  br label %147

147:                                              ; preds = %146, %112
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #5
  %148 = load i32, ptr %9, align 4, !tbaa !11
  %149 = shl i32 %148, 3
  %150 = zext i32 %149 to i64
  %151 = or i64 %150, 1
  %152 = or i64 %151, 2
  %153 = load ptr, ptr %12, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.malloc_chunk, ptr %153, i32 0, i32 1
  store i64 %152, ptr %154, align 8, !tbaa !18
  %155 = load ptr, ptr %12, align 8, !tbaa !5
  %156 = load i32, ptr %9, align 4, !tbaa !11
  %157 = shl i32 %156, 3
  %158 = zext i32 %157 to i64
  %159 = getelementptr inbounds i8, ptr %155, i64 %158
  %160 = getelementptr inbounds %struct.malloc_chunk, ptr %159, i32 0, i32 1
  %161 = load i64, ptr %160, align 8, !tbaa !18
  %162 = or i64 %161, 1
  store i64 %162, ptr %160, align 8, !tbaa !18
  %163 = load ptr, ptr %12, align 8, !tbaa !5
  %164 = getelementptr inbounds i8, ptr %163, i64 16
  store ptr %164, ptr %7, align 8, !tbaa !5
  %165 = load ptr, ptr %6, align 8, !tbaa !5
  %166 = load ptr, ptr %7, align 8, !tbaa !5
  %167 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %165, ptr noundef %166, i64 noundef %167)
  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 %423

168:                                              ; preds = %48
  %169 = load i64, ptr %8, align 8, !tbaa !9
  %170 = load ptr, ptr %6, align 8, !tbaa !5
  %171 = getelementptr inbounds %struct.malloc_state, ptr %170, i32 0, i32 2
  %172 = load i64, ptr %171, align 8, !tbaa !21
  %173 = icmp ugt i64 %169, %172
  br i1 %173, label %174, label %421

174:                                              ; preds = %168
  %175 = load i32, ptr %10, align 4, !tbaa !11
  %176 = icmp ne i32 %175, 0
  br i1 %176, label %177, label %405

177:                                              ; preds = %174
  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
  %178 = load i32, ptr %10, align 4, !tbaa !11
  %179 = load i32, ptr %9, align 4, !tbaa !11
  %180 = shl i32 %178, %179
  %181 = load i32, ptr %9, align 4, !tbaa !11
  %182 = shl i32 1, %181
  %183 = shl i32 %182, 1
  %184 = load i32, ptr %9, align 4, !tbaa !11
  %185 = shl i32 1, %184
  %186 = shl i32 %185, 1
  %187 = sub i32 0, %186
  %188 = or i32 %183, %187
  %189 = and i32 %180, %188
  store i32 %189, ptr %20, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #5
  %190 = load i32, ptr %20, align 4, !tbaa !11
  %191 = load i32, ptr %20, align 4, !tbaa !11
  %192 = sub i32 0, %191
  %193 = and i32 %190, %192
  store i32 %193, ptr %21, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #5
  %194 = load i32, ptr %21, align 4, !tbaa !11
  %195 = call i32 @llvm.cttz.i32(i32 %194, i1 true)
  store i32 %195, ptr %22, align 4, !tbaa !11
  %196 = load i32, ptr %22, align 4, !tbaa !11
  store i32 %196, ptr %19, align 4, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #5
  %197 = load ptr, ptr %6, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct.malloc_state, ptr %197, i32 0, i32 10
  %199 = load i32, ptr %19, align 4, !tbaa !11
  %200 = shl i32 %199, 1
  %201 = zext i32 %200 to i64
  %202 = getelementptr inbounds [66 x ptr], ptr %198, i64 0, i64 %201
  store ptr %202, ptr %15, align 8, !tbaa !5
  %203 = load ptr, ptr %15, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.malloc_chunk, ptr %203, i32 0, i32 2
  %205 = load ptr, ptr %204, align 8, !tbaa !16
  store ptr %205, ptr %16, align 8, !tbaa !5
  %206 = load ptr, ptr %16, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.malloc_chunk, ptr %206, i32 0, i32 1
  %208 = load i64, ptr %207, align 8, !tbaa !18
  %209 = and i64 %208, -8
  %210 = load i32, ptr %19, align 4, !tbaa !11
  %211 = shl i32 %210, 3
  %212 = zext i32 %211 to i64
  %213 = icmp eq i64 %209, %212
  br i1 %213, label %215, label %214

214:                                              ; preds = %177
  call void @abort() #6
  unreachable

215:                                              ; preds = %177
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #5
  %216 = load ptr, ptr %16, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.malloc_chunk, ptr %216, i32 0, i32 2
  %218 = load ptr, ptr %217, align 8, !tbaa !16
  store ptr %218, ptr %23, align 8, !tbaa !5
  %219 = load ptr, ptr %16, align 8, !tbaa !5
  %220 = load ptr, ptr %15, align 8, !tbaa !5
  %221 = icmp ne ptr %219, %220
  br i1 %221, label %223, label %222

222:                                              ; preds = %215
  call void @abort() #6
  unreachable

223:                                              ; preds = %215
  %224 = load ptr, ptr %16, align 8, !tbaa !5
  %225 = load ptr, ptr %23, align 8, !tbaa !5
  %226 = icmp ne ptr %224, %225
  br i1 %226, label %228, label %227

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

228:                                              ; preds = %223
  %229 = load ptr, ptr %16, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.malloc_chunk, ptr %229, i32 0, i32 1
  %231 = load i64, ptr %230, align 8, !tbaa !18
  %232 = and i64 %231, -8
  %233 = load i32, ptr %19, align 4, !tbaa !11
  %234 = shl i32 %233, 3
  %235 = zext i32 %234 to i64
  %236 = icmp eq i64 %232, %235
  br i1 %236, label %238, label %237

237:                                              ; preds = %228
  call void @abort() #6
  unreachable

238:                                              ; preds = %228
  %239 = load ptr, ptr %15, align 8, !tbaa !5
  %240 = load ptr, ptr %23, align 8, !tbaa !5
  %241 = icmp eq ptr %239, %240
  br i1 %241, label %242, label %250

242:                                              ; preds = %238
  %243 = load i32, ptr %19, align 4, !tbaa !11
  %244 = shl i32 1, %243
  %245 = xor i32 %244, -1
  %246 = load ptr, ptr %6, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.malloc_state, ptr %246, i32 0, i32 0
  %248 = load i32, ptr %247, align 8, !tbaa !13
  %249 = and i32 %248, %245
  store i32 %249, ptr %247, align 8, !tbaa !13
  br label %277

250:                                              ; preds = %238
  %251 = load ptr, ptr %23, align 8, !tbaa !5
  %252 = load ptr, ptr %6, align 8, !tbaa !5
  %253 = getelementptr inbounds %struct.malloc_state, ptr %252, i32 0, i32 4
  %254 = load ptr, ptr %253, align 8, !tbaa !19
  %255 = icmp uge ptr %251, %254
  br i1 %255, label %256, label %262

256:                                              ; preds = %250
  %257 = load ptr, ptr %23, align 8, !tbaa !5
  %258 = getelementptr inbounds %struct.malloc_chunk, ptr %257, i32 0, i32 3
  %259 = load ptr, ptr %258, align 8, !tbaa !20
  %260 = load ptr, ptr %16, align 8, !tbaa !5
  %261 = icmp eq ptr %259, %260
  br label %262

262:                                              ; preds = %256, %250
  %263 = phi i1 [ false, %250 ], [ %261, %256 ]
  %264 = zext i1 %263 to i32
  %265 = sext i32 %264 to i64
  %266 = call i64 @llvm.expect.i64(i64 %265, i64 1)
  %267 = icmp ne i64 %266, 0
  br i1 %267, label %268, label %275

268:                                              ; preds = %262
  %269 = load ptr, ptr %15, align 8, !tbaa !5
  %270 = load ptr, ptr %23, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.malloc_chunk, ptr %270, i32 0, i32 3
  store ptr %269, ptr %271, align 8, !tbaa !20
  %272 = load ptr, ptr %23, align 8, !tbaa !5
  %273 = load ptr, ptr %15, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.malloc_chunk, ptr %273, i32 0, i32 2
  store ptr %272, ptr %274, align 8, !tbaa !16
  br label %276

275:                                              ; preds = %262
  call void @abort() #6
  unreachable

276:                                              ; preds = %268
  br label %277

277:                                              ; preds = %276, %242
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #5
  %278 = load i32, ptr %19, align 4, !tbaa !11
  %279 = shl i32 %278, 3
  %280 = zext i32 %279 to i64
  %281 = load i64, ptr %8, align 8, !tbaa !9
  %282 = sub i64 %280, %281
  store i64 %282, ptr %18, align 8, !tbaa !9
  %283 = load i64, ptr %18, align 8, !tbaa !9
  %284 = icmp ult i64 %283, 32
  br i1 %284, label %285, label %301

285:                                              ; preds = %277
  %286 = load i32, ptr %19, align 4, !tbaa !11
  %287 = shl i32 %286, 3
  %288 = zext i32 %287 to i64
  %289 = or i64 %288, 1
  %290 = or i64 %289, 2
  %291 = load ptr, ptr %16, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.malloc_chunk, ptr %291, i32 0, i32 1
  store i64 %290, ptr %292, align 8, !tbaa !18
  %293 = load ptr, ptr %16, align 8, !tbaa !5
  %294 = load i32, ptr %19, align 4, !tbaa !11
  %295 = shl i32 %294, 3
  %296 = zext i32 %295 to i64
  %297 = getelementptr inbounds i8, ptr %293, i64 %296
  %298 = getelementptr inbounds %struct.malloc_chunk, ptr %297, i32 0, i32 1
  %299 = load i64, ptr %298, align 8, !tbaa !18
  %300 = or i64 %299, 1
  store i64 %300, ptr %298, align 8, !tbaa !18
  br label %399

301:                                              ; preds = %277
  %302 = load i64, ptr %8, align 8, !tbaa !9
  %303 = or i64 %302, 1
  %304 = or i64 %303, 2
  %305 = load ptr, ptr %16, align 8, !tbaa !5
  %306 = getelementptr inbounds %struct.malloc_chunk, ptr %305, i32 0, i32 1
  store i64 %304, ptr %306, align 8, !tbaa !18
  %307 = load ptr, ptr %16, align 8, !tbaa !5
  %308 = load i64, ptr %8, align 8, !tbaa !9
  %309 = getelementptr inbounds i8, ptr %307, i64 %308
  store ptr %309, ptr %17, align 8, !tbaa !5
  %310 = load i64, ptr %18, align 8, !tbaa !9
  %311 = or i64 %310, 1
  %312 = load ptr, ptr %17, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.malloc_chunk, ptr %312, i32 0, i32 1
  store i64 %311, ptr %313, align 8, !tbaa !18
  %314 = load i64, ptr %18, align 8, !tbaa !9
  %315 = load ptr, ptr %17, align 8, !tbaa !5
  %316 = load i64, ptr %18, align 8, !tbaa !9
  %317 = getelementptr inbounds i8, ptr %315, i64 %316
  %318 = getelementptr inbounds %struct.malloc_chunk, ptr %317, i32 0, i32 0
  store i64 %314, ptr %318, align 8, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #5
  %319 = load ptr, ptr %6, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.malloc_state, ptr %319, i32 0, i32 2
  %321 = load i64, ptr %320, align 8, !tbaa !21
  store i64 %321, ptr %24, align 8, !tbaa !9
  %322 = load i64, ptr %24, align 8, !tbaa !9
  %323 = lshr i64 %322, 3
  %324 = icmp ult i64 %323, 32
  br i1 %324, label %326, label %325

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

326:                                              ; preds = %301
  %327 = load i64, ptr %24, align 8, !tbaa !9
  %328 = icmp ne i64 %327, 0
  br i1 %328, label %329, label %392

329:                                              ; preds = %326
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #5
  %330 = load ptr, ptr %6, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.malloc_state, ptr %330, i32 0, i32 5
  %332 = load ptr, ptr %331, align 8, !tbaa !23
  store ptr %332, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #5
  %333 = load i64, ptr %24, align 8, !tbaa !9
  %334 = lshr i64 %333, 3
  %335 = trunc i64 %334 to i32
  store i32 %335, ptr %26, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #5
  %336 = load ptr, ptr %6, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.malloc_state, ptr %336, i32 0, i32 10
  %338 = load i32, ptr %26, align 4, !tbaa !11
  %339 = shl i32 %338, 1
  %340 = zext i32 %339 to i64
  %341 = getelementptr inbounds [66 x ptr], ptr %337, i64 0, i64 %340
  store ptr %341, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #5
  %342 = load ptr, ptr %27, align 8, !tbaa !5
  store ptr %342, ptr %28, align 8, !tbaa !5
  %343 = load i64, ptr %24, align 8, !tbaa !9
  %344 = icmp uge i64 %343, 32
  br i1 %344, label %346, label %345

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

346:                                              ; preds = %329
  %347 = load ptr, ptr %6, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.malloc_state, ptr %347, i32 0, i32 0
  %349 = load i32, ptr %348, align 8, !tbaa !13
  %350 = load i32, ptr %26, align 4, !tbaa !11
  %351 = shl i32 1, %350
  %352 = and i32 %349, %351
  %353 = icmp ne i32 %352, 0
  br i1 %353, label %361, label %354

354:                                              ; preds = %346
  %355 = load i32, ptr %26, align 4, !tbaa !11
  %356 = shl i32 1, %355
  %357 = load ptr, ptr %6, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.malloc_state, ptr %357, i32 0, i32 0
  %359 = load i32, ptr %358, align 8, !tbaa !13
  %360 = or i32 %359, %356
  store i32 %360, ptr %358, align 8, !tbaa !13
  br label %379

361:                                              ; preds = %346
  %362 = load ptr, ptr %27, align 8, !tbaa !5
  %363 = getelementptr inbounds %struct.malloc_chunk, ptr %362, i32 0, i32 2
  %364 = load ptr, ptr %363, align 8, !tbaa !16
  %365 = load ptr, ptr %6, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.malloc_state, ptr %365, i32 0, i32 4
  %367 = load ptr, ptr %366, align 8, !tbaa !19
  %368 = icmp uge ptr %364, %367
  %369 = zext i1 %368 to i32
  %370 = sext i32 %369 to i64
  %371 = call i64 @llvm.expect.i64(i64 %370, i64 1)
  %372 = icmp ne i64 %371, 0
  br i1 %372, label %373, label %377

373:                                              ; preds = %361
  %374 = load ptr, ptr %27, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.malloc_chunk, ptr %374, i32 0, i32 2
  %376 = load ptr, ptr %375, align 8, !tbaa !16
  store ptr %376, ptr %28, align 8, !tbaa !5
  br label %378

377:                                              ; preds = %361
  call void @abort() #6
  unreachable

378:                                              ; preds = %373
  br label %379

379:                                              ; preds = %378, %354
  %380 = load ptr, ptr %25, align 8, !tbaa !5
  %381 = load ptr, ptr %27, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.malloc_chunk, ptr %381, i32 0, i32 2
  store ptr %380, ptr %382, align 8, !tbaa !16
  %383 = load ptr, ptr %25, align 8, !tbaa !5
  %384 = load ptr, ptr %28, align 8, !tbaa !5
  %385 = getelementptr inbounds %struct.malloc_chunk, ptr %384, i32 0, i32 3
  store ptr %383, ptr %385, align 8, !tbaa !20
  %386 = load ptr, ptr %28, align 8, !tbaa !5
  %387 = load ptr, ptr %25, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.malloc_chunk, ptr %387, i32 0, i32 2
  store ptr %386, ptr %388, align 8, !tbaa !16
  %389 = load ptr, ptr %27, align 8, !tbaa !5
  %390 = load ptr, ptr %25, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.malloc_chunk, ptr %390, i32 0, i32 3
  store ptr %389, ptr %391, align 8, !tbaa !20
  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 %392

392:                                              ; preds = %379, %326
  %393 = load i64, ptr %18, align 8, !tbaa !9
  %394 = load ptr, ptr %6, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.malloc_state, ptr %394, i32 0, i32 2
  store i64 %393, ptr %395, align 8, !tbaa !21
  %396 = load ptr, ptr %17, align 8, !tbaa !5
  %397 = load ptr, ptr %6, align 8, !tbaa !5
  %398 = getelementptr inbounds %struct.malloc_state, ptr %397, i32 0, i32 5
  store ptr %396, ptr %398, align 8, !tbaa !23
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #5
  br label %399

399:                                              ; preds = %392, %285
  %400 = load ptr, ptr %16, align 8, !tbaa !5
  %401 = getelementptr inbounds i8, ptr %400, i64 16
  store ptr %401, ptr %7, align 8, !tbaa !5
  %402 = load ptr, ptr %6, align 8, !tbaa !5
  %403 = load ptr, ptr %7, align 8, !tbaa !5
  %404 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %402, ptr noundef %403, i64 noundef %404)
  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 %423

405:                                              ; preds = %174
  %406 = load ptr, ptr %6, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.malloc_state, ptr %406, i32 0, i32 1
  %408 = load i32, ptr %407, align 4, !tbaa !24
  %409 = icmp ne i32 %408, 0
  br i1 %409, label %410, label %419

410:                                              ; preds = %405
  %411 = load ptr, ptr %6, align 8, !tbaa !5
  %412 = load i64, ptr %8, align 8, !tbaa !9
  %413 = call ptr @tmalloc_small(ptr noundef %411, i64 noundef %412)
  store ptr %413, ptr %7, align 8, !tbaa !5
  %414 = icmp ne ptr %413, null
  br i1 %414, label %415, label %419

415:                                              ; preds = %410
  %416 = load ptr, ptr %6, align 8, !tbaa !5
  %417 = load ptr, ptr %7, align 8, !tbaa !5
  %418 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %416, ptr noundef %417, i64 noundef %418)
  store i32 2, ptr %14, align 4
  br label %423

419:                                              ; preds = %410, %405
  br label %420

420:                                              ; preds = %419
  br label %421

421:                                              ; preds = %420, %168
  br label %422

422:                                              ; preds = %421
  store i32 0, ptr %14, align 4
  br label %423

423:                                              ; preds = %422, %415, %399, %147
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #5
  %424 = load i32, ptr %14, align 4
  switch i32 %424, label %562 [
    i32 0, label %425
    i32 2, label %560
  ]

425:                                              ; preds = %423
  br label %450

426:                                              ; preds = %2
  %427 = load i64, ptr %5, align 8, !tbaa !9
  %428 = icmp uge i64 %427, -128
  br i1 %428, label %429, label %430

429:                                              ; preds = %426
  store i64 -1, ptr %8, align 8, !tbaa !9
  br label %449

430:                                              ; preds = %426
  %431 = load i64, ptr %5, align 8, !tbaa !9
  %432 = add i64 %431, 8
  %433 = add i64 %432, 15
  %434 = and i64 %433, -16
  store i64 %434, ptr %8, align 8, !tbaa !9
  %435 = load ptr, ptr %6, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.malloc_state, ptr %435, i32 0, i32 1
  %437 = load i32, ptr %436, align 4, !tbaa !24
  %438 = icmp ne i32 %437, 0
  br i1 %438, label %439, label %448

439:                                              ; preds = %430
  %440 = load ptr, ptr %6, align 8, !tbaa !5
  %441 = load i64, ptr %8, align 8, !tbaa !9
  %442 = call ptr @tmalloc_large(ptr noundef %440, i64 noundef %441)
  store ptr %442, ptr %7, align 8, !tbaa !5
  %443 = icmp ne ptr %442, null
  br i1 %443, label %444, label %448

444:                                              ; preds = %439
  %445 = load ptr, ptr %6, align 8, !tbaa !5
  %446 = load ptr, ptr %7, align 8, !tbaa !5
  %447 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %445, ptr noundef %446, i64 noundef %447)
  br label %560

448:                                              ; preds = %439, %430
  br label %449

449:                                              ; preds = %448, %429
  br label %450

450:                                              ; preds = %449, %425
  %451 = load i64, ptr %8, align 8, !tbaa !9
  %452 = load ptr, ptr %6, align 8, !tbaa !5
  %453 = getelementptr inbounds %struct.malloc_state, ptr %452, i32 0, i32 2
  %454 = load i64, ptr %453, align 8, !tbaa !21
  %455 = icmp ule i64 %451, %454
  br i1 %455, label %456, label %516

456:                                              ; preds = %450
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #5
  %457 = load ptr, ptr %6, align 8, !tbaa !5
  %458 = getelementptr inbounds %struct.malloc_state, ptr %457, i32 0, i32 2
  %459 = load i64, ptr %458, align 8, !tbaa !21
  %460 = load i64, ptr %8, align 8, !tbaa !9
  %461 = sub i64 %459, %460
  store i64 %461, ptr %29, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #5
  %462 = load ptr, ptr %6, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.malloc_state, ptr %462, i32 0, i32 5
  %464 = load ptr, ptr %463, align 8, !tbaa !23
  store ptr %464, ptr %30, align 8, !tbaa !5
  %465 = load i64, ptr %29, align 8, !tbaa !9
  %466 = icmp uge i64 %465, 32
  br i1 %466, label %467, label %490

467:                                              ; preds = %456
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #5
  %468 = load ptr, ptr %30, align 8, !tbaa !5
  %469 = load i64, ptr %8, align 8, !tbaa !9
  %470 = getelementptr inbounds i8, ptr %468, i64 %469
  %471 = load ptr, ptr %6, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.malloc_state, ptr %471, i32 0, i32 5
  store ptr %470, ptr %472, align 8, !tbaa !23
  store ptr %470, ptr %31, align 8, !tbaa !5
  %473 = load i64, ptr %29, align 8, !tbaa !9
  %474 = load ptr, ptr %6, align 8, !tbaa !5
  %475 = getelementptr inbounds %struct.malloc_state, ptr %474, i32 0, i32 2
  store i64 %473, ptr %475, align 8, !tbaa !21
  %476 = load i64, ptr %29, align 8, !tbaa !9
  %477 = or i64 %476, 1
  %478 = load ptr, ptr %31, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.malloc_chunk, ptr %478, i32 0, i32 1
  store i64 %477, ptr %479, align 8, !tbaa !18
  %480 = load i64, ptr %29, align 8, !tbaa !9
  %481 = load ptr, ptr %31, align 8, !tbaa !5
  %482 = load i64, ptr %29, align 8, !tbaa !9
  %483 = getelementptr inbounds i8, ptr %481, i64 %482
  %484 = getelementptr inbounds %struct.malloc_chunk, ptr %483, i32 0, i32 0
  store i64 %480, ptr %484, align 8, !tbaa !22
  %485 = load i64, ptr %8, align 8, !tbaa !9
  %486 = or i64 %485, 1
  %487 = or i64 %486, 2
  %488 = load ptr, ptr %30, align 8, !tbaa !5
  %489 = getelementptr inbounds %struct.malloc_chunk, ptr %488, i32 0, i32 1
  store i64 %487, ptr %489, align 8, !tbaa !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #5
  br label %509

490:                                              ; preds = %456
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #5
  %491 = load ptr, ptr %6, align 8, !tbaa !5
  %492 = getelementptr inbounds %struct.malloc_state, ptr %491, i32 0, i32 2
  %493 = load i64, ptr %492, align 8, !tbaa !21
  store i64 %493, ptr %32, align 8, !tbaa !9
  %494 = load ptr, ptr %6, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.malloc_state, ptr %494, i32 0, i32 2
  store i64 0, ptr %495, align 8, !tbaa !21
  %496 = load ptr, ptr %6, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.malloc_state, ptr %496, i32 0, i32 5
  store ptr null, ptr %497, align 8, !tbaa !23
  %498 = load i64, ptr %32, align 8, !tbaa !9
  %499 = or i64 %498, 1
  %500 = or i64 %499, 2
  %501 = load ptr, ptr %30, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.malloc_chunk, ptr %501, i32 0, i32 1
  store i64 %500, ptr %502, align 8, !tbaa !18
  %503 = load ptr, ptr %30, align 8, !tbaa !5
  %504 = load i64, ptr %32, align 8, !tbaa !9
  %505 = getelementptr inbounds i8, ptr %503, i64 %504
  %506 = getelementptr inbounds %struct.malloc_chunk, ptr %505, i32 0, i32 1
  %507 = load i64, ptr %506, align 8, !tbaa !18
  %508 = or i64 %507, 1
  store i64 %508, ptr %506, align 8, !tbaa !18
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #5
  br label %509

509:                                              ; preds = %490, %467
  %510 = load ptr, ptr %30, align 8, !tbaa !5
  %511 = getelementptr inbounds i8, ptr %510, i64 16
  store ptr %511, ptr %7, align 8, !tbaa !5
  %512 = load ptr, ptr %6, align 8, !tbaa !5
  %513 = load ptr, ptr %7, align 8, !tbaa !5
  %514 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %512, ptr noundef %513, i64 noundef %514)
  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
  %515 = load i32, ptr %14, align 4
  switch i32 %515, label %562 [
    i32 2, label %560
  ]

516:                                              ; preds = %450
  %517 = load i64, ptr %8, align 8, !tbaa !9
  %518 = load ptr, ptr %6, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.malloc_state, ptr %518, i32 0, i32 3
  %520 = load i64, ptr %519, align 8, !tbaa !25
  %521 = icmp ult i64 %517, %520
  br i1 %521, label %522, label %555

522:                                              ; preds = %516
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #5
  %523 = load i64, ptr %8, align 8, !tbaa !9
  %524 = load ptr, ptr %6, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.malloc_state, ptr %524, i32 0, i32 3
  %526 = load i64, ptr %525, align 8, !tbaa !25
  %527 = sub i64 %526, %523
  store i64 %527, ptr %525, align 8, !tbaa !25
  store i64 %527, ptr %33, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #5
  %528 = load ptr, ptr %6, align 8, !tbaa !5
  %529 = getelementptr inbounds %struct.malloc_state, ptr %528, i32 0, i32 6
  %530 = load ptr, ptr %529, align 8, !tbaa !26
  store ptr %530, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #5
  %531 = load ptr, ptr %34, align 8, !tbaa !5
  %532 = load i64, ptr %8, align 8, !tbaa !9
  %533 = getelementptr inbounds i8, ptr %531, i64 %532
  %534 = load ptr, ptr %6, align 8, !tbaa !5
  %535 = getelementptr inbounds %struct.malloc_state, ptr %534, i32 0, i32 6
  store ptr %533, ptr %535, align 8, !tbaa !26
  store ptr %533, ptr %35, align 8, !tbaa !5
  %536 = load i64, ptr %33, align 8, !tbaa !9
  %537 = or i64 %536, 1
  %538 = load ptr, ptr %35, align 8, !tbaa !5
  %539 = getelementptr inbounds %struct.malloc_chunk, ptr %538, i32 0, i32 1
  store i64 %537, ptr %539, align 8, !tbaa !18
  %540 = load i64, ptr %8, align 8, !tbaa !9
  %541 = or i64 %540, 1
  %542 = or i64 %541, 2
  %543 = load ptr, ptr %34, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.malloc_chunk, ptr %543, i32 0, i32 1
  store i64 %542, ptr %544, align 8, !tbaa !18
  %545 = load ptr, ptr %34, align 8, !tbaa !5
  %546 = getelementptr inbounds i8, ptr %545, i64 16
  store ptr %546, ptr %7, align 8, !tbaa !5
  %547 = load ptr, ptr %6, align 8, !tbaa !5
  %548 = load ptr, ptr %6, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.malloc_state, ptr %548, i32 0, i32 6
  %550 = load ptr, ptr %549, align 8, !tbaa !26
  call void @do_check_top_chunk(ptr noundef %547, ptr noundef %550)
  %551 = load ptr, ptr %6, align 8, !tbaa !5
  %552 = load ptr, ptr %7, align 8, !tbaa !5
  %553 = load i64, ptr %8, align 8, !tbaa !9
  call void @do_check_malloced_chunk(ptr noundef %551, ptr noundef %552, i64 noundef %553)
  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
  %554 = load i32, ptr %14, align 4
  switch i32 %554, label %562 [
    i32 2, label %560
  ]

555:                                              ; preds = %516
  br label %556

556:                                              ; preds = %555
  %557 = load ptr, ptr %6, align 8, !tbaa !5
  %558 = load i64, ptr %8, align 8, !tbaa !9
  %559 = call ptr @sys_alloc(ptr noundef %557, i64 noundef %558)
  store ptr %559, ptr %7, align 8, !tbaa !5
  br label %560

560:                                              ; preds = %556, %522, %509, %444, %423
  %561 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %561, ptr %3, align 8
  store i32 1, ptr %14, align 4
  br label %562

562:                                              ; preds = %560, %522, %509, %423
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #5
  %563 = load ptr, ptr %3, align 8
  ret ptr %563
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
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 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #3 = { 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 #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, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!14, !12, i64 0}
!14 = !{!"malloc_state", !12, i64 0, !12, 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, !12, i64 880, !12, i64 884, !15, i64 888, !6, i64 920, !10, i64 928}
!15 = !{!"malloc_segment", !6, i64 0, !10, i64 8, !6, i64 16, !12, i64 24}
!16 = !{!17, !6, i64 16}
!17 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !6, i64 16, !6, i64 24}
!18 = !{!17, !10, i64 8}
!19 = !{!14, !6, i64 24}
!20 = !{!17, !6, i64 24}
!21 = !{!14, !10, i64 8}
!22 = !{!17, !10, i64 0}
!23 = !{!14, !6, i64 32}
!24 = !{!14, !12, i64 4}
!25 = !{!14, !10, i64 16}
!26 = !{!14, !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: noreturn nounwind
declare void @abort() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @do_check_malloced_chunk(ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #1

; 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 #1

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

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

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

; Function Attrs: nounwind uwtable
define dso_local ptr @mspace_malloc_lockless(ptr noundef %0, i64 noundef %1) local_unnamed_addr #1 {
  %3 = icmp ult i64 %1, 233
  br i1 %3, label %4, label %152

4:                                                ; preds = %2
  %5 = icmp ult i64 %1, 23
  %6 = add nuw nsw i64 %1, 23
  %7 = and i64 %6, 496
  %8 = select i1 %5, i64 32, i64 %7
  %9 = lshr exact i64 %8, 3
  %10 = trunc nuw nsw i64 %9 to i32
  %11 = load i32, ptr %0, align 8, !tbaa !5
  %12 = lshr i32 %11, %10
  %13 = and i32 %12, 3
  %.not220 = icmp eq i32 %13, 0
  br i1 %.not220, label %57, label %14

14:                                               ; preds = %4
  %15 = and i32 %12, 1
  %16 = or disjoint i32 %15, %10
  %17 = xor i32 %16, 1
  %18 = getelementptr inbounds i8, ptr %0, i64 72
  %19 = shl nuw nsw i32 %17, 1
  %20 = zext nneg i32 %19 to i64
  %21 = getelementptr inbounds [66 x ptr], ptr %18, i64 0, i64 %20
  %22 = getelementptr inbounds i8, ptr %21, i64 16
  %23 = load ptr, ptr %22, align 8, !tbaa !13
  %24 = getelementptr inbounds i8, ptr %23, i64 8
  %25 = load i64, ptr %24, align 8, !tbaa !15
  %26 = and i64 %25, -8
  %27 = shl nuw nsw i32 %17, 3
  %28 = zext nneg i32 %27 to i64
  %29 = icmp eq i64 %26, %28
  br i1 %29, label %31, label %30

30:                                               ; preds = %14
  tail call void @abort() #3
  unreachable

31:                                               ; preds = %14
  %32 = getelementptr inbounds i8, ptr %23, i64 16
  %33 = load ptr, ptr %32, align 8, !tbaa !13
  %.not230 = icmp eq ptr %23, %21
  br i1 %.not230, label %34, label %35

34:                                               ; preds = %31
  tail call void @abort() #3
  unreachable

35:                                               ; preds = %31
  %.not231 = icmp eq ptr %23, %33
  br i1 %.not231, label %36, label %37

36:                                               ; preds = %35
  tail call void @abort() #3
  unreachable

37:                                               ; preds = %35
  %38 = icmp eq ptr %21, %33
  br i1 %38, label %39, label %43

39:                                               ; preds = %37
  %40 = shl nuw i32 1, %17
  %41 = xor i32 %40, -1
  %42 = and i32 %11, %41
  store i32 %42, ptr %0, align 8, !tbaa !5
  br label %51

43:                                               ; preds = %37
  %44 = getelementptr inbounds i8, ptr %0, i64 24
  %45 = load ptr, ptr %44, align 8, !tbaa !16
  %.not232 = icmp ult ptr %33, %45
  br i1 %.not232, label %.critedge, label %46, !prof !17

46:                                               ; preds = %43
  %47 = getelementptr inbounds i8, ptr %33, i64 24
  %48 = load ptr, ptr %47, align 8, !tbaa !18
  %49 = icmp eq ptr %48, %23
  br i1 %49, label %50, label %.critedge, !prof !19

50:                                               ; preds = %46
  store ptr %21, ptr %47, align 8, !tbaa !18
  store ptr %33, ptr %22, align 8, !tbaa !13
  br label %51

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

51:                                               ; preds = %50, %39
  %52 = or disjoint i64 %26, 3
  store i64 %52, ptr %24, align 8, !tbaa !15
  %53 = getelementptr inbounds i8, ptr %23, i64 %26
  %54 = getelementptr inbounds i8, ptr %53, i64 8
  %55 = load i64, ptr %54, align 8, !tbaa !15
  %56 = or i64 %55, 1
  store i64 %56, ptr %54, align 8, !tbaa !15
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %32, i64 noundef %8)
  br label %201

57:                                               ; preds = %4
  %58 = getelementptr inbounds i8, ptr %0, i64 8
  %59 = load i64, ptr %58, align 8, !tbaa !20
  %60 = icmp ugt i64 %8, %59
  br i1 %60, label %61, label %.thread

61:                                               ; preds = %57
  %.not221 = icmp eq i32 %12, 0
  br i1 %.not221, label %146, label %62

62:                                               ; preds = %61
  %63 = shl i32 %12, %10
  %64 = shl nuw i32 2, %10
  %65 = sub i32 0, %64
  %66 = or i32 %64, %65
  %67 = and i32 %63, %66
  %68 = tail call range(i32 2, 33) i32 @llvm.cttz.i32(i32 %67, i1 true)
  %69 = getelementptr inbounds i8, ptr %0, i64 72
  %70 = shl nuw nsw i32 %68, 1
  %71 = zext nneg i32 %70 to i64
  %72 = getelementptr inbounds [66 x ptr], ptr %69, i64 0, i64 %71
  %73 = getelementptr inbounds i8, ptr %72, i64 16
  %74 = load ptr, ptr %73, align 8, !tbaa !13
  %75 = getelementptr inbounds i8, ptr %74, i64 8
  %76 = load i64, ptr %75, align 8, !tbaa !15
  %77 = and i64 %76, -8
  %78 = shl nuw nsw i32 %68, 3
  %79 = zext nneg i32 %78 to i64
  %80 = icmp eq i64 %77, %79
  br i1 %80, label %82, label %81

81:                                               ; preds = %62
  tail call void @abort() #3
  unreachable

82:                                               ; preds = %62
  %83 = getelementptr inbounds i8, ptr %74, i64 16
  %84 = load ptr, ptr %83, align 8, !tbaa !13
  %.not224 = icmp eq ptr %74, %72
  br i1 %.not224, label %85, label %86

85:                                               ; preds = %82
  tail call void @abort() #3
  unreachable

86:                                               ; preds = %82
  %.not225 = icmp eq ptr %74, %84
  br i1 %.not225, label %87, label %88

87:                                               ; preds = %86
  tail call void @abort() #3
  unreachable

88:                                               ; preds = %86
  %89 = icmp eq ptr %72, %84
  br i1 %89, label %90, label %94

90:                                               ; preds = %88
  %91 = shl nuw i32 1, %68
  %92 = xor i32 %91, -1
  %93 = and i32 %11, %92
  store i32 %93, ptr %0, align 8, !tbaa !5
  br label %102

94:                                               ; preds = %88
  %95 = getelementptr inbounds i8, ptr %0, i64 24
  %96 = load ptr, ptr %95, align 8, !tbaa !16
  %.not226 = icmp ult ptr %84, %96
  br i1 %.not226, label %.critedge235, label %97, !prof !17

97:                                               ; preds = %94
  %98 = getelementptr inbounds i8, ptr %84, i64 24
  %99 = load ptr, ptr %98, align 8, !tbaa !18
  %100 = icmp eq ptr %99, %74
  br i1 %100, label %101, label %.critedge235, !prof !19

101:                                              ; preds = %97
  store ptr %72, ptr %98, align 8, !tbaa !18
  store ptr %84, ptr %73, align 8, !tbaa !13
  br label %102

.critedge235:                                     ; preds = %94, %97
  tail call void @abort() #3
  unreachable

102:                                              ; preds = %101, %90
  %103 = phi i32 [ %11, %101 ], [ %93, %90 ]
  %104 = sub nsw i64 %77, %8
  %105 = icmp ult i64 %104, 32
  br i1 %105, label %106, label %112

106:                                              ; preds = %102
  %107 = or disjoint i64 %77, 3
  store i64 %107, ptr %75, align 8, !tbaa !15
  %108 = getelementptr inbounds i8, ptr %74, i64 %77
  %109 = getelementptr inbounds i8, ptr %108, i64 8
  %110 = load i64, ptr %109, align 8, !tbaa !15
  %111 = or i64 %110, 1
  store i64 %111, ptr %109, align 8, !tbaa !15
  br label %145

112:                                              ; preds = %102
  %113 = or disjoint i64 %8, 3
  store i64 %113, ptr %75, align 8, !tbaa !15
  %114 = getelementptr inbounds i8, ptr %74, i64 %8
  %115 = or disjoint i64 %104, 1
  %116 = getelementptr inbounds i8, ptr %114, i64 8
  store i64 %115, ptr %116, align 8, !tbaa !15
  %117 = getelementptr inbounds i8, ptr %74, i64 %77
  store i64 %104, ptr %117, align 8, !tbaa !21
  %118 = lshr i64 %59, 3
  %.not227 = icmp eq i64 %59, 0
  br i1 %.not227, label %143, label %119

119:                                              ; preds = %112
  %120 = getelementptr inbounds i8, ptr %0, i64 32
  %121 = load ptr, ptr %120, align 8, !tbaa !22
  %122 = shl nuw nsw i64 %118, 1
  %123 = getelementptr inbounds [66 x ptr], ptr %69, i64 0, i64 %122
  %124 = icmp ugt i64 %59, 31
  br i1 %124, label %126, label %125

125:                                              ; preds = %119
  tail call void @abort() #3
  unreachable

126:                                              ; preds = %119
  %127 = trunc nuw nsw i64 %118 to i32
  %128 = shl nuw nsw i32 1, %127
  %129 = and i32 %103, %128
  %.not228 = icmp eq i32 %129, 0
  br i1 %.not228, label %130, label %132

130:                                              ; preds = %126
  %131 = or i32 %103, %128
  store i32 %131, ptr %0, align 8, !tbaa !5
  br label %138

132:                                              ; preds = %126
  %133 = getelementptr inbounds i8, ptr %123, i64 16
  %134 = load ptr, ptr %133, align 8, !tbaa !13
  %135 = getelementptr inbounds i8, ptr %0, i64 24
  %136 = load ptr, ptr %135, align 8, !tbaa !16
  %.not229 = icmp ult ptr %134, %136
  br i1 %.not229, label %137, label %138, !prof !17

137:                                              ; preds = %132
  tail call void @abort() #3
  unreachable

138:                                              ; preds = %132, %130
  %.0196 = phi ptr [ %123, %130 ], [ %134, %132 ]
  %139 = getelementptr inbounds i8, ptr %123, i64 16
  store ptr %121, ptr %139, align 8, !tbaa !13
  %140 = getelementptr inbounds i8, ptr %.0196, i64 24
  store ptr %121, ptr %140, align 8, !tbaa !18
  %141 = getelementptr inbounds i8, ptr %121, i64 16
  store ptr %.0196, ptr %141, align 8, !tbaa !13
  %142 = getelementptr inbounds i8, ptr %121, i64 24
  store ptr %123, ptr %142, align 8, !tbaa !18
  br label %143

143:                                              ; preds = %138, %112
  store i64 %104, ptr %58, align 8, !tbaa !20
  %144 = getelementptr inbounds i8, ptr %0, i64 32
  store ptr %114, ptr %144, align 8, !tbaa !22
  br label %145

145:                                              ; preds = %143, %106
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %83, i64 noundef %8)
  br label %201

146:                                              ; preds = %61
  %147 = getelementptr inbounds i8, ptr %0, i64 4
  %148 = load i32, ptr %147, align 4, !tbaa !23
  %.not222 = icmp eq i32 %148, 0
  br i1 %.not222, label %.thread, label %149

149:                                              ; preds = %146
  %150 = tail call ptr @tmalloc_small(ptr noundef nonnull %0, i64 noundef %8)
  %.not223 = icmp eq ptr %150, null
  br i1 %.not223, label %.thread, label %151

151:                                              ; preds = %149
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %150, i64 noundef %8)
  br label %201

152:                                              ; preds = %2
  %153 = icmp ugt i64 %1, -129
  br i1 %153, label %.thread, label %154

154:                                              ; preds = %152
  %155 = add nuw i64 %1, 23
  %156 = and i64 %155, -16
  %157 = getelementptr inbounds i8, ptr %0, i64 4
  %158 = load i32, ptr %157, align 4, !tbaa !23
  %.not = icmp eq i32 %158, 0
  br i1 %.not, label %.thread, label %159

159:                                              ; preds = %154
  %160 = tail call ptr @tmalloc_large(ptr noundef nonnull %0, i64 noundef %156)
  %.not219 = icmp eq ptr %160, null
  br i1 %.not219, label %.thread, label %161

161:                                              ; preds = %159
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %160, i64 noundef %156)
  br label %201

.thread:                                          ; preds = %149, %146, %57, %152, %159, %154
  %.0194 = phi i64 [ %156, %159 ], [ %156, %154 ], [ -1, %152 ], [ %8, %57 ], [ %8, %146 ], [ %8, %149 ]
  %162 = getelementptr inbounds i8, ptr %0, i64 8
  %163 = load i64, ptr %162, align 8, !tbaa !20
  %.not233 = icmp ugt i64 %.0194, %163
  br i1 %.not233, label %185, label %164

164:                                              ; preds = %.thread
  %165 = sub i64 %163, %.0194
  %166 = getelementptr inbounds i8, ptr %0, i64 32
  %167 = load ptr, ptr %166, align 8, !tbaa !22
  %168 = icmp ugt i64 %165, 31
  br i1 %168, label %169, label %176

169:                                              ; preds = %164
  %170 = getelementptr inbounds i8, ptr %167, i64 %.0194
  %171 = or i64 %165, 1
  %172 = getelementptr inbounds i8, ptr %170, i64 8
  store i64 %171, ptr %172, align 8, !tbaa !15
  %173 = getelementptr inbounds i8, ptr %167, i64 %163
  store i64 %165, ptr %173, align 8, !tbaa !21
  %174 = or i64 %.0194, 3
  %175 = getelementptr inbounds i8, ptr %167, i64 8
  store i64 %174, ptr %175, align 8, !tbaa !15
  br label %183

176:                                              ; preds = %164
  %177 = or i64 %163, 3
  %178 = getelementptr inbounds i8, ptr %167, i64 8
  store i64 %177, ptr %178, align 8, !tbaa !15
  %179 = getelementptr inbounds i8, ptr %167, i64 %163
  %180 = getelementptr inbounds i8, ptr %179, i64 8
  %181 = load i64, ptr %180, align 8, !tbaa !15
  %182 = or i64 %181, 1
  store i64 %182, ptr %180, align 8, !tbaa !15
  br label %183

183:                                              ; preds = %176, %169
  %.sink240 = phi ptr [ %170, %169 ], [ null, %176 ]
  %.sink = phi i64 [ %165, %169 ], [ 0, %176 ]
  store ptr %.sink240, ptr %166, align 8
  store i64 %.sink, ptr %162, align 8
  %184 = getelementptr inbounds i8, ptr %167, i64 16
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %184, i64 noundef %.0194)
  br label %201

185:                                              ; preds = %.thread
  %186 = getelementptr inbounds i8, ptr %0, i64 16
  %187 = load i64, ptr %186, align 8, !tbaa !24
  %188 = icmp ult i64 %.0194, %187
  br i1 %188, label %189, label %199

189:                                              ; preds = %185
  %190 = sub i64 %187, %.0194
  store i64 %190, ptr %186, align 8, !tbaa !24
  %191 = getelementptr inbounds i8, ptr %0, i64 40
  %192 = load ptr, ptr %191, align 8, !tbaa !25
  %193 = getelementptr inbounds i8, ptr %192, i64 %.0194
  store ptr %193, ptr %191, align 8, !tbaa !25
  %194 = or i64 %190, 1
  %195 = getelementptr inbounds i8, ptr %193, i64 8
  store i64 %194, ptr %195, align 8, !tbaa !15
  %196 = or i64 %.0194, 3
  %197 = getelementptr inbounds i8, ptr %192, i64 8
  store i64 %196, ptr %197, align 8, !tbaa !15
  %198 = getelementptr inbounds i8, ptr %192, i64 16
  tail call void @do_check_top_chunk(ptr noundef nonnull %0, ptr noundef nonnull %193)
  tail call void @do_check_malloced_chunk(ptr noundef nonnull %0, ptr noundef nonnull %198, i64 noundef %.0194)
  br label %201

199:                                              ; preds = %185
  %200 = tail call ptr @sys_alloc(ptr noundef nonnull %0, i64 noundef %.0194)
  br label %201

201:                                              ; preds = %51, %145, %151, %161, %199, %183, %189
  %.2 = phi ptr [ %184, %183 ], [ %198, %189 ], [ %200, %199 ], [ %160, %161 ], [ %32, %51 ], [ %83, %145 ], [ %150, %151 ]
  ret ptr %.2
}

attributes #0 = { 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 #1 = { 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 #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 0}
!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 = !{!14, !11, i64 16}
!14 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24}
!15 = !{!14, !10, i64 8}
!16 = !{!6, !11, i64 24}
!17 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!18 = !{!14, !11, i64 24}
!19 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!20 = !{!6, !10, i64 8}
!21 = !{!14, !10, i64 0}
!22 = !{!6, !11, i64 32}
!23 = !{!6, !7, i64 4}
!24 = !{!6, !10, i64 16}
!25 = !{!6, !11, i64 40}


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