; LLVM IR from preshing/CompareIntegerMaps :: dlmalloc (malloc)

; 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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @dlfree(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 %1083

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

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 %456, 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 %453

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

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

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

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 %8, align 8, !tbaa !5
  %142 = load i32, ptr %10, align 4, !tbaa !22
  %143 = shl i32 %142, 1
  %144 = zext i32 %143 to i64
  %145 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %144
  %146 = icmp eq ptr %141, %145
  br i1 %146, label %159, label %147

147:                                              ; preds = %131
  %148 = load ptr, ptr %8, align 8, !tbaa !5
  %149 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %150 = icmp uge ptr %148, %149
  br i1 %150, label %151, label %157

151:                                              ; preds = %147
  %152 = load ptr, ptr %8, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.malloc_chunk, ptr %152, i32 0, i32 3
  %154 = load ptr, ptr %153, align 8, !tbaa !21
  %155 = load ptr, ptr %3, align 8, !tbaa !5
  %156 = icmp eq ptr %154, %155
  br label %157

157:                                              ; preds = %151, %147
  %158 = phi i1 [ false, %147 ], [ %156, %151 ]
  br label %159

159:                                              ; preds = %157, %131
  %160 = phi i1 [ true, %131 ], [ %158, %157 ]
  %161 = zext i1 %160 to i32
  %162 = sext i32 %161 to i64
  %163 = call i64 @llvm.expect.i64(i64 %162, i64 1)
  %164 = icmp ne i64 %163, 0
  br i1 %164, label %165, label %210

165:                                              ; preds = %159
  %166 = load ptr, ptr %9, align 8, !tbaa !5
  %167 = load ptr, ptr %8, align 8, !tbaa !5
  %168 = icmp eq ptr %166, %167
  br i1 %168, label %169, label %175

169:                                              ; preds = %165
  %170 = load i32, ptr %10, align 4, !tbaa !22
  %171 = shl i32 1, %170
  %172 = xor i32 %171, -1
  %173 = load i32, ptr @_gm_, align 8, !tbaa !23
  %174 = and i32 %173, %172
  store i32 %174, ptr @_gm_, align 8, !tbaa !23
  br label %209

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

182:                                              ; preds = %175
  %183 = load ptr, ptr %9, align 8, !tbaa !5
  %184 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %185 = icmp uge ptr %183, %184
  br i1 %185, label %186, label %192

186:                                              ; preds = %182
  %187 = load ptr, ptr %9, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.malloc_chunk, ptr %187, i32 0, i32 2
  %189 = load ptr, ptr %188, align 8, !tbaa !20
  %190 = load ptr, ptr %3, align 8, !tbaa !5
  %191 = icmp eq ptr %189, %190
  br label %192

192:                                              ; preds = %186, %182
  %193 = phi i1 [ false, %182 ], [ %191, %186 ]
  br label %194

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

200:                                              ; preds = %194
  %201 = load ptr, ptr %9, align 8, !tbaa !5
  %202 = load ptr, ptr %8, align 8, !tbaa !5
  %203 = getelementptr inbounds %struct.malloc_chunk, ptr %202, i32 0, i32 3
  store ptr %201, ptr %203, align 8, !tbaa !21
  %204 = load ptr, ptr %8, align 8, !tbaa !5
  %205 = load ptr, ptr %9, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.malloc_chunk, ptr %205, i32 0, i32 2
  store ptr %204, ptr %206, align 8, !tbaa !20
  br label %208

207:                                              ; preds = %194
  call void @abort() #7
  unreachable

208:                                              ; preds = %200
  br label %209

209:                                              ; preds = %208, %169
  br label %211

210:                                              ; preds = %159
  call void @abort() #7
  unreachable

211:                                              ; preds = %209
  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 %423

212:                                              ; preds = %127
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #6
  %213 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %213, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #6
  %214 = load ptr, ptr %11, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %214, i32 0, i32 5
  %216 = load ptr, ptr %215, align 8, !tbaa !24
  store ptr %216, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #6
  %217 = load ptr, ptr %11, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %217, i32 0, i32 3
  %219 = load ptr, ptr %218, align 8, !tbaa !26
  %220 = load ptr, ptr %11, align 8, !tbaa !5
  %221 = icmp ne ptr %219, %220
  br i1 %221, label %222, label %259

222:                                              ; preds = %212
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #6
  %223 = load ptr, ptr %11, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %223, i32 0, i32 2
  %225 = load ptr, ptr %224, align 8, !tbaa !27
  store ptr %225, ptr %14, align 8, !tbaa !5
  %226 = load ptr, ptr %11, align 8, !tbaa !5
  %227 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %226, i32 0, i32 3
  %228 = load ptr, ptr %227, align 8, !tbaa !26
  store ptr %228, ptr %13, align 8, !tbaa !5
  %229 = load ptr, ptr %14, align 8, !tbaa !5
  %230 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %231 = icmp uge ptr %229, %230
  br i1 %231, label %232, label %244

232:                                              ; preds = %222
  %233 = load ptr, ptr %14, align 8, !tbaa !5
  %234 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %233, i32 0, i32 3
  %235 = load ptr, ptr %234, align 8, !tbaa !26
  %236 = load ptr, ptr %11, align 8, !tbaa !5
  %237 = icmp eq ptr %235, %236
  br i1 %237, label %238, label %244

238:                                              ; preds = %232
  %239 = load ptr, ptr %13, align 8, !tbaa !5
  %240 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %239, i32 0, i32 2
  %241 = load ptr, ptr %240, align 8, !tbaa !27
  %242 = load ptr, ptr %11, align 8, !tbaa !5
  %243 = icmp eq ptr %241, %242
  br label %244

244:                                              ; preds = %238, %232, %222
  %245 = phi i1 [ false, %232 ], [ false, %222 ], [ %243, %238 ]
  %246 = zext i1 %245 to i32
  %247 = sext i32 %246 to i64
  %248 = call i64 @llvm.expect.i64(i64 %247, i64 1)
  %249 = icmp ne i64 %248, 0
  br i1 %249, label %250, label %257

250:                                              ; preds = %244
  %251 = load ptr, ptr %13, align 8, !tbaa !5
  %252 = load ptr, ptr %14, align 8, !tbaa !5
  %253 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %252, i32 0, i32 3
  store ptr %251, ptr %253, align 8, !tbaa !26
  %254 = load ptr, ptr %14, align 8, !tbaa !5
  %255 = load ptr, ptr %13, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %255, i32 0, i32 2
  store ptr %254, ptr %256, align 8, !tbaa !27
  br label %258

257:                                              ; preds = %244
  call void @abort() #7
  unreachable

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

259:                                              ; preds = %212
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  %260 = load ptr, ptr %11, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %260, i32 0, i32 4
  %262 = getelementptr inbounds [2 x ptr], ptr %261, i64 0, i64 1
  store ptr %262, ptr %15, align 8, !tbaa !5
  %263 = load ptr, ptr %262, align 8, !tbaa !5
  store ptr %263, ptr %13, align 8, !tbaa !5
  %264 = icmp ne ptr %263, null
  br i1 %264, label %271, label %265

265:                                              ; preds = %259
  %266 = load ptr, ptr %11, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %266, i32 0, i32 4
  %268 = getelementptr inbounds [2 x ptr], ptr %267, i64 0, i64 0
  store ptr %268, ptr %15, align 8, !tbaa !5
  %269 = load ptr, ptr %268, align 8, !tbaa !5
  store ptr %269, ptr %13, align 8, !tbaa !5
  %270 = icmp ne ptr %269, null
  br i1 %270, label %271, label %301

271:                                              ; preds = %265, %259
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #6
  br label %272

272:                                              ; preds = %286, %271
  %273 = load ptr, ptr %13, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %273, i32 0, i32 4
  %275 = getelementptr inbounds [2 x ptr], ptr %274, i64 0, i64 1
  store ptr %275, ptr %16, align 8, !tbaa !5
  %276 = load ptr, ptr %275, align 8, !tbaa !5
  %277 = icmp ne ptr %276, null
  br i1 %277, label %284, label %278

278:                                              ; preds = %272
  %279 = load ptr, ptr %13, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %279, i32 0, i32 4
  %281 = getelementptr inbounds [2 x ptr], ptr %280, i64 0, i64 0
  store ptr %281, ptr %16, align 8, !tbaa !5
  %282 = load ptr, ptr %281, align 8, !tbaa !5
  %283 = icmp ne ptr %282, null
  br label %284

284:                                              ; preds = %278, %272
  %285 = phi i1 [ true, %272 ], [ %283, %278 ]
  br i1 %285, label %286, label %289

286:                                              ; preds = %284
  %287 = load ptr, ptr %16, align 8, !tbaa !5
  store ptr %287, ptr %15, align 8, !tbaa !5
  %288 = load ptr, ptr %287, align 8, !tbaa !5
  store ptr %288, ptr %13, align 8, !tbaa !5
  br label %272, !llvm.loop !28

289:                                              ; preds = %284
  %290 = load ptr, ptr %15, align 8, !tbaa !5
  %291 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %292 = icmp uge ptr %290, %291
  %293 = zext i1 %292 to i32
  %294 = sext i32 %293 to i64
  %295 = call i64 @llvm.expect.i64(i64 %294, i64 1)
  %296 = icmp ne i64 %295, 0
  br i1 %296, label %297, label %299

297:                                              ; preds = %289
  %298 = load ptr, ptr %15, align 8, !tbaa !5
  store ptr null, ptr %298, align 8, !tbaa !5
  br label %300

299:                                              ; preds = %289
  call void @abort() #7
  unreachable

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

301:                                              ; preds = %300, %265
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  br label %302

302:                                              ; preds = %301, %258
  %303 = load ptr, ptr %12, align 8, !tbaa !5
  %304 = icmp ne ptr %303, null
  br i1 %304, label %305, label %422

305:                                              ; preds = %302
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #6
  %306 = load ptr, ptr %11, align 8, !tbaa !5
  %307 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %306, i32 0, i32 6
  %308 = load i32, ptr %307, align 8, !tbaa !30
  %309 = zext i32 %308 to i64
  %310 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %309
  store ptr %310, ptr %17, align 8, !tbaa !5
  %311 = load ptr, ptr %11, align 8, !tbaa !5
  %312 = load ptr, ptr %17, align 8, !tbaa !5
  %313 = load ptr, ptr %312, align 8, !tbaa !5
  %314 = icmp eq ptr %311, %313
  br i1 %314, label %315, label %328

315:                                              ; preds = %305
  %316 = load ptr, ptr %13, align 8, !tbaa !5
  %317 = load ptr, ptr %17, align 8, !tbaa !5
  store ptr %316, ptr %317, align 8, !tbaa !5
  %318 = icmp eq ptr %316, null
  br i1 %318, label %319, label %327

319:                                              ; preds = %315
  %320 = load ptr, ptr %11, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %320, i32 0, i32 6
  %322 = load i32, ptr %321, align 8, !tbaa !30
  %323 = shl i32 1, %322
  %324 = xor i32 %323, -1
  %325 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %326 = and i32 %325, %324
  store i32 %326, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  br label %327

327:                                              ; preds = %319, %315
  br label %356

328:                                              ; preds = %305
  %329 = load ptr, ptr %12, align 8, !tbaa !5
  %330 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %331 = icmp uge ptr %329, %330
  %332 = zext i1 %331 to i32
  %333 = sext i32 %332 to i64
  %334 = call i64 @llvm.expect.i64(i64 %333, i64 1)
  %335 = icmp ne i64 %334, 0
  br i1 %335, label %336, label %354

336:                                              ; preds = %328
  %337 = load ptr, ptr %12, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %337, i32 0, i32 4
  %339 = getelementptr inbounds [2 x ptr], ptr %338, i64 0, i64 0
  %340 = load ptr, ptr %339, align 8, !tbaa !5
  %341 = load ptr, ptr %11, align 8, !tbaa !5
  %342 = icmp eq ptr %340, %341
  br i1 %342, label %343, label %348

343:                                              ; preds = %336
  %344 = load ptr, ptr %13, align 8, !tbaa !5
  %345 = load ptr, ptr %12, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %345, i32 0, i32 4
  %347 = getelementptr inbounds [2 x ptr], ptr %346, i64 0, i64 0
  store ptr %344, ptr %347, align 8, !tbaa !5
  br label %353

348:                                              ; preds = %336
  %349 = load ptr, ptr %13, align 8, !tbaa !5
  %350 = load ptr, ptr %12, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %350, i32 0, i32 4
  %352 = getelementptr inbounds [2 x ptr], ptr %351, i64 0, i64 1
  store ptr %349, ptr %352, align 8, !tbaa !5
  br label %353

353:                                              ; preds = %348, %343
  br label %355

354:                                              ; preds = %328
  call void @abort() #7
  unreachable

355:                                              ; preds = %353
  br label %356

356:                                              ; preds = %355, %327
  %357 = load ptr, ptr %13, align 8, !tbaa !5
  %358 = icmp ne ptr %357, null
  br i1 %358, label %359, label %421

359:                                              ; preds = %356
  %360 = load ptr, ptr %13, align 8, !tbaa !5
  %361 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %362 = icmp uge ptr %360, %361
  %363 = zext i1 %362 to i32
  %364 = sext i32 %363 to i64
  %365 = call i64 @llvm.expect.i64(i64 %364, i64 1)
  %366 = icmp ne i64 %365, 0
  br i1 %366, label %367, label %419

367:                                              ; preds = %359
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #6
  %368 = load ptr, ptr %12, align 8, !tbaa !5
  %369 = load ptr, ptr %13, align 8, !tbaa !5
  %370 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %369, i32 0, i32 5
  store ptr %368, ptr %370, align 8, !tbaa !24
  %371 = load ptr, ptr %11, align 8, !tbaa !5
  %372 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %371, i32 0, i32 4
  %373 = getelementptr inbounds [2 x ptr], ptr %372, i64 0, i64 0
  %374 = load ptr, ptr %373, align 8, !tbaa !5
  store ptr %374, ptr %18, align 8, !tbaa !5
  %375 = icmp ne ptr %374, null
  br i1 %375, label %376, label %394

376:                                              ; preds = %367
  %377 = load ptr, ptr %18, align 8, !tbaa !5
  %378 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %379 = icmp uge ptr %377, %378
  %380 = zext i1 %379 to i32
  %381 = sext i32 %380 to i64
  %382 = call i64 @llvm.expect.i64(i64 %381, i64 1)
  %383 = icmp ne i64 %382, 0
  br i1 %383, label %384, label %392

384:                                              ; preds = %376
  %385 = load ptr, ptr %18, align 8, !tbaa !5
  %386 = load ptr, ptr %13, align 8, !tbaa !5
  %387 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %386, i32 0, i32 4
  %388 = getelementptr inbounds [2 x ptr], ptr %387, i64 0, i64 0
  store ptr %385, ptr %388, align 8, !tbaa !5
  %389 = load ptr, ptr %13, align 8, !tbaa !5
  %390 = load ptr, ptr %18, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %390, i32 0, i32 5
  store ptr %389, ptr %391, align 8, !tbaa !24
  br label %393

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

393:                                              ; preds = %384
  br label %394

394:                                              ; preds = %393, %367
  %395 = load ptr, ptr %11, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %395, i32 0, i32 4
  %397 = getelementptr inbounds [2 x ptr], ptr %396, i64 0, i64 1
  %398 = load ptr, ptr %397, align 8, !tbaa !5
  store ptr %398, ptr %19, align 8, !tbaa !5
  %399 = icmp ne ptr %398, null
  br i1 %399, label %400, label %418

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

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

416:                                              ; preds = %400
  call void @abort() #7
  unreachable

417:                                              ; preds = %408
  br label %418

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

419:                                              ; preds = %359
  call void @abort() #7
  unreachable

420:                                              ; preds = %418
  br label %421

421:                                              ; preds = %420, %356
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #6
  br label %422

422:                                              ; preds = %421, %302
  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 %423

423:                                              ; preds = %422, %211
  br label %446

424:                                              ; preds = %123
  %425 = load ptr, ptr %5, align 8, !tbaa !5
  %426 = getelementptr inbounds %struct.malloc_chunk, ptr %425, i32 0, i32 1
  %427 = load i64, ptr %426, align 8, !tbaa !14
  %428 = and i64 %427, 3
  %429 = icmp eq i64 %428, 3
  br i1 %429, label %430, label %445

430:                                              ; preds = %424
  %431 = load i64, ptr %4, align 8, !tbaa !16
  store i64 %431, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  %432 = load ptr, ptr %5, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.malloc_chunk, ptr %432, i32 0, i32 1
  %434 = load i64, ptr %433, align 8, !tbaa !14
  %435 = and i64 %434, -2
  store i64 %435, ptr %433, align 8, !tbaa !14
  %436 = load i64, ptr %4, align 8, !tbaa !16
  %437 = or i64 %436, 1
  %438 = load ptr, ptr %3, align 8, !tbaa !5
  %439 = getelementptr inbounds %struct.malloc_chunk, ptr %438, i32 0, i32 1
  store i64 %437, ptr %439, align 8, !tbaa !14
  %440 = load i64, ptr %4, align 8, !tbaa !16
  %441 = load ptr, ptr %3, align 8, !tbaa !5
  %442 = load i64, ptr %4, align 8, !tbaa !16
  %443 = getelementptr inbounds i8, ptr %441, i64 %442
  %444 = getelementptr inbounds %struct.malloc_chunk, ptr %443, i32 0, i32 0
  store i64 %440, ptr %444, align 8, !tbaa !17
  store i32 2, ptr %20, align 4
  br label %449

445:                                              ; preds = %424
  br label %446

446:                                              ; preds = %445, %423
  br label %448

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

448:                                              ; preds = %446
  store i32 0, ptr %20, align 4
  br label %449

449:                                              ; preds = %448, %447, %430
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #6
  %450 = load i32, ptr %20, align 4
  switch i32 %450, label %453 [
    i32 0, label %451
  ]

451:                                              ; preds = %449
  br label %452

452:                                              ; preds = %451
  store i32 0, ptr %20, align 4
  br label %453

453:                                              ; preds = %452, %449, %106
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #6
  %454 = load i32, ptr %20, align 4
  switch i32 %454, label %1077 [
    i32 0, label %455
  ]

455:                                              ; preds = %453
  br label %456

456:                                              ; preds = %455, %68
  %457 = load ptr, ptr %3, align 8, !tbaa !5
  %458 = load ptr, ptr %5, align 8, !tbaa !5
  %459 = icmp ult ptr %457, %458
  br i1 %459, label %460, label %466

460:                                              ; preds = %456
  %461 = load ptr, ptr %5, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.malloc_chunk, ptr %461, i32 0, i32 1
  %463 = load i64, ptr %462, align 8, !tbaa !14
  %464 = and i64 %463, 1
  %465 = icmp ne i64 %464, 0
  br label %466

466:                                              ; preds = %460, %456
  %467 = phi i1 [ false, %456 ], [ %465, %460 ]
  %468 = zext i1 %467 to i32
  %469 = sext i32 %468 to i64
  %470 = call i64 @llvm.expect.i64(i64 %469, i64 1)
  %471 = icmp ne i64 %470, 0
  br i1 %471, label %472, label %1076

472:                                              ; preds = %466
  %473 = load ptr, ptr %5, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.malloc_chunk, ptr %473, i32 0, i32 1
  %475 = load i64, ptr %474, align 8, !tbaa !14
  %476 = and i64 %475, 2
  %477 = icmp ne i64 %476, 0
  br i1 %477, label %844, label %478

478:                                              ; preds = %472
  %479 = load ptr, ptr %5, align 8, !tbaa !5
  %480 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !33
  %481 = icmp eq ptr %479, %480
  br i1 %481, label %482, label %502

482:                                              ; preds = %478
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #6
  %483 = load i64, ptr %4, align 8, !tbaa !16
  %484 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !34
  %485 = add i64 %484, %483
  store i64 %485, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 3), align 8, !tbaa !34
  store i64 %485, ptr %21, align 8, !tbaa !16
  %486 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %486, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 6), align 8, !tbaa !33
  %487 = load i64, ptr %21, align 8, !tbaa !16
  %488 = or i64 %487, 1
  %489 = load ptr, ptr %3, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.malloc_chunk, ptr %489, i32 0, i32 1
  store i64 %488, ptr %490, align 8, !tbaa !14
  %491 = load ptr, ptr %3, align 8, !tbaa !5
  %492 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %493 = icmp eq ptr %491, %492
  br i1 %493, label %494, label %495

494:                                              ; preds = %482
  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 %495

495:                                              ; preds = %494, %482
  %496 = load i64, ptr %21, align 8, !tbaa !16
  %497 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 7), align 8, !tbaa !35
  %498 = icmp ugt i64 %496, %497
  br i1 %498, label %499, label %501

499:                                              ; preds = %495
  %500 = call i32 @sys_trim(ptr noundef @_gm_, i64 noundef 0)
  br label %501

501:                                              ; preds = %499, %495
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #6
  br label %1077

502:                                              ; preds = %478
  %503 = load ptr, ptr %5, align 8, !tbaa !5
  %504 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %505 = icmp eq ptr %503, %504
  br i1 %505, label %506, label %520

506:                                              ; preds = %502
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #6
  %507 = load i64, ptr %4, align 8, !tbaa !16
  %508 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  %509 = add i64 %508, %507
  store i64 %509, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 2), align 8, !tbaa !32
  store i64 %509, ptr %22, align 8, !tbaa !16
  %510 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %510, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %511 = load i64, ptr %22, align 8, !tbaa !16
  %512 = or i64 %511, 1
  %513 = load ptr, ptr %3, align 8, !tbaa !5
  %514 = getelementptr inbounds %struct.malloc_chunk, ptr %513, i32 0, i32 1
  store i64 %512, ptr %514, align 8, !tbaa !14
  %515 = load i64, ptr %22, align 8, !tbaa !16
  %516 = load ptr, ptr %3, align 8, !tbaa !5
  %517 = load i64, ptr %22, align 8, !tbaa !16
  %518 = getelementptr inbounds i8, ptr %516, i64 %517
  %519 = getelementptr inbounds %struct.malloc_chunk, ptr %518, i32 0, i32 0
  store i64 %515, ptr %519, align 8, !tbaa !17
  store i32 2, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #6
  br label %1077

520:                                              ; preds = %502
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #6
  %521 = load ptr, ptr %5, align 8, !tbaa !5
  %522 = getelementptr inbounds %struct.malloc_chunk, ptr %521, i32 0, i32 1
  %523 = load i64, ptr %522, align 8, !tbaa !14
  %524 = and i64 %523, -8
  store i64 %524, ptr %23, align 8, !tbaa !16
  %525 = load i64, ptr %23, align 8, !tbaa !16
  %526 = load i64, ptr %4, align 8, !tbaa !16
  %527 = add i64 %526, %525
  store i64 %527, ptr %4, align 8, !tbaa !16
  %528 = load i64, ptr %23, align 8, !tbaa !16
  %529 = lshr i64 %528, 3
  %530 = icmp ult i64 %529, 32
  br i1 %530, label %531, label %612

531:                                              ; preds = %520
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #6
  %532 = load ptr, ptr %5, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.malloc_chunk, ptr %532, i32 0, i32 2
  %534 = load ptr, ptr %533, align 8, !tbaa !20
  store ptr %534, ptr %24, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #6
  %535 = load ptr, ptr %5, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.malloc_chunk, ptr %535, i32 0, i32 3
  %537 = load ptr, ptr %536, align 8, !tbaa !21
  store ptr %537, ptr %25, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #6
  %538 = load i64, ptr %23, align 8, !tbaa !16
  %539 = lshr i64 %538, 3
  %540 = trunc i64 %539 to i32
  store i32 %540, ptr %26, align 4, !tbaa !22
  %541 = load ptr, ptr %24, align 8, !tbaa !5
  %542 = load i32, ptr %26, align 4, !tbaa !22
  %543 = shl i32 %542, 1
  %544 = zext i32 %543 to i64
  %545 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %544
  %546 = icmp eq ptr %541, %545
  br i1 %546, label %559, label %547

547:                                              ; preds = %531
  %548 = load ptr, ptr %24, align 8, !tbaa !5
  %549 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %550 = icmp uge ptr %548, %549
  br i1 %550, label %551, label %557

551:                                              ; preds = %547
  %552 = load ptr, ptr %24, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.malloc_chunk, ptr %552, i32 0, i32 3
  %554 = load ptr, ptr %553, align 8, !tbaa !21
  %555 = load ptr, ptr %5, align 8, !tbaa !5
  %556 = icmp eq ptr %554, %555
  br label %557

557:                                              ; preds = %551, %547
  %558 = phi i1 [ false, %547 ], [ %556, %551 ]
  br label %559

559:                                              ; preds = %557, %531
  %560 = phi i1 [ true, %531 ], [ %558, %557 ]
  %561 = zext i1 %560 to i32
  %562 = sext i32 %561 to i64
  %563 = call i64 @llvm.expect.i64(i64 %562, i64 1)
  %564 = icmp ne i64 %563, 0
  br i1 %564, label %565, label %610

565:                                              ; preds = %559
  %566 = load ptr, ptr %25, align 8, !tbaa !5
  %567 = load ptr, ptr %24, align 8, !tbaa !5
  %568 = icmp eq ptr %566, %567
  br i1 %568, label %569, label %575

569:                                              ; preds = %565
  %570 = load i32, ptr %26, align 4, !tbaa !22
  %571 = shl i32 1, %570
  %572 = xor i32 %571, -1
  %573 = load i32, ptr @_gm_, align 8, !tbaa !23
  %574 = and i32 %573, %572
  store i32 %574, ptr @_gm_, align 8, !tbaa !23
  br label %609

575:                                              ; preds = %565
  %576 = load ptr, ptr %25, align 8, !tbaa !5
  %577 = load i32, ptr %26, align 4, !tbaa !22
  %578 = shl i32 %577, 1
  %579 = zext i32 %578 to i64
  %580 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %579
  %581 = icmp eq ptr %576, %580
  br i1 %581, label %594, label %582

582:                                              ; preds = %575
  %583 = load ptr, ptr %25, align 8, !tbaa !5
  %584 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %585 = icmp uge ptr %583, %584
  br i1 %585, label %586, label %592

586:                                              ; preds = %582
  %587 = load ptr, ptr %25, align 8, !tbaa !5
  %588 = getelementptr inbounds %struct.malloc_chunk, ptr %587, i32 0, i32 2
  %589 = load ptr, ptr %588, align 8, !tbaa !20
  %590 = load ptr, ptr %5, align 8, !tbaa !5
  %591 = icmp eq ptr %589, %590
  br label %592

592:                                              ; preds = %586, %582
  %593 = phi i1 [ false, %582 ], [ %591, %586 ]
  br label %594

594:                                              ; preds = %592, %575
  %595 = phi i1 [ true, %575 ], [ %593, %592 ]
  %596 = zext i1 %595 to i32
  %597 = sext i32 %596 to i64
  %598 = call i64 @llvm.expect.i64(i64 %597, i64 1)
  %599 = icmp ne i64 %598, 0
  br i1 %599, label %600, label %607

600:                                              ; preds = %594
  %601 = load ptr, ptr %25, align 8, !tbaa !5
  %602 = load ptr, ptr %24, align 8, !tbaa !5
  %603 = getelementptr inbounds %struct.malloc_chunk, ptr %602, i32 0, i32 3
  store ptr %601, ptr %603, align 8, !tbaa !21
  %604 = load ptr, ptr %24, align 8, !tbaa !5
  %605 = load ptr, ptr %25, align 8, !tbaa !5
  %606 = getelementptr inbounds %struct.malloc_chunk, ptr %605, i32 0, i32 2
  store ptr %604, ptr %606, align 8, !tbaa !20
  br label %608

607:                                              ; preds = %594
  call void @abort() #7
  unreachable

608:                                              ; preds = %600
  br label %609

609:                                              ; preds = %608, %569
  br label %611

610:                                              ; preds = %559
  call void @abort() #7
  unreachable

611:                                              ; preds = %609
  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 %823

612:                                              ; preds = %520
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #6
  %613 = load ptr, ptr %5, align 8, !tbaa !5
  store ptr %613, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #6
  %614 = load ptr, ptr %27, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %614, i32 0, i32 5
  %616 = load ptr, ptr %615, align 8, !tbaa !24
  store ptr %616, ptr %28, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #6
  %617 = load ptr, ptr %27, align 8, !tbaa !5
  %618 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %617, i32 0, i32 3
  %619 = load ptr, ptr %618, align 8, !tbaa !26
  %620 = load ptr, ptr %27, align 8, !tbaa !5
  %621 = icmp ne ptr %619, %620
  br i1 %621, label %622, label %659

622:                                              ; preds = %612
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #6
  %623 = load ptr, ptr %27, align 8, !tbaa !5
  %624 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %623, i32 0, i32 2
  %625 = load ptr, ptr %624, align 8, !tbaa !27
  store ptr %625, ptr %30, align 8, !tbaa !5
  %626 = load ptr, ptr %27, align 8, !tbaa !5
  %627 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %626, i32 0, i32 3
  %628 = load ptr, ptr %627, align 8, !tbaa !26
  store ptr %628, ptr %29, align 8, !tbaa !5
  %629 = load ptr, ptr %30, 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 %644

632:                                              ; preds = %622
  %633 = load ptr, ptr %30, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %633, i32 0, i32 3
  %635 = load ptr, ptr %634, align 8, !tbaa !26
  %636 = load ptr, ptr %27, align 8, !tbaa !5
  %637 = icmp eq ptr %635, %636
  br i1 %637, label %638, label %644

638:                                              ; preds = %632
  %639 = load ptr, ptr %29, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %639, i32 0, i32 2
  %641 = load ptr, ptr %640, align 8, !tbaa !27
  %642 = load ptr, ptr %27, align 8, !tbaa !5
  %643 = icmp eq ptr %641, %642
  br label %644

644:                                              ; preds = %638, %632, %622
  %645 = phi i1 [ false, %632 ], [ false, %622 ], [ %643, %638 ]
  %646 = zext i1 %645 to i32
  %647 = sext i32 %646 to i64
  %648 = call i64 @llvm.expect.i64(i64 %647, i64 1)
  %649 = icmp ne i64 %648, 0
  br i1 %649, label %650, label %657

650:                                              ; preds = %644
  %651 = load ptr, ptr %29, align 8, !tbaa !5
  %652 = load ptr, ptr %30, align 8, !tbaa !5
  %653 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %652, i32 0, i32 3
  store ptr %651, ptr %653, align 8, !tbaa !26
  %654 = load ptr, ptr %30, align 8, !tbaa !5
  %655 = load ptr, ptr %29, align 8, !tbaa !5
  %656 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %655, i32 0, i32 2
  store ptr %654, ptr %656, align 8, !tbaa !27
  br label %658

657:                                              ; preds = %644
  call void @abort() #7
  unreachable

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

659:                                              ; preds = %612
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #6
  %660 = load ptr, ptr %27, align 8, !tbaa !5
  %661 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %660, i32 0, i32 4
  %662 = getelementptr inbounds [2 x ptr], ptr %661, i64 0, i64 1
  store ptr %662, ptr %31, align 8, !tbaa !5
  %663 = load ptr, ptr %662, align 8, !tbaa !5
  store ptr %663, ptr %29, align 8, !tbaa !5
  %664 = icmp ne ptr %663, null
  br i1 %664, label %671, label %665

665:                                              ; preds = %659
  %666 = load ptr, ptr %27, align 8, !tbaa !5
  %667 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %666, i32 0, i32 4
  %668 = getelementptr inbounds [2 x ptr], ptr %667, i64 0, i64 0
  store ptr %668, ptr %31, align 8, !tbaa !5
  %669 = load ptr, ptr %668, align 8, !tbaa !5
  store ptr %669, ptr %29, align 8, !tbaa !5
  %670 = icmp ne ptr %669, null
  br i1 %670, label %671, label %701

671:                                              ; preds = %665, %659
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #6
  br label %672

672:                                              ; preds = %686, %671
  %673 = load ptr, ptr %29, align 8, !tbaa !5
  %674 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %673, i32 0, i32 4
  %675 = getelementptr inbounds [2 x ptr], ptr %674, i64 0, i64 1
  store ptr %675, ptr %32, align 8, !tbaa !5
  %676 = load ptr, ptr %675, align 8, !tbaa !5
  %677 = icmp ne ptr %676, null
  br i1 %677, label %684, label %678

678:                                              ; preds = %672
  %679 = load ptr, ptr %29, align 8, !tbaa !5
  %680 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %679, i32 0, i32 4
  %681 = getelementptr inbounds [2 x ptr], ptr %680, i64 0, i64 0
  store ptr %681, ptr %32, align 8, !tbaa !5
  %682 = load ptr, ptr %681, align 8, !tbaa !5
  %683 = icmp ne ptr %682, null
  br label %684

684:                                              ; preds = %678, %672
  %685 = phi i1 [ true, %672 ], [ %683, %678 ]
  br i1 %685, label %686, label %689

686:                                              ; preds = %684
  %687 = load ptr, ptr %32, align 8, !tbaa !5
  store ptr %687, ptr %31, align 8, !tbaa !5
  %688 = load ptr, ptr %687, align 8, !tbaa !5
  store ptr %688, ptr %29, align 8, !tbaa !5
  br label %672, !llvm.loop !36

689:                                              ; preds = %684
  %690 = load ptr, ptr %31, align 8, !tbaa !5
  %691 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %692 = icmp uge ptr %690, %691
  %693 = zext i1 %692 to i32
  %694 = sext i32 %693 to i64
  %695 = call i64 @llvm.expect.i64(i64 %694, i64 1)
  %696 = icmp ne i64 %695, 0
  br i1 %696, label %697, label %699

697:                                              ; preds = %689
  %698 = load ptr, ptr %31, align 8, !tbaa !5
  store ptr null, ptr %698, align 8, !tbaa !5
  br label %700

699:                                              ; preds = %689
  call void @abort() #7
  unreachable

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

701:                                              ; preds = %700, %665
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #6
  br label %702

702:                                              ; preds = %701, %658
  %703 = load ptr, ptr %28, align 8, !tbaa !5
  %704 = icmp ne ptr %703, null
  br i1 %704, label %705, label %822

705:                                              ; preds = %702
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #6
  %706 = load ptr, ptr %27, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %706, i32 0, i32 6
  %708 = load i32, ptr %707, align 8, !tbaa !30
  %709 = zext i32 %708 to i64
  %710 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %709
  store ptr %710, ptr %33, align 8, !tbaa !5
  %711 = load ptr, ptr %27, align 8, !tbaa !5
  %712 = load ptr, ptr %33, align 8, !tbaa !5
  %713 = load ptr, ptr %712, align 8, !tbaa !5
  %714 = icmp eq ptr %711, %713
  br i1 %714, label %715, label %728

715:                                              ; preds = %705
  %716 = load ptr, ptr %29, align 8, !tbaa !5
  %717 = load ptr, ptr %33, align 8, !tbaa !5
  store ptr %716, ptr %717, align 8, !tbaa !5
  %718 = icmp eq ptr %716, null
  br i1 %718, label %719, label %727

719:                                              ; preds = %715
  %720 = load ptr, ptr %27, align 8, !tbaa !5
  %721 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %720, i32 0, i32 6
  %722 = load i32, ptr %721, align 8, !tbaa !30
  %723 = shl i32 1, %722
  %724 = xor i32 %723, -1
  %725 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %726 = and i32 %725, %724
  store i32 %726, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  br label %727

727:                                              ; preds = %719, %715
  br label %756

728:                                              ; preds = %705
  %729 = load ptr, ptr %28, align 8, !tbaa !5
  %730 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %731 = icmp uge ptr %729, %730
  %732 = zext i1 %731 to i32
  %733 = sext i32 %732 to i64
  %734 = call i64 @llvm.expect.i64(i64 %733, i64 1)
  %735 = icmp ne i64 %734, 0
  br i1 %735, label %736, label %754

736:                                              ; preds = %728
  %737 = load ptr, ptr %28, align 8, !tbaa !5
  %738 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %737, i32 0, i32 4
  %739 = getelementptr inbounds [2 x ptr], ptr %738, i64 0, i64 0
  %740 = load ptr, ptr %739, align 8, !tbaa !5
  %741 = load ptr, ptr %27, align 8, !tbaa !5
  %742 = icmp eq ptr %740, %741
  br i1 %742, label %743, label %748

743:                                              ; preds = %736
  %744 = load ptr, ptr %29, align 8, !tbaa !5
  %745 = load ptr, ptr %28, align 8, !tbaa !5
  %746 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %745, i32 0, i32 4
  %747 = getelementptr inbounds [2 x ptr], ptr %746, i64 0, i64 0
  store ptr %744, ptr %747, align 8, !tbaa !5
  br label %753

748:                                              ; preds = %736
  %749 = load ptr, ptr %29, align 8, !tbaa !5
  %750 = load ptr, ptr %28, align 8, !tbaa !5
  %751 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %750, i32 0, i32 4
  %752 = getelementptr inbounds [2 x ptr], ptr %751, i64 0, i64 1
  store ptr %749, ptr %752, align 8, !tbaa !5
  br label %753

753:                                              ; preds = %748, %743
  br label %755

754:                                              ; preds = %728
  call void @abort() #7
  unreachable

755:                                              ; preds = %753
  br label %756

756:                                              ; preds = %755, %727
  %757 = load ptr, ptr %29, align 8, !tbaa !5
  %758 = icmp ne ptr %757, null
  br i1 %758, label %759, label %821

759:                                              ; preds = %756
  %760 = load ptr, ptr %29, align 8, !tbaa !5
  %761 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %762 = icmp uge ptr %760, %761
  %763 = zext i1 %762 to i32
  %764 = sext i32 %763 to i64
  %765 = call i64 @llvm.expect.i64(i64 %764, i64 1)
  %766 = icmp ne i64 %765, 0
  br i1 %766, label %767, label %819

767:                                              ; preds = %759
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #6
  %768 = load ptr, ptr %28, align 8, !tbaa !5
  %769 = load ptr, ptr %29, align 8, !tbaa !5
  %770 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %769, i32 0, i32 5
  store ptr %768, ptr %770, align 8, !tbaa !24
  %771 = load ptr, ptr %27, align 8, !tbaa !5
  %772 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %771, i32 0, i32 4
  %773 = getelementptr inbounds [2 x ptr], ptr %772, i64 0, i64 0
  %774 = load ptr, ptr %773, align 8, !tbaa !5
  store ptr %774, ptr %34, align 8, !tbaa !5
  %775 = icmp ne ptr %774, null
  br i1 %775, label %776, label %794

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

784:                                              ; preds = %776
  %785 = load ptr, ptr %34, align 8, !tbaa !5
  %786 = load ptr, ptr %29, align 8, !tbaa !5
  %787 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %786, i32 0, i32 4
  %788 = getelementptr inbounds [2 x ptr], ptr %787, i64 0, i64 0
  store ptr %785, ptr %788, align 8, !tbaa !5
  %789 = load ptr, ptr %29, align 8, !tbaa !5
  %790 = load ptr, ptr %34, align 8, !tbaa !5
  %791 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %790, i32 0, i32 5
  store ptr %789, ptr %791, align 8, !tbaa !24
  br label %793

792:                                              ; preds = %776
  call void @abort() #7
  unreachable

793:                                              ; preds = %784
  br label %794

794:                                              ; preds = %793, %767
  %795 = load ptr, ptr %27, align 8, !tbaa !5
  %796 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %795, i32 0, i32 4
  %797 = getelementptr inbounds [2 x ptr], ptr %796, i64 0, i64 1
  %798 = load ptr, ptr %797, align 8, !tbaa !5
  store ptr %798, ptr %35, align 8, !tbaa !5
  %799 = icmp ne ptr %798, null
  br i1 %799, label %800, label %818

800:                                              ; preds = %794
  %801 = load ptr, ptr %35, align 8, !tbaa !5
  %802 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %803 = icmp uge ptr %801, %802
  %804 = zext i1 %803 to i32
  %805 = sext i32 %804 to i64
  %806 = call i64 @llvm.expect.i64(i64 %805, i64 1)
  %807 = icmp ne i64 %806, 0
  br i1 %807, label %808, label %816

808:                                              ; preds = %800
  %809 = load ptr, ptr %35, align 8, !tbaa !5
  %810 = load ptr, ptr %29, align 8, !tbaa !5
  %811 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %810, i32 0, i32 4
  %812 = getelementptr inbounds [2 x ptr], ptr %811, i64 0, i64 1
  store ptr %809, ptr %812, align 8, !tbaa !5
  %813 = load ptr, ptr %29, align 8, !tbaa !5
  %814 = load ptr, ptr %35, align 8, !tbaa !5
  %815 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %814, i32 0, i32 5
  store ptr %813, ptr %815, align 8, !tbaa !24
  br label %817

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

817:                                              ; preds = %808
  br label %818

818:                                              ; preds = %817, %794
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #6
  br label %820

819:                                              ; preds = %759
  call void @abort() #7
  unreachable

820:                                              ; preds = %818
  br label %821

821:                                              ; preds = %820, %756
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #6
  br label %822

822:                                              ; preds = %821, %702
  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 %823

823:                                              ; preds = %822, %611
  %824 = load i64, ptr %4, align 8, !tbaa !16
  %825 = or i64 %824, 1
  %826 = load ptr, ptr %3, align 8, !tbaa !5
  %827 = getelementptr inbounds %struct.malloc_chunk, ptr %826, i32 0, i32 1
  store i64 %825, ptr %827, align 8, !tbaa !14
  %828 = load i64, ptr %4, align 8, !tbaa !16
  %829 = load ptr, ptr %3, align 8, !tbaa !5
  %830 = load i64, ptr %4, align 8, !tbaa !16
  %831 = getelementptr inbounds i8, ptr %829, i64 %830
  %832 = getelementptr inbounds %struct.malloc_chunk, ptr %831, i32 0, i32 0
  store i64 %828, ptr %832, align 8, !tbaa !17
  %833 = load ptr, ptr %3, align 8, !tbaa !5
  %834 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 5), align 8, !tbaa !19
  %835 = icmp eq ptr %833, %834
  br i1 %835, label %836, label %838

836:                                              ; preds = %823
  %837 = load i64, ptr %4, align 8, !tbaa !16
  store i64 %837, 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 %839

838:                                              ; preds = %823
  store i32 0, ptr %20, align 4
  br label %839

839:                                              ; preds = %838, %836
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #6
  %840 = load i32, ptr %20, align 4
  switch i32 %840, label %1077 [
    i32 0, label %841
  ]

841:                                              ; preds = %839
  br label %842

842:                                              ; preds = %841
  br label %843

843:                                              ; preds = %842
  br label %858

844:                                              ; preds = %472
  %845 = load ptr, ptr %5, align 8, !tbaa !5
  %846 = getelementptr inbounds %struct.malloc_chunk, ptr %845, i32 0, i32 1
  %847 = load i64, ptr %846, align 8, !tbaa !14
  %848 = and i64 %847, -2
  store i64 %848, ptr %846, align 8, !tbaa !14
  %849 = load i64, ptr %4, align 8, !tbaa !16
  %850 = or i64 %849, 1
  %851 = load ptr, ptr %3, align 8, !tbaa !5
  %852 = getelementptr inbounds %struct.malloc_chunk, ptr %851, i32 0, i32 1
  store i64 %850, ptr %852, align 8, !tbaa !14
  %853 = load i64, ptr %4, align 8, !tbaa !16
  %854 = load ptr, ptr %3, align 8, !tbaa !5
  %855 = load i64, ptr %4, align 8, !tbaa !16
  %856 = getelementptr inbounds i8, ptr %854, i64 %855
  %857 = getelementptr inbounds %struct.malloc_chunk, ptr %856, i32 0, i32 0
  store i64 %853, ptr %857, align 8, !tbaa !17
  br label %858

858:                                              ; preds = %844, %843
  %859 = load i64, ptr %4, align 8, !tbaa !16
  %860 = lshr i64 %859, 3
  %861 = icmp ult i64 %860, 32
  br i1 %861, label %862, label %910

862:                                              ; preds = %858
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #6
  %863 = load i64, ptr %4, align 8, !tbaa !16
  %864 = lshr i64 %863, 3
  %865 = trunc i64 %864 to i32
  store i32 %865, ptr %36, align 4, !tbaa !22
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #6
  %866 = load i32, ptr %36, align 4, !tbaa !22
  %867 = shl i32 %866, 1
  %868 = zext i32 %867 to i64
  %869 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 10), i64 0, i64 %868
  store ptr %869, ptr %37, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #6
  %870 = load ptr, ptr %37, align 8, !tbaa !5
  store ptr %870, ptr %38, align 8, !tbaa !5
  %871 = load i32, ptr @_gm_, align 8, !tbaa !23
  %872 = load i32, ptr %36, align 4, !tbaa !22
  %873 = shl i32 1, %872
  %874 = and i32 %871, %873
  %875 = icmp ne i32 %874, 0
  br i1 %875, label %881, label %876

876:                                              ; preds = %862
  %877 = load i32, ptr %36, align 4, !tbaa !22
  %878 = shl i32 1, %877
  %879 = load i32, ptr @_gm_, align 8, !tbaa !23
  %880 = or i32 %879, %878
  store i32 %880, ptr @_gm_, align 8, !tbaa !23
  br label %897

881:                                              ; preds = %862
  %882 = load ptr, ptr %37, align 8, !tbaa !5
  %883 = getelementptr inbounds %struct.malloc_chunk, ptr %882, i32 0, i32 2
  %884 = load ptr, ptr %883, align 8, !tbaa !20
  %885 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %886 = icmp uge ptr %884, %885
  %887 = zext i1 %886 to i32
  %888 = sext i32 %887 to i64
  %889 = call i64 @llvm.expect.i64(i64 %888, i64 1)
  %890 = icmp ne i64 %889, 0
  br i1 %890, label %891, label %895

891:                                              ; preds = %881
  %892 = load ptr, ptr %37, align 8, !tbaa !5
  %893 = getelementptr inbounds %struct.malloc_chunk, ptr %892, i32 0, i32 2
  %894 = load ptr, ptr %893, align 8, !tbaa !20
  store ptr %894, ptr %38, align 8, !tbaa !5
  br label %896

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

896:                                              ; preds = %891
  br label %897

897:                                              ; preds = %896, %876
  %898 = load ptr, ptr %3, align 8, !tbaa !5
  %899 = load ptr, ptr %37, align 8, !tbaa !5
  %900 = getelementptr inbounds %struct.malloc_chunk, ptr %899, i32 0, i32 2
  store ptr %898, ptr %900, align 8, !tbaa !20
  %901 = load ptr, ptr %3, align 8, !tbaa !5
  %902 = load ptr, ptr %38, align 8, !tbaa !5
  %903 = getelementptr inbounds %struct.malloc_chunk, ptr %902, i32 0, i32 3
  store ptr %901, ptr %903, align 8, !tbaa !21
  %904 = load ptr, ptr %38, align 8, !tbaa !5
  %905 = load ptr, ptr %3, align 8, !tbaa !5
  %906 = getelementptr inbounds %struct.malloc_chunk, ptr %905, i32 0, i32 2
  store ptr %904, ptr %906, align 8, !tbaa !20
  %907 = load ptr, ptr %37, align 8, !tbaa !5
  %908 = load ptr, ptr %3, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.malloc_chunk, ptr %908, i32 0, i32 3
  store ptr %907, ptr %909, 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 %1075

910:                                              ; preds = %858
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #6
  %911 = load ptr, ptr %3, align 8, !tbaa !5
  store ptr %911, 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
  %912 = load i64, ptr %4, align 8, !tbaa !16
  %913 = lshr i64 %912, 8
  %914 = trunc i64 %913 to i32
  store i32 %914, ptr %42, align 4, !tbaa !22
  %915 = load i32, ptr %42, align 4, !tbaa !22
  %916 = icmp eq i32 %915, 0
  br i1 %916, label %917, label %918

917:                                              ; preds = %910
  store i32 0, ptr %41, align 4, !tbaa !22
  br label %938

918:                                              ; preds = %910
  %919 = load i32, ptr %42, align 4, !tbaa !22
  %920 = icmp ugt i32 %919, 65535
  br i1 %920, label %921, label %922

921:                                              ; preds = %918
  store i32 31, ptr %41, align 4, !tbaa !22
  br label %937

922:                                              ; preds = %918
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #6
  %923 = load i32, ptr %42, align 4, !tbaa !22
  %924 = call i32 @llvm.ctlz.i32(i32 %923, i1 true)
  %925 = sub i32 31, %924
  store i32 %925, ptr %43, align 4, !tbaa !22
  %926 = load i32, ptr %43, align 4, !tbaa !22
  %927 = shl i32 %926, 1
  %928 = zext i32 %927 to i64
  %929 = load i64, ptr %4, align 8, !tbaa !16
  %930 = load i32, ptr %43, align 4, !tbaa !22
  %931 = add i32 %930, 7
  %932 = zext i32 %931 to i64
  %933 = lshr i64 %929, %932
  %934 = and i64 %933, 1
  %935 = add i64 %928, %934
  %936 = trunc i64 %935 to i32
  store i32 %936, ptr %41, align 4, !tbaa !22
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #6
  br label %937

937:                                              ; preds = %922, %921
  br label %938

938:                                              ; preds = %937, %917
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #6
  %939 = load i32, ptr %41, align 4, !tbaa !22
  %940 = zext i32 %939 to i64
  %941 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 11), i64 0, i64 %940
  store ptr %941, ptr %40, align 8, !tbaa !5
  %942 = load i32, ptr %41, align 4, !tbaa !22
  %943 = load ptr, ptr %39, align 8, !tbaa !5
  %944 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %943, i32 0, i32 6
  store i32 %942, ptr %944, align 8, !tbaa !30
  %945 = load ptr, ptr %39, align 8, !tbaa !5
  %946 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %945, i32 0, i32 4
  %947 = getelementptr inbounds [2 x ptr], ptr %946, i64 0, i64 1
  store ptr null, ptr %947, align 8, !tbaa !5
  %948 = load ptr, ptr %39, align 8, !tbaa !5
  %949 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %948, i32 0, i32 4
  %950 = getelementptr inbounds [2 x ptr], ptr %949, i64 0, i64 0
  store ptr null, ptr %950, align 8, !tbaa !5
  %951 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %952 = load i32, ptr %41, align 4, !tbaa !22
  %953 = shl i32 1, %952
  %954 = and i32 %951, %953
  %955 = icmp ne i32 %954, 0
  br i1 %955, label %971, label %956

956:                                              ; preds = %938
  %957 = load i32, ptr %41, align 4, !tbaa !22
  %958 = shl i32 1, %957
  %959 = load i32, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %960 = or i32 %959, %958
  store i32 %960, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 1), align 4, !tbaa !31
  %961 = load ptr, ptr %39, align 8, !tbaa !5
  %962 = load ptr, ptr %40, align 8, !tbaa !5
  store ptr %961, ptr %962, align 8, !tbaa !5
  %963 = load ptr, ptr %40, align 8, !tbaa !5
  %964 = load ptr, ptr %39, align 8, !tbaa !5
  %965 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %964, i32 0, i32 5
  store ptr %963, ptr %965, align 8, !tbaa !24
  %966 = load ptr, ptr %39, align 8, !tbaa !5
  %967 = load ptr, ptr %39, align 8, !tbaa !5
  %968 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %967, i32 0, i32 3
  store ptr %966, ptr %968, align 8, !tbaa !26
  %969 = load ptr, ptr %39, align 8, !tbaa !5
  %970 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %969, i32 0, i32 2
  store ptr %966, ptr %970, align 8, !tbaa !27
  br label %1068

971:                                              ; preds = %938
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #6
  %972 = load ptr, ptr %40, align 8, !tbaa !5
  %973 = load ptr, ptr %972, align 8, !tbaa !5
  store ptr %973, ptr %44, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #6
  %974 = load i64, ptr %4, align 8, !tbaa !16
  %975 = load i32, ptr %41, align 4, !tbaa !22
  %976 = icmp eq i32 %975, 31
  br i1 %976, label %977, label %978

977:                                              ; preds = %971
  br label %985

978:                                              ; preds = %971
  %979 = load i32, ptr %41, align 4, !tbaa !22
  %980 = lshr i32 %979, 1
  %981 = add i32 %980, 8
  %982 = sub i32 %981, 2
  %983 = zext i32 %982 to i64
  %984 = sub i64 63, %983
  br label %985

985:                                              ; preds = %978, %977
  %986 = phi i64 [ 0, %977 ], [ %984, %978 ]
  %987 = shl i64 %974, %986
  store i64 %987, ptr %45, align 8, !tbaa !16
  br label %988

988:                                              ; preds = %1066, %985
  %989 = load ptr, ptr %44, align 8, !tbaa !5
  %990 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %989, i32 0, i32 1
  %991 = load i64, ptr %990, align 8, !tbaa !37
  %992 = and i64 %991, -8
  %993 = load i64, ptr %4, align 8, !tbaa !16
  %994 = icmp ne i64 %992, %993
  br i1 %994, label %995, label %1034

995:                                              ; preds = %988
  call void @llvm.lifetime.start.p0(i64 8, ptr %46) #6
  %996 = load ptr, ptr %44, align 8, !tbaa !5
  %997 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %996, i32 0, i32 4
  %998 = load i64, ptr %45, align 8, !tbaa !16
  %999 = lshr i64 %998, 63
  %1000 = and i64 %999, 1
  %1001 = getelementptr inbounds [2 x ptr], ptr %997, i64 0, i64 %1000
  store ptr %1001, ptr %46, align 8, !tbaa !5
  %1002 = load i64, ptr %45, align 8, !tbaa !16
  %1003 = shl i64 %1002, 1
  store i64 %1003, ptr %45, align 8, !tbaa !16
  %1004 = load ptr, ptr %46, align 8, !tbaa !5
  %1005 = load ptr, ptr %1004, align 8, !tbaa !5
  %1006 = icmp ne ptr %1005, null
  br i1 %1006, label %1007, label %1010

1007:                                             ; preds = %995
  %1008 = load ptr, ptr %46, align 8, !tbaa !5
  %1009 = load ptr, ptr %1008, align 8, !tbaa !5
  store ptr %1009, ptr %44, align 8, !tbaa !5
  br label %1030

1010:                                             ; preds = %995
  %1011 = load ptr, ptr %46, align 8, !tbaa !5
  %1012 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1013 = icmp uge ptr %1011, %1012
  %1014 = zext i1 %1013 to i32
  %1015 = sext i32 %1014 to i64
  %1016 = call i64 @llvm.expect.i64(i64 %1015, i64 1)
  %1017 = icmp ne i64 %1016, 0
  br i1 %1017, label %1018, label %1029

1018:                                             ; preds = %1010
  %1019 = load ptr, ptr %39, align 8, !tbaa !5
  %1020 = load ptr, ptr %46, align 8, !tbaa !5
  store ptr %1019, ptr %1020, align 8, !tbaa !5
  %1021 = load ptr, ptr %44, align 8, !tbaa !5
  %1022 = load ptr, ptr %39, align 8, !tbaa !5
  %1023 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1022, i32 0, i32 5
  store ptr %1021, ptr %1023, align 8, !tbaa !24
  %1024 = load ptr, ptr %39, align 8, !tbaa !5
  %1025 = load ptr, ptr %39, align 8, !tbaa !5
  %1026 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1025, i32 0, i32 3
  store ptr %1024, ptr %1026, align 8, !tbaa !26
  %1027 = load ptr, ptr %39, align 8, !tbaa !5
  %1028 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1027, i32 0, i32 2
  store ptr %1024, ptr %1028, align 8, !tbaa !27
  store i32 8, ptr %20, align 4
  br label %1031

1029:                                             ; preds = %1010
  call void @abort() #7
  unreachable

1030:                                             ; preds = %1007
  store i32 0, ptr %20, align 4
  br label %1031

1031:                                             ; preds = %1030, %1018
  call void @llvm.lifetime.end.p0(i64 8, ptr %46) #6
  %1032 = load i32, ptr %20, align 4
  switch i32 %1032, label %1084 [
    i32 0, label %1033
    i32 8, label %1067
  ]

1033:                                             ; preds = %1031
  br label %1066

1034:                                             ; preds = %988
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #6
  %1035 = load ptr, ptr %44, align 8, !tbaa !5
  %1036 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1035, i32 0, i32 2
  %1037 = load ptr, ptr %1036, align 8, !tbaa !27
  store ptr %1037, ptr %47, align 8, !tbaa !5
  %1038 = load ptr, ptr %44, align 8, !tbaa !5
  %1039 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1040 = icmp uge ptr %1038, %1039
  br i1 %1040, label %1041, label %1045

1041:                                             ; preds = %1034
  %1042 = load ptr, ptr %47, align 8, !tbaa !5
  %1043 = load ptr, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 4), align 8, !tbaa !9
  %1044 = icmp uge ptr %1042, %1043
  br label %1045

1045:                                             ; preds = %1041, %1034
  %1046 = phi i1 [ false, %1034 ], [ %1044, %1041 ]
  %1047 = zext i1 %1046 to i32
  %1048 = sext i32 %1047 to i64
  %1049 = call i64 @llvm.expect.i64(i64 %1048, i64 1)
  %1050 = icmp ne i64 %1049, 0
  br i1 %1050, label %1051, label %1065

1051:                                             ; preds = %1045
  %1052 = load ptr, ptr %39, align 8, !tbaa !5
  %1053 = load ptr, ptr %47, align 8, !tbaa !5
  %1054 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1053, i32 0, i32 3
  store ptr %1052, ptr %1054, align 8, !tbaa !26
  %1055 = load ptr, ptr %44, align 8, !tbaa !5
  %1056 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1055, i32 0, i32 2
  store ptr %1052, ptr %1056, align 8, !tbaa !27
  %1057 = load ptr, ptr %47, align 8, !tbaa !5
  %1058 = load ptr, ptr %39, align 8, !tbaa !5
  %1059 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1058, i32 0, i32 2
  store ptr %1057, ptr %1059, align 8, !tbaa !27
  %1060 = load ptr, ptr %44, align 8, !tbaa !5
  %1061 = load ptr, ptr %39, align 8, !tbaa !5
  %1062 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1061, i32 0, i32 3
  store ptr %1060, ptr %1062, align 8, !tbaa !26
  %1063 = load ptr, ptr %39, align 8, !tbaa !5
  %1064 = getelementptr inbounds %struct.malloc_tree_chunk, ptr %1063, i32 0, i32 5
  store ptr null, ptr %1064, align 8, !tbaa !24
  store i32 8, ptr %20, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #6
  br label %1067

1065:                                             ; preds = %1045
  call void @abort() #7
  unreachable

1066:                                             ; preds = %1033
  br label %988

1067:                                             ; preds = %1051, %1031
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #6
  br label %1068

1068:                                             ; preds = %1067, %956
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #6
  %1069 = load i64, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !38
  %1070 = add i64 %1069, -1
  store i64 %1070, ptr getelementptr inbounds (%struct.malloc_state, ptr @_gm_, i32 0, i32 8), align 8, !tbaa !38
  %1071 = icmp eq i64 %1070, 0
  br i1 %1071, label %1072, label %1074

1072:                                             ; preds = %1068
  %1073 = call i64 @release_unused_segments(ptr noundef @_gm_)
  br label %1074

1074:                                             ; preds = %1072, %1068
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #6
  br label %1075

1075:                                             ; preds = %1074, %897
  store i32 2, ptr %20, align 4
  br label %1077

1076:                                             ; preds = %466
  store i32 0, ptr %20, align 4
  br label %1077

1077:                                             ; preds = %1076, %1075, %839, %506, %501, %453
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #6
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #6
  %1078 = load i32, ptr %20, align 4
  switch i32 %1078, label %1084 [
    i32 0, label %1079
    i32 5, label %1081
    i32 2, label %1082
  ]

1079:                                             ; preds = %1077
  br label %1080

1080:                                             ; preds = %1079, %62
  br label %1081

1081:                                             ; preds = %1080, %1077
  call void @abort() #7
  unreachable

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

1083:                                             ; preds = %1082, %1
  ret void

1084:                                             ; preds = %1077, %1031
  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 = { nocallback nofree nosync nounwind willreturn memory(none) }
attributes #2 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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

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

; Function Attrs: nounwind uwtable
define dso_local void @dlfree(ptr noundef %0) local_unnamed_addr #1 {
  %.not = icmp eq ptr %0, null
  br i1 %.not, label %.critedge407.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
  %.not348 = icmp ult ptr %3, %4
  br i1 %.not348, label %.critedge395, 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
  %.not434 = icmp eq i64 %8, 1
  br i1 %.not434, label %.critedge395, 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
  %.not349 = icmp eq i64 %12, 0
  br i1 %.not349, 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 %.critedge407.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 %.critedge407.thread

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

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

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

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
  %42 = shl nuw nsw i64 %36, 1
  %43 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %42
  %44 = icmp eq ptr %38, %43
  br i1 %44, label %.critedge397, label %45

45:                                               ; preds = %35
  %.not367 = icmp ult ptr %38, %4
  br i1 %.not367, label %.critedge399, label %46

46:                                               ; preds = %45
  %47 = getelementptr inbounds i8, ptr %38, i64 24
  %48 = load ptr, ptr %47, align 8, !tbaa !20
  %49 = icmp eq ptr %48, %29
  br i1 %49, label %.critedge397, label %.critedge399, !prof !21

.critedge397:                                     ; preds = %35, %46
  %50 = icmp eq ptr %40, %38
  br i1 %50, label %51, label %56

51:                                               ; preds = %.critedge397
  %52 = shl nuw i32 1, %41
  %53 = xor i32 %52, -1
  %54 = load i32, ptr @_gm_, align 8, !tbaa !22
  %55 = and i32 %54, %53
  store i32 %55, ptr @_gm_, align 8, !tbaa !22
  br label %.thread

56:                                               ; preds = %.critedge397
  %57 = icmp eq ptr %40, %43
  br i1 %57, label %.critedge401, label %58

58:                                               ; preds = %56
  %.not368 = icmp ult ptr %40, %4
  br i1 %.not368, label %.critedge403, label %59

59:                                               ; preds = %58
  %60 = getelementptr inbounds i8, ptr %40, i64 16
  %61 = load ptr, ptr %60, align 8, !tbaa !19
  %62 = icmp eq ptr %61, %29
  br i1 %62, label %.critedge401, label %.critedge403, !prof !21

.critedge401:                                     ; preds = %56, %59
  %63 = getelementptr inbounds i8, ptr %38, i64 24
  store ptr %40, ptr %63, align 8, !tbaa !20
  %64 = getelementptr inbounds i8, ptr %40, i64 16
  store ptr %38, ptr %64, align 8, !tbaa !19
  br label %.thread

.critedge403:                                     ; preds = %58, %59
  tail call void @abort() #6
  unreachable

.critedge399:                                     ; preds = %45, %46
  tail call void @abort() #6
  unreachable

65:                                               ; preds = %33
  %66 = getelementptr inbounds i8, ptr %29, i64 48
  %67 = load ptr, ptr %66, align 8, !tbaa !23
  %68 = getelementptr inbounds i8, ptr %29, i64 24
  %69 = load ptr, ptr %68, align 8, !tbaa !25
  %.not352 = icmp eq ptr %69, %29
  br i1 %.not352, label %82, label %70

70:                                               ; preds = %65
  %71 = getelementptr inbounds i8, ptr %29, i64 16
  %72 = load ptr, ptr %71, align 8, !tbaa !26
  %.not358 = icmp ult ptr %72, %4
  br i1 %.not358, label %.critedge405, label %73, !prof !13

73:                                               ; preds = %70
  %74 = getelementptr inbounds i8, ptr %72, i64 24
  %75 = load ptr, ptr %74, align 8, !tbaa !25
  %76 = icmp eq ptr %75, %29
  br i1 %76, label %77, label %.critedge405, !prof !21

77:                                               ; preds = %73
  %78 = getelementptr inbounds i8, ptr %69, i64 16
  %79 = load ptr, ptr %78, align 8, !tbaa !26
  %80 = icmp eq ptr %79, %29
  br i1 %80, label %81, label %.critedge405, !prof !21

81:                                               ; preds = %77
  store ptr %69, ptr %74, align 8, !tbaa !25
  store ptr %72, ptr %78, align 8, !tbaa !26
  br label %96

.critedge405:                                     ; preds = %73, %70, %77
  tail call void @abort() #6
  unreachable

82:                                               ; preds = %65
  %83 = getelementptr inbounds i8, ptr %29, i64 40
  %84 = load ptr, ptr %83, align 8, !tbaa !27
  %.not353 = icmp eq ptr %84, null
  br i1 %.not353, label %85, label %.critedge.preheader

85:                                               ; preds = %82
  %86 = getelementptr inbounds i8, ptr %29, i64 32
  %87 = load ptr, ptr %86, align 8, !tbaa !27
  %.not354 = icmp eq ptr %87, null
  br i1 %.not354, label %96, label %.critedge.preheader

.critedge.preheader:                              ; preds = %85, %82
  %.1297.ph = phi ptr [ %86, %85 ], [ %83, %82 ]
  %.1294.ph = phi ptr [ %87, %85 ], [ %84, %82 ]
  br label %.critedge

.critedge:                                        ; preds = %.critedge.backedge, %.critedge.preheader
  %.1297 = phi ptr [ %.1297.ph, %.critedge.preheader ], [ %.1297.be, %.critedge.backedge ]
  %.1294 = phi ptr [ %.1294.ph, %.critedge.preheader ], [ %.1294.be, %.critedge.backedge ]
  %88 = getelementptr inbounds i8, ptr %.1294, i64 40
  %89 = load ptr, ptr %88, align 8, !tbaa !27
  %.not355 = icmp eq ptr %89, null
  br i1 %.not355, label %90, label %.critedge.backedge

.critedge.backedge:                               ; preds = %.critedge, %90
  %.1297.be = phi ptr [ %88, %.critedge ], [ %91, %90 ]
  %.1294.be = phi ptr [ %89, %.critedge ], [ %92, %90 ]
  br label %.critedge, !llvm.loop !28

90:                                               ; preds = %.critedge
  %91 = getelementptr inbounds i8, ptr %.1294, i64 32
  %92 = load ptr, ptr %91, align 8, !tbaa !27
  %.not356 = icmp eq ptr %92, null
  br i1 %.not356, label %93, label %.critedge.backedge

93:                                               ; preds = %90
  %.not357 = icmp ult ptr %.1297, %4
  br i1 %.not357, label %95, label %94, !prof !13

94:                                               ; preds = %93
  store ptr null, ptr %.1297, align 8, !tbaa !27
  br label %96

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

96:                                               ; preds = %85, %94, %81
  %.3 = phi ptr [ %69, %81 ], [ %.1294, %94 ], [ null, %85 ]
  %.not359 = icmp eq ptr %67, null
  br i1 %.not359, label %.thread, label %97

97:                                               ; preds = %96
  %98 = getelementptr inbounds i8, ptr %29, i64 56
  %99 = load i32, ptr %98, align 8, !tbaa !30
  %100 = zext i32 %99 to i64
  %101 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %100
  %102 = load ptr, ptr %101, align 8, !tbaa !27
  %103 = icmp eq ptr %29, %102
  br i1 %103, label %104, label %109

104:                                              ; preds = %97
  store ptr %.3, ptr %101, align 8, !tbaa !27
  %cond = icmp eq ptr %.3, null
  br i1 %cond, label %.thread441, label %117

.thread441:                                       ; preds = %104
  %105 = shl nuw i32 1, %99
  %106 = xor i32 %105, -1
  %107 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %108 = and i32 %107, %106
  store i32 %108, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %.thread

109:                                              ; preds = %97
  %110 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not360 = icmp ult ptr %67, %110
  br i1 %.not360, label %116, label %111, !prof !13

111:                                              ; preds = %109
  %112 = getelementptr inbounds i8, ptr %67, i64 32
  %113 = load ptr, ptr %112, align 8, !tbaa !27
  %114 = icmp eq ptr %113, %29
  %115 = getelementptr inbounds i8, ptr %67, i64 40
  %.sink = select i1 %114, ptr %112, ptr %115
  store ptr %.3, ptr %.sink, align 8, !tbaa !27
  %.not361 = icmp eq ptr %.3, null
  br i1 %.not361, label %.thread, label %117

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

117:                                              ; preds = %104, %111
  %118 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not362 = icmp ult ptr %.3, %118
  br i1 %.not362, label %136, label %119, !prof !13

119:                                              ; preds = %117
  %120 = getelementptr inbounds i8, ptr %.3, i64 48
  store ptr %67, ptr %120, align 8, !tbaa !23
  %121 = getelementptr inbounds i8, ptr %29, i64 32
  %122 = load ptr, ptr %121, align 8, !tbaa !27
  %.not363 = icmp eq ptr %122, null
  br i1 %.not363, label %128, label %123

123:                                              ; preds = %119
  %.not364 = icmp ult ptr %122, %118
  br i1 %.not364, label %127, label %124, !prof !13

124:                                              ; preds = %123
  %125 = getelementptr inbounds i8, ptr %.3, i64 32
  store ptr %122, ptr %125, align 8, !tbaa !27
  %126 = getelementptr inbounds i8, ptr %122, i64 48
  store ptr %.3, ptr %126, align 8, !tbaa !23
  br label %128

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

128:                                              ; preds = %124, %119
  %129 = getelementptr inbounds i8, ptr %29, i64 40
  %130 = load ptr, ptr %129, align 8, !tbaa !27
  %.not365 = icmp eq ptr %130, null
  br i1 %.not365, label %.thread, label %131

131:                                              ; preds = %128
  %.not366 = icmp ult ptr %130, %118
  br i1 %.not366, label %135, label %132, !prof !13

132:                                              ; preds = %131
  %133 = getelementptr inbounds i8, ptr %.3, i64 40
  store ptr %130, ptr %133, align 8, !tbaa !27
  %134 = getelementptr inbounds i8, ptr %130, i64 48
  store ptr %.3, ptr %134, align 8, !tbaa !23
  br label %.thread

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

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

137:                                              ; preds = %31
  %138 = getelementptr inbounds i8, ptr %11, i64 8
  %139 = load i64, ptr %138, align 8, !tbaa !14
  %140 = and i64 %139, 3
  %141 = icmp eq i64 %140, 3
  br i1 %141, label %142, label %.thread

142:                                              ; preds = %137
  store i64 %30, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  %143 = and i64 %139, -2
  store i64 %143, ptr %138, align 8, !tbaa !14
  %144 = or i64 %30, 1
  %145 = getelementptr inbounds i8, ptr %29, i64 8
  store i64 %144, ptr %145, align 8, !tbaa !14
  store i64 %30, ptr %11, align 8, !tbaa !16
  br label %.critedge407.thread

.thread:                                          ; preds = %.thread441, %137, %51, %.critedge401, %111, %132, %128, %96, %9
  %.1289 = phi i64 [ %10, %9 ], [ %30, %96 ], [ %30, %128 ], [ %30, %132 ], [ %30, %111 ], [ %30, %.critedge401 ], [ %30, %51 ], [ %30, %137 ], [ %30, %.thread441 ]
  %.1 = phi ptr [ %3, %9 ], [ %29, %96 ], [ %29, %128 ], [ %29, %132 ], [ %29, %111 ], [ %29, %.critedge401 ], [ %29, %51 ], [ %29, %137 ], [ %29, %.thread441 ]
  %146 = icmp ult ptr %.1, %11
  br i1 %146, label %147, label %.critedge395, !prof !21

147:                                              ; preds = %.thread
  %148 = getelementptr inbounds i8, ptr %11, i64 8
  %149 = load i64, ptr %148, align 8, !tbaa !14
  %150 = and i64 %149, 1
  %.not435 = icmp eq i64 %150, 0
  br i1 %.not435, label %.critedge395, label %151, !prof !13

151:                                              ; preds = %147
  %152 = and i64 %149, 2
  %.not369 = icmp eq i64 %152, 0
  br i1 %.not369, label %153, label %293

153:                                              ; preds = %151
  %154 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 40), align 8, !tbaa !33
  %155 = icmp eq ptr %11, %154
  br i1 %155, label %156, label %169

156:                                              ; preds = %153
  %157 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 16), align 8, !tbaa !34
  %158 = add i64 %157, %.1289
  store i64 %158, 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
  %159 = or i64 %158, 1
  %160 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %159, ptr %160, align 8, !tbaa !14
  %161 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %162 = icmp eq ptr %.1, %161
  br i1 %162, label %163, label %164

163:                                              ; preds = %156
  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 %164

164:                                              ; preds = %163, %156
  %165 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 48), align 8, !tbaa !35
  %166 = icmp ugt i64 %158, %165
  br i1 %166, label %167, label %.critedge407.thread

167:                                              ; preds = %164
  %168 = tail call i32 @sys_trim(ptr noundef nonnull @_gm_, i64 noundef 0)
  br label %.critedge407.thread

169:                                              ; preds = %153
  %170 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %171 = icmp eq ptr %11, %170
  br i1 %171, label %172, label %178

172:                                              ; preds = %169
  %173 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  %174 = add i64 %173, %.1289
  store i64 %174, 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
  %175 = or i64 %174, 1
  %176 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %175, ptr %176, align 8, !tbaa !14
  %177 = getelementptr inbounds i8, ptr %.1, i64 %174
  store i64 %174, ptr %177, align 8, !tbaa !16
  br label %.critedge407.thread

178:                                              ; preds = %169
  %179 = and i64 %149, -8
  %180 = add i64 %179, %.1289
  %181 = icmp ult i64 %149, 256
  br i1 %181, label %182, label %214

182:                                              ; preds = %178
  %183 = lshr i64 %149, 3
  %184 = getelementptr inbounds i8, ptr %11, i64 16
  %185 = load ptr, ptr %184, align 8, !tbaa !19
  %186 = getelementptr inbounds i8, ptr %11, i64 24
  %187 = load ptr, ptr %186, align 8, !tbaa !20
  %188 = trunc nuw nsw i64 %183 to i32
  %189 = shl nuw nsw i64 %183, 1
  %190 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %189
  %191 = icmp eq ptr %185, %190
  br i1 %191, label %.critedge409, label %192

192:                                              ; preds = %182
  %193 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not385 = icmp ult ptr %185, %193
  br i1 %.not385, label %.critedge411, label %194

194:                                              ; preds = %192
  %195 = getelementptr inbounds i8, ptr %185, i64 24
  %196 = load ptr, ptr %195, align 8, !tbaa !20
  %197 = icmp eq ptr %196, %11
  br i1 %197, label %.critedge409, label %.critedge411, !prof !21

.critedge409:                                     ; preds = %182, %194
  %198 = icmp eq ptr %187, %185
  br i1 %198, label %199, label %204

199:                                              ; preds = %.critedge409
  %200 = shl nuw i32 1, %188
  %201 = xor i32 %200, -1
  %202 = load i32, ptr @_gm_, align 8, !tbaa !22
  %203 = and i32 %202, %201
  store i32 %203, ptr @_gm_, align 8, !tbaa !22
  br label %288

204:                                              ; preds = %.critedge409
  %205 = icmp eq ptr %187, %190
  br i1 %205, label %.critedge413, label %206

206:                                              ; preds = %204
  %207 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not386 = icmp ult ptr %187, %207
  br i1 %.not386, label %.critedge415, label %208

208:                                              ; preds = %206
  %209 = getelementptr inbounds i8, ptr %187, i64 16
  %210 = load ptr, ptr %209, align 8, !tbaa !19
  %211 = icmp eq ptr %210, %11
  br i1 %211, label %.critedge413, label %.critedge415, !prof !21

.critedge413:                                     ; preds = %204, %208
  %212 = getelementptr inbounds i8, ptr %185, i64 24
  store ptr %187, ptr %212, align 8, !tbaa !20
  %213 = getelementptr inbounds i8, ptr %187, i64 16
  store ptr %185, ptr %213, align 8, !tbaa !19
  br label %288

.critedge415:                                     ; preds = %206, %208
  tail call void @abort() #6
  unreachable

.critedge411:                                     ; preds = %192, %194
  tail call void @abort() #6
  unreachable

214:                                              ; preds = %178
  %215 = getelementptr inbounds i8, ptr %11, i64 48
  %216 = load ptr, ptr %215, align 8, !tbaa !23
  %217 = getelementptr inbounds i8, ptr %11, i64 24
  %218 = load ptr, ptr %217, align 8, !tbaa !25
  %.not370 = icmp eq ptr %218, %11
  br i1 %.not370, label %232, label %219

219:                                              ; preds = %214
  %220 = getelementptr inbounds i8, ptr %11, i64 16
  %221 = load ptr, ptr %220, align 8, !tbaa !26
  %222 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not376 = icmp ult ptr %221, %222
  br i1 %.not376, label %.critedge417, label %223, !prof !13

223:                                              ; preds = %219
  %224 = getelementptr inbounds i8, ptr %221, i64 24
  %225 = load ptr, ptr %224, align 8, !tbaa !25
  %226 = icmp eq ptr %225, %11
  br i1 %226, label %227, label %.critedge417, !prof !21

227:                                              ; preds = %223
  %228 = getelementptr inbounds i8, ptr %218, i64 16
  %229 = load ptr, ptr %228, align 8, !tbaa !26
  %230 = icmp eq ptr %229, %11
  br i1 %230, label %231, label %.critedge417, !prof !21

231:                                              ; preds = %227
  store ptr %218, ptr %224, align 8, !tbaa !25
  store ptr %221, ptr %228, align 8, !tbaa !26
  br label %247

.critedge417:                                     ; preds = %223, %219, %227
  tail call void @abort() #6
  unreachable

232:                                              ; preds = %214
  %233 = getelementptr inbounds i8, ptr %11, i64 40
  %234 = load ptr, ptr %233, align 8, !tbaa !27
  %.not371 = icmp eq ptr %234, null
  br i1 %.not371, label %235, label %.critedge4.preheader

235:                                              ; preds = %232
  %236 = getelementptr inbounds i8, ptr %11, i64 32
  %237 = load ptr, ptr %236, align 8, !tbaa !27
  %.not372 = icmp eq ptr %237, null
  br i1 %.not372, label %247, label %.critedge4.preheader

.critedge4.preheader:                             ; preds = %235, %232
  %.1310.ph = phi ptr [ %236, %235 ], [ %233, %232 ]
  %.1306.ph = phi ptr [ %237, %235 ], [ %234, %232 ]
  br label %.critedge4

.critedge4:                                       ; preds = %.critedge4.backedge, %.critedge4.preheader
  %.1310 = phi ptr [ %.1310.ph, %.critedge4.preheader ], [ %.1310.be, %.critedge4.backedge ]
  %.1306 = phi ptr [ %.1306.ph, %.critedge4.preheader ], [ %.1306.be, %.critedge4.backedge ]
  %238 = getelementptr inbounds i8, ptr %.1306, i64 40
  %239 = load ptr, ptr %238, align 8, !tbaa !27
  %.not373 = icmp eq ptr %239, null
  br i1 %.not373, label %240, label %.critedge4.backedge

.critedge4.backedge:                              ; preds = %.critedge4, %240
  %.1310.be = phi ptr [ %238, %.critedge4 ], [ %241, %240 ]
  %.1306.be = phi ptr [ %239, %.critedge4 ], [ %242, %240 ]
  br label %.critedge4, !llvm.loop !36

240:                                              ; preds = %.critedge4
  %241 = getelementptr inbounds i8, ptr %.1306, i64 32
  %242 = load ptr, ptr %241, align 8, !tbaa !27
  %.not374 = icmp eq ptr %242, null
  br i1 %.not374, label %243, label %.critedge4.backedge

243:                                              ; preds = %240
  %244 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not375 = icmp ult ptr %.1310, %244
  br i1 %.not375, label %246, label %245, !prof !13

245:                                              ; preds = %243
  store ptr null, ptr %.1310, align 8, !tbaa !27
  br label %247

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

247:                                              ; preds = %235, %245, %231
  %.3308 = phi ptr [ %218, %231 ], [ %.1306, %245 ], [ null, %235 ]
  %.not377 = icmp eq ptr %216, null
  br i1 %.not377, label %288, label %248

248:                                              ; preds = %247
  %249 = getelementptr inbounds i8, ptr %11, i64 56
  %250 = load i32, ptr %249, align 8, !tbaa !30
  %251 = zext i32 %250 to i64
  %252 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %251
  %253 = load ptr, ptr %252, align 8, !tbaa !27
  %254 = icmp eq ptr %11, %253
  br i1 %254, label %255, label %260

255:                                              ; preds = %248
  store ptr %.3308, ptr %252, align 8, !tbaa !27
  %cond420 = icmp eq ptr %.3308, null
  br i1 %cond420, label %.thread443, label %268

.thread443:                                       ; preds = %255
  %256 = shl nuw i32 1, %250
  %257 = xor i32 %256, -1
  %258 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %259 = and i32 %258, %257
  store i32 %259, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %288

260:                                              ; preds = %248
  %261 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not378 = icmp ult ptr %216, %261
  br i1 %.not378, label %267, label %262, !prof !13

262:                                              ; preds = %260
  %263 = getelementptr inbounds i8, ptr %216, i64 32
  %264 = load ptr, ptr %263, align 8, !tbaa !27
  %265 = icmp eq ptr %264, %11
  %266 = getelementptr inbounds i8, ptr %216, i64 40
  %.sink448 = select i1 %265, ptr %263, ptr %266
  store ptr %.3308, ptr %.sink448, align 8, !tbaa !27
  %.not379 = icmp eq ptr %.3308, null
  br i1 %.not379, label %288, label %268

267:                                              ; preds = %260
  tail call void @abort() #6
  unreachable

268:                                              ; preds = %255, %262
  %269 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not380 = icmp ult ptr %.3308, %269
  br i1 %.not380, label %287, label %270, !prof !13

270:                                              ; preds = %268
  %271 = getelementptr inbounds i8, ptr %.3308, i64 48
  store ptr %216, ptr %271, align 8, !tbaa !23
  %272 = getelementptr inbounds i8, ptr %11, i64 32
  %273 = load ptr, ptr %272, align 8, !tbaa !27
  %.not381 = icmp eq ptr %273, null
  br i1 %.not381, label %279, label %274

274:                                              ; preds = %270
  %.not382 = icmp ult ptr %273, %269
  br i1 %.not382, label %278, label %275, !prof !13

275:                                              ; preds = %274
  %276 = getelementptr inbounds i8, ptr %.3308, i64 32
  store ptr %273, ptr %276, align 8, !tbaa !27
  %277 = getelementptr inbounds i8, ptr %273, i64 48
  store ptr %.3308, ptr %277, align 8, !tbaa !23
  br label %279

278:                                              ; preds = %274
  tail call void @abort() #6
  unreachable

279:                                              ; preds = %275, %270
  %280 = getelementptr inbounds i8, ptr %11, i64 40
  %281 = load ptr, ptr %280, align 8, !tbaa !27
  %.not383 = icmp eq ptr %281, null
  br i1 %.not383, label %288, label %282

282:                                              ; preds = %279
  %.not384 = icmp ult ptr %281, %269
  br i1 %.not384, label %286, label %283, !prof !13

283:                                              ; preds = %282
  %284 = getelementptr inbounds i8, ptr %.3308, i64 40
  store ptr %281, ptr %284, align 8, !tbaa !27
  %285 = getelementptr inbounds i8, ptr %281, i64 48
  store ptr %.3308, ptr %285, align 8, !tbaa !23
  br label %288

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

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

288:                                              ; preds = %.thread443, %247, %279, %283, %262, %.critedge413, %199
  %289 = or i64 %180, 1
  %290 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %289, ptr %290, align 8, !tbaa !14
  %291 = getelementptr inbounds i8, ptr %.1, i64 %180
  store i64 %180, ptr %291, align 8, !tbaa !16
  %292 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 32), align 8, !tbaa !18
  %.not387 = icmp eq ptr %.1, %292
  br i1 %.not387, label %.thread425, label %298

.thread425:                                       ; preds = %288
  store i64 %180, ptr getelementptr inbounds (i8, ptr @_gm_, i64 8), align 8, !tbaa !32
  br label %.critedge407.thread

293:                                              ; preds = %151
  %294 = and i64 %149, -2
  store i64 %294, ptr %148, align 8, !tbaa !14
  %295 = or i64 %.1289, 1
  %296 = getelementptr inbounds i8, ptr %.1, i64 8
  store i64 %295, ptr %296, align 8, !tbaa !14
  %297 = getelementptr inbounds i8, ptr %.1, i64 %.1289
  store i64 %.1289, ptr %297, align 8, !tbaa !16
  br label %298

298:                                              ; preds = %288, %293
  %.2 = phi i64 [ %.1289, %293 ], [ %180, %288 ]
  %299 = icmp ult i64 %.2, 256
  br i1 %299, label %300, label %320

300:                                              ; preds = %298
  %301 = lshr i64 %.2, 3
  %302 = trunc nuw nsw i64 %301 to i32
  %303 = shl nuw nsw i64 %301, 1
  %304 = getelementptr inbounds [66 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 72), i64 0, i64 %303
  %305 = load i32, ptr @_gm_, align 8, !tbaa !22
  %306 = shl nuw i32 1, %302
  %307 = and i32 %305, %306
  %.not392 = icmp eq i32 %307, 0
  br i1 %.not392, label %308, label %310

308:                                              ; preds = %300
  %309 = or i32 %305, %306
  store i32 %309, ptr @_gm_, align 8, !tbaa !22
  br label %315

310:                                              ; preds = %300
  %311 = getelementptr inbounds i8, ptr %304, i64 16
  %312 = load ptr, ptr %311, align 8, !tbaa !19
  %313 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not393 = icmp ult ptr %312, %313
  br i1 %.not393, label %314, label %315, !prof !13

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

315:                                              ; preds = %310, %308
  %.0304 = phi ptr [ %304, %308 ], [ %312, %310 ]
  %316 = getelementptr inbounds i8, ptr %304, i64 16
  store ptr %.1, ptr %316, align 8, !tbaa !19
  %317 = getelementptr inbounds i8, ptr %.0304, i64 24
  store ptr %.1, ptr %317, align 8, !tbaa !20
  %318 = getelementptr inbounds i8, ptr %.1, i64 16
  store ptr %.0304, ptr %318, align 8, !tbaa !19
  %319 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %304, ptr %319, align 8, !tbaa !20
  br label %.critedge407.thread

320:                                              ; preds = %298
  %321 = lshr i64 %.2, 8
  %322 = trunc i64 %321 to i32
  %323 = icmp eq i32 %322, 0
  br i1 %323, label %336, label %324

324:                                              ; preds = %320
  %325 = icmp ugt i32 %322, 65535
  br i1 %325, label %336, label %326

326:                                              ; preds = %324
  %327 = tail call range(i32 16, 33) i32 @llvm.ctlz.i32(i32 %322, i1 true)
  %328 = shl nuw nsw i32 %327, 1
  %329 = sub nuw nsw i32 38, %327
  %330 = zext nneg i32 %329 to i64
  %331 = lshr i64 %.2, %330
  %332 = trunc i64 %331 to i32
  %333 = and i32 %332, 1
  %334 = or disjoint i32 %333, %328
  %335 = xor i32 %334, 62
  br label %336

336:                                              ; preds = %324, %320, %326
  %.0298 = phi i32 [ %335, %326 ], [ 0, %320 ], [ 31, %324 ]
  %337 = zext nneg i32 %.0298 to i64
  %338 = getelementptr inbounds [32 x ptr], ptr getelementptr inbounds (i8, ptr @_gm_, i64 600), i64 0, i64 %337
  %339 = getelementptr inbounds i8, ptr %.1, i64 56
  store i32 %.0298, ptr %339, align 8, !tbaa !30
  %340 = getelementptr inbounds i8, ptr %.1, i64 32
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %340, i8 0, i64 16, i1 false)
  %341 = load i32, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  %342 = shl nuw i32 1, %.0298
  %343 = and i32 %341, %342
  %.not388 = icmp eq i32 %343, 0
  br i1 %.not388, label %344, label %346

344:                                              ; preds = %336
  %345 = or i32 %341, %342
  store i32 %345, ptr getelementptr inbounds (i8, ptr @_gm_, i64 4), align 4, !tbaa !31
  br label %.thread427

346:                                              ; preds = %336
  %347 = load ptr, ptr %338, align 8, !tbaa !27
  %348 = icmp eq i32 %.0298, 31
  %349 = lshr i32 %.0298, 1
  %350 = add nuw nsw i32 %349, 6
  %351 = zext nneg i32 %350 to i64
  %352 = sub nuw nsw i64 63, %351
  %353 = select i1 %348, i64 0, i64 %352
  %354 = shl i64 %.2, %353
  br label %355

355:                                              ; preds = %359, %346
  %.0291 = phi ptr [ %347, %346 ], [ %364, %359 ]
  %.0290 = phi i64 [ %354, %346 ], [ %363, %359 ]
  %356 = getelementptr inbounds i8, ptr %.0291, i64 8
  %357 = load i64, ptr %356, align 8, !tbaa !37
  %358 = and i64 %357, -8
  %.not389 = icmp eq i64 %358, %.2
  br i1 %.not389, label %369, label %359

359:                                              ; preds = %355
  %360 = getelementptr inbounds i8, ptr %.0291, i64 32
  %361 = lshr i64 %.0290, 63
  %362 = getelementptr inbounds [2 x ptr], ptr %360, i64 0, i64 %361
  %363 = shl i64 %.0290, 1
  %364 = load ptr, ptr %362, align 8, !tbaa !27
  %.not390 = icmp eq ptr %364, null
  br i1 %.not390, label %365, label %355

365:                                              ; preds = %359
  %366 = getelementptr inbounds [2 x ptr], ptr %360, i64 0, i64 %361
  %367 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8, !tbaa !5
  %.not391 = icmp ult ptr %366, %367
  br i1 %.not391, label %368, label %.thread427, !prof !13

368:                                              ; preds = %365
  tail call void @abort() #6
  unreachable

369:                                              ; preds = %355
  %370 = getelementptr inbounds i8, ptr %.0291, i64 16
  %371 = load ptr, ptr %370, align 8, !tbaa !26
  %372 = load ptr, ptr getelementptr inbounds (i8, ptr @_gm_, i64 24), align 8
  %373 = icmp uge ptr %.0291, %372
  %374 = icmp uge ptr %371, %372
  %375 = select i1 %373, i1 %374, i1 false, !prof !21
  br i1 %375, label %376, label %378, !prof !21

376:                                              ; preds = %369
  %377 = getelementptr inbounds i8, ptr %371, i64 24
  store ptr %.1, ptr %377, align 8, !tbaa !25
  br label %.thread427

378:                                              ; preds = %369
  tail call void @abort() #6
  unreachable

.thread427:                                       ; preds = %365, %376, %344
  %.sink455 = phi ptr [ %370, %376 ], [ %338, %344 ], [ %366, %365 ]
  %.sink454 = phi i64 [ 16, %376 ], [ 48, %344 ], [ 48, %365 ]
  %.0291.lcssa445.sink = phi ptr [ %371, %376 ], [ %338, %344 ], [ %.0291, %365 ]
  %.1.sink451 = phi ptr [ %.0291, %376 ], [ %.1, %344 ], [ %.1, %365 ]
  %.sink450 = phi i64 [ 48, %376 ], [ 16, %344 ], [ 16, %365 ]
  %.1.sink = phi ptr [ null, %376 ], [ %.1, %344 ], [ %.1, %365 ]
  store ptr %.1, ptr %.sink455, align 8, !tbaa !27
  %379 = getelementptr inbounds i8, ptr %.1, i64 %.sink454
  store ptr %.0291.lcssa445.sink, ptr %379, align 8, !tbaa !27
  %380 = getelementptr inbounds i8, ptr %.1, i64 24
  store ptr %.1.sink451, ptr %380, align 8, !tbaa !25
  %381 = getelementptr inbounds i8, ptr %.1, i64 %.sink450
  store ptr %.1.sink, ptr %381, align 8, !tbaa !27
  %382 = load i64, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !38
  %383 = add i64 %382, -1
  store i64 %383, ptr getelementptr inbounds (i8, ptr @_gm_, i64 56), align 8, !tbaa !38
  %384 = icmp eq i64 %383, 0
  br i1 %384, label %385, label %.critedge407.thread

385:                                              ; preds = %.thread427
  %386 = tail call i64 @release_unused_segments(ptr noundef nonnull @_gm_)
  br label %.critedge407.thread

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

.critedge407.thread:                              ; preds = %.thread425, %142, %17, %24, %315, %385, %.thread427, %164, %167, %172, %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