; LLVM IR from mkazhdan/DMG :: Util/ZLIB (infblock)

; 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.z_stream_s = type { ptr, i32, i64, ptr, i32, i64, ptr, ptr, ptr, ptr, ptr, i32, i64, i64 }
%struct.inflate_blocks_state = type { i32, %union.anon, i32, i32, i64, ptr, ptr, ptr, ptr, ptr, ptr, i64 }
%union.anon = type { %struct.anon }
%struct.anon = type { i32, i32, ptr, i32, ptr }
%struct.anon.0 = type { ptr }
%struct.inflate_huft_s = type { %union.anon.1, i32 }
%union.anon.1 = type { i32 }
%struct.anon.2 = type { i8, i8 }

@.str = external hidden unnamed_addr constant [19 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [36 x i8], align 1
@border = external hidden constant [19 x i32], align 16
@inflate_mask = external global [17 x i32], align 16
@.str.3 = external hidden unnamed_addr constant [26 x i8], align 1

declare void @inflate_codes_free(ptr noundef, ptr noundef) #0

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

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

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

49:                                               ; preds = %3
  %50 = load ptr, ptr %5, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.inflate_blocks_state, ptr %50, i32 0, i32 8
  %52 = load ptr, ptr %51, align 8, !tbaa !20
  %53 = load ptr, ptr %13, align 8, !tbaa !5
  %54 = ptrtoint ptr %52 to i64
  %55 = ptrtoint ptr %53 to i64
  %56 = sub i64 %54, %55
  %57 = sub nsw i64 %56, 1
  br label %66

58:                                               ; preds = %3
  %59 = load ptr, ptr %5, align 8, !tbaa !5
  %60 = getelementptr inbounds %struct.inflate_blocks_state, ptr %59, i32 0, i32 7
  %61 = load ptr, ptr %60, align 8, !tbaa !21
  %62 = load ptr, ptr %13, align 8, !tbaa !5
  %63 = ptrtoint ptr %61 to i64
  %64 = ptrtoint ptr %62 to i64
  %65 = sub i64 %63, %64
  br label %66

66:                                               ; preds = %58, %49
  %67 = phi i64 [ %57, %49 ], [ %65, %58 ]
  %68 = trunc i64 %67 to i32
  store i32 %68, ptr %14, align 4, !tbaa !9
  br label %69

69:                                               ; preds = %1689, %66
  br label %70

70:                                               ; preds = %69
  %71 = load ptr, ptr %5, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.inflate_blocks_state, ptr %71, i32 0, i32 0
  %73 = load i32, ptr %72, align 8, !tbaa !22
  switch i32 %73, label %1658 [
    i32 0, label %74
    i32 1, label %258
    i32 2, label %376
    i32 3, label %623
    i32 4, label %787
    i32 5, label %972
    i32 6, label %1426
    i32 7, label %1519
    i32 8, label %1596
    i32 9, label %1627
  ]

74:                                               ; preds = %70
  br label %75

75:                                               ; preds = %113, %74
  %76 = load i32, ptr %10, align 4, !tbaa !9
  %77 = icmp ult i32 %76, 3
  br i1 %77, label %78, label %127

78:                                               ; preds = %75
  %79 = load i32, ptr %12, align 4, !tbaa !9
  %80 = icmp ne i32 %79, 0
  br i1 %80, label %81, label %82

81:                                               ; preds = %78
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %113

82:                                               ; preds = %78
  %83 = load i64, ptr %9, align 8, !tbaa !17
  %84 = load ptr, ptr %5, align 8, !tbaa !5
  %85 = getelementptr inbounds %struct.inflate_blocks_state, ptr %84, i32 0, i32 4
  store i64 %83, ptr %85, align 8, !tbaa !15
  %86 = load i32, ptr %10, align 4, !tbaa !9
  %87 = load ptr, ptr %5, align 8, !tbaa !5
  %88 = getelementptr inbounds %struct.inflate_blocks_state, ptr %87, i32 0, i32 3
  store i32 %86, ptr %88, align 4, !tbaa !18
  %89 = load i32, ptr %12, align 4, !tbaa !9
  %90 = load ptr, ptr %6, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct.z_stream_s, ptr %90, i32 0, i32 1
  store i32 %89, ptr %91, align 8, !tbaa !14
  %92 = load ptr, ptr %11, align 8, !tbaa !5
  %93 = load ptr, ptr %6, align 8, !tbaa !5
  %94 = getelementptr inbounds %struct.z_stream_s, ptr %93, i32 0, i32 0
  %95 = load ptr, ptr %94, align 8, !tbaa !11
  %96 = ptrtoint ptr %92 to i64
  %97 = ptrtoint ptr %95 to i64
  %98 = sub i64 %96, %97
  %99 = load ptr, ptr %6, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.z_stream_s, ptr %99, i32 0, i32 2
  %101 = load i64, ptr %100, align 8, !tbaa !23
  %102 = add i64 %101, %98
  store i64 %102, ptr %100, align 8, !tbaa !23
  %103 = load ptr, ptr %11, align 8, !tbaa !5
  %104 = load ptr, ptr %6, align 8, !tbaa !5
  %105 = getelementptr inbounds %struct.z_stream_s, ptr %104, i32 0, i32 0
  store ptr %103, ptr %105, align 8, !tbaa !11
  %106 = load ptr, ptr %13, align 8, !tbaa !5
  %107 = load ptr, ptr %5, align 8, !tbaa !5
  %108 = getelementptr inbounds %struct.inflate_blocks_state, ptr %107, i32 0, i32 9
  store ptr %106, ptr %108, align 8, !tbaa !19
  %109 = load ptr, ptr %5, align 8, !tbaa !5
  %110 = load ptr, ptr %6, align 8, !tbaa !5
  %111 = load i32, ptr %7, align 4, !tbaa !9
  %112 = call i32 @inflate_flush(ptr noundef %109, ptr noundef %110, i32 noundef %111)
  store i32 %112, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

113:                                              ; preds = %81
  %114 = load i32, ptr %12, align 4, !tbaa !9
  %115 = add i32 %114, -1
  store i32 %115, ptr %12, align 4, !tbaa !9
  %116 = load ptr, ptr %11, align 8, !tbaa !5
  %117 = getelementptr inbounds i8, ptr %116, i32 1
  store ptr %117, ptr %11, align 8, !tbaa !5
  %118 = load i8, ptr %116, align 1, !tbaa !24
  %119 = zext i8 %118 to i64
  %120 = load i32, ptr %10, align 4, !tbaa !9
  %121 = zext i32 %120 to i64
  %122 = shl i64 %119, %121
  %123 = load i64, ptr %9, align 8, !tbaa !17
  %124 = or i64 %123, %122
  store i64 %124, ptr %9, align 8, !tbaa !17
  %125 = load i32, ptr %10, align 4, !tbaa !9
  %126 = add i32 %125, 8
  store i32 %126, ptr %10, align 4, !tbaa !9
  br label %75, !llvm.loop !25

127:                                              ; preds = %75
  %128 = load i64, ptr %9, align 8, !tbaa !17
  %129 = trunc i64 %128 to i32
  %130 = and i32 %129, 7
  store i32 %130, ptr %8, align 4, !tbaa !9
  %131 = load i32, ptr %8, align 4, !tbaa !9
  %132 = and i32 %131, 1
  %133 = load ptr, ptr %5, align 8, !tbaa !5
  %134 = getelementptr inbounds %struct.inflate_blocks_state, ptr %133, i32 0, i32 2
  store i32 %132, ptr %134, align 8, !tbaa !27
  %135 = load i32, ptr %8, align 4, !tbaa !9
  %136 = lshr i32 %135, 1
  switch i32 %136, label %257 [
    i32 0, label %137
    i32 1, label %153
    i32 2, label %211
    i32 3, label %218
  ]

137:                                              ; preds = %127
  %138 = load i64, ptr %9, align 8, !tbaa !17
  %139 = lshr i64 %138, 3
  store i64 %139, ptr %9, align 8, !tbaa !17
  %140 = load i32, ptr %10, align 4, !tbaa !9
  %141 = sub i32 %140, 3
  store i32 %141, ptr %10, align 4, !tbaa !9
  %142 = load i32, ptr %10, align 4, !tbaa !9
  %143 = and i32 %142, 7
  store i32 %143, ptr %8, align 4, !tbaa !9
  %144 = load i32, ptr %8, align 4, !tbaa !9
  %145 = load i64, ptr %9, align 8, !tbaa !17
  %146 = zext i32 %144 to i64
  %147 = lshr i64 %145, %146
  store i64 %147, ptr %9, align 8, !tbaa !17
  %148 = load i32, ptr %8, align 4, !tbaa !9
  %149 = load i32, ptr %10, align 4, !tbaa !9
  %150 = sub i32 %149, %148
  store i32 %150, ptr %10, align 4, !tbaa !9
  %151 = load ptr, ptr %5, align 8, !tbaa !5
  %152 = getelementptr inbounds %struct.inflate_blocks_state, ptr %151, i32 0, i32 0
  store i32 1, ptr %152, align 8, !tbaa !22
  br label %257

153:                                              ; preds = %127
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #4
  %154 = load ptr, ptr %6, align 8, !tbaa !5
  %155 = call i32 @inflate_trees_fixed(ptr noundef %16, ptr noundef %17, ptr noundef %18, ptr noundef %19, ptr noundef %154)
  %156 = load i32, ptr %16, align 4, !tbaa !9
  %157 = load i32, ptr %17, align 4, !tbaa !9
  %158 = load ptr, ptr %18, align 8, !tbaa !5
  %159 = load ptr, ptr %19, align 8, !tbaa !5
  %160 = load ptr, ptr %6, align 8, !tbaa !5
  %161 = call ptr @inflate_codes_new(i32 noundef %156, i32 noundef %157, ptr noundef %158, ptr noundef %159, ptr noundef %160)
  %162 = load ptr, ptr %5, align 8, !tbaa !5
  %163 = getelementptr inbounds %struct.inflate_blocks_state, ptr %162, i32 0, i32 1
  %164 = getelementptr inbounds %struct.anon.0, ptr %163, i32 0, i32 0
  store ptr %161, ptr %164, align 8, !tbaa !24
  %165 = load ptr, ptr %5, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.inflate_blocks_state, ptr %165, i32 0, i32 1
  %167 = getelementptr inbounds %struct.anon.0, ptr %166, i32 0, i32 0
  %168 = load ptr, ptr %167, align 8, !tbaa !24
  %169 = icmp eq ptr %168, null
  br i1 %169, label %170, label %201

170:                                              ; preds = %153
  store i32 -4, ptr %7, align 4, !tbaa !9
  %171 = load i64, ptr %9, align 8, !tbaa !17
  %172 = load ptr, ptr %5, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.inflate_blocks_state, ptr %172, i32 0, i32 4
  store i64 %171, ptr %173, align 8, !tbaa !15
  %174 = load i32, ptr %10, align 4, !tbaa !9
  %175 = load ptr, ptr %5, align 8, !tbaa !5
  %176 = getelementptr inbounds %struct.inflate_blocks_state, ptr %175, i32 0, i32 3
  store i32 %174, ptr %176, align 4, !tbaa !18
  %177 = load i32, ptr %12, align 4, !tbaa !9
  %178 = load ptr, ptr %6, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.z_stream_s, ptr %178, i32 0, i32 1
  store i32 %177, ptr %179, align 8, !tbaa !14
  %180 = load ptr, ptr %11, align 8, !tbaa !5
  %181 = load ptr, ptr %6, align 8, !tbaa !5
  %182 = getelementptr inbounds %struct.z_stream_s, ptr %181, i32 0, i32 0
  %183 = load ptr, ptr %182, align 8, !tbaa !11
  %184 = ptrtoint ptr %180 to i64
  %185 = ptrtoint ptr %183 to i64
  %186 = sub i64 %184, %185
  %187 = load ptr, ptr %6, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.z_stream_s, ptr %187, i32 0, i32 2
  %189 = load i64, ptr %188, align 8, !tbaa !23
  %190 = add i64 %189, %186
  store i64 %190, ptr %188, align 8, !tbaa !23
  %191 = load ptr, ptr %11, align 8, !tbaa !5
  %192 = load ptr, ptr %6, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.z_stream_s, ptr %192, i32 0, i32 0
  store ptr %191, ptr %193, align 8, !tbaa !11
  %194 = load ptr, ptr %13, align 8, !tbaa !5
  %195 = load ptr, ptr %5, align 8, !tbaa !5
  %196 = getelementptr inbounds %struct.inflate_blocks_state, ptr %195, i32 0, i32 9
  store ptr %194, ptr %196, align 8, !tbaa !19
  %197 = load ptr, ptr %5, align 8, !tbaa !5
  %198 = load ptr, ptr %6, align 8, !tbaa !5
  %199 = load i32, ptr %7, align 4, !tbaa !9
  %200 = call i32 @inflate_flush(ptr noundef %197, ptr noundef %198, i32 noundef %199)
  store i32 %200, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %202

201:                                              ; preds = %153
  store i32 0, ptr %15, align 4
  br label %202

202:                                              ; preds = %201, %170
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  %203 = load i32, ptr %15, align 4
  switch i32 %203, label %1690 [
    i32 0, label %204
  ]

204:                                              ; preds = %202
  %205 = load i64, ptr %9, align 8, !tbaa !17
  %206 = lshr i64 %205, 3
  store i64 %206, ptr %9, align 8, !tbaa !17
  %207 = load i32, ptr %10, align 4, !tbaa !9
  %208 = sub i32 %207, 3
  store i32 %208, ptr %10, align 4, !tbaa !9
  %209 = load ptr, ptr %5, align 8, !tbaa !5
  %210 = getelementptr inbounds %struct.inflate_blocks_state, ptr %209, i32 0, i32 0
  store i32 6, ptr %210, align 8, !tbaa !22
  br label %257

211:                                              ; preds = %127
  %212 = load i64, ptr %9, align 8, !tbaa !17
  %213 = lshr i64 %212, 3
  store i64 %213, ptr %9, align 8, !tbaa !17
  %214 = load i32, ptr %10, align 4, !tbaa !9
  %215 = sub i32 %214, 3
  store i32 %215, ptr %10, align 4, !tbaa !9
  %216 = load ptr, ptr %5, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.inflate_blocks_state, ptr %216, i32 0, i32 0
  store i32 3, ptr %217, align 8, !tbaa !22
  br label %257

218:                                              ; preds = %127
  %219 = load i64, ptr %9, align 8, !tbaa !17
  %220 = lshr i64 %219, 3
  store i64 %220, ptr %9, align 8, !tbaa !17
  %221 = load i32, ptr %10, align 4, !tbaa !9
  %222 = sub i32 %221, 3
  store i32 %222, ptr %10, align 4, !tbaa !9
  %223 = load ptr, ptr %5, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.inflate_blocks_state, ptr %223, i32 0, i32 0
  store i32 9, ptr %224, align 8, !tbaa !22
  %225 = load ptr, ptr %6, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.z_stream_s, ptr %225, i32 0, i32 6
  store ptr @.str, ptr %226, align 8, !tbaa !28
  store i32 -3, ptr %7, align 4, !tbaa !9
  %227 = load i64, ptr %9, align 8, !tbaa !17
  %228 = load ptr, ptr %5, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.inflate_blocks_state, ptr %228, i32 0, i32 4
  store i64 %227, ptr %229, align 8, !tbaa !15
  %230 = load i32, ptr %10, align 4, !tbaa !9
  %231 = load ptr, ptr %5, align 8, !tbaa !5
  %232 = getelementptr inbounds %struct.inflate_blocks_state, ptr %231, i32 0, i32 3
  store i32 %230, ptr %232, align 4, !tbaa !18
  %233 = load i32, ptr %12, align 4, !tbaa !9
  %234 = load ptr, ptr %6, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.z_stream_s, ptr %234, i32 0, i32 1
  store i32 %233, ptr %235, align 8, !tbaa !14
  %236 = load ptr, ptr %11, align 8, !tbaa !5
  %237 = load ptr, ptr %6, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.z_stream_s, ptr %237, i32 0, i32 0
  %239 = load ptr, ptr %238, align 8, !tbaa !11
  %240 = ptrtoint ptr %236 to i64
  %241 = ptrtoint ptr %239 to i64
  %242 = sub i64 %240, %241
  %243 = load ptr, ptr %6, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.z_stream_s, ptr %243, i32 0, i32 2
  %245 = load i64, ptr %244, align 8, !tbaa !23
  %246 = add i64 %245, %242
  store i64 %246, ptr %244, align 8, !tbaa !23
  %247 = load ptr, ptr %11, align 8, !tbaa !5
  %248 = load ptr, ptr %6, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.z_stream_s, ptr %248, i32 0, i32 0
  store ptr %247, ptr %249, align 8, !tbaa !11
  %250 = load ptr, ptr %13, align 8, !tbaa !5
  %251 = load ptr, ptr %5, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.inflate_blocks_state, ptr %251, i32 0, i32 9
  store ptr %250, ptr %252, align 8, !tbaa !19
  %253 = load ptr, ptr %5, align 8, !tbaa !5
  %254 = load ptr, ptr %6, align 8, !tbaa !5
  %255 = load i32, ptr %7, align 4, !tbaa !9
  %256 = call i32 @inflate_flush(ptr noundef %253, ptr noundef %254, i32 noundef %255)
  store i32 %256, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

257:                                              ; preds = %211, %204, %137, %127
  br label %1689

258:                                              ; preds = %70
  br label %259

259:                                              ; preds = %297, %258
  %260 = load i32, ptr %10, align 4, !tbaa !9
  %261 = icmp ult i32 %260, 32
  br i1 %261, label %262, label %311

262:                                              ; preds = %259
  %263 = load i32, ptr %12, align 4, !tbaa !9
  %264 = icmp ne i32 %263, 0
  br i1 %264, label %265, label %266

265:                                              ; preds = %262
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %297

266:                                              ; preds = %262
  %267 = load i64, ptr %9, align 8, !tbaa !17
  %268 = load ptr, ptr %5, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.inflate_blocks_state, ptr %268, i32 0, i32 4
  store i64 %267, ptr %269, align 8, !tbaa !15
  %270 = load i32, ptr %10, align 4, !tbaa !9
  %271 = load ptr, ptr %5, align 8, !tbaa !5
  %272 = getelementptr inbounds %struct.inflate_blocks_state, ptr %271, i32 0, i32 3
  store i32 %270, ptr %272, align 4, !tbaa !18
  %273 = load i32, ptr %12, align 4, !tbaa !9
  %274 = load ptr, ptr %6, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.z_stream_s, ptr %274, i32 0, i32 1
  store i32 %273, ptr %275, align 8, !tbaa !14
  %276 = load ptr, ptr %11, align 8, !tbaa !5
  %277 = load ptr, ptr %6, align 8, !tbaa !5
  %278 = getelementptr inbounds %struct.z_stream_s, ptr %277, i32 0, i32 0
  %279 = load ptr, ptr %278, align 8, !tbaa !11
  %280 = ptrtoint ptr %276 to i64
  %281 = ptrtoint ptr %279 to i64
  %282 = sub i64 %280, %281
  %283 = load ptr, ptr %6, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.z_stream_s, ptr %283, i32 0, i32 2
  %285 = load i64, ptr %284, align 8, !tbaa !23
  %286 = add i64 %285, %282
  store i64 %286, ptr %284, align 8, !tbaa !23
  %287 = load ptr, ptr %11, align 8, !tbaa !5
  %288 = load ptr, ptr %6, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.z_stream_s, ptr %288, i32 0, i32 0
  store ptr %287, ptr %289, align 8, !tbaa !11
  %290 = load ptr, ptr %13, align 8, !tbaa !5
  %291 = load ptr, ptr %5, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.inflate_blocks_state, ptr %291, i32 0, i32 9
  store ptr %290, ptr %292, align 8, !tbaa !19
  %293 = load ptr, ptr %5, align 8, !tbaa !5
  %294 = load ptr, ptr %6, align 8, !tbaa !5
  %295 = load i32, ptr %7, align 4, !tbaa !9
  %296 = call i32 @inflate_flush(ptr noundef %293, ptr noundef %294, i32 noundef %295)
  store i32 %296, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

297:                                              ; preds = %265
  %298 = load i32, ptr %12, align 4, !tbaa !9
  %299 = add i32 %298, -1
  store i32 %299, ptr %12, align 4, !tbaa !9
  %300 = load ptr, ptr %11, align 8, !tbaa !5
  %301 = getelementptr inbounds i8, ptr %300, i32 1
  store ptr %301, ptr %11, align 8, !tbaa !5
  %302 = load i8, ptr %300, align 1, !tbaa !24
  %303 = zext i8 %302 to i64
  %304 = load i32, ptr %10, align 4, !tbaa !9
  %305 = zext i32 %304 to i64
  %306 = shl i64 %303, %305
  %307 = load i64, ptr %9, align 8, !tbaa !17
  %308 = or i64 %307, %306
  store i64 %308, ptr %9, align 8, !tbaa !17
  %309 = load i32, ptr %10, align 4, !tbaa !9
  %310 = add i32 %309, 8
  store i32 %310, ptr %10, align 4, !tbaa !9
  br label %259, !llvm.loop !29

311:                                              ; preds = %259
  %312 = load i64, ptr %9, align 8, !tbaa !17
  %313 = xor i64 %312, -1
  %314 = lshr i64 %313, 16
  %315 = and i64 %314, 65535
  %316 = load i64, ptr %9, align 8, !tbaa !17
  %317 = and i64 %316, 65535
  %318 = icmp ne i64 %315, %317
  br i1 %318, label %319, label %354

319:                                              ; preds = %311
  %320 = load ptr, ptr %5, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.inflate_blocks_state, ptr %320, i32 0, i32 0
  store i32 9, ptr %321, align 8, !tbaa !22
  %322 = load ptr, ptr %6, align 8, !tbaa !5
  %323 = getelementptr inbounds %struct.z_stream_s, ptr %322, i32 0, i32 6
  store ptr @.str.1, ptr %323, align 8, !tbaa !28
  store i32 -3, ptr %7, align 4, !tbaa !9
  %324 = load i64, ptr %9, align 8, !tbaa !17
  %325 = load ptr, ptr %5, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.inflate_blocks_state, ptr %325, i32 0, i32 4
  store i64 %324, ptr %326, align 8, !tbaa !15
  %327 = load i32, ptr %10, align 4, !tbaa !9
  %328 = load ptr, ptr %5, align 8, !tbaa !5
  %329 = getelementptr inbounds %struct.inflate_blocks_state, ptr %328, i32 0, i32 3
  store i32 %327, ptr %329, align 4, !tbaa !18
  %330 = load i32, ptr %12, align 4, !tbaa !9
  %331 = load ptr, ptr %6, align 8, !tbaa !5
  %332 = getelementptr inbounds %struct.z_stream_s, ptr %331, i32 0, i32 1
  store i32 %330, ptr %332, align 8, !tbaa !14
  %333 = load ptr, ptr %11, align 8, !tbaa !5
  %334 = load ptr, ptr %6, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.z_stream_s, ptr %334, i32 0, i32 0
  %336 = load ptr, ptr %335, align 8, !tbaa !11
  %337 = ptrtoint ptr %333 to i64
  %338 = ptrtoint ptr %336 to i64
  %339 = sub i64 %337, %338
  %340 = load ptr, ptr %6, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.z_stream_s, ptr %340, i32 0, i32 2
  %342 = load i64, ptr %341, align 8, !tbaa !23
  %343 = add i64 %342, %339
  store i64 %343, ptr %341, align 8, !tbaa !23
  %344 = load ptr, ptr %11, align 8, !tbaa !5
  %345 = load ptr, ptr %6, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.z_stream_s, ptr %345, i32 0, i32 0
  store ptr %344, ptr %346, align 8, !tbaa !11
  %347 = load ptr, ptr %13, align 8, !tbaa !5
  %348 = load ptr, ptr %5, align 8, !tbaa !5
  %349 = getelementptr inbounds %struct.inflate_blocks_state, ptr %348, i32 0, i32 9
  store ptr %347, ptr %349, align 8, !tbaa !19
  %350 = load ptr, ptr %5, align 8, !tbaa !5
  %351 = load ptr, ptr %6, align 8, !tbaa !5
  %352 = load i32, ptr %7, align 4, !tbaa !9
  %353 = call i32 @inflate_flush(ptr noundef %350, ptr noundef %351, i32 noundef %352)
  store i32 %353, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

354:                                              ; preds = %311
  %355 = load i64, ptr %9, align 8, !tbaa !17
  %356 = trunc i64 %355 to i32
  %357 = and i32 %356, 65535
  %358 = load ptr, ptr %5, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.inflate_blocks_state, ptr %358, i32 0, i32 1
  store i32 %357, ptr %359, align 8, !tbaa !24
  store i32 0, ptr %10, align 4, !tbaa !9
  store i64 0, ptr %9, align 8, !tbaa !17
  %360 = load ptr, ptr %5, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.inflate_blocks_state, ptr %360, i32 0, i32 1
  %362 = load i32, ptr %361, align 8, !tbaa !24
  %363 = icmp ne i32 %362, 0
  br i1 %363, label %364, label %365

364:                                              ; preds = %354
  br label %372

365:                                              ; preds = %354
  %366 = load ptr, ptr %5, align 8, !tbaa !5
  %367 = getelementptr inbounds %struct.inflate_blocks_state, ptr %366, i32 0, i32 2
  %368 = load i32, ptr %367, align 8, !tbaa !27
  %369 = icmp ne i32 %368, 0
  %370 = zext i1 %369 to i64
  %371 = select i1 %369, i32 7, i32 0
  br label %372

372:                                              ; preds = %365, %364
  %373 = phi i32 [ 2, %364 ], [ %371, %365 ]
  %374 = load ptr, ptr %5, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.inflate_blocks_state, ptr %374, i32 0, i32 0
  store i32 %373, ptr %375, align 8, !tbaa !22
  br label %1689

376:                                              ; preds = %70
  %377 = load i32, ptr %12, align 4, !tbaa !9
  %378 = icmp eq i32 %377, 0
  br i1 %378, label %379, label %410

379:                                              ; preds = %376
  %380 = load i64, ptr %9, align 8, !tbaa !17
  %381 = load ptr, ptr %5, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.inflate_blocks_state, ptr %381, i32 0, i32 4
  store i64 %380, ptr %382, align 8, !tbaa !15
  %383 = load i32, ptr %10, align 4, !tbaa !9
  %384 = load ptr, ptr %5, align 8, !tbaa !5
  %385 = getelementptr inbounds %struct.inflate_blocks_state, ptr %384, i32 0, i32 3
  store i32 %383, ptr %385, align 4, !tbaa !18
  %386 = load i32, ptr %12, align 4, !tbaa !9
  %387 = load ptr, ptr %6, align 8, !tbaa !5
  %388 = getelementptr inbounds %struct.z_stream_s, ptr %387, i32 0, i32 1
  store i32 %386, ptr %388, align 8, !tbaa !14
  %389 = load ptr, ptr %11, align 8, !tbaa !5
  %390 = load ptr, ptr %6, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.z_stream_s, ptr %390, i32 0, i32 0
  %392 = load ptr, ptr %391, align 8, !tbaa !11
  %393 = ptrtoint ptr %389 to i64
  %394 = ptrtoint ptr %392 to i64
  %395 = sub i64 %393, %394
  %396 = load ptr, ptr %6, align 8, !tbaa !5
  %397 = getelementptr inbounds %struct.z_stream_s, ptr %396, i32 0, i32 2
  %398 = load i64, ptr %397, align 8, !tbaa !23
  %399 = add i64 %398, %395
  store i64 %399, ptr %397, align 8, !tbaa !23
  %400 = load ptr, ptr %11, align 8, !tbaa !5
  %401 = load ptr, ptr %6, align 8, !tbaa !5
  %402 = getelementptr inbounds %struct.z_stream_s, ptr %401, i32 0, i32 0
  store ptr %400, ptr %402, align 8, !tbaa !11
  %403 = load ptr, ptr %13, align 8, !tbaa !5
  %404 = load ptr, ptr %5, align 8, !tbaa !5
  %405 = getelementptr inbounds %struct.inflate_blocks_state, ptr %404, i32 0, i32 9
  store ptr %403, ptr %405, align 8, !tbaa !19
  %406 = load ptr, ptr %5, align 8, !tbaa !5
  %407 = load ptr, ptr %6, align 8, !tbaa !5
  %408 = load i32, ptr %7, align 4, !tbaa !9
  %409 = call i32 @inflate_flush(ptr noundef %406, ptr noundef %407, i32 noundef %408)
  store i32 %409, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

410:                                              ; preds = %376
  %411 = load i32, ptr %14, align 4, !tbaa !9
  %412 = icmp eq i32 %411, 0
  br i1 %412, label %413, label %573

413:                                              ; preds = %410
  %414 = load ptr, ptr %13, align 8, !tbaa !5
  %415 = load ptr, ptr %5, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.inflate_blocks_state, ptr %415, i32 0, i32 7
  %417 = load ptr, ptr %416, align 8, !tbaa !21
  %418 = icmp eq ptr %414, %417
  br i1 %418, label %419, label %456

419:                                              ; preds = %413
  %420 = load ptr, ptr %5, align 8, !tbaa !5
  %421 = getelementptr inbounds %struct.inflate_blocks_state, ptr %420, i32 0, i32 8
  %422 = load ptr, ptr %421, align 8, !tbaa !20
  %423 = load ptr, ptr %5, align 8, !tbaa !5
  %424 = getelementptr inbounds %struct.inflate_blocks_state, ptr %423, i32 0, i32 6
  %425 = load ptr, ptr %424, align 8, !tbaa !30
  %426 = icmp ne ptr %422, %425
  br i1 %426, label %427, label %456

427:                                              ; preds = %419
  %428 = load ptr, ptr %5, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.inflate_blocks_state, ptr %428, i32 0, i32 6
  %430 = load ptr, ptr %429, align 8, !tbaa !30
  store ptr %430, ptr %13, align 8, !tbaa !5
  %431 = load ptr, ptr %13, align 8, !tbaa !5
  %432 = load ptr, ptr %5, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.inflate_blocks_state, ptr %432, i32 0, i32 8
  %434 = load ptr, ptr %433, align 8, !tbaa !20
  %435 = icmp ult ptr %431, %434
  br i1 %435, label %436, label %445

436:                                              ; preds = %427
  %437 = load ptr, ptr %5, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct.inflate_blocks_state, ptr %437, i32 0, i32 8
  %439 = load ptr, ptr %438, align 8, !tbaa !20
  %440 = load ptr, ptr %13, align 8, !tbaa !5
  %441 = ptrtoint ptr %439 to i64
  %442 = ptrtoint ptr %440 to i64
  %443 = sub i64 %441, %442
  %444 = sub nsw i64 %443, 1
  br label %453

445:                                              ; preds = %427
  %446 = load ptr, ptr %5, align 8, !tbaa !5
  %447 = getelementptr inbounds %struct.inflate_blocks_state, ptr %446, i32 0, i32 7
  %448 = load ptr, ptr %447, align 8, !tbaa !21
  %449 = load ptr, ptr %13, align 8, !tbaa !5
  %450 = ptrtoint ptr %448 to i64
  %451 = ptrtoint ptr %449 to i64
  %452 = sub i64 %450, %451
  br label %453

453:                                              ; preds = %445, %436
  %454 = phi i64 [ %444, %436 ], [ %452, %445 ]
  %455 = trunc i64 %454 to i32
  store i32 %455, ptr %14, align 4, !tbaa !9
  br label %456

456:                                              ; preds = %453, %419, %413
  %457 = load i32, ptr %14, align 4, !tbaa !9
  %458 = icmp eq i32 %457, 0
  br i1 %458, label %459, label %572

459:                                              ; preds = %456
  %460 = load ptr, ptr %13, align 8, !tbaa !5
  %461 = load ptr, ptr %5, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.inflate_blocks_state, ptr %461, i32 0, i32 9
  store ptr %460, ptr %462, align 8, !tbaa !19
  %463 = load ptr, ptr %5, align 8, !tbaa !5
  %464 = load ptr, ptr %6, align 8, !tbaa !5
  %465 = load i32, ptr %7, align 4, !tbaa !9
  %466 = call i32 @inflate_flush(ptr noundef %463, ptr noundef %464, i32 noundef %465)
  store i32 %466, ptr %7, align 4, !tbaa !9
  %467 = load ptr, ptr %5, align 8, !tbaa !5
  %468 = getelementptr inbounds %struct.inflate_blocks_state, ptr %467, i32 0, i32 9
  %469 = load ptr, ptr %468, align 8, !tbaa !19
  store ptr %469, ptr %13, align 8, !tbaa !5
  %470 = load ptr, ptr %13, align 8, !tbaa !5
  %471 = load ptr, ptr %5, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.inflate_blocks_state, ptr %471, i32 0, i32 8
  %473 = load ptr, ptr %472, align 8, !tbaa !20
  %474 = icmp ult ptr %470, %473
  br i1 %474, label %475, label %484

475:                                              ; preds = %459
  %476 = load ptr, ptr %5, align 8, !tbaa !5
  %477 = getelementptr inbounds %struct.inflate_blocks_state, ptr %476, i32 0, i32 8
  %478 = load ptr, ptr %477, align 8, !tbaa !20
  %479 = load ptr, ptr %13, align 8, !tbaa !5
  %480 = ptrtoint ptr %478 to i64
  %481 = ptrtoint ptr %479 to i64
  %482 = sub i64 %480, %481
  %483 = sub nsw i64 %482, 1
  br label %492

484:                                              ; preds = %459
  %485 = load ptr, ptr %5, align 8, !tbaa !5
  %486 = getelementptr inbounds %struct.inflate_blocks_state, ptr %485, i32 0, i32 7
  %487 = load ptr, ptr %486, align 8, !tbaa !21
  %488 = load ptr, ptr %13, align 8, !tbaa !5
  %489 = ptrtoint ptr %487 to i64
  %490 = ptrtoint ptr %488 to i64
  %491 = sub i64 %489, %490
  br label %492

492:                                              ; preds = %484, %475
  %493 = phi i64 [ %483, %475 ], [ %491, %484 ]
  %494 = trunc i64 %493 to i32
  store i32 %494, ptr %14, align 4, !tbaa !9
  %495 = load ptr, ptr %13, align 8, !tbaa !5
  %496 = load ptr, ptr %5, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.inflate_blocks_state, ptr %496, i32 0, i32 7
  %498 = load ptr, ptr %497, align 8, !tbaa !21
  %499 = icmp eq ptr %495, %498
  br i1 %499, label %500, label %537

500:                                              ; preds = %492
  %501 = load ptr, ptr %5, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.inflate_blocks_state, ptr %501, i32 0, i32 8
  %503 = load ptr, ptr %502, align 8, !tbaa !20
  %504 = load ptr, ptr %5, align 8, !tbaa !5
  %505 = getelementptr inbounds %struct.inflate_blocks_state, ptr %504, i32 0, i32 6
  %506 = load ptr, ptr %505, align 8, !tbaa !30
  %507 = icmp ne ptr %503, %506
  br i1 %507, label %508, label %537

508:                                              ; preds = %500
  %509 = load ptr, ptr %5, align 8, !tbaa !5
  %510 = getelementptr inbounds %struct.inflate_blocks_state, ptr %509, i32 0, i32 6
  %511 = load ptr, ptr %510, align 8, !tbaa !30
  store ptr %511, ptr %13, align 8, !tbaa !5
  %512 = load ptr, ptr %13, align 8, !tbaa !5
  %513 = load ptr, ptr %5, align 8, !tbaa !5
  %514 = getelementptr inbounds %struct.inflate_blocks_state, ptr %513, i32 0, i32 8
  %515 = load ptr, ptr %514, align 8, !tbaa !20
  %516 = icmp ult ptr %512, %515
  br i1 %516, label %517, label %526

517:                                              ; preds = %508
  %518 = load ptr, ptr %5, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.inflate_blocks_state, ptr %518, i32 0, i32 8
  %520 = load ptr, ptr %519, align 8, !tbaa !20
  %521 = load ptr, ptr %13, align 8, !tbaa !5
  %522 = ptrtoint ptr %520 to i64
  %523 = ptrtoint ptr %521 to i64
  %524 = sub i64 %522, %523
  %525 = sub nsw i64 %524, 1
  br label %534

526:                                              ; preds = %508
  %527 = load ptr, ptr %5, align 8, !tbaa !5
  %528 = getelementptr inbounds %struct.inflate_blocks_state, ptr %527, i32 0, i32 7
  %529 = load ptr, ptr %528, align 8, !tbaa !21
  %530 = load ptr, ptr %13, align 8, !tbaa !5
  %531 = ptrtoint ptr %529 to i64
  %532 = ptrtoint ptr %530 to i64
  %533 = sub i64 %531, %532
  br label %534

534:                                              ; preds = %526, %517
  %535 = phi i64 [ %525, %517 ], [ %533, %526 ]
  %536 = trunc i64 %535 to i32
  store i32 %536, ptr %14, align 4, !tbaa !9
  br label %537

537:                                              ; preds = %534, %500, %492
  %538 = load i32, ptr %14, align 4, !tbaa !9
  %539 = icmp eq i32 %538, 0
  br i1 %539, label %540, label %571

540:                                              ; preds = %537
  %541 = load i64, ptr %9, align 8, !tbaa !17
  %542 = load ptr, ptr %5, align 8, !tbaa !5
  %543 = getelementptr inbounds %struct.inflate_blocks_state, ptr %542, i32 0, i32 4
  store i64 %541, ptr %543, align 8, !tbaa !15
  %544 = load i32, ptr %10, align 4, !tbaa !9
  %545 = load ptr, ptr %5, align 8, !tbaa !5
  %546 = getelementptr inbounds %struct.inflate_blocks_state, ptr %545, i32 0, i32 3
  store i32 %544, ptr %546, align 4, !tbaa !18
  %547 = load i32, ptr %12, align 4, !tbaa !9
  %548 = load ptr, ptr %6, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.z_stream_s, ptr %548, i32 0, i32 1
  store i32 %547, ptr %549, align 8, !tbaa !14
  %550 = load ptr, ptr %11, align 8, !tbaa !5
  %551 = load ptr, ptr %6, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.z_stream_s, ptr %551, i32 0, i32 0
  %553 = load ptr, ptr %552, align 8, !tbaa !11
  %554 = ptrtoint ptr %550 to i64
  %555 = ptrtoint ptr %553 to i64
  %556 = sub i64 %554, %555
  %557 = load ptr, ptr %6, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.z_stream_s, ptr %557, i32 0, i32 2
  %559 = load i64, ptr %558, align 8, !tbaa !23
  %560 = add i64 %559, %556
  store i64 %560, ptr %558, align 8, !tbaa !23
  %561 = load ptr, ptr %11, align 8, !tbaa !5
  %562 = load ptr, ptr %6, align 8, !tbaa !5
  %563 = getelementptr inbounds %struct.z_stream_s, ptr %562, i32 0, i32 0
  store ptr %561, ptr %563, align 8, !tbaa !11
  %564 = load ptr, ptr %13, align 8, !tbaa !5
  %565 = load ptr, ptr %5, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.inflate_blocks_state, ptr %565, i32 0, i32 9
  store ptr %564, ptr %566, align 8, !tbaa !19
  %567 = load ptr, ptr %5, align 8, !tbaa !5
  %568 = load ptr, ptr %6, align 8, !tbaa !5
  %569 = load i32, ptr %7, align 4, !tbaa !9
  %570 = call i32 @inflate_flush(ptr noundef %567, ptr noundef %568, i32 noundef %569)
  store i32 %570, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

571:                                              ; preds = %537
  br label %572

572:                                              ; preds = %571, %456
  br label %573

573:                                              ; preds = %572, %410
  store i32 0, ptr %7, align 4, !tbaa !9
  %574 = load ptr, ptr %5, align 8, !tbaa !5
  %575 = getelementptr inbounds %struct.inflate_blocks_state, ptr %574, i32 0, i32 1
  %576 = load i32, ptr %575, align 8, !tbaa !24
  store i32 %576, ptr %8, align 4, !tbaa !9
  %577 = load i32, ptr %8, align 4, !tbaa !9
  %578 = load i32, ptr %12, align 4, !tbaa !9
  %579 = icmp ugt i32 %577, %578
  br i1 %579, label %580, label %582

580:                                              ; preds = %573
  %581 = load i32, ptr %12, align 4, !tbaa !9
  store i32 %581, ptr %8, align 4, !tbaa !9
  br label %582

582:                                              ; preds = %580, %573
  %583 = load i32, ptr %8, align 4, !tbaa !9
  %584 = load i32, ptr %14, align 4, !tbaa !9
  %585 = icmp ugt i32 %583, %584
  br i1 %585, label %586, label %588

586:                                              ; preds = %582
  %587 = load i32, ptr %14, align 4, !tbaa !9
  store i32 %587, ptr %8, align 4, !tbaa !9
  br label %588

588:                                              ; preds = %586, %582
  %589 = load ptr, ptr %13, align 8, !tbaa !5
  %590 = load ptr, ptr %11, align 8, !tbaa !5
  %591 = load i32, ptr %8, align 4, !tbaa !9
  %592 = zext i32 %591 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %589, ptr align 1 %590, i64 %592, i1 false)
  %593 = load i32, ptr %8, align 4, !tbaa !9
  %594 = load ptr, ptr %11, align 8, !tbaa !5
  %595 = zext i32 %593 to i64
  %596 = getelementptr inbounds i8, ptr %594, i64 %595
  store ptr %596, ptr %11, align 8, !tbaa !5
  %597 = load i32, ptr %8, align 4, !tbaa !9
  %598 = load i32, ptr %12, align 4, !tbaa !9
  %599 = sub i32 %598, %597
  store i32 %599, ptr %12, align 4, !tbaa !9
  %600 = load i32, ptr %8, align 4, !tbaa !9
  %601 = load ptr, ptr %13, align 8, !tbaa !5
  %602 = zext i32 %600 to i64
  %603 = getelementptr inbounds i8, ptr %601, i64 %602
  store ptr %603, ptr %13, align 8, !tbaa !5
  %604 = load i32, ptr %8, align 4, !tbaa !9
  %605 = load i32, ptr %14, align 4, !tbaa !9
  %606 = sub i32 %605, %604
  store i32 %606, ptr %14, align 4, !tbaa !9
  %607 = load i32, ptr %8, align 4, !tbaa !9
  %608 = load ptr, ptr %5, align 8, !tbaa !5
  %609 = getelementptr inbounds %struct.inflate_blocks_state, ptr %608, i32 0, i32 1
  %610 = load i32, ptr %609, align 8, !tbaa !24
  %611 = sub i32 %610, %607
  store i32 %611, ptr %609, align 8, !tbaa !24
  %612 = icmp ne i32 %611, 0
  br i1 %612, label %613, label %614

613:                                              ; preds = %588
  br label %1689

614:                                              ; preds = %588
  %615 = load ptr, ptr %5, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.inflate_blocks_state, ptr %615, i32 0, i32 2
  %617 = load i32, ptr %616, align 8, !tbaa !27
  %618 = icmp ne i32 %617, 0
  %619 = zext i1 %618 to i64
  %620 = select i1 %618, i32 7, i32 0
  %621 = load ptr, ptr %5, align 8, !tbaa !5
  %622 = getelementptr inbounds %struct.inflate_blocks_state, ptr %621, i32 0, i32 0
  store i32 %620, ptr %622, align 8, !tbaa !22
  br label %1689

623:                                              ; preds = %70
  br label %624

624:                                              ; preds = %662, %623
  %625 = load i32, ptr %10, align 4, !tbaa !9
  %626 = icmp ult i32 %625, 14
  br i1 %626, label %627, label %676

627:                                              ; preds = %624
  %628 = load i32, ptr %12, align 4, !tbaa !9
  %629 = icmp ne i32 %628, 0
  br i1 %629, label %630, label %631

630:                                              ; preds = %627
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %662

631:                                              ; preds = %627
  %632 = load i64, ptr %9, align 8, !tbaa !17
  %633 = load ptr, ptr %5, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.inflate_blocks_state, ptr %633, i32 0, i32 4
  store i64 %632, ptr %634, align 8, !tbaa !15
  %635 = load i32, ptr %10, align 4, !tbaa !9
  %636 = load ptr, ptr %5, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.inflate_blocks_state, ptr %636, i32 0, i32 3
  store i32 %635, ptr %637, align 4, !tbaa !18
  %638 = load i32, ptr %12, align 4, !tbaa !9
  %639 = load ptr, ptr %6, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.z_stream_s, ptr %639, i32 0, i32 1
  store i32 %638, ptr %640, align 8, !tbaa !14
  %641 = load ptr, ptr %11, align 8, !tbaa !5
  %642 = load ptr, ptr %6, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.z_stream_s, ptr %642, i32 0, i32 0
  %644 = load ptr, ptr %643, align 8, !tbaa !11
  %645 = ptrtoint ptr %641 to i64
  %646 = ptrtoint ptr %644 to i64
  %647 = sub i64 %645, %646
  %648 = load ptr, ptr %6, align 8, !tbaa !5
  %649 = getelementptr inbounds %struct.z_stream_s, ptr %648, i32 0, i32 2
  %650 = load i64, ptr %649, align 8, !tbaa !23
  %651 = add i64 %650, %647
  store i64 %651, ptr %649, align 8, !tbaa !23
  %652 = load ptr, ptr %11, align 8, !tbaa !5
  %653 = load ptr, ptr %6, align 8, !tbaa !5
  %654 = getelementptr inbounds %struct.z_stream_s, ptr %653, i32 0, i32 0
  store ptr %652, ptr %654, align 8, !tbaa !11
  %655 = load ptr, ptr %13, align 8, !tbaa !5
  %656 = load ptr, ptr %5, align 8, !tbaa !5
  %657 = getelementptr inbounds %struct.inflate_blocks_state, ptr %656, i32 0, i32 9
  store ptr %655, ptr %657, align 8, !tbaa !19
  %658 = load ptr, ptr %5, align 8, !tbaa !5
  %659 = load ptr, ptr %6, align 8, !tbaa !5
  %660 = load i32, ptr %7, align 4, !tbaa !9
  %661 = call i32 @inflate_flush(ptr noundef %658, ptr noundef %659, i32 noundef %660)
  store i32 %661, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

662:                                              ; preds = %630
  %663 = load i32, ptr %12, align 4, !tbaa !9
  %664 = add i32 %663, -1
  store i32 %664, ptr %12, align 4, !tbaa !9
  %665 = load ptr, ptr %11, align 8, !tbaa !5
  %666 = getelementptr inbounds i8, ptr %665, i32 1
  store ptr %666, ptr %11, align 8, !tbaa !5
  %667 = load i8, ptr %665, align 1, !tbaa !24
  %668 = zext i8 %667 to i64
  %669 = load i32, ptr %10, align 4, !tbaa !9
  %670 = zext i32 %669 to i64
  %671 = shl i64 %668, %670
  %672 = load i64, ptr %9, align 8, !tbaa !17
  %673 = or i64 %672, %671
  store i64 %673, ptr %9, align 8, !tbaa !17
  %674 = load i32, ptr %10, align 4, !tbaa !9
  %675 = add i32 %674, 8
  store i32 %675, ptr %10, align 4, !tbaa !9
  br label %624, !llvm.loop !31

676:                                              ; preds = %624
  %677 = load i64, ptr %9, align 8, !tbaa !17
  %678 = trunc i64 %677 to i32
  %679 = and i32 %678, 16383
  store i32 %679, ptr %8, align 4, !tbaa !9
  %680 = load ptr, ptr %5, align 8, !tbaa !5
  %681 = getelementptr inbounds %struct.inflate_blocks_state, ptr %680, i32 0, i32 1
  %682 = getelementptr inbounds %struct.anon, ptr %681, i32 0, i32 0
  store i32 %679, ptr %682, align 8, !tbaa !24
  %683 = load i32, ptr %8, align 4, !tbaa !9
  %684 = and i32 %683, 31
  %685 = icmp ugt i32 %684, 29
  br i1 %685, label %691, label %686

686:                                              ; preds = %676
  %687 = load i32, ptr %8, align 4, !tbaa !9
  %688 = lshr i32 %687, 5
  %689 = and i32 %688, 31
  %690 = icmp ugt i32 %689, 29
  br i1 %690, label %691, label %726

691:                                              ; preds = %686, %676
  %692 = load ptr, ptr %5, align 8, !tbaa !5
  %693 = getelementptr inbounds %struct.inflate_blocks_state, ptr %692, i32 0, i32 0
  store i32 9, ptr %693, align 8, !tbaa !22
  %694 = load ptr, ptr %6, align 8, !tbaa !5
  %695 = getelementptr inbounds %struct.z_stream_s, ptr %694, i32 0, i32 6
  store ptr @.str.2, ptr %695, align 8, !tbaa !28
  store i32 -3, ptr %7, align 4, !tbaa !9
  %696 = load i64, ptr %9, align 8, !tbaa !17
  %697 = load ptr, ptr %5, align 8, !tbaa !5
  %698 = getelementptr inbounds %struct.inflate_blocks_state, ptr %697, i32 0, i32 4
  store i64 %696, ptr %698, align 8, !tbaa !15
  %699 = load i32, ptr %10, align 4, !tbaa !9
  %700 = load ptr, ptr %5, align 8, !tbaa !5
  %701 = getelementptr inbounds %struct.inflate_blocks_state, ptr %700, i32 0, i32 3
  store i32 %699, ptr %701, align 4, !tbaa !18
  %702 = load i32, ptr %12, align 4, !tbaa !9
  %703 = load ptr, ptr %6, align 8, !tbaa !5
  %704 = getelementptr inbounds %struct.z_stream_s, ptr %703, i32 0, i32 1
  store i32 %702, ptr %704, align 8, !tbaa !14
  %705 = load ptr, ptr %11, align 8, !tbaa !5
  %706 = load ptr, ptr %6, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.z_stream_s, ptr %706, i32 0, i32 0
  %708 = load ptr, ptr %707, align 8, !tbaa !11
  %709 = ptrtoint ptr %705 to i64
  %710 = ptrtoint ptr %708 to i64
  %711 = sub i64 %709, %710
  %712 = load ptr, ptr %6, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.z_stream_s, ptr %712, i32 0, i32 2
  %714 = load i64, ptr %713, align 8, !tbaa !23
  %715 = add i64 %714, %711
  store i64 %715, ptr %713, align 8, !tbaa !23
  %716 = load ptr, ptr %11, align 8, !tbaa !5
  %717 = load ptr, ptr %6, align 8, !tbaa !5
  %718 = getelementptr inbounds %struct.z_stream_s, ptr %717, i32 0, i32 0
  store ptr %716, ptr %718, align 8, !tbaa !11
  %719 = load ptr, ptr %13, align 8, !tbaa !5
  %720 = load ptr, ptr %5, align 8, !tbaa !5
  %721 = getelementptr inbounds %struct.inflate_blocks_state, ptr %720, i32 0, i32 9
  store ptr %719, ptr %721, align 8, !tbaa !19
  %722 = load ptr, ptr %5, align 8, !tbaa !5
  %723 = load ptr, ptr %6, align 8, !tbaa !5
  %724 = load i32, ptr %7, align 4, !tbaa !9
  %725 = call i32 @inflate_flush(ptr noundef %722, ptr noundef %723, i32 noundef %724)
  store i32 %725, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

726:                                              ; preds = %686
  %727 = load i32, ptr %8, align 4, !tbaa !9
  %728 = and i32 %727, 31
  %729 = add i32 258, %728
  %730 = load i32, ptr %8, align 4, !tbaa !9
  %731 = lshr i32 %730, 5
  %732 = and i32 %731, 31
  %733 = add i32 %729, %732
  store i32 %733, ptr %8, align 4, !tbaa !9
  %734 = load ptr, ptr %6, align 8, !tbaa !5
  %735 = getelementptr inbounds %struct.z_stream_s, ptr %734, i32 0, i32 8
  %736 = load ptr, ptr %735, align 8, !tbaa !32
  %737 = load ptr, ptr %6, align 8, !tbaa !5
  %738 = getelementptr inbounds %struct.z_stream_s, ptr %737, i32 0, i32 10
  %739 = load ptr, ptr %738, align 8, !tbaa !33
  %740 = load i32, ptr %8, align 4, !tbaa !9
  %741 = call ptr %736(ptr noundef %739, i32 noundef %740, i32 noundef 4)
  %742 = load ptr, ptr %5, align 8, !tbaa !5
  %743 = getelementptr inbounds %struct.inflate_blocks_state, ptr %742, i32 0, i32 1
  %744 = getelementptr inbounds %struct.anon, ptr %743, i32 0, i32 2
  store ptr %741, ptr %744, align 8, !tbaa !24
  %745 = icmp eq ptr %741, null
  br i1 %745, label %746, label %777

746:                                              ; preds = %726
  store i32 -4, ptr %7, align 4, !tbaa !9
  %747 = load i64, ptr %9, align 8, !tbaa !17
  %748 = load ptr, ptr %5, align 8, !tbaa !5
  %749 = getelementptr inbounds %struct.inflate_blocks_state, ptr %748, i32 0, i32 4
  store i64 %747, ptr %749, align 8, !tbaa !15
  %750 = load i32, ptr %10, align 4, !tbaa !9
  %751 = load ptr, ptr %5, align 8, !tbaa !5
  %752 = getelementptr inbounds %struct.inflate_blocks_state, ptr %751, i32 0, i32 3
  store i32 %750, ptr %752, align 4, !tbaa !18
  %753 = load i32, ptr %12, align 4, !tbaa !9
  %754 = load ptr, ptr %6, align 8, !tbaa !5
  %755 = getelementptr inbounds %struct.z_stream_s, ptr %754, i32 0, i32 1
  store i32 %753, ptr %755, align 8, !tbaa !14
  %756 = load ptr, ptr %11, align 8, !tbaa !5
  %757 = load ptr, ptr %6, align 8, !tbaa !5
  %758 = getelementptr inbounds %struct.z_stream_s, ptr %757, i32 0, i32 0
  %759 = load ptr, ptr %758, align 8, !tbaa !11
  %760 = ptrtoint ptr %756 to i64
  %761 = ptrtoint ptr %759 to i64
  %762 = sub i64 %760, %761
  %763 = load ptr, ptr %6, align 8, !tbaa !5
  %764 = getelementptr inbounds %struct.z_stream_s, ptr %763, i32 0, i32 2
  %765 = load i64, ptr %764, align 8, !tbaa !23
  %766 = add i64 %765, %762
  store i64 %766, ptr %764, align 8, !tbaa !23
  %767 = load ptr, ptr %11, align 8, !tbaa !5
  %768 = load ptr, ptr %6, align 8, !tbaa !5
  %769 = getelementptr inbounds %struct.z_stream_s, ptr %768, i32 0, i32 0
  store ptr %767, ptr %769, align 8, !tbaa !11
  %770 = load ptr, ptr %13, align 8, !tbaa !5
  %771 = load ptr, ptr %5, align 8, !tbaa !5
  %772 = getelementptr inbounds %struct.inflate_blocks_state, ptr %771, i32 0, i32 9
  store ptr %770, ptr %772, align 8, !tbaa !19
  %773 = load ptr, ptr %5, align 8, !tbaa !5
  %774 = load ptr, ptr %6, align 8, !tbaa !5
  %775 = load i32, ptr %7, align 4, !tbaa !9
  %776 = call i32 @inflate_flush(ptr noundef %773, ptr noundef %774, i32 noundef %775)
  store i32 %776, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

777:                                              ; preds = %726
  %778 = load i64, ptr %9, align 8, !tbaa !17
  %779 = lshr i64 %778, 14
  store i64 %779, ptr %9, align 8, !tbaa !17
  %780 = load i32, ptr %10, align 4, !tbaa !9
  %781 = sub i32 %780, 14
  store i32 %781, ptr %10, align 4, !tbaa !9
  %782 = load ptr, ptr %5, align 8, !tbaa !5
  %783 = getelementptr inbounds %struct.inflate_blocks_state, ptr %782, i32 0, i32 1
  %784 = getelementptr inbounds %struct.anon, ptr %783, i32 0, i32 1
  store i32 0, ptr %784, align 4, !tbaa !24
  %785 = load ptr, ptr %5, align 8, !tbaa !5
  %786 = getelementptr inbounds %struct.inflate_blocks_state, ptr %785, i32 0, i32 0
  store i32 4, ptr %786, align 8, !tbaa !22
  br label %787

787:                                              ; preds = %777, %70
  br label %788

788:                                              ; preds = %853, %787
  %789 = load ptr, ptr %5, align 8, !tbaa !5
  %790 = getelementptr inbounds %struct.inflate_blocks_state, ptr %789, i32 0, i32 1
  %791 = getelementptr inbounds %struct.anon, ptr %790, i32 0, i32 1
  %792 = load i32, ptr %791, align 4, !tbaa !24
  %793 = load ptr, ptr %5, align 8, !tbaa !5
  %794 = getelementptr inbounds %struct.inflate_blocks_state, ptr %793, i32 0, i32 1
  %795 = getelementptr inbounds %struct.anon, ptr %794, i32 0, i32 0
  %796 = load i32, ptr %795, align 8, !tbaa !24
  %797 = lshr i32 %796, 10
  %798 = add i32 4, %797
  %799 = icmp ult i32 %792, %798
  br i1 %799, label %800, label %875

800:                                              ; preds = %788
  br label %801

801:                                              ; preds = %839, %800
  %802 = load i32, ptr %10, align 4, !tbaa !9
  %803 = icmp ult i32 %802, 3
  br i1 %803, label %804, label %853

804:                                              ; preds = %801
  %805 = load i32, ptr %12, align 4, !tbaa !9
  %806 = icmp ne i32 %805, 0
  br i1 %806, label %807, label %808

807:                                              ; preds = %804
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %839

808:                                              ; preds = %804
  %809 = load i64, ptr %9, align 8, !tbaa !17
  %810 = load ptr, ptr %5, align 8, !tbaa !5
  %811 = getelementptr inbounds %struct.inflate_blocks_state, ptr %810, i32 0, i32 4
  store i64 %809, ptr %811, align 8, !tbaa !15
  %812 = load i32, ptr %10, align 4, !tbaa !9
  %813 = load ptr, ptr %5, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.inflate_blocks_state, ptr %813, i32 0, i32 3
  store i32 %812, ptr %814, align 4, !tbaa !18
  %815 = load i32, ptr %12, align 4, !tbaa !9
  %816 = load ptr, ptr %6, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.z_stream_s, ptr %816, i32 0, i32 1
  store i32 %815, ptr %817, align 8, !tbaa !14
  %818 = load ptr, ptr %11, align 8, !tbaa !5
  %819 = load ptr, ptr %6, align 8, !tbaa !5
  %820 = getelementptr inbounds %struct.z_stream_s, ptr %819, i32 0, i32 0
  %821 = load ptr, ptr %820, align 8, !tbaa !11
  %822 = ptrtoint ptr %818 to i64
  %823 = ptrtoint ptr %821 to i64
  %824 = sub i64 %822, %823
  %825 = load ptr, ptr %6, align 8, !tbaa !5
  %826 = getelementptr inbounds %struct.z_stream_s, ptr %825, i32 0, i32 2
  %827 = load i64, ptr %826, align 8, !tbaa !23
  %828 = add i64 %827, %824
  store i64 %828, ptr %826, align 8, !tbaa !23
  %829 = load ptr, ptr %11, align 8, !tbaa !5
  %830 = load ptr, ptr %6, align 8, !tbaa !5
  %831 = getelementptr inbounds %struct.z_stream_s, ptr %830, i32 0, i32 0
  store ptr %829, ptr %831, align 8, !tbaa !11
  %832 = load ptr, ptr %13, align 8, !tbaa !5
  %833 = load ptr, ptr %5, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct.inflate_blocks_state, ptr %833, i32 0, i32 9
  store ptr %832, ptr %834, align 8, !tbaa !19
  %835 = load ptr, ptr %5, align 8, !tbaa !5
  %836 = load ptr, ptr %6, align 8, !tbaa !5
  %837 = load i32, ptr %7, align 4, !tbaa !9
  %838 = call i32 @inflate_flush(ptr noundef %835, ptr noundef %836, i32 noundef %837)
  store i32 %838, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

839:                                              ; preds = %807
  %840 = load i32, ptr %12, align 4, !tbaa !9
  %841 = add i32 %840, -1
  store i32 %841, ptr %12, align 4, !tbaa !9
  %842 = load ptr, ptr %11, align 8, !tbaa !5
  %843 = getelementptr inbounds i8, ptr %842, i32 1
  store ptr %843, ptr %11, align 8, !tbaa !5
  %844 = load i8, ptr %842, align 1, !tbaa !24
  %845 = zext i8 %844 to i64
  %846 = load i32, ptr %10, align 4, !tbaa !9
  %847 = zext i32 %846 to i64
  %848 = shl i64 %845, %847
  %849 = load i64, ptr %9, align 8, !tbaa !17
  %850 = or i64 %849, %848
  store i64 %850, ptr %9, align 8, !tbaa !17
  %851 = load i32, ptr %10, align 4, !tbaa !9
  %852 = add i32 %851, 8
  store i32 %852, ptr %10, align 4, !tbaa !9
  br label %801, !llvm.loop !34

853:                                              ; preds = %801
  %854 = load i64, ptr %9, align 8, !tbaa !17
  %855 = trunc i64 %854 to i32
  %856 = and i32 %855, 7
  %857 = load ptr, ptr %5, align 8, !tbaa !5
  %858 = getelementptr inbounds %struct.inflate_blocks_state, ptr %857, i32 0, i32 1
  %859 = getelementptr inbounds %struct.anon, ptr %858, i32 0, i32 2
  %860 = load ptr, ptr %859, align 8, !tbaa !24
  %861 = load ptr, ptr %5, align 8, !tbaa !5
  %862 = getelementptr inbounds %struct.inflate_blocks_state, ptr %861, i32 0, i32 1
  %863 = getelementptr inbounds %struct.anon, ptr %862, i32 0, i32 1
  %864 = load i32, ptr %863, align 4, !tbaa !24
  %865 = add i32 %864, 1
  store i32 %865, ptr %863, align 4, !tbaa !24
  %866 = zext i32 %864 to i64
  %867 = getelementptr inbounds [19 x i32], ptr @border, i64 0, i64 %866
  %868 = load i32, ptr %867, align 4, !tbaa !9
  %869 = zext i32 %868 to i64
  %870 = getelementptr inbounds i32, ptr %860, i64 %869
  store i32 %856, ptr %870, align 4, !tbaa !9
  %871 = load i64, ptr %9, align 8, !tbaa !17
  %872 = lshr i64 %871, 3
  store i64 %872, ptr %9, align 8, !tbaa !17
  %873 = load i32, ptr %10, align 4, !tbaa !9
  %874 = sub i32 %873, 3
  store i32 %874, ptr %10, align 4, !tbaa !9
  br label %788, !llvm.loop !35

875:                                              ; preds = %788
  br label %876

876:                                              ; preds = %882, %875
  %877 = load ptr, ptr %5, align 8, !tbaa !5
  %878 = getelementptr inbounds %struct.inflate_blocks_state, ptr %877, i32 0, i32 1
  %879 = getelementptr inbounds %struct.anon, ptr %878, i32 0, i32 1
  %880 = load i32, ptr %879, align 4, !tbaa !24
  %881 = icmp ult i32 %880, 19
  br i1 %881, label %882, label %897

882:                                              ; preds = %876
  %883 = load ptr, ptr %5, align 8, !tbaa !5
  %884 = getelementptr inbounds %struct.inflate_blocks_state, ptr %883, i32 0, i32 1
  %885 = getelementptr inbounds %struct.anon, ptr %884, i32 0, i32 2
  %886 = load ptr, ptr %885, align 8, !tbaa !24
  %887 = load ptr, ptr %5, align 8, !tbaa !5
  %888 = getelementptr inbounds %struct.inflate_blocks_state, ptr %887, i32 0, i32 1
  %889 = getelementptr inbounds %struct.anon, ptr %888, i32 0, i32 1
  %890 = load i32, ptr %889, align 4, !tbaa !24
  %891 = add i32 %890, 1
  store i32 %891, ptr %889, align 4, !tbaa !24
  %892 = zext i32 %890 to i64
  %893 = getelementptr inbounds [19 x i32], ptr @border, i64 0, i64 %892
  %894 = load i32, ptr %893, align 4, !tbaa !9
  %895 = zext i32 %894 to i64
  %896 = getelementptr inbounds i32, ptr %886, i64 %895
  store i32 0, ptr %896, align 4, !tbaa !9
  br label %876, !llvm.loop !36

897:                                              ; preds = %876
  %898 = load ptr, ptr %5, align 8, !tbaa !5
  %899 = getelementptr inbounds %struct.inflate_blocks_state, ptr %898, i32 0, i32 1
  %900 = getelementptr inbounds %struct.anon, ptr %899, i32 0, i32 3
  store i32 7, ptr %900, align 8, !tbaa !24
  %901 = load ptr, ptr %5, align 8, !tbaa !5
  %902 = getelementptr inbounds %struct.inflate_blocks_state, ptr %901, i32 0, i32 1
  %903 = getelementptr inbounds %struct.anon, ptr %902, i32 0, i32 2
  %904 = load ptr, ptr %903, align 8, !tbaa !24
  %905 = load ptr, ptr %5, align 8, !tbaa !5
  %906 = getelementptr inbounds %struct.inflate_blocks_state, ptr %905, i32 0, i32 1
  %907 = getelementptr inbounds %struct.anon, ptr %906, i32 0, i32 3
  %908 = load ptr, ptr %5, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.inflate_blocks_state, ptr %908, i32 0, i32 1
  %910 = getelementptr inbounds %struct.anon, ptr %909, i32 0, i32 4
  %911 = load ptr, ptr %5, align 8, !tbaa !5
  %912 = getelementptr inbounds %struct.inflate_blocks_state, ptr %911, i32 0, i32 5
  %913 = load ptr, ptr %912, align 8, !tbaa !37
  %914 = load ptr, ptr %6, align 8, !tbaa !5
  %915 = call i32 @inflate_trees_bits(ptr noundef %904, ptr noundef %907, ptr noundef %910, ptr noundef %913, ptr noundef %914)
  store i32 %915, ptr %8, align 4, !tbaa !9
  %916 = load i32, ptr %8, align 4, !tbaa !9
  %917 = icmp ne i32 %916, 0
  br i1 %917, label %918, label %966

918:                                              ; preds = %897
  %919 = load i32, ptr %8, align 4, !tbaa !9
  store i32 %919, ptr %7, align 4, !tbaa !9
  %920 = load i32, ptr %7, align 4, !tbaa !9
  %921 = icmp eq i32 %920, -3
  br i1 %921, label %922, label %935

922:                                              ; preds = %918
  %923 = load ptr, ptr %6, align 8, !tbaa !5
  %924 = getelementptr inbounds %struct.z_stream_s, ptr %923, i32 0, i32 9
  %925 = load ptr, ptr %924, align 8, !tbaa !38
  %926 = load ptr, ptr %6, align 8, !tbaa !5
  %927 = getelementptr inbounds %struct.z_stream_s, ptr %926, i32 0, i32 10
  %928 = load ptr, ptr %927, align 8, !tbaa !33
  %929 = load ptr, ptr %5, align 8, !tbaa !5
  %930 = getelementptr inbounds %struct.inflate_blocks_state, ptr %929, i32 0, i32 1
  %931 = getelementptr inbounds %struct.anon, ptr %930, i32 0, i32 2
  %932 = load ptr, ptr %931, align 8, !tbaa !24
  call void %925(ptr noundef %928, ptr noundef %932)
  %933 = load ptr, ptr %5, align 8, !tbaa !5
  %934 = getelementptr inbounds %struct.inflate_blocks_state, ptr %933, i32 0, i32 0
  store i32 9, ptr %934, align 8, !tbaa !22
  br label %935

935:                                              ; preds = %922, %918
  %936 = load i64, ptr %9, align 8, !tbaa !17
  %937 = load ptr, ptr %5, align 8, !tbaa !5
  %938 = getelementptr inbounds %struct.inflate_blocks_state, ptr %937, i32 0, i32 4
  store i64 %936, ptr %938, align 8, !tbaa !15
  %939 = load i32, ptr %10, align 4, !tbaa !9
  %940 = load ptr, ptr %5, align 8, !tbaa !5
  %941 = getelementptr inbounds %struct.inflate_blocks_state, ptr %940, i32 0, i32 3
  store i32 %939, ptr %941, align 4, !tbaa !18
  %942 = load i32, ptr %12, align 4, !tbaa !9
  %943 = load ptr, ptr %6, align 8, !tbaa !5
  %944 = getelementptr inbounds %struct.z_stream_s, ptr %943, i32 0, i32 1
  store i32 %942, ptr %944, align 8, !tbaa !14
  %945 = load ptr, ptr %11, align 8, !tbaa !5
  %946 = load ptr, ptr %6, align 8, !tbaa !5
  %947 = getelementptr inbounds %struct.z_stream_s, ptr %946, i32 0, i32 0
  %948 = load ptr, ptr %947, align 8, !tbaa !11
  %949 = ptrtoint ptr %945 to i64
  %950 = ptrtoint ptr %948 to i64
  %951 = sub i64 %949, %950
  %952 = load ptr, ptr %6, align 8, !tbaa !5
  %953 = getelementptr inbounds %struct.z_stream_s, ptr %952, i32 0, i32 2
  %954 = load i64, ptr %953, align 8, !tbaa !23
  %955 = add i64 %954, %951
  store i64 %955, ptr %953, align 8, !tbaa !23
  %956 = load ptr, ptr %11, align 8, !tbaa !5
  %957 = load ptr, ptr %6, align 8, !tbaa !5
  %958 = getelementptr inbounds %struct.z_stream_s, ptr %957, i32 0, i32 0
  store ptr %956, ptr %958, align 8, !tbaa !11
  %959 = load ptr, ptr %13, align 8, !tbaa !5
  %960 = load ptr, ptr %5, align 8, !tbaa !5
  %961 = getelementptr inbounds %struct.inflate_blocks_state, ptr %960, i32 0, i32 9
  store ptr %959, ptr %961, align 8, !tbaa !19
  %962 = load ptr, ptr %5, align 8, !tbaa !5
  %963 = load ptr, ptr %6, align 8, !tbaa !5
  %964 = load i32, ptr %7, align 4, !tbaa !9
  %965 = call i32 @inflate_flush(ptr noundef %962, ptr noundef %963, i32 noundef %964)
  store i32 %965, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

966:                                              ; preds = %897
  %967 = load ptr, ptr %5, align 8, !tbaa !5
  %968 = getelementptr inbounds %struct.inflate_blocks_state, ptr %967, i32 0, i32 1
  %969 = getelementptr inbounds %struct.anon, ptr %968, i32 0, i32 1
  store i32 0, ptr %969, align 4, !tbaa !24
  %970 = load ptr, ptr %5, align 8, !tbaa !5
  %971 = getelementptr inbounds %struct.inflate_blocks_state, ptr %970, i32 0, i32 0
  store i32 5, ptr %971, align 8, !tbaa !22
  br label %972

972:                                              ; preds = %966, %70
  br label %973

973:                                              ; preds = %1292, %972
  %974 = load ptr, ptr %5, align 8, !tbaa !5
  %975 = getelementptr inbounds %struct.inflate_blocks_state, ptr %974, i32 0, i32 1
  %976 = getelementptr inbounds %struct.anon, ptr %975, i32 0, i32 0
  %977 = load i32, ptr %976, align 8, !tbaa !24
  store i32 %977, ptr %8, align 4, !tbaa !9
  %978 = load ptr, ptr %5, align 8, !tbaa !5
  %979 = getelementptr inbounds %struct.inflate_blocks_state, ptr %978, i32 0, i32 1
  %980 = getelementptr inbounds %struct.anon, ptr %979, i32 0, i32 1
  %981 = load i32, ptr %980, align 4, !tbaa !24
  %982 = load i32, ptr %8, align 4, !tbaa !9
  %983 = and i32 %982, 31
  %984 = add i32 258, %983
  %985 = load i32, ptr %8, align 4, !tbaa !9
  %986 = lshr i32 %985, 5
  %987 = and i32 %986, 31
  %988 = add i32 %984, %987
  %989 = icmp ult i32 %981, %988
  br i1 %989, label %990, label %1293

990:                                              ; preds = %973
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #4
  %991 = load ptr, ptr %5, align 8, !tbaa !5
  %992 = getelementptr inbounds %struct.inflate_blocks_state, ptr %991, i32 0, i32 1
  %993 = getelementptr inbounds %struct.anon, ptr %992, i32 0, i32 3
  %994 = load i32, ptr %993, align 8, !tbaa !24
  store i32 %994, ptr %8, align 4, !tbaa !9
  br label %995

995:                                              ; preds = %1034, %990
  %996 = load i32, ptr %10, align 4, !tbaa !9
  %997 = load i32, ptr %8, align 4, !tbaa !9
  %998 = icmp ult i32 %996, %997
  br i1 %998, label %999, label %1048

999:                                              ; preds = %995
  %1000 = load i32, ptr %12, align 4, !tbaa !9
  %1001 = icmp ne i32 %1000, 0
  br i1 %1001, label %1002, label %1003

1002:                                             ; preds = %999
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %1034

1003:                                             ; preds = %999
  %1004 = load i64, ptr %9, align 8, !tbaa !17
  %1005 = load ptr, ptr %5, align 8, !tbaa !5
  %1006 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1005, i32 0, i32 4
  store i64 %1004, ptr %1006, align 8, !tbaa !15
  %1007 = load i32, ptr %10, align 4, !tbaa !9
  %1008 = load ptr, ptr %5, align 8, !tbaa !5
  %1009 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1008, i32 0, i32 3
  store i32 %1007, ptr %1009, align 4, !tbaa !18
  %1010 = load i32, ptr %12, align 4, !tbaa !9
  %1011 = load ptr, ptr %6, align 8, !tbaa !5
  %1012 = getelementptr inbounds %struct.z_stream_s, ptr %1011, i32 0, i32 1
  store i32 %1010, ptr %1012, align 8, !tbaa !14
  %1013 = load ptr, ptr %11, align 8, !tbaa !5
  %1014 = load ptr, ptr %6, align 8, !tbaa !5
  %1015 = getelementptr inbounds %struct.z_stream_s, ptr %1014, i32 0, i32 0
  %1016 = load ptr, ptr %1015, align 8, !tbaa !11
  %1017 = ptrtoint ptr %1013 to i64
  %1018 = ptrtoint ptr %1016 to i64
  %1019 = sub i64 %1017, %1018
  %1020 = load ptr, ptr %6, align 8, !tbaa !5
  %1021 = getelementptr inbounds %struct.z_stream_s, ptr %1020, i32 0, i32 2
  %1022 = load i64, ptr %1021, align 8, !tbaa !23
  %1023 = add i64 %1022, %1019
  store i64 %1023, ptr %1021, align 8, !tbaa !23
  %1024 = load ptr, ptr %11, align 8, !tbaa !5
  %1025 = load ptr, ptr %6, align 8, !tbaa !5
  %1026 = getelementptr inbounds %struct.z_stream_s, ptr %1025, i32 0, i32 0
  store ptr %1024, ptr %1026, align 8, !tbaa !11
  %1027 = load ptr, ptr %13, align 8, !tbaa !5
  %1028 = load ptr, ptr %5, align 8, !tbaa !5
  %1029 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1028, i32 0, i32 9
  store ptr %1027, ptr %1029, align 8, !tbaa !19
  %1030 = load ptr, ptr %5, align 8, !tbaa !5
  %1031 = load ptr, ptr %6, align 8, !tbaa !5
  %1032 = load i32, ptr %7, align 4, !tbaa !9
  %1033 = call i32 @inflate_flush(ptr noundef %1030, ptr noundef %1031, i32 noundef %1032)
  store i32 %1033, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1290

1034:                                             ; preds = %1002
  %1035 = load i32, ptr %12, align 4, !tbaa !9
  %1036 = add i32 %1035, -1
  store i32 %1036, ptr %12, align 4, !tbaa !9
  %1037 = load ptr, ptr %11, align 8, !tbaa !5
  %1038 = getelementptr inbounds i8, ptr %1037, i32 1
  store ptr %1038, ptr %11, align 8, !tbaa !5
  %1039 = load i8, ptr %1037, align 1, !tbaa !24
  %1040 = zext i8 %1039 to i64
  %1041 = load i32, ptr %10, align 4, !tbaa !9
  %1042 = zext i32 %1041 to i64
  %1043 = shl i64 %1040, %1042
  %1044 = load i64, ptr %9, align 8, !tbaa !17
  %1045 = or i64 %1044, %1043
  store i64 %1045, ptr %9, align 8, !tbaa !17
  %1046 = load i32, ptr %10, align 4, !tbaa !9
  %1047 = add i32 %1046, 8
  store i32 %1047, ptr %10, align 4, !tbaa !9
  br label %995, !llvm.loop !39

1048:                                             ; preds = %995
  %1049 = load ptr, ptr %5, align 8, !tbaa !5
  %1050 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1049, i32 0, i32 1
  %1051 = getelementptr inbounds %struct.anon, ptr %1050, i32 0, i32 4
  %1052 = load ptr, ptr %1051, align 8, !tbaa !24
  %1053 = load i64, ptr %9, align 8, !tbaa !17
  %1054 = trunc i64 %1053 to i32
  %1055 = load i32, ptr %8, align 4, !tbaa !9
  %1056 = zext i32 %1055 to i64
  %1057 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %1056
  %1058 = load i32, ptr %1057, align 4, !tbaa !9
  %1059 = and i32 %1054, %1058
  %1060 = zext i32 %1059 to i64
  %1061 = getelementptr inbounds %struct.inflate_huft_s, ptr %1052, i64 %1060
  store ptr %1061, ptr %20, align 8, !tbaa !5
  %1062 = load ptr, ptr %20, align 8, !tbaa !5
  %1063 = getelementptr inbounds %struct.inflate_huft_s, ptr %1062, i32 0, i32 0
  %1064 = getelementptr inbounds %struct.anon.2, ptr %1063, i32 0, i32 1
  %1065 = load i8, ptr %1064, align 1, !tbaa !24
  %1066 = zext i8 %1065 to i32
  store i32 %1066, ptr %8, align 4, !tbaa !9
  %1067 = load ptr, ptr %20, align 8, !tbaa !5
  %1068 = getelementptr inbounds %struct.inflate_huft_s, ptr %1067, i32 0, i32 1
  %1069 = load i32, ptr %1068, align 4, !tbaa !40
  store i32 %1069, ptr %23, align 4, !tbaa !9
  %1070 = load i32, ptr %23, align 4, !tbaa !9
  %1071 = icmp ult i32 %1070, 16
  br i1 %1071, label %1072, label %1092

1072:                                             ; preds = %1048
  %1073 = load i32, ptr %8, align 4, !tbaa !9
  %1074 = load i64, ptr %9, align 8, !tbaa !17
  %1075 = zext i32 %1073 to i64
  %1076 = lshr i64 %1074, %1075
  store i64 %1076, ptr %9, align 8, !tbaa !17
  %1077 = load i32, ptr %8, align 4, !tbaa !9
  %1078 = load i32, ptr %10, align 4, !tbaa !9
  %1079 = sub i32 %1078, %1077
  store i32 %1079, ptr %10, align 4, !tbaa !9
  %1080 = load i32, ptr %23, align 4, !tbaa !9
  %1081 = load ptr, ptr %5, align 8, !tbaa !5
  %1082 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1081, i32 0, i32 1
  %1083 = getelementptr inbounds %struct.anon, ptr %1082, i32 0, i32 2
  %1084 = load ptr, ptr %1083, align 8, !tbaa !24
  %1085 = load ptr, ptr %5, align 8, !tbaa !5
  %1086 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1085, i32 0, i32 1
  %1087 = getelementptr inbounds %struct.anon, ptr %1086, i32 0, i32 1
  %1088 = load i32, ptr %1087, align 4, !tbaa !24
  %1089 = add i32 %1088, 1
  store i32 %1089, ptr %1087, align 4, !tbaa !24
  %1090 = zext i32 %1088 to i64
  %1091 = getelementptr inbounds i32, ptr %1084, i64 %1090
  store i32 %1080, ptr %1091, align 4, !tbaa !9
  br label %1289

1092:                                             ; preds = %1048
  %1093 = load i32, ptr %23, align 4, !tbaa !9
  %1094 = icmp eq i32 %1093, 18
  br i1 %1094, label %1095, label %1096

1095:                                             ; preds = %1092
  br label %1099

1096:                                             ; preds = %1092
  %1097 = load i32, ptr %23, align 4, !tbaa !9
  %1098 = sub i32 %1097, 14
  br label %1099

1099:                                             ; preds = %1096, %1095
  %1100 = phi i32 [ 7, %1095 ], [ %1098, %1096 ]
  store i32 %1100, ptr %21, align 4, !tbaa !9
  %1101 = load i32, ptr %23, align 4, !tbaa !9
  %1102 = icmp eq i32 %1101, 18
  %1103 = zext i1 %1102 to i64
  %1104 = select i1 %1102, i32 11, i32 3
  store i32 %1104, ptr %22, align 4, !tbaa !9
  br label %1105

1105:                                             ; preds = %1146, %1099
  %1106 = load i32, ptr %10, align 4, !tbaa !9
  %1107 = load i32, ptr %8, align 4, !tbaa !9
  %1108 = load i32, ptr %21, align 4, !tbaa !9
  %1109 = add i32 %1107, %1108
  %1110 = icmp ult i32 %1106, %1109
  br i1 %1110, label %1111, label %1160

1111:                                             ; preds = %1105
  %1112 = load i32, ptr %12, align 4, !tbaa !9
  %1113 = icmp ne i32 %1112, 0
  br i1 %1113, label %1114, label %1115

1114:                                             ; preds = %1111
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %1146

1115:                                             ; preds = %1111
  %1116 = load i64, ptr %9, align 8, !tbaa !17
  %1117 = load ptr, ptr %5, align 8, !tbaa !5
  %1118 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1117, i32 0, i32 4
  store i64 %1116, ptr %1118, align 8, !tbaa !15
  %1119 = load i32, ptr %10, align 4, !tbaa !9
  %1120 = load ptr, ptr %5, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1120, i32 0, i32 3
  store i32 %1119, ptr %1121, align 4, !tbaa !18
  %1122 = load i32, ptr %12, align 4, !tbaa !9
  %1123 = load ptr, ptr %6, align 8, !tbaa !5
  %1124 = getelementptr inbounds %struct.z_stream_s, ptr %1123, i32 0, i32 1
  store i32 %1122, ptr %1124, align 8, !tbaa !14
  %1125 = load ptr, ptr %11, align 8, !tbaa !5
  %1126 = load ptr, ptr %6, align 8, !tbaa !5
  %1127 = getelementptr inbounds %struct.z_stream_s, ptr %1126, i32 0, i32 0
  %1128 = load ptr, ptr %1127, align 8, !tbaa !11
  %1129 = ptrtoint ptr %1125 to i64
  %1130 = ptrtoint ptr %1128 to i64
  %1131 = sub i64 %1129, %1130
  %1132 = load ptr, ptr %6, align 8, !tbaa !5
  %1133 = getelementptr inbounds %struct.z_stream_s, ptr %1132, i32 0, i32 2
  %1134 = load i64, ptr %1133, align 8, !tbaa !23
  %1135 = add i64 %1134, %1131
  store i64 %1135, ptr %1133, align 8, !tbaa !23
  %1136 = load ptr, ptr %11, align 8, !tbaa !5
  %1137 = load ptr, ptr %6, align 8, !tbaa !5
  %1138 = getelementptr inbounds %struct.z_stream_s, ptr %1137, i32 0, i32 0
  store ptr %1136, ptr %1138, align 8, !tbaa !11
  %1139 = load ptr, ptr %13, align 8, !tbaa !5
  %1140 = load ptr, ptr %5, align 8, !tbaa !5
  %1141 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1140, i32 0, i32 9
  store ptr %1139, ptr %1141, align 8, !tbaa !19
  %1142 = load ptr, ptr %5, align 8, !tbaa !5
  %1143 = load ptr, ptr %6, align 8, !tbaa !5
  %1144 = load i32, ptr %7, align 4, !tbaa !9
  %1145 = call i32 @inflate_flush(ptr noundef %1142, ptr noundef %1143, i32 noundef %1144)
  store i32 %1145, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1290

1146:                                             ; preds = %1114
  %1147 = load i32, ptr %12, align 4, !tbaa !9
  %1148 = add i32 %1147, -1
  store i32 %1148, ptr %12, align 4, !tbaa !9
  %1149 = load ptr, ptr %11, align 8, !tbaa !5
  %1150 = getelementptr inbounds i8, ptr %1149, i32 1
  store ptr %1150, ptr %11, align 8, !tbaa !5
  %1151 = load i8, ptr %1149, align 1, !tbaa !24
  %1152 = zext i8 %1151 to i64
  %1153 = load i32, ptr %10, align 4, !tbaa !9
  %1154 = zext i32 %1153 to i64
  %1155 = shl i64 %1152, %1154
  %1156 = load i64, ptr %9, align 8, !tbaa !17
  %1157 = or i64 %1156, %1155
  store i64 %1157, ptr %9, align 8, !tbaa !17
  %1158 = load i32, ptr %10, align 4, !tbaa !9
  %1159 = add i32 %1158, 8
  store i32 %1159, ptr %10, align 4, !tbaa !9
  br label %1105, !llvm.loop !42

1160:                                             ; preds = %1105
  %1161 = load i32, ptr %8, align 4, !tbaa !9
  %1162 = load i64, ptr %9, align 8, !tbaa !17
  %1163 = zext i32 %1161 to i64
  %1164 = lshr i64 %1162, %1163
  store i64 %1164, ptr %9, align 8, !tbaa !17
  %1165 = load i32, ptr %8, align 4, !tbaa !9
  %1166 = load i32, ptr %10, align 4, !tbaa !9
  %1167 = sub i32 %1166, %1165
  store i32 %1167, ptr %10, align 4, !tbaa !9
  %1168 = load i64, ptr %9, align 8, !tbaa !17
  %1169 = trunc i64 %1168 to i32
  %1170 = load i32, ptr %21, align 4, !tbaa !9
  %1171 = zext i32 %1170 to i64
  %1172 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %1171
  %1173 = load i32, ptr %1172, align 4, !tbaa !9
  %1174 = and i32 %1169, %1173
  %1175 = load i32, ptr %22, align 4, !tbaa !9
  %1176 = add i32 %1175, %1174
  store i32 %1176, ptr %22, align 4, !tbaa !9
  %1177 = load i32, ptr %21, align 4, !tbaa !9
  %1178 = load i64, ptr %9, align 8, !tbaa !17
  %1179 = zext i32 %1177 to i64
  %1180 = lshr i64 %1178, %1179
  store i64 %1180, ptr %9, align 8, !tbaa !17
  %1181 = load i32, ptr %21, align 4, !tbaa !9
  %1182 = load i32, ptr %10, align 4, !tbaa !9
  %1183 = sub i32 %1182, %1181
  store i32 %1183, ptr %10, align 4, !tbaa !9
  %1184 = load ptr, ptr %5, align 8, !tbaa !5
  %1185 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1184, i32 0, i32 1
  %1186 = getelementptr inbounds %struct.anon, ptr %1185, i32 0, i32 1
  %1187 = load i32, ptr %1186, align 4, !tbaa !24
  store i32 %1187, ptr %21, align 4, !tbaa !9
  %1188 = load ptr, ptr %5, align 8, !tbaa !5
  %1189 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1188, i32 0, i32 1
  %1190 = getelementptr inbounds %struct.anon, ptr %1189, i32 0, i32 0
  %1191 = load i32, ptr %1190, align 8, !tbaa !24
  store i32 %1191, ptr %8, align 4, !tbaa !9
  %1192 = load i32, ptr %21, align 4, !tbaa !9
  %1193 = load i32, ptr %22, align 4, !tbaa !9
  %1194 = add i32 %1192, %1193
  %1195 = load i32, ptr %8, align 4, !tbaa !9
  %1196 = and i32 %1195, 31
  %1197 = add i32 258, %1196
  %1198 = load i32, ptr %8, align 4, !tbaa !9
  %1199 = lshr i32 %1198, 5
  %1200 = and i32 %1199, 31
  %1201 = add i32 %1197, %1200
  %1202 = icmp ugt i32 %1194, %1201
  br i1 %1202, label %1209, label %1203

1203:                                             ; preds = %1160
  %1204 = load i32, ptr %23, align 4, !tbaa !9
  %1205 = icmp eq i32 %1204, 16
  br i1 %1205, label %1206, label %1254

1206:                                             ; preds = %1203
  %1207 = load i32, ptr %21, align 4, !tbaa !9
  %1208 = icmp ult i32 %1207, 1
  br i1 %1208, label %1209, label %1254

1209:                                             ; preds = %1206, %1160
  %1210 = load ptr, ptr %6, align 8, !tbaa !5
  %1211 = getelementptr inbounds %struct.z_stream_s, ptr %1210, i32 0, i32 9
  %1212 = load ptr, ptr %1211, align 8, !tbaa !38
  %1213 = load ptr, ptr %6, align 8, !tbaa !5
  %1214 = getelementptr inbounds %struct.z_stream_s, ptr %1213, i32 0, i32 10
  %1215 = load ptr, ptr %1214, align 8, !tbaa !33
  %1216 = load ptr, ptr %5, align 8, !tbaa !5
  %1217 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1216, i32 0, i32 1
  %1218 = getelementptr inbounds %struct.anon, ptr %1217, i32 0, i32 2
  %1219 = load ptr, ptr %1218, align 8, !tbaa !24
  call void %1212(ptr noundef %1215, ptr noundef %1219)
  %1220 = load ptr, ptr %5, align 8, !tbaa !5
  %1221 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1220, i32 0, i32 0
  store i32 9, ptr %1221, align 8, !tbaa !22
  %1222 = load ptr, ptr %6, align 8, !tbaa !5
  %1223 = getelementptr inbounds %struct.z_stream_s, ptr %1222, i32 0, i32 6
  store ptr @.str.3, ptr %1223, align 8, !tbaa !28
  store i32 -3, ptr %7, align 4, !tbaa !9
  %1224 = load i64, ptr %9, align 8, !tbaa !17
  %1225 = load ptr, ptr %5, align 8, !tbaa !5
  %1226 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1225, i32 0, i32 4
  store i64 %1224, ptr %1226, align 8, !tbaa !15
  %1227 = load i32, ptr %10, align 4, !tbaa !9
  %1228 = load ptr, ptr %5, align 8, !tbaa !5
  %1229 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1228, i32 0, i32 3
  store i32 %1227, ptr %1229, align 4, !tbaa !18
  %1230 = load i32, ptr %12, align 4, !tbaa !9
  %1231 = load ptr, ptr %6, align 8, !tbaa !5
  %1232 = getelementptr inbounds %struct.z_stream_s, ptr %1231, i32 0, i32 1
  store i32 %1230, ptr %1232, align 8, !tbaa !14
  %1233 = load ptr, ptr %11, align 8, !tbaa !5
  %1234 = load ptr, ptr %6, align 8, !tbaa !5
  %1235 = getelementptr inbounds %struct.z_stream_s, ptr %1234, i32 0, i32 0
  %1236 = load ptr, ptr %1235, align 8, !tbaa !11
  %1237 = ptrtoint ptr %1233 to i64
  %1238 = ptrtoint ptr %1236 to i64
  %1239 = sub i64 %1237, %1238
  %1240 = load ptr, ptr %6, align 8, !tbaa !5
  %1241 = getelementptr inbounds %struct.z_stream_s, ptr %1240, i32 0, i32 2
  %1242 = load i64, ptr %1241, align 8, !tbaa !23
  %1243 = add i64 %1242, %1239
  store i64 %1243, ptr %1241, align 8, !tbaa !23
  %1244 = load ptr, ptr %11, align 8, !tbaa !5
  %1245 = load ptr, ptr %6, align 8, !tbaa !5
  %1246 = getelementptr inbounds %struct.z_stream_s, ptr %1245, i32 0, i32 0
  store ptr %1244, ptr %1246, align 8, !tbaa !11
  %1247 = load ptr, ptr %13, align 8, !tbaa !5
  %1248 = load ptr, ptr %5, align 8, !tbaa !5
  %1249 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1248, i32 0, i32 9
  store ptr %1247, ptr %1249, align 8, !tbaa !19
  %1250 = load ptr, ptr %5, align 8, !tbaa !5
  %1251 = load ptr, ptr %6, align 8, !tbaa !5
  %1252 = load i32, ptr %7, align 4, !tbaa !9
  %1253 = call i32 @inflate_flush(ptr noundef %1250, ptr noundef %1251, i32 noundef %1252)
  store i32 %1253, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1290

1254:                                             ; preds = %1206, %1203
  %1255 = load i32, ptr %23, align 4, !tbaa !9
  %1256 = icmp eq i32 %1255, 16
  br i1 %1256, label %1257, label %1267

1257:                                             ; preds = %1254
  %1258 = load ptr, ptr %5, align 8, !tbaa !5
  %1259 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1258, i32 0, i32 1
  %1260 = getelementptr inbounds %struct.anon, ptr %1259, i32 0, i32 2
  %1261 = load ptr, ptr %1260, align 8, !tbaa !24
  %1262 = load i32, ptr %21, align 4, !tbaa !9
  %1263 = sub i32 %1262, 1
  %1264 = zext i32 %1263 to i64
  %1265 = getelementptr inbounds i32, ptr %1261, i64 %1264
  %1266 = load i32, ptr %1265, align 4, !tbaa !9
  br label %1268

1267:                                             ; preds = %1254
  br label %1268

1268:                                             ; preds = %1267, %1257
  %1269 = phi i32 [ %1266, %1257 ], [ 0, %1267 ]
  store i32 %1269, ptr %23, align 4, !tbaa !9
  br label %1270

1270:                                             ; preds = %1280, %1268
  %1271 = load i32, ptr %23, align 4, !tbaa !9
  %1272 = load ptr, ptr %5, align 8, !tbaa !5
  %1273 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1272, i32 0, i32 1
  %1274 = getelementptr inbounds %struct.anon, ptr %1273, i32 0, i32 2
  %1275 = load ptr, ptr %1274, align 8, !tbaa !24
  %1276 = load i32, ptr %21, align 4, !tbaa !9
  %1277 = add i32 %1276, 1
  store i32 %1277, ptr %21, align 4, !tbaa !9
  %1278 = zext i32 %1276 to i64
  %1279 = getelementptr inbounds i32, ptr %1275, i64 %1278
  store i32 %1271, ptr %1279, align 4, !tbaa !9
  br label %1280

1280:                                             ; preds = %1270
  %1281 = load i32, ptr %22, align 4, !tbaa !9
  %1282 = add i32 %1281, -1
  store i32 %1282, ptr %22, align 4, !tbaa !9
  %1283 = icmp ne i32 %1282, 0
  br i1 %1283, label %1270, label %1284, !llvm.loop !43

1284:                                             ; preds = %1280
  %1285 = load i32, ptr %21, align 4, !tbaa !9
  %1286 = load ptr, ptr %5, align 8, !tbaa !5
  %1287 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1286, i32 0, i32 1
  %1288 = getelementptr inbounds %struct.anon, ptr %1287, i32 0, i32 1
  store i32 %1285, ptr %1288, align 4, !tbaa !24
  br label %1289

1289:                                             ; preds = %1284, %1072
  store i32 0, ptr %15, align 4
  br label %1290

1290:                                             ; preds = %1289, %1209, %1115, %1003
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #4
  %1291 = load i32, ptr %15, align 4
  switch i32 %1291, label %1690 [
    i32 0, label %1292
  ]

1292:                                             ; preds = %1290
  br label %973, !llvm.loop !44

1293:                                             ; preds = %973
  %1294 = load ptr, ptr %5, align 8, !tbaa !5
  %1295 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1294, i32 0, i32 1
  %1296 = getelementptr inbounds %struct.anon, ptr %1295, i32 0, i32 4
  store ptr null, ptr %1296, align 8, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #4
  store i32 9, ptr %24, align 4, !tbaa !9
  store i32 6, ptr %25, align 4, !tbaa !9
  %1297 = load ptr, ptr %5, align 8, !tbaa !5
  %1298 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1297, i32 0, i32 1
  %1299 = getelementptr inbounds %struct.anon, ptr %1298, i32 0, i32 0
  %1300 = load i32, ptr %1299, align 8, !tbaa !24
  store i32 %1300, ptr %8, align 4, !tbaa !9
  %1301 = load i32, ptr %8, align 4, !tbaa !9
  %1302 = and i32 %1301, 31
  %1303 = add i32 257, %1302
  %1304 = load i32, ptr %8, align 4, !tbaa !9
  %1305 = lshr i32 %1304, 5
  %1306 = and i32 %1305, 31
  %1307 = add i32 1, %1306
  %1308 = load ptr, ptr %5, align 8, !tbaa !5
  %1309 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1308, i32 0, i32 1
  %1310 = getelementptr inbounds %struct.anon, ptr %1309, i32 0, i32 2
  %1311 = load ptr, ptr %1310, align 8, !tbaa !24
  %1312 = load ptr, ptr %5, align 8, !tbaa !5
  %1313 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1312, i32 0, i32 5
  %1314 = load ptr, ptr %1313, align 8, !tbaa !37
  %1315 = load ptr, ptr %6, align 8, !tbaa !5
  %1316 = call i32 @inflate_trees_dynamic(i32 noundef %1303, i32 noundef %1307, ptr noundef %1311, ptr noundef %24, ptr noundef %25, ptr noundef %26, ptr noundef %27, ptr noundef %1314, ptr noundef %1315)
  store i32 %1316, ptr %8, align 4, !tbaa !9
  %1317 = load i32, ptr %8, align 4, !tbaa !9
  %1318 = icmp ne i32 %1317, 0
  br i1 %1318, label %1319, label %1367

1319:                                             ; preds = %1293
  %1320 = load i32, ptr %8, align 4, !tbaa !9
  %1321 = icmp eq i32 %1320, -3
  br i1 %1321, label %1322, label %1335

1322:                                             ; preds = %1319
  %1323 = load ptr, ptr %6, align 8, !tbaa !5
  %1324 = getelementptr inbounds %struct.z_stream_s, ptr %1323, i32 0, i32 9
  %1325 = load ptr, ptr %1324, align 8, !tbaa !38
  %1326 = load ptr, ptr %6, align 8, !tbaa !5
  %1327 = getelementptr inbounds %struct.z_stream_s, ptr %1326, i32 0, i32 10
  %1328 = load ptr, ptr %1327, align 8, !tbaa !33
  %1329 = load ptr, ptr %5, align 8, !tbaa !5
  %1330 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1329, i32 0, i32 1
  %1331 = getelementptr inbounds %struct.anon, ptr %1330, i32 0, i32 2
  %1332 = load ptr, ptr %1331, align 8, !tbaa !24
  call void %1325(ptr noundef %1328, ptr noundef %1332)
  %1333 = load ptr, ptr %5, align 8, !tbaa !5
  %1334 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1333, i32 0, i32 0
  store i32 9, ptr %1334, align 8, !tbaa !22
  br label %1335

1335:                                             ; preds = %1322, %1319
  %1336 = load i32, ptr %8, align 4, !tbaa !9
  store i32 %1336, ptr %7, align 4, !tbaa !9
  %1337 = load i64, ptr %9, align 8, !tbaa !17
  %1338 = load ptr, ptr %5, align 8, !tbaa !5
  %1339 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1338, i32 0, i32 4
  store i64 %1337, ptr %1339, align 8, !tbaa !15
  %1340 = load i32, ptr %10, align 4, !tbaa !9
  %1341 = load ptr, ptr %5, align 8, !tbaa !5
  %1342 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1341, i32 0, i32 3
  store i32 %1340, ptr %1342, align 4, !tbaa !18
  %1343 = load i32, ptr %12, align 4, !tbaa !9
  %1344 = load ptr, ptr %6, align 8, !tbaa !5
  %1345 = getelementptr inbounds %struct.z_stream_s, ptr %1344, i32 0, i32 1
  store i32 %1343, ptr %1345, align 8, !tbaa !14
  %1346 = load ptr, ptr %11, align 8, !tbaa !5
  %1347 = load ptr, ptr %6, align 8, !tbaa !5
  %1348 = getelementptr inbounds %struct.z_stream_s, ptr %1347, i32 0, i32 0
  %1349 = load ptr, ptr %1348, align 8, !tbaa !11
  %1350 = ptrtoint ptr %1346 to i64
  %1351 = ptrtoint ptr %1349 to i64
  %1352 = sub i64 %1350, %1351
  %1353 = load ptr, ptr %6, align 8, !tbaa !5
  %1354 = getelementptr inbounds %struct.z_stream_s, ptr %1353, i32 0, i32 2
  %1355 = load i64, ptr %1354, align 8, !tbaa !23
  %1356 = add i64 %1355, %1352
  store i64 %1356, ptr %1354, align 8, !tbaa !23
  %1357 = load ptr, ptr %11, align 8, !tbaa !5
  %1358 = load ptr, ptr %6, align 8, !tbaa !5
  %1359 = getelementptr inbounds %struct.z_stream_s, ptr %1358, i32 0, i32 0
  store ptr %1357, ptr %1359, align 8, !tbaa !11
  %1360 = load ptr, ptr %13, align 8, !tbaa !5
  %1361 = load ptr, ptr %5, align 8, !tbaa !5
  %1362 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1361, i32 0, i32 9
  store ptr %1360, ptr %1362, align 8, !tbaa !19
  %1363 = load ptr, ptr %5, align 8, !tbaa !5
  %1364 = load ptr, ptr %6, align 8, !tbaa !5
  %1365 = load i32, ptr %7, align 4, !tbaa !9
  %1366 = call i32 @inflate_flush(ptr noundef %1363, ptr noundef %1364, i32 noundef %1365)
  store i32 %1366, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1411

1367:                                             ; preds = %1293
  %1368 = load i32, ptr %24, align 4, !tbaa !9
  %1369 = load i32, ptr %25, align 4, !tbaa !9
  %1370 = load ptr, ptr %26, align 8, !tbaa !5
  %1371 = load ptr, ptr %27, align 8, !tbaa !5
  %1372 = load ptr, ptr %6, align 8, !tbaa !5
  %1373 = call ptr @inflate_codes_new(i32 noundef %1368, i32 noundef %1369, ptr noundef %1370, ptr noundef %1371, ptr noundef %1372)
  store ptr %1373, ptr %28, align 8, !tbaa !5
  %1374 = icmp eq ptr %1373, null
  br i1 %1374, label %1375, label %1406

1375:                                             ; preds = %1367
  store i32 -4, ptr %7, align 4, !tbaa !9
  %1376 = load i64, ptr %9, align 8, !tbaa !17
  %1377 = load ptr, ptr %5, align 8, !tbaa !5
  %1378 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1377, i32 0, i32 4
  store i64 %1376, ptr %1378, align 8, !tbaa !15
  %1379 = load i32, ptr %10, align 4, !tbaa !9
  %1380 = load ptr, ptr %5, align 8, !tbaa !5
  %1381 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1380, i32 0, i32 3
  store i32 %1379, ptr %1381, align 4, !tbaa !18
  %1382 = load i32, ptr %12, align 4, !tbaa !9
  %1383 = load ptr, ptr %6, align 8, !tbaa !5
  %1384 = getelementptr inbounds %struct.z_stream_s, ptr %1383, i32 0, i32 1
  store i32 %1382, ptr %1384, align 8, !tbaa !14
  %1385 = load ptr, ptr %11, align 8, !tbaa !5
  %1386 = load ptr, ptr %6, align 8, !tbaa !5
  %1387 = getelementptr inbounds %struct.z_stream_s, ptr %1386, i32 0, i32 0
  %1388 = load ptr, ptr %1387, align 8, !tbaa !11
  %1389 = ptrtoint ptr %1385 to i64
  %1390 = ptrtoint ptr %1388 to i64
  %1391 = sub i64 %1389, %1390
  %1392 = load ptr, ptr %6, align 8, !tbaa !5
  %1393 = getelementptr inbounds %struct.z_stream_s, ptr %1392, i32 0, i32 2
  %1394 = load i64, ptr %1393, align 8, !tbaa !23
  %1395 = add i64 %1394, %1391
  store i64 %1395, ptr %1393, align 8, !tbaa !23
  %1396 = load ptr, ptr %11, align 8, !tbaa !5
  %1397 = load ptr, ptr %6, align 8, !tbaa !5
  %1398 = getelementptr inbounds %struct.z_stream_s, ptr %1397, i32 0, i32 0
  store ptr %1396, ptr %1398, align 8, !tbaa !11
  %1399 = load ptr, ptr %13, align 8, !tbaa !5
  %1400 = load ptr, ptr %5, align 8, !tbaa !5
  %1401 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1400, i32 0, i32 9
  store ptr %1399, ptr %1401, align 8, !tbaa !19
  %1402 = load ptr, ptr %5, align 8, !tbaa !5
  %1403 = load ptr, ptr %6, align 8, !tbaa !5
  %1404 = load i32, ptr %7, align 4, !tbaa !9
  %1405 = call i32 @inflate_flush(ptr noundef %1402, ptr noundef %1403, i32 noundef %1404)
  store i32 %1405, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1411

1406:                                             ; preds = %1367
  %1407 = load ptr, ptr %28, align 8, !tbaa !5
  %1408 = load ptr, ptr %5, align 8, !tbaa !5
  %1409 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1408, i32 0, i32 1
  %1410 = getelementptr inbounds %struct.anon.0, ptr %1409, i32 0, i32 0
  store ptr %1407, ptr %1410, align 8, !tbaa !24
  store i32 0, ptr %15, align 4
  br label %1411

1411:                                             ; preds = %1406, %1375, %1335
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  %1412 = load i32, ptr %15, align 4
  switch i32 %1412, label %1690 [
    i32 0, label %1413
  ]

1413:                                             ; preds = %1411
  %1414 = load ptr, ptr %6, align 8, !tbaa !5
  %1415 = getelementptr inbounds %struct.z_stream_s, ptr %1414, i32 0, i32 9
  %1416 = load ptr, ptr %1415, align 8, !tbaa !38
  %1417 = load ptr, ptr %6, align 8, !tbaa !5
  %1418 = getelementptr inbounds %struct.z_stream_s, ptr %1417, i32 0, i32 10
  %1419 = load ptr, ptr %1418, align 8, !tbaa !33
  %1420 = load ptr, ptr %5, align 8, !tbaa !5
  %1421 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1420, i32 0, i32 1
  %1422 = getelementptr inbounds %struct.anon, ptr %1421, i32 0, i32 2
  %1423 = load ptr, ptr %1422, align 8, !tbaa !24
  call void %1416(ptr noundef %1419, ptr noundef %1423)
  %1424 = load ptr, ptr %5, align 8, !tbaa !5
  %1425 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1424, i32 0, i32 0
  store i32 6, ptr %1425, align 8, !tbaa !22
  br label %1426

1426:                                             ; preds = %1413, %70
  %1427 = load i64, ptr %9, align 8, !tbaa !17
  %1428 = load ptr, ptr %5, align 8, !tbaa !5
  %1429 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1428, i32 0, i32 4
  store i64 %1427, ptr %1429, align 8, !tbaa !15
  %1430 = load i32, ptr %10, align 4, !tbaa !9
  %1431 = load ptr, ptr %5, align 8, !tbaa !5
  %1432 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1431, i32 0, i32 3
  store i32 %1430, ptr %1432, align 4, !tbaa !18
  %1433 = load i32, ptr %12, align 4, !tbaa !9
  %1434 = load ptr, ptr %6, align 8, !tbaa !5
  %1435 = getelementptr inbounds %struct.z_stream_s, ptr %1434, i32 0, i32 1
  store i32 %1433, ptr %1435, align 8, !tbaa !14
  %1436 = load ptr, ptr %11, align 8, !tbaa !5
  %1437 = load ptr, ptr %6, align 8, !tbaa !5
  %1438 = getelementptr inbounds %struct.z_stream_s, ptr %1437, i32 0, i32 0
  %1439 = load ptr, ptr %1438, align 8, !tbaa !11
  %1440 = ptrtoint ptr %1436 to i64
  %1441 = ptrtoint ptr %1439 to i64
  %1442 = sub i64 %1440, %1441
  %1443 = load ptr, ptr %6, align 8, !tbaa !5
  %1444 = getelementptr inbounds %struct.z_stream_s, ptr %1443, i32 0, i32 2
  %1445 = load i64, ptr %1444, align 8, !tbaa !23
  %1446 = add i64 %1445, %1442
  store i64 %1446, ptr %1444, align 8, !tbaa !23
  %1447 = load ptr, ptr %11, align 8, !tbaa !5
  %1448 = load ptr, ptr %6, align 8, !tbaa !5
  %1449 = getelementptr inbounds %struct.z_stream_s, ptr %1448, i32 0, i32 0
  store ptr %1447, ptr %1449, align 8, !tbaa !11
  %1450 = load ptr, ptr %13, align 8, !tbaa !5
  %1451 = load ptr, ptr %5, align 8, !tbaa !5
  %1452 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1451, i32 0, i32 9
  store ptr %1450, ptr %1452, align 8, !tbaa !19
  %1453 = load ptr, ptr %5, align 8, !tbaa !5
  %1454 = load ptr, ptr %6, align 8, !tbaa !5
  %1455 = load i32, ptr %7, align 4, !tbaa !9
  %1456 = call i32 @inflate_codes(ptr noundef %1453, ptr noundef %1454, i32 noundef %1455)
  store i32 %1456, ptr %7, align 4, !tbaa !9
  %1457 = icmp ne i32 %1456, 1
  br i1 %1457, label %1458, label %1463

1458:                                             ; preds = %1426
  %1459 = load ptr, ptr %5, align 8, !tbaa !5
  %1460 = load ptr, ptr %6, align 8, !tbaa !5
  %1461 = load i32, ptr %7, align 4, !tbaa !9
  %1462 = call i32 @inflate_flush(ptr noundef %1459, ptr noundef %1460, i32 noundef %1461)
  store i32 %1462, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

1463:                                             ; preds = %1426
  store i32 0, ptr %7, align 4, !tbaa !9
  %1464 = load ptr, ptr %5, align 8, !tbaa !5
  %1465 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1464, i32 0, i32 1
  %1466 = getelementptr inbounds %struct.anon.0, ptr %1465, i32 0, i32 0
  %1467 = load ptr, ptr %1466, align 8, !tbaa !24
  %1468 = load ptr, ptr %6, align 8, !tbaa !5
  call void @inflate_codes_free(ptr noundef %1467, ptr noundef %1468)
  %1469 = load ptr, ptr %6, align 8, !tbaa !5
  %1470 = getelementptr inbounds %struct.z_stream_s, ptr %1469, i32 0, i32 0
  %1471 = load ptr, ptr %1470, align 8, !tbaa !11
  store ptr %1471, ptr %11, align 8, !tbaa !5
  %1472 = load ptr, ptr %6, align 8, !tbaa !5
  %1473 = getelementptr inbounds %struct.z_stream_s, ptr %1472, i32 0, i32 1
  %1474 = load i32, ptr %1473, align 8, !tbaa !14
  store i32 %1474, ptr %12, align 4, !tbaa !9
  %1475 = load ptr, ptr %5, align 8, !tbaa !5
  %1476 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1475, i32 0, i32 4
  %1477 = load i64, ptr %1476, align 8, !tbaa !15
  store i64 %1477, ptr %9, align 8, !tbaa !17
  %1478 = load ptr, ptr %5, align 8, !tbaa !5
  %1479 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1478, i32 0, i32 3
  %1480 = load i32, ptr %1479, align 4, !tbaa !18
  store i32 %1480, ptr %10, align 4, !tbaa !9
  %1481 = load ptr, ptr %5, align 8, !tbaa !5
  %1482 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1481, i32 0, i32 9
  %1483 = load ptr, ptr %1482, align 8, !tbaa !19
  store ptr %1483, ptr %13, align 8, !tbaa !5
  %1484 = load ptr, ptr %13, align 8, !tbaa !5
  %1485 = load ptr, ptr %5, align 8, !tbaa !5
  %1486 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1485, i32 0, i32 8
  %1487 = load ptr, ptr %1486, align 8, !tbaa !20
  %1488 = icmp ult ptr %1484, %1487
  br i1 %1488, label %1489, label %1498

1489:                                             ; preds = %1463
  %1490 = load ptr, ptr %5, align 8, !tbaa !5
  %1491 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1490, i32 0, i32 8
  %1492 = load ptr, ptr %1491, align 8, !tbaa !20
  %1493 = load ptr, ptr %13, align 8, !tbaa !5
  %1494 = ptrtoint ptr %1492 to i64
  %1495 = ptrtoint ptr %1493 to i64
  %1496 = sub i64 %1494, %1495
  %1497 = sub nsw i64 %1496, 1
  br label %1506

1498:                                             ; preds = %1463
  %1499 = load ptr, ptr %5, align 8, !tbaa !5
  %1500 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1499, i32 0, i32 7
  %1501 = load ptr, ptr %1500, align 8, !tbaa !21
  %1502 = load ptr, ptr %13, align 8, !tbaa !5
  %1503 = ptrtoint ptr %1501 to i64
  %1504 = ptrtoint ptr %1502 to i64
  %1505 = sub i64 %1503, %1504
  br label %1506

1506:                                             ; preds = %1498, %1489
  %1507 = phi i64 [ %1497, %1489 ], [ %1505, %1498 ]
  %1508 = trunc i64 %1507 to i32
  store i32 %1508, ptr %14, align 4, !tbaa !9
  %1509 = load ptr, ptr %5, align 8, !tbaa !5
  %1510 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1509, i32 0, i32 2
  %1511 = load i32, ptr %1510, align 8, !tbaa !27
  %1512 = icmp ne i32 %1511, 0
  br i1 %1512, label %1516, label %1513

1513:                                             ; preds = %1506
  %1514 = load ptr, ptr %5, align 8, !tbaa !5
  %1515 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1514, i32 0, i32 0
  store i32 0, ptr %1515, align 8, !tbaa !22
  br label %1689

1516:                                             ; preds = %1506
  %1517 = load ptr, ptr %5, align 8, !tbaa !5
  %1518 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1517, i32 0, i32 0
  store i32 7, ptr %1518, align 8, !tbaa !22
  br label %1519

1519:                                             ; preds = %1516, %70
  %1520 = load ptr, ptr %13, align 8, !tbaa !5
  %1521 = load ptr, ptr %5, align 8, !tbaa !5
  %1522 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1521, i32 0, i32 9
  store ptr %1520, ptr %1522, align 8, !tbaa !19
  %1523 = load ptr, ptr %5, align 8, !tbaa !5
  %1524 = load ptr, ptr %6, align 8, !tbaa !5
  %1525 = load i32, ptr %7, align 4, !tbaa !9
  %1526 = call i32 @inflate_flush(ptr noundef %1523, ptr noundef %1524, i32 noundef %1525)
  store i32 %1526, ptr %7, align 4, !tbaa !9
  %1527 = load ptr, ptr %5, align 8, !tbaa !5
  %1528 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1527, i32 0, i32 9
  %1529 = load ptr, ptr %1528, align 8, !tbaa !19
  store ptr %1529, ptr %13, align 8, !tbaa !5
  %1530 = load ptr, ptr %13, align 8, !tbaa !5
  %1531 = load ptr, ptr %5, align 8, !tbaa !5
  %1532 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1531, i32 0, i32 8
  %1533 = load ptr, ptr %1532, align 8, !tbaa !20
  %1534 = icmp ult ptr %1530, %1533
  br i1 %1534, label %1535, label %1544

1535:                                             ; preds = %1519
  %1536 = load ptr, ptr %5, align 8, !tbaa !5
  %1537 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1536, i32 0, i32 8
  %1538 = load ptr, ptr %1537, align 8, !tbaa !20
  %1539 = load ptr, ptr %13, align 8, !tbaa !5
  %1540 = ptrtoint ptr %1538 to i64
  %1541 = ptrtoint ptr %1539 to i64
  %1542 = sub i64 %1540, %1541
  %1543 = sub nsw i64 %1542, 1
  br label %1552

1544:                                             ; preds = %1519
  %1545 = load ptr, ptr %5, align 8, !tbaa !5
  %1546 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1545, i32 0, i32 7
  %1547 = load ptr, ptr %1546, align 8, !tbaa !21
  %1548 = load ptr, ptr %13, align 8, !tbaa !5
  %1549 = ptrtoint ptr %1547 to i64
  %1550 = ptrtoint ptr %1548 to i64
  %1551 = sub i64 %1549, %1550
  br label %1552

1552:                                             ; preds = %1544, %1535
  %1553 = phi i64 [ %1543, %1535 ], [ %1551, %1544 ]
  %1554 = trunc i64 %1553 to i32
  store i32 %1554, ptr %14, align 4, !tbaa !9
  %1555 = load ptr, ptr %5, align 8, !tbaa !5
  %1556 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1555, i32 0, i32 8
  %1557 = load ptr, ptr %1556, align 8, !tbaa !20
  %1558 = load ptr, ptr %5, align 8, !tbaa !5
  %1559 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1558, i32 0, i32 9
  %1560 = load ptr, ptr %1559, align 8, !tbaa !19
  %1561 = icmp ne ptr %1557, %1560
  br i1 %1561, label %1562, label %1593

1562:                                             ; preds = %1552
  %1563 = load i64, ptr %9, align 8, !tbaa !17
  %1564 = load ptr, ptr %5, align 8, !tbaa !5
  %1565 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1564, i32 0, i32 4
  store i64 %1563, ptr %1565, align 8, !tbaa !15
  %1566 = load i32, ptr %10, align 4, !tbaa !9
  %1567 = load ptr, ptr %5, align 8, !tbaa !5
  %1568 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1567, i32 0, i32 3
  store i32 %1566, ptr %1568, align 4, !tbaa !18
  %1569 = load i32, ptr %12, align 4, !tbaa !9
  %1570 = load ptr, ptr %6, align 8, !tbaa !5
  %1571 = getelementptr inbounds %struct.z_stream_s, ptr %1570, i32 0, i32 1
  store i32 %1569, ptr %1571, align 8, !tbaa !14
  %1572 = load ptr, ptr %11, align 8, !tbaa !5
  %1573 = load ptr, ptr %6, align 8, !tbaa !5
  %1574 = getelementptr inbounds %struct.z_stream_s, ptr %1573, i32 0, i32 0
  %1575 = load ptr, ptr %1574, align 8, !tbaa !11
  %1576 = ptrtoint ptr %1572 to i64
  %1577 = ptrtoint ptr %1575 to i64
  %1578 = sub i64 %1576, %1577
  %1579 = load ptr, ptr %6, align 8, !tbaa !5
  %1580 = getelementptr inbounds %struct.z_stream_s, ptr %1579, i32 0, i32 2
  %1581 = load i64, ptr %1580, align 8, !tbaa !23
  %1582 = add i64 %1581, %1578
  store i64 %1582, ptr %1580, align 8, !tbaa !23
  %1583 = load ptr, ptr %11, align 8, !tbaa !5
  %1584 = load ptr, ptr %6, align 8, !tbaa !5
  %1585 = getelementptr inbounds %struct.z_stream_s, ptr %1584, i32 0, i32 0
  store ptr %1583, ptr %1585, align 8, !tbaa !11
  %1586 = load ptr, ptr %13, align 8, !tbaa !5
  %1587 = load ptr, ptr %5, align 8, !tbaa !5
  %1588 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1587, i32 0, i32 9
  store ptr %1586, ptr %1588, align 8, !tbaa !19
  %1589 = load ptr, ptr %5, align 8, !tbaa !5
  %1590 = load ptr, ptr %6, align 8, !tbaa !5
  %1591 = load i32, ptr %7, align 4, !tbaa !9
  %1592 = call i32 @inflate_flush(ptr noundef %1589, ptr noundef %1590, i32 noundef %1591)
  store i32 %1592, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

1593:                                             ; preds = %1552
  %1594 = load ptr, ptr %5, align 8, !tbaa !5
  %1595 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1594, i32 0, i32 0
  store i32 8, ptr %1595, align 8, !tbaa !22
  br label %1596

1596:                                             ; preds = %1593, %70
  store i32 1, ptr %7, align 4, !tbaa !9
  %1597 = load i64, ptr %9, align 8, !tbaa !17
  %1598 = load ptr, ptr %5, align 8, !tbaa !5
  %1599 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1598, i32 0, i32 4
  store i64 %1597, ptr %1599, align 8, !tbaa !15
  %1600 = load i32, ptr %10, align 4, !tbaa !9
  %1601 = load ptr, ptr %5, align 8, !tbaa !5
  %1602 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1601, i32 0, i32 3
  store i32 %1600, ptr %1602, align 4, !tbaa !18
  %1603 = load i32, ptr %12, align 4, !tbaa !9
  %1604 = load ptr, ptr %6, align 8, !tbaa !5
  %1605 = getelementptr inbounds %struct.z_stream_s, ptr %1604, i32 0, i32 1
  store i32 %1603, ptr %1605, align 8, !tbaa !14
  %1606 = load ptr, ptr %11, align 8, !tbaa !5
  %1607 = load ptr, ptr %6, align 8, !tbaa !5
  %1608 = getelementptr inbounds %struct.z_stream_s, ptr %1607, i32 0, i32 0
  %1609 = load ptr, ptr %1608, align 8, !tbaa !11
  %1610 = ptrtoint ptr %1606 to i64
  %1611 = ptrtoint ptr %1609 to i64
  %1612 = sub i64 %1610, %1611
  %1613 = load ptr, ptr %6, align 8, !tbaa !5
  %1614 = getelementptr inbounds %struct.z_stream_s, ptr %1613, i32 0, i32 2
  %1615 = load i64, ptr %1614, align 8, !tbaa !23
  %1616 = add i64 %1615, %1612
  store i64 %1616, ptr %1614, align 8, !tbaa !23
  %1617 = load ptr, ptr %11, align 8, !tbaa !5
  %1618 = load ptr, ptr %6, align 8, !tbaa !5
  %1619 = getelementptr inbounds %struct.z_stream_s, ptr %1618, i32 0, i32 0
  store ptr %1617, ptr %1619, align 8, !tbaa !11
  %1620 = load ptr, ptr %13, align 8, !tbaa !5
  %1621 = load ptr, ptr %5, align 8, !tbaa !5
  %1622 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1621, i32 0, i32 9
  store ptr %1620, ptr %1622, align 8, !tbaa !19
  %1623 = load ptr, ptr %5, align 8, !tbaa !5
  %1624 = load ptr, ptr %6, align 8, !tbaa !5
  %1625 = load i32, ptr %7, align 4, !tbaa !9
  %1626 = call i32 @inflate_flush(ptr noundef %1623, ptr noundef %1624, i32 noundef %1625)
  store i32 %1626, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

1627:                                             ; preds = %70
  store i32 -3, ptr %7, align 4, !tbaa !9
  %1628 = load i64, ptr %9, align 8, !tbaa !17
  %1629 = load ptr, ptr %5, align 8, !tbaa !5
  %1630 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1629, i32 0, i32 4
  store i64 %1628, ptr %1630, align 8, !tbaa !15
  %1631 = load i32, ptr %10, align 4, !tbaa !9
  %1632 = load ptr, ptr %5, align 8, !tbaa !5
  %1633 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1632, i32 0, i32 3
  store i32 %1631, ptr %1633, align 4, !tbaa !18
  %1634 = load i32, ptr %12, align 4, !tbaa !9
  %1635 = load ptr, ptr %6, align 8, !tbaa !5
  %1636 = getelementptr inbounds %struct.z_stream_s, ptr %1635, i32 0, i32 1
  store i32 %1634, ptr %1636, align 8, !tbaa !14
  %1637 = load ptr, ptr %11, align 8, !tbaa !5
  %1638 = load ptr, ptr %6, align 8, !tbaa !5
  %1639 = getelementptr inbounds %struct.z_stream_s, ptr %1638, i32 0, i32 0
  %1640 = load ptr, ptr %1639, align 8, !tbaa !11
  %1641 = ptrtoint ptr %1637 to i64
  %1642 = ptrtoint ptr %1640 to i64
  %1643 = sub i64 %1641, %1642
  %1644 = load ptr, ptr %6, align 8, !tbaa !5
  %1645 = getelementptr inbounds %struct.z_stream_s, ptr %1644, i32 0, i32 2
  %1646 = load i64, ptr %1645, align 8, !tbaa !23
  %1647 = add i64 %1646, %1643
  store i64 %1647, ptr %1645, align 8, !tbaa !23
  %1648 = load ptr, ptr %11, align 8, !tbaa !5
  %1649 = load ptr, ptr %6, align 8, !tbaa !5
  %1650 = getelementptr inbounds %struct.z_stream_s, ptr %1649, i32 0, i32 0
  store ptr %1648, ptr %1650, align 8, !tbaa !11
  %1651 = load ptr, ptr %13, align 8, !tbaa !5
  %1652 = load ptr, ptr %5, align 8, !tbaa !5
  %1653 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1652, i32 0, i32 9
  store ptr %1651, ptr %1653, align 8, !tbaa !19
  %1654 = load ptr, ptr %5, align 8, !tbaa !5
  %1655 = load ptr, ptr %6, align 8, !tbaa !5
  %1656 = load i32, ptr %7, align 4, !tbaa !9
  %1657 = call i32 @inflate_flush(ptr noundef %1654, ptr noundef %1655, i32 noundef %1656)
  store i32 %1657, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

1658:                                             ; preds = %70
  store i32 -2, ptr %7, align 4, !tbaa !9
  %1659 = load i64, ptr %9, align 8, !tbaa !17
  %1660 = load ptr, ptr %5, align 8, !tbaa !5
  %1661 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1660, i32 0, i32 4
  store i64 %1659, ptr %1661, align 8, !tbaa !15
  %1662 = load i32, ptr %10, align 4, !tbaa !9
  %1663 = load ptr, ptr %5, align 8, !tbaa !5
  %1664 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1663, i32 0, i32 3
  store i32 %1662, ptr %1664, align 4, !tbaa !18
  %1665 = load i32, ptr %12, align 4, !tbaa !9
  %1666 = load ptr, ptr %6, align 8, !tbaa !5
  %1667 = getelementptr inbounds %struct.z_stream_s, ptr %1666, i32 0, i32 1
  store i32 %1665, ptr %1667, align 8, !tbaa !14
  %1668 = load ptr, ptr %11, align 8, !tbaa !5
  %1669 = load ptr, ptr %6, align 8, !tbaa !5
  %1670 = getelementptr inbounds %struct.z_stream_s, ptr %1669, i32 0, i32 0
  %1671 = load ptr, ptr %1670, align 8, !tbaa !11
  %1672 = ptrtoint ptr %1668 to i64
  %1673 = ptrtoint ptr %1671 to i64
  %1674 = sub i64 %1672, %1673
  %1675 = load ptr, ptr %6, align 8, !tbaa !5
  %1676 = getelementptr inbounds %struct.z_stream_s, ptr %1675, i32 0, i32 2
  %1677 = load i64, ptr %1676, align 8, !tbaa !23
  %1678 = add i64 %1677, %1674
  store i64 %1678, ptr %1676, align 8, !tbaa !23
  %1679 = load ptr, ptr %11, align 8, !tbaa !5
  %1680 = load ptr, ptr %6, align 8, !tbaa !5
  %1681 = getelementptr inbounds %struct.z_stream_s, ptr %1680, i32 0, i32 0
  store ptr %1679, ptr %1681, align 8, !tbaa !11
  %1682 = load ptr, ptr %13, align 8, !tbaa !5
  %1683 = load ptr, ptr %5, align 8, !tbaa !5
  %1684 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1683, i32 0, i32 9
  store ptr %1682, ptr %1684, align 8, !tbaa !19
  %1685 = load ptr, ptr %5, align 8, !tbaa !5
  %1686 = load ptr, ptr %6, align 8, !tbaa !5
  %1687 = load i32, ptr %7, align 4, !tbaa !9
  %1688 = call i32 @inflate_flush(ptr noundef %1685, ptr noundef %1686, i32 noundef %1687)
  store i32 %1688, ptr %4, align 4
  store i32 1, ptr %15, align 4
  br label %1690

1689:                                             ; preds = %1513, %614, %613, %372, %257
  br label %69

1690:                                             ; preds = %1658, %1627, %1596, %1562, %1458, %1411, %1290, %935, %808, %746, %691, %631, %540, %379, %319, %266, %218, %202, %82
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  %1691 = load i32, ptr %4, align 4
  ret i32 %1691
}

declare i32 @inflate_flush(ptr noundef, ptr noundef, i32 noundef) #0

declare i32 @inflate_trees_fixed(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #0

declare ptr @inflate_codes_new(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef) #0

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

declare i32 @inflate_trees_bits(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #0

declare i32 @inflate_trees_dynamic(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #0

declare i32 @inflate_codes(ptr noundef, ptr noundef, i32 noundef) #0

attributes #0 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 #3 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !6, i64 0}
!12 = !{!"z_stream_s", !6, i64 0, !10, i64 8, !13, i64 16, !6, i64 24, !10, i64 32, !13, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !10, i64 88, !13, i64 96, !13, i64 104}
!13 = !{!"long", !7, i64 0}
!14 = !{!12, !10, i64 8}
!15 = !{!16, !13, i64 48}
!16 = !{!"inflate_blocks_state", !10, i64 0, !7, i64 8, !10, i64 40, !10, i64 44, !13, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !13, i64 104}
!17 = !{!13, !13, i64 0}
!18 = !{!16, !10, i64 44}
!19 = !{!16, !6, i64 88}
!20 = !{!16, !6, i64 80}
!21 = !{!16, !6, i64 72}
!22 = !{!16, !10, i64 0}
!23 = !{!12, !13, i64 16}
!24 = !{!7, !7, i64 0}
!25 = distinct !{!25, !26}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!16, !10, i64 40}
!28 = !{!12, !6, i64 48}
!29 = distinct !{!29, !26}
!30 = !{!16, !6, i64 64}
!31 = distinct !{!31, !26}
!32 = !{!12, !6, i64 64}
!33 = !{!12, !6, i64 80}
!34 = distinct !{!34, !26}
!35 = distinct !{!35, !26}
!36 = distinct !{!36, !26}
!37 = !{!16, !6, i64 56}
!38 = !{!12, !6, i64 72}
!39 = distinct !{!39, !26}
!40 = !{!41, !10, i64 4}
!41 = !{!"inflate_huft_s", !7, i64 0, !10, i64 4}
!42 = distinct !{!42, !26}
!43 = distinct !{!43, !26}
!44 = distinct !{!44, !26}


; 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.inflate_huft_s = type { %union.anon.1, i32 }
%union.anon.1 = type { i32 }

@.str = external hidden unnamed_addr constant [19 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [36 x i8], align 1
@border = external hidden local_unnamed_addr constant [19 x i32], align 16
@inflate_mask = external local_unnamed_addr global [17 x i32], align 16
@.str.3 = external hidden unnamed_addr constant [26 x i8], align 1

declare void @inflate_codes_free(ptr noundef, ptr noundef) local_unnamed_addr #0

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

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

; Function Attrs: nounwind uwtable
define dso_local i32 @inflate_blocks(ptr noundef %0, ptr noundef %1, i32 noundef %2) local_unnamed_addr #2 {
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = load ptr, ptr %1, align 8, !tbaa !5
  %13 = getelementptr inbounds i8, ptr %1, i64 8
  %14 = load i32, ptr %13, align 8, !tbaa !12
  %15 = getelementptr inbounds i8, ptr %0, i64 48
  %16 = load i64, ptr %15, align 8, !tbaa !13
  %17 = getelementptr inbounds i8, ptr %0, i64 44
  %18 = load i32, ptr %17, align 4, !tbaa !15
  %19 = getelementptr inbounds i8, ptr %0, i64 88
  %20 = load ptr, ptr %19, align 8, !tbaa !16
  %21 = getelementptr inbounds i8, ptr %0, i64 80
  %22 = load ptr, ptr %21, align 8, !tbaa !17
  %23 = icmp ult ptr %20, %22
  br i1 %23, label %24, label %29

24:                                               ; preds = %3
  %25 = ptrtoint ptr %22 to i64
  %26 = ptrtoint ptr %20 to i64
  %27 = xor i64 %26, -1
  %28 = add i64 %25, %27
  br label %.split1451

29:                                               ; preds = %3
  %30 = getelementptr inbounds i8, ptr %0, i64 72
  %31 = load ptr, ptr %30, align 8, !tbaa !18
  %32 = ptrtoint ptr %31 to i64
  %33 = ptrtoint ptr %20 to i64
  %34 = sub i64 %32, %33
  br label %.split1451

.split1451:                                       ; preds = %29, %24
  %35 = phi i64 [ %28, %24 ], [ %34, %29 ]
  %36 = trunc i64 %35 to i32
  %37 = getelementptr inbounds i8, ptr %0, i64 8
  %38 = getelementptr inbounds i8, ptr %1, i64 64
  %39 = getelementptr inbounds i8, ptr %1, i64 80
  %40 = getelementptr inbounds i8, ptr %0, i64 16
  %41 = getelementptr inbounds i8, ptr %0, i64 12
  %42 = getelementptr inbounds i8, ptr %0, i64 24
  %43 = getelementptr inbounds i8, ptr %0, i64 32
  %44 = getelementptr inbounds i8, ptr %0, i64 56
  %45 = getelementptr inbounds i8, ptr %1, i64 72
  %46 = getelementptr inbounds i8, ptr %1, i64 16
  %47 = getelementptr inbounds i8, ptr %0, i64 72
  %48 = getelementptr inbounds i8, ptr %0, i64 40
  %49 = getelementptr inbounds i8, ptr %0, i64 64
  br label %.outer

.outer:                                           ; preds = %.sink.split, %.split1451
  %.0736.ph = phi i64 [ %.16752.ph, %.sink.split ], [ %16, %.split1451 ]
  %.0719.ph = phi i32 [ %.16735.ph, %.sink.split ], [ %18, %.split1451 ]
  %.0702.ph = phi ptr [ %.16718.ph, %.sink.split ], [ %12, %.split1451 ]
  %.0685.ph = phi i32 [ %.16701.ph, %.sink.split ], [ %14, %.split1451 ]
  %.0678.ph = phi ptr [ %.6684.ph, %.sink.split ], [ %20, %.split1451 ]
  %.0673.ph = phi i32 [ %.4677.ph, %.sink.split ], [ %36, %.split1451 ]
  %.0662.ph = phi i32 [ %.17.ph, %.sink.split ], [ %2, %.split1451 ]
  %50 = load i32, ptr %0, align 8, !tbaa !19
  switch i32 %50, label %.loopexit2650 [
    i32 0, label %.preheader846
    i32 1, label %.preheader847
    i32 2, label %51
    i32 3, label %.preheader849
    i32 4, label %.split1194
    i32 5, label %._crit_edge1730
    i32 6, label %.loopexit2364
    i32 7, label %.loopexit
    i32 8, label %.loopexit850
    i32 9, label %.loopexit2651
  ]

51:                                               ; preds = %.outer
  %52 = icmp eq i32 %.0685.ph, 0
  br i1 %52, label %.loopexit2652, label %53

53:                                               ; preds = %51
  %54 = icmp eq i32 %.0673.ph, 0
  br i1 %54, label %55, label %103

55:                                               ; preds = %53
  %56 = load ptr, ptr %47, align 8, !tbaa !18
  %57 = icmp eq ptr %.0678.ph, %56
  br i1 %57, label %58, label %.thread807.peel

58:                                               ; preds = %55
  %59 = load ptr, ptr %21, align 8, !tbaa !17
  %60 = load ptr, ptr %49, align 8, !tbaa !20
  %.not795.peel = icmp eq ptr %59, %60
  br i1 %.not795.peel, label %.thread807.peel, label %61

61:                                               ; preds = %58
  %62 = icmp ult ptr %60, %59
  %63 = ptrtoint ptr %59 to i64
  %64 = ptrtoint ptr %60 to i64
  %65 = xor i64 %64, -1
  %66 = add i64 %65, %63
  %67 = ptrtoint ptr %.0678.ph to i64
  %68 = sub i64 %67, %64
  %69 = select i1 %62, i64 %66, i64 %68
  %70 = trunc i64 %69 to i32
  %71 = icmp eq i32 %70, 0
  br i1 %71, label %.thread807.peel, label %103

.thread807.peel:                                  ; preds = %61, %58, %55
  %.1679810.peel = phi ptr [ %60, %61 ], [ %.0678.ph, %58 ], [ %.0678.ph, %55 ]
  store ptr %.1679810.peel, ptr %19, align 8, !tbaa !16
  %72 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.0662.ph) #5
  %73 = load ptr, ptr %19, align 8, !tbaa !16
  %74 = load ptr, ptr %21, align 8, !tbaa !17
  %75 = icmp ult ptr %73, %74
  br i1 %75, label %81, label %76

76:                                               ; preds = %.thread807.peel
  %77 = load ptr, ptr %47, align 8, !tbaa !18
  %78 = ptrtoint ptr %77 to i64
  %79 = ptrtoint ptr %73 to i64
  %80 = sub i64 %78, %79
  br label %86

81:                                               ; preds = %.thread807.peel
  %82 = ptrtoint ptr %74 to i64
  %83 = ptrtoint ptr %73 to i64
  %84 = xor i64 %83, -1
  %85 = add i64 %82, %84
  %.pre1733.peel = load ptr, ptr %47, align 8, !tbaa !18
  br label %86

86:                                               ; preds = %81, %76
  %87 = phi ptr [ %.pre1733.peel, %81 ], [ %77, %76 ]
  %88 = phi i64 [ %85, %81 ], [ %80, %76 ]
  %89 = icmp eq ptr %73, %87
  br i1 %89, label %90, label %101

90:                                               ; preds = %86
  %91 = load ptr, ptr %49, align 8, !tbaa !20
  %.not796.peel = icmp eq ptr %74, %91
  br i1 %.not796.peel, label %101, label %92

92:                                               ; preds = %90
  %93 = icmp ult ptr %91, %74
  %94 = ptrtoint ptr %74 to i64
  %95 = ptrtoint ptr %91 to i64
  %96 = xor i64 %95, -1
  %97 = add i64 %96, %94
  %98 = ptrtoint ptr %73 to i64
  %99 = sub i64 %98, %95
  %100 = select i1 %93, i64 %97, i64 %99
  br label %101

101:                                              ; preds = %92, %90, %86
  %.2680.peel = phi ptr [ %91, %92 ], [ %73, %90 ], [ %73, %86 ]
  %.2675.in.peel = phi i64 [ %100, %92 ], [ %88, %90 ], [ %88, %86 ]
  %.2675.peel = trunc i64 %.2675.in.peel to i32
  %102 = icmp eq i32 %.2675.peel, 0
  br i1 %102, label %.loopexit2653, label %103

103:                                              ; preds = %101, %61, %53
  %.3681.peel = phi ptr [ %.2680.peel, %101 ], [ %60, %61 ], [ %.0678.ph, %53 ]
  %.3676.peel = phi i32 [ %.2675.peel, %101 ], [ %70, %61 ], [ %.0673.ph, %53 ]
  %104 = load i32, ptr %37, align 8, !tbaa !21
  %spec.select.peel = call i32 @llvm.umin.i32(i32 %104, i32 %.0685.ph)
  %.1754.peel = call i32 @llvm.umin.i32(i32 %spec.select.peel, i32 %.3676.peel)
  %105 = zext i32 %.1754.peel to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.3681.peel, ptr align 1 %.0702.ph, i64 %105, i1 false)
  %106 = getelementptr inbounds i8, ptr %.0702.ph, i64 %105
  %107 = sub i32 %.0685.ph, %.1754.peel
  %108 = getelementptr inbounds i8, ptr %.3681.peel, i64 %105
  %109 = sub i32 %.3676.peel, %.1754.peel
  %110 = load i32, ptr %37, align 8, !tbaa !21
  %111 = sub i32 %110, %.1754.peel
  store i32 %111, ptr %37, align 8, !tbaa !21
  %.not797.peel = icmp eq i32 %110, %.1754.peel
  br i1 %.not797.peel, label %.loopexit2654, label %.outer.peel.newph

.outer.peel.newph:                                ; preds = %103, %309
  %.0702 = phi ptr [ %312, %309 ], [ %106, %103 ]
  %.0685 = phi i32 [ %313, %309 ], [ %107, %103 ]
  %.0678 = phi ptr [ %314, %309 ], [ %108, %103 ]
  %.0673 = phi i32 [ %315, %309 ], [ %109, %103 ]
  %112 = load i32, ptr %0, align 8, !tbaa !19
  switch i32 %112, label %.loopexit2650 [
    i32 0, label %.preheader846
    i32 1, label %.preheader847
    i32 2, label %243
    i32 3, label %.preheader849
    i32 4, label %.split1194
    i32 5, label %._crit_edge1730
    i32 6, label %.loopexit2364
    i32 7, label %.loopexit
    i32 8, label %.loopexit850
    i32 9, label %.loopexit2651
  ]

._crit_edge1730:                                  ; preds = %.outer.peel.newph, %.outer
  %.0702.lcssa2454 = phi ptr [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.0685.lcssa2442 = phi i32 [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.0678.lcssa2402 = phi ptr [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.0662.lcssa2370 = phi i32 [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  %.pre1731 = load i32, ptr %41, align 4, !tbaa !21
  br label %432

.preheader849:                                    ; preds = %.outer.peel.newph, %.outer
  %.0702.lcssa2452 = phi ptr [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.0685.lcssa2440 = phi i32 [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.0678.lcssa2400 = phi ptr [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.0662.lcssa2368 = phi i32 [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  %113 = icmp ult i32 %.0719.ph, 14
  br i1 %113, label %.lr.ph.preheader, label %._crit_edge

.lr.ph.preheader:                                 ; preds = %.preheader849
  %114 = zext nneg i32 %.0719.ph to i64
  %.not794.peel = icmp eq i32 %.0685.lcssa2440, 0
  br i1 %.not794.peel, label %.loopexit1696, label %115

115:                                              ; preds = %.lr.ph.preheader
  %116 = add i32 %.0685.lcssa2440, -1
  %117 = getelementptr inbounds i8, ptr %.0702.lcssa2452, i64 1
  %118 = load i8, ptr %.0702.lcssa2452, align 1, !tbaa !21
  %119 = zext i8 %118 to i64
  %120 = shl nuw nsw i64 %119, %114
  %121 = or i64 %120, %.0736.ph
  %indvars.iv.next.peel = add nuw nsw i64 %114, 8
  %122 = icmp ult i32 %.0719.ph, 6
  br i1 %122, label %.lr.ph, label %._crit_edge.loopexit

.preheader847:                                    ; preds = %.outer.peel.newph, %.outer
  %.0702.lcssa2451 = phi ptr [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.0685.lcssa2439 = phi i32 [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.0678.lcssa2399 = phi ptr [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.0673.lcssa2387 = phi i32 [ %.0673.ph, %.outer ], [ %.0673, %.outer.peel.newph ]
  %.0662.lcssa2367 = phi i32 [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  %123 = icmp ult i32 %.0719.ph, 32
  br i1 %123, label %.lr.ph1256.preheader, label %._crit_edge1257

.lr.ph1256.preheader:                             ; preds = %.preheader847
  %.not802.peel = icmp eq i32 %.0685.lcssa2439, 0
  br i1 %.not802.peel, label %.loopexit1724, label %124

124:                                              ; preds = %.lr.ph1256.preheader
  %125 = zext nneg i32 %.0719.ph to i64
  %126 = add i32 %.0685.lcssa2439, -1
  %127 = getelementptr inbounds i8, ptr %.0702.lcssa2451, i64 1
  %128 = load i8, ptr %.0702.lcssa2451, align 1, !tbaa !21
  %129 = zext i8 %128 to i64
  %130 = shl nuw nsw i64 %129, %125
  %131 = or i64 %130, %.0736.ph
  %indvars.iv.next1720.peel = add nuw nsw i64 %125, 8
  %132 = icmp ult i32 %.0719.ph, 24
  br i1 %132, label %.lr.ph1256, label %._crit_edge1257.loopexit

.preheader846:                                    ; preds = %.outer.peel.newph, %.outer
  %.0702.lcssa2450 = phi ptr [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.0685.lcssa2438 = phi i32 [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.0678.lcssa2398 = phi ptr [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.0673.lcssa2386 = phi i32 [ %.0673.ph, %.outer ], [ %.0673, %.outer.peel.newph ]
  %.0662.lcssa2366 = phi i32 [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  %133 = icmp ult i32 %.0719.ph, 3
  br i1 %133, label %.lr.ph1268, label %149

.lr.ph1268:                                       ; preds = %.preheader846
  %.not804 = icmp eq i32 %.0685.lcssa2438, 0
  br i1 %.not804, label %.split1276, label %._crit_edge1269

._crit_edge1269:                                  ; preds = %.lr.ph1268
  %134 = or disjoint i32 %.0719.ph, 8
  %135 = add i32 %.0685.lcssa2438, -1
  %136 = getelementptr inbounds i8, ptr %.0702.lcssa2450, i64 1
  %137 = load i8, ptr %.0702.lcssa2450, align 1, !tbaa !21
  %138 = zext i8 %137 to i64
  %139 = zext nneg i32 %.0719.ph to i64
  %140 = shl nuw nsw i64 %138, %139
  %141 = or i64 %140, %.0736.ph
  br label %149

.split1276:                                       ; preds = %.lr.ph1268
  store i64 %.0736.ph, ptr %15, align 8, !tbaa !13
  store i32 %.0719.ph, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %142 = load ptr, ptr %1, align 8, !tbaa !5
  %143 = ptrtoint ptr %.0702.lcssa2450 to i64
  %144 = ptrtoint ptr %142 to i64
  %145 = sub i64 %143, %144
  %146 = load i64, ptr %46, align 8, !tbaa !22
  %147 = add i64 %145, %146
  store i64 %147, ptr %46, align 8, !tbaa !22
  store ptr %.0702.lcssa2450, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2398, ptr %19, align 8, !tbaa !16
  %148 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.0662.lcssa2366) #5
  br label %.thread812

149:                                              ; preds = %._crit_edge1269, %.preheader846
  %.1737.lcssa = phi i64 [ %141, %._crit_edge1269 ], [ %.0736.ph, %.preheader846 ]
  %.1720.lcssa = phi i32 [ %134, %._crit_edge1269 ], [ %.0719.ph, %.preheader846 ]
  %.1703.lcssa = phi ptr [ %136, %._crit_edge1269 ], [ %.0702.lcssa2450, %.preheader846 ]
  %.1686.lcssa = phi i32 [ %135, %._crit_edge1269 ], [ %.0685.lcssa2438, %.preheader846 ]
  %.1663.lcssa = phi i32 [ 0, %._crit_edge1269 ], [ %.0662.lcssa2366, %.preheader846 ]
  %150 = trunc i64 %.1737.lcssa to i32
  %151 = and i32 %150, 1
  store i32 %151, ptr %48, align 8, !tbaa !23
  %152 = lshr i32 %150, 1
  %153 = and i32 %152, 3
  switch i32 %153, label %default.unreachable1734 [
    i32 0, label %154
    i32 1, label %161
    i32 2, label %178
    i32 3, label %181
  ]

154:                                              ; preds = %149
  %155 = lshr i64 %.1737.lcssa, 3
  %156 = add i32 %.1720.lcssa, -3
  %157 = and i32 %156, 7
  %158 = zext nneg i32 %157 to i64
  %159 = lshr i64 %155, %158
  %160 = and i32 %156, -8
  br label %.sink.split

161:                                              ; preds = %149
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %4) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %5) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %6) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %7) #5
  %162 = call i32 @inflate_trees_fixed(ptr noundef nonnull %4, ptr noundef nonnull %5, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef %1) #5
  %163 = load i32, ptr %4, align 4, !tbaa !24
  %164 = load i32, ptr %5, align 4, !tbaa !24
  %165 = load ptr, ptr %6, align 8, !tbaa !25
  %166 = load ptr, ptr %7, align 8, !tbaa !25
  %167 = call ptr @inflate_codes_new(i32 noundef %163, i32 noundef %164, ptr noundef %165, ptr noundef %166, ptr noundef %1) #5
  store ptr %167, ptr %37, align 8, !tbaa !21
  %.not803 = icmp eq ptr %167, null
  br i1 %.not803, label %.thread, label %175

.thread:                                          ; preds = %161
  store i64 %.1737.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.1720.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.1686.lcssa, ptr %13, align 8, !tbaa !12
  %168 = load ptr, ptr %1, align 8, !tbaa !5
  %169 = ptrtoint ptr %.1703.lcssa to i64
  %170 = ptrtoint ptr %168 to i64
  %171 = sub i64 %169, %170
  %172 = load i64, ptr %46, align 8, !tbaa !22
  %173 = add i64 %171, %172
  store i64 %173, ptr %46, align 8, !tbaa !22
  store ptr %.1703.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2398, ptr %19, align 8, !tbaa !16
  %174 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -4) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %6) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %5) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %4) #5
  br label %.thread812

175:                                              ; preds = %161
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %6) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %5) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %4) #5
  %176 = lshr i64 %.1737.lcssa, 3
  %177 = add i32 %.1720.lcssa, -3
  br label %.sink.split

178:                                              ; preds = %149
  %179 = lshr i64 %.1737.lcssa, 3
  %180 = add i32 %.1720.lcssa, -3
  br label %.sink.split

181:                                              ; preds = %149
  %182 = lshr i64 %.1737.lcssa, 3
  %183 = add i32 %.1720.lcssa, -3
  store i32 9, ptr %0, align 8, !tbaa !19
  %184 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str, ptr %184, align 8, !tbaa !26
  store i64 %182, ptr %15, align 8, !tbaa !13
  store i32 %183, ptr %17, align 4, !tbaa !15
  store i32 %.1686.lcssa, ptr %13, align 8, !tbaa !12
  %185 = load ptr, ptr %1, align 8, !tbaa !5
  %186 = ptrtoint ptr %.1703.lcssa to i64
  %187 = ptrtoint ptr %185 to i64
  %188 = sub i64 %186, %187
  %189 = load i64, ptr %46, align 8, !tbaa !22
  %190 = add i64 %188, %189
  store i64 %190, ptr %46, align 8, !tbaa !22
  store ptr %.1703.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2398, ptr %19, align 8, !tbaa !16
  %191 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -3) #5
  br label %.thread812

.lr.ph1256:                                       ; preds = %124
  %.not802 = icmp eq i32 %126, 0
  br i1 %.not802, label %.loopexit1723, label %192

192:                                              ; preds = %.lr.ph1256
  %193 = add i32 %.0685.lcssa2439, -2
  %194 = getelementptr inbounds i8, ptr %.0702.lcssa2451, i64 2
  %195 = load i8, ptr %127, align 1, !tbaa !21
  %196 = zext i8 %195 to i64
  %197 = shl nuw nsw i64 %196, %indvars.iv.next1720.peel
  %198 = or i64 %197, %131
  %indvars.iv.next1720 = add nuw nsw i64 %125, 16
  %199 = icmp ult i32 %.0719.ph, 16
  br i1 %199, label %.lr.ph1256.1, label %._crit_edge1257.loopexit, !llvm.loop !27

.lr.ph1256.1:                                     ; preds = %192
  %.not802.1 = icmp eq i32 %193, 0
  br i1 %.not802.1, label %.loopexit1723, label %200

200:                                              ; preds = %.lr.ph1256.1
  %201 = add i32 %.0685.lcssa2439, -3
  %202 = getelementptr inbounds i8, ptr %.0702.lcssa2451, i64 3
  %203 = load i8, ptr %194, align 1, !tbaa !21
  %204 = zext i8 %203 to i64
  %205 = shl nuw nsw i64 %204, %indvars.iv.next1720
  %206 = or i64 %205, %198
  %indvars.iv.next1720.1 = add nuw nsw i64 %125, 24
  %207 = icmp ult i32 %.0719.ph, 8
  br i1 %207, label %.lr.ph1256.2, label %._crit_edge1257.loopexit, !llvm.loop !27

.lr.ph1256.2:                                     ; preds = %200
  %.not802.2 = icmp eq i32 %201, 0
  br i1 %.not802.2, label %.loopexit1723, label %208

208:                                              ; preds = %.lr.ph1256.2
  %209 = add i32 %.0685.lcssa2439, -4
  %210 = getelementptr inbounds i8, ptr %.0702.lcssa2451, i64 4
  %211 = load i8, ptr %202, align 1, !tbaa !21
  %212 = zext i8 %211 to i64
  %213 = shl nuw nsw i64 %212, %indvars.iv.next1720.1
  %214 = or i64 %213, %206
  %indvars.iv.next1720.2 = or disjoint i64 %125, 32
  br label %._crit_edge1257.loopexit

.loopexit1723:                                    ; preds = %.lr.ph1256.2, %.lr.ph1256.1, %.lr.ph1256
  %indvars.iv1719.lcssa = phi i64 [ %indvars.iv.next1720.peel, %.lr.ph1256 ], [ %indvars.iv.next1720, %.lr.ph1256.1 ], [ %indvars.iv.next1720.1, %.lr.ph1256.2 ]
  %.27041253.lcssa2546 = phi ptr [ %127, %.lr.ph1256 ], [ %194, %.lr.ph1256.1 ], [ %202, %.lr.ph1256.2 ]
  %.27381251.lcssa2544 = phi i64 [ %131, %.lr.ph1256 ], [ %198, %.lr.ph1256.1 ], [ %206, %.lr.ph1256.2 ]
  %215 = trunc nuw nsw i64 %indvars.iv1719.lcssa to i32
  br label %.loopexit1724

.loopexit1724:                                    ; preds = %.lr.ph1256.preheader, %.loopexit1723
  %.36651255.lcssa = phi i32 [ 0, %.loopexit1723 ], [ %.0662.lcssa2367, %.lr.ph1256.preheader ]
  %.27041253.lcssa = phi ptr [ %.27041253.lcssa2546, %.loopexit1723 ], [ %.0702.lcssa2451, %.lr.ph1256.preheader ]
  %.27211252.lcssa.wide = phi i32 [ %215, %.loopexit1723 ], [ %.0719.ph, %.lr.ph1256.preheader ]
  %.27381251.lcssa = phi i64 [ %.27381251.lcssa2544, %.loopexit1723 ], [ %.0736.ph, %.lr.ph1256.preheader ]
  store i64 %.27381251.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.27211252.lcssa.wide, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %216 = load ptr, ptr %1, align 8, !tbaa !5
  %217 = ptrtoint ptr %.27041253.lcssa to i64
  %218 = ptrtoint ptr %216 to i64
  %219 = sub i64 %217, %218
  %220 = load i64, ptr %46, align 8, !tbaa !22
  %221 = add i64 %219, %220
  store i64 %221, ptr %46, align 8, !tbaa !22
  store ptr %.27041253.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2399, ptr %19, align 8, !tbaa !16
  %222 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.36651255.lcssa) #5
  br label %.thread812

._crit_edge1257.loopexit:                         ; preds = %192, %200, %208, %124
  %.lcssa1495 = phi i32 [ %126, %124 ], [ %193, %192 ], [ %201, %200 ], [ %209, %208 ]
  %.lcssa1494 = phi ptr [ %127, %124 ], [ %194, %192 ], [ %202, %200 ], [ %210, %208 ]
  %.lcssa1493 = phi i64 [ %131, %124 ], [ %198, %192 ], [ %206, %200 ], [ %214, %208 ]
  %.lcssa1492.wide = phi i64 [ %indvars.iv.next1720.peel, %124 ], [ %indvars.iv.next1720, %192 ], [ %indvars.iv.next1720.1, %200 ], [ %indvars.iv.next1720.2, %208 ]
  %223 = trunc nuw nsw i64 %.lcssa1492.wide to i32
  br label %._crit_edge1257

._crit_edge1257:                                  ; preds = %._crit_edge1257.loopexit, %.preheader847
  %.2738.lcssa = phi i64 [ %.0736.ph, %.preheader847 ], [ %.lcssa1493, %._crit_edge1257.loopexit ]
  %.2721.lcssa = phi i32 [ %.0719.ph, %.preheader847 ], [ %223, %._crit_edge1257.loopexit ]
  %.2704.lcssa = phi ptr [ %.0702.lcssa2451, %.preheader847 ], [ %.lcssa1494, %._crit_edge1257.loopexit ]
  %.2687.lcssa = phi i32 [ %.0685.lcssa2439, %.preheader847 ], [ %.lcssa1495, %._crit_edge1257.loopexit ]
  %.3665.lcssa = phi i32 [ %.0662.lcssa2367, %.preheader847 ], [ 0, %._crit_edge1257.loopexit ]
  %224 = xor i64 %.2738.lcssa, -1
  %225 = lshr i64 %224, 16
  %226 = xor i64 %225, %.2738.lcssa
  %227 = and i64 %226, 65535
  %.not799 = icmp eq i64 %227, 0
  br i1 %.not799, label %237, label %228

228:                                              ; preds = %._crit_edge1257
  store i32 9, ptr %0, align 8, !tbaa !19
  %229 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str.1, ptr %229, align 8, !tbaa !26
  store i64 %.2738.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.2721.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.2687.lcssa, ptr %13, align 8, !tbaa !12
  %230 = load ptr, ptr %1, align 8, !tbaa !5
  %231 = ptrtoint ptr %.2704.lcssa to i64
  %232 = ptrtoint ptr %230 to i64
  %233 = sub i64 %231, %232
  %234 = load i64, ptr %46, align 8, !tbaa !22
  %235 = add i64 %233, %234
  store i64 %235, ptr %46, align 8, !tbaa !22
  store ptr %.2704.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2399, ptr %19, align 8, !tbaa !16
  %236 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -3) #5
  br label %.thread812

237:                                              ; preds = %._crit_edge1257
  %238 = trunc i64 %.2738.lcssa to i32
  %239 = and i32 %238, 65535
  store i32 %239, ptr %37, align 8, !tbaa !21
  %.not800 = icmp eq i32 %239, 0
  br i1 %.not800, label %240, label %.sink.split

240:                                              ; preds = %237
  %241 = load i32, ptr %48, align 8, !tbaa !23
  %.not801 = icmp eq i32 %241, 0
  %242 = select i1 %.not801, i32 0, i32 7
  br label %.sink.split

243:                                              ; preds = %.outer.peel.newph
  %244 = icmp eq i32 %.0685, 0
  br i1 %244, label %.loopexit2652, label %252

.loopexit2652:                                    ; preds = %51, %243
  %.0702.lcssa2459 = phi ptr [ %.0702, %243 ], [ %.0702.ph, %51 ]
  %.0678.lcssa2407 = phi ptr [ %.0678, %243 ], [ %.0678.ph, %51 ]
  %.0662.lcssa2375 = phi i32 [ 0, %243 ], [ %.0662.ph, %51 ]
  store i64 %.0736.ph, ptr %15, align 8, !tbaa !13
  store i32 %.0719.ph, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %245 = load ptr, ptr %1, align 8, !tbaa !5
  %246 = ptrtoint ptr %.0702.lcssa2459 to i64
  %247 = ptrtoint ptr %245 to i64
  %248 = sub i64 %246, %247
  %249 = load i64, ptr %46, align 8, !tbaa !22
  %250 = add i64 %248, %249
  store i64 %250, ptr %46, align 8, !tbaa !22
  store ptr %.0702.lcssa2459, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2407, ptr %19, align 8, !tbaa !16
  %251 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.0662.lcssa2375) #5
  br label %.thread812

252:                                              ; preds = %243
  %253 = icmp eq i32 %.0673, 0
  br i1 %253, label %254, label %309

254:                                              ; preds = %252
  %255 = load ptr, ptr %47, align 8, !tbaa !18
  %256 = icmp eq ptr %.0678, %255
  br i1 %256, label %257, label %.thread807

257:                                              ; preds = %254
  %258 = load ptr, ptr %21, align 8, !tbaa !17
  %259 = load ptr, ptr %49, align 8, !tbaa !20
  %.not795 = icmp eq ptr %258, %259
  br i1 %.not795, label %.thread807, label %260

260:                                              ; preds = %257
  %261 = icmp ult ptr %259, %258
  %262 = ptrtoint ptr %258 to i64
  %263 = ptrtoint ptr %259 to i64
  %264 = xor i64 %263, -1
  %265 = add i64 %264, %262
  %266 = ptrtoint ptr %.0678 to i64
  %267 = sub i64 %266, %263
  %268 = select i1 %261, i64 %265, i64 %267
  %269 = trunc i64 %268 to i32
  %270 = icmp eq i32 %269, 0
  br i1 %270, label %.thread807, label %309

.thread807:                                       ; preds = %254, %257, %260
  %.1679810 = phi ptr [ %259, %260 ], [ %.0678, %257 ], [ %.0678, %254 ]
  store ptr %.1679810, ptr %19, align 8, !tbaa !16
  %271 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef 0) #5
  %272 = load ptr, ptr %19, align 8, !tbaa !16
  %273 = load ptr, ptr %21, align 8, !tbaa !17
  %274 = icmp ult ptr %272, %273
  br i1 %274, label %275, label %280

275:                                              ; preds = %.thread807
  %276 = ptrtoint ptr %273 to i64
  %277 = ptrtoint ptr %272 to i64
  %278 = xor i64 %277, -1
  %279 = add i64 %276, %278
  %.pre1733 = load ptr, ptr %47, align 8, !tbaa !18
  br label %285

280:                                              ; preds = %.thread807
  %281 = load ptr, ptr %47, align 8, !tbaa !18
  %282 = ptrtoint ptr %281 to i64
  %283 = ptrtoint ptr %272 to i64
  %284 = sub i64 %282, %283
  br label %285

285:                                              ; preds = %280, %275
  %286 = phi ptr [ %.pre1733, %275 ], [ %281, %280 ]
  %287 = phi i64 [ %279, %275 ], [ %284, %280 ]
  %288 = icmp eq ptr %272, %286
  br i1 %288, label %289, label %300

289:                                              ; preds = %285
  %290 = load ptr, ptr %49, align 8, !tbaa !20
  %.not796 = icmp eq ptr %273, %290
  br i1 %.not796, label %300, label %291

291:                                              ; preds = %289
  %292 = icmp ult ptr %290, %273
  %293 = ptrtoint ptr %273 to i64
  %294 = ptrtoint ptr %290 to i64
  %295 = xor i64 %294, -1
  %296 = add i64 %295, %293
  %297 = ptrtoint ptr %272 to i64
  %298 = sub i64 %297, %294
  %299 = select i1 %292, i64 %296, i64 %298
  br label %300

300:                                              ; preds = %291, %289, %285
  %.2680 = phi ptr [ %290, %291 ], [ %272, %289 ], [ %272, %285 ]
  %.2675.in = phi i64 [ %299, %291 ], [ %287, %289 ], [ %287, %285 ]
  %.2675 = trunc i64 %.2675.in to i32
  %301 = icmp eq i32 %.2675, 0
  br i1 %301, label %.loopexit2653, label %309

.loopexit2653:                                    ; preds = %101, %300
  %.0702.lcssa2460 = phi ptr [ %.0702, %300 ], [ %.0702.ph, %101 ]
  %.0685.lcssa2448 = phi i32 [ %.0685, %300 ], [ %.0685.ph, %101 ]
  %.2680.lcssa = phi ptr [ %.2680, %300 ], [ %.2680.peel, %101 ]
  %.lcssa2365 = phi i32 [ %271, %300 ], [ %72, %101 ]
  store i64 %.0736.ph, ptr %15, align 8, !tbaa !13
  store i32 %.0719.ph, ptr %17, align 4, !tbaa !15
  store i32 %.0685.lcssa2448, ptr %13, align 8, !tbaa !12
  %302 = load ptr, ptr %1, align 8, !tbaa !5
  %303 = ptrtoint ptr %.0702.lcssa2460 to i64
  %304 = ptrtoint ptr %302 to i64
  %305 = sub i64 %303, %304
  %306 = load i64, ptr %46, align 8, !tbaa !22
  %307 = add i64 %305, %306
  store i64 %307, ptr %46, align 8, !tbaa !22
  store ptr %.0702.lcssa2460, ptr %1, align 8, !tbaa !5
  store ptr %.2680.lcssa, ptr %19, align 8, !tbaa !16
  %308 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.lcssa2365) #5
  br label %.thread812

309:                                              ; preds = %260, %300, %252
  %.3681 = phi ptr [ %.2680, %300 ], [ %259, %260 ], [ %.0678, %252 ]
  %.3676 = phi i32 [ %.2675, %300 ], [ %269, %260 ], [ %.0673, %252 ]
  %310 = load i32, ptr %37, align 8, !tbaa !21
  %spec.select = call i32 @llvm.umin.i32(i32 %310, i32 %.0685)
  %.1754 = call i32 @llvm.umin.i32(i32 %spec.select, i32 %.3676)
  %311 = zext i32 %.1754 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %.3681, ptr align 1 %.0702, i64 %311, i1 false)
  %312 = getelementptr inbounds i8, ptr %.0702, i64 %311
  %313 = sub i32 %.0685, %.1754
  %314 = getelementptr inbounds i8, ptr %.3681, i64 %311
  %315 = sub i32 %.3676, %.1754
  %316 = load i32, ptr %37, align 8, !tbaa !21
  %317 = sub i32 %316, %.1754
  store i32 %317, ptr %37, align 8, !tbaa !21
  %.not797 = icmp eq i32 %316, %.1754
  br i1 %.not797, label %.loopexit2654, label %.outer.peel.newph, !llvm.loop !30

.loopexit2654:                                    ; preds = %309, %103
  %.lcssa2473 = phi ptr [ %106, %103 ], [ %312, %309 ]
  %.lcssa2472 = phi i32 [ %107, %103 ], [ %313, %309 ]
  %.lcssa2471 = phi ptr [ %108, %103 ], [ %314, %309 ]
  %.lcssa2470 = phi i32 [ %109, %103 ], [ %315, %309 ]
  %318 = load i32, ptr %48, align 8, !tbaa !23
  %.not798 = icmp eq i32 %318, 0
  %319 = select i1 %.not798, i32 0, i32 7
  br label %.sink.split

.lr.ph:                                           ; preds = %115
  %.not794 = icmp eq i32 %116, 0
  br i1 %.not794, label %.loopexit1695, label %._crit_edge.loopexit.loopexit

.loopexit1695:                                    ; preds = %.lr.ph
  %320 = trunc nuw nsw i64 %indvars.iv.next.peel to i32
  br label %.loopexit1696

.loopexit1696:                                    ; preds = %.lr.ph.preheader, %.loopexit1695
  %.46661129.lcssa = phi i32 [ 0, %.loopexit1695 ], [ %.0662.lcssa2368, %.lr.ph.preheader ]
  %.37051127.lcssa = phi ptr [ %117, %.loopexit1695 ], [ %.0702.lcssa2452, %.lr.ph.preheader ]
  %.37221126.lcssa.wide = phi i32 [ %320, %.loopexit1695 ], [ %.0719.ph, %.lr.ph.preheader ]
  %.37391125.lcssa = phi i64 [ %121, %.loopexit1695 ], [ %.0736.ph, %.lr.ph.preheader ]
  store i64 %.37391125.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.37221126.lcssa.wide, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %321 = load ptr, ptr %1, align 8, !tbaa !5
  %322 = ptrtoint ptr %.37051127.lcssa to i64
  %323 = ptrtoint ptr %321 to i64
  %324 = sub i64 %322, %323
  %325 = load i64, ptr %46, align 8, !tbaa !22
  %326 = add i64 %324, %325
  store i64 %326, ptr %46, align 8, !tbaa !22
  store ptr %.37051127.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2400, ptr %19, align 8, !tbaa !16
  %327 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.46661129.lcssa) #5
  br label %.thread812

._crit_edge.loopexit.loopexit:                    ; preds = %.lr.ph
  %indvars.iv.next = or disjoint i64 %114, 16
  %328 = load i8, ptr %117, align 1, !tbaa !21
  %329 = zext i8 %328 to i64
  %330 = shl nuw nsw i64 %329, %indvars.iv.next.peel
  %331 = or i64 %330, %121
  %332 = getelementptr inbounds i8, ptr %.0702.lcssa2452, i64 2
  %333 = add i32 %.0685.lcssa2440, -2
  br label %._crit_edge.loopexit

._crit_edge.loopexit:                             ; preds = %._crit_edge.loopexit.loopexit, %115
  %.lcssa1459 = phi i32 [ %116, %115 ], [ %333, %._crit_edge.loopexit.loopexit ]
  %.lcssa1458 = phi ptr [ %117, %115 ], [ %332, %._crit_edge.loopexit.loopexit ]
  %.lcssa1457 = phi i64 [ %121, %115 ], [ %331, %._crit_edge.loopexit.loopexit ]
  %.lcssa1456.wide = phi i64 [ %indvars.iv.next.peel, %115 ], [ %indvars.iv.next, %._crit_edge.loopexit.loopexit ]
  %334 = trunc nuw nsw i64 %.lcssa1456.wide to i32
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %.preheader849
  %.3739.lcssa = phi i64 [ %.0736.ph, %.preheader849 ], [ %.lcssa1457, %._crit_edge.loopexit ]
  %.3722.lcssa = phi i32 [ %.0719.ph, %.preheader849 ], [ %334, %._crit_edge.loopexit ]
  %.3705.lcssa = phi ptr [ %.0702.lcssa2452, %.preheader849 ], [ %.lcssa1458, %._crit_edge.loopexit ]
  %.3688.lcssa = phi i32 [ %.0685.lcssa2440, %.preheader849 ], [ %.lcssa1459, %._crit_edge.loopexit ]
  %.4666.lcssa = phi i32 [ %.0662.lcssa2368, %.preheader849 ], [ 0, %._crit_edge.loopexit ]
  %335 = trunc i64 %.3739.lcssa to i32
  %336 = and i32 %335, 16383
  store i32 %336, ptr %37, align 8, !tbaa !21
  %337 = and i32 %335, 31
  %338 = icmp ugt i32 %337, 29
  br i1 %338, label %343, label %339

339:                                              ; preds = %._crit_edge
  %340 = lshr i32 %335, 5
  %341 = and i32 %340, 31
  %342 = icmp ugt i32 %341, 29
  br i1 %342, label %343, label %352

343:                                              ; preds = %339, %._crit_edge
  store i32 9, ptr %0, align 8, !tbaa !19
  %344 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str.2, ptr %344, align 8, !tbaa !26
  store i64 %.3739.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.3722.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.3688.lcssa, ptr %13, align 8, !tbaa !12
  %345 = load ptr, ptr %1, align 8, !tbaa !5
  %346 = ptrtoint ptr %.3705.lcssa to i64
  %347 = ptrtoint ptr %345 to i64
  %348 = sub i64 %346, %347
  %349 = load i64, ptr %46, align 8, !tbaa !22
  %350 = add i64 %348, %349
  store i64 %350, ptr %46, align 8, !tbaa !22
  store ptr %.3705.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2400, ptr %19, align 8, !tbaa !16
  %351 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -3) #5
  br label %.thread812

352:                                              ; preds = %339
  %353 = add nuw nsw i32 %337, 258
  %354 = add nuw nsw i32 %353, %341
  %355 = load ptr, ptr %38, align 8, !tbaa !31
  %356 = load ptr, ptr %39, align 8, !tbaa !32
  %357 = call ptr %355(ptr noundef %356, i32 noundef %354, i32 noundef 4) #5
  store ptr %357, ptr %40, align 8, !tbaa !21
  %358 = icmp eq ptr %357, null
  br i1 %358, label %359, label %.split1194.thread

359:                                              ; preds = %352
  store i64 %.3739.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.3722.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.3688.lcssa, ptr %13, align 8, !tbaa !12
  %360 = load ptr, ptr %1, align 8, !tbaa !5
  %361 = ptrtoint ptr %.3705.lcssa to i64
  %362 = ptrtoint ptr %360 to i64
  %363 = sub i64 %361, %362
  %364 = load i64, ptr %46, align 8, !tbaa !22
  %365 = add i64 %363, %364
  store i64 %365, ptr %46, align 8, !tbaa !22
  store ptr %.3705.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2400, ptr %19, align 8, !tbaa !16
  %366 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef -4) #5
  br label %.thread812

.split1194.thread:                                ; preds = %352
  %367 = lshr i64 %.3739.lcssa, 14
  %368 = add i32 %.3722.lcssa, -14
  store i32 0, ptr %41, align 4, !tbaa !21
  store i32 4, ptr %0, align 8, !tbaa !19
  br label %.preheader.preheader

.split1194:                                       ; preds = %.outer.peel.newph, %.outer
  %.0702.lcssa2453 = phi ptr [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.0685.lcssa2441 = phi i32 [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.0678.lcssa2401 = phi ptr [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.0662.lcssa2369 = phi i32 [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  %.pre = load i32, ptr %41, align 4, !tbaa !21
  %369 = load i32, ptr %37, align 8, !tbaa !21
  %370 = lshr i32 %369, 10
  %371 = add nuw nsw i32 %370, 4
  %372 = icmp ult i32 %.pre, %371
  br i1 %372, label %.preheader.preheader, label %.preheader848

.preheader.preheader:                             ; preds = %.split1194.thread, %.split1194
  %.06782412 = phi ptr [ %.0678.lcssa2401, %.split1194 ], [ %.0678.lcssa2400, %.split1194.thread ]
  %.ph = phi i32 [ %.pre, %.split1194 ], [ 0, %.split1194.thread ]
  %.66681199.ph = phi i32 [ %.0662.lcssa2369, %.split1194 ], [ %.4666.lcssa, %.split1194.thread ]
  %.56901198.ph = phi i32 [ %.0685.lcssa2441, %.split1194 ], [ %.3688.lcssa, %.split1194.thread ]
  %.57071197.ph = phi ptr [ %.0702.lcssa2453, %.split1194 ], [ %.3705.lcssa, %.split1194.thread ]
  %.57241196.ph = phi i32 [ %.0719.ph, %.split1194 ], [ %368, %.split1194.thread ]
  %.57411195.ph = phi i64 [ %.0736.ph, %.split1194 ], [ %367, %.split1194.thread ]
  br label %.preheader

.preheader848:                                    ; preds = %391, %.split1194
  %.06782413 = phi ptr [ %.0678.lcssa2401, %.split1194 ], [ %.06782412, %391 ]
  %.5741.lcssa = phi i64 [ %.0736.ph, %.split1194 ], [ %401, %391 ]
  %.5724.lcssa = phi i32 [ %.0719.ph, %.split1194 ], [ %402, %391 ]
  %.5707.lcssa = phi ptr [ %.0702.lcssa2453, %.split1194 ], [ %.6708.lcssa, %391 ]
  %.5690.lcssa = phi i32 [ %.0685.lcssa2441, %.split1194 ], [ %.6691.lcssa, %391 ]
  %.6668.lcssa = phi i32 [ %.0662.lcssa2369, %.split1194 ], [ %.7669.lcssa, %391 ]
  %.lcssa = phi i32 [ %.pre, %.split1194 ], [ %403, %391 ]
  %373 = icmp ult i32 %.lcssa, 19
  br i1 %373, label %.lr.ph1207, label %._crit_edge1208

.preheader:                                       ; preds = %.preheader.preheader, %391
  %374 = phi i32 [ %403, %391 ], [ %.ph, %.preheader.preheader ]
  %.66681199 = phi i32 [ %.7669.lcssa, %391 ], [ %.66681199.ph, %.preheader.preheader ]
  %.56901198 = phi i32 [ %.6691.lcssa, %391 ], [ %.56901198.ph, %.preheader.preheader ]
  %.57071197 = phi ptr [ %.6708.lcssa, %391 ], [ %.57071197.ph, %.preheader.preheader ]
  %.57241196 = phi i32 [ %402, %391 ], [ %.57241196.ph, %.preheader.preheader ]
  %.57411195 = phi i64 [ %401, %391 ], [ %.57411195.ph, %.preheader.preheader ]
  %375 = icmp ult i32 %.57241196, 3
  br i1 %375, label %.lr.ph1139, label %391

.lr.ph1139:                                       ; preds = %.preheader
  %.not793 = icmp eq i32 %.56901198, 0
  br i1 %.not793, label %.split, label %._crit_edge1140

._crit_edge1140:                                  ; preds = %.lr.ph1139
  %376 = or disjoint i32 %.57241196, 8
  %377 = add i32 %.56901198, -1
  %378 = getelementptr inbounds i8, ptr %.57071197, i64 1
  %379 = load i8, ptr %.57071197, align 1, !tbaa !21
  %380 = zext i8 %379 to i64
  %381 = zext nneg i32 %.57241196 to i64
  %382 = shl nuw nsw i64 %380, %381
  %383 = or i64 %382, %.57411195
  br label %391

.split:                                           ; preds = %.lr.ph1139
  store i64 %.57411195, ptr %15, align 8, !tbaa !13
  store i32 %.57241196, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %384 = load ptr, ptr %1, align 8, !tbaa !5
  %385 = ptrtoint ptr %.57071197 to i64
  %386 = ptrtoint ptr %384 to i64
  %387 = sub i64 %385, %386
  %388 = load i64, ptr %46, align 8, !tbaa !22
  %389 = add i64 %387, %388
  store i64 %389, ptr %46, align 8, !tbaa !22
  store ptr %.57071197, ptr %1, align 8, !tbaa !5
  store ptr %.06782412, ptr %19, align 8, !tbaa !16
  %390 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.66681199) #5
  br label %.thread812

391:                                              ; preds = %._crit_edge1140, %.preheader
  %.6742.lcssa = phi i64 [ %383, %._crit_edge1140 ], [ %.57411195, %.preheader ]
  %.6725.lcssa = phi i32 [ %376, %._crit_edge1140 ], [ %.57241196, %.preheader ]
  %.6708.lcssa = phi ptr [ %378, %._crit_edge1140 ], [ %.57071197, %.preheader ]
  %.6691.lcssa = phi i32 [ %377, %._crit_edge1140 ], [ %.56901198, %.preheader ]
  %.7669.lcssa = phi i32 [ 0, %._crit_edge1140 ], [ %.66681199, %.preheader ]
  %392 = trunc i64 %.6742.lcssa to i32
  %393 = and i32 %392, 7
  %394 = load ptr, ptr %40, align 8, !tbaa !21
  %395 = add nuw nsw i32 %374, 1
  store i32 %395, ptr %41, align 4, !tbaa !21
  %396 = zext nneg i32 %374 to i64
  %397 = getelementptr inbounds [19 x i32], ptr @border, i64 0, i64 %396
  %398 = load i32, ptr %397, align 4, !tbaa !24
  %399 = zext i32 %398 to i64
  %400 = getelementptr inbounds i32, ptr %394, i64 %399
  store i32 %393, ptr %400, align 4, !tbaa !24
  %401 = lshr i64 %.6742.lcssa, 3
  %402 = add i32 %.6725.lcssa, -3
  %403 = load i32, ptr %41, align 4, !tbaa !21
  %404 = load i32, ptr %37, align 8, !tbaa !21
  %405 = lshr i32 %404, 10
  %406 = add nuw nsw i32 %405, 4
  %407 = icmp ult i32 %403, %406
  br i1 %407, label %.preheader, label %.preheader848, !llvm.loop !33

.lr.ph1207:                                       ; preds = %.preheader848, %.lr.ph1207
  %408 = phi i32 [ %.pr, %.lr.ph1207 ], [ %.lcssa, %.preheader848 ]
  %409 = load ptr, ptr %40, align 8, !tbaa !21
  %410 = add nuw nsw i32 %408, 1
  store i32 %410, ptr %41, align 4, !tbaa !21
  %411 = zext nneg i32 %408 to i64
  %412 = getelementptr inbounds [19 x i32], ptr @border, i64 0, i64 %411
  %413 = load i32, ptr %412, align 4, !tbaa !24
  %414 = zext i32 %413 to i64
  %415 = getelementptr inbounds i32, ptr %409, i64 %414
  store i32 0, ptr %415, align 4, !tbaa !24
  %.pr = load i32, ptr %41, align 4, !tbaa !21
  %416 = icmp ult i32 %.pr, 19
  br i1 %416, label %.lr.ph1207, label %._crit_edge1208, !llvm.loop !34

._crit_edge1208:                                  ; preds = %.lr.ph1207, %.preheader848
  store i32 7, ptr %42, align 8, !tbaa !21
  %417 = load ptr, ptr %40, align 8, !tbaa !21
  %418 = load ptr, ptr %44, align 8, !tbaa !35
  %419 = call i32 @inflate_trees_bits(ptr noundef %417, ptr noundef nonnull %42, ptr noundef nonnull %43, ptr noundef %418, ptr noundef %1) #5
  switch i32 %419, label %.loopexit851 [
    i32 0, label %431
    i32 -3, label %420
  ]

420:                                              ; preds = %._crit_edge1208
  %421 = load ptr, ptr %45, align 8, !tbaa !36
  %422 = load ptr, ptr %39, align 8, !tbaa !32
  %423 = load ptr, ptr %40, align 8, !tbaa !21
  call void %421(ptr noundef %422, ptr noundef %423) #5
  store i32 9, ptr %0, align 8, !tbaa !19
  br label %.loopexit851

.loopexit851:                                     ; preds = %._crit_edge1208, %420
  store i64 %.5741.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.5724.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.5690.lcssa, ptr %13, align 8, !tbaa !12
  %424 = load ptr, ptr %1, align 8, !tbaa !5
  %425 = ptrtoint ptr %.5707.lcssa to i64
  %426 = ptrtoint ptr %424 to i64
  %427 = sub i64 %425, %426
  %428 = load i64, ptr %46, align 8, !tbaa !22
  %429 = add i64 %427, %428
  store i64 %429, ptr %46, align 8, !tbaa !22
  store ptr %.5707.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.06782413, ptr %19, align 8, !tbaa !16
  %430 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %419) #5
  br label %.thread812

431:                                              ; preds = %._crit_edge1208
  store i32 0, ptr %41, align 4, !tbaa !21
  store i32 5, ptr %0, align 8, !tbaa !19
  br label %432

432:                                              ; preds = %._crit_edge1730, %431
  %.06782414 = phi ptr [ %.0678.lcssa2402, %._crit_edge1730 ], [ %.06782413, %431 ]
  %433 = phi i32 [ %.pre1731, %._crit_edge1730 ], [ 0, %431 ]
  %.7743 = phi i64 [ %.0736.ph, %._crit_edge1730 ], [ %.5741.lcssa, %431 ]
  %.7726 = phi i32 [ %.0719.ph, %._crit_edge1730 ], [ %.5724.lcssa, %431 ]
  %.7709 = phi ptr [ %.0702.lcssa2454, %._crit_edge1730 ], [ %.5707.lcssa, %431 ]
  %.7692 = phi i32 [ %.0685.lcssa2442, %._crit_edge1730 ], [ %.5690.lcssa, %431 ]
  %.8 = phi i32 [ %.0662.lcssa2370, %._crit_edge1730 ], [ %.6668.lcssa, %431 ]
  %434 = load i32, ptr %37, align 8, !tbaa !21
  %435 = and i32 %434, 31
  %436 = add nuw nsw i32 %435, 258
  %437 = lshr i32 %434, 5
  %438 = and i32 %437, 31
  %439 = add nuw nsw i32 %436, %438
  %440 = icmp ult i32 %433, %439
  br i1 %440, label %.lr.ph1242, label %._crit_edge1243

.lr.ph1242:                                       ; preds = %432, %595
  %441 = phi i32 [ %602, %595 ], [ %439, %432 ]
  %442 = phi i32 [ %596, %595 ], [ %433, %432 ]
  %.91240 = phi i32 [ %.13, %595 ], [ %.8, %432 ]
  %.86931239 = phi i32 [ %.12697, %595 ], [ %.7692, %432 ]
  %.87101238 = phi ptr [ %.12714, %595 ], [ %.7709, %432 ]
  %.87271237 = phi i32 [ %.12731, %595 ], [ %.7726, %432 ]
  %.87441236 = phi i64 [ %.12748, %595 ], [ %.7743, %432 ]
  %443 = load i32, ptr %42, align 8, !tbaa !21
  %444 = icmp ult i32 %.87271237, %443
  br i1 %444, label %.lr.ph1215.preheader, label %._crit_edge1216

.lr.ph1215.preheader:                             ; preds = %.lr.ph1242
  %.not792.peel = icmp eq i32 %.86931239, 0
  br i1 %.not792.peel, label %.loopexit1703, label %445

445:                                              ; preds = %.lr.ph1215.preheader
  %446 = add i32 %.86931239, -1
  %447 = getelementptr inbounds i8, ptr %.87101238, i64 1
  %448 = load i8, ptr %.87101238, align 1, !tbaa !21
  %449 = zext i8 %448 to i64
  %450 = zext nneg i32 %.87271237 to i64
  %451 = shl i64 %449, %450
  %452 = or i64 %451, %.87441236
  %453 = add i32 %.87271237, 8
  %454 = icmp ult i32 %453, %443
  br i1 %454, label %.lr.ph1215, label %._crit_edge1216

.lr.ph1215:                                       ; preds = %445, %455
  %.96941212 = phi i32 [ %456, %455 ], [ %446, %445 ]
  %.97111211 = phi ptr [ %457, %455 ], [ %447, %445 ]
  %.97281210 = phi i32 [ %463, %455 ], [ %453, %445 ]
  %.97451209 = phi i64 [ %462, %455 ], [ %452, %445 ]
  %.not792 = icmp eq i32 %.96941212, 0
  br i1 %.not792, label %.loopexit1703, label %455

455:                                              ; preds = %.lr.ph1215
  %456 = add i32 %.96941212, -1
  %457 = getelementptr inbounds i8, ptr %.97111211, i64 1
  %458 = load i8, ptr %.97111211, align 1, !tbaa !21
  %459 = zext i8 %458 to i64
  %460 = zext nneg i32 %.97281210 to i64
  %461 = shl i64 %459, %460
  %462 = or i64 %461, %.97451209
  %463 = add i32 %.97281210, 8
  %464 = icmp ult i32 %463, %443
  br i1 %464, label %.lr.ph1215, label %._crit_edge1216, !llvm.loop !37

.loopexit1703:                                    ; preds = %.lr.ph1215.preheader, %.lr.ph1215
  %.101213.lcssa = phi i32 [ 0, %.lr.ph1215 ], [ %.91240, %.lr.ph1215.preheader ]
  %.97451209.lcssa = phi i64 [ %.97451209, %.lr.ph1215 ], [ %.87441236, %.lr.ph1215.preheader ]
  %465 = zext i32 %.86931239 to i64
  %scevgep.le2045 = getelementptr i8, ptr %.87101238, i64 %465
  %466 = shl i32 %.86931239, 3
  %467 = add i32 %.87271237, %466
  store i64 %.97451209.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %467, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %468 = load ptr, ptr %1, align 8, !tbaa !5
  %469 = ptrtoint ptr %scevgep.le2045 to i64
  %470 = ptrtoint ptr %468 to i64
  %471 = sub i64 %469, %470
  %472 = load i64, ptr %46, align 8, !tbaa !22
  %473 = add i64 %471, %472
  store i64 %473, ptr %46, align 8, !tbaa !22
  store ptr %scevgep.le2045, ptr %1, align 8, !tbaa !5
  store ptr %.06782414, ptr %19, align 8, !tbaa !16
  %474 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.101213.lcssa) #5
  br label %.thread812

._crit_edge1216:                                  ; preds = %455, %445, %.lr.ph1242
  %.9745.lcssa = phi i64 [ %.87441236, %.lr.ph1242 ], [ %452, %445 ], [ %462, %455 ]
  %.9728.lcssa = phi i32 [ %.87271237, %.lr.ph1242 ], [ %453, %445 ], [ %463, %455 ]
  %.9711.lcssa = phi ptr [ %.87101238, %.lr.ph1242 ], [ %447, %445 ], [ %457, %455 ]
  %.9694.lcssa = phi i32 [ %.86931239, %.lr.ph1242 ], [ %446, %445 ], [ %456, %455 ]
  %.10.lcssa = phi i32 [ %.91240, %.lr.ph1242 ], [ 0, %445 ], [ 0, %455 ]
  %475 = load ptr, ptr %43, align 8, !tbaa !21
  %476 = trunc i64 %.9745.lcssa to i32
  %477 = zext i32 %443 to i64
  %478 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %477
  %479 = load i32, ptr %478, align 4, !tbaa !24
  %480 = and i32 %479, %476
  %481 = zext i32 %480 to i64
  %482 = getelementptr inbounds %struct.inflate_huft_s, ptr %475, i64 %481
  %483 = getelementptr inbounds i8, ptr %482, i64 1
  %484 = load i8, ptr %483, align 1, !tbaa !21
  %485 = zext i8 %484 to i32
  %486 = getelementptr inbounds i8, ptr %482, i64 4
  %487 = load i32, ptr %486, align 4, !tbaa !38
  %488 = icmp ult i32 %487, 16
  br i1 %488, label %489, label %497

489:                                              ; preds = %._crit_edge1216
  %490 = zext nneg i8 %484 to i64
  %491 = lshr i64 %.9745.lcssa, %490
  %492 = sub i32 %.9728.lcssa, %485
  %493 = load ptr, ptr %40, align 8, !tbaa !21
  %494 = add i32 %442, 1
  store i32 %494, ptr %41, align 4, !tbaa !21
  %495 = zext i32 %442 to i64
  %496 = getelementptr inbounds i32, ptr %493, i64 %495
  store i32 %487, ptr %496, align 4, !tbaa !24
  %.pre1732 = load i32, ptr %41, align 4, !tbaa !21
  br label %595

497:                                              ; preds = %._crit_edge1216
  %498 = icmp eq i32 %487, 18
  %499 = add i32 %487, -14
  %500 = select i1 %498, i32 7, i32 %499
  %501 = select i1 %498, i32 11, i32 3
  %502 = add i32 %500, %485
  %503 = icmp ult i32 %.9728.lcssa, %502
  br i1 %503, label %.lr.ph1228.preheader, label %._crit_edge1229

.lr.ph1228.preheader:                             ; preds = %497
  %.not791.peel = icmp eq i32 %.9694.lcssa, 0
  br i1 %.not791.peel, label %.loopexit1712, label %504

504:                                              ; preds = %.lr.ph1228.preheader
  %505 = add i32 %.9694.lcssa, -1
  %506 = getelementptr inbounds i8, ptr %.9711.lcssa, i64 1
  %507 = load i8, ptr %.9711.lcssa, align 1, !tbaa !21
  %508 = zext i8 %507 to i64
  %509 = zext nneg i32 %.9728.lcssa to i64
  %510 = shl i64 %508, %509
  %511 = or i64 %510, %.9745.lcssa
  %512 = add i32 %.9728.lcssa, 8
  %513 = icmp ult i32 %512, %502
  br i1 %513, label %.lr.ph1228, label %._crit_edge1229

.lr.ph1228:                                       ; preds = %504, %514
  %.106951225 = phi i32 [ %515, %514 ], [ %505, %504 ]
  %.107121224 = phi ptr [ %516, %514 ], [ %506, %504 ]
  %.107291223 = phi i32 [ %522, %514 ], [ %512, %504 ]
  %.107461222 = phi i64 [ %521, %514 ], [ %511, %504 ]
  %.not791 = icmp eq i32 %.106951225, 0
  br i1 %.not791, label %.loopexit1712, label %514

514:                                              ; preds = %.lr.ph1228
  %515 = add i32 %.106951225, -1
  %516 = getelementptr inbounds i8, ptr %.107121224, i64 1
  %517 = load i8, ptr %.107121224, align 1, !tbaa !21
  %518 = zext i8 %517 to i64
  %519 = zext nneg i32 %.107291223 to i64
  %520 = shl i64 %518, %519
  %521 = or i64 %520, %.107461222
  %522 = add i32 %.107291223, 8
  %523 = icmp ult i32 %522, %502
  br i1 %523, label %.lr.ph1228, label %._crit_edge1229, !llvm.loop !40

.loopexit1712:                                    ; preds = %.lr.ph1228.preheader, %.lr.ph1228
  %.111226.lcssa = phi i32 [ 0, %.lr.ph1228 ], [ %.10.lcssa, %.lr.ph1228.preheader ]
  %.107461222.lcssa = phi i64 [ %.107461222, %.lr.ph1228 ], [ %.9745.lcssa, %.lr.ph1228.preheader ]
  %524 = zext i32 %.9694.lcssa to i64
  %scevgep1710.le2035 = getelementptr i8, ptr %.9711.lcssa, i64 %524
  %525 = shl i32 %.9694.lcssa, 3
  %526 = add i32 %.9728.lcssa, %525
  store i64 %.107461222.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %526, ptr %17, align 4, !tbaa !15
  store i32 0, ptr %13, align 8, !tbaa !12
  %527 = load ptr, ptr %1, align 8, !tbaa !5
  %528 = ptrtoint ptr %scevgep1710.le2035 to i64
  %529 = ptrtoint ptr %527 to i64
  %530 = sub i64 %528, %529
  %531 = load i64, ptr %46, align 8, !tbaa !22
  %532 = add i64 %530, %531
  store i64 %532, ptr %46, align 8, !tbaa !22
  store ptr %scevgep1710.le2035, ptr %1, align 8, !tbaa !5
  store ptr %.06782414, ptr %19, align 8, !tbaa !16
  %533 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.111226.lcssa) #5
  br label %.thread812

._crit_edge1229:                                  ; preds = %514, %504, %497
  %.10746.lcssa = phi i64 [ %.9745.lcssa, %497 ], [ %511, %504 ], [ %521, %514 ]
  %.10729.lcssa = phi i32 [ %.9728.lcssa, %497 ], [ %512, %504 ], [ %522, %514 ]
  %.10712.lcssa = phi ptr [ %.9711.lcssa, %497 ], [ %506, %504 ], [ %516, %514 ]
  %.10695.lcssa = phi i32 [ %.9694.lcssa, %497 ], [ %505, %504 ], [ %515, %514 ]
  %.11.lcssa = phi i32 [ %.10.lcssa, %497 ], [ 0, %504 ], [ 0, %514 ]
  %534 = zext nneg i8 %484 to i64
  %535 = lshr i64 %.10746.lcssa, %534
  %536 = trunc i64 %535 to i32
  %537 = zext i32 %500 to i64
  %538 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %537
  %539 = load i32, ptr %538, align 4, !tbaa !24
  %540 = and i32 %539, %536
  %541 = add i32 %540, %501
  %542 = lshr i64 %535, %537
  %543 = sub i32 %.10729.lcssa, %502
  %544 = add i32 %541, %442
  %545 = icmp ugt i32 %544, %441
  br i1 %545, label %549, label %546

546:                                              ; preds = %._crit_edge1229
  %547 = icmp eq i32 %487, 16
  %548 = icmp eq i32 %442, 0
  %or.cond = and i1 %548, %547
  br i1 %or.cond, label %549, label %561

549:                                              ; preds = %546, %._crit_edge1229
  %550 = load ptr, ptr %45, align 8, !tbaa !36
  %551 = load ptr, ptr %39, align 8, !tbaa !32
  %552 = load ptr, ptr %40, align 8, !tbaa !21
  call void %550(ptr noundef %551, ptr noundef %552) #5
  store i32 9, ptr %0, align 8, !tbaa !19
  %553 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str.3, ptr %553, align 8, !tbaa !26
  store i64 %542, ptr %15, align 8, !tbaa !13
  store i32 %543, ptr %17, align 4, !tbaa !15
  store i32 %.10695.lcssa, ptr %13, align 8, !tbaa !12
  %554 = load ptr, ptr %1, align 8, !tbaa !5
  %555 = ptrtoint ptr %.10712.lcssa to i64
  %556 = ptrtoint ptr %554 to i64
  %557 = sub i64 %555, %556
  %558 = load i64, ptr %46, align 8, !tbaa !22
  %559 = add i64 %557, %558
  store i64 %559, ptr %46, align 8, !tbaa !22
  store ptr %.10712.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.06782414, ptr %19, align 8, !tbaa !16
  %560 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -3) #5
  br label %.thread812

561:                                              ; preds = %546
  br i1 %547, label %562, label %568

562:                                              ; preds = %561
  %563 = load ptr, ptr %40, align 8, !tbaa !21
  %564 = add i32 %442, -1
  %565 = zext i32 %564 to i64
  %566 = getelementptr inbounds i32, ptr %563, i64 %565
  %567 = load i32, ptr %566, align 4, !tbaa !24
  br label %568

568:                                              ; preds = %561, %562
  %569 = phi i32 [ %567, %562 ], [ 0, %561 ]
  %570 = add nsw i32 %501, -1
  %571 = add i32 %570, %540
  %xtraiter = and i32 %541, 3
  %lcmp.mod.not = icmp eq i32 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.prol.loopexit, label %.prol.preheader

.prol.preheader:                                  ; preds = %568, %.prol.preheader
  %.0661.prol = phi i32 [ %573, %.prol.preheader ], [ %442, %568 ]
  %.0660.prol = phi i32 [ %576, %.prol.preheader ], [ %541, %568 ]
  %prol.iter = phi i32 [ %prol.iter.next, %.prol.preheader ], [ 0, %568 ]
  %572 = load ptr, ptr %40, align 8, !tbaa !21
  %573 = add i32 %.0661.prol, 1
  %574 = zext i32 %.0661.prol to i64
  %575 = getelementptr inbounds i32, ptr %572, i64 %574
  store i32 %569, ptr %575, align 4, !tbaa !24
  %576 = add i32 %.0660.prol, -1
  %prol.iter.next = add i32 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i32 %prol.iter.next, %xtraiter
  br i1 %prol.iter.cmp.not, label %.prol.loopexit, label %.prol.preheader, !llvm.loop !41

.prol.loopexit:                                   ; preds = %.prol.preheader, %568
  %.lcssa2493.unr = phi i32 [ poison, %568 ], [ %573, %.prol.preheader ]
  %.0661.unr = phi i32 [ %442, %568 ], [ %573, %.prol.preheader ]
  %.0660.unr = phi i32 [ %541, %568 ], [ %576, %.prol.preheader ]
  %577 = icmp ult i32 %571, 3
  br i1 %577, label %.unr-lcssa, label %.new

.new:                                             ; preds = %.prol.loopexit, %.new
  %.0661 = phi i32 [ %591, %.new ], [ %.0661.unr, %.prol.loopexit ]
  %.0660 = phi i32 [ %594, %.new ], [ %.0660.unr, %.prol.loopexit ]
  %578 = load ptr, ptr %40, align 8, !tbaa !21
  %579 = add i32 %.0661, 1
  %580 = zext i32 %.0661 to i64
  %581 = getelementptr inbounds i32, ptr %578, i64 %580
  store i32 %569, ptr %581, align 4, !tbaa !24
  %582 = load ptr, ptr %40, align 8, !tbaa !21
  %583 = add i32 %.0661, 2
  %584 = zext i32 %579 to i64
  %585 = getelementptr inbounds i32, ptr %582, i64 %584
  store i32 %569, ptr %585, align 4, !tbaa !24
  %586 = load ptr, ptr %40, align 8, !tbaa !21
  %587 = add i32 %.0661, 3
  %588 = zext i32 %583 to i64
  %589 = getelementptr inbounds i32, ptr %586, i64 %588
  store i32 %569, ptr %589, align 4, !tbaa !24
  %590 = load ptr, ptr %40, align 8, !tbaa !21
  %591 = add i32 %.0661, 4
  %592 = zext i32 %587 to i64
  %593 = getelementptr inbounds i32, ptr %590, i64 %592
  store i32 %569, ptr %593, align 4, !tbaa !24
  %594 = add i32 %.0660, -4
  %.not790.3 = icmp eq i32 %594, 0
  br i1 %.not790.3, label %.unr-lcssa, label %.new, !llvm.loop !43

.unr-lcssa:                                       ; preds = %.new, %.prol.loopexit
  %.lcssa2493 = phi i32 [ %.lcssa2493.unr, %.prol.loopexit ], [ %591, %.new ]
  store i32 %.lcssa2493, ptr %41, align 4, !tbaa !21
  br label %595

595:                                              ; preds = %489, %.unr-lcssa
  %596 = phi i32 [ %.pre1732, %489 ], [ %.lcssa2493, %.unr-lcssa ]
  %.12748 = phi i64 [ %491, %489 ], [ %542, %.unr-lcssa ]
  %.12731 = phi i32 [ %492, %489 ], [ %543, %.unr-lcssa ]
  %.12714 = phi ptr [ %.9711.lcssa, %489 ], [ %.10712.lcssa, %.unr-lcssa ]
  %.12697 = phi i32 [ %.9694.lcssa, %489 ], [ %.10695.lcssa, %.unr-lcssa ]
  %.13 = phi i32 [ %.10.lcssa, %489 ], [ %.11.lcssa, %.unr-lcssa ]
  %597 = load i32, ptr %37, align 8, !tbaa !21
  %598 = and i32 %597, 31
  %599 = add nuw nsw i32 %598, 258
  %600 = lshr i32 %597, 5
  %601 = and i32 %600, 31
  %602 = add nuw nsw i32 %599, %601
  %603 = icmp ult i32 %596, %602
  br i1 %603, label %.lr.ph1242, label %._crit_edge1243, !llvm.loop !44

._crit_edge1243:                                  ; preds = %595, %432
  %.8744.lcssa = phi i64 [ %.7743, %432 ], [ %.12748, %595 ]
  %.8727.lcssa = phi i32 [ %.7726, %432 ], [ %.12731, %595 ]
  %.8710.lcssa = phi ptr [ %.7709, %432 ], [ %.12714, %595 ]
  %.8693.lcssa = phi i32 [ %.7692, %432 ], [ %.12697, %595 ]
  %.9.lcssa = phi i32 [ %.8, %432 ], [ %.13, %595 ]
  %.lcssa902 = phi i32 [ %435, %432 ], [ %598, %595 ]
  %.lcssa898 = phi i32 [ %438, %432 ], [ %601, %595 ]
  store ptr null, ptr %43, align 8, !tbaa !21
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %8) #5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %9) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %10) #5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %11) #5
  store i32 9, ptr %8, align 4, !tbaa !24
  store i32 6, ptr %9, align 4, !tbaa !24
  %604 = add nuw nsw i32 %.lcssa902, 257
  %605 = add nuw nsw i32 %.lcssa898, 1
  %606 = load ptr, ptr %40, align 8, !tbaa !21
  %607 = load ptr, ptr %44, align 8, !tbaa !35
  %608 = call i32 @inflate_trees_dynamic(i32 noundef %604, i32 noundef %605, ptr noundef %606, ptr noundef nonnull %8, ptr noundef nonnull %9, ptr noundef nonnull %10, ptr noundef nonnull %11, ptr noundef %607, ptr noundef %1) #5
  switch i32 %608, label %.thread821 [
    i32 0, label %613
    i32 -3, label %609
  ]

609:                                              ; preds = %._crit_edge1243
  %610 = load ptr, ptr %45, align 8, !tbaa !36
  %611 = load ptr, ptr %39, align 8, !tbaa !32
  %612 = load ptr, ptr %40, align 8, !tbaa !21
  call void %610(ptr noundef %611, ptr noundef %612) #5
  store i32 9, ptr %0, align 8, !tbaa !19
  br label %.thread821

613:                                              ; preds = %._crit_edge1243
  %614 = load i32, ptr %8, align 4, !tbaa !24
  %615 = load i32, ptr %9, align 4, !tbaa !24
  %616 = load ptr, ptr %10, align 8, !tbaa !25
  %617 = load ptr, ptr %11, align 8, !tbaa !25
  %618 = call ptr @inflate_codes_new(i32 noundef %614, i32 noundef %615, ptr noundef %616, ptr noundef %617, ptr noundef %1) #5
  %619 = icmp eq ptr %618, null
  br i1 %619, label %.thread821, label %627

.thread821:                                       ; preds = %613, %._crit_edge1243, %609
  %.sink = phi i32 [ %608, %609 ], [ %608, %._crit_edge1243 ], [ -4, %613 ]
  store i64 %.8744.lcssa, ptr %15, align 8, !tbaa !13
  store i32 %.8727.lcssa, ptr %17, align 4, !tbaa !15
  store i32 %.8693.lcssa, ptr %13, align 8, !tbaa !12
  %620 = load ptr, ptr %1, align 8, !tbaa !5
  %621 = ptrtoint ptr %.8710.lcssa to i64
  %622 = ptrtoint ptr %620 to i64
  %623 = sub i64 %621, %622
  %624 = load i64, ptr %46, align 8, !tbaa !22
  %625 = add i64 %623, %624
  store i64 %625, ptr %46, align 8, !tbaa !22
  store ptr %.8710.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.06782414, ptr %19, align 8, !tbaa !16
  %626 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %.sink) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #5
  br label %.thread812

627:                                              ; preds = %613
  store ptr %618, ptr %37, align 8, !tbaa !21
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #5
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #5
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #5
  %628 = load ptr, ptr %45, align 8, !tbaa !36
  %629 = load ptr, ptr %39, align 8, !tbaa !32
  %630 = load ptr, ptr %40, align 8, !tbaa !21
  call void %628(ptr noundef %629, ptr noundef %630) #5
  store i32 6, ptr %0, align 8, !tbaa !19
  br label %.loopexit2364

.loopexit2364:                                    ; preds = %.outer, %.outer.peel.newph, %627
  %.06782415 = phi ptr [ %.06782414, %627 ], [ %.0678.ph, %.outer ], [ %.0678, %.outer.peel.newph ]
  %.13749 = phi i64 [ %.8744.lcssa, %627 ], [ %.0736.ph, %.outer.peel.newph ], [ %.0736.ph, %.outer ]
  %.13732 = phi i32 [ %.8727.lcssa, %627 ], [ %.0719.ph, %.outer.peel.newph ], [ %.0719.ph, %.outer ]
  %.13715 = phi ptr [ %.8710.lcssa, %627 ], [ %.0702.ph, %.outer ], [ %.0702, %.outer.peel.newph ]
  %.13698 = phi i32 [ %.8693.lcssa, %627 ], [ %.0685.ph, %.outer ], [ %.0685, %.outer.peel.newph ]
  %.15 = phi i32 [ %.9.lcssa, %627 ], [ %.0662.ph, %.outer ], [ 0, %.outer.peel.newph ]
  store i64 %.13749, ptr %15, align 8, !tbaa !13
  store i32 %.13732, ptr %17, align 4, !tbaa !15
  store i32 %.13698, ptr %13, align 8, !tbaa !12
  %631 = load ptr, ptr %1, align 8, !tbaa !5
  %632 = ptrtoint ptr %.13715 to i64
  %633 = ptrtoint ptr %631 to i64
  %634 = sub i64 %632, %633
  %635 = load i64, ptr %46, align 8, !tbaa !22
  %636 = add i64 %634, %635
  store i64 %636, ptr %46, align 8, !tbaa !22
  store ptr %.13715, ptr %1, align 8, !tbaa !5
  store ptr %.06782415, ptr %19, align 8, !tbaa !16
  %637 = call i32 @inflate_codes(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %.15) #5
  %.not787 = icmp eq i32 %637, 1
  br i1 %.not787, label %640, label %638

638:                                              ; preds = %.loopexit2364
  %639 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %637) #5
  br label %.thread812

640:                                              ; preds = %.loopexit2364
  %641 = load ptr, ptr %37, align 8, !tbaa !21
  call void @inflate_codes_free(ptr noundef %641, ptr noundef nonnull %1) #5
  %642 = load ptr, ptr %1, align 8, !tbaa !5
  %643 = load i32, ptr %13, align 8, !tbaa !12
  %644 = load i64, ptr %15, align 8, !tbaa !13
  %645 = load i32, ptr %17, align 4, !tbaa !15
  %646 = load ptr, ptr %19, align 8, !tbaa !16
  %647 = load ptr, ptr %21, align 8, !tbaa !17
  %648 = icmp ult ptr %646, %647
  br i1 %648, label %649, label %654

649:                                              ; preds = %640
  %650 = ptrtoint ptr %647 to i64
  %651 = ptrtoint ptr %646 to i64
  %652 = xor i64 %651, -1
  %653 = add i64 %650, %652
  br label %659

654:                                              ; preds = %640
  %655 = load ptr, ptr %47, align 8, !tbaa !18
  %656 = ptrtoint ptr %655 to i64
  %657 = ptrtoint ptr %646 to i64
  %658 = sub i64 %656, %657
  br label %659

659:                                              ; preds = %654, %649
  %660 = phi i64 [ %653, %649 ], [ %658, %654 ]
  %661 = load i32, ptr %48, align 8, !tbaa !23
  %.not788 = icmp eq i32 %661, 0
  br i1 %.not788, label %662, label %664

662:                                              ; preds = %659
  %663 = trunc i64 %660 to i32
  br label %.sink.split

664:                                              ; preds = %659
  store i32 7, ptr %0, align 8, !tbaa !19
  br label %.loopexit

.loopexit:                                        ; preds = %.outer.peel.newph, %.outer, %664
  %.14750 = phi i64 [ %644, %664 ], [ %.0736.ph, %.outer ], [ %.0736.ph, %.outer.peel.newph ]
  %.14733 = phi i32 [ %645, %664 ], [ %.0719.ph, %.outer ], [ %.0719.ph, %.outer.peel.newph ]
  %.14716 = phi ptr [ %642, %664 ], [ %.0702, %.outer.peel.newph ], [ %.0702.ph, %.outer ]
  %.14699 = phi i32 [ %643, %664 ], [ %.0685, %.outer.peel.newph ], [ %.0685.ph, %.outer ]
  %.4682 = phi ptr [ %646, %664 ], [ %.0678, %.outer.peel.newph ], [ %.0678.ph, %.outer ]
  %.16 = phi i32 [ 0, %664 ], [ 0, %.outer.peel.newph ], [ %.0662.ph, %.outer ]
  store ptr %.4682, ptr %19, align 8, !tbaa !16
  %665 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.16) #5
  %666 = load ptr, ptr %19, align 8, !tbaa !16
  %667 = load ptr, ptr %21, align 8, !tbaa !17
  %.not789 = icmp eq ptr %667, %666
  br i1 %.not789, label %676, label %668

668:                                              ; preds = %.loopexit
  store i64 %.14750, ptr %15, align 8, !tbaa !13
  store i32 %.14733, ptr %17, align 4, !tbaa !15
  store i32 %.14699, ptr %13, align 8, !tbaa !12
  %669 = load ptr, ptr %1, align 8, !tbaa !5
  %670 = ptrtoint ptr %.14716 to i64
  %671 = ptrtoint ptr %669 to i64
  %672 = sub i64 %670, %671
  %673 = load i64, ptr %46, align 8, !tbaa !22
  %674 = add i64 %672, %673
  store i64 %674, ptr %46, align 8, !tbaa !22
  store ptr %.14716, ptr %1, align 8, !tbaa !5
  %675 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %665) #5
  br label %.thread812

676:                                              ; preds = %.loopexit
  store i32 8, ptr %0, align 8, !tbaa !19
  br label %.loopexit850

.loopexit850:                                     ; preds = %.outer.peel.newph, %.outer, %676
  %.15751 = phi i64 [ %.14750, %676 ], [ %.0736.ph, %.outer ], [ %.0736.ph, %.outer.peel.newph ]
  %.15734 = phi i32 [ %.14733, %676 ], [ %.0719.ph, %.outer ], [ %.0719.ph, %.outer.peel.newph ]
  %.15717 = phi ptr [ %.14716, %676 ], [ %.0702, %.outer.peel.newph ], [ %.0702.ph, %.outer ]
  %.15700 = phi i32 [ %.14699, %676 ], [ %.0685, %.outer.peel.newph ], [ %.0685.ph, %.outer ]
  %.5683 = phi ptr [ %666, %676 ], [ %.0678, %.outer.peel.newph ], [ %.0678.ph, %.outer ]
  store i64 %.15751, ptr %15, align 8, !tbaa !13
  store i32 %.15734, ptr %17, align 4, !tbaa !15
  store i32 %.15700, ptr %13, align 8, !tbaa !12
  %677 = load ptr, ptr %1, align 8, !tbaa !5
  %678 = ptrtoint ptr %.15717 to i64
  %679 = ptrtoint ptr %677 to i64
  %680 = sub i64 %678, %679
  %681 = load i64, ptr %46, align 8, !tbaa !22
  %682 = add i64 %680, %681
  store i64 %682, ptr %46, align 8, !tbaa !22
  store ptr %.15717, ptr %1, align 8, !tbaa !5
  store ptr %.5683, ptr %19, align 8, !tbaa !16
  %683 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef 1) #5
  br label %.thread812

.loopexit2651:                                    ; preds = %.outer, %.outer.peel.newph
  %.0702.lcssa2458 = phi ptr [ %.0702, %.outer.peel.newph ], [ %.0702.ph, %.outer ]
  %.0685.lcssa2446 = phi i32 [ %.0685, %.outer.peel.newph ], [ %.0685.ph, %.outer ]
  %.0678.lcssa2406 = phi ptr [ %.0678, %.outer.peel.newph ], [ %.0678.ph, %.outer ]
  store i64 %.0736.ph, ptr %15, align 8, !tbaa !13
  store i32 %.0719.ph, ptr %17, align 4, !tbaa !15
  store i32 %.0685.lcssa2446, ptr %13, align 8, !tbaa !12
  %684 = load ptr, ptr %1, align 8, !tbaa !5
  %685 = ptrtoint ptr %.0702.lcssa2458 to i64
  %686 = ptrtoint ptr %684 to i64
  %687 = sub i64 %685, %686
  %688 = load i64, ptr %46, align 8, !tbaa !22
  %689 = add i64 %687, %688
  store i64 %689, ptr %46, align 8, !tbaa !22
  store ptr %.0702.lcssa2458, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa2406, ptr %19, align 8, !tbaa !16
  %690 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef -3) #5
  br label %.thread812

.loopexit2650:                                    ; preds = %.outer, %.outer.peel.newph
  %.0702.lcssa = phi ptr [ %.0702, %.outer.peel.newph ], [ %.0702.ph, %.outer ]
  %.0685.lcssa = phi i32 [ %.0685, %.outer.peel.newph ], [ %.0685.ph, %.outer ]
  %.0678.lcssa = phi ptr [ %.0678, %.outer.peel.newph ], [ %.0678.ph, %.outer ]
  store i64 %.0736.ph, ptr %15, align 8, !tbaa !13
  store i32 %.0719.ph, ptr %17, align 4, !tbaa !15
  store i32 %.0685.lcssa, ptr %13, align 8, !tbaa !12
  %691 = load ptr, ptr %1, align 8, !tbaa !5
  %692 = ptrtoint ptr %.0702.lcssa to i64
  %693 = ptrtoint ptr %691 to i64
  %694 = sub i64 %692, %693
  %695 = load i64, ptr %46, align 8, !tbaa !22
  %696 = add i64 %694, %695
  store i64 %696, ptr %46, align 8, !tbaa !22
  store ptr %.0702.lcssa, ptr %1, align 8, !tbaa !5
  store ptr %.0678.lcssa, ptr %19, align 8, !tbaa !16
  %697 = call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef -2) #5
  br label %.thread812

default.unreachable1734:                          ; preds = %149
  unreachable

.sink.split:                                      ; preds = %240, %237, %.loopexit2654, %662, %178, %175, %154
  %.sink2059 = phi i32 [ 1, %154 ], [ 6, %175 ], [ 3, %178 ], [ 0, %662 ], [ %319, %.loopexit2654 ], [ %242, %240 ], [ 2, %237 ]
  %.16752.ph = phi i64 [ %159, %154 ], [ %176, %175 ], [ %179, %178 ], [ %644, %662 ], [ %.0736.ph, %.loopexit2654 ], [ 0, %240 ], [ 0, %237 ]
  %.16735.ph = phi i32 [ %160, %154 ], [ %177, %175 ], [ %180, %178 ], [ %645, %662 ], [ %.0719.ph, %.loopexit2654 ], [ 0, %240 ], [ 0, %237 ]
  %.16718.ph = phi ptr [ %.1703.lcssa, %154 ], [ %.1703.lcssa, %175 ], [ %.1703.lcssa, %178 ], [ %642, %662 ], [ %.lcssa2473, %.loopexit2654 ], [ %.2704.lcssa, %240 ], [ %.2704.lcssa, %237 ]
  %.16701.ph = phi i32 [ %.1686.lcssa, %154 ], [ %.1686.lcssa, %175 ], [ %.1686.lcssa, %178 ], [ %643, %662 ], [ %.lcssa2472, %.loopexit2654 ], [ %.2687.lcssa, %240 ], [ %.2687.lcssa, %237 ]
  %.6684.ph = phi ptr [ %.0678.lcssa2398, %154 ], [ %.0678.lcssa2398, %175 ], [ %.0678.lcssa2398, %178 ], [ %646, %662 ], [ %.lcssa2471, %.loopexit2654 ], [ %.0678.lcssa2399, %240 ], [ %.0678.lcssa2399, %237 ]
  %.4677.ph = phi i32 [ %.0673.lcssa2386, %154 ], [ %.0673.lcssa2386, %175 ], [ %.0673.lcssa2386, %178 ], [ %663, %662 ], [ %.lcssa2470, %.loopexit2654 ], [ %.0673.lcssa2387, %240 ], [ %.0673.lcssa2387, %237 ]
  %.17.ph = phi i32 [ %.1663.lcssa, %154 ], [ %.1663.lcssa, %175 ], [ %.1663.lcssa, %178 ], [ 0, %662 ], [ 0, %.loopexit2654 ], [ %.3665.lcssa, %240 ], [ %.3665.lcssa, %237 ]
  store i32 %.sink2059, ptr %0, align 8, !tbaa !19
  br label %.outer

.thread812:                                       ; preds = %549, %.loopexit1712, %.loopexit1703, %.thread821, %.thread, %.loopexit2650, %.loopexit2651, %.loopexit850, %668, %638, %.loopexit851, %.split, %359, %343, %.loopexit1696, %.loopexit2653, %.loopexit2652, %228, %.loopexit1724, %181, %.split1276
  %.7 = phi i32 [ %697, %.loopexit2650 ], [ %690, %.loopexit2651 ], [ %683, %.loopexit850 ], [ %675, %668 ], [ %639, %638 ], [ %390, %.split ], [ %430, %.loopexit851 ], [ %327, %.loopexit1696 ], [ %351, %343 ], [ %366, %359 ], [ %251, %.loopexit2652 ], [ %308, %.loopexit2653 ], [ %222, %.loopexit1724 ], [ %236, %228 ], [ %148, %.split1276 ], [ %191, %181 ], [ %174, %.thread ], [ %626, %.thread821 ], [ %560, %549 ], [ %533, %.loopexit1712 ], [ %474, %.loopexit1703 ]
  ret i32 %.7
}

declare i32 @inflate_flush(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #0

declare i32 @inflate_trees_fixed(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

declare ptr @inflate_codes_new(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

declare i32 @inflate_trees_bits(ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

declare i32 @inflate_trees_dynamic(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

declare i32 @inflate_codes(ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #0

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

attributes #0 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { 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 #3 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #5 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 0}
!6 = !{!"z_stream_s", !7, i64 0, !10, i64 8, !11, i64 16, !7, i64 24, !10, i64 32, !11, i64 40, !7, i64 48, !7, i64 56, !7, i64 64, !7, i64 72, !7, i64 80, !10, i64 88, !11, i64 96, !11, i64 104}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"long", !8, i64 0}
!12 = !{!6, !10, i64 8}
!13 = !{!14, !11, i64 48}
!14 = !{!"inflate_blocks_state", !10, i64 0, !8, i64 8, !10, i64 40, !10, i64 44, !11, i64 48, !7, i64 56, !7, i64 64, !7, i64 72, !7, i64 80, !7, i64 88, !7, i64 96, !11, i64 104}
!15 = !{!14, !10, i64 44}
!16 = !{!14, !7, i64 88}
!17 = !{!14, !7, i64 80}
!18 = !{!14, !7, i64 72}
!19 = !{!14, !10, i64 0}
!20 = !{!14, !7, i64 64}
!21 = !{!8, !8, i64 0}
!22 = !{!6, !11, i64 16}
!23 = !{!14, !10, i64 40}
!24 = !{!10, !10, i64 0}
!25 = !{!7, !7, i64 0}
!26 = !{!6, !7, i64 48}
!27 = distinct !{!27, !28, !29}
!28 = !{!"llvm.loop.mustprogress"}
!29 = !{!"llvm.loop.peeled.count", i32 1}
!30 = distinct !{!30, !29}
!31 = !{!6, !7, i64 64}
!32 = !{!6, !7, i64 80}
!33 = distinct !{!33, !28}
!34 = distinct !{!34, !28}
!35 = !{!14, !7, i64 56}
!36 = !{!6, !7, i64 72}
!37 = distinct !{!37, !28, !29}
!38 = !{!39, !10, i64 4}
!39 = !{!"inflate_huft_s", !8, i64 0, !10, i64 4}
!40 = distinct !{!40, !28, !29}
!41 = distinct !{!41, !42}
!42 = !{!"llvm.loop.unroll.disable"}
!43 = distinct !{!43, !28}
!44 = distinct !{!44, !28}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopFullUnrollPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,ReassociatePass,SCCPPass,SROAPass,SimplifyCFGPass