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

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.malloc_state = type { i32, i32, i64, i64, ptr, ptr, ptr, i64, i64, i64, [66 x ptr], [32 x ptr], i64, i64, i64, i32, i32, %struct.malloc_segment, ptr, i64 }
%struct.malloc_segment = type { ptr, i64, ptr, i32 }
%struct.malloc_chunk = type { i64, i64, ptr, ptr }
%struct.malloc_tree_chunk = type { i64, i64, ptr, ptr, [2 x ptr], ptr, i32 }

@_gm_ = external hidden global %struct.malloc_state, align 8

; 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
define dso_local void @dlfree(ptr noundef %0) #0 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca i64, align 8
  %5 = alloca ptr, align 8
  %6 = alloca i64, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca ptr, align 8
  %10 = alloca i32, align 4
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca ptr, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca ptr, align 8
  %17 = alloca ptr, align 8
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca i32, align 4
  %21 = alloca i64, align 8
  %22 = alloca i64, align 8
  %23 = alloca i64, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, align 8
  %26 = alloca i32, align 4
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca ptr, align 8
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca i32, align 4
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca i32, align 4
  %42 = alloca i32, align 4
  %43 = alloca i32, align 4
  %44 = alloca ptr, align 8
  %45 = alloca i64, align 8
  %46 = alloca ptr, align 8
  %47 = alloca ptr, align 8
  store ptr %0, ptr %2, align 8, !tbaa !5
  %48 = load ptr, ptr %2, align 8, !tbaa !5
  %49 = icmp ne ptr %48, null
  br i1 %49, label %50, label %1148

50:                                               ; preds = %1
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #6
  %51 = load ptr, ptr %2, align 8, !tbaa !5
  %52 = getelementptr inbounds i8, ptr %51, i64 -16
  store ptr %52, ptr %3, align 8, !tbaa !5
  %53 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 15), align 8, !tbaa !9
  %54 = and i32 %53, 2
  %55 = icmp ne i32 %54, 0
  br i1 %55, label %56, label %63

56:                                               ; preds = %50
  %57 = atomicrmw xchg ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 16), i32 1 seq_cst, align 4
  %58 = icmp ne i32 %57, 0
  br i1 %58, label %59, label %62

59:                                               ; preds = %56
  %60 = call i32 @spin_acquire_lock(ptr noundef getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 16))
  %61 = icmp ne i32 %60, 0
  br i1 %61, label %1147, label %64

62:                                               ; preds = %56
  br i1 false, label %1147, label %64

63:                                               ; preds = %50
  br i1 false, label %1147, label %64

64:                                               ; preds = %63, %62, %59
  %65 = load ptr, ptr %3, align 8, !tbaa !5
  call void @do_check_inuse_chunk(ptr noundef @_gm_, ptr noundef %65)
  %66 = load ptr, ptr %3, align 8, !tbaa !5
  %67 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %68 = icmp uge ptr %66, %67
  br i1 %68, label %69, label %75

69:                                               ; preds = %64
  %70 = load ptr, ptr %3, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.malloc_chunk, ptr %70, i32 0, i32 1
  %72 = load i64, ptr %71, align 8, !tbaa !15
  %73 = and i64 %72, 3
  %74 = icmp ne i64 %73, 1
  br label %75

75:                                               ; preds = %69, %64
  %76 = phi i1 [ false, %64 ], [ %74, %69 ]
  %77 = zext i1 %76 to i32
  %78 = sext i32 %77 to i64
  %79 = call i64 @llvm.expect.i64(i64 %78, i64 1)
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %81, label %1139

81:                                               ; preds = %75
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #6
  %82 = load ptr, ptr %3, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.malloc_chunk, ptr %82, i32 0, i32 1
  %84 = load i64, ptr %83, align 8, !tbaa !15
  %85 = and i64 %84, -8
  store i64 %85, ptr %4, align 8, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #6
  %86 = load ptr, ptr %3, align 8, !tbaa !5
  %87 = load i64, ptr %4, align 8, !tbaa !17
  %88 = getelementptr inbounds i8, ptr %86, i64 %87
  store ptr %88, ptr %5, align 8, !tbaa !5
  %89 = load ptr, ptr %3, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.malloc_chunk, ptr %89, i32 0, i32 1
  %91 = load i64, ptr %90, align 8, !tbaa !15
  %92 = and i64 %91, 1
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %489, label %94

94:                                               ; preds = %81
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #6
  %95 = load ptr, ptr %3, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.malloc_chunk, ptr %95, i32 0, i32 0
  %97 = load i64, ptr %96, align 8, !tbaa !18
  store i64 %97, ptr %6, align 8, !tbaa !17
  %98 = load ptr, ptr %3, align 8, !tbaa !5
  %99 = getelementptr inbounds %struct.malloc_chunk, ptr %98, i32 0, i32 1
  %100 = load i64, ptr %99, align 8, !tbaa !15
  %101 = and i64 %100, 3
  %102 = icmp eq i64 %101, 0
  br i1 %102, label %103, label %120

103:                                              ; preds = %94
  %104 = load i64, ptr %6, align 8, !tbaa !17
  %105 = add i64 %104, 32
  %106 = load i64, ptr %4, align 8, !tbaa !17
  %107 = add i64 %106, %105
  store i64 %107, ptr %4, align 8, !tbaa !17
  %108 = load ptr, ptr %3, align 8, !tbaa !5
  %109 = load i64, ptr %6, align 8, !tbaa !17
  %110 = sub i64 0, %109
  %111 = getelementptr inbounds i8, ptr %108, i64 %110
  %112 = load i64, ptr %4, align 8, !tbaa !17
  %113 = call i32 @munmap(ptr noundef %111, i64 noundef %112) #6
  %114 = icmp eq i32 %113, 0
  br i1 %114, label %115, label %119

115:                                              ; preds = %103
  %116 = load i64, ptr %4, align 8, !tbaa !17
  %117 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 12), align 8, !tbaa !19
  %118 = sub i64 %117, %116
  store i64 %118, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 12), align 8, !tbaa !19
  br label %119

119:                                              ; preds = %115, %103
  store i32 2, ptr %20, align 4
  br label %486

120:                                              ; preds = %94
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %121 = load ptr, ptr %3, align 8, !tbaa !5
  %122 = load i64, ptr %6, align 8, !tbaa !17
  %123 = sub i64 0, %122
  %124 = getelementptr inbounds i8, ptr %121, i64 %123
  store ptr %124, ptr %7, align 8, !tbaa !5
  %125 = load i64, ptr %6, align 8, !tbaa !17
  %126 = load i64, ptr %4, align 8, !tbaa !17
  %127 = add i64 %126, %125
  store i64 %127, ptr %4, align 8, !tbaa !17
  %128 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %128, ptr %3, align 8, !tbaa !5
  %129 = load ptr, ptr %7, align 8, !tbaa !5
  %130 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %131 = icmp uge ptr %129, %130
  %132 = zext i1 %131 to i32
  %133 = sext i32 %132 to i64
  %134 = call i64 @llvm.expect.i64(i64 %133, i64 1)
  %135 = icmp ne i64 %134, 0
  br i1 %135, label %136, label %480

136:                                              ; preds = %120
  %137 = load ptr, ptr %3, align 8, !tbaa !5
  %138 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  %139 = icmp ne ptr %137, %138
  br i1 %139, label %140, label %457

140:                                              ; preds = %136
  %141 = load i64, ptr %6, align 8, !tbaa !17
  %142 = lshr i64 %141, 3
  %143 = icmp ult i64 %142, 32
  br i1 %143, label %144, label %245

144:                                              ; preds = %140
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #6
  %145 = load ptr, ptr %3, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct.malloc_chunk, ptr %145, i32 0, i32 2
  %147 = load ptr, ptr %146, align 8, !tbaa !21
  store ptr %147, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  %148 = load ptr, ptr %3, align 8, !tbaa !5
  %149 = getelementptr inbounds %struct.malloc_chunk, ptr %148, i32 0, i32 3
  %150 = load ptr, ptr %149, align 8, !tbaa !22
  store ptr %150, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  %151 = load i64, ptr %6, align 8, !tbaa !17
  %152 = lshr i64 %151, 3
  %153 = trunc i64 %152 to i32
  store i32 %153, ptr %10, align 4, !tbaa !23
  %154 = load ptr, ptr %3, align 8, !tbaa !5
  %155 = load ptr, ptr %9, align 8, !tbaa !5
  %156 = icmp ne ptr %154, %155
  br i1 %156, label %158, label %157

157:                                              ; preds = %144
  call void @abort() #7
  unreachable

158:                                              ; preds = %144
  %159 = load ptr, ptr %3, align 8, !tbaa !5
  %160 = load ptr, ptr %8, align 8, !tbaa !5
  %161 = icmp ne ptr %159, %160
  br i1 %161, label %163, label %162

162:                                              ; preds = %158
  call void @abort() #7
  unreachable

163:                                              ; preds = %158
  %164 = load ptr, ptr %3, align 8, !tbaa !5
  %165 = getelementptr inbounds %struct.malloc_chunk, ptr %164, i32 0, i32 1
  %166 = load i64, ptr %165, align 8, !tbaa !15
  %167 = and i64 %166, -8
  %168 = load i32, ptr %10, align 4, !tbaa !23
  %169 = shl i32 %168, 3
  %170 = zext i32 %169 to i64
  %171 = icmp eq i64 %167, %170
  br i1 %171, label %173, label %172

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

173:                                              ; preds = %163
  %174 = load ptr, ptr %8, align 8, !tbaa !5
  %175 = load i32, ptr %10, align 4, !tbaa !23
  %176 = shl i32 %175, 1
  %177 = zext i32 %176 to i64
  %178 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %177
  %179 = icmp eq ptr %174, %178
  br i1 %179, label %192, label %180

180:                                              ; preds = %173
  %181 = load ptr, ptr %8, align 8, !tbaa !5
  %182 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %183 = icmp uge ptr %181, %182
  br i1 %183, label %184, label %190

184:                                              ; preds = %180
  %185 = load ptr, ptr %8, align 8, !tbaa !5
  %186 = getelementptr inbounds %struct.malloc_chunk, ptr %185, i32 0, i32 3
  %187 = load ptr, ptr %186, align 8, !tbaa !22
  %188 = load ptr, ptr %3, align 8, !tbaa !5
  %189 = icmp eq ptr %187, %188
  br label %190

190:                                              ; preds = %184, %180
  %191 = phi i1 [ false, %180 ], [ %189, %184 ]
  br label %192

192:                                              ; preds = %190, %173
  %193 = phi i1 [ true, %173 ], [ %191, %190 ]
  %194 = zext i1 %193 to i32
  %195 = sext i32 %194 to i64
  %196 = call i64 @llvm.expect.i64(i64 %195, i64 1)
  %197 = icmp ne i64 %196, 0
  br i1 %197, label %198, label %243

198:                                              ; preds = %192
  %199 = load ptr, ptr %9, align 8, !tbaa !5
  %200 = load ptr, ptr %8, align 8, !tbaa !5
  %201 = icmp eq ptr %199, %200
  br i1 %201, label %202, label %208

202:                                              ; preds = %198
  %203 = load i32, ptr %10, align 4, !tbaa !23
  %204 = shl i32 1, %203
  %205 = xor i32 %204, -1
  %206 = load i32, ptr @_gm_, align 8, !tbaa !24
  %207 = and i32 %206, %205
  store i32 %207, ptr @_gm_, align 8, !tbaa !24
  br label %242

208:                                              ; preds = %198
  %209 = load ptr, ptr %9, align 8, !tbaa !5
  %210 = load i32, ptr %10, align 4, !tbaa !23
  %211 = shl i32 %210, 1
  %212 = zext i32 %211 to i64
  %213 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %212
  %214 = icmp eq ptr %209, %213
  br i1 %214, label %227, label %215

215:                                              ; preds = %208
  %216 = load ptr, ptr %9, align 8, !tbaa !5
  %217 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %218 = icmp uge ptr %216, %217
  br i1 %218, label %219, label %225

219:                                              ; preds = %215
  %220 = load ptr, ptr %9, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.malloc_chunk, ptr %220, i32 0, i32 2
  %222 = load ptr, ptr %221, align 8, !tbaa !21
  %223 = load ptr, ptr %3, align 8, !tbaa !5
  %224 = icmp eq ptr %222, %223
  br label %225

225:                                              ; preds = %219, %215
  %226 = phi i1 [ false, %215 ], [ %224, %219 ]
  br label %227

227:                                              ; preds = %225, %208
  %228 = phi i1 [ true, %208 ], [ %226, %225 ]
  %229 = zext i1 %228 to i32
  %230 = sext i32 %229 to i64
  %231 = call i64 @llvm.expect.i64(i64 %230, i64 1)
  %232 = icmp ne i64 %231, 0
  br i1 %232, label %233, label %240

233:                                              ; preds = %227
  %234 = load ptr, ptr %9, align 8, !tbaa !5
  %235 = load ptr, ptr %8, align 8, !tbaa !5
  %236 = getelementptr inbounds %struct.malloc_chunk, ptr %235, i32 0, i32 3
  store ptr %234, ptr %236, align 8, !tbaa !22
  %237 = load ptr, ptr %8, align 8, !tbaa !5
  %238 = load ptr, ptr %9, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.malloc_chunk, ptr %238, i32 0, i32 2
  store ptr %237, ptr %239, align 8, !tbaa !21
  br label %241

240:                                              ; preds = %227
  call void @abort() #7
  unreachable

241:                                              ; preds = %233
  br label %242

242:                                              ; preds = %241, %202
  br label %244

243:                                              ; preds = %192
  call void @abort() #7
  unreachable

244:                                              ; preds = %242
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #6
  br label %456

245:                                              ; preds = %140
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  %246 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %246, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %247 = load ptr, ptr %11, align 8, !tbaa !5
  %248 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %247, i32 0, i32 5
  %249 = load ptr, ptr %248, align 8, !tbaa !25
  store ptr %249, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #6
  %250 = load ptr, ptr %11, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %250, i32 0, i32 3
  %252 = load ptr, ptr %251, align 8, !tbaa !27
  %253 = load ptr, ptr %11, align 8, !tbaa !5
  %254 = icmp ne ptr %252, %253
  br i1 %254, label %255, label %292

255:                                              ; preds = %245
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #6
  %256 = load ptr, ptr %11, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %256, i32 0, i32 2
  %258 = load ptr, ptr %257, align 8, !tbaa !28
  store ptr %258, ptr %14, align 8, !tbaa !5
  %259 = load ptr, ptr %11, align 8, !tbaa !5
  %260 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %259, i32 0, i32 3
  %261 = load ptr, ptr %260, align 8, !tbaa !27
  store ptr %261, ptr %13, align 8, !tbaa !5
  %262 = load ptr, ptr %14, align 8, !tbaa !5
  %263 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %264 = icmp uge ptr %262, %263
  br i1 %264, label %265, label %277

265:                                              ; preds = %255
  %266 = load ptr, ptr %14, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %266, i32 0, i32 3
  %268 = load ptr, ptr %267, align 8, !tbaa !27
  %269 = load ptr, ptr %11, align 8, !tbaa !5
  %270 = icmp eq ptr %268, %269
  br i1 %270, label %271, label %277

271:                                              ; preds = %265
  %272 = load ptr, ptr %13, align 8, !tbaa !5
  %273 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %272, i32 0, i32 2
  %274 = load ptr, ptr %273, align 8, !tbaa !28
  %275 = load ptr, ptr %11, align 8, !tbaa !5
  %276 = icmp eq ptr %274, %275
  br label %277

277:                                              ; preds = %271, %265, %255
  %278 = phi i1 [ false, %265 ], [ false, %255 ], [ %276, %271 ]
  %279 = zext i1 %278 to i32
  %280 = sext i32 %279 to i64
  %281 = call i64 @llvm.expect.i64(i64 %280, i64 1)
  %282 = icmp ne i64 %281, 0
  br i1 %282, label %283, label %290

283:                                              ; preds = %277
  %284 = load ptr, ptr %13, align 8, !tbaa !5
  %285 = load ptr, ptr %14, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %285, i32 0, i32 3
  store ptr %284, ptr %286, align 8, !tbaa !27
  %287 = load ptr, ptr %14, align 8, !tbaa !5
  %288 = load ptr, ptr %13, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %288, i32 0, i32 2
  store ptr %287, ptr %289, align 8, !tbaa !28
  br label %291

290:                                              ; preds = %277
  call void @abort() #7
  unreachable

291:                                              ; preds = %283
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #6
  br label %335

292:                                              ; preds = %245
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  %293 = load ptr, ptr %11, align 8, !tbaa !5
  %294 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %293, i32 0, i32 4
  %295 = getelementptr inbounds [2 x ptr], ptr %294, i64 0, i64 1
  store ptr %295, ptr %15, align 8, !tbaa !5
  %296 = load ptr, ptr %295, align 8, !tbaa !5
  store ptr %296, ptr %13, align 8, !tbaa !5
  %297 = icmp ne ptr %296, null
  br i1 %297, label %304, label %298

298:                                              ; preds = %292
  %299 = load ptr, ptr %11, align 8, !tbaa !5
  %300 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %299, i32 0, i32 4
  %301 = getelementptr inbounds [2 x ptr], ptr %300, i64 0, i64 0
  store ptr %301, ptr %15, align 8, !tbaa !5
  %302 = load ptr, ptr %301, align 8, !tbaa !5
  store ptr %302, ptr %13, align 8, !tbaa !5
  %303 = icmp ne ptr %302, null
  br i1 %303, label %304, label %334

304:                                              ; preds = %298, %292
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #6
  br label %305

305:                                              ; preds = %319, %304
  %306 = load ptr, ptr %13, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %306, i32 0, i32 4
  %308 = getelementptr inbounds [2 x ptr], ptr %307, i64 0, i64 1
  store ptr %308, ptr %16, align 8, !tbaa !5
  %309 = load ptr, ptr %308, align 8, !tbaa !5
  %310 = icmp ne ptr %309, null
  br i1 %310, label %317, label %311

311:                                              ; preds = %305
  %312 = load ptr, ptr %13, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %312, i32 0, i32 4
  %314 = getelementptr inbounds [2 x ptr], ptr %313, i64 0, i64 0
  store ptr %314, ptr %16, align 8, !tbaa !5
  %315 = load ptr, ptr %314, align 8, !tbaa !5
  %316 = icmp ne ptr %315, null
  br label %317

317:                                              ; preds = %311, %305
  %318 = phi i1 [ true, %305 ], [ %316, %311 ]
  br i1 %318, label %319, label %322

319:                                              ; preds = %317
  %320 = load ptr, ptr %16, align 8, !tbaa !5
  store ptr %320, ptr %15, align 8, !tbaa !5
  %321 = load ptr, ptr %320, align 8, !tbaa !5
  store ptr %321, ptr %13, align 8, !tbaa !5
  br label %305, !llvm.loop !29

322:                                              ; preds = %317
  %323 = load ptr, ptr %15, align 8, !tbaa !5
  %324 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %325 = icmp uge ptr %323, %324
  %326 = zext i1 %325 to i32
  %327 = sext i32 %326 to i64
  %328 = call i64 @llvm.expect.i64(i64 %327, i64 1)
  %329 = icmp ne i64 %328, 0
  br i1 %329, label %330, label %332

330:                                              ; preds = %322
  %331 = load ptr, ptr %15, align 8, !tbaa !5
  store ptr null, ptr %331, align 8, !tbaa !5
  br label %333

332:                                              ; preds = %322
  call void @abort() #7
  unreachable

333:                                              ; preds = %330
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #6
  br label %334

334:                                              ; preds = %333, %298
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  br label %335

335:                                              ; preds = %334, %291
  %336 = load ptr, ptr %12, align 8, !tbaa !5
  %337 = icmp ne ptr %336, null
  br i1 %337, label %338, label %455

338:                                              ; preds = %335
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  %339 = load ptr, ptr %11, align 8, !tbaa !5
  %340 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %339, i32 0, i32 6
  %341 = load i32, ptr %340, align 8, !tbaa !31
  %342 = zext i32 %341 to i64
  %343 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %342
  store ptr %343, ptr %17, align 8, !tbaa !5
  %344 = load ptr, ptr %11, align 8, !tbaa !5
  %345 = load ptr, ptr %17, align 8, !tbaa !5
  %346 = load ptr, ptr %345, align 8, !tbaa !5
  %347 = icmp eq ptr %344, %346
  br i1 %347, label %348, label %361

348:                                              ; preds = %338
  %349 = load ptr, ptr %13, align 8, !tbaa !5
  %350 = load ptr, ptr %17, align 8, !tbaa !5
  store ptr %349, ptr %350, align 8, !tbaa !5
  %351 = icmp eq ptr %349, null
  br i1 %351, label %352, label %360

352:                                              ; preds = %348
  %353 = load ptr, ptr %11, align 8, !tbaa !5
  %354 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %353, i32 0, i32 6
  %355 = load i32, ptr %354, align 8, !tbaa !31
  %356 = shl i32 1, %355
  %357 = xor i32 %356, -1
  %358 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  %359 = and i32 %358, %357
  store i32 %359, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  br label %360

360:                                              ; preds = %352, %348
  br label %389

361:                                              ; preds = %338
  %362 = load ptr, ptr %12, align 8, !tbaa !5
  %363 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %364 = icmp uge ptr %362, %363
  %365 = zext i1 %364 to i32
  %366 = sext i32 %365 to i64
  %367 = call i64 @llvm.expect.i64(i64 %366, i64 1)
  %368 = icmp ne i64 %367, 0
  br i1 %368, label %369, label %387

369:                                              ; preds = %361
  %370 = load ptr, ptr %12, align 8, !tbaa !5
  %371 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %370, i32 0, i32 4
  %372 = getelementptr inbounds [2 x ptr], ptr %371, i64 0, i64 0
  %373 = load ptr, ptr %372, align 8, !tbaa !5
  %374 = load ptr, ptr %11, align 8, !tbaa !5
  %375 = icmp eq ptr %373, %374
  br i1 %375, label %376, label %381

376:                                              ; preds = %369
  %377 = load ptr, ptr %13, align 8, !tbaa !5
  %378 = load ptr, ptr %12, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %378, i32 0, i32 4
  %380 = getelementptr inbounds [2 x ptr], ptr %379, i64 0, i64 0
  store ptr %377, ptr %380, align 8, !tbaa !5
  br label %386

381:                                              ; preds = %369
  %382 = load ptr, ptr %13, align 8, !tbaa !5
  %383 = load ptr, ptr %12, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %383, i32 0, i32 4
  %385 = getelementptr inbounds [2 x ptr], ptr %384, i64 0, i64 1
  store ptr %382, ptr %385, align 8, !tbaa !5
  br label %386

386:                                              ; preds = %381, %376
  br label %388

387:                                              ; preds = %361
  call void @abort() #7
  unreachable

388:                                              ; preds = %386
  br label %389

389:                                              ; preds = %388, %360
  %390 = load ptr, ptr %13, align 8, !tbaa !5
  %391 = icmp ne ptr %390, null
  br i1 %391, label %392, label %454

392:                                              ; preds = %389
  %393 = load ptr, ptr %13, align 8, !tbaa !5
  %394 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %395 = icmp uge ptr %393, %394
  %396 = zext i1 %395 to i32
  %397 = sext i32 %396 to i64
  %398 = call i64 @llvm.expect.i64(i64 %397, i64 1)
  %399 = icmp ne i64 %398, 0
  br i1 %399, label %400, label %452

400:                                              ; preds = %392
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  %401 = load ptr, ptr %12, align 8, !tbaa !5
  %402 = load ptr, ptr %13, align 8, !tbaa !5
  %403 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %402, i32 0, i32 5
  store ptr %401, ptr %403, align 8, !tbaa !25
  %404 = load ptr, ptr %11, align 8, !tbaa !5
  %405 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %404, i32 0, i32 4
  %406 = getelementptr inbounds [2 x ptr], ptr %405, i64 0, i64 0
  %407 = load ptr, ptr %406, align 8, !tbaa !5
  store ptr %407, ptr %18, align 8, !tbaa !5
  %408 = icmp ne ptr %407, null
  br i1 %408, label %409, label %427

409:                                              ; preds = %400
  %410 = load ptr, ptr %18, align 8, !tbaa !5
  %411 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %412 = icmp uge ptr %410, %411
  %413 = zext i1 %412 to i32
  %414 = sext i32 %413 to i64
  %415 = call i64 @llvm.expect.i64(i64 %414, i64 1)
  %416 = icmp ne i64 %415, 0
  br i1 %416, label %417, label %425

417:                                              ; preds = %409
  %418 = load ptr, ptr %18, align 8, !tbaa !5
  %419 = load ptr, ptr %13, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %419, i32 0, i32 4
  %421 = getelementptr inbounds [2 x ptr], ptr %420, i64 0, i64 0
  store ptr %418, ptr %421, align 8, !tbaa !5
  %422 = load ptr, ptr %13, align 8, !tbaa !5
  %423 = load ptr, ptr %18, align 8, !tbaa !5
  %424 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %423, i32 0, i32 5
  store ptr %422, ptr %424, align 8, !tbaa !25
  br label %426

425:                                              ; preds = %409
  call void @abort() #7
  unreachable

426:                                              ; preds = %417
  br label %427

427:                                              ; preds = %426, %400
  %428 = load ptr, ptr %11, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %428, i32 0, i32 4
  %430 = getelementptr inbounds [2 x ptr], ptr %429, i64 0, i64 1
  %431 = load ptr, ptr %430, align 8, !tbaa !5
  store ptr %431, ptr %19, align 8, !tbaa !5
  %432 = icmp ne ptr %431, null
  br i1 %432, label %433, label %451

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

441:                                              ; preds = %433
  %442 = load ptr, ptr %19, align 8, !tbaa !5
  %443 = load ptr, ptr %13, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %443, i32 0, i32 4
  %445 = getelementptr inbounds [2 x ptr], ptr %444, i64 0, i64 1
  store ptr %442, ptr %445, align 8, !tbaa !5
  %446 = load ptr, ptr %13, align 8, !tbaa !5
  %447 = load ptr, ptr %19, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %447, i32 0, i32 5
  store ptr %446, ptr %448, align 8, !tbaa !25
  br label %450

449:                                              ; preds = %433
  call void @abort() #7
  unreachable

450:                                              ; preds = %441
  br label %451

451:                                              ; preds = %450, %427
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  br label %453

452:                                              ; preds = %392
  call void @abort() #7
  unreachable

453:                                              ; preds = %451
  br label %454

454:                                              ; preds = %453, %389
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  br label %455

455:                                              ; preds = %454, %335
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #6
  br label %456

456:                                              ; preds = %455, %244
  br label %479

457:                                              ; preds = %136
  %458 = load ptr, ptr %5, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.malloc_chunk, ptr %458, i32 0, i32 1
  %460 = load i64, ptr %459, align 8, !tbaa !15
  %461 = and i64 %460, 3
  %462 = icmp eq i64 %461, 3
  br i1 %462, label %463, label %478

463:                                              ; preds = %457
  %464 = load i64, ptr %4, align 8, !tbaa !17
  store i64 %464, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !33
  %465 = load ptr, ptr %5, align 8, !tbaa !5
  %466 = getelementptr inbounds %struct.malloc_chunk, ptr %465, i32 0, i32 1
  %467 = load i64, ptr %466, align 8, !tbaa !15
  %468 = and i64 %467, -2
  store i64 %468, ptr %466, align 8, !tbaa !15
  %469 = load i64, ptr %4, align 8, !tbaa !17
  %470 = or i64 %469, 1
  %471 = load ptr, ptr %3, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.malloc_chunk, ptr %471, i32 0, i32 1
  store i64 %470, ptr %472, align 8, !tbaa !15
  %473 = load i64, ptr %4, align 8, !tbaa !17
  %474 = load ptr, ptr %3, align 8, !tbaa !5
  %475 = load i64, ptr %4, align 8, !tbaa !17
  %476 = getelementptr inbounds i8, ptr %474, i64 %475
  %477 = getelementptr inbounds %struct.malloc_chunk, ptr %476, i32 0, i32 0
  store i64 %473, ptr %477, align 8, !tbaa !18
  store i32 2, ptr %20, align 4
  br label %482

478:                                              ; preds = %457
  br label %479

479:                                              ; preds = %478, %456
  br label %481

480:                                              ; preds = %120
  store i32 5, ptr %20, align 4
  br label %482

481:                                              ; preds = %479
  store i32 0, ptr %20, align 4
  br label %482

482:                                              ; preds = %481, %480, %463
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  %483 = load i32, ptr %20, align 4
  switch i32 %483, label %486 [
    i32 0, label %484
  ]

484:                                              ; preds = %482
  br label %485

485:                                              ; preds = %484
  store i32 0, ptr %20, align 4
  br label %486

486:                                              ; preds = %485, %482, %119
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #6
  %487 = load i32, ptr %20, align 4
  switch i32 %487, label %1136 [
    i32 0, label %488
  ]

488:                                              ; preds = %486
  br label %489

489:                                              ; preds = %488, %81
  %490 = load ptr, ptr %3, align 8, !tbaa !5
  %491 = load ptr, ptr %5, align 8, !tbaa !5
  %492 = icmp ult ptr %490, %491
  br i1 %492, label %493, label %499

493:                                              ; preds = %489
  %494 = load ptr, ptr %5, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.malloc_chunk, ptr %494, i32 0, i32 1
  %496 = load i64, ptr %495, align 8, !tbaa !15
  %497 = and i64 %496, 1
  %498 = icmp ne i64 %497, 0
  br label %499

499:                                              ; preds = %493, %489
  %500 = phi i1 [ false, %489 ], [ %498, %493 ]
  %501 = zext i1 %500 to i32
  %502 = sext i32 %501 to i64
  %503 = call i64 @llvm.expect.i64(i64 %502, i64 1)
  %504 = icmp ne i64 %503, 0
  br i1 %504, label %505, label %1135

505:                                              ; preds = %499
  %506 = load ptr, ptr %5, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.malloc_chunk, ptr %506, i32 0, i32 1
  %508 = load i64, ptr %507, align 8, !tbaa !15
  %509 = and i64 %508, 2
  %510 = icmp ne i64 %509, 0
  br i1 %510, label %897, label %511

511:                                              ; preds = %505
  %512 = load ptr, ptr %5, align 8, !tbaa !5
  %513 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !34
  %514 = icmp eq ptr %512, %513
  br i1 %514, label %515, label %535

515:                                              ; preds = %511
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  %516 = load i64, ptr %4, align 8, !tbaa !17
  %517 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !35
  %518 = add i64 %517, %516
  store i64 %518, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !35
  store i64 %518, ptr %21, align 8, !tbaa !17
  %519 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %519, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !34
  %520 = load i64, ptr %21, align 8, !tbaa !17
  %521 = or i64 %520, 1
  %522 = load ptr, ptr %3, align 8, !tbaa !5
  %523 = getelementptr inbounds %struct.malloc_chunk, ptr %522, i32 0, i32 1
  store i64 %521, ptr %523, align 8, !tbaa !15
  %524 = load ptr, ptr %3, align 8, !tbaa !5
  %525 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  %526 = icmp eq ptr %524, %525
  br i1 %526, label %527, label %528

527:                                              ; preds = %515
  store ptr null, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  store i64 0, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !33
  br label %528

528:                                              ; preds = %527, %515
  %529 = load i64, ptr %21, align 8, !tbaa !17
  %530 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 7), align 8, !tbaa !36
  %531 = icmp ugt i64 %529, %530
  br i1 %531, label %532, label %534

532:                                              ; preds = %528
  %533 = call i32 @sys_trim(ptr noundef @_gm_, i64 noundef 0)
  br label %534

534:                                              ; preds = %532, %528
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  br label %1136

535:                                              ; preds = %511
  %536 = load ptr, ptr %5, align 8, !tbaa !5
  %537 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  %538 = icmp eq ptr %536, %537
  br i1 %538, label %539, label %553

539:                                              ; preds = %535
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  %540 = load i64, ptr %4, align 8, !tbaa !17
  %541 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !33
  %542 = add i64 %541, %540
  store i64 %542, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !33
  store i64 %542, ptr %22, align 8, !tbaa !17
  %543 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %543, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  %544 = load i64, ptr %22, align 8, !tbaa !17
  %545 = or i64 %544, 1
  %546 = load ptr, ptr %3, align 8, !tbaa !5
  %547 = getelementptr inbounds %struct.malloc_chunk, ptr %546, i32 0, i32 1
  store i64 %545, ptr %547, align 8, !tbaa !15
  %548 = load i64, ptr %22, align 8, !tbaa !17
  %549 = load ptr, ptr %3, align 8, !tbaa !5
  %550 = load i64, ptr %22, align 8, !tbaa !17
  %551 = getelementptr inbounds i8, ptr %549, i64 %550
  %552 = getelementptr inbounds %struct.malloc_chunk, ptr %551, i32 0, i32 0
  store i64 %548, ptr %552, align 8, !tbaa !18
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  br label %1136

553:                                              ; preds = %535
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  %554 = load ptr, ptr %5, align 8, !tbaa !5
  %555 = getelementptr inbounds %struct.malloc_chunk, ptr %554, i32 0, i32 1
  %556 = load i64, ptr %555, align 8, !tbaa !15
  %557 = and i64 %556, -8
  store i64 %557, ptr %23, align 8, !tbaa !17
  %558 = load i64, ptr %23, align 8, !tbaa !17
  %559 = load i64, ptr %4, align 8, !tbaa !17
  %560 = add i64 %559, %558
  store i64 %560, ptr %4, align 8, !tbaa !17
  %561 = load i64, ptr %23, align 8, !tbaa !17
  %562 = lshr i64 %561, 3
  %563 = icmp ult i64 %562, 32
  br i1 %563, label %564, label %665

564:                                              ; preds = %553
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  %565 = load ptr, ptr %5, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.malloc_chunk, ptr %565, i32 0, i32 2
  %567 = load ptr, ptr %566, align 8, !tbaa !21
  store ptr %567, ptr %24, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %568 = load ptr, ptr %5, align 8, !tbaa !5
  %569 = getelementptr inbounds %struct.malloc_chunk, ptr %568, i32 0, i32 3
  %570 = load ptr, ptr %569, align 8, !tbaa !22
  store ptr %570, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %571 = load i64, ptr %23, align 8, !tbaa !17
  %572 = lshr i64 %571, 3
  %573 = trunc i64 %572 to i32
  store i32 %573, ptr %26, align 4, !tbaa !23
  %574 = load ptr, ptr %5, align 8, !tbaa !5
  %575 = load ptr, ptr %25, align 8, !tbaa !5
  %576 = icmp ne ptr %574, %575
  br i1 %576, label %578, label %577

577:                                              ; preds = %564
  call void @abort() #7
  unreachable

578:                                              ; preds = %564
  %579 = load ptr, ptr %5, align 8, !tbaa !5
  %580 = load ptr, ptr %24, align 8, !tbaa !5
  %581 = icmp ne ptr %579, %580
  br i1 %581, label %583, label %582

582:                                              ; preds = %578
  call void @abort() #7
  unreachable

583:                                              ; preds = %578
  %584 = load ptr, ptr %5, align 8, !tbaa !5
  %585 = getelementptr inbounds %struct.malloc_chunk, ptr %584, i32 0, i32 1
  %586 = load i64, ptr %585, align 8, !tbaa !15
  %587 = and i64 %586, -8
  %588 = load i32, ptr %26, align 4, !tbaa !23
  %589 = shl i32 %588, 3
  %590 = zext i32 %589 to i64
  %591 = icmp eq i64 %587, %590
  br i1 %591, label %593, label %592

592:                                              ; preds = %583
  call void @abort() #7
  unreachable

593:                                              ; preds = %583
  %594 = load ptr, ptr %24, align 8, !tbaa !5
  %595 = load i32, ptr %26, align 4, !tbaa !23
  %596 = shl i32 %595, 1
  %597 = zext i32 %596 to i64
  %598 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %597
  %599 = icmp eq ptr %594, %598
  br i1 %599, label %612, label %600

600:                                              ; preds = %593
  %601 = load ptr, ptr %24, align 8, !tbaa !5
  %602 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %603 = icmp uge ptr %601, %602
  br i1 %603, label %604, label %610

604:                                              ; preds = %600
  %605 = load ptr, ptr %24, align 8, !tbaa !5
  %606 = getelementptr inbounds %struct.malloc_chunk, ptr %605, i32 0, i32 3
  %607 = load ptr, ptr %606, align 8, !tbaa !22
  %608 = load ptr, ptr %5, align 8, !tbaa !5
  %609 = icmp eq ptr %607, %608
  br label %610

610:                                              ; preds = %604, %600
  %611 = phi i1 [ false, %600 ], [ %609, %604 ]
  br label %612

612:                                              ; preds = %610, %593
  %613 = phi i1 [ true, %593 ], [ %611, %610 ]
  %614 = zext i1 %613 to i32
  %615 = sext i32 %614 to i64
  %616 = call i64 @llvm.expect.i64(i64 %615, i64 1)
  %617 = icmp ne i64 %616, 0
  br i1 %617, label %618, label %663

618:                                              ; preds = %612
  %619 = load ptr, ptr %25, align 8, !tbaa !5
  %620 = load ptr, ptr %24, align 8, !tbaa !5
  %621 = icmp eq ptr %619, %620
  br i1 %621, label %622, label %628

622:                                              ; preds = %618
  %623 = load i32, ptr %26, align 4, !tbaa !23
  %624 = shl i32 1, %623
  %625 = xor i32 %624, -1
  %626 = load i32, ptr @_gm_, align 8, !tbaa !24
  %627 = and i32 %626, %625
  store i32 %627, ptr @_gm_, align 8, !tbaa !24
  br label %662

628:                                              ; preds = %618
  %629 = load ptr, ptr %25, align 8, !tbaa !5
  %630 = load i32, ptr %26, align 4, !tbaa !23
  %631 = shl i32 %630, 1
  %632 = zext i32 %631 to i64
  %633 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %632
  %634 = icmp eq ptr %629, %633
  br i1 %634, label %647, label %635

635:                                              ; preds = %628
  %636 = load ptr, ptr %25, align 8, !tbaa !5
  %637 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %638 = icmp uge ptr %636, %637
  br i1 %638, label %639, label %645

639:                                              ; preds = %635
  %640 = load ptr, ptr %25, align 8, !tbaa !5
  %641 = getelementptr inbounds %struct.malloc_chunk, ptr %640, i32 0, i32 2
  %642 = load ptr, ptr %641, align 8, !tbaa !21
  %643 = load ptr, ptr %5, align 8, !tbaa !5
  %644 = icmp eq ptr %642, %643
  br label %645

645:                                              ; preds = %639, %635
  %646 = phi i1 [ false, %635 ], [ %644, %639 ]
  br label %647

647:                                              ; preds = %645, %628
  %648 = phi i1 [ true, %628 ], [ %646, %645 ]
  %649 = zext i1 %648 to i32
  %650 = sext i32 %649 to i64
  %651 = call i64 @llvm.expect.i64(i64 %650, i64 1)
  %652 = icmp ne i64 %651, 0
  br i1 %652, label %653, label %660

653:                                              ; preds = %647
  %654 = load ptr, ptr %25, align 8, !tbaa !5
  %655 = load ptr, ptr %24, align 8, !tbaa !5
  %656 = getelementptr inbounds %struct.malloc_chunk, ptr %655, i32 0, i32 3
  store ptr %654, ptr %656, align 8, !tbaa !22
  %657 = load ptr, ptr %24, align 8, !tbaa !5
  %658 = load ptr, ptr %25, align 8, !tbaa !5
  %659 = getelementptr inbounds %struct.malloc_chunk, ptr %658, i32 0, i32 2
  store ptr %657, ptr %659, align 8, !tbaa !21
  br label %661

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

661:                                              ; preds = %653
  br label %662

662:                                              ; preds = %661, %622
  br label %664

663:                                              ; preds = %612
  call void @abort() #7
  unreachable

664:                                              ; preds = %662
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #6
  br label %876

665:                                              ; preds = %553
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  %666 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %666, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  %667 = load ptr, ptr %27, align 8, !tbaa !5
  %668 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %667, i32 0, i32 5
  %669 = load ptr, ptr %668, align 8, !tbaa !25
  store ptr %669, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  %670 = load ptr, ptr %27, align 8, !tbaa !5
  %671 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %670, i32 0, i32 3
  %672 = load ptr, ptr %671, align 8, !tbaa !27
  %673 = load ptr, ptr %27, align 8, !tbaa !5
  %674 = icmp ne ptr %672, %673
  br i1 %674, label %675, label %712

675:                                              ; preds = %665
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  %676 = load ptr, ptr %27, align 8, !tbaa !5
  %677 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %676, i32 0, i32 2
  %678 = load ptr, ptr %677, align 8, !tbaa !28
  store ptr %678, ptr %30, align 8, !tbaa !5
  %679 = load ptr, ptr %27, align 8, !tbaa !5
  %680 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %679, i32 0, i32 3
  %681 = load ptr, ptr %680, align 8, !tbaa !27
  store ptr %681, ptr %29, align 8, !tbaa !5
  %682 = load ptr, ptr %30, align 8, !tbaa !5
  %683 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %684 = icmp uge ptr %682, %683
  br i1 %684, label %685, label %697

685:                                              ; preds = %675
  %686 = load ptr, ptr %30, align 8, !tbaa !5
  %687 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %686, i32 0, i32 3
  %688 = load ptr, ptr %687, align 8, !tbaa !27
  %689 = load ptr, ptr %27, align 8, !tbaa !5
  %690 = icmp eq ptr %688, %689
  br i1 %690, label %691, label %697

691:                                              ; preds = %685
  %692 = load ptr, ptr %29, align 8, !tbaa !5
  %693 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %692, i32 0, i32 2
  %694 = load ptr, ptr %693, align 8, !tbaa !28
  %695 = load ptr, ptr %27, align 8, !tbaa !5
  %696 = icmp eq ptr %694, %695
  br label %697

697:                                              ; preds = %691, %685, %675
  %698 = phi i1 [ false, %685 ], [ false, %675 ], [ %696, %691 ]
  %699 = zext i1 %698 to i32
  %700 = sext i32 %699 to i64
  %701 = call i64 @llvm.expect.i64(i64 %700, i64 1)
  %702 = icmp ne i64 %701, 0
  br i1 %702, label %703, label %710

703:                                              ; preds = %697
  %704 = load ptr, ptr %29, align 8, !tbaa !5
  %705 = load ptr, ptr %30, align 8, !tbaa !5
  %706 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %705, i32 0, i32 3
  store ptr %704, ptr %706, align 8, !tbaa !27
  %707 = load ptr, ptr %30, align 8, !tbaa !5
  %708 = load ptr, ptr %29, align 8, !tbaa !5
  %709 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %708, i32 0, i32 2
  store ptr %707, ptr %709, align 8, !tbaa !28
  br label %711

710:                                              ; preds = %697
  call void @abort() #7
  unreachable

711:                                              ; preds = %703
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #6
  br label %755

712:                                              ; preds = %665
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  %713 = load ptr, ptr %27, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %713, i32 0, i32 4
  %715 = getelementptr inbounds [2 x ptr], ptr %714, i64 0, i64 1
  store ptr %715, ptr %31, align 8, !tbaa !5
  %716 = load ptr, ptr %715, align 8, !tbaa !5
  store ptr %716, ptr %29, align 8, !tbaa !5
  %717 = icmp ne ptr %716, null
  br i1 %717, label %724, label %718

718:                                              ; preds = %712
  %719 = load ptr, ptr %27, align 8, !tbaa !5
  %720 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %719, i32 0, i32 4
  %721 = getelementptr inbounds [2 x ptr], ptr %720, i64 0, i64 0
  store ptr %721, ptr %31, align 8, !tbaa !5
  %722 = load ptr, ptr %721, align 8, !tbaa !5
  store ptr %722, ptr %29, align 8, !tbaa !5
  %723 = icmp ne ptr %722, null
  br i1 %723, label %724, label %754

724:                                              ; preds = %718, %712
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  br label %725

725:                                              ; preds = %739, %724
  %726 = load ptr, ptr %29, align 8, !tbaa !5
  %727 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %726, i32 0, i32 4
  %728 = getelementptr inbounds [2 x ptr], ptr %727, i64 0, i64 1
  store ptr %728, ptr %32, align 8, !tbaa !5
  %729 = load ptr, ptr %728, align 8, !tbaa !5
  %730 = icmp ne ptr %729, null
  br i1 %730, label %737, label %731

731:                                              ; preds = %725
  %732 = load ptr, ptr %29, align 8, !tbaa !5
  %733 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %732, i32 0, i32 4
  %734 = getelementptr inbounds [2 x ptr], ptr %733, i64 0, i64 0
  store ptr %734, ptr %32, align 8, !tbaa !5
  %735 = load ptr, ptr %734, align 8, !tbaa !5
  %736 = icmp ne ptr %735, null
  br label %737

737:                                              ; preds = %731, %725
  %738 = phi i1 [ true, %725 ], [ %736, %731 ]
  br i1 %738, label %739, label %742

739:                                              ; preds = %737
  %740 = load ptr, ptr %32, align 8, !tbaa !5
  store ptr %740, ptr %31, align 8, !tbaa !5
  %741 = load ptr, ptr %740, align 8, !tbaa !5
  store ptr %741, ptr %29, align 8, !tbaa !5
  br label %725, !llvm.loop !37

742:                                              ; preds = %737
  %743 = load ptr, ptr %31, align 8, !tbaa !5
  %744 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %745 = icmp uge ptr %743, %744
  %746 = zext i1 %745 to i32
  %747 = sext i32 %746 to i64
  %748 = call i64 @llvm.expect.i64(i64 %747, i64 1)
  %749 = icmp ne i64 %748, 0
  br i1 %749, label %750, label %752

750:                                              ; preds = %742
  %751 = load ptr, ptr %31, align 8, !tbaa !5
  store ptr null, ptr %751, align 8, !tbaa !5
  br label %753

752:                                              ; preds = %742
  call void @abort() #7
  unreachable

753:                                              ; preds = %750
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #6
  br label %754

754:                                              ; preds = %753, %718
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  br label %755

755:                                              ; preds = %754, %711
  %756 = load ptr, ptr %28, align 8, !tbaa !5
  %757 = icmp ne ptr %756, null
  br i1 %757, label %758, label %875

758:                                              ; preds = %755
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %759 = load ptr, ptr %27, align 8, !tbaa !5
  %760 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %759, i32 0, i32 6
  %761 = load i32, ptr %760, align 8, !tbaa !31
  %762 = zext i32 %761 to i64
  %763 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %762
  store ptr %763, ptr %33, align 8, !tbaa !5
  %764 = load ptr, ptr %27, align 8, !tbaa !5
  %765 = load ptr, ptr %33, align 8, !tbaa !5
  %766 = load ptr, ptr %765, align 8, !tbaa !5
  %767 = icmp eq ptr %764, %766
  br i1 %767, label %768, label %781

768:                                              ; preds = %758
  %769 = load ptr, ptr %29, align 8, !tbaa !5
  %770 = load ptr, ptr %33, align 8, !tbaa !5
  store ptr %769, ptr %770, align 8, !tbaa !5
  %771 = icmp eq ptr %769, null
  br i1 %771, label %772, label %780

772:                                              ; preds = %768
  %773 = load ptr, ptr %27, align 8, !tbaa !5
  %774 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %773, i32 0, i32 6
  %775 = load i32, ptr %774, align 8, !tbaa !31
  %776 = shl i32 1, %775
  %777 = xor i32 %776, -1
  %778 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  %779 = and i32 %778, %777
  store i32 %779, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  br label %780

780:                                              ; preds = %772, %768
  br label %809

781:                                              ; preds = %758
  %782 = load ptr, ptr %28, align 8, !tbaa !5
  %783 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %784 = icmp uge ptr %782, %783
  %785 = zext i1 %784 to i32
  %786 = sext i32 %785 to i64
  %787 = call i64 @llvm.expect.i64(i64 %786, i64 1)
  %788 = icmp ne i64 %787, 0
  br i1 %788, label %789, label %807

789:                                              ; preds = %781
  %790 = load ptr, ptr %28, align 8, !tbaa !5
  %791 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %790, i32 0, i32 4
  %792 = getelementptr inbounds [2 x ptr], ptr %791, i64 0, i64 0
  %793 = load ptr, ptr %792, align 8, !tbaa !5
  %794 = load ptr, ptr %27, align 8, !tbaa !5
  %795 = icmp eq ptr %793, %794
  br i1 %795, label %796, label %801

796:                                              ; preds = %789
  %797 = load ptr, ptr %29, align 8, !tbaa !5
  %798 = load ptr, ptr %28, align 8, !tbaa !5
  %799 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %798, i32 0, i32 4
  %800 = getelementptr inbounds [2 x ptr], ptr %799, i64 0, i64 0
  store ptr %797, ptr %800, align 8, !tbaa !5
  br label %806

801:                                              ; preds = %789
  %802 = load ptr, ptr %29, align 8, !tbaa !5
  %803 = load ptr, ptr %28, align 8, !tbaa !5
  %804 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %803, i32 0, i32 4
  %805 = getelementptr inbounds [2 x ptr], ptr %804, i64 0, i64 1
  store ptr %802, ptr %805, align 8, !tbaa !5
  br label %806

806:                                              ; preds = %801, %796
  br label %808

807:                                              ; preds = %781
  call void @abort() #7
  unreachable

808:                                              ; preds = %806
  br label %809

809:                                              ; preds = %808, %780
  %810 = load ptr, ptr %29, align 8, !tbaa !5
  %811 = icmp ne ptr %810, null
  br i1 %811, label %812, label %874

812:                                              ; preds = %809
  %813 = load ptr, ptr %29, align 8, !tbaa !5
  %814 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %815 = icmp uge ptr %813, %814
  %816 = zext i1 %815 to i32
  %817 = sext i32 %816 to i64
  %818 = call i64 @llvm.expect.i64(i64 %817, i64 1)
  %819 = icmp ne i64 %818, 0
  br i1 %819, label %820, label %872

820:                                              ; preds = %812
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  %821 = load ptr, ptr %28, align 8, !tbaa !5
  %822 = load ptr, ptr %29, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %822, i32 0, i32 5
  store ptr %821, ptr %823, align 8, !tbaa !25
  %824 = load ptr, ptr %27, align 8, !tbaa !5
  %825 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %824, i32 0, i32 4
  %826 = getelementptr inbounds [2 x ptr], ptr %825, i64 0, i64 0
  %827 = load ptr, ptr %826, align 8, !tbaa !5
  store ptr %827, ptr %34, align 8, !tbaa !5
  %828 = icmp ne ptr %827, null
  br i1 %828, label %829, label %847

829:                                              ; preds = %820
  %830 = load ptr, ptr %34, align 8, !tbaa !5
  %831 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %832 = icmp uge ptr %830, %831
  %833 = zext i1 %832 to i32
  %834 = sext i32 %833 to i64
  %835 = call i64 @llvm.expect.i64(i64 %834, i64 1)
  %836 = icmp ne i64 %835, 0
  br i1 %836, label %837, label %845

837:                                              ; preds = %829
  %838 = load ptr, ptr %34, align 8, !tbaa !5
  %839 = load ptr, ptr %29, align 8, !tbaa !5
  %840 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %839, i32 0, i32 4
  %841 = getelementptr inbounds [2 x ptr], ptr %840, i64 0, i64 0
  store ptr %838, ptr %841, align 8, !tbaa !5
  %842 = load ptr, ptr %29, align 8, !tbaa !5
  %843 = load ptr, ptr %34, align 8, !tbaa !5
  %844 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %843, i32 0, i32 5
  store ptr %842, ptr %844, align 8, !tbaa !25
  br label %846

845:                                              ; preds = %829
  call void @abort() #7
  unreachable

846:                                              ; preds = %837
  br label %847

847:                                              ; preds = %846, %820
  %848 = load ptr, ptr %27, align 8, !tbaa !5
  %849 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %848, i32 0, i32 4
  %850 = getelementptr inbounds [2 x ptr], ptr %849, i64 0, i64 1
  %851 = load ptr, ptr %850, align 8, !tbaa !5
  store ptr %851, ptr %35, align 8, !tbaa !5
  %852 = icmp ne ptr %851, null
  br i1 %852, label %853, label %871

853:                                              ; preds = %847
  %854 = load ptr, ptr %35, align 8, !tbaa !5
  %855 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %856 = icmp uge ptr %854, %855
  %857 = zext i1 %856 to i32
  %858 = sext i32 %857 to i64
  %859 = call i64 @llvm.expect.i64(i64 %858, i64 1)
  %860 = icmp ne i64 %859, 0
  br i1 %860, label %861, label %869

861:                                              ; preds = %853
  %862 = load ptr, ptr %35, align 8, !tbaa !5
  %863 = load ptr, ptr %29, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %863, i32 0, i32 4
  %865 = getelementptr inbounds [2 x ptr], ptr %864, i64 0, i64 1
  store ptr %862, ptr %865, align 8, !tbaa !5
  %866 = load ptr, ptr %29, align 8, !tbaa !5
  %867 = load ptr, ptr %35, align 8, !tbaa !5
  %868 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %867, i32 0, i32 5
  store ptr %866, ptr %868, align 8, !tbaa !25
  br label %870

869:                                              ; preds = %853
  call void @abort() #7
  unreachable

870:                                              ; preds = %861
  br label %871

871:                                              ; preds = %870, %847
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  br label %873

872:                                              ; preds = %812
  call void @abort() #7
  unreachable

873:                                              ; preds = %871
  br label %874

874:                                              ; preds = %873, %809
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  br label %875

875:                                              ; preds = %874, %755
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #6
  br label %876

876:                                              ; preds = %875, %664
  %877 = load i64, ptr %4, align 8, !tbaa !17
  %878 = or i64 %877, 1
  %879 = load ptr, ptr %3, align 8, !tbaa !5
  %880 = getelementptr inbounds %struct.malloc_chunk, ptr %879, i32 0, i32 1
  store i64 %878, ptr %880, align 8, !tbaa !15
  %881 = load i64, ptr %4, align 8, !tbaa !17
  %882 = load ptr, ptr %3, align 8, !tbaa !5
  %883 = load i64, ptr %4, align 8, !tbaa !17
  %884 = getelementptr inbounds i8, ptr %882, i64 %883
  %885 = getelementptr inbounds %struct.malloc_chunk, ptr %884, i32 0, i32 0
  store i64 %881, ptr %885, align 8, !tbaa !18
  %886 = load ptr, ptr %3, align 8, !tbaa !5
  %887 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !20
  %888 = icmp eq ptr %886, %887
  br i1 %888, label %889, label %891

889:                                              ; preds = %876
  %890 = load i64, ptr %4, align 8, !tbaa !17
  store i64 %890, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !33
  store i32 2, ptr %20, align 4
  br label %892

891:                                              ; preds = %876
  store i32 0, ptr %20, align 4
  br label %892

892:                                              ; preds = %891, %889
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  %893 = load i32, ptr %20, align 4
  switch i32 %893, label %1136 [
    i32 0, label %894
  ]

894:                                              ; preds = %892
  br label %895

895:                                              ; preds = %894
  br label %896

896:                                              ; preds = %895
  br label %911

897:                                              ; preds = %505
  %898 = load ptr, ptr %5, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.malloc_chunk, ptr %898, i32 0, i32 1
  %900 = load i64, ptr %899, align 8, !tbaa !15
  %901 = and i64 %900, -2
  store i64 %901, ptr %899, align 8, !tbaa !15
  %902 = load i64, ptr %4, align 8, !tbaa !17
  %903 = or i64 %902, 1
  %904 = load ptr, ptr %3, align 8, !tbaa !5
  %905 = getelementptr inbounds %struct.malloc_chunk, ptr %904, i32 0, i32 1
  store i64 %903, ptr %905, align 8, !tbaa !15
  %906 = load i64, ptr %4, align 8, !tbaa !17
  %907 = load ptr, ptr %3, align 8, !tbaa !5
  %908 = load i64, ptr %4, align 8, !tbaa !17
  %909 = getelementptr inbounds i8, ptr %907, i64 %908
  %910 = getelementptr inbounds %struct.malloc_chunk, ptr %909, i32 0, i32 0
  store i64 %906, ptr %910, align 8, !tbaa !18
  br label %911

911:                                              ; preds = %897, %896
  %912 = load i64, ptr %4, align 8, !tbaa !17
  %913 = lshr i64 %912, 3
  %914 = icmp ult i64 %913, 32
  br i1 %914, label %915, label %968

915:                                              ; preds = %911
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %916 = load i64, ptr %4, align 8, !tbaa !17
  %917 = lshr i64 %916, 3
  %918 = trunc i64 %917 to i32
  store i32 %918, ptr %36, align 4, !tbaa !23
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %919 = load i32, ptr %36, align 4, !tbaa !23
  %920 = shl i32 %919, 1
  %921 = zext i32 %920 to i64
  %922 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %921
  store ptr %922, ptr %37, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %923 = load ptr, ptr %37, align 8, !tbaa !5
  store ptr %923, ptr %38, align 8, !tbaa !5
  %924 = load i64, ptr %4, align 8, !tbaa !17
  %925 = icmp uge i64 %924, 32
  br i1 %925, label %927, label %926

926:                                              ; preds = %915
  call void @abort() #7
  unreachable

927:                                              ; preds = %915
  %928 = load i32, ptr @_gm_, align 8, !tbaa !24
  %929 = load i32, ptr %36, align 4, !tbaa !23
  %930 = shl i32 1, %929
  %931 = and i32 %928, %930
  %932 = icmp ne i32 %931, 0
  br i1 %932, label %938, label %933

933:                                              ; preds = %927
  %934 = load i32, ptr %36, align 4, !tbaa !23
  %935 = shl i32 1, %934
  %936 = load i32, ptr @_gm_, align 8, !tbaa !24
  %937 = or i32 %936, %935
  store i32 %937, ptr @_gm_, align 8, !tbaa !24
  br label %954

938:                                              ; preds = %927
  %939 = load ptr, ptr %37, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.malloc_chunk, ptr %939, i32 0, i32 2
  %941 = load ptr, ptr %940, align 8, !tbaa !21
  %942 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %943 = icmp uge ptr %941, %942
  %944 = zext i1 %943 to i32
  %945 = sext i32 %944 to i64
  %946 = call i64 @llvm.expect.i64(i64 %945, i64 1)
  %947 = icmp ne i64 %946, 0
  br i1 %947, label %948, label %952

948:                                              ; preds = %938
  %949 = load ptr, ptr %37, align 8, !tbaa !5
  %950 = getelementptr inbounds %struct.malloc_chunk, ptr %949, i32 0, i32 2
  %951 = load ptr, ptr %950, align 8, !tbaa !21
  store ptr %951, ptr %38, align 8, !tbaa !5
  br label %953

952:                                              ; preds = %938
  call void @abort() #7
  unreachable

953:                                              ; preds = %948
  br label %954

954:                                              ; preds = %953, %933
  %955 = load ptr, ptr %3, align 8, !tbaa !5
  %956 = load ptr, ptr %37, align 8, !tbaa !5
  %957 = getelementptr inbounds %struct.malloc_chunk, ptr %956, i32 0, i32 2
  store ptr %955, ptr %957, align 8, !tbaa !21
  %958 = load ptr, ptr %3, align 8, !tbaa !5
  %959 = load ptr, ptr %38, align 8, !tbaa !5
  %960 = getelementptr inbounds %struct.malloc_chunk, ptr %959, i32 0, i32 3
  store ptr %958, ptr %960, align 8, !tbaa !22
  %961 = load ptr, ptr %38, align 8, !tbaa !5
  %962 = load ptr, ptr %3, align 8, !tbaa !5
  %963 = getelementptr inbounds %struct.malloc_chunk, ptr %962, i32 0, i32 2
  store ptr %961, ptr %963, align 8, !tbaa !21
  %964 = load ptr, ptr %37, align 8, !tbaa !5
  %965 = load ptr, ptr %3, align 8, !tbaa !5
  %966 = getelementptr inbounds %struct.malloc_chunk, ptr %965, i32 0, i32 3
  store ptr %964, ptr %966, align 8, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #6
  %967 = load ptr, ptr %3, align 8, !tbaa !5
  call void @do_check_free_chunk(ptr noundef @_gm_, ptr noundef %967)
  br label %1134

968:                                              ; preds = %911
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  %969 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %969, ptr %39, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #6
  %970 = load i64, ptr %4, align 8, !tbaa !17
  %971 = lshr i64 %970, 8
  %972 = trunc i64 %971 to i32
  store i32 %972, ptr %42, align 4, !tbaa !23
  %973 = load i32, ptr %42, align 4, !tbaa !23
  %974 = icmp eq i32 %973, 0
  br i1 %974, label %975, label %976

975:                                              ; preds = %968
  store i32 0, ptr %41, align 4, !tbaa !23
  br label %996

976:                                              ; preds = %968
  %977 = load i32, ptr %42, align 4, !tbaa !23
  %978 = icmp ugt i32 %977, 65535
  br i1 %978, label %979, label %980

979:                                              ; preds = %976
  store i32 31, ptr %41, align 4, !tbaa !23
  br label %995

980:                                              ; preds = %976
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %981 = load i32, ptr %42, align 4, !tbaa !23
  %982 = call i32 @llvm.ctlz.i32(i32 %981, i1 true)
  %983 = sub i32 31, %982
  store i32 %983, ptr %43, align 4, !tbaa !23
  %984 = load i32, ptr %43, align 4, !tbaa !23
  %985 = shl i32 %984, 1
  %986 = zext i32 %985 to i64
  %987 = load i64, ptr %4, align 8, !tbaa !17
  %988 = load i32, ptr %43, align 4, !tbaa !23
  %989 = add i32 %988, 7
  %990 = zext i32 %989 to i64
  %991 = lshr i64 %987, %990
  %992 = and i64 %991, 1
  %993 = add i64 %986, %992
  %994 = trunc i64 %993 to i32
  store i32 %994, ptr %41, align 4, !tbaa !23
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  br label %995

995:                                              ; preds = %980, %979
  br label %996

996:                                              ; preds = %995, %975
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  %997 = load i32, ptr %41, align 4, !tbaa !23
  %998 = zext i32 %997 to i64
  %999 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %998
  store ptr %999, ptr %40, align 8, !tbaa !5
  %1000 = load i32, ptr %41, align 4, !tbaa !23
  %1001 = load ptr, ptr %39, align 8, !tbaa !5
  %1002 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1001, i32 0, i32 6
  store i32 %1000, ptr %1002, align 8, !tbaa !31
  %1003 = load ptr, ptr %39, align 8, !tbaa !5
  %1004 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1003, i32 0, i32 4
  %1005 = getelementptr inbounds [2 x ptr], ptr %1004, i64 0, i64 1
  store ptr null, ptr %1005, align 8, !tbaa !5
  %1006 = load ptr, ptr %39, align 8, !tbaa !5
  %1007 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1006, i32 0, i32 4
  %1008 = getelementptr inbounds [2 x ptr], ptr %1007, i64 0, i64 0
  store ptr null, ptr %1008, align 8, !tbaa !5
  %1009 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  %1010 = load i32, ptr %41, align 4, !tbaa !23
  %1011 = shl i32 1, %1010
  %1012 = and i32 %1009, %1011
  %1013 = icmp ne i32 %1012, 0
  br i1 %1013, label %1029, label %1014

1014:                                             ; preds = %996
  %1015 = load i32, ptr %41, align 4, !tbaa !23
  %1016 = shl i32 1, %1015
  %1017 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  %1018 = or i32 %1017, %1016
  store i32 %1018, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !32
  %1019 = load ptr, ptr %39, align 8, !tbaa !5
  %1020 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1019, ptr %1020, align 8, !tbaa !5
  %1021 = load ptr, ptr %40, align 8, !tbaa !5
  %1022 = load ptr, ptr %39, align 8, !tbaa !5
  %1023 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1022, i32 0, i32 5
  store ptr %1021, ptr %1023, align 8, !tbaa !25
  %1024 = load ptr, ptr %39, align 8, !tbaa !5
  %1025 = load ptr, ptr %39, align 8, !tbaa !5
  %1026 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1025, i32 0, i32 3
  store ptr %1024, ptr %1026, align 8, !tbaa !27
  %1027 = load ptr, ptr %39, align 8, !tbaa !5
  %1028 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1027, i32 0, i32 2
  store ptr %1024, ptr %1028, align 8, !tbaa !28
  br label %1126

1029:                                             ; preds = %996
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #6
  %1030 = load ptr, ptr %40, align 8, !tbaa !5
  %1031 = load ptr, ptr %1030, align 8, !tbaa !5
  store ptr %1031, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  %1032 = load i64, ptr %4, align 8, !tbaa !17
  %1033 = load i32, ptr %41, align 4, !tbaa !23
  %1034 = icmp eq i32 %1033, 31
  br i1 %1034, label %1035, label %1036

1035:                                             ; preds = %1029
  br label %1043

1036:                                             ; preds = %1029
  %1037 = load i32, ptr %41, align 4, !tbaa !23
  %1038 = lshr i32 %1037, 1
  %1039 = add i32 %1038, 8
  %1040 = sub i32 %1039, 2
  %1041 = zext i32 %1040 to i64
  %1042 = sub i64 63, %1041
  br label %1043

1043:                                             ; preds = %1036, %1035
  %1044 = phi i64 [ 0, %1035 ], [ %1042, %1036 ]
  %1045 = shl i64 %1032, %1044
  store i64 %1045, ptr %45, align 8, !tbaa !17
  br label %1046

1046:                                             ; preds = %1124, %1043
  %1047 = load ptr, ptr %44, align 8, !tbaa !5
  %1048 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1047, i32 0, i32 1
  %1049 = load i64, ptr %1048, align 8, !tbaa !38
  %1050 = and i64 %1049, -8
  %1051 = load i64, ptr %4, align 8, !tbaa !17
  %1052 = icmp ne i64 %1050, %1051
  br i1 %1052, label %1053, label %1092

1053:                                             ; preds = %1046
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  %1054 = load ptr, ptr %44, align 8, !tbaa !5
  %1055 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1054, i32 0, i32 4
  %1056 = load i64, ptr %45, align 8, !tbaa !17
  %1057 = lshr i64 %1056, 63
  %1058 = and i64 %1057, 1
  %1059 = getelementptr inbounds [2 x ptr], ptr %1055, i64 0, i64 %1058
  store ptr %1059, ptr %46, align 8, !tbaa !5
  %1060 = load i64, ptr %45, align 8, !tbaa !17
  %1061 = shl i64 %1060, 1
  store i64 %1061, ptr %45, align 8, !tbaa !17
  %1062 = load ptr, ptr %46, align 8, !tbaa !5
  %1063 = load ptr, ptr %1062, align 8, !tbaa !5
  %1064 = icmp ne ptr %1063, null
  br i1 %1064, label %1065, label %1068

1065:                                             ; preds = %1053
  %1066 = load ptr, ptr %46, align 8, !tbaa !5
  %1067 = load ptr, ptr %1066, align 8, !tbaa !5
  store ptr %1067, ptr %44, align 8, !tbaa !5
  br label %1088

1068:                                             ; preds = %1053
  %1069 = load ptr, ptr %46, align 8, !tbaa !5
  %1070 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %1071 = icmp uge ptr %1069, %1070
  %1072 = zext i1 %1071 to i32
  %1073 = sext i32 %1072 to i64
  %1074 = call i64 @llvm.expect.i64(i64 %1073, i64 1)
  %1075 = icmp ne i64 %1074, 0
  br i1 %1075, label %1076, label %1087

1076:                                             ; preds = %1068
  %1077 = load ptr, ptr %39, align 8, !tbaa !5
  %1078 = load ptr, ptr %46, align 8, !tbaa !5
  store ptr %1077, ptr %1078, align 8, !tbaa !5
  %1079 = load ptr, ptr %44, align 8, !tbaa !5
  %1080 = load ptr, ptr %39, align 8, !tbaa !5
  %1081 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1080, i32 0, i32 5
  store ptr %1079, ptr %1081, align 8, !tbaa !25
  %1082 = load ptr, ptr %39, align 8, !tbaa !5
  %1083 = load ptr, ptr %39, align 8, !tbaa !5
  %1084 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1083, i32 0, i32 3
  store ptr %1082, ptr %1084, align 8, !tbaa !27
  %1085 = load ptr, ptr %39, align 8, !tbaa !5
  %1086 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1085, i32 0, i32 2
  store ptr %1082, ptr %1086, align 8, !tbaa !28
  store i32 8, ptr %20, align 4
  br label %1089

1087:                                             ; preds = %1068
  call void @abort() #7
  unreachable

1088:                                             ; preds = %1065
  store i32 0, ptr %20, align 4
  br label %1089

1089:                                             ; preds = %1088, %1076
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  %1090 = load i32, ptr %20, align 4
  switch i32 %1090, label %1149 [
    i32 0, label %1091
    i32 8, label %1125
  ]

1091:                                             ; preds = %1089
  br label %1124

1092:                                             ; preds = %1046
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  %1093 = load ptr, ptr %44, align 8, !tbaa !5
  %1094 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1093, i32 0, i32 2
  %1095 = load ptr, ptr %1094, align 8, !tbaa !28
  store ptr %1095, ptr %47, align 8, !tbaa !5
  %1096 = load ptr, ptr %44, align 8, !tbaa !5
  %1097 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %1098 = icmp uge ptr %1096, %1097
  br i1 %1098, label %1099, label %1103

1099:                                             ; preds = %1092
  %1100 = load ptr, ptr %47, align 8, !tbaa !5
  %1101 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !14
  %1102 = icmp uge ptr %1100, %1101
  br label %1103

1103:                                             ; preds = %1099, %1092
  %1104 = phi i1 [ false, %1092 ], [ %1102, %1099 ]
  %1105 = zext i1 %1104 to i32
  %1106 = sext i32 %1105 to i64
  %1107 = call i64 @llvm.expect.i64(i64 %1106, i64 1)
  %1108 = icmp ne i64 %1107, 0
  br i1 %1108, label %1109, label %1123

1109:                                             ; preds = %1103
  %1110 = load ptr, ptr %39, align 8, !tbaa !5
  %1111 = load ptr, ptr %47, align 8, !tbaa !5
  %1112 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1111, i32 0, i32 3
  store ptr %1110, ptr %1112, align 8, !tbaa !27
  %1113 = load ptr, ptr %44, align 8, !tbaa !5
  %1114 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1113, i32 0, i32 2
  store ptr %1110, ptr %1114, align 8, !tbaa !28
  %1115 = load ptr, ptr %47, align 8, !tbaa !5
  %1116 = load ptr, ptr %39, align 8, !tbaa !5
  %1117 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1116, i32 0, i32 2
  store ptr %1115, ptr %1117, align 8, !tbaa !28
  %1118 = load ptr, ptr %44, align 8, !tbaa !5
  %1119 = load ptr, ptr %39, align 8, !tbaa !5
  %1120 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1119, i32 0, i32 3
  store ptr %1118, ptr %1120, align 8, !tbaa !27
  %1121 = load ptr, ptr %39, align 8, !tbaa !5
  %1122 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1121, i32 0, i32 5
  store ptr null, ptr %1122, align 8, !tbaa !25
  store i32 8, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  br label %1125

1123:                                             ; preds = %1103
  call void @abort() #7
  unreachable

1124:                                             ; preds = %1091
  br label %1046

1125:                                             ; preds = %1109, %1089
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  br label %1126

1126:                                             ; preds = %1125, %1014
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  %1127 = load ptr, ptr %3, align 8, !tbaa !5
  call void @do_check_free_chunk(ptr noundef @_gm_, ptr noundef %1127)
  %1128 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !39
  %1129 = add i64 %1128, -1
  store i64 %1129, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !39
  %1130 = icmp eq i64 %1129, 0
  br i1 %1130, label %1131, label %1133

1131:                                             ; preds = %1126
  %1132 = call i64 @release_unused_segments(ptr noundef @_gm_)
  br label %1133

1133:                                             ; preds = %1131, %1126
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  br label %1134

1134:                                             ; preds = %1133, %954
  store i32 2, ptr %20, align 4
  br label %1136

1135:                                             ; preds = %499
  store i32 0, ptr %20, align 4
  br label %1136

1136:                                             ; preds = %1135, %1134, %892, %539, %534, %486
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #6
  %1137 = load i32, ptr %20, align 4
  switch i32 %1137, label %1149 [
    i32 0, label %1138
    i32 5, label %1140
    i32 2, label %1141
  ]

1138:                                             ; preds = %1136
  br label %1139

1139:                                             ; preds = %1138, %75
  br label %1140

1140:                                             ; preds = %1139, %1136
  call void @abort() #7
  unreachable

1141:                                             ; preds = %1136
  %1142 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 15), align 8, !tbaa !9
  %1143 = and i32 %1142, 2
  %1144 = icmp ne i32 %1143, 0
  br i1 %1144, label %1145, label %1146

1145:                                             ; preds = %1141
  store atomic i32 0, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 16) release, align 4
  br label %1146

1146:                                             ; preds = %1145, %1141
  br label %1147

1147:                                             ; preds = %1146, %63, %62, %59
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #6
  br label %1148

1148:                                             ; preds = %1147, %1
  ret void

1149:                                             ; preds = %1136, %1089
  unreachable
}

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

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

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

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

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

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

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

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

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


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

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

@_gm_ = external hidden global %struct.malloc_state, align 8

; 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
define dso_local void @dlfree(ptr noundef %0) local_unnamed_addr #0 {
  %.not = icmp eq ptr %0, null
  br i1 %.not, label %416, label %2

2:                                                ; preds = %1
  %3 = getelementptr inbounds i8, ptr %0, i64 -16
  %4 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 880), align 8, !tbaa !5
  %5 = and i32 %4, 2
  %.not362 = icmp eq i32 %5, 0
  br i1 %.not362, label %10, label %6

6:                                                ; preds = %2
  %7 = atomicrmw xchg ptr getelementptr inbounds (i8, ptr @_gm_, i64 884), i32 1 seq_cst, align 4
  %.not363 = icmp eq i32 %7, 0
  br i1 %.not363, label %10, label %8

8:                                                ; preds = %6
  %9 = tail call i32 @spin_acquire_lock(ptr noundef nonnull getelementptr inbounds (i8, ptr @_gm_, i64 884))
  %.not364 = icmp eq i32 %9, 0
  br i1 %.not364, label %10, label %416

10:                                               ; preds = %2, %6, %8
  tail call void @do_check_inuse_chunk(ptr noundef nonnull @_gm_, ptr noundef nonnull %3)
  %11 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not365 = icmp ult ptr %3, %11
  br i1 %.not365, label %.critedge417, label %12, !prof !14

12:                                               ; preds = %10
  %13 = getelementptr inbounds i8, ptr %0, i64 -8
  %14 = load i64, ptr %13, align 8, !tbaa !15
  %15 = and i64 %14, 3
  %.not456 = icmp eq i64 %15, 1
  br i1 %.not456, label %.critedge417, label %16, !prof !14

16:                                               ; preds = %12
  %17 = and i64 %14, -8
  %18 = getelementptr inbounds i8, ptr %3, i64 %17
  %19 = and i64 %14, 1
  %.not366 = icmp eq i64 %19, 0
  br i1 %.not366, label %20, label %.thread

20:                                               ; preds = %16
  %21 = load i64, ptr %3, align 8, !tbaa !17
  %22 = and i64 %14, 2
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %24, label %34

24:                                               ; preds = %20
  %25 = add i64 %17, 32
  %26 = add i64 %25, %21
  %27 = sub i64 0, %21
  %28 = getelementptr inbounds i8, ptr %3, i64 %27
  %29 = tail call i32 @munmap(ptr noundef nonnull %28, i64 noundef %26) #5
  %30 = icmp eq i32 %29, 0
  br i1 %30, label %31, label %412

31:                                               ; preds = %24
  %32 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 856), align 8, !tbaa !18
  %33 = sub i64 %32, %26
  store i64 %33, ptr getelementptr inbounds (i8, ptr @_gm_, i64 856), align 8, !tbaa !18
  br label %412

34:                                               ; preds = %20
  %35 = sub i64 0, %21
  %36 = getelementptr inbounds i8, ptr %3, i64 %35
  %37 = add i64 %21, %17
  %.not367 = icmp ult ptr %36, %11
  br i1 %.not367, label %.critedge417, label %38, !prof !14

38:                                               ; preds = %34
  %39 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  %.not368 = icmp eq ptr %36, %39
  br i1 %.not368, label %155, label %40

40:                                               ; preds = %38
  %41 = icmp ult i64 %21, 256
  br i1 %41, label %42, label %83

42:                                               ; preds = %40
  %43 = lshr i64 %21, 3
  %44 = getelementptr inbounds i8, ptr %36, i64 16
  %45 = load ptr, ptr %44, align 8, !tbaa !20
  %46 = getelementptr inbounds i8, ptr %36, i64 24
  %47 = load ptr, ptr %46, align 8, !tbaa !21
  %48 = trunc nuw nsw i64 %43 to i32
  %.not384 = icmp eq ptr %36, %47
  br i1 %.not384, label %49, label %50

49:                                               ; preds = %42
  tail call void @abort() #6
  unreachable

50:                                               ; preds = %42
  %.not385 = icmp eq ptr %36, %45
  br i1 %.not385, label %51, label %52

51:                                               ; preds = %50
  tail call void @abort() #6
  unreachable

52:                                               ; preds = %50
  %53 = getelementptr inbounds i8, ptr %36, i64 8
  %54 = load i64, ptr %53, align 8, !tbaa !15
  %55 = and i64 %54, -8
  %56 = and i64 %21, 248
  %57 = icmp eq i64 %55, %56
  br i1 %57, label %59, label %58

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

59:                                               ; preds = %52
  %60 = shl nuw nsw i64 %43, 1
  %61 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %60
  %62 = icmp eq ptr %45, %61
  br i1 %62, label %.critedge419, label %63

63:                                               ; preds = %59
  %.not386 = icmp ult ptr %45, %11
  br i1 %.not386, label %.critedge421, label %64

64:                                               ; preds = %63
  %65 = getelementptr inbounds i8, ptr %45, i64 24
  %66 = load ptr, ptr %65, align 8, !tbaa !21
  %67 = icmp eq ptr %66, %36
  br i1 %67, label %.critedge419, label %.critedge421, !prof !22

.critedge419:                                     ; preds = %59, %64
  %68 = icmp eq ptr %47, %45
  br i1 %68, label %69, label %74

69:                                               ; preds = %.critedge419
  %70 = shl nuw i32 1, %48
  %71 = xor i32 %70, -1
  %72 = load i32, ptr @_gm_, align 8, !tbaa !23
  %73 = and i32 %72, %71
  store i32 %73, ptr @_gm_, align 8, !tbaa !23
  br label %.thread

74:                                               ; preds = %.critedge419
  %75 = icmp eq ptr %47, %61
  br i1 %75, label %.critedge423, label %76

76:                                               ; preds = %74
  %.not387 = icmp ult ptr %47, %11
  br i1 %.not387, label %.critedge425, label %77

77:                                               ; preds = %76
  %78 = getelementptr inbounds i8, ptr %47, i64 16
  %79 = load ptr, ptr %78, align 8, !tbaa !20
  %80 = icmp eq ptr %79, %36
  br i1 %80, label %.critedge423, label %.critedge425, !prof !22

.critedge423:                                     ; preds = %74, %77
  %81 = getelementptr inbounds i8, ptr %45, i64 24
  store ptr %47, ptr %81, align 8, !tbaa !21
  %82 = getelementptr inbounds i8, ptr %47, i64 16
  store ptr %45, ptr %82, align 8, !tbaa !20
  br label %.thread

.critedge425:                                     ; preds = %76, %77
  tail call void @abort() #6
  unreachable

.critedge421:                                     ; preds = %63, %64
  tail call void @abort() #6
  unreachable

83:                                               ; preds = %40
  %84 = getelementptr inbounds i8, ptr %36, i64 48
  %85 = load ptr, ptr %84, align 8, !tbaa !24
  %86 = getelementptr inbounds i8, ptr %36, i64 24
  %87 = load ptr, ptr %86, align 8, !tbaa !26
  %.not369 = icmp eq ptr %87, %36
  br i1 %.not369, label %100, label %88

88:                                               ; preds = %83
  %89 = getelementptr inbounds i8, ptr %36, i64 16
  %90 = load ptr, ptr %89, align 8, !tbaa !27
  %.not375 = icmp ult ptr %90, %11
  br i1 %.not375, label %.critedge427, label %91, !prof !14

91:                                               ; preds = %88
  %92 = getelementptr inbounds i8, ptr %90, i64 24
  %93 = load ptr, ptr %92, align 8, !tbaa !26
  %94 = icmp eq ptr %93, %36
  br i1 %94, label %95, label %.critedge427, !prof !22

95:                                               ; preds = %91
  %96 = getelementptr inbounds i8, ptr %87, i64 16
  %97 = load ptr, ptr %96, align 8, !tbaa !27
  %98 = icmp eq ptr %97, %36
  br i1 %98, label %99, label %.critedge427, !prof !22

99:                                               ; preds = %95
  store ptr %87, ptr %92, align 8, !tbaa !26
  store ptr %90, ptr %96, align 8, !tbaa !27
  br label %114

.critedge427:                                     ; preds = %91, %88, %95
  tail call void @abort() #6
  unreachable

100:                                              ; preds = %83
  %101 = getelementptr inbounds i8, ptr %36, i64 40
  %102 = load ptr, ptr %101, align 8, !tbaa !28
  %.not370 = icmp eq ptr %102, null
  br i1 %.not370, label %103, label %.critedge.preheader

103:                                              ; preds = %100
  %104 = getelementptr inbounds i8, ptr %36, i64 32
  %105 = load ptr, ptr %104, align 8, !tbaa !28
  %.not371 = icmp eq ptr %105, null
  br i1 %.not371, label %114, label %.critedge.preheader

.critedge.preheader:                              ; preds = %103, %100
  %.1313.ph = phi ptr [ %104, %103 ], [ %101, %100 ]
  %.1310.ph = phi ptr [ %105, %103 ], [ %102, %100 ]
  br label %.critedge

.critedge:                                        ; preds = %.critedge.backedge, %.critedge.preheader
  %.1313 = phi ptr [ %.1313.ph, %.critedge.preheader ], [ %.1313.be, %.critedge.backedge ]
  %.1310 = phi ptr [ %.1310.ph, %.critedge.preheader ], [ %.1310.be, %.critedge.backedge ]
  %106 = getelementptr inbounds i8, ptr %.1310, i64 40
  %107 = load ptr, ptr %106, align 8, !tbaa !28
  %.not372 = icmp eq ptr %107, null
  br i1 %.not372, label %108, label %.critedge.backedge

.critedge.backedge:                               ; preds = %.critedge, %108
  %.1313.be = phi ptr [ %106, %.critedge ], [ %109, %108 ]
  %.1310.be = phi ptr [ %107, %.critedge ], [ %110, %108 ]
  br label %.critedge, !llvm.loop !29

108:                                              ; preds = %.critedge
  %109 = getelementptr inbounds i8, ptr %.1310, i64 32
  %110 = load ptr, ptr %109, align 8, !tbaa !28
  %.not373 = icmp eq ptr %110, null
  br i1 %.not373, label %111, label %.critedge.backedge

111:                                              ; preds = %108
  %.not374 = icmp ult ptr %.1313, %11
  br i1 %.not374, label %113, label %112, !prof !14

112:                                              ; preds = %111
  store ptr null, ptr %.1313, align 8, !tbaa !28
  br label %114

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

114:                                              ; preds = %103, %112, %99
  %.3 = phi ptr [ %87, %99 ], [ %.1310, %112 ], [ null, %103 ]
  %.not376 = icmp eq ptr %85, null
  br i1 %.not376, label %.thread, label %115

115:                                              ; preds = %114
  %116 = getelementptr inbounds i8, ptr %36, i64 56
  %117 = load i32, ptr %116, align 8, !tbaa !31
  %118 = zext i32 %117 to i64
  %119 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %118
  %120 = load ptr, ptr %119, align 8, !tbaa !28
  %121 = icmp eq ptr %36, %120
  br i1 %121, label %122, label %127

122:                                              ; preds = %115
  store ptr %.3, ptr %119, align 8, !tbaa !28
  %cond = icmp eq ptr %.3, null
  br i1 %cond, label %.thread463, label %135

.thread463:                                       ; preds = %122
  %123 = shl nuw i32 1, %117
  %124 = xor i32 %123, -1
  %125 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  %126 = and i32 %125, %124
  store i32 %126, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  br label %.thread

127:                                              ; preds = %115
  %128 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not377 = icmp ult ptr %85, %128
  br i1 %.not377, label %134, label %129, !prof !14

129:                                              ; preds = %127
  %130 = getelementptr inbounds i8, ptr %85, i64 32
  %131 = load ptr, ptr %130, align 8, !tbaa !28
  %132 = icmp eq ptr %131, %36
  %133 = getelementptr inbounds i8, ptr %85, i64 40
  %.sink = select i1 %132, ptr %130, ptr %133
  store ptr %.3, ptr %.sink, align 8, !tbaa !28
  %.not378 = icmp eq ptr %.3, null
  br i1 %.not378, label %.thread, label %135

134:                                              ; preds = %127
  tail call void @abort() #6
  unreachable

135:                                              ; preds = %122, %129
  %136 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not379 = icmp ult ptr %.3, %136
  br i1 %.not379, label %154, label %137, !prof !14

137:                                              ; preds = %135
  %138 = getelementptr inbounds i8, ptr %.3, i64 48
  store ptr %85, ptr %138, align 8, !tbaa !24
  %139 = getelementptr inbounds i8, ptr %36, i64 32
  %140 = load ptr, ptr %139, align 8, !tbaa !28
  %.not380 = icmp eq ptr %140, null
  br i1 %.not380, label %146, label %141

141:                                              ; preds = %137
  %.not381 = icmp ult ptr %140, %136
  br i1 %.not381, label %145, label %142, !prof !14

142:                                              ; preds = %141
  %143 = getelementptr inbounds i8, ptr %.3, i64 32
  store ptr %140, ptr %143, align 8, !tbaa !28
  %144 = getelementptr inbounds i8, ptr %140, i64 48
  store ptr %.3, ptr %144, align 8, !tbaa !24
  br label %146

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

146:                                              ; preds = %142, %137
  %147 = getelementptr inbounds i8, ptr %36, i64 40
  %148 = load ptr, ptr %147, align 8, !tbaa !28
  %.not382 = icmp eq ptr %148, null
  br i1 %.not382, label %.thread, label %149

149:                                              ; preds = %146
  %.not383 = icmp ult ptr %148, %136
  br i1 %.not383, label %153, label %150, !prof !14

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

153:                                              ; preds = %149
  tail call void @abort() #6
  unreachable

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

155:                                              ; preds = %38
  %156 = getelementptr inbounds i8, ptr %18, i64 8
  %157 = load i64, ptr %156, align 8, !tbaa !15
  %158 = and i64 %157, 3
  %159 = icmp eq i64 %158, 3
  br i1 %159, label %160, label %.thread

160:                                              ; preds = %155
  store i64 %37, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !33
  %161 = and i64 %157, -2
  store i64 %161, ptr %156, align 8, !tbaa !15
  %162 = or i64 %37, 1
  %163 = getelementptr inbounds i8, ptr %36, i64 8
  store i64 %162, ptr %163, align 8, !tbaa !15
  store i64 %37, ptr %18, align 8, !tbaa !17
  br label %412

.thread:                                          ; preds = %.thread463, %155, %69, %.critedge423, %129, %150, %146, %114, %16
  %.1305 = phi i64 [ %17, %16 ], [ %37, %114 ], [ %37, %146 ], [ %37, %150 ], [ %37, %129 ], [ %37, %.critedge423 ], [ %37, %69 ], [ %37, %155 ], [ %37, %.thread463 ]
  %.1 = phi ptr [ %3, %16 ], [ %36, %114 ], [ %36, %146 ], [ %36, %150 ], [ %36, %129 ], [ %36, %.critedge423 ], [ %36, %69 ], [ %36, %155 ], [ %36, %.thread463 ]
  %164 = icmp ult ptr %.1, %18
  br i1 %164, label %165, label %.critedge417, !prof !22

165:                                              ; preds = %.thread
  %166 = getelementptr inbounds i8, ptr %18, i64 8
  %167 = load i64, ptr %166, align 8, !tbaa !15
  %168 = and i64 %167, 1
  %.not457 = icmp eq i64 %168, 0
  br i1 %.not457, label %.critedge417, label %169, !prof !14

169:                                              ; preds = %165
  %170 = and i64 %167, 2
  %.not388 = icmp eq i64 %170, 0
  br i1 %.not388, label %171, label %315

171:                                              ; preds = %169
  %172 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 40), align 8, !tbaa !34
  %173 = icmp eq ptr %18, %172
  br i1 %173, label %174, label %187

174:                                              ; preds = %171
  %175 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 16), align 8, !tbaa !35
  %176 = add i64 %175, %.1305
  store i64 %176, ptr getelementptr inbounds (i8, ptr @_gm_, i64 16), align 8, !tbaa !35
  store ptr %.1, ptr getelementptr inbounds (i8, ptr @_gm_, i64 40), align 8, !tbaa !34
  %177 = or i64 %176, 1
  %178 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %177, ptr %178, align 8, !tbaa !15
  %179 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  %180 = icmp eq ptr %.1, %179
  br i1 %180, label %181, label %182

181:                                              ; preds = %174
  store ptr null, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  store i64 0, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !33
  br label %182

182:                                              ; preds = %181, %174
  %183 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 48), align 8, !tbaa !36
  %184 = icmp ugt i64 %176, %183
  br i1 %184, label %185, label %412

185:                                              ; preds = %182
  %186 = tail call i32 @sys_trim(ptr noundef nonnull @_gm_, i64 noundef 0)
  br label %412

187:                                              ; preds = %171
  %188 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  %189 = icmp eq ptr %18, %188
  br i1 %189, label %190, label %196

190:                                              ; preds = %187
  %191 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !33
  %192 = add i64 %191, %.1305
  store i64 %192, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !33
  store ptr %.1, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  %193 = or i64 %192, 1
  %194 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %193, ptr %194, align 8, !tbaa !15
  %195 = getelementptr inbounds i8, ptr %.1, i64 %192
  store i64 %192, ptr %195, align 8, !tbaa !17
  br label %412

196:                                              ; preds = %187
  %197 = and i64 %167, -8
  %198 = add i64 %197, %.1305
  %199 = icmp ult i64 %167, 256
  br i1 %199, label %200, label %236

200:                                              ; preds = %196
  %201 = lshr i64 %167, 3
  %202 = getelementptr inbounds i8, ptr %18, i64 16
  %203 = load ptr, ptr %202, align 8, !tbaa !20
  %204 = getelementptr inbounds i8, ptr %18, i64 24
  %205 = load ptr, ptr %204, align 8, !tbaa !21
  %206 = trunc nuw nsw i64 %201 to i32
  %.not404 = icmp eq ptr %18, %205
  br i1 %.not404, label %207, label %208

207:                                              ; preds = %200
  tail call void @abort() #6
  unreachable

208:                                              ; preds = %200
  %.not405 = icmp eq ptr %18, %203
  br i1 %.not405, label %209, label %210

209:                                              ; preds = %208
  tail call void @abort() #6
  unreachable

210:                                              ; preds = %208
  %211 = shl nuw nsw i64 %201, 1
  %212 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %211
  %213 = icmp eq ptr %203, %212
  br i1 %213, label %.critedge431, label %214

214:                                              ; preds = %210
  %215 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not406 = icmp ult ptr %203, %215
  br i1 %.not406, label %.critedge433, label %216

216:                                              ; preds = %214
  %217 = getelementptr inbounds i8, ptr %203, i64 24
  %218 = load ptr, ptr %217, align 8, !tbaa !21
  %219 = icmp eq ptr %218, %18
  br i1 %219, label %.critedge431, label %.critedge433, !prof !22

.critedge431:                                     ; preds = %210, %216
  %220 = icmp eq ptr %205, %203
  br i1 %220, label %221, label %226

221:                                              ; preds = %.critedge431
  %222 = shl nuw i32 1, %206
  %223 = xor i32 %222, -1
  %224 = load i32, ptr @_gm_, align 8, !tbaa !23
  %225 = and i32 %224, %223
  store i32 %225, ptr @_gm_, align 8, !tbaa !23
  br label %310

226:                                              ; preds = %.critedge431
  %227 = icmp eq ptr %205, %212
  br i1 %227, label %.critedge435, label %228

228:                                              ; preds = %226
  %229 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not407 = icmp ult ptr %205, %229
  br i1 %.not407, label %.critedge437, label %230

230:                                              ; preds = %228
  %231 = getelementptr inbounds i8, ptr %205, i64 16
  %232 = load ptr, ptr %231, align 8, !tbaa !20
  %233 = icmp eq ptr %232, %18
  br i1 %233, label %.critedge435, label %.critedge437, !prof !22

.critedge435:                                     ; preds = %226, %230
  %234 = getelementptr inbounds i8, ptr %203, i64 24
  store ptr %205, ptr %234, align 8, !tbaa !21
  %235 = getelementptr inbounds i8, ptr %205, i64 16
  store ptr %203, ptr %235, align 8, !tbaa !20
  br label %310

.critedge437:                                     ; preds = %228, %230
  tail call void @abort() #6
  unreachable

.critedge433:                                     ; preds = %214, %216
  tail call void @abort() #6
  unreachable

236:                                              ; preds = %196
  %237 = getelementptr inbounds i8, ptr %18, i64 48
  %238 = load ptr, ptr %237, align 8, !tbaa !24
  %239 = getelementptr inbounds i8, ptr %18, i64 24
  %240 = load ptr, ptr %239, align 8, !tbaa !26
  %.not389 = icmp eq ptr %240, %18
  br i1 %.not389, label %254, label %241

241:                                              ; preds = %236
  %242 = getelementptr inbounds i8, ptr %18, i64 16
  %243 = load ptr, ptr %242, align 8, !tbaa !27
  %244 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not395 = icmp ult ptr %243, %244
  br i1 %.not395, label %.critedge439, label %245, !prof !14

245:                                              ; preds = %241
  %246 = getelementptr inbounds i8, ptr %243, i64 24
  %247 = load ptr, ptr %246, align 8, !tbaa !26
  %248 = icmp eq ptr %247, %18
  br i1 %248, label %249, label %.critedge439, !prof !22

249:                                              ; preds = %245
  %250 = getelementptr inbounds i8, ptr %240, i64 16
  %251 = load ptr, ptr %250, align 8, !tbaa !27
  %252 = icmp eq ptr %251, %18
  br i1 %252, label %253, label %.critedge439, !prof !22

253:                                              ; preds = %249
  store ptr %240, ptr %246, align 8, !tbaa !26
  store ptr %243, ptr %250, align 8, !tbaa !27
  br label %269

.critedge439:                                     ; preds = %245, %241, %249
  tail call void @abort() #6
  unreachable

254:                                              ; preds = %236
  %255 = getelementptr inbounds i8, ptr %18, i64 40
  %256 = load ptr, ptr %255, align 8, !tbaa !28
  %.not390 = icmp eq ptr %256, null
  br i1 %.not390, label %257, label %.critedge4.preheader

257:                                              ; preds = %254
  %258 = getelementptr inbounds i8, ptr %18, i64 32
  %259 = load ptr, ptr %258, align 8, !tbaa !28
  %.not391 = icmp eq ptr %259, null
  br i1 %.not391, label %269, label %.critedge4.preheader

.critedge4.preheader:                             ; preds = %257, %254
  %.1326.ph = phi ptr [ %258, %257 ], [ %255, %254 ]
  %.1322.ph = phi ptr [ %259, %257 ], [ %256, %254 ]
  br label %.critedge4

.critedge4:                                       ; preds = %.critedge4.backedge, %.critedge4.preheader
  %.1326 = phi ptr [ %.1326.ph, %.critedge4.preheader ], [ %.1326.be, %.critedge4.backedge ]
  %.1322 = phi ptr [ %.1322.ph, %.critedge4.preheader ], [ %.1322.be, %.critedge4.backedge ]
  %260 = getelementptr inbounds i8, ptr %.1322, i64 40
  %261 = load ptr, ptr %260, align 8, !tbaa !28
  %.not392 = icmp eq ptr %261, null
  br i1 %.not392, label %262, label %.critedge4.backedge

.critedge4.backedge:                              ; preds = %.critedge4, %262
  %.1326.be = phi ptr [ %260, %.critedge4 ], [ %263, %262 ]
  %.1322.be = phi ptr [ %261, %.critedge4 ], [ %264, %262 ]
  br label %.critedge4, !llvm.loop !37

262:                                              ; preds = %.critedge4
  %263 = getelementptr inbounds i8, ptr %.1322, i64 32
  %264 = load ptr, ptr %263, align 8, !tbaa !28
  %.not393 = icmp eq ptr %264, null
  br i1 %.not393, label %265, label %.critedge4.backedge

265:                                              ; preds = %262
  %266 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not394 = icmp ult ptr %.1326, %266
  br i1 %.not394, label %268, label %267, !prof !14

267:                                              ; preds = %265
  store ptr null, ptr %.1326, align 8, !tbaa !28
  br label %269

268:                                              ; preds = %265
  tail call void @abort() #6
  unreachable

269:                                              ; preds = %257, %267, %253
  %.3324 = phi ptr [ %240, %253 ], [ %.1322, %267 ], [ null, %257 ]
  %.not396 = icmp eq ptr %238, null
  br i1 %.not396, label %310, label %270

270:                                              ; preds = %269
  %271 = getelementptr inbounds i8, ptr %18, i64 56
  %272 = load i32, ptr %271, align 8, !tbaa !31
  %273 = zext i32 %272 to i64
  %274 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %273
  %275 = load ptr, ptr %274, align 8, !tbaa !28
  %276 = icmp eq ptr %18, %275
  br i1 %276, label %277, label %282

277:                                              ; preds = %270
  store ptr %.3324, ptr %274, align 8, !tbaa !28
  %cond442 = icmp eq ptr %.3324, null
  br i1 %cond442, label %.thread465, label %290

.thread465:                                       ; preds = %277
  %278 = shl nuw i32 1, %272
  %279 = xor i32 %278, -1
  %280 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  %281 = and i32 %280, %279
  store i32 %281, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  br label %310

282:                                              ; preds = %270
  %283 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not397 = icmp ult ptr %238, %283
  br i1 %.not397, label %289, label %284, !prof !14

284:                                              ; preds = %282
  %285 = getelementptr inbounds i8, ptr %238, i64 32
  %286 = load ptr, ptr %285, align 8, !tbaa !28
  %287 = icmp eq ptr %286, %18
  %288 = getelementptr inbounds i8, ptr %238, i64 40
  %.sink470 = select i1 %287, ptr %285, ptr %288
  store ptr %.3324, ptr %.sink470, align 8, !tbaa !28
  %.not398 = icmp eq ptr %.3324, null
  br i1 %.not398, label %310, label %290

289:                                              ; preds = %282
  tail call void @abort() #6
  unreachable

290:                                              ; preds = %277, %284
  %291 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not399 = icmp ult ptr %.3324, %291
  br i1 %.not399, label %309, label %292, !prof !14

292:                                              ; preds = %290
  %293 = getelementptr inbounds i8, ptr %.3324, i64 48
  store ptr %238, ptr %293, align 8, !tbaa !24
  %294 = getelementptr inbounds i8, ptr %18, i64 32
  %295 = load ptr, ptr %294, align 8, !tbaa !28
  %.not400 = icmp eq ptr %295, null
  br i1 %.not400, label %301, label %296

296:                                              ; preds = %292
  %.not401 = icmp ult ptr %295, %291
  br i1 %.not401, label %300, label %297, !prof !14

297:                                              ; preds = %296
  %298 = getelementptr inbounds i8, ptr %.3324, i64 32
  store ptr %295, ptr %298, align 8, !tbaa !28
  %299 = getelementptr inbounds i8, ptr %295, i64 48
  store ptr %.3324, ptr %299, align 8, !tbaa !24
  br label %301

300:                                              ; preds = %296
  tail call void @abort() #6
  unreachable

301:                                              ; preds = %297, %292
  %302 = getelementptr inbounds i8, ptr %18, i64 40
  %303 = load ptr, ptr %302, align 8, !tbaa !28
  %.not402 = icmp eq ptr %303, null
  br i1 %.not402, label %310, label %304

304:                                              ; preds = %301
  %.not403 = icmp ult ptr %303, %291
  br i1 %.not403, label %308, label %305, !prof !14

305:                                              ; preds = %304
  %306 = getelementptr inbounds i8, ptr %.3324, i64 40
  store ptr %303, ptr %306, align 8, !tbaa !28
  %307 = getelementptr inbounds i8, ptr %303, i64 48
  store ptr %.3324, ptr %307, align 8, !tbaa !24
  br label %310

308:                                              ; preds = %304
  tail call void @abort() #6
  unreachable

309:                                              ; preds = %290
  tail call void @abort() #6
  unreachable

310:                                              ; preds = %.thread465, %269, %301, %305, %284, %.critedge435, %221
  %311 = or i64 %198, 1
  %312 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %311, ptr %312, align 8, !tbaa !15
  %313 = getelementptr inbounds i8, ptr %.1, i64 %198
  store i64 %198, ptr %313, align 8, !tbaa !17
  %314 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !19
  %.not408 = icmp eq ptr %.1, %314
  br i1 %.not408, label %.thread447, label %320

.thread447:                                       ; preds = %310
  store i64 %198, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !33
  br label %412

315:                                              ; preds = %169
  %316 = and i64 %167, -2
  store i64 %316, ptr %166, align 8, !tbaa !15
  %317 = or i64 %.1305, 1
  %318 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %317, ptr %318, align 8, !tbaa !15
  %319 = getelementptr inbounds i8, ptr %.1, i64 %.1305
  store i64 %.1305, ptr %319, align 8, !tbaa !17
  br label %320

320:                                              ; preds = %310, %315
  %.2 = phi i64 [ %.1305, %315 ], [ %198, %310 ]
  %321 = icmp ult i64 %.2, 256
  br i1 %321, label %322, label %345

322:                                              ; preds = %320
  %323 = lshr i64 %.2, 3
  %324 = shl nuw nsw i64 %323, 1
  %325 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %324
  %326 = icmp ugt i64 %.2, 31
  br i1 %326, label %328, label %327

327:                                              ; preds = %322
  tail call void @abort() #6
  unreachable

328:                                              ; preds = %322
  %329 = trunc nuw nsw i64 %323 to i32
  %330 = load i32, ptr @_gm_, align 8, !tbaa !23
  %331 = shl nuw i32 1, %329
  %332 = and i32 %330, %331
  %.not413 = icmp eq i32 %332, 0
  br i1 %.not413, label %333, label %335

333:                                              ; preds = %328
  %334 = or i32 %330, %331
  store i32 %334, ptr @_gm_, align 8, !tbaa !23
  br label %340

335:                                              ; preds = %328
  %336 = getelementptr inbounds i8, ptr %325, i64 16
  %337 = load ptr, ptr %336, align 8, !tbaa !20
  %338 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not414 = icmp ult ptr %337, %338
  br i1 %.not414, label %339, label %340, !prof !14

339:                                              ; preds = %335
  tail call void @abort() #6
  unreachable

340:                                              ; preds = %335, %333
  %.0320 = phi ptr [ %325, %333 ], [ %337, %335 ]
  %341 = getelementptr inbounds i8, ptr %325, i64 16
  store ptr %.1, ptr %341, align 8, !tbaa !20
  %342 = getelementptr inbounds i8, ptr %.0320, i64 24
  store ptr %.1, ptr %342, align 8, !tbaa !21
  %343 = getelementptr inbounds i8, ptr %.1, i64 16
  store ptr %.0320, ptr %343, align 8, !tbaa !20
  %344 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %325, ptr %344, align 8, !tbaa !21
  tail call void @do_check_free_chunk(ptr noundef nonnull @_gm_, ptr noundef nonnull %.1)
  br label %412

345:                                              ; preds = %320
  %346 = lshr i64 %.2, 8
  %347 = trunc i64 %346 to i32
  %348 = icmp eq i32 %347, 0
  br i1 %348, label %361, label %349

349:                                              ; preds = %345
  %350 = icmp ugt i32 %347, 65535
  br i1 %350, label %361, label %351

351:                                              ; preds = %349
  %352 = tail call range(i32 16, 33) i32 @llvm.ctlz.i32(i32 %347, i1 true)
  %353 = shl nuw nsw i32 %352, 1
  %354 = sub nuw nsw i32 38, %352
  %355 = zext nneg i32 %354 to i64
  %356 = lshr i64 %.2, %355
  %357 = trunc i64 %356 to i32
  %358 = and i32 %357, 1
  %359 = or disjoint i32 %358, %353
  %360 = xor i32 %359, 62
  br label %361

361:                                              ; preds = %349, %345, %351
  %.0314 = phi i32 [ %360, %351 ], [ 0, %345 ], [ 31, %349 ]
  %362 = zext nneg i32 %.0314 to i64
  %363 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %362
  %364 = getelementptr inbounds i8, ptr %.1, i64 56
  store i32 %.0314, ptr %364, align 8, !tbaa !31
  %365 = getelementptr inbounds i8, ptr %.1, i64 32
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %365, i8 0, i64 16, i1 false)
  %366 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  %367 = shl nuw i32 1, %.0314
  %368 = and i32 %366, %367
  %.not409 = icmp eq i32 %368, 0
  br i1 %.not409, label %369, label %371

369:                                              ; preds = %361
  %370 = or i32 %366, %367
  store i32 %370, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !32
  br label %.thread449

371:                                              ; preds = %361
  %372 = load ptr, ptr %363, align 8, !tbaa !28
  %373 = icmp eq i32 %.0314, 31
  %374 = lshr i32 %.0314, 1
  %375 = add nuw nsw i32 %374, 6
  %376 = zext nneg i32 %375 to i64
  %377 = sub nuw nsw i64 63, %376
  %378 = select i1 %373, i64 0, i64 %377
  %379 = shl i64 %.2, %378
  br label %380

380:                                              ; preds = %384, %371
  %.0307 = phi ptr [ %372, %371 ], [ %389, %384 ]
  %.0306 = phi i64 [ %379, %371 ], [ %388, %384 ]
  %381 = getelementptr inbounds i8, ptr %.0307, i64 8
  %382 = load i64, ptr %381, align 8, !tbaa !38
  %383 = and i64 %382, -8
  %.not410 = icmp eq i64 %383, %.2
  br i1 %.not410, label %394, label %384

384:                                              ; preds = %380
  %385 = getelementptr inbounds i8, ptr %.0307, i64 32
  %386 = lshr i64 %.0306, 63
  %387 = getelementptr inbounds [2 x ptr], ptr %385, i64 0, i64 %386
  %388 = shl i64 %.0306, 1
  %389 = load ptr, ptr %387, align 8, !tbaa !28
  %.not411 = icmp eq ptr %389, null
  br i1 %.not411, label %390, label %380

390:                                              ; preds = %384
  %391 = getelementptr inbounds [2 x ptr], ptr %385, i64 0, i64 %386
  %392 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !13
  %.not412 = icmp ult ptr %391, %392
  br i1 %.not412, label %393, label %.thread449, !prof !14

393:                                              ; preds = %390
  tail call void @abort() #6
  unreachable

394:                                              ; preds = %380
  %395 = getelementptr inbounds i8, ptr %.0307, i64 16
  %396 = load ptr, ptr %395, align 8, !tbaa !27
  %397 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8
  %398 = icmp uge ptr %.0307, %397
  %399 = icmp uge ptr %396, %397
  %400 = select i1 %398, i1 %399, i1 false, !prof !22
  br i1 %400, label %401, label %403, !prof !22

401:                                              ; preds = %394
  %402 = getelementptr inbounds i8, ptr %396, i64 24
  store ptr %.1, ptr %402, align 8, !tbaa !26
  br label %.thread449

403:                                              ; preds = %394
  tail call void @abort() #6
  unreachable

.thread449:                                       ; preds = %390, %401, %369
  %.sink477 = phi ptr [ %395, %401 ], [ %363, %369 ], [ %391, %390 ]
  %.sink476 = phi i64 [ 16, %401 ], [ 48, %369 ], [ 48, %390 ]
  %.0307.lcssa467.sink = phi ptr [ %396, %401 ], [ %363, %369 ], [ %.0307, %390 ]
  %.1.sink473 = phi ptr [ %.0307, %401 ], [ %.1, %369 ], [ %.1, %390 ]
  %.sink472 = phi i64 [ 48, %401 ], [ 16, %369 ], [ 16, %390 ]
  %.1.sink = phi ptr [ null, %401 ], [ %.1, %369 ], [ %.1, %390 ]
  store ptr %.1, ptr %.sink477, align 8, !tbaa !28
  %404 = getelementptr inbounds i8, ptr %.1, i64 %.sink476
  store ptr %.0307.lcssa467.sink, ptr %404, align 8, !tbaa !28
  %405 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %.1.sink473, ptr %405, align 8, !tbaa !26
  %406 = getelementptr inbounds i8, ptr %.1, i64 %.sink472
  store ptr %.1.sink, ptr %406, align 8, !tbaa !28
  tail call void @do_check_free_chunk(ptr noundef nonnull @_gm_, ptr noundef nonnull %.1)
  %407 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !39
  %408 = add i64 %407, -1
  store i64 %408, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !39
  %409 = icmp eq i64 %408, 0
  br i1 %409, label %410, label %412

410:                                              ; preds = %.thread449
  %411 = tail call i64 @release_unused_segments(ptr noundef nonnull @_gm_)
  br label %412

.critedge417:                                     ; preds = %.thread, %165, %34, %10, %12
  tail call void @abort() #6
  unreachable

412:                                              ; preds = %190, %185, %182, %.thread449, %410, %340, %31, %24, %160, %.thread447
  %413 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 880), align 8, !tbaa !5
  %414 = and i32 %413, 2
  %.not415 = icmp eq i32 %414, 0
  br i1 %.not415, label %416, label %415

415:                                              ; preds = %412
  store atomic i32 0, ptr getelementptr inbounds (i8, ptr @_gm_, i64 884) release, align 4
  br label %416

416:                                              ; preds = %8, %415, %412, %1
  ret void
}

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

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

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

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

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

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

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #5 = { nounwind }
attributes #6 = { noreturn nounwind }

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

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


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