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

; 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, %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
@.str.1 = external hidden unnamed_addr constant [100 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [7 x i8], align 1
@__PRETTY_FUNCTION__.free = external hidden unnamed_addr constant [18 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1

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

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #1

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @free(ptr noundef %0) #3 {
  %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 %1134

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 ptr, ptr %3, align 8, !tbaa !5
  %54 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %55 = icmp uge ptr %53, %54
  br i1 %55, label %56, label %62

56:                                               ; preds = %50
  %57 = load ptr, ptr %3, align 8, !tbaa !5
  %58 = getelementptr inbounds %struct.malloc_chunk, ptr %57, i32 0, i32 1
  %59 = load i64, ptr %58, align 8, !tbaa !14
  %60 = and i64 %59, 3
  %61 = icmp ne i64 %60, 1
  br label %62

62:                                               ; preds = %56, %50
  %63 = phi i1 [ false, %50 ], [ %61, %56 ]
  %64 = zext i1 %63 to i32
  %65 = sext i32 %64 to i64
  %66 = call i64 @llvm.expect.i64(i64 %65, i64 1)
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %68, label %1131

68:                                               ; preds = %62
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #6
  %69 = load ptr, ptr %3, align 8, !tbaa !5
  %70 = getelementptr inbounds %struct.malloc_chunk, ptr %69, i32 0, i32 1
  %71 = load i64, ptr %70, align 8, !tbaa !14
  %72 = and i64 %71, -8
  store i64 %72, ptr %4, align 8, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #6
  %73 = load ptr, ptr %3, align 8, !tbaa !5
  %74 = load i64, ptr %4, align 8, !tbaa !16
  %75 = getelementptr inbounds i8, ptr %73, i64 %74
  store ptr %75, ptr %5, align 8, !tbaa !5
  %76 = load ptr, ptr %3, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.malloc_chunk, ptr %76, i32 0, i32 1
  %78 = load i64, ptr %77, align 8, !tbaa !14
  %79 = and i64 %78, 1
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %479, label %81

81:                                               ; preds = %68
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #6
  %82 = load ptr, ptr %3, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.malloc_chunk, ptr %82, i32 0, i32 0
  %84 = load i64, ptr %83, align 8, !tbaa !17
  store i64 %84, ptr %6, align 8, !tbaa !16
  %85 = load ptr, ptr %3, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.malloc_chunk, ptr %85, i32 0, i32 1
  %87 = load i64, ptr %86, align 8, !tbaa !14
  %88 = and i64 %87, 3
  %89 = icmp eq i64 %88, 0
  br i1 %89, label %90, label %107

90:                                               ; preds = %81
  %91 = load i64, ptr %6, align 8, !tbaa !16
  %92 = add i64 %91, 32
  %93 = load i64, ptr %4, align 8, !tbaa !16
  %94 = add i64 %93, %92
  store i64 %94, ptr %4, align 8, !tbaa !16
  %95 = load ptr, ptr %3, align 8, !tbaa !5
  %96 = load i64, ptr %6, align 8, !tbaa !16
  %97 = sub i64 0, %96
  %98 = getelementptr inbounds i8, ptr %95, i64 %97
  %99 = load i64, ptr %4, align 8, !tbaa !16
  %100 = call i32 @munmap(ptr noundef %98, i64 noundef %99) #6
  %101 = icmp eq i32 %100, 0
  br i1 %101, label %102, label %106

102:                                              ; preds = %90
  %103 = load i64, ptr %4, align 8, !tbaa !16
  %104 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 12), align 8, !tbaa !18
  %105 = sub i64 %104, %103
  store i64 %105, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 12), align 8, !tbaa !18
  br label %106

106:                                              ; preds = %102, %90
  store i32 2, ptr %20, align 4
  br label %476

107:                                              ; preds = %81
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #6
  %108 = load ptr, ptr %3, align 8, !tbaa !5
  %109 = load i64, ptr %6, align 8, !tbaa !16
  %110 = sub i64 0, %109
  %111 = getelementptr inbounds i8, ptr %108, i64 %110
  store ptr %111, ptr %7, align 8, !tbaa !5
  %112 = load i64, ptr %6, align 8, !tbaa !16
  %113 = load i64, ptr %4, align 8, !tbaa !16
  %114 = add i64 %113, %112
  store i64 %114, ptr %4, align 8, !tbaa !16
  %115 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %115, ptr %3, align 8, !tbaa !5
  %116 = load ptr, ptr %7, align 8, !tbaa !5
  %117 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %118 = icmp uge ptr %116, %117
  %119 = zext i1 %118 to i32
  %120 = sext i32 %119 to i64
  %121 = call i64 @llvm.expect.i64(i64 %120, i64 1)
  %122 = icmp ne i64 %121, 0
  br i1 %122, label %123, label %470

123:                                              ; preds = %107
  %124 = load ptr, ptr %3, align 8, !tbaa !5
  %125 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %126 = icmp ne ptr %124, %125
  br i1 %126, label %127, label %447

127:                                              ; preds = %123
  %128 = load i64, ptr %6, align 8, !tbaa !16
  %129 = lshr i64 %128, 3
  %130 = icmp ult i64 %129, 32
  br i1 %130, label %131, label %235

131:                                              ; preds = %127
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #6
  %132 = load ptr, ptr %3, align 8, !tbaa !5
  %133 = getelementptr inbounds %struct.malloc_chunk, ptr %132, i32 0, i32 2
  %134 = load ptr, ptr %133, align 8, !tbaa !20
  store ptr %134, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #6
  %135 = load ptr, ptr %3, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.malloc_chunk, ptr %135, i32 0, i32 3
  %137 = load ptr, ptr %136, align 8, !tbaa !21
  store ptr %137, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #6
  %138 = load i64, ptr %6, align 8, !tbaa !16
  %139 = lshr i64 %138, 3
  %140 = trunc i64 %139 to i32
  store i32 %140, ptr %10, align 4, !tbaa !22
  %141 = load ptr, ptr %3, align 8, !tbaa !5
  %142 = load ptr, ptr %9, align 8, !tbaa !5
  %143 = icmp ne ptr %141, %142
  br i1 %143, label %144, label %145

144:                                              ; preds = %131
  br label %146

145:                                              ; preds = %131
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 4714, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

146:                                              ; preds = %144
  %147 = load ptr, ptr %3, align 8, !tbaa !5
  %148 = load ptr, ptr %8, align 8, !tbaa !5
  %149 = icmp ne ptr %147, %148
  br i1 %149, label %150, label %151

150:                                              ; preds = %146
  br label %152

151:                                              ; preds = %146
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 4714, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

152:                                              ; preds = %150
  %153 = load ptr, ptr %3, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.malloc_chunk, ptr %153, i32 0, i32 1
  %155 = load i64, ptr %154, align 8, !tbaa !14
  %156 = and i64 %155, -8
  %157 = load i32, ptr %10, align 4, !tbaa !22
  %158 = shl i32 %157, 3
  %159 = zext i32 %158 to i64
  %160 = icmp eq i64 %156, %159
  br i1 %160, label %161, label %162

161:                                              ; preds = %152
  br label %163

162:                                              ; preds = %152
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 4714, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

163:                                              ; preds = %161
  %164 = load ptr, ptr %8, align 8, !tbaa !5
  %165 = load i32, ptr %10, align 4, !tbaa !22
  %166 = shl i32 %165, 1
  %167 = zext i32 %166 to i64
  %168 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %167
  %169 = icmp eq ptr %164, %168
  br i1 %169, label %182, label %170

170:                                              ; preds = %163
  %171 = load ptr, ptr %8, align 8, !tbaa !5
  %172 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %173 = icmp uge ptr %171, %172
  br i1 %173, label %174, label %180

174:                                              ; preds = %170
  %175 = load ptr, ptr %8, align 8, !tbaa !5
  %176 = getelementptr inbounds %struct.malloc_chunk, ptr %175, i32 0, i32 3
  %177 = load ptr, ptr %176, align 8, !tbaa !21
  %178 = load ptr, ptr %3, align 8, !tbaa !5
  %179 = icmp eq ptr %177, %178
  br label %180

180:                                              ; preds = %174, %170
  %181 = phi i1 [ false, %170 ], [ %179, %174 ]
  br label %182

182:                                              ; preds = %180, %163
  %183 = phi i1 [ true, %163 ], [ %181, %180 ]
  %184 = zext i1 %183 to i32
  %185 = sext i32 %184 to i64
  %186 = call i64 @llvm.expect.i64(i64 %185, i64 1)
  %187 = icmp ne i64 %186, 0
  br i1 %187, label %188, label %233

188:                                              ; preds = %182
  %189 = load ptr, ptr %9, align 8, !tbaa !5
  %190 = load ptr, ptr %8, align 8, !tbaa !5
  %191 = icmp eq ptr %189, %190
  br i1 %191, label %192, label %198

192:                                              ; preds = %188
  %193 = load i32, ptr %10, align 4, !tbaa !22
  %194 = shl i32 1, %193
  %195 = xor i32 %194, -1
  %196 = load i32, ptr @_gm_, align 8, !tbaa !23
  %197 = and i32 %196, %195
  store i32 %197, ptr @_gm_, align 8, !tbaa !23
  br label %232

198:                                              ; preds = %188
  %199 = load ptr, ptr %9, align 8, !tbaa !5
  %200 = load i32, ptr %10, align 4, !tbaa !22
  %201 = shl i32 %200, 1
  %202 = zext i32 %201 to i64
  %203 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %202
  %204 = icmp eq ptr %199, %203
  br i1 %204, label %217, label %205

205:                                              ; preds = %198
  %206 = load ptr, ptr %9, align 8, !tbaa !5
  %207 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %208 = icmp uge ptr %206, %207
  br i1 %208, label %209, label %215

209:                                              ; preds = %205
  %210 = load ptr, ptr %9, align 8, !tbaa !5
  %211 = getelementptr inbounds %struct.malloc_chunk, ptr %210, i32 0, i32 2
  %212 = load ptr, ptr %211, align 8, !tbaa !20
  %213 = load ptr, ptr %3, align 8, !tbaa !5
  %214 = icmp eq ptr %212, %213
  br label %215

215:                                              ; preds = %209, %205
  %216 = phi i1 [ false, %205 ], [ %214, %209 ]
  br label %217

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

223:                                              ; preds = %217
  %224 = load ptr, ptr %9, align 8, !tbaa !5
  %225 = load ptr, ptr %8, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.malloc_chunk, ptr %225, i32 0, i32 3
  store ptr %224, ptr %226, align 8, !tbaa !21
  %227 = load ptr, ptr %8, align 8, !tbaa !5
  %228 = load ptr, ptr %9, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.malloc_chunk, ptr %228, i32 0, i32 2
  store ptr %227, ptr %229, align 8, !tbaa !20
  br label %231

230:                                              ; preds = %217
  call void @abort() #7
  unreachable

231:                                              ; preds = %223
  br label %232

232:                                              ; preds = %231, %192
  br label %234

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

234:                                              ; preds = %232
  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 %446

235:                                              ; preds = %127
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  %236 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %236, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %237 = load ptr, ptr %11, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %237, i32 0, i32 5
  %239 = load ptr, ptr %238, align 8, !tbaa !24
  store ptr %239, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #6
  %240 = load ptr, ptr %11, align 8, !tbaa !5
  %241 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %240, i32 0, i32 3
  %242 = load ptr, ptr %241, align 8, !tbaa !26
  %243 = load ptr, ptr %11, align 8, !tbaa !5
  %244 = icmp ne ptr %242, %243
  br i1 %244, label %245, label %282

245:                                              ; preds = %235
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #6
  %246 = load ptr, ptr %11, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %246, i32 0, i32 2
  %248 = load ptr, ptr %247, align 8, !tbaa !27
  store ptr %248, ptr %14, align 8, !tbaa !5
  %249 = load ptr, ptr %11, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %249, i32 0, i32 3
  %251 = load ptr, ptr %250, align 8, !tbaa !26
  store ptr %251, ptr %13, align 8, !tbaa !5
  %252 = load ptr, ptr %14, align 8, !tbaa !5
  %253 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %254 = icmp uge ptr %252, %253
  br i1 %254, label %255, label %267

255:                                              ; preds = %245
  %256 = load ptr, ptr %14, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %256, i32 0, i32 3
  %258 = load ptr, ptr %257, align 8, !tbaa !26
  %259 = load ptr, ptr %11, align 8, !tbaa !5
  %260 = icmp eq ptr %258, %259
  br i1 %260, label %261, label %267

261:                                              ; preds = %255
  %262 = load ptr, ptr %13, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %262, i32 0, i32 2
  %264 = load ptr, ptr %263, align 8, !tbaa !27
  %265 = load ptr, ptr %11, align 8, !tbaa !5
  %266 = icmp eq ptr %264, %265
  br label %267

267:                                              ; preds = %261, %255, %245
  %268 = phi i1 [ false, %255 ], [ false, %245 ], [ %266, %261 ]
  %269 = zext i1 %268 to i32
  %270 = sext i32 %269 to i64
  %271 = call i64 @llvm.expect.i64(i64 %270, i64 1)
  %272 = icmp ne i64 %271, 0
  br i1 %272, label %273, label %280

273:                                              ; preds = %267
  %274 = load ptr, ptr %13, align 8, !tbaa !5
  %275 = load ptr, ptr %14, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %275, i32 0, i32 3
  store ptr %274, ptr %276, align 8, !tbaa !26
  %277 = load ptr, ptr %14, align 8, !tbaa !5
  %278 = load ptr, ptr %13, align 8, !tbaa !5
  %279 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %278, i32 0, i32 2
  store ptr %277, ptr %279, align 8, !tbaa !27
  br label %281

280:                                              ; preds = %267
  call void @abort() #7
  unreachable

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

282:                                              ; preds = %235
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  %283 = load ptr, ptr %11, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %283, i32 0, i32 4
  %285 = getelementptr inbounds [2 x ptr], ptr %284, i64 0, i64 1
  store ptr %285, ptr %15, align 8, !tbaa !5
  %286 = load ptr, ptr %285, align 8, !tbaa !5
  store ptr %286, ptr %13, align 8, !tbaa !5
  %287 = icmp ne ptr %286, null
  br i1 %287, label %294, label %288

288:                                              ; preds = %282
  %289 = load ptr, ptr %11, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %289, i32 0, i32 4
  %291 = getelementptr inbounds [2 x ptr], ptr %290, i64 0, i64 0
  store ptr %291, ptr %15, align 8, !tbaa !5
  %292 = load ptr, ptr %291, align 8, !tbaa !5
  store ptr %292, ptr %13, align 8, !tbaa !5
  %293 = icmp ne ptr %292, null
  br i1 %293, label %294, label %324

294:                                              ; preds = %288, %282
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #6
  br label %295

295:                                              ; preds = %309, %294
  %296 = load ptr, ptr %13, align 8, !tbaa !5
  %297 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %296, i32 0, i32 4
  %298 = getelementptr inbounds [2 x ptr], ptr %297, i64 0, i64 1
  store ptr %298, ptr %16, align 8, !tbaa !5
  %299 = load ptr, ptr %298, align 8, !tbaa !5
  %300 = icmp ne ptr %299, null
  br i1 %300, label %307, label %301

301:                                              ; preds = %295
  %302 = load ptr, ptr %13, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %302, i32 0, i32 4
  %304 = getelementptr inbounds [2 x ptr], ptr %303, i64 0, i64 0
  store ptr %304, ptr %16, align 8, !tbaa !5
  %305 = load ptr, ptr %304, align 8, !tbaa !5
  %306 = icmp ne ptr %305, null
  br label %307

307:                                              ; preds = %301, %295
  %308 = phi i1 [ true, %295 ], [ %306, %301 ]
  br i1 %308, label %309, label %312

309:                                              ; preds = %307
  %310 = load ptr, ptr %16, align 8, !tbaa !5
  store ptr %310, ptr %15, align 8, !tbaa !5
  %311 = load ptr, ptr %310, align 8, !tbaa !5
  store ptr %311, ptr %13, align 8, !tbaa !5
  br label %295, !llvm.loop !28

312:                                              ; preds = %307
  %313 = load ptr, ptr %15, align 8, !tbaa !5
  %314 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %315 = icmp uge ptr %313, %314
  %316 = zext i1 %315 to i32
  %317 = sext i32 %316 to i64
  %318 = call i64 @llvm.expect.i64(i64 %317, i64 1)
  %319 = icmp ne i64 %318, 0
  br i1 %319, label %320, label %322

320:                                              ; preds = %312
  %321 = load ptr, ptr %15, align 8, !tbaa !5
  store ptr null, ptr %321, align 8, !tbaa !5
  br label %323

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

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

324:                                              ; preds = %323, %288
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  br label %325

325:                                              ; preds = %324, %281
  %326 = load ptr, ptr %12, align 8, !tbaa !5
  %327 = icmp ne ptr %326, null
  br i1 %327, label %328, label %445

328:                                              ; preds = %325
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  %329 = load ptr, ptr %11, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %329, i32 0, i32 6
  %331 = load i32, ptr %330, align 8, !tbaa !30
  %332 = zext i32 %331 to i64
  %333 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %332
  store ptr %333, ptr %17, align 8, !tbaa !5
  %334 = load ptr, ptr %11, align 8, !tbaa !5
  %335 = load ptr, ptr %17, align 8, !tbaa !5
  %336 = load ptr, ptr %335, align 8, !tbaa !5
  %337 = icmp eq ptr %334, %336
  br i1 %337, label %338, label %351

338:                                              ; preds = %328
  %339 = load ptr, ptr %13, align 8, !tbaa !5
  %340 = load ptr, ptr %17, align 8, !tbaa !5
  store ptr %339, ptr %340, align 8, !tbaa !5
  %341 = icmp eq ptr %339, null
  br i1 %341, label %342, label %350

342:                                              ; preds = %338
  %343 = load ptr, ptr %11, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %343, i32 0, i32 6
  %345 = load i32, ptr %344, align 8, !tbaa !30
  %346 = shl i32 1, %345
  %347 = xor i32 %346, -1
  %348 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %349 = and i32 %348, %347
  store i32 %349, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  br label %350

350:                                              ; preds = %342, %338
  br label %379

351:                                              ; preds = %328
  %352 = load ptr, ptr %12, align 8, !tbaa !5
  %353 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %354 = icmp uge ptr %352, %353
  %355 = zext i1 %354 to i32
  %356 = sext i32 %355 to i64
  %357 = call i64 @llvm.expect.i64(i64 %356, i64 1)
  %358 = icmp ne i64 %357, 0
  br i1 %358, label %359, label %377

359:                                              ; preds = %351
  %360 = load ptr, ptr %12, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %360, i32 0, i32 4
  %362 = getelementptr inbounds [2 x ptr], ptr %361, i64 0, i64 0
  %363 = load ptr, ptr %362, align 8, !tbaa !5
  %364 = load ptr, ptr %11, align 8, !tbaa !5
  %365 = icmp eq ptr %363, %364
  br i1 %365, label %366, label %371

366:                                              ; preds = %359
  %367 = load ptr, ptr %13, align 8, !tbaa !5
  %368 = load ptr, ptr %12, align 8, !tbaa !5
  %369 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %368, i32 0, i32 4
  %370 = getelementptr inbounds [2 x ptr], ptr %369, i64 0, i64 0
  store ptr %367, ptr %370, align 8, !tbaa !5
  br label %376

371:                                              ; preds = %359
  %372 = load ptr, ptr %13, align 8, !tbaa !5
  %373 = load ptr, ptr %12, align 8, !tbaa !5
  %374 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %373, i32 0, i32 4
  %375 = getelementptr inbounds [2 x ptr], ptr %374, i64 0, i64 1
  store ptr %372, ptr %375, align 8, !tbaa !5
  br label %376

376:                                              ; preds = %371, %366
  br label %378

377:                                              ; preds = %351
  call void @abort() #7
  unreachable

378:                                              ; preds = %376
  br label %379

379:                                              ; preds = %378, %350
  %380 = load ptr, ptr %13, align 8, !tbaa !5
  %381 = icmp ne ptr %380, null
  br i1 %381, label %382, label %444

382:                                              ; preds = %379
  %383 = load ptr, ptr %13, align 8, !tbaa !5
  %384 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %385 = icmp uge ptr %383, %384
  %386 = zext i1 %385 to i32
  %387 = sext i32 %386 to i64
  %388 = call i64 @llvm.expect.i64(i64 %387, i64 1)
  %389 = icmp ne i64 %388, 0
  br i1 %389, label %390, label %442

390:                                              ; preds = %382
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  %391 = load ptr, ptr %12, align 8, !tbaa !5
  %392 = load ptr, ptr %13, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %392, i32 0, i32 5
  store ptr %391, ptr %393, align 8, !tbaa !24
  %394 = load ptr, ptr %11, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %394, i32 0, i32 4
  %396 = getelementptr inbounds [2 x ptr], ptr %395, i64 0, i64 0
  %397 = load ptr, ptr %396, align 8, !tbaa !5
  store ptr %397, ptr %18, align 8, !tbaa !5
  %398 = icmp ne ptr %397, null
  br i1 %398, label %399, label %417

399:                                              ; preds = %390
  %400 = load ptr, ptr %18, align 8, !tbaa !5
  %401 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %402 = icmp uge ptr %400, %401
  %403 = zext i1 %402 to i32
  %404 = sext i32 %403 to i64
  %405 = call i64 @llvm.expect.i64(i64 %404, i64 1)
  %406 = icmp ne i64 %405, 0
  br i1 %406, label %407, label %415

407:                                              ; preds = %399
  %408 = load ptr, ptr %18, align 8, !tbaa !5
  %409 = load ptr, ptr %13, align 8, !tbaa !5
  %410 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %409, i32 0, i32 4
  %411 = getelementptr inbounds [2 x ptr], ptr %410, i64 0, i64 0
  store ptr %408, ptr %411, align 8, !tbaa !5
  %412 = load ptr, ptr %13, align 8, !tbaa !5
  %413 = load ptr, ptr %18, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %413, i32 0, i32 5
  store ptr %412, ptr %414, align 8, !tbaa !24
  br label %416

415:                                              ; preds = %399
  call void @abort() #7
  unreachable

416:                                              ; preds = %407
  br label %417

417:                                              ; preds = %416, %390
  %418 = load ptr, ptr %11, align 8, !tbaa !5
  %419 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %418, i32 0, i32 4
  %420 = getelementptr inbounds [2 x ptr], ptr %419, i64 0, i64 1
  %421 = load ptr, ptr %420, align 8, !tbaa !5
  store ptr %421, ptr %19, align 8, !tbaa !5
  %422 = icmp ne ptr %421, null
  br i1 %422, label %423, label %441

423:                                              ; preds = %417
  %424 = load ptr, ptr %19, align 8, !tbaa !5
  %425 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %426 = icmp uge ptr %424, %425
  %427 = zext i1 %426 to i32
  %428 = sext i32 %427 to i64
  %429 = call i64 @llvm.expect.i64(i64 %428, i64 1)
  %430 = icmp ne i64 %429, 0
  br i1 %430, label %431, label %439

431:                                              ; preds = %423
  %432 = load ptr, ptr %19, align 8, !tbaa !5
  %433 = load ptr, ptr %13, align 8, !tbaa !5
  %434 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %433, i32 0, i32 4
  %435 = getelementptr inbounds [2 x ptr], ptr %434, i64 0, i64 1
  store ptr %432, ptr %435, align 8, !tbaa !5
  %436 = load ptr, ptr %13, align 8, !tbaa !5
  %437 = load ptr, ptr %19, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %437, i32 0, i32 5
  store ptr %436, ptr %438, align 8, !tbaa !24
  br label %440

439:                                              ; preds = %423
  call void @abort() #7
  unreachable

440:                                              ; preds = %431
  br label %441

441:                                              ; preds = %440, %417
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #6
  br label %443

442:                                              ; preds = %382
  call void @abort() #7
  unreachable

443:                                              ; preds = %441
  br label %444

444:                                              ; preds = %443, %379
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  br label %445

445:                                              ; preds = %444, %325
  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 %446

446:                                              ; preds = %445, %234
  br label %469

447:                                              ; preds = %123
  %448 = load ptr, ptr %5, align 8, !tbaa !5
  %449 = getelementptr inbounds %struct.malloc_chunk, ptr %448, i32 0, i32 1
  %450 = load i64, ptr %449, align 8, !tbaa !14
  %451 = and i64 %450, 3
  %452 = icmp eq i64 %451, 3
  br i1 %452, label %453, label %468

453:                                              ; preds = %447
  %454 = load i64, ptr %4, align 8, !tbaa !16
  store i64 %454, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  %455 = load ptr, ptr %5, align 8, !tbaa !5
  %456 = getelementptr inbounds %struct.malloc_chunk, ptr %455, i32 0, i32 1
  %457 = load i64, ptr %456, align 8, !tbaa !14
  %458 = and i64 %457, -2
  store i64 %458, ptr %456, align 8, !tbaa !14
  %459 = load i64, ptr %4, align 8, !tbaa !16
  %460 = or i64 %459, 1
  %461 = load ptr, ptr %3, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.malloc_chunk, ptr %461, i32 0, i32 1
  store i64 %460, ptr %462, align 8, !tbaa !14
  %463 = load i64, ptr %4, align 8, !tbaa !16
  %464 = load ptr, ptr %3, align 8, !tbaa !5
  %465 = load i64, ptr %4, align 8, !tbaa !16
  %466 = getelementptr inbounds i8, ptr %464, i64 %465
  %467 = getelementptr inbounds %struct.malloc_chunk, ptr %466, i32 0, i32 0
  store i64 %463, ptr %467, align 8, !tbaa !17
  store i32 2, ptr %20, align 4
  br label %472

468:                                              ; preds = %447
  br label %469

469:                                              ; preds = %468, %446
  br label %471

470:                                              ; preds = %107
  store i32 5, ptr %20, align 4
  br label %472

471:                                              ; preds = %469
  store i32 0, ptr %20, align 4
  br label %472

472:                                              ; preds = %471, %470, %453
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  %473 = load i32, ptr %20, align 4
  switch i32 %473, label %476 [
    i32 0, label %474
  ]

474:                                              ; preds = %472
  br label %475

475:                                              ; preds = %474
  store i32 0, ptr %20, align 4
  br label %476

476:                                              ; preds = %475, %472, %106
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #6
  %477 = load i32, ptr %20, align 4
  switch i32 %477, label %1128 [
    i32 0, label %478
  ]

478:                                              ; preds = %476
  br label %479

479:                                              ; preds = %478, %68
  %480 = load ptr, ptr %3, align 8, !tbaa !5
  %481 = load ptr, ptr %5, align 8, !tbaa !5
  %482 = icmp ult ptr %480, %481
  br i1 %482, label %483, label %489

483:                                              ; preds = %479
  %484 = load ptr, ptr %5, align 8, !tbaa !5
  %485 = getelementptr inbounds %struct.malloc_chunk, ptr %484, i32 0, i32 1
  %486 = load i64, ptr %485, align 8, !tbaa !14
  %487 = and i64 %486, 1
  %488 = icmp ne i64 %487, 0
  br label %489

489:                                              ; preds = %483, %479
  %490 = phi i1 [ false, %479 ], [ %488, %483 ]
  %491 = zext i1 %490 to i32
  %492 = sext i32 %491 to i64
  %493 = call i64 @llvm.expect.i64(i64 %492, i64 1)
  %494 = icmp ne i64 %493, 0
  br i1 %494, label %495, label %1127

495:                                              ; preds = %489
  %496 = load ptr, ptr %5, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.malloc_chunk, ptr %496, i32 0, i32 1
  %498 = load i64, ptr %497, align 8, !tbaa !14
  %499 = and i64 %498, 2
  %500 = icmp ne i64 %499, 0
  br i1 %500, label %890, label %501

501:                                              ; preds = %495
  %502 = load ptr, ptr %5, align 8, !tbaa !5
  %503 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !33
  %504 = icmp eq ptr %502, %503
  br i1 %504, label %505, label %525

505:                                              ; preds = %501
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  %506 = load i64, ptr %4, align 8, !tbaa !16
  %507 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !34
  %508 = add i64 %507, %506
  store i64 %508, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !34
  store i64 %508, ptr %21, align 8, !tbaa !16
  %509 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %509, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !33
  %510 = load i64, ptr %21, align 8, !tbaa !16
  %511 = or i64 %510, 1
  %512 = load ptr, ptr %3, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.malloc_chunk, ptr %512, i32 0, i32 1
  store i64 %511, ptr %513, align 8, !tbaa !14
  %514 = load ptr, ptr %3, align 8, !tbaa !5
  %515 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %516 = icmp eq ptr %514, %515
  br i1 %516, label %517, label %518

517:                                              ; preds = %505
  store ptr null, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  store i64 0, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  br label %518

518:                                              ; preds = %517, %505
  %519 = load i64, ptr %21, align 8, !tbaa !16
  %520 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 7), align 8, !tbaa !35
  %521 = icmp ugt i64 %519, %520
  br i1 %521, label %522, label %524

522:                                              ; preds = %518
  %523 = call i32 @sys_trim(ptr noundef @_gm_, i64 noundef 0)
  br label %524

524:                                              ; preds = %522, %518
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  br label %1128

525:                                              ; preds = %501
  %526 = load ptr, ptr %5, align 8, !tbaa !5
  %527 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %528 = icmp eq ptr %526, %527
  br i1 %528, label %529, label %543

529:                                              ; preds = %525
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  %530 = load i64, ptr %4, align 8, !tbaa !16
  %531 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  %532 = add i64 %531, %530
  store i64 %532, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  store i64 %532, ptr %22, align 8, !tbaa !16
  %533 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %533, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %534 = load i64, ptr %22, align 8, !tbaa !16
  %535 = or i64 %534, 1
  %536 = load ptr, ptr %3, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.malloc_chunk, ptr %536, i32 0, i32 1
  store i64 %535, ptr %537, align 8, !tbaa !14
  %538 = load i64, ptr %22, align 8, !tbaa !16
  %539 = load ptr, ptr %3, align 8, !tbaa !5
  %540 = load i64, ptr %22, align 8, !tbaa !16
  %541 = getelementptr inbounds i8, ptr %539, i64 %540
  %542 = getelementptr inbounds %struct.malloc_chunk, ptr %541, i32 0, i32 0
  store i64 %538, ptr %542, align 8, !tbaa !17
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  br label %1128

543:                                              ; preds = %525
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  %544 = load ptr, ptr %5, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.malloc_chunk, ptr %544, i32 0, i32 1
  %546 = load i64, ptr %545, align 8, !tbaa !14
  %547 = and i64 %546, -8
  store i64 %547, ptr %23, align 8, !tbaa !16
  %548 = load i64, ptr %23, align 8, !tbaa !16
  %549 = load i64, ptr %4, align 8, !tbaa !16
  %550 = add i64 %549, %548
  store i64 %550, ptr %4, align 8, !tbaa !16
  %551 = load i64, ptr %23, align 8, !tbaa !16
  %552 = lshr i64 %551, 3
  %553 = icmp ult i64 %552, 32
  br i1 %553, label %554, label %658

554:                                              ; preds = %543
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  %555 = load ptr, ptr %5, align 8, !tbaa !5
  %556 = getelementptr inbounds %struct.malloc_chunk, ptr %555, i32 0, i32 2
  %557 = load ptr, ptr %556, align 8, !tbaa !20
  store ptr %557, ptr %24, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %558 = load ptr, ptr %5, align 8, !tbaa !5
  %559 = getelementptr inbounds %struct.malloc_chunk, ptr %558, i32 0, i32 3
  %560 = load ptr, ptr %559, align 8, !tbaa !21
  store ptr %560, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %561 = load i64, ptr %23, align 8, !tbaa !16
  %562 = lshr i64 %561, 3
  %563 = trunc i64 %562 to i32
  store i32 %563, ptr %26, align 4, !tbaa !22
  %564 = load ptr, ptr %5, align 8, !tbaa !5
  %565 = load ptr, ptr %25, align 8, !tbaa !5
  %566 = icmp ne ptr %564, %565
  br i1 %566, label %567, label %568

567:                                              ; preds = %554
  br label %569

568:                                              ; preds = %554
  call void @__assert_fail(ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 4750, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

569:                                              ; preds = %567
  %570 = load ptr, ptr %5, align 8, !tbaa !5
  %571 = load ptr, ptr %24, align 8, !tbaa !5
  %572 = icmp ne ptr %570, %571
  br i1 %572, label %573, label %574

573:                                              ; preds = %569
  br label %575

574:                                              ; preds = %569
  call void @__assert_fail(ptr noundef @.str.10, ptr noundef @.str.1, i32 noundef 4750, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

575:                                              ; preds = %573
  %576 = load ptr, ptr %5, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.malloc_chunk, ptr %576, i32 0, i32 1
  %578 = load i64, ptr %577, align 8, !tbaa !14
  %579 = and i64 %578, -8
  %580 = load i32, ptr %26, align 4, !tbaa !22
  %581 = shl i32 %580, 3
  %582 = zext i32 %581 to i64
  %583 = icmp eq i64 %579, %582
  br i1 %583, label %584, label %585

584:                                              ; preds = %575
  br label %586

585:                                              ; preds = %575
  call void @__assert_fail(ptr noundef @.str.11, ptr noundef @.str.1, i32 noundef 4750, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

586:                                              ; preds = %584
  %587 = load ptr, ptr %24, align 8, !tbaa !5
  %588 = load i32, ptr %26, align 4, !tbaa !22
  %589 = shl i32 %588, 1
  %590 = zext i32 %589 to i64
  %591 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %590
  %592 = icmp eq ptr %587, %591
  br i1 %592, label %605, label %593

593:                                              ; preds = %586
  %594 = load ptr, ptr %24, align 8, !tbaa !5
  %595 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %596 = icmp uge ptr %594, %595
  br i1 %596, label %597, label %603

597:                                              ; preds = %593
  %598 = load ptr, ptr %24, align 8, !tbaa !5
  %599 = getelementptr inbounds %struct.malloc_chunk, ptr %598, i32 0, i32 3
  %600 = load ptr, ptr %599, align 8, !tbaa !21
  %601 = load ptr, ptr %5, align 8, !tbaa !5
  %602 = icmp eq ptr %600, %601
  br label %603

603:                                              ; preds = %597, %593
  %604 = phi i1 [ false, %593 ], [ %602, %597 ]
  br label %605

605:                                              ; preds = %603, %586
  %606 = phi i1 [ true, %586 ], [ %604, %603 ]
  %607 = zext i1 %606 to i32
  %608 = sext i32 %607 to i64
  %609 = call i64 @llvm.expect.i64(i64 %608, i64 1)
  %610 = icmp ne i64 %609, 0
  br i1 %610, label %611, label %656

611:                                              ; preds = %605
  %612 = load ptr, ptr %25, align 8, !tbaa !5
  %613 = load ptr, ptr %24, align 8, !tbaa !5
  %614 = icmp eq ptr %612, %613
  br i1 %614, label %615, label %621

615:                                              ; preds = %611
  %616 = load i32, ptr %26, align 4, !tbaa !22
  %617 = shl i32 1, %616
  %618 = xor i32 %617, -1
  %619 = load i32, ptr @_gm_, align 8, !tbaa !23
  %620 = and i32 %619, %618
  store i32 %620, ptr @_gm_, align 8, !tbaa !23
  br label %655

621:                                              ; preds = %611
  %622 = load ptr, ptr %25, align 8, !tbaa !5
  %623 = load i32, ptr %26, align 4, !tbaa !22
  %624 = shl i32 %623, 1
  %625 = zext i32 %624 to i64
  %626 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %625
  %627 = icmp eq ptr %622, %626
  br i1 %627, label %640, label %628

628:                                              ; preds = %621
  %629 = load ptr, ptr %25, align 8, !tbaa !5
  %630 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %631 = icmp uge ptr %629, %630
  br i1 %631, label %632, label %638

632:                                              ; preds = %628
  %633 = load ptr, ptr %25, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.malloc_chunk, ptr %633, i32 0, i32 2
  %635 = load ptr, ptr %634, align 8, !tbaa !20
  %636 = load ptr, ptr %5, align 8, !tbaa !5
  %637 = icmp eq ptr %635, %636
  br label %638

638:                                              ; preds = %632, %628
  %639 = phi i1 [ false, %628 ], [ %637, %632 ]
  br label %640

640:                                              ; preds = %638, %621
  %641 = phi i1 [ true, %621 ], [ %639, %638 ]
  %642 = zext i1 %641 to i32
  %643 = sext i32 %642 to i64
  %644 = call i64 @llvm.expect.i64(i64 %643, i64 1)
  %645 = icmp ne i64 %644, 0
  br i1 %645, label %646, label %653

646:                                              ; preds = %640
  %647 = load ptr, ptr %25, align 8, !tbaa !5
  %648 = load ptr, ptr %24, align 8, !tbaa !5
  %649 = getelementptr inbounds %struct.malloc_chunk, ptr %648, i32 0, i32 3
  store ptr %647, ptr %649, align 8, !tbaa !21
  %650 = load ptr, ptr %24, align 8, !tbaa !5
  %651 = load ptr, ptr %25, align 8, !tbaa !5
  %652 = getelementptr inbounds %struct.malloc_chunk, ptr %651, i32 0, i32 2
  store ptr %650, ptr %652, align 8, !tbaa !20
  br label %654

653:                                              ; preds = %640
  call void @abort() #7
  unreachable

654:                                              ; preds = %646
  br label %655

655:                                              ; preds = %654, %615
  br label %657

656:                                              ; preds = %605
  call void @abort() #7
  unreachable

657:                                              ; preds = %655
  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 %869

658:                                              ; preds = %543
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  %659 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %659, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  %660 = load ptr, ptr %27, align 8, !tbaa !5
  %661 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %660, i32 0, i32 5
  %662 = load ptr, ptr %661, align 8, !tbaa !24
  store ptr %662, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  %663 = load ptr, ptr %27, align 8, !tbaa !5
  %664 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %663, i32 0, i32 3
  %665 = load ptr, ptr %664, align 8, !tbaa !26
  %666 = load ptr, ptr %27, align 8, !tbaa !5
  %667 = icmp ne ptr %665, %666
  br i1 %667, label %668, label %705

668:                                              ; preds = %658
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  %669 = load ptr, ptr %27, align 8, !tbaa !5
  %670 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %669, i32 0, i32 2
  %671 = load ptr, ptr %670, align 8, !tbaa !27
  store ptr %671, ptr %30, align 8, !tbaa !5
  %672 = load ptr, ptr %27, align 8, !tbaa !5
  %673 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %672, i32 0, i32 3
  %674 = load ptr, ptr %673, align 8, !tbaa !26
  store ptr %674, ptr %29, align 8, !tbaa !5
  %675 = load ptr, ptr %30, align 8, !tbaa !5
  %676 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %677 = icmp uge ptr %675, %676
  br i1 %677, label %678, label %690

678:                                              ; preds = %668
  %679 = load ptr, ptr %30, 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 !26
  %682 = load ptr, ptr %27, align 8, !tbaa !5
  %683 = icmp eq ptr %681, %682
  br i1 %683, label %684, label %690

684:                                              ; preds = %678
  %685 = load ptr, ptr %29, align 8, !tbaa !5
  %686 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %685, i32 0, i32 2
  %687 = load ptr, ptr %686, align 8, !tbaa !27
  %688 = load ptr, ptr %27, align 8, !tbaa !5
  %689 = icmp eq ptr %687, %688
  br label %690

690:                                              ; preds = %684, %678, %668
  %691 = phi i1 [ false, %678 ], [ false, %668 ], [ %689, %684 ]
  %692 = zext i1 %691 to i32
  %693 = sext i32 %692 to i64
  %694 = call i64 @llvm.expect.i64(i64 %693, i64 1)
  %695 = icmp ne i64 %694, 0
  br i1 %695, label %696, label %703

696:                                              ; preds = %690
  %697 = load ptr, ptr %29, align 8, !tbaa !5
  %698 = load ptr, ptr %30, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %698, i32 0, i32 3
  store ptr %697, ptr %699, align 8, !tbaa !26
  %700 = load ptr, ptr %30, align 8, !tbaa !5
  %701 = load ptr, ptr %29, align 8, !tbaa !5
  %702 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %701, i32 0, i32 2
  store ptr %700, ptr %702, align 8, !tbaa !27
  br label %704

703:                                              ; preds = %690
  call void @abort() #7
  unreachable

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

705:                                              ; preds = %658
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  %706 = load ptr, ptr %27, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %706, i32 0, i32 4
  %708 = getelementptr inbounds [2 x ptr], ptr %707, i64 0, i64 1
  store ptr %708, ptr %31, align 8, !tbaa !5
  %709 = load ptr, ptr %708, align 8, !tbaa !5
  store ptr %709, ptr %29, align 8, !tbaa !5
  %710 = icmp ne ptr %709, null
  br i1 %710, label %717, label %711

711:                                              ; preds = %705
  %712 = load ptr, ptr %27, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %712, i32 0, i32 4
  %714 = getelementptr inbounds [2 x ptr], ptr %713, i64 0, i64 0
  store ptr %714, ptr %31, align 8, !tbaa !5
  %715 = load ptr, ptr %714, align 8, !tbaa !5
  store ptr %715, ptr %29, align 8, !tbaa !5
  %716 = icmp ne ptr %715, null
  br i1 %716, label %717, label %747

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

718:                                              ; preds = %732, %717
  %719 = load ptr, ptr %29, 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 1
  store ptr %721, ptr %32, align 8, !tbaa !5
  %722 = load ptr, ptr %721, align 8, !tbaa !5
  %723 = icmp ne ptr %722, null
  br i1 %723, label %730, label %724

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

730:                                              ; preds = %724, %718
  %731 = phi i1 [ true, %718 ], [ %729, %724 ]
  br i1 %731, label %732, label %735

732:                                              ; preds = %730
  %733 = load ptr, ptr %32, align 8, !tbaa !5
  store ptr %733, ptr %31, align 8, !tbaa !5
  %734 = load ptr, ptr %733, align 8, !tbaa !5
  store ptr %734, ptr %29, align 8, !tbaa !5
  br label %718, !llvm.loop !36

735:                                              ; preds = %730
  %736 = load ptr, ptr %31, align 8, !tbaa !5
  %737 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %738 = icmp uge ptr %736, %737
  %739 = zext i1 %738 to i32
  %740 = sext i32 %739 to i64
  %741 = call i64 @llvm.expect.i64(i64 %740, i64 1)
  %742 = icmp ne i64 %741, 0
  br i1 %742, label %743, label %745

743:                                              ; preds = %735
  %744 = load ptr, ptr %31, align 8, !tbaa !5
  store ptr null, ptr %744, align 8, !tbaa !5
  br label %746

745:                                              ; preds = %735
  call void @abort() #7
  unreachable

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

747:                                              ; preds = %746, %711
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  br label %748

748:                                              ; preds = %747, %704
  %749 = load ptr, ptr %28, align 8, !tbaa !5
  %750 = icmp ne ptr %749, null
  br i1 %750, label %751, label %868

751:                                              ; preds = %748
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %752 = load ptr, ptr %27, align 8, !tbaa !5
  %753 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %752, i32 0, i32 6
  %754 = load i32, ptr %753, align 8, !tbaa !30
  %755 = zext i32 %754 to i64
  %756 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %755
  store ptr %756, ptr %33, align 8, !tbaa !5
  %757 = load ptr, ptr %27, align 8, !tbaa !5
  %758 = load ptr, ptr %33, align 8, !tbaa !5
  %759 = load ptr, ptr %758, align 8, !tbaa !5
  %760 = icmp eq ptr %757, %759
  br i1 %760, label %761, label %774

761:                                              ; preds = %751
  %762 = load ptr, ptr %29, align 8, !tbaa !5
  %763 = load ptr, ptr %33, align 8, !tbaa !5
  store ptr %762, ptr %763, align 8, !tbaa !5
  %764 = icmp eq ptr %762, null
  br i1 %764, label %765, label %773

765:                                              ; preds = %761
  %766 = load ptr, ptr %27, align 8, !tbaa !5
  %767 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %766, i32 0, i32 6
  %768 = load i32, ptr %767, align 8, !tbaa !30
  %769 = shl i32 1, %768
  %770 = xor i32 %769, -1
  %771 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %772 = and i32 %771, %770
  store i32 %772, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  br label %773

773:                                              ; preds = %765, %761
  br label %802

774:                                              ; preds = %751
  %775 = load ptr, ptr %28, align 8, !tbaa !5
  %776 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %777 = icmp uge ptr %775, %776
  %778 = zext i1 %777 to i32
  %779 = sext i32 %778 to i64
  %780 = call i64 @llvm.expect.i64(i64 %779, i64 1)
  %781 = icmp ne i64 %780, 0
  br i1 %781, label %782, label %800

782:                                              ; preds = %774
  %783 = load ptr, ptr %28, align 8, !tbaa !5
  %784 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %783, i32 0, i32 4
  %785 = getelementptr inbounds [2 x ptr], ptr %784, i64 0, i64 0
  %786 = load ptr, ptr %785, align 8, !tbaa !5
  %787 = load ptr, ptr %27, align 8, !tbaa !5
  %788 = icmp eq ptr %786, %787
  br i1 %788, label %789, label %794

789:                                              ; preds = %782
  %790 = load ptr, ptr %29, align 8, !tbaa !5
  %791 = load ptr, ptr %28, align 8, !tbaa !5
  %792 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %791, i32 0, i32 4
  %793 = getelementptr inbounds [2 x ptr], ptr %792, i64 0, i64 0
  store ptr %790, ptr %793, align 8, !tbaa !5
  br label %799

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

799:                                              ; preds = %794, %789
  br label %801

800:                                              ; preds = %774
  call void @abort() #7
  unreachable

801:                                              ; preds = %799
  br label %802

802:                                              ; preds = %801, %773
  %803 = load ptr, ptr %29, align 8, !tbaa !5
  %804 = icmp ne ptr %803, null
  br i1 %804, label %805, label %867

805:                                              ; preds = %802
  %806 = load ptr, ptr %29, align 8, !tbaa !5
  %807 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %808 = icmp uge ptr %806, %807
  %809 = zext i1 %808 to i32
  %810 = sext i32 %809 to i64
  %811 = call i64 @llvm.expect.i64(i64 %810, i64 1)
  %812 = icmp ne i64 %811, 0
  br i1 %812, label %813, label %865

813:                                              ; preds = %805
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  %814 = load ptr, ptr %28, align 8, !tbaa !5
  %815 = load ptr, ptr %29, align 8, !tbaa !5
  %816 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %815, i32 0, i32 5
  store ptr %814, ptr %816, align 8, !tbaa !24
  %817 = load ptr, ptr %27, align 8, !tbaa !5
  %818 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %817, i32 0, i32 4
  %819 = getelementptr inbounds [2 x ptr], ptr %818, i64 0, i64 0
  %820 = load ptr, ptr %819, align 8, !tbaa !5
  store ptr %820, ptr %34, align 8, !tbaa !5
  %821 = icmp ne ptr %820, null
  br i1 %821, label %822, label %840

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

830:                                              ; preds = %822
  %831 = load ptr, ptr %34, align 8, !tbaa !5
  %832 = load ptr, ptr %29, align 8, !tbaa !5
  %833 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %832, i32 0, i32 4
  %834 = getelementptr inbounds [2 x ptr], ptr %833, i64 0, i64 0
  store ptr %831, ptr %834, align 8, !tbaa !5
  %835 = load ptr, ptr %29, align 8, !tbaa !5
  %836 = load ptr, ptr %34, align 8, !tbaa !5
  %837 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %836, i32 0, i32 5
  store ptr %835, ptr %837, align 8, !tbaa !24
  br label %839

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

839:                                              ; preds = %830
  br label %840

840:                                              ; preds = %839, %813
  %841 = load ptr, ptr %27, align 8, !tbaa !5
  %842 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %841, i32 0, i32 4
  %843 = getelementptr inbounds [2 x ptr], ptr %842, i64 0, i64 1
  %844 = load ptr, ptr %843, align 8, !tbaa !5
  store ptr %844, ptr %35, align 8, !tbaa !5
  %845 = icmp ne ptr %844, null
  br i1 %845, label %846, label %864

846:                                              ; preds = %840
  %847 = load ptr, ptr %35, align 8, !tbaa !5
  %848 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %849 = icmp uge ptr %847, %848
  %850 = zext i1 %849 to i32
  %851 = sext i32 %850 to i64
  %852 = call i64 @llvm.expect.i64(i64 %851, i64 1)
  %853 = icmp ne i64 %852, 0
  br i1 %853, label %854, label %862

854:                                              ; preds = %846
  %855 = load ptr, ptr %35, align 8, !tbaa !5
  %856 = load ptr, ptr %29, align 8, !tbaa !5
  %857 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %856, i32 0, i32 4
  %858 = getelementptr inbounds [2 x ptr], ptr %857, i64 0, i64 1
  store ptr %855, ptr %858, align 8, !tbaa !5
  %859 = load ptr, ptr %29, align 8, !tbaa !5
  %860 = load ptr, ptr %35, align 8, !tbaa !5
  %861 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %860, i32 0, i32 5
  store ptr %859, ptr %861, align 8, !tbaa !24
  br label %863

862:                                              ; preds = %846
  call void @abort() #7
  unreachable

863:                                              ; preds = %854
  br label %864

864:                                              ; preds = %863, %840
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  br label %866

865:                                              ; preds = %805
  call void @abort() #7
  unreachable

866:                                              ; preds = %864
  br label %867

867:                                              ; preds = %866, %802
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  br label %868

868:                                              ; preds = %867, %748
  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 %869

869:                                              ; preds = %868, %657
  %870 = load i64, ptr %4, align 8, !tbaa !16
  %871 = or i64 %870, 1
  %872 = load ptr, ptr %3, align 8, !tbaa !5
  %873 = getelementptr inbounds %struct.malloc_chunk, ptr %872, i32 0, i32 1
  store i64 %871, ptr %873, align 8, !tbaa !14
  %874 = load i64, ptr %4, align 8, !tbaa !16
  %875 = load ptr, ptr %3, align 8, !tbaa !5
  %876 = load i64, ptr %4, align 8, !tbaa !16
  %877 = getelementptr inbounds i8, ptr %875, i64 %876
  %878 = getelementptr inbounds %struct.malloc_chunk, ptr %877, i32 0, i32 0
  store i64 %874, ptr %878, align 8, !tbaa !17
  %879 = load ptr, ptr %3, align 8, !tbaa !5
  %880 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %881 = icmp eq ptr %879, %880
  br i1 %881, label %882, label %884

882:                                              ; preds = %869
  %883 = load i64, ptr %4, align 8, !tbaa !16
  store i64 %883, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  store i32 2, ptr %20, align 4
  br label %885

884:                                              ; preds = %869
  store i32 0, ptr %20, align 4
  br label %885

885:                                              ; preds = %884, %882
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  %886 = load i32, ptr %20, align 4
  switch i32 %886, label %1128 [
    i32 0, label %887
  ]

887:                                              ; preds = %885
  br label %888

888:                                              ; preds = %887
  br label %889

889:                                              ; preds = %888
  br label %904

890:                                              ; preds = %495
  %891 = load ptr, ptr %5, align 8, !tbaa !5
  %892 = getelementptr inbounds %struct.malloc_chunk, ptr %891, i32 0, i32 1
  %893 = load i64, ptr %892, align 8, !tbaa !14
  %894 = and i64 %893, -2
  store i64 %894, ptr %892, align 8, !tbaa !14
  %895 = load i64, ptr %4, align 8, !tbaa !16
  %896 = or i64 %895, 1
  %897 = load ptr, ptr %3, align 8, !tbaa !5
  %898 = getelementptr inbounds %struct.malloc_chunk, ptr %897, i32 0, i32 1
  store i64 %896, ptr %898, align 8, !tbaa !14
  %899 = load i64, ptr %4, align 8, !tbaa !16
  %900 = load ptr, ptr %3, align 8, !tbaa !5
  %901 = load i64, ptr %4, align 8, !tbaa !16
  %902 = getelementptr inbounds i8, ptr %900, i64 %901
  %903 = getelementptr inbounds %struct.malloc_chunk, ptr %902, i32 0, i32 0
  store i64 %899, ptr %903, align 8, !tbaa !17
  br label %904

904:                                              ; preds = %890, %889
  %905 = load i64, ptr %4, align 8, !tbaa !16
  %906 = lshr i64 %905, 3
  %907 = icmp ult i64 %906, 32
  br i1 %907, label %908, label %961

908:                                              ; preds = %904
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %909 = load i64, ptr %4, align 8, !tbaa !16
  %910 = lshr i64 %909, 3
  %911 = trunc i64 %910 to i32
  store i32 %911, ptr %36, align 4, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %912 = load i32, ptr %36, align 4, !tbaa !22
  %913 = shl i32 %912, 1
  %914 = zext i32 %913 to i64
  %915 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %914
  store ptr %915, ptr %37, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %916 = load ptr, ptr %37, align 8, !tbaa !5
  store ptr %916, ptr %38, align 8, !tbaa !5
  %917 = load i64, ptr %4, align 8, !tbaa !16
  %918 = icmp uge i64 %917, 32
  br i1 %918, label %919, label %920

919:                                              ; preds = %908
  br label %921

920:                                              ; preds = %908
  call void @__assert_fail(ptr noundef @.str.12, ptr noundef @.str.1, i32 noundef 4762, ptr noundef @__PRETTY_FUNCTION__.free) #7
  unreachable

921:                                              ; preds = %919
  %922 = load i32, ptr @_gm_, align 8, !tbaa !23
  %923 = load i32, ptr %36, align 4, !tbaa !22
  %924 = shl i32 1, %923
  %925 = and i32 %922, %924
  %926 = icmp ne i32 %925, 0
  br i1 %926, label %932, label %927

927:                                              ; preds = %921
  %928 = load i32, ptr %36, align 4, !tbaa !22
  %929 = shl i32 1, %928
  %930 = load i32, ptr @_gm_, align 8, !tbaa !23
  %931 = or i32 %930, %929
  store i32 %931, ptr @_gm_, align 8, !tbaa !23
  br label %948

932:                                              ; preds = %921
  %933 = load ptr, ptr %37, align 8, !tbaa !5
  %934 = getelementptr inbounds %struct.malloc_chunk, ptr %933, i32 0, i32 2
  %935 = load ptr, ptr %934, align 8, !tbaa !20
  %936 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %937 = icmp uge ptr %935, %936
  %938 = zext i1 %937 to i32
  %939 = sext i32 %938 to i64
  %940 = call i64 @llvm.expect.i64(i64 %939, i64 1)
  %941 = icmp ne i64 %940, 0
  br i1 %941, label %942, label %946

942:                                              ; preds = %932
  %943 = load ptr, ptr %37, align 8, !tbaa !5
  %944 = getelementptr inbounds %struct.malloc_chunk, ptr %943, i32 0, i32 2
  %945 = load ptr, ptr %944, align 8, !tbaa !20
  store ptr %945, ptr %38, align 8, !tbaa !5
  br label %947

946:                                              ; preds = %932
  call void @abort() #7
  unreachable

947:                                              ; preds = %942
  br label %948

948:                                              ; preds = %947, %927
  %949 = load ptr, ptr %3, align 8, !tbaa !5
  %950 = load ptr, ptr %37, align 8, !tbaa !5
  %951 = getelementptr inbounds %struct.malloc_chunk, ptr %950, i32 0, i32 2
  store ptr %949, ptr %951, align 8, !tbaa !20
  %952 = load ptr, ptr %3, align 8, !tbaa !5
  %953 = load ptr, ptr %38, align 8, !tbaa !5
  %954 = getelementptr inbounds %struct.malloc_chunk, ptr %953, i32 0, i32 3
  store ptr %952, ptr %954, align 8, !tbaa !21
  %955 = load ptr, ptr %38, align 8, !tbaa !5
  %956 = load ptr, ptr %3, align 8, !tbaa !5
  %957 = getelementptr inbounds %struct.malloc_chunk, ptr %956, i32 0, i32 2
  store ptr %955, ptr %957, align 8, !tbaa !20
  %958 = load ptr, ptr %37, align 8, !tbaa !5
  %959 = load ptr, ptr %3, align 8, !tbaa !5
  %960 = getelementptr inbounds %struct.malloc_chunk, ptr %959, i32 0, i32 3
  store ptr %958, ptr %960, align 8, !tbaa !21
  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
  br label %1126

961:                                              ; preds = %904
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  %962 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %962, 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
  %963 = load i64, ptr %4, align 8, !tbaa !16
  %964 = lshr i64 %963, 8
  %965 = trunc i64 %964 to i32
  store i32 %965, ptr %42, align 4, !tbaa !22
  %966 = load i32, ptr %42, align 4, !tbaa !22
  %967 = icmp eq i32 %966, 0
  br i1 %967, label %968, label %969

968:                                              ; preds = %961
  store i32 0, ptr %41, align 4, !tbaa !22
  br label %989

969:                                              ; preds = %961
  %970 = load i32, ptr %42, align 4, !tbaa !22
  %971 = icmp ugt i32 %970, 65535
  br i1 %971, label %972, label %973

972:                                              ; preds = %969
  store i32 31, ptr %41, align 4, !tbaa !22
  br label %988

973:                                              ; preds = %969
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %974 = load i32, ptr %42, align 4, !tbaa !22
  %975 = call i32 @llvm.ctlz.i32(i32 %974, i1 true)
  %976 = sub i32 31, %975
  store i32 %976, ptr %43, align 4, !tbaa !22
  %977 = load i32, ptr %43, align 4, !tbaa !22
  %978 = shl i32 %977, 1
  %979 = zext i32 %978 to i64
  %980 = load i64, ptr %4, align 8, !tbaa !16
  %981 = load i32, ptr %43, align 4, !tbaa !22
  %982 = add i32 %981, 7
  %983 = zext i32 %982 to i64
  %984 = lshr i64 %980, %983
  %985 = and i64 %984, 1
  %986 = add i64 %979, %985
  %987 = trunc i64 %986 to i32
  store i32 %987, ptr %41, align 4, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  br label %988

988:                                              ; preds = %973, %972
  br label %989

989:                                              ; preds = %988, %968
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  %990 = load i32, ptr %41, align 4, !tbaa !22
  %991 = zext i32 %990 to i64
  %992 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %991
  store ptr %992, ptr %40, align 8, !tbaa !5
  %993 = load i32, ptr %41, align 4, !tbaa !22
  %994 = load ptr, ptr %39, align 8, !tbaa !5
  %995 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %994, i32 0, i32 6
  store i32 %993, ptr %995, align 8, !tbaa !30
  %996 = load ptr, ptr %39, align 8, !tbaa !5
  %997 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %996, i32 0, i32 4
  %998 = getelementptr inbounds [2 x ptr], ptr %997, i64 0, i64 1
  store ptr null, ptr %998, align 8, !tbaa !5
  %999 = load ptr, ptr %39, align 8, !tbaa !5
  %1000 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %999, i32 0, i32 4
  %1001 = getelementptr inbounds [2 x ptr], ptr %1000, i64 0, i64 0
  store ptr null, ptr %1001, align 8, !tbaa !5
  %1002 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %1003 = load i32, ptr %41, align 4, !tbaa !22
  %1004 = shl i32 1, %1003
  %1005 = and i32 %1002, %1004
  %1006 = icmp ne i32 %1005, 0
  br i1 %1006, label %1022, label %1007

1007:                                             ; preds = %989
  %1008 = load i32, ptr %41, align 4, !tbaa !22
  %1009 = shl i32 1, %1008
  %1010 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %1011 = or i32 %1010, %1009
  store i32 %1011, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %1012 = load ptr, ptr %39, align 8, !tbaa !5
  %1013 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %1012, ptr %1013, align 8, !tbaa !5
  %1014 = load ptr, ptr %40, align 8, !tbaa !5
  %1015 = load ptr, ptr %39, align 8, !tbaa !5
  %1016 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1015, i32 0, i32 5
  store ptr %1014, ptr %1016, align 8, !tbaa !24
  %1017 = load ptr, ptr %39, align 8, !tbaa !5
  %1018 = load ptr, ptr %39, align 8, !tbaa !5
  %1019 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1018, i32 0, i32 3
  store ptr %1017, ptr %1019, align 8, !tbaa !26
  %1020 = load ptr, ptr %39, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1020, i32 0, i32 2
  store ptr %1017, ptr %1021, align 8, !tbaa !27
  br label %1119

1022:                                             ; preds = %989
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #6
  %1023 = load ptr, ptr %40, align 8, !tbaa !5
  %1024 = load ptr, ptr %1023, align 8, !tbaa !5
  store ptr %1024, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  %1025 = load i64, ptr %4, align 8, !tbaa !16
  %1026 = load i32, ptr %41, align 4, !tbaa !22
  %1027 = icmp eq i32 %1026, 31
  br i1 %1027, label %1028, label %1029

1028:                                             ; preds = %1022
  br label %1036

1029:                                             ; preds = %1022
  %1030 = load i32, ptr %41, align 4, !tbaa !22
  %1031 = lshr i32 %1030, 1
  %1032 = add i32 %1031, 8
  %1033 = sub i32 %1032, 2
  %1034 = zext i32 %1033 to i64
  %1035 = sub i64 63, %1034
  br label %1036

1036:                                             ; preds = %1029, %1028
  %1037 = phi i64 [ 0, %1028 ], [ %1035, %1029 ]
  %1038 = shl i64 %1025, %1037
  store i64 %1038, ptr %45, align 8, !tbaa !16
  br label %1039

1039:                                             ; preds = %1117, %1036
  %1040 = load ptr, ptr %44, align 8, !tbaa !5
  %1041 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1040, i32 0, i32 1
  %1042 = load i64, ptr %1041, align 8, !tbaa !37
  %1043 = and i64 %1042, -8
  %1044 = load i64, ptr %4, align 8, !tbaa !16
  %1045 = icmp ne i64 %1043, %1044
  br i1 %1045, label %1046, label %1085

1046:                                             ; preds = %1039
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  %1047 = load ptr, ptr %44, align 8, !tbaa !5
  %1048 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1047, i32 0, i32 4
  %1049 = load i64, ptr %45, align 8, !tbaa !16
  %1050 = lshr i64 %1049, 63
  %1051 = and i64 %1050, 1
  %1052 = getelementptr inbounds [2 x ptr], ptr %1048, i64 0, i64 %1051
  store ptr %1052, ptr %46, align 8, !tbaa !5
  %1053 = load i64, ptr %45, align 8, !tbaa !16
  %1054 = shl i64 %1053, 1
  store i64 %1054, ptr %45, align 8, !tbaa !16
  %1055 = load ptr, ptr %46, align 8, !tbaa !5
  %1056 = load ptr, ptr %1055, align 8, !tbaa !5
  %1057 = icmp ne ptr %1056, null
  br i1 %1057, label %1058, label %1061

1058:                                             ; preds = %1046
  %1059 = load ptr, ptr %46, align 8, !tbaa !5
  %1060 = load ptr, ptr %1059, align 8, !tbaa !5
  store ptr %1060, ptr %44, align 8, !tbaa !5
  br label %1081

1061:                                             ; preds = %1046
  %1062 = load ptr, ptr %46, align 8, !tbaa !5
  %1063 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1064 = icmp uge ptr %1062, %1063
  %1065 = zext i1 %1064 to i32
  %1066 = sext i32 %1065 to i64
  %1067 = call i64 @llvm.expect.i64(i64 %1066, i64 1)
  %1068 = icmp ne i64 %1067, 0
  br i1 %1068, label %1069, label %1080

1069:                                             ; preds = %1061
  %1070 = load ptr, ptr %39, align 8, !tbaa !5
  %1071 = load ptr, ptr %46, align 8, !tbaa !5
  store ptr %1070, ptr %1071, align 8, !tbaa !5
  %1072 = load ptr, ptr %44, align 8, !tbaa !5
  %1073 = load ptr, ptr %39, align 8, !tbaa !5
  %1074 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1073, i32 0, i32 5
  store ptr %1072, ptr %1074, align 8, !tbaa !24
  %1075 = load ptr, ptr %39, align 8, !tbaa !5
  %1076 = load ptr, ptr %39, align 8, !tbaa !5
  %1077 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1076, i32 0, i32 3
  store ptr %1075, ptr %1077, align 8, !tbaa !26
  %1078 = load ptr, ptr %39, align 8, !tbaa !5
  %1079 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1078, i32 0, i32 2
  store ptr %1075, ptr %1079, align 8, !tbaa !27
  store i32 8, ptr %20, align 4
  br label %1082

1080:                                             ; preds = %1061
  call void @abort() #7
  unreachable

1081:                                             ; preds = %1058
  store i32 0, ptr %20, align 4
  br label %1082

1082:                                             ; preds = %1081, %1069
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  %1083 = load i32, ptr %20, align 4
  switch i32 %1083, label %1135 [
    i32 0, label %1084
    i32 8, label %1118
  ]

1084:                                             ; preds = %1082
  br label %1117

1085:                                             ; preds = %1039
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  %1086 = load ptr, ptr %44, align 8, !tbaa !5
  %1087 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1086, i32 0, i32 2
  %1088 = load ptr, ptr %1087, align 8, !tbaa !27
  store ptr %1088, ptr %47, align 8, !tbaa !5
  %1089 = load ptr, ptr %44, align 8, !tbaa !5
  %1090 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1091 = icmp uge ptr %1089, %1090
  br i1 %1091, label %1092, label %1096

1092:                                             ; preds = %1085
  %1093 = load ptr, ptr %47, align 8, !tbaa !5
  %1094 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1095 = icmp uge ptr %1093, %1094
  br label %1096

1096:                                             ; preds = %1092, %1085
  %1097 = phi i1 [ false, %1085 ], [ %1095, %1092 ]
  %1098 = zext i1 %1097 to i32
  %1099 = sext i32 %1098 to i64
  %1100 = call i64 @llvm.expect.i64(i64 %1099, i64 1)
  %1101 = icmp ne i64 %1100, 0
  br i1 %1101, label %1102, label %1116

1102:                                             ; preds = %1096
  %1103 = load ptr, ptr %39, align 8, !tbaa !5
  %1104 = load ptr, ptr %47, align 8, !tbaa !5
  %1105 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1104, i32 0, i32 3
  store ptr %1103, ptr %1105, align 8, !tbaa !26
  %1106 = load ptr, ptr %44, align 8, !tbaa !5
  %1107 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1106, i32 0, i32 2
  store ptr %1103, ptr %1107, align 8, !tbaa !27
  %1108 = load ptr, ptr %47, align 8, !tbaa !5
  %1109 = load ptr, ptr %39, align 8, !tbaa !5
  %1110 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1109, i32 0, i32 2
  store ptr %1108, ptr %1110, align 8, !tbaa !27
  %1111 = load ptr, ptr %44, align 8, !tbaa !5
  %1112 = load ptr, ptr %39, align 8, !tbaa !5
  %1113 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1112, i32 0, i32 3
  store ptr %1111, ptr %1113, align 8, !tbaa !26
  %1114 = load ptr, ptr %39, align 8, !tbaa !5
  %1115 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1114, i32 0, i32 5
  store ptr null, ptr %1115, align 8, !tbaa !24
  store i32 8, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  br label %1118

1116:                                             ; preds = %1096
  call void @abort() #7
  unreachable

1117:                                             ; preds = %1084
  br label %1039

1118:                                             ; preds = %1102, %1082
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  br label %1119

1119:                                             ; preds = %1118, %1007
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  %1120 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !38
  %1121 = add i64 %1120, -1
  store i64 %1121, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !38
  %1122 = icmp eq i64 %1121, 0
  br i1 %1122, label %1123, label %1125

1123:                                             ; preds = %1119
  %1124 = call i64 @release_unused_segments(ptr noundef @_gm_)
  br label %1125

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

1126:                                             ; preds = %1125, %948
  store i32 2, ptr %20, align 4
  br label %1128

1127:                                             ; preds = %489
  store i32 0, ptr %20, align 4
  br label %1128

1128:                                             ; preds = %1127, %1126, %885, %529, %524, %476
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #6
  %1129 = load i32, ptr %20, align 4
  switch i32 %1129, label %1135 [
    i32 0, label %1130
    i32 5, label %1132
    i32 2, label %1133
  ]

1130:                                             ; preds = %1128
  br label %1131

1131:                                             ; preds = %1130, %62
  br label %1132

1132:                                             ; preds = %1131, %1128
  call void @abort() #7
  unreachable

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

1134:                                             ; preds = %1133, %1
  ret void

1135:                                             ; preds = %1128, %1082
  unreachable
}

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

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

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

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #3 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { 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, !6, i64 24}
!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, !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 = !{!15, !12, i64 8}
!15 = !{!"malloc_chunk", !12, i64 0, !12, i64 8, !6, i64 16, !6, i64 24}
!16 = !{!12, !12, i64 0}
!17 = !{!15, !12, i64 0}
!18 = !{!10, !12, i64 856}
!19 = !{!10, !6, i64 32}
!20 = !{!15, !6, i64 16}
!21 = !{!15, !6, i64 24}
!22 = !{!11, !11, i64 0}
!23 = !{!10, !11, i64 0}
!24 = !{!25, !6, i64 48}
!25 = !{!"malloc_tree_chunk", !12, i64 0, !12, i64 8, !6, i64 16, !6, i64 24, !7, i64 32, !6, i64 48, !11, i64 56}
!26 = !{!25, !6, i64 24}
!27 = !{!25, !6, i64 16}
!28 = distinct !{!28, !29}
!29 = !{!"llvm.loop.mustprogress"}
!30 = !{!25, !11, i64 56}
!31 = !{!10, !11, i64 4}
!32 = !{!10, !12, i64 8}
!33 = !{!10, !6, i64 40}
!34 = !{!10, !12, i64 16}
!35 = !{!10, !12, i64 48}
!36 = distinct !{!36, !29}
!37 = !{!25, !12, i64 8}
!38 = !{!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, %struct.malloc_segment, ptr, i64 }
%struct.malloc_segment = type { ptr, i64, ptr, i32 }

@_gm_ = external hidden global %struct.malloc_state, align 8
@.str.1 = external hidden unnamed_addr constant [100 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [7 x i8], align 1
@__PRETTY_FUNCTION__.free = external hidden unnamed_addr constant [18 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [10 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #0

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

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

2:                                                ; preds = %1
  %3 = getelementptr inbounds i8, ptr %0, i64 -16
  %4 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not359 = icmp ult ptr %3, %4
  br i1 %.not359, label %.critedge410, label %5, !prof !13

5:                                                ; preds = %2
  %6 = getelementptr inbounds i8, ptr %0, i64 -8
  %7 = load i64, ptr %6, align 8, !tbaa !14
  %8 = and i64 %7, 3
  %.not449 = icmp eq i64 %8, 1
  br i1 %.not449, label %.critedge410, label %9, !prof !13

9:                                                ; preds = %5
  %10 = and i64 %7, -8
  %11 = getelementptr inbounds i8, ptr %3, i64 %10
  %12 = and i64 %7, 1
  %.not360 = icmp eq i64 %12, 0
  br i1 %.not360, label %13, label %.thread

13:                                               ; preds = %9
  %14 = load i64, ptr %3, align 8, !tbaa !16
  %15 = and i64 %7, 2
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %17, label %27

17:                                               ; preds = %13
  %18 = add i64 %10, 32
  %19 = add i64 %18, %14
  %20 = sub i64 0, %14
  %21 = getelementptr inbounds i8, ptr %3, i64 %20
  %22 = tail call i32 @munmap(ptr noundef nonnull %21, i64 noundef %19) #5
  %23 = icmp eq i32 %22, 0
  br i1 %23, label %24, label %.critedge422.thread

24:                                               ; preds = %17
  %25 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 856), align 8, !tbaa !17
  %26 = sub i64 %25, %19
  store i64 %26, ptr getelementptr inbounds (i8, ptr @_gm_, i64 856), align 8, !tbaa !17
  br label %.critedge422.thread

27:                                               ; preds = %13
  %28 = sub i64 0, %14
  %29 = getelementptr inbounds i8, ptr %3, i64 %28
  %30 = add i64 %14, %10
  %.not361 = icmp ult ptr %29, %4
  br i1 %.not361, label %.critedge410, label %31, !prof !13

31:                                               ; preds = %27
  %32 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %.not362 = icmp eq ptr %29, %32
  br i1 %.not362, label %148, label %33

33:                                               ; preds = %31
  %34 = icmp ult i64 %14, 256
  br i1 %34, label %35, label %76

35:                                               ; preds = %33
  %36 = lshr i64 %14, 3
  %37 = getelementptr inbounds i8, ptr %29, i64 16
  %38 = load ptr, ptr %37, align 8, !tbaa !19
  %39 = getelementptr inbounds i8, ptr %29, i64 24
  %40 = load ptr, ptr %39, align 8, !tbaa !20
  %41 = trunc nuw nsw i64 %36 to i32
  %.not378 = icmp eq ptr %29, %40
  br i1 %.not378, label %42, label %43

42:                                               ; preds = %35
  tail call void @__assert_fail(ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.1, i32 noundef 4714, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

43:                                               ; preds = %35
  %.not379 = icmp eq ptr %29, %38
  br i1 %.not379, label %44, label %45

44:                                               ; preds = %43
  tail call void @__assert_fail(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.1, i32 noundef 4714, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

45:                                               ; preds = %43
  %46 = getelementptr inbounds i8, ptr %29, i64 8
  %47 = load i64, ptr %46, align 8, !tbaa !14
  %48 = and i64 %47, -8
  %49 = and i64 %14, 248
  %50 = icmp eq i64 %48, %49
  br i1 %50, label %52, label %51

51:                                               ; preds = %45
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 4714, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

52:                                               ; preds = %45
  %53 = shl nuw nsw i64 %36, 1
  %54 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %53
  %55 = icmp eq ptr %38, %54
  br i1 %55, label %.critedge412, label %56

56:                                               ; preds = %52
  %.not380 = icmp ult ptr %38, %4
  br i1 %.not380, label %.critedge414, label %57

57:                                               ; preds = %56
  %58 = getelementptr inbounds i8, ptr %38, i64 24
  %59 = load ptr, ptr %58, align 8, !tbaa !20
  %60 = icmp eq ptr %59, %29
  br i1 %60, label %.critedge412, label %.critedge414, !prof !21

.critedge412:                                     ; preds = %52, %57
  %61 = icmp eq ptr %40, %38
  br i1 %61, label %62, label %67

62:                                               ; preds = %.critedge412
  %63 = shl nuw i32 1, %41
  %64 = xor i32 %63, -1
  %65 = load i32, ptr @_gm_, align 8, !tbaa !22
  %66 = and i32 %65, %64
  store i32 %66, ptr @_gm_, align 8, !tbaa !22
  br label %.thread

67:                                               ; preds = %.critedge412
  %68 = icmp eq ptr %40, %54
  br i1 %68, label %.critedge416, label %69

69:                                               ; preds = %67
  %.not381 = icmp ult ptr %40, %4
  br i1 %.not381, label %.critedge418, label %70

70:                                               ; preds = %69
  %71 = getelementptr inbounds i8, ptr %40, i64 16
  %72 = load ptr, ptr %71, align 8, !tbaa !19
  %73 = icmp eq ptr %72, %29
  br i1 %73, label %.critedge416, label %.critedge418, !prof !21

.critedge416:                                     ; preds = %67, %70
  %74 = getelementptr inbounds i8, ptr %38, i64 24
  store ptr %40, ptr %74, align 8, !tbaa !20
  %75 = getelementptr inbounds i8, ptr %40, i64 16
  store ptr %38, ptr %75, align 8, !tbaa !19
  br label %.thread

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

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

76:                                               ; preds = %33
  %77 = getelementptr inbounds i8, ptr %29, i64 48
  %78 = load ptr, ptr %77, align 8, !tbaa !23
  %79 = getelementptr inbounds i8, ptr %29, i64 24
  %80 = load ptr, ptr %79, align 8, !tbaa !25
  %.not363 = icmp eq ptr %80, %29
  br i1 %.not363, label %93, label %81

81:                                               ; preds = %76
  %82 = getelementptr inbounds i8, ptr %29, i64 16
  %83 = load ptr, ptr %82, align 8, !tbaa !26
  %.not369 = icmp ult ptr %83, %4
  br i1 %.not369, label %.critedge420, label %84, !prof !13

84:                                               ; preds = %81
  %85 = getelementptr inbounds i8, ptr %83, i64 24
  %86 = load ptr, ptr %85, align 8, !tbaa !25
  %87 = icmp eq ptr %86, %29
  br i1 %87, label %88, label %.critedge420, !prof !21

88:                                               ; preds = %84
  %89 = getelementptr inbounds i8, ptr %80, i64 16
  %90 = load ptr, ptr %89, align 8, !tbaa !26
  %91 = icmp eq ptr %90, %29
  br i1 %91, label %92, label %.critedge420, !prof !21

92:                                               ; preds = %88
  store ptr %80, ptr %85, align 8, !tbaa !25
  store ptr %83, ptr %89, align 8, !tbaa !26
  br label %107

.critedge420:                                     ; preds = %84, %81, %88
  tail call void @abort() #6
  unreachable

93:                                               ; preds = %76
  %94 = getelementptr inbounds i8, ptr %29, i64 40
  %95 = load ptr, ptr %94, align 8, !tbaa !27
  %.not364 = icmp eq ptr %95, null
  br i1 %.not364, label %96, label %.critedge.preheader

96:                                               ; preds = %93
  %97 = getelementptr inbounds i8, ptr %29, i64 32
  %98 = load ptr, ptr %97, align 8, !tbaa !27
  %.not365 = icmp eq ptr %98, null
  br i1 %.not365, label %107, label %.critedge.preheader

.critedge.preheader:                              ; preds = %96, %93
  %.1310.ph = phi ptr [ %97, %96 ], [ %94, %93 ]
  %.1307.ph = phi ptr [ %98, %96 ], [ %95, %93 ]
  br label %.critedge

.critedge:                                        ; preds = %.critedge.backedge, %.critedge.preheader
  %.1310 = phi ptr [ %.1310.ph, %.critedge.preheader ], [ %.1310.be, %.critedge.backedge ]
  %.1307 = phi ptr [ %.1307.ph, %.critedge.preheader ], [ %.1307.be, %.critedge.backedge ]
  %99 = getelementptr inbounds i8, ptr %.1307, i64 40
  %100 = load ptr, ptr %99, align 8, !tbaa !27
  %.not366 = icmp eq ptr %100, null
  br i1 %.not366, label %101, label %.critedge.backedge

.critedge.backedge:                               ; preds = %.critedge, %101
  %.1310.be = phi ptr [ %99, %.critedge ], [ %102, %101 ]
  %.1307.be = phi ptr [ %100, %.critedge ], [ %103, %101 ]
  br label %.critedge, !llvm.loop !28

101:                                              ; preds = %.critedge
  %102 = getelementptr inbounds i8, ptr %.1307, i64 32
  %103 = load ptr, ptr %102, align 8, !tbaa !27
  %.not367 = icmp eq ptr %103, null
  br i1 %.not367, label %104, label %.critedge.backedge

104:                                              ; preds = %101
  %.not368 = icmp ult ptr %.1310, %4
  br i1 %.not368, label %106, label %105, !prof !13

105:                                              ; preds = %104
  store ptr null, ptr %.1310, align 8, !tbaa !27
  br label %107

106:                                              ; preds = %104
  tail call void @abort() #6
  unreachable

107:                                              ; preds = %96, %105, %92
  %.3 = phi ptr [ %80, %92 ], [ %.1307, %105 ], [ null, %96 ]
  %.not370 = icmp eq ptr %78, null
  br i1 %.not370, label %.thread, label %108

108:                                              ; preds = %107
  %109 = getelementptr inbounds i8, ptr %29, i64 56
  %110 = load i32, ptr %109, align 8, !tbaa !30
  %111 = zext i32 %110 to i64
  %112 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %111
  %113 = load ptr, ptr %112, align 8, !tbaa !27
  %114 = icmp eq ptr %29, %113
  br i1 %114, label %115, label %120

115:                                              ; preds = %108
  store ptr %.3, ptr %112, align 8, !tbaa !27
  %cond = icmp eq ptr %.3, null
  br i1 %cond, label %.thread456, label %128

.thread456:                                       ; preds = %115
  %116 = shl nuw i32 1, %110
  %117 = xor i32 %116, -1
  %118 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %119 = and i32 %118, %117
  store i32 %119, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %.thread

120:                                              ; preds = %108
  %121 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not371 = icmp ult ptr %78, %121
  br i1 %.not371, label %127, label %122, !prof !13

122:                                              ; preds = %120
  %123 = getelementptr inbounds i8, ptr %78, i64 32
  %124 = load ptr, ptr %123, align 8, !tbaa !27
  %125 = icmp eq ptr %124, %29
  %126 = getelementptr inbounds i8, ptr %78, i64 40
  %.sink = select i1 %125, ptr %123, ptr %126
  store ptr %.3, ptr %.sink, align 8, !tbaa !27
  %.not372 = icmp eq ptr %.3, null
  br i1 %.not372, label %.thread, label %128

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

128:                                              ; preds = %115, %122
  %129 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not373 = icmp ult ptr %.3, %129
  br i1 %.not373, label %147, label %130, !prof !13

130:                                              ; preds = %128
  %131 = getelementptr inbounds i8, ptr %.3, i64 48
  store ptr %78, ptr %131, align 8, !tbaa !23
  %132 = getelementptr inbounds i8, ptr %29, i64 32
  %133 = load ptr, ptr %132, align 8, !tbaa !27
  %.not374 = icmp eq ptr %133, null
  br i1 %.not374, label %139, label %134

134:                                              ; preds = %130
  %.not375 = icmp ult ptr %133, %129
  br i1 %.not375, label %138, label %135, !prof !13

135:                                              ; preds = %134
  %136 = getelementptr inbounds i8, ptr %.3, i64 32
  store ptr %133, ptr %136, align 8, !tbaa !27
  %137 = getelementptr inbounds i8, ptr %133, i64 48
  store ptr %.3, ptr %137, align 8, !tbaa !23
  br label %139

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

139:                                              ; preds = %135, %130
  %140 = getelementptr inbounds i8, ptr %29, i64 40
  %141 = load ptr, ptr %140, align 8, !tbaa !27
  %.not376 = icmp eq ptr %141, null
  br i1 %.not376, label %.thread, label %142

142:                                              ; preds = %139
  %.not377 = icmp ult ptr %141, %129
  br i1 %.not377, label %146, label %143, !prof !13

143:                                              ; preds = %142
  %144 = getelementptr inbounds i8, ptr %.3, i64 40
  store ptr %141, ptr %144, align 8, !tbaa !27
  %145 = getelementptr inbounds i8, ptr %141, i64 48
  store ptr %.3, ptr %145, align 8, !tbaa !23
  br label %.thread

146:                                              ; preds = %142
  tail call void @abort() #6
  unreachable

147:                                              ; preds = %128
  tail call void @abort() #6
  unreachable

148:                                              ; preds = %31
  %149 = getelementptr inbounds i8, ptr %11, i64 8
  %150 = load i64, ptr %149, align 8, !tbaa !14
  %151 = and i64 %150, 3
  %152 = icmp eq i64 %151, 3
  br i1 %152, label %153, label %.thread

153:                                              ; preds = %148
  store i64 %30, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  %154 = and i64 %150, -2
  store i64 %154, ptr %149, align 8, !tbaa !14
  %155 = or i64 %30, 1
  %156 = getelementptr inbounds i8, ptr %29, i64 8
  store i64 %155, ptr %156, align 8, !tbaa !14
  store i64 %30, ptr %11, align 8, !tbaa !16
  br label %.critedge422.thread

.thread:                                          ; preds = %.thread456, %148, %62, %.critedge416, %122, %143, %139, %107, %9
  %.1302 = phi i64 [ %10, %9 ], [ %30, %107 ], [ %30, %139 ], [ %30, %143 ], [ %30, %122 ], [ %30, %.critedge416 ], [ %30, %62 ], [ %30, %148 ], [ %30, %.thread456 ]
  %.1 = phi ptr [ %3, %9 ], [ %29, %107 ], [ %29, %139 ], [ %29, %143 ], [ %29, %122 ], [ %29, %.critedge416 ], [ %29, %62 ], [ %29, %148 ], [ %29, %.thread456 ]
  %157 = icmp ult ptr %.1, %11
  br i1 %157, label %158, label %.critedge410, !prof !21

158:                                              ; preds = %.thread
  %159 = getelementptr inbounds i8, ptr %11, i64 8
  %160 = load i64, ptr %159, align 8, !tbaa !14
  %161 = and i64 %160, 1
  %.not450 = icmp eq i64 %161, 0
  br i1 %.not450, label %.critedge410, label %162, !prof !13

162:                                              ; preds = %158
  %163 = and i64 %160, 2
  %.not382 = icmp eq i64 %163, 0
  br i1 %.not382, label %164, label %308

164:                                              ; preds = %162
  %165 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 40), align 8, !tbaa !33
  %166 = icmp eq ptr %11, %165
  br i1 %166, label %167, label %180

167:                                              ; preds = %164
  %168 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 16), align 8, !tbaa !34
  %169 = add i64 %168, %.1302
  store i64 %169, ptr getelementptr inbounds (i8, ptr @_gm_, i64 16), align 8, !tbaa !34
  store ptr %.1, ptr getelementptr inbounds (i8, ptr @_gm_, i64 40), align 8, !tbaa !33
  %170 = or i64 %169, 1
  %171 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %170, ptr %171, align 8, !tbaa !14
  %172 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %173 = icmp eq ptr %.1, %172
  br i1 %173, label %174, label %175

174:                                              ; preds = %167
  store ptr null, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  store i64 0, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  br label %175

175:                                              ; preds = %174, %167
  %176 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 48), align 8, !tbaa !35
  %177 = icmp ugt i64 %169, %176
  br i1 %177, label %178, label %.critedge422.thread

178:                                              ; preds = %175
  %179 = tail call i32 @sys_trim(ptr noundef nonnull @_gm_, i64 noundef 0)
  br label %.critedge422.thread

180:                                              ; preds = %164
  %181 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %182 = icmp eq ptr %11, %181
  br i1 %182, label %183, label %189

183:                                              ; preds = %180
  %184 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  %185 = add i64 %184, %.1302
  store i64 %185, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  store ptr %.1, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %186 = or i64 %185, 1
  %187 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %186, ptr %187, align 8, !tbaa !14
  %188 = getelementptr inbounds i8, ptr %.1, i64 %185
  store i64 %185, ptr %188, align 8, !tbaa !16
  br label %.critedge422.thread

189:                                              ; preds = %180
  %190 = and i64 %160, -8
  %191 = add i64 %190, %.1302
  %192 = icmp ult i64 %160, 256
  br i1 %192, label %193, label %229

193:                                              ; preds = %189
  %194 = lshr i64 %160, 3
  %195 = getelementptr inbounds i8, ptr %11, i64 16
  %196 = load ptr, ptr %195, align 8, !tbaa !19
  %197 = getelementptr inbounds i8, ptr %11, i64 24
  %198 = load ptr, ptr %197, align 8, !tbaa !20
  %199 = trunc nuw nsw i64 %194 to i32
  %.not398 = icmp eq ptr %11, %198
  br i1 %.not398, label %200, label %201

200:                                              ; preds = %193
  tail call void @__assert_fail(ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 4750, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

201:                                              ; preds = %193
  %.not399 = icmp eq ptr %11, %196
  br i1 %.not399, label %202, label %203

202:                                              ; preds = %201
  tail call void @__assert_fail(ptr noundef nonnull @.str.10, ptr noundef nonnull @.str.1, i32 noundef 4750, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

203:                                              ; preds = %201
  %204 = shl nuw nsw i64 %194, 1
  %205 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %204
  %206 = icmp eq ptr %196, %205
  br i1 %206, label %.critedge424, label %207

207:                                              ; preds = %203
  %208 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not400 = icmp ult ptr %196, %208
  br i1 %.not400, label %.critedge426, label %209

209:                                              ; preds = %207
  %210 = getelementptr inbounds i8, ptr %196, i64 24
  %211 = load ptr, ptr %210, align 8, !tbaa !20
  %212 = icmp eq ptr %211, %11
  br i1 %212, label %.critedge424, label %.critedge426, !prof !21

.critedge424:                                     ; preds = %203, %209
  %213 = icmp eq ptr %198, %196
  br i1 %213, label %214, label %219

214:                                              ; preds = %.critedge424
  %215 = shl nuw i32 1, %199
  %216 = xor i32 %215, -1
  %217 = load i32, ptr @_gm_, align 8, !tbaa !22
  %218 = and i32 %217, %216
  store i32 %218, ptr @_gm_, align 8, !tbaa !22
  br label %303

219:                                              ; preds = %.critedge424
  %220 = icmp eq ptr %198, %205
  br i1 %220, label %.critedge428, label %221

221:                                              ; preds = %219
  %222 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not401 = icmp ult ptr %198, %222
  br i1 %.not401, label %.critedge430, label %223

223:                                              ; preds = %221
  %224 = getelementptr inbounds i8, ptr %198, i64 16
  %225 = load ptr, ptr %224, align 8, !tbaa !19
  %226 = icmp eq ptr %225, %11
  br i1 %226, label %.critedge428, label %.critedge430, !prof !21

.critedge428:                                     ; preds = %219, %223
  %227 = getelementptr inbounds i8, ptr %196, i64 24
  store ptr %198, ptr %227, align 8, !tbaa !20
  %228 = getelementptr inbounds i8, ptr %198, i64 16
  store ptr %196, ptr %228, align 8, !tbaa !19
  br label %303

.critedge430:                                     ; preds = %221, %223
  tail call void @abort() #6
  unreachable

.critedge426:                                     ; preds = %207, %209
  tail call void @abort() #6
  unreachable

229:                                              ; preds = %189
  %230 = getelementptr inbounds i8, ptr %11, i64 48
  %231 = load ptr, ptr %230, align 8, !tbaa !23
  %232 = getelementptr inbounds i8, ptr %11, i64 24
  %233 = load ptr, ptr %232, align 8, !tbaa !25
  %.not383 = icmp eq ptr %233, %11
  br i1 %.not383, label %247, label %234

234:                                              ; preds = %229
  %235 = getelementptr inbounds i8, ptr %11, i64 16
  %236 = load ptr, ptr %235, align 8, !tbaa !26
  %237 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not389 = icmp ult ptr %236, %237
  br i1 %.not389, label %.critedge432, label %238, !prof !13

238:                                              ; preds = %234
  %239 = getelementptr inbounds i8, ptr %236, i64 24
  %240 = load ptr, ptr %239, align 8, !tbaa !25
  %241 = icmp eq ptr %240, %11
  br i1 %241, label %242, label %.critedge432, !prof !21

242:                                              ; preds = %238
  %243 = getelementptr inbounds i8, ptr %233, i64 16
  %244 = load ptr, ptr %243, align 8, !tbaa !26
  %245 = icmp eq ptr %244, %11
  br i1 %245, label %246, label %.critedge432, !prof !21

246:                                              ; preds = %242
  store ptr %233, ptr %239, align 8, !tbaa !25
  store ptr %236, ptr %243, align 8, !tbaa !26
  br label %262

.critedge432:                                     ; preds = %238, %234, %242
  tail call void @abort() #6
  unreachable

247:                                              ; preds = %229
  %248 = getelementptr inbounds i8, ptr %11, i64 40
  %249 = load ptr, ptr %248, align 8, !tbaa !27
  %.not384 = icmp eq ptr %249, null
  br i1 %.not384, label %250, label %.critedge4.preheader

250:                                              ; preds = %247
  %251 = getelementptr inbounds i8, ptr %11, i64 32
  %252 = load ptr, ptr %251, align 8, !tbaa !27
  %.not385 = icmp eq ptr %252, null
  br i1 %.not385, label %262, label %.critedge4.preheader

.critedge4.preheader:                             ; preds = %250, %247
  %.1323.ph = phi ptr [ %251, %250 ], [ %248, %247 ]
  %.1319.ph = phi ptr [ %252, %250 ], [ %249, %247 ]
  br label %.critedge4

.critedge4:                                       ; preds = %.critedge4.backedge, %.critedge4.preheader
  %.1323 = phi ptr [ %.1323.ph, %.critedge4.preheader ], [ %.1323.be, %.critedge4.backedge ]
  %.1319 = phi ptr [ %.1319.ph, %.critedge4.preheader ], [ %.1319.be, %.critedge4.backedge ]
  %253 = getelementptr inbounds i8, ptr %.1319, i64 40
  %254 = load ptr, ptr %253, align 8, !tbaa !27
  %.not386 = icmp eq ptr %254, null
  br i1 %.not386, label %255, label %.critedge4.backedge

.critedge4.backedge:                              ; preds = %.critedge4, %255
  %.1323.be = phi ptr [ %253, %.critedge4 ], [ %256, %255 ]
  %.1319.be = phi ptr [ %254, %.critedge4 ], [ %257, %255 ]
  br label %.critedge4, !llvm.loop !36

255:                                              ; preds = %.critedge4
  %256 = getelementptr inbounds i8, ptr %.1319, i64 32
  %257 = load ptr, ptr %256, align 8, !tbaa !27
  %.not387 = icmp eq ptr %257, null
  br i1 %.not387, label %258, label %.critedge4.backedge

258:                                              ; preds = %255
  %259 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not388 = icmp ult ptr %.1323, %259
  br i1 %.not388, label %261, label %260, !prof !13

260:                                              ; preds = %258
  store ptr null, ptr %.1323, align 8, !tbaa !27
  br label %262

261:                                              ; preds = %258
  tail call void @abort() #6
  unreachable

262:                                              ; preds = %250, %260, %246
  %.3321 = phi ptr [ %233, %246 ], [ %.1319, %260 ], [ null, %250 ]
  %.not390 = icmp eq ptr %231, null
  br i1 %.not390, label %303, label %263

263:                                              ; preds = %262
  %264 = getelementptr inbounds i8, ptr %11, i64 56
  %265 = load i32, ptr %264, align 8, !tbaa !30
  %266 = zext i32 %265 to i64
  %267 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %266
  %268 = load ptr, ptr %267, align 8, !tbaa !27
  %269 = icmp eq ptr %11, %268
  br i1 %269, label %270, label %275

270:                                              ; preds = %263
  store ptr %.3321, ptr %267, align 8, !tbaa !27
  %cond435 = icmp eq ptr %.3321, null
  br i1 %cond435, label %.thread458, label %283

.thread458:                                       ; preds = %270
  %271 = shl nuw i32 1, %265
  %272 = xor i32 %271, -1
  %273 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %274 = and i32 %273, %272
  store i32 %274, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %303

275:                                              ; preds = %263
  %276 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not391 = icmp ult ptr %231, %276
  br i1 %.not391, label %282, label %277, !prof !13

277:                                              ; preds = %275
  %278 = getelementptr inbounds i8, ptr %231, i64 32
  %279 = load ptr, ptr %278, align 8, !tbaa !27
  %280 = icmp eq ptr %279, %11
  %281 = getelementptr inbounds i8, ptr %231, i64 40
  %.sink463 = select i1 %280, ptr %278, ptr %281
  store ptr %.3321, ptr %.sink463, align 8, !tbaa !27
  %.not392 = icmp eq ptr %.3321, null
  br i1 %.not392, label %303, label %283

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

283:                                              ; preds = %270, %277
  %284 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not393 = icmp ult ptr %.3321, %284
  br i1 %.not393, label %302, label %285, !prof !13

285:                                              ; preds = %283
  %286 = getelementptr inbounds i8, ptr %.3321, i64 48
  store ptr %231, ptr %286, align 8, !tbaa !23
  %287 = getelementptr inbounds i8, ptr %11, i64 32
  %288 = load ptr, ptr %287, align 8, !tbaa !27
  %.not394 = icmp eq ptr %288, null
  br i1 %.not394, label %294, label %289

289:                                              ; preds = %285
  %.not395 = icmp ult ptr %288, %284
  br i1 %.not395, label %293, label %290, !prof !13

290:                                              ; preds = %289
  %291 = getelementptr inbounds i8, ptr %.3321, i64 32
  store ptr %288, ptr %291, align 8, !tbaa !27
  %292 = getelementptr inbounds i8, ptr %288, i64 48
  store ptr %.3321, ptr %292, align 8, !tbaa !23
  br label %294

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

294:                                              ; preds = %290, %285
  %295 = getelementptr inbounds i8, ptr %11, i64 40
  %296 = load ptr, ptr %295, align 8, !tbaa !27
  %.not396 = icmp eq ptr %296, null
  br i1 %.not396, label %303, label %297

297:                                              ; preds = %294
  %.not397 = icmp ult ptr %296, %284
  br i1 %.not397, label %301, label %298, !prof !13

298:                                              ; preds = %297
  %299 = getelementptr inbounds i8, ptr %.3321, i64 40
  store ptr %296, ptr %299, align 8, !tbaa !27
  %300 = getelementptr inbounds i8, ptr %296, i64 48
  store ptr %.3321, ptr %300, align 8, !tbaa !23
  br label %303

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

302:                                              ; preds = %283
  tail call void @abort() #6
  unreachable

303:                                              ; preds = %.thread458, %262, %294, %298, %277, %.critedge428, %214
  %304 = or i64 %191, 1
  %305 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %304, ptr %305, align 8, !tbaa !14
  %306 = getelementptr inbounds i8, ptr %.1, i64 %191
  store i64 %191, ptr %306, align 8, !tbaa !16
  %307 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %.not402 = icmp eq ptr %.1, %307
  br i1 %.not402, label %.thread440, label %313

.thread440:                                       ; preds = %303
  store i64 %191, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  br label %.critedge422.thread

308:                                              ; preds = %162
  %309 = and i64 %160, -2
  store i64 %309, ptr %159, align 8, !tbaa !14
  %310 = or i64 %.1302, 1
  %311 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %310, ptr %311, align 8, !tbaa !14
  %312 = getelementptr inbounds i8, ptr %.1, i64 %.1302
  store i64 %.1302, ptr %312, align 8, !tbaa !16
  br label %313

313:                                              ; preds = %303, %308
  %.2 = phi i64 [ %.1302, %308 ], [ %191, %303 ]
  %314 = icmp ult i64 %.2, 256
  br i1 %314, label %315, label %338

315:                                              ; preds = %313
  %316 = lshr i64 %.2, 3
  %317 = shl nuw nsw i64 %316, 1
  %318 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %317
  %319 = icmp ugt i64 %.2, 31
  br i1 %319, label %321, label %320

320:                                              ; preds = %315
  tail call void @__assert_fail(ptr noundef nonnull @.str.12, ptr noundef nonnull @.str.1, i32 noundef 4762, ptr noundef nonnull @__PRETTY_FUNCTION__.free) #6
  unreachable

321:                                              ; preds = %315
  %322 = trunc nuw nsw i64 %316 to i32
  %323 = load i32, ptr @_gm_, align 8, !tbaa !22
  %324 = shl nuw i32 1, %322
  %325 = and i32 %323, %324
  %.not407 = icmp eq i32 %325, 0
  br i1 %.not407, label %326, label %328

326:                                              ; preds = %321
  %327 = or i32 %323, %324
  store i32 %327, ptr @_gm_, align 8, !tbaa !22
  br label %333

328:                                              ; preds = %321
  %329 = getelementptr inbounds i8, ptr %318, i64 16
  %330 = load ptr, ptr %329, align 8, !tbaa !19
  %331 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not408 = icmp ult ptr %330, %331
  br i1 %.not408, label %332, label %333, !prof !13

332:                                              ; preds = %328
  tail call void @abort() #6
  unreachable

333:                                              ; preds = %328, %326
  %.0317 = phi ptr [ %318, %326 ], [ %330, %328 ]
  %334 = getelementptr inbounds i8, ptr %318, i64 16
  store ptr %.1, ptr %334, align 8, !tbaa !19
  %335 = getelementptr inbounds i8, ptr %.0317, i64 24
  store ptr %.1, ptr %335, align 8, !tbaa !20
  %336 = getelementptr inbounds i8, ptr %.1, i64 16
  store ptr %.0317, ptr %336, align 8, !tbaa !19
  %337 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %318, ptr %337, align 8, !tbaa !20
  br label %.critedge422.thread

338:                                              ; preds = %313
  %339 = lshr i64 %.2, 8
  %340 = trunc i64 %339 to i32
  %341 = icmp eq i32 %340, 0
  br i1 %341, label %354, label %342

342:                                              ; preds = %338
  %343 = icmp ugt i32 %340, 65535
  br i1 %343, label %354, label %344

344:                                              ; preds = %342
  %345 = tail call range(i32 16, 33) i32 @llvm.ctlz.i32(i32 %340, i1 true)
  %346 = shl nuw nsw i32 %345, 1
  %347 = sub nuw nsw i32 38, %345
  %348 = zext nneg i32 %347 to i64
  %349 = lshr i64 %.2, %348
  %350 = trunc i64 %349 to i32
  %351 = and i32 %350, 1
  %352 = or disjoint i32 %351, %346
  %353 = xor i32 %352, 62
  br label %354

354:                                              ; preds = %342, %338, %344
  %.0311 = phi i32 [ %353, %344 ], [ 0, %338 ], [ 31, %342 ]
  %355 = zext nneg i32 %.0311 to i64
  %356 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %355
  %357 = getelementptr inbounds i8, ptr %.1, i64 56
  store i32 %.0311, ptr %357, align 8, !tbaa !30
  %358 = getelementptr inbounds i8, ptr %.1, i64 32
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %358, i8 0, i64 16, i1 false)
  %359 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %360 = shl nuw i32 1, %.0311
  %361 = and i32 %359, %360
  %.not403 = icmp eq i32 %361, 0
  br i1 %.not403, label %362, label %364

362:                                              ; preds = %354
  %363 = or i32 %359, %360
  store i32 %363, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %.thread442

364:                                              ; preds = %354
  %365 = load ptr, ptr %356, align 8, !tbaa !27
  %366 = icmp eq i32 %.0311, 31
  %367 = lshr i32 %.0311, 1
  %368 = add nuw nsw i32 %367, 6
  %369 = zext nneg i32 %368 to i64
  %370 = sub nuw nsw i64 63, %369
  %371 = select i1 %366, i64 0, i64 %370
  %372 = shl i64 %.2, %371
  br label %373

373:                                              ; preds = %377, %364
  %.0304 = phi ptr [ %365, %364 ], [ %382, %377 ]
  %.0303 = phi i64 [ %372, %364 ], [ %381, %377 ]
  %374 = getelementptr inbounds i8, ptr %.0304, i64 8
  %375 = load i64, ptr %374, align 8, !tbaa !37
  %376 = and i64 %375, -8
  %.not404 = icmp eq i64 %376, %.2
  br i1 %.not404, label %387, label %377

377:                                              ; preds = %373
  %378 = getelementptr inbounds i8, ptr %.0304, i64 32
  %379 = lshr i64 %.0303, 63
  %380 = getelementptr inbounds [2 x ptr], ptr %378, i64 0, i64 %379
  %381 = shl i64 %.0303, 1
  %382 = load ptr, ptr %380, align 8, !tbaa !27
  %.not405 = icmp eq ptr %382, null
  br i1 %.not405, label %383, label %373

383:                                              ; preds = %377
  %384 = getelementptr inbounds [2 x ptr], ptr %378, i64 0, i64 %379
  %385 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not406 = icmp ult ptr %384, %385
  br i1 %.not406, label %386, label %.thread442, !prof !13

386:                                              ; preds = %383
  tail call void @abort() #6
  unreachable

387:                                              ; preds = %373
  %388 = getelementptr inbounds i8, ptr %.0304, i64 16
  %389 = load ptr, ptr %388, align 8, !tbaa !26
  %390 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8
  %391 = icmp uge ptr %.0304, %390
  %392 = icmp uge ptr %389, %390
  %393 = select i1 %391, i1 %392, i1 false, !prof !21
  br i1 %393, label %394, label %396, !prof !21

394:                                              ; preds = %387
  %395 = getelementptr inbounds i8, ptr %389, i64 24
  store ptr %.1, ptr %395, align 8, !tbaa !25
  br label %.thread442

396:                                              ; preds = %387
  tail call void @abort() #6
  unreachable

.thread442:                                       ; preds = %383, %394, %362
  %.sink470 = phi ptr [ %388, %394 ], [ %356, %362 ], [ %384, %383 ]
  %.sink469 = phi i64 [ 16, %394 ], [ 48, %362 ], [ 48, %383 ]
  %.0304.lcssa460.sink = phi ptr [ %389, %394 ], [ %356, %362 ], [ %.0304, %383 ]
  %.1.sink466 = phi ptr [ %.0304, %394 ], [ %.1, %362 ], [ %.1, %383 ]
  %.sink465 = phi i64 [ 48, %394 ], [ 16, %362 ], [ 16, %383 ]
  %.1.sink = phi ptr [ null, %394 ], [ %.1, %362 ], [ %.1, %383 ]
  store ptr %.1, ptr %.sink470, align 8, !tbaa !27
  %397 = getelementptr inbounds i8, ptr %.1, i64 %.sink469
  store ptr %.0304.lcssa460.sink, ptr %397, align 8, !tbaa !27
  %398 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %.1.sink466, ptr %398, align 8, !tbaa !25
  %399 = getelementptr inbounds i8, ptr %.1, i64 %.sink465
  store ptr %.1.sink, ptr %399, align 8, !tbaa !27
  %400 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !38
  %401 = add i64 %400, -1
  store i64 %401, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !38
  %402 = icmp eq i64 %401, 0
  br i1 %402, label %403, label %.critedge422.thread

403:                                              ; preds = %.thread442
  %404 = tail call i64 @release_unused_segments(ptr noundef nonnull @_gm_)
  br label %.critedge422.thread

.critedge410:                                     ; preds = %.thread, %158, %27, %2, %5
  tail call void @abort() #6
  unreachable

.critedge422.thread:                              ; preds = %.thread440, %153, %17, %24, %333, %403, %.thread442, %175, %178, %183, %1
  ret void
}

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

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

; 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 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { 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, !11, i64 24}
!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, !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 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!14 = !{!15, !10, i64 8}
!15 = !{!"malloc_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24}
!16 = !{!15, !10, i64 0}
!17 = !{!6, !10, i64 856}
!18 = !{!6, !11, i64 32}
!19 = !{!15, !11, i64 16}
!20 = !{!15, !11, i64 24}
!21 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!22 = !{!6, !7, i64 0}
!23 = !{!24, !11, i64 48}
!24 = !{!"malloc_tree_chunk", !10, i64 0, !10, i64 8, !11, i64 16, !11, i64 24, !8, i64 32, !11, i64 48, !7, i64 56}
!25 = !{!24, !11, i64 24}
!26 = !{!24, !11, i64 16}
!27 = !{!11, !11, i64 0}
!28 = distinct !{!28, !29}
!29 = !{!"llvm.loop.mustprogress"}
!30 = !{!24, !7, i64 56}
!31 = !{!6, !7, i64 4}
!32 = !{!6, !10, i64 8}
!33 = !{!6, !11, i64 40}
!34 = !{!6, !10, i64 16}
!35 = !{!6, !10, i64 48}
!36 = distinct !{!36, !29}
!37 = !{!24, !10, i64 8}
!38 = !{!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