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

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

@inflate_mask = external global [17 x i32], align 16
@.str = external hidden unnamed_addr constant [28 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [22 x i8], align 1

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

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

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

44:                                               ; preds = %3
  %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 !21
  %48 = load ptr, ptr %15, align 8, !tbaa !5
  %49 = ptrtoint ptr %47 to i64
  %50 = ptrtoint ptr %48 to i64
  %51 = sub i64 %49, %50
  %52 = sub nsw i64 %51, 1
  br label %61

53:                                               ; preds = %3
  %54 = load ptr, ptr %5, align 8, !tbaa !5
  %55 = getelementptr inbounds %struct.inflate_blocks_state, ptr %54, i32 0, i32 7
  %56 = load ptr, ptr %55, align 8, !tbaa !22
  %57 = load ptr, ptr %15, align 8, !tbaa !5
  %58 = ptrtoint ptr %56 to i64
  %59 = ptrtoint ptr %57 to i64
  %60 = sub i64 %58, %59
  br label %61

61:                                               ; preds = %53, %44
  %62 = phi i64 [ %52, %44 ], [ %60, %53 ]
  %63 = trunc i64 %62 to i32
  store i32 %63, ptr %16, align 4, !tbaa !9
  br label %64

64:                                               ; preds = %1273, %61
  br label %65

65:                                               ; preds = %64
  %66 = load ptr, ptr %18, align 8, !tbaa !5
  %67 = getelementptr inbounds %struct.inflate_codes_state, ptr %66, i32 0, i32 0
  %68 = load i32, ptr %67, align 8, !tbaa !23
  switch i32 %68, label %1242 [
    i32 0, label %69
    i32 1, label %185
    i32 2, label %364
    i32 3, label %456
    i32 4, label %618
    i32 5, label %698
    i32 6, label %919
    i32 7, label %1093
    i32 8, label %1180
    i32 9, label %1211
  ]

69:                                               ; preds = %65
  %70 = load i32, ptr %16, align 4, !tbaa !9
  %71 = icmp uge i32 %70, 258
  br i1 %71, label %72, label %169

72:                                               ; preds = %69
  %73 = load i32, ptr %14, align 4, !tbaa !9
  %74 = icmp uge i32 %73, 10
  br i1 %74, label %75, label %169

75:                                               ; preds = %72
  %76 = load i64, ptr %11, align 8, !tbaa !18
  %77 = load ptr, ptr %5, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.inflate_blocks_state, ptr %77, i32 0, i32 4
  store i64 %76, ptr %78, align 8, !tbaa !16
  %79 = load i32, ptr %12, align 4, !tbaa !9
  %80 = load ptr, ptr %5, align 8, !tbaa !5
  %81 = getelementptr inbounds %struct.inflate_blocks_state, ptr %80, i32 0, i32 3
  store i32 %79, ptr %81, align 4, !tbaa !19
  %82 = load i32, ptr %14, align 4, !tbaa !9
  %83 = load ptr, ptr %6, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.z_stream_s, ptr %83, i32 0, i32 1
  store i32 %82, ptr %84, align 8, !tbaa !15
  %85 = load ptr, ptr %13, align 8, !tbaa !5
  %86 = load ptr, ptr %6, align 8, !tbaa !5
  %87 = getelementptr inbounds %struct.z_stream_s, ptr %86, i32 0, i32 0
  %88 = load ptr, ptr %87, align 8, !tbaa !12
  %89 = ptrtoint ptr %85 to i64
  %90 = ptrtoint ptr %88 to i64
  %91 = sub i64 %89, %90
  %92 = load ptr, ptr %6, align 8, !tbaa !5
  %93 = getelementptr inbounds %struct.z_stream_s, ptr %92, i32 0, i32 2
  %94 = load i64, ptr %93, align 8, !tbaa !25
  %95 = add i64 %94, %91
  store i64 %95, ptr %93, align 8, !tbaa !25
  %96 = load ptr, ptr %13, align 8, !tbaa !5
  %97 = load ptr, ptr %6, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.z_stream_s, ptr %97, i32 0, i32 0
  store ptr %96, ptr %98, align 8, !tbaa !12
  %99 = load ptr, ptr %15, align 8, !tbaa !5
  %100 = load ptr, ptr %5, align 8, !tbaa !5
  %101 = getelementptr inbounds %struct.inflate_blocks_state, ptr %100, i32 0, i32 9
  store ptr %99, ptr %101, align 8, !tbaa !20
  %102 = load ptr, ptr %18, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.inflate_codes_state, ptr %102, i32 0, i32 3
  %104 = load i8, ptr %103, align 8, !tbaa !26
  %105 = zext i8 %104 to i32
  %106 = load ptr, ptr %18, align 8, !tbaa !5
  %107 = getelementptr inbounds %struct.inflate_codes_state, ptr %106, i32 0, i32 4
  %108 = load i8, ptr %107, align 1, !tbaa !27
  %109 = zext i8 %108 to i32
  %110 = load ptr, ptr %18, align 8, !tbaa !5
  %111 = getelementptr inbounds %struct.inflate_codes_state, ptr %110, i32 0, i32 5
  %112 = load ptr, ptr %111, align 8, !tbaa !28
  %113 = load ptr, ptr %18, align 8, !tbaa !5
  %114 = getelementptr inbounds %struct.inflate_codes_state, ptr %113, i32 0, i32 6
  %115 = load ptr, ptr %114, align 8, !tbaa !29
  %116 = load ptr, ptr %5, align 8, !tbaa !5
  %117 = load ptr, ptr %6, align 8, !tbaa !5
  %118 = call i32 @inflate_fast(i32 noundef %105, i32 noundef %109, ptr noundef %112, ptr noundef %115, ptr noundef %116, ptr noundef %117)
  store i32 %118, ptr %7, align 4, !tbaa !9
  %119 = load ptr, ptr %6, align 8, !tbaa !5
  %120 = getelementptr inbounds %struct.z_stream_s, ptr %119, i32 0, i32 0
  %121 = load ptr, ptr %120, align 8, !tbaa !12
  store ptr %121, ptr %13, align 8, !tbaa !5
  %122 = load ptr, ptr %6, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.z_stream_s, ptr %122, i32 0, i32 1
  %124 = load i32, ptr %123, align 8, !tbaa !15
  store i32 %124, ptr %14, align 4, !tbaa !9
  %125 = load ptr, ptr %5, align 8, !tbaa !5
  %126 = getelementptr inbounds %struct.inflate_blocks_state, ptr %125, i32 0, i32 4
  %127 = load i64, ptr %126, align 8, !tbaa !16
  store i64 %127, ptr %11, align 8, !tbaa !18
  %128 = load ptr, ptr %5, align 8, !tbaa !5
  %129 = getelementptr inbounds %struct.inflate_blocks_state, ptr %128, i32 0, i32 3
  %130 = load i32, ptr %129, align 4, !tbaa !19
  store i32 %130, ptr %12, align 4, !tbaa !9
  %131 = load ptr, ptr %5, align 8, !tbaa !5
  %132 = getelementptr inbounds %struct.inflate_blocks_state, ptr %131, i32 0, i32 9
  %133 = load ptr, ptr %132, align 8, !tbaa !20
  store ptr %133, ptr %15, align 8, !tbaa !5
  %134 = load ptr, ptr %15, align 8, !tbaa !5
  %135 = load ptr, ptr %5, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.inflate_blocks_state, ptr %135, i32 0, i32 8
  %137 = load ptr, ptr %136, align 8, !tbaa !21
  %138 = icmp ult ptr %134, %137
  br i1 %138, label %139, label %148

139:                                              ; preds = %75
  %140 = load ptr, ptr %5, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.inflate_blocks_state, ptr %140, i32 0, i32 8
  %142 = load ptr, ptr %141, align 8, !tbaa !21
  %143 = load ptr, ptr %15, align 8, !tbaa !5
  %144 = ptrtoint ptr %142 to i64
  %145 = ptrtoint ptr %143 to i64
  %146 = sub i64 %144, %145
  %147 = sub nsw i64 %146, 1
  br label %156

148:                                              ; preds = %75
  %149 = load ptr, ptr %5, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct.inflate_blocks_state, ptr %149, i32 0, i32 7
  %151 = load ptr, ptr %150, align 8, !tbaa !22
  %152 = load ptr, ptr %15, align 8, !tbaa !5
  %153 = ptrtoint ptr %151 to i64
  %154 = ptrtoint ptr %152 to i64
  %155 = sub i64 %153, %154
  br label %156

156:                                              ; preds = %148, %139
  %157 = phi i64 [ %147, %139 ], [ %155, %148 ]
  %158 = trunc i64 %157 to i32
  store i32 %158, ptr %16, align 4, !tbaa !9
  %159 = load i32, ptr %7, align 4, !tbaa !9
  %160 = icmp ne i32 %159, 0
  br i1 %160, label %161, label %168

161:                                              ; preds = %156
  %162 = load i32, ptr %7, align 4, !tbaa !9
  %163 = icmp eq i32 %162, 1
  %164 = zext i1 %163 to i64
  %165 = select i1 %163, i32 7, i32 9
  %166 = load ptr, ptr %18, align 8, !tbaa !5
  %167 = getelementptr inbounds %struct.inflate_codes_state, ptr %166, i32 0, i32 0
  store i32 %165, ptr %167, align 8, !tbaa !23
  br label %1273

168:                                              ; preds = %156
  br label %169

169:                                              ; preds = %168, %72, %69
  %170 = load ptr, ptr %18, align 8, !tbaa !5
  %171 = getelementptr inbounds %struct.inflate_codes_state, ptr %170, i32 0, i32 3
  %172 = load i8, ptr %171, align 8, !tbaa !26
  %173 = zext i8 %172 to i32
  %174 = load ptr, ptr %18, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct.inflate_codes_state, ptr %174, i32 0, i32 2
  %176 = getelementptr inbounds %struct.anon, ptr %175, i32 0, i32 1
  store i32 %173, ptr %176, align 8, !tbaa !11
  %177 = load ptr, ptr %18, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.inflate_codes_state, ptr %177, i32 0, i32 5
  %179 = load ptr, ptr %178, align 8, !tbaa !28
  %180 = load ptr, ptr %18, align 8, !tbaa !5
  %181 = getelementptr inbounds %struct.inflate_codes_state, ptr %180, i32 0, i32 2
  %182 = getelementptr inbounds %struct.anon, ptr %181, i32 0, i32 0
  store ptr %179, ptr %182, align 8, !tbaa !11
  %183 = load ptr, ptr %18, align 8, !tbaa !5
  %184 = getelementptr inbounds %struct.inflate_codes_state, ptr %183, i32 0, i32 0
  store i32 1, ptr %184, align 8, !tbaa !23
  br label %185

185:                                              ; preds = %169, %65
  %186 = load ptr, ptr %18, align 8, !tbaa !5
  %187 = getelementptr inbounds %struct.inflate_codes_state, ptr %186, i32 0, i32 2
  %188 = getelementptr inbounds %struct.anon, ptr %187, i32 0, i32 1
  %189 = load i32, ptr %188, align 8, !tbaa !11
  store i32 %189, ptr %8, align 4, !tbaa !9
  br label %190

190:                                              ; preds = %229, %185
  %191 = load i32, ptr %12, align 4, !tbaa !9
  %192 = load i32, ptr %8, align 4, !tbaa !9
  %193 = icmp ult i32 %191, %192
  br i1 %193, label %194, label %243

194:                                              ; preds = %190
  %195 = load i32, ptr %14, align 4, !tbaa !9
  %196 = icmp ne i32 %195, 0
  br i1 %196, label %197, label %198

197:                                              ; preds = %194
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %229

198:                                              ; preds = %194
  %199 = load i64, ptr %11, align 8, !tbaa !18
  %200 = load ptr, ptr %5, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.inflate_blocks_state, ptr %200, i32 0, i32 4
  store i64 %199, ptr %201, align 8, !tbaa !16
  %202 = load i32, ptr %12, align 4, !tbaa !9
  %203 = load ptr, ptr %5, align 8, !tbaa !5
  %204 = getelementptr inbounds %struct.inflate_blocks_state, ptr %203, i32 0, i32 3
  store i32 %202, ptr %204, align 4, !tbaa !19
  %205 = load i32, ptr %14, align 4, !tbaa !9
  %206 = load ptr, ptr %6, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.z_stream_s, ptr %206, i32 0, i32 1
  store i32 %205, ptr %207, align 8, !tbaa !15
  %208 = load ptr, ptr %13, align 8, !tbaa !5
  %209 = load ptr, ptr %6, align 8, !tbaa !5
  %210 = getelementptr inbounds %struct.z_stream_s, ptr %209, i32 0, i32 0
  %211 = load ptr, ptr %210, align 8, !tbaa !12
  %212 = ptrtoint ptr %208 to i64
  %213 = ptrtoint ptr %211 to i64
  %214 = sub i64 %212, %213
  %215 = load ptr, ptr %6, align 8, !tbaa !5
  %216 = getelementptr inbounds %struct.z_stream_s, ptr %215, i32 0, i32 2
  %217 = load i64, ptr %216, align 8, !tbaa !25
  %218 = add i64 %217, %214
  store i64 %218, ptr %216, align 8, !tbaa !25
  %219 = load ptr, ptr %13, align 8, !tbaa !5
  %220 = load ptr, ptr %6, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.z_stream_s, ptr %220, i32 0, i32 0
  store ptr %219, ptr %221, align 8, !tbaa !12
  %222 = load ptr, ptr %15, align 8, !tbaa !5
  %223 = load ptr, ptr %5, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.inflate_blocks_state, ptr %223, i32 0, i32 9
  store ptr %222, ptr %224, align 8, !tbaa !20
  %225 = load ptr, ptr %5, align 8, !tbaa !5
  %226 = load ptr, ptr %6, align 8, !tbaa !5
  %227 = load i32, ptr %7, align 4, !tbaa !9
  %228 = call i32 @inflate_flush(ptr noundef %225, ptr noundef %226, i32 noundef %227)
  store i32 %228, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

229:                                              ; preds = %197
  %230 = load i32, ptr %14, align 4, !tbaa !9
  %231 = add i32 %230, -1
  store i32 %231, ptr %14, align 4, !tbaa !9
  %232 = load ptr, ptr %13, align 8, !tbaa !5
  %233 = getelementptr inbounds i8, ptr %232, i32 1
  store ptr %233, ptr %13, align 8, !tbaa !5
  %234 = load i8, ptr %232, align 1, !tbaa !11
  %235 = zext i8 %234 to i64
  %236 = load i32, ptr %12, align 4, !tbaa !9
  %237 = zext i32 %236 to i64
  %238 = shl i64 %235, %237
  %239 = load i64, ptr %11, align 8, !tbaa !18
  %240 = or i64 %239, %238
  store i64 %240, ptr %11, align 8, !tbaa !18
  %241 = load i32, ptr %12, align 4, !tbaa !9
  %242 = add i32 %241, 8
  store i32 %242, ptr %12, align 4, !tbaa !9
  br label %190, !llvm.loop !30

243:                                              ; preds = %190
  %244 = load ptr, ptr %18, align 8, !tbaa !5
  %245 = getelementptr inbounds %struct.inflate_codes_state, ptr %244, i32 0, i32 2
  %246 = getelementptr inbounds %struct.anon, ptr %245, i32 0, i32 0
  %247 = load ptr, ptr %246, align 8, !tbaa !11
  %248 = load i64, ptr %11, align 8, !tbaa !18
  %249 = trunc i64 %248 to i32
  %250 = load i32, ptr %8, align 4, !tbaa !9
  %251 = zext i32 %250 to i64
  %252 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %251
  %253 = load i32, ptr %252, align 4, !tbaa !9
  %254 = and i32 %249, %253
  %255 = zext i32 %254 to i64
  %256 = getelementptr inbounds %struct.inflate_huft_s, ptr %247, i64 %255
  store ptr %256, ptr %9, align 8, !tbaa !5
  %257 = load ptr, ptr %9, align 8, !tbaa !5
  %258 = getelementptr inbounds %struct.inflate_huft_s, ptr %257, i32 0, i32 0
  %259 = getelementptr inbounds %struct.anon.5, ptr %258, i32 0, i32 1
  %260 = load i8, ptr %259, align 1, !tbaa !11
  %261 = zext i8 %260 to i32
  %262 = load i64, ptr %11, align 8, !tbaa !18
  %263 = zext i32 %261 to i64
  %264 = lshr i64 %262, %263
  store i64 %264, ptr %11, align 8, !tbaa !18
  %265 = load ptr, ptr %9, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.inflate_huft_s, ptr %265, i32 0, i32 0
  %267 = getelementptr inbounds %struct.anon.5, ptr %266, i32 0, i32 1
  %268 = load i8, ptr %267, align 1, !tbaa !11
  %269 = zext i8 %268 to i32
  %270 = load i32, ptr %12, align 4, !tbaa !9
  %271 = sub i32 %270, %269
  store i32 %271, ptr %12, align 4, !tbaa !9
  %272 = load ptr, ptr %9, align 8, !tbaa !5
  %273 = getelementptr inbounds %struct.inflate_huft_s, ptr %272, i32 0, i32 0
  %274 = getelementptr inbounds %struct.anon.5, ptr %273, i32 0, i32 0
  %275 = load i8, ptr %274, align 4, !tbaa !11
  %276 = zext i8 %275 to i32
  store i32 %276, ptr %10, align 4, !tbaa !9
  %277 = load i32, ptr %10, align 4, !tbaa !9
  %278 = icmp eq i32 %277, 0
  br i1 %278, label %279, label %287

279:                                              ; preds = %243
  %280 = load ptr, ptr %9, align 8, !tbaa !5
  %281 = getelementptr inbounds %struct.inflate_huft_s, ptr %280, i32 0, i32 1
  %282 = load i32, ptr %281, align 4, !tbaa !32
  %283 = load ptr, ptr %18, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.inflate_codes_state, ptr %283, i32 0, i32 2
  store i32 %282, ptr %284, align 8, !tbaa !11
  %285 = load ptr, ptr %18, align 8, !tbaa !5
  %286 = getelementptr inbounds %struct.inflate_codes_state, ptr %285, i32 0, i32 0
  store i32 6, ptr %286, align 8, !tbaa !23
  br label %1273

287:                                              ; preds = %243
  %288 = load i32, ptr %10, align 4, !tbaa !9
  %289 = and i32 %288, 16
  %290 = icmp ne i32 %289, 0
  br i1 %290, label %291, label %304

291:                                              ; preds = %287
  %292 = load i32, ptr %10, align 4, !tbaa !9
  %293 = and i32 %292, 15
  %294 = load ptr, ptr %18, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.inflate_codes_state, ptr %294, i32 0, i32 2
  %296 = getelementptr inbounds %struct.anon.0, ptr %295, i32 0, i32 0
  store i32 %293, ptr %296, align 8, !tbaa !11
  %297 = load ptr, ptr %9, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.inflate_huft_s, ptr %297, i32 0, i32 1
  %299 = load i32, ptr %298, align 4, !tbaa !32
  %300 = load ptr, ptr %18, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.inflate_codes_state, ptr %300, i32 0, i32 1
  store i32 %299, ptr %301, align 4, !tbaa !34
  %302 = load ptr, ptr %18, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.inflate_codes_state, ptr %302, i32 0, i32 0
  store i32 2, ptr %303, align 8, !tbaa !23
  br label %1273

304:                                              ; preds = %287
  %305 = load i32, ptr %10, align 4, !tbaa !9
  %306 = and i32 %305, 64
  %307 = icmp eq i32 %306, 0
  br i1 %307, label %308, label %322

308:                                              ; preds = %304
  %309 = load i32, ptr %10, align 4, !tbaa !9
  %310 = load ptr, ptr %18, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.inflate_codes_state, ptr %310, i32 0, i32 2
  %312 = getelementptr inbounds %struct.anon, ptr %311, i32 0, i32 1
  store i32 %309, ptr %312, align 8, !tbaa !11
  %313 = load ptr, ptr %9, align 8, !tbaa !5
  %314 = load ptr, ptr %9, align 8, !tbaa !5
  %315 = getelementptr inbounds %struct.inflate_huft_s, ptr %314, i32 0, i32 1
  %316 = load i32, ptr %315, align 4, !tbaa !32
  %317 = zext i32 %316 to i64
  %318 = getelementptr inbounds %struct.inflate_huft_s, ptr %313, i64 %317
  %319 = load ptr, ptr %18, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.inflate_codes_state, ptr %319, i32 0, i32 2
  %321 = getelementptr inbounds %struct.anon, ptr %320, i32 0, i32 0
  store ptr %318, ptr %321, align 8, !tbaa !11
  br label %1273

322:                                              ; preds = %304
  %323 = load i32, ptr %10, align 4, !tbaa !9
  %324 = and i32 %323, 32
  %325 = icmp ne i32 %324, 0
  br i1 %325, label %326, label %329

326:                                              ; preds = %322
  %327 = load ptr, ptr %18, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.inflate_codes_state, ptr %327, i32 0, i32 0
  store i32 7, ptr %328, align 8, !tbaa !23
  br label %1273

329:                                              ; preds = %322
  %330 = load ptr, ptr %18, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.inflate_codes_state, ptr %330, i32 0, i32 0
  store i32 9, ptr %331, align 8, !tbaa !23
  %332 = load ptr, ptr %6, align 8, !tbaa !5
  %333 = getelementptr inbounds %struct.z_stream_s, ptr %332, i32 0, i32 6
  store ptr @.str, ptr %333, align 8, !tbaa !35
  store i32 -3, ptr %7, align 4, !tbaa !9
  %334 = load i64, ptr %11, align 8, !tbaa !18
  %335 = load ptr, ptr %5, align 8, !tbaa !5
  %336 = getelementptr inbounds %struct.inflate_blocks_state, ptr %335, i32 0, i32 4
  store i64 %334, ptr %336, align 8, !tbaa !16
  %337 = load i32, ptr %12, align 4, !tbaa !9
  %338 = load ptr, ptr %5, align 8, !tbaa !5
  %339 = getelementptr inbounds %struct.inflate_blocks_state, ptr %338, i32 0, i32 3
  store i32 %337, ptr %339, align 4, !tbaa !19
  %340 = load i32, ptr %14, align 4, !tbaa !9
  %341 = load ptr, ptr %6, align 8, !tbaa !5
  %342 = getelementptr inbounds %struct.z_stream_s, ptr %341, i32 0, i32 1
  store i32 %340, ptr %342, align 8, !tbaa !15
  %343 = load ptr, ptr %13, align 8, !tbaa !5
  %344 = load ptr, ptr %6, align 8, !tbaa !5
  %345 = getelementptr inbounds %struct.z_stream_s, ptr %344, i32 0, i32 0
  %346 = load ptr, ptr %345, align 8, !tbaa !12
  %347 = ptrtoint ptr %343 to i64
  %348 = ptrtoint ptr %346 to i64
  %349 = sub i64 %347, %348
  %350 = load ptr, ptr %6, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.z_stream_s, ptr %350, i32 0, i32 2
  %352 = load i64, ptr %351, align 8, !tbaa !25
  %353 = add i64 %352, %349
  store i64 %353, ptr %351, align 8, !tbaa !25
  %354 = load ptr, ptr %13, align 8, !tbaa !5
  %355 = load ptr, ptr %6, align 8, !tbaa !5
  %356 = getelementptr inbounds %struct.z_stream_s, ptr %355, i32 0, i32 0
  store ptr %354, ptr %356, align 8, !tbaa !12
  %357 = load ptr, ptr %15, align 8, !tbaa !5
  %358 = load ptr, ptr %5, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.inflate_blocks_state, ptr %358, i32 0, i32 9
  store ptr %357, ptr %359, align 8, !tbaa !20
  %360 = load ptr, ptr %5, align 8, !tbaa !5
  %361 = load ptr, ptr %6, align 8, !tbaa !5
  %362 = load i32, ptr %7, align 4, !tbaa !9
  %363 = call i32 @inflate_flush(ptr noundef %360, ptr noundef %361, i32 noundef %362)
  store i32 %363, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

364:                                              ; preds = %65
  %365 = load ptr, ptr %18, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.inflate_codes_state, ptr %365, i32 0, i32 2
  %367 = getelementptr inbounds %struct.anon.0, ptr %366, i32 0, i32 0
  %368 = load i32, ptr %367, align 8, !tbaa !11
  store i32 %368, ptr %8, align 4, !tbaa !9
  br label %369

369:                                              ; preds = %408, %364
  %370 = load i32, ptr %12, align 4, !tbaa !9
  %371 = load i32, ptr %8, align 4, !tbaa !9
  %372 = icmp ult i32 %370, %371
  br i1 %372, label %373, label %422

373:                                              ; preds = %369
  %374 = load i32, ptr %14, align 4, !tbaa !9
  %375 = icmp ne i32 %374, 0
  br i1 %375, label %376, label %377

376:                                              ; preds = %373
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %408

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

408:                                              ; preds = %376
  %409 = load i32, ptr %14, align 4, !tbaa !9
  %410 = add i32 %409, -1
  store i32 %410, ptr %14, align 4, !tbaa !9
  %411 = load ptr, ptr %13, align 8, !tbaa !5
  %412 = getelementptr inbounds i8, ptr %411, i32 1
  store ptr %412, ptr %13, align 8, !tbaa !5
  %413 = load i8, ptr %411, align 1, !tbaa !11
  %414 = zext i8 %413 to i64
  %415 = load i32, ptr %12, align 4, !tbaa !9
  %416 = zext i32 %415 to i64
  %417 = shl i64 %414, %416
  %418 = load i64, ptr %11, align 8, !tbaa !18
  %419 = or i64 %418, %417
  store i64 %419, ptr %11, align 8, !tbaa !18
  %420 = load i32, ptr %12, align 4, !tbaa !9
  %421 = add i32 %420, 8
  store i32 %421, ptr %12, align 4, !tbaa !9
  br label %369, !llvm.loop !36

422:                                              ; preds = %369
  %423 = load i64, ptr %11, align 8, !tbaa !18
  %424 = trunc i64 %423 to i32
  %425 = load i32, ptr %8, align 4, !tbaa !9
  %426 = zext i32 %425 to i64
  %427 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %426
  %428 = load i32, ptr %427, align 4, !tbaa !9
  %429 = and i32 %424, %428
  %430 = load ptr, ptr %18, align 8, !tbaa !5
  %431 = getelementptr inbounds %struct.inflate_codes_state, ptr %430, i32 0, i32 1
  %432 = load i32, ptr %431, align 4, !tbaa !34
  %433 = add i32 %432, %429
  store i32 %433, ptr %431, align 4, !tbaa !34
  %434 = load i32, ptr %8, align 4, !tbaa !9
  %435 = load i64, ptr %11, align 8, !tbaa !18
  %436 = zext i32 %434 to i64
  %437 = lshr i64 %435, %436
  store i64 %437, ptr %11, align 8, !tbaa !18
  %438 = load i32, ptr %8, align 4, !tbaa !9
  %439 = load i32, ptr %12, align 4, !tbaa !9
  %440 = sub i32 %439, %438
  store i32 %440, ptr %12, align 4, !tbaa !9
  %441 = load ptr, ptr %18, align 8, !tbaa !5
  %442 = getelementptr inbounds %struct.inflate_codes_state, ptr %441, i32 0, i32 4
  %443 = load i8, ptr %442, align 1, !tbaa !27
  %444 = zext i8 %443 to i32
  %445 = load ptr, ptr %18, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.inflate_codes_state, ptr %445, i32 0, i32 2
  %447 = getelementptr inbounds %struct.anon, ptr %446, i32 0, i32 1
  store i32 %444, ptr %447, align 8, !tbaa !11
  %448 = load ptr, ptr %18, align 8, !tbaa !5
  %449 = getelementptr inbounds %struct.inflate_codes_state, ptr %448, i32 0, i32 6
  %450 = load ptr, ptr %449, align 8, !tbaa !29
  %451 = load ptr, ptr %18, align 8, !tbaa !5
  %452 = getelementptr inbounds %struct.inflate_codes_state, ptr %451, i32 0, i32 2
  %453 = getelementptr inbounds %struct.anon, ptr %452, i32 0, i32 0
  store ptr %450, ptr %453, align 8, !tbaa !11
  %454 = load ptr, ptr %18, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.inflate_codes_state, ptr %454, i32 0, i32 0
  store i32 3, ptr %455, align 8, !tbaa !23
  br label %456

456:                                              ; preds = %422, %65
  %457 = load ptr, ptr %18, align 8, !tbaa !5
  %458 = getelementptr inbounds %struct.inflate_codes_state, ptr %457, i32 0, i32 2
  %459 = getelementptr inbounds %struct.anon, ptr %458, i32 0, i32 1
  %460 = load i32, ptr %459, align 8, !tbaa !11
  store i32 %460, ptr %8, align 4, !tbaa !9
  br label %461

461:                                              ; preds = %500, %456
  %462 = load i32, ptr %12, align 4, !tbaa !9
  %463 = load i32, ptr %8, align 4, !tbaa !9
  %464 = icmp ult i32 %462, %463
  br i1 %464, label %465, label %514

465:                                              ; preds = %461
  %466 = load i32, ptr %14, align 4, !tbaa !9
  %467 = icmp ne i32 %466, 0
  br i1 %467, label %468, label %469

468:                                              ; preds = %465
  store i32 0, ptr %7, align 4, !tbaa !9
  br label %500

469:                                              ; preds = %465
  %470 = load i64, ptr %11, align 8, !tbaa !18
  %471 = load ptr, ptr %5, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.inflate_blocks_state, ptr %471, i32 0, i32 4
  store i64 %470, ptr %472, align 8, !tbaa !16
  %473 = load i32, ptr %12, align 4, !tbaa !9
  %474 = load ptr, ptr %5, align 8, !tbaa !5
  %475 = getelementptr inbounds %struct.inflate_blocks_state, ptr %474, i32 0, i32 3
  store i32 %473, ptr %475, align 4, !tbaa !19
  %476 = load i32, ptr %14, align 4, !tbaa !9
  %477 = load ptr, ptr %6, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.z_stream_s, ptr %477, i32 0, i32 1
  store i32 %476, ptr %478, align 8, !tbaa !15
  %479 = load ptr, ptr %13, align 8, !tbaa !5
  %480 = load ptr, ptr %6, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.z_stream_s, ptr %480, i32 0, i32 0
  %482 = load ptr, ptr %481, align 8, !tbaa !12
  %483 = ptrtoint ptr %479 to i64
  %484 = ptrtoint ptr %482 to i64
  %485 = sub i64 %483, %484
  %486 = load ptr, ptr %6, align 8, !tbaa !5
  %487 = getelementptr inbounds %struct.z_stream_s, ptr %486, i32 0, i32 2
  %488 = load i64, ptr %487, align 8, !tbaa !25
  %489 = add i64 %488, %485
  store i64 %489, ptr %487, align 8, !tbaa !25
  %490 = load ptr, ptr %13, align 8, !tbaa !5
  %491 = load ptr, ptr %6, align 8, !tbaa !5
  %492 = getelementptr inbounds %struct.z_stream_s, ptr %491, i32 0, i32 0
  store ptr %490, ptr %492, align 8, !tbaa !12
  %493 = load ptr, ptr %15, align 8, !tbaa !5
  %494 = load ptr, ptr %5, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.inflate_blocks_state, ptr %494, i32 0, i32 9
  store ptr %493, ptr %495, align 8, !tbaa !20
  %496 = load ptr, ptr %5, align 8, !tbaa !5
  %497 = load ptr, ptr %6, align 8, !tbaa !5
  %498 = load i32, ptr %7, align 4, !tbaa !9
  %499 = call i32 @inflate_flush(ptr noundef %496, ptr noundef %497, i32 noundef %498)
  store i32 %499, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

500:                                              ; preds = %468
  %501 = load i32, ptr %14, align 4, !tbaa !9
  %502 = add i32 %501, -1
  store i32 %502, ptr %14, align 4, !tbaa !9
  %503 = load ptr, ptr %13, align 8, !tbaa !5
  %504 = getelementptr inbounds i8, ptr %503, i32 1
  store ptr %504, ptr %13, align 8, !tbaa !5
  %505 = load i8, ptr %503, align 1, !tbaa !11
  %506 = zext i8 %505 to i64
  %507 = load i32, ptr %12, align 4, !tbaa !9
  %508 = zext i32 %507 to i64
  %509 = shl i64 %506, %508
  %510 = load i64, ptr %11, align 8, !tbaa !18
  %511 = or i64 %510, %509
  store i64 %511, ptr %11, align 8, !tbaa !18
  %512 = load i32, ptr %12, align 4, !tbaa !9
  %513 = add i32 %512, 8
  store i32 %513, ptr %12, align 4, !tbaa !9
  br label %461, !llvm.loop !37

514:                                              ; preds = %461
  %515 = load ptr, ptr %18, align 8, !tbaa !5
  %516 = getelementptr inbounds %struct.inflate_codes_state, ptr %515, i32 0, i32 2
  %517 = getelementptr inbounds %struct.anon, ptr %516, i32 0, i32 0
  %518 = load ptr, ptr %517, align 8, !tbaa !11
  %519 = load i64, ptr %11, align 8, !tbaa !18
  %520 = trunc i64 %519 to i32
  %521 = load i32, ptr %8, align 4, !tbaa !9
  %522 = zext i32 %521 to i64
  %523 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %522
  %524 = load i32, ptr %523, align 4, !tbaa !9
  %525 = and i32 %520, %524
  %526 = zext i32 %525 to i64
  %527 = getelementptr inbounds %struct.inflate_huft_s, ptr %518, i64 %526
  store ptr %527, ptr %9, align 8, !tbaa !5
  %528 = load ptr, ptr %9, align 8, !tbaa !5
  %529 = getelementptr inbounds %struct.inflate_huft_s, ptr %528, i32 0, i32 0
  %530 = getelementptr inbounds %struct.anon.5, ptr %529, i32 0, i32 1
  %531 = load i8, ptr %530, align 1, !tbaa !11
  %532 = zext i8 %531 to i32
  %533 = load i64, ptr %11, align 8, !tbaa !18
  %534 = zext i32 %532 to i64
  %535 = lshr i64 %533, %534
  store i64 %535, ptr %11, align 8, !tbaa !18
  %536 = load ptr, ptr %9, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.inflate_huft_s, ptr %536, i32 0, i32 0
  %538 = getelementptr inbounds %struct.anon.5, ptr %537, i32 0, i32 1
  %539 = load i8, ptr %538, align 1, !tbaa !11
  %540 = zext i8 %539 to i32
  %541 = load i32, ptr %12, align 4, !tbaa !9
  %542 = sub i32 %541, %540
  store i32 %542, ptr %12, align 4, !tbaa !9
  %543 = load ptr, ptr %9, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.inflate_huft_s, ptr %543, i32 0, i32 0
  %545 = getelementptr inbounds %struct.anon.5, ptr %544, i32 0, i32 0
  %546 = load i8, ptr %545, align 4, !tbaa !11
  %547 = zext i8 %546 to i32
  store i32 %547, ptr %10, align 4, !tbaa !9
  %548 = load i32, ptr %10, align 4, !tbaa !9
  %549 = and i32 %548, 16
  %550 = icmp ne i32 %549, 0
  br i1 %550, label %551, label %565

551:                                              ; preds = %514
  %552 = load i32, ptr %10, align 4, !tbaa !9
  %553 = and i32 %552, 15
  %554 = load ptr, ptr %18, align 8, !tbaa !5
  %555 = getelementptr inbounds %struct.inflate_codes_state, ptr %554, i32 0, i32 2
  %556 = getelementptr inbounds %struct.anon.0, ptr %555, i32 0, i32 0
  store i32 %553, ptr %556, align 8, !tbaa !11
  %557 = load ptr, ptr %9, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.inflate_huft_s, ptr %557, i32 0, i32 1
  %559 = load i32, ptr %558, align 4, !tbaa !32
  %560 = load ptr, ptr %18, align 8, !tbaa !5
  %561 = getelementptr inbounds %struct.inflate_codes_state, ptr %560, i32 0, i32 2
  %562 = getelementptr inbounds %struct.anon.0, ptr %561, i32 0, i32 1
  store i32 %559, ptr %562, align 4, !tbaa !11
  %563 = load ptr, ptr %18, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.inflate_codes_state, ptr %563, i32 0, i32 0
  store i32 4, ptr %564, align 8, !tbaa !23
  br label %1273

565:                                              ; preds = %514
  %566 = load i32, ptr %10, align 4, !tbaa !9
  %567 = and i32 %566, 64
  %568 = icmp eq i32 %567, 0
  br i1 %568, label %569, label %583

569:                                              ; preds = %565
  %570 = load i32, ptr %10, align 4, !tbaa !9
  %571 = load ptr, ptr %18, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.inflate_codes_state, ptr %571, i32 0, i32 2
  %573 = getelementptr inbounds %struct.anon, ptr %572, i32 0, i32 1
  store i32 %570, ptr %573, align 8, !tbaa !11
  %574 = load ptr, ptr %9, align 8, !tbaa !5
  %575 = load ptr, ptr %9, align 8, !tbaa !5
  %576 = getelementptr inbounds %struct.inflate_huft_s, ptr %575, i32 0, i32 1
  %577 = load i32, ptr %576, align 4, !tbaa !32
  %578 = zext i32 %577 to i64
  %579 = getelementptr inbounds %struct.inflate_huft_s, ptr %574, i64 %578
  %580 = load ptr, ptr %18, align 8, !tbaa !5
  %581 = getelementptr inbounds %struct.inflate_codes_state, ptr %580, i32 0, i32 2
  %582 = getelementptr inbounds %struct.anon, ptr %581, i32 0, i32 0
  store ptr %579, ptr %582, align 8, !tbaa !11
  br label %1273

583:                                              ; preds = %565
  %584 = load ptr, ptr %18, align 8, !tbaa !5
  %585 = getelementptr inbounds %struct.inflate_codes_state, ptr %584, i32 0, i32 0
  store i32 9, ptr %585, align 8, !tbaa !23
  %586 = load ptr, ptr %6, align 8, !tbaa !5
  %587 = getelementptr inbounds %struct.z_stream_s, ptr %586, i32 0, i32 6
  store ptr @.str.1, ptr %587, align 8, !tbaa !35
  store i32 -3, ptr %7, align 4, !tbaa !9
  %588 = load i64, ptr %11, align 8, !tbaa !18
  %589 = load ptr, ptr %5, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.inflate_blocks_state, ptr %589, i32 0, i32 4
  store i64 %588, ptr %590, align 8, !tbaa !16
  %591 = load i32, ptr %12, align 4, !tbaa !9
  %592 = load ptr, ptr %5, align 8, !tbaa !5
  %593 = getelementptr inbounds %struct.inflate_blocks_state, ptr %592, i32 0, i32 3
  store i32 %591, ptr %593, align 4, !tbaa !19
  %594 = load i32, ptr %14, align 4, !tbaa !9
  %595 = load ptr, ptr %6, align 8, !tbaa !5
  %596 = getelementptr inbounds %struct.z_stream_s, ptr %595, i32 0, i32 1
  store i32 %594, ptr %596, align 8, !tbaa !15
  %597 = load ptr, ptr %13, align 8, !tbaa !5
  %598 = load ptr, ptr %6, align 8, !tbaa !5
  %599 = getelementptr inbounds %struct.z_stream_s, ptr %598, i32 0, i32 0
  %600 = load ptr, ptr %599, align 8, !tbaa !12
  %601 = ptrtoint ptr %597 to i64
  %602 = ptrtoint ptr %600 to i64
  %603 = sub i64 %601, %602
  %604 = load ptr, ptr %6, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.z_stream_s, ptr %604, i32 0, i32 2
  %606 = load i64, ptr %605, align 8, !tbaa !25
  %607 = add i64 %606, %603
  store i64 %607, ptr %605, align 8, !tbaa !25
  %608 = load ptr, ptr %13, align 8, !tbaa !5
  %609 = load ptr, ptr %6, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.z_stream_s, ptr %609, i32 0, i32 0
  store ptr %608, ptr %610, align 8, !tbaa !12
  %611 = load ptr, ptr %15, align 8, !tbaa !5
  %612 = load ptr, ptr %5, align 8, !tbaa !5
  %613 = getelementptr inbounds %struct.inflate_blocks_state, ptr %612, i32 0, i32 9
  store ptr %611, ptr %613, align 8, !tbaa !20
  %614 = load ptr, ptr %5, align 8, !tbaa !5
  %615 = load ptr, ptr %6, align 8, !tbaa !5
  %616 = load i32, ptr %7, align 4, !tbaa !9
  %617 = call i32 @inflate_flush(ptr noundef %614, ptr noundef %615, i32 noundef %616)
  store i32 %617, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

618:                                              ; preds = %65
  %619 = load ptr, ptr %18, align 8, !tbaa !5
  %620 = getelementptr inbounds %struct.inflate_codes_state, ptr %619, i32 0, i32 2
  %621 = getelementptr inbounds %struct.anon.0, ptr %620, i32 0, i32 0
  %622 = load i32, ptr %621, align 8, !tbaa !11
  store i32 %622, ptr %8, align 4, !tbaa !9
  br label %623

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

627:                                              ; preds = %623
  %628 = load i32, ptr %14, 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 %11, align 8, !tbaa !18
  %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 !16
  %635 = load i32, ptr %12, 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 !19
  %638 = load i32, ptr %14, 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 !15
  %641 = load ptr, ptr %13, 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 !12
  %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 !25
  %651 = add i64 %650, %647
  store i64 %651, ptr %649, align 8, !tbaa !25
  %652 = load ptr, ptr %13, 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 !12
  %655 = load ptr, ptr %15, 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 !20
  %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 %19, align 4
  br label %1274

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

676:                                              ; preds = %623
  %677 = load i64, ptr %11, align 8, !tbaa !18
  %678 = trunc i64 %677 to i32
  %679 = load i32, ptr %8, align 4, !tbaa !9
  %680 = zext i32 %679 to i64
  %681 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %680
  %682 = load i32, ptr %681, align 4, !tbaa !9
  %683 = and i32 %678, %682
  %684 = load ptr, ptr %18, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.inflate_codes_state, ptr %684, i32 0, i32 2
  %686 = getelementptr inbounds %struct.anon.0, ptr %685, i32 0, i32 1
  %687 = load i32, ptr %686, align 4, !tbaa !11
  %688 = add i32 %687, %683
  store i32 %688, ptr %686, align 4, !tbaa !11
  %689 = load i32, ptr %8, align 4, !tbaa !9
  %690 = load i64, ptr %11, align 8, !tbaa !18
  %691 = zext i32 %689 to i64
  %692 = lshr i64 %690, %691
  store i64 %692, ptr %11, align 8, !tbaa !18
  %693 = load i32, ptr %8, align 4, !tbaa !9
  %694 = load i32, ptr %12, align 4, !tbaa !9
  %695 = sub i32 %694, %693
  store i32 %695, ptr %12, align 4, !tbaa !9
  %696 = load ptr, ptr %18, align 8, !tbaa !5
  %697 = getelementptr inbounds %struct.inflate_codes_state, ptr %696, i32 0, i32 0
  store i32 5, ptr %697, align 8, !tbaa !23
  br label %698

698:                                              ; preds = %676, %65
  %699 = load ptr, ptr %15, align 8, !tbaa !5
  %700 = load ptr, ptr %18, align 8, !tbaa !5
  %701 = getelementptr inbounds %struct.inflate_codes_state, ptr %700, i32 0, i32 2
  %702 = getelementptr inbounds %struct.anon.0, ptr %701, i32 0, i32 1
  %703 = load i32, ptr %702, align 4, !tbaa !11
  %704 = zext i32 %703 to i64
  %705 = sub i64 0, %704
  %706 = getelementptr inbounds i8, ptr %699, i64 %705
  store ptr %706, ptr %17, align 8, !tbaa !5
  br label %707

707:                                              ; preds = %713, %698
  %708 = load ptr, ptr %17, align 8, !tbaa !5
  %709 = load ptr, ptr %5, align 8, !tbaa !5
  %710 = getelementptr inbounds %struct.inflate_blocks_state, ptr %709, i32 0, i32 6
  %711 = load ptr, ptr %710, align 8, !tbaa !39
  %712 = icmp ult ptr %708, %711
  br i1 %712, label %713, label %725

713:                                              ; preds = %707
  %714 = load ptr, ptr %5, align 8, !tbaa !5
  %715 = getelementptr inbounds %struct.inflate_blocks_state, ptr %714, i32 0, i32 7
  %716 = load ptr, ptr %715, align 8, !tbaa !22
  %717 = load ptr, ptr %5, align 8, !tbaa !5
  %718 = getelementptr inbounds %struct.inflate_blocks_state, ptr %717, i32 0, i32 6
  %719 = load ptr, ptr %718, align 8, !tbaa !39
  %720 = ptrtoint ptr %716 to i64
  %721 = ptrtoint ptr %719 to i64
  %722 = sub i64 %720, %721
  %723 = load ptr, ptr %17, align 8, !tbaa !5
  %724 = getelementptr inbounds i8, ptr %723, i64 %722
  store ptr %724, ptr %17, align 8, !tbaa !5
  br label %707, !llvm.loop !40

725:                                              ; preds = %707
  br label %726

726:                                              ; preds = %911, %725
  %727 = load ptr, ptr %18, align 8, !tbaa !5
  %728 = getelementptr inbounds %struct.inflate_codes_state, ptr %727, i32 0, i32 1
  %729 = load i32, ptr %728, align 4, !tbaa !34
  %730 = icmp ne i32 %729, 0
  br i1 %730, label %731, label %916

731:                                              ; preds = %726
  %732 = load i32, ptr %16, align 4, !tbaa !9
  %733 = icmp eq i32 %732, 0
  br i1 %733, label %734, label %894

734:                                              ; preds = %731
  %735 = load ptr, ptr %15, align 8, !tbaa !5
  %736 = load ptr, ptr %5, align 8, !tbaa !5
  %737 = getelementptr inbounds %struct.inflate_blocks_state, ptr %736, i32 0, i32 7
  %738 = load ptr, ptr %737, align 8, !tbaa !22
  %739 = icmp eq ptr %735, %738
  br i1 %739, label %740, label %777

740:                                              ; preds = %734
  %741 = load ptr, ptr %5, align 8, !tbaa !5
  %742 = getelementptr inbounds %struct.inflate_blocks_state, ptr %741, i32 0, i32 8
  %743 = load ptr, ptr %742, align 8, !tbaa !21
  %744 = load ptr, ptr %5, align 8, !tbaa !5
  %745 = getelementptr inbounds %struct.inflate_blocks_state, ptr %744, i32 0, i32 6
  %746 = load ptr, ptr %745, align 8, !tbaa !39
  %747 = icmp ne ptr %743, %746
  br i1 %747, label %748, label %777

748:                                              ; preds = %740
  %749 = load ptr, ptr %5, align 8, !tbaa !5
  %750 = getelementptr inbounds %struct.inflate_blocks_state, ptr %749, i32 0, i32 6
  %751 = load ptr, ptr %750, align 8, !tbaa !39
  store ptr %751, ptr %15, align 8, !tbaa !5
  %752 = load ptr, ptr %15, align 8, !tbaa !5
  %753 = load ptr, ptr %5, align 8, !tbaa !5
  %754 = getelementptr inbounds %struct.inflate_blocks_state, ptr %753, i32 0, i32 8
  %755 = load ptr, ptr %754, align 8, !tbaa !21
  %756 = icmp ult ptr %752, %755
  br i1 %756, label %757, label %766

757:                                              ; preds = %748
  %758 = load ptr, ptr %5, align 8, !tbaa !5
  %759 = getelementptr inbounds %struct.inflate_blocks_state, ptr %758, i32 0, i32 8
  %760 = load ptr, ptr %759, align 8, !tbaa !21
  %761 = load ptr, ptr %15, align 8, !tbaa !5
  %762 = ptrtoint ptr %760 to i64
  %763 = ptrtoint ptr %761 to i64
  %764 = sub i64 %762, %763
  %765 = sub nsw i64 %764, 1
  br label %774

766:                                              ; preds = %748
  %767 = load ptr, ptr %5, align 8, !tbaa !5
  %768 = getelementptr inbounds %struct.inflate_blocks_state, ptr %767, i32 0, i32 7
  %769 = load ptr, ptr %768, align 8, !tbaa !22
  %770 = load ptr, ptr %15, align 8, !tbaa !5
  %771 = ptrtoint ptr %769 to i64
  %772 = ptrtoint ptr %770 to i64
  %773 = sub i64 %771, %772
  br label %774

774:                                              ; preds = %766, %757
  %775 = phi i64 [ %765, %757 ], [ %773, %766 ]
  %776 = trunc i64 %775 to i32
  store i32 %776, ptr %16, align 4, !tbaa !9
  br label %777

777:                                              ; preds = %774, %740, %734
  %778 = load i32, ptr %16, align 4, !tbaa !9
  %779 = icmp eq i32 %778, 0
  br i1 %779, label %780, label %893

780:                                              ; preds = %777
  %781 = load ptr, ptr %15, align 8, !tbaa !5
  %782 = load ptr, ptr %5, align 8, !tbaa !5
  %783 = getelementptr inbounds %struct.inflate_blocks_state, ptr %782, i32 0, i32 9
  store ptr %781, ptr %783, align 8, !tbaa !20
  %784 = load ptr, ptr %5, align 8, !tbaa !5
  %785 = load ptr, ptr %6, align 8, !tbaa !5
  %786 = load i32, ptr %7, align 4, !tbaa !9
  %787 = call i32 @inflate_flush(ptr noundef %784, ptr noundef %785, i32 noundef %786)
  store i32 %787, ptr %7, align 4, !tbaa !9
  %788 = load ptr, ptr %5, align 8, !tbaa !5
  %789 = getelementptr inbounds %struct.inflate_blocks_state, ptr %788, i32 0, i32 9
  %790 = load ptr, ptr %789, align 8, !tbaa !20
  store ptr %790, ptr %15, align 8, !tbaa !5
  %791 = load ptr, ptr %15, align 8, !tbaa !5
  %792 = load ptr, ptr %5, align 8, !tbaa !5
  %793 = getelementptr inbounds %struct.inflate_blocks_state, ptr %792, i32 0, i32 8
  %794 = load ptr, ptr %793, align 8, !tbaa !21
  %795 = icmp ult ptr %791, %794
  br i1 %795, label %796, label %805

796:                                              ; preds = %780
  %797 = load ptr, ptr %5, align 8, !tbaa !5
  %798 = getelementptr inbounds %struct.inflate_blocks_state, ptr %797, i32 0, i32 8
  %799 = load ptr, ptr %798, align 8, !tbaa !21
  %800 = load ptr, ptr %15, align 8, !tbaa !5
  %801 = ptrtoint ptr %799 to i64
  %802 = ptrtoint ptr %800 to i64
  %803 = sub i64 %801, %802
  %804 = sub nsw i64 %803, 1
  br label %813

805:                                              ; preds = %780
  %806 = load ptr, ptr %5, align 8, !tbaa !5
  %807 = getelementptr inbounds %struct.inflate_blocks_state, ptr %806, i32 0, i32 7
  %808 = load ptr, ptr %807, align 8, !tbaa !22
  %809 = load ptr, ptr %15, align 8, !tbaa !5
  %810 = ptrtoint ptr %808 to i64
  %811 = ptrtoint ptr %809 to i64
  %812 = sub i64 %810, %811
  br label %813

813:                                              ; preds = %805, %796
  %814 = phi i64 [ %804, %796 ], [ %812, %805 ]
  %815 = trunc i64 %814 to i32
  store i32 %815, ptr %16, align 4, !tbaa !9
  %816 = load ptr, ptr %15, align 8, !tbaa !5
  %817 = load ptr, ptr %5, align 8, !tbaa !5
  %818 = getelementptr inbounds %struct.inflate_blocks_state, ptr %817, i32 0, i32 7
  %819 = load ptr, ptr %818, align 8, !tbaa !22
  %820 = icmp eq ptr %816, %819
  br i1 %820, label %821, label %858

821:                                              ; preds = %813
  %822 = load ptr, ptr %5, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.inflate_blocks_state, ptr %822, i32 0, i32 8
  %824 = load ptr, ptr %823, align 8, !tbaa !21
  %825 = load ptr, ptr %5, align 8, !tbaa !5
  %826 = getelementptr inbounds %struct.inflate_blocks_state, ptr %825, i32 0, i32 6
  %827 = load ptr, ptr %826, align 8, !tbaa !39
  %828 = icmp ne ptr %824, %827
  br i1 %828, label %829, label %858

829:                                              ; preds = %821
  %830 = load ptr, ptr %5, align 8, !tbaa !5
  %831 = getelementptr inbounds %struct.inflate_blocks_state, ptr %830, i32 0, i32 6
  %832 = load ptr, ptr %831, align 8, !tbaa !39
  store ptr %832, ptr %15, align 8, !tbaa !5
  %833 = load ptr, ptr %15, align 8, !tbaa !5
  %834 = load ptr, ptr %5, align 8, !tbaa !5
  %835 = getelementptr inbounds %struct.inflate_blocks_state, ptr %834, i32 0, i32 8
  %836 = load ptr, ptr %835, align 8, !tbaa !21
  %837 = icmp ult ptr %833, %836
  br i1 %837, label %838, label %847

838:                                              ; preds = %829
  %839 = load ptr, ptr %5, align 8, !tbaa !5
  %840 = getelementptr inbounds %struct.inflate_blocks_state, ptr %839, i32 0, i32 8
  %841 = load ptr, ptr %840, align 8, !tbaa !21
  %842 = load ptr, ptr %15, align 8, !tbaa !5
  %843 = ptrtoint ptr %841 to i64
  %844 = ptrtoint ptr %842 to i64
  %845 = sub i64 %843, %844
  %846 = sub nsw i64 %845, 1
  br label %855

847:                                              ; preds = %829
  %848 = load ptr, ptr %5, align 8, !tbaa !5
  %849 = getelementptr inbounds %struct.inflate_blocks_state, ptr %848, i32 0, i32 7
  %850 = load ptr, ptr %849, align 8, !tbaa !22
  %851 = load ptr, ptr %15, align 8, !tbaa !5
  %852 = ptrtoint ptr %850 to i64
  %853 = ptrtoint ptr %851 to i64
  %854 = sub i64 %852, %853
  br label %855

855:                                              ; preds = %847, %838
  %856 = phi i64 [ %846, %838 ], [ %854, %847 ]
  %857 = trunc i64 %856 to i32
  store i32 %857, ptr %16, align 4, !tbaa !9
  br label %858

858:                                              ; preds = %855, %821, %813
  %859 = load i32, ptr %16, align 4, !tbaa !9
  %860 = icmp eq i32 %859, 0
  br i1 %860, label %861, label %892

861:                                              ; preds = %858
  %862 = load i64, ptr %11, align 8, !tbaa !18
  %863 = load ptr, ptr %5, align 8, !tbaa !5
  %864 = getelementptr inbounds %struct.inflate_blocks_state, ptr %863, i32 0, i32 4
  store i64 %862, ptr %864, align 8, !tbaa !16
  %865 = load i32, ptr %12, align 4, !tbaa !9
  %866 = load ptr, ptr %5, align 8, !tbaa !5
  %867 = getelementptr inbounds %struct.inflate_blocks_state, ptr %866, i32 0, i32 3
  store i32 %865, ptr %867, align 4, !tbaa !19
  %868 = load i32, ptr %14, align 4, !tbaa !9
  %869 = load ptr, ptr %6, align 8, !tbaa !5
  %870 = getelementptr inbounds %struct.z_stream_s, ptr %869, i32 0, i32 1
  store i32 %868, ptr %870, align 8, !tbaa !15
  %871 = load ptr, ptr %13, align 8, !tbaa !5
  %872 = load ptr, ptr %6, align 8, !tbaa !5
  %873 = getelementptr inbounds %struct.z_stream_s, ptr %872, i32 0, i32 0
  %874 = load ptr, ptr %873, align 8, !tbaa !12
  %875 = ptrtoint ptr %871 to i64
  %876 = ptrtoint ptr %874 to i64
  %877 = sub i64 %875, %876
  %878 = load ptr, ptr %6, align 8, !tbaa !5
  %879 = getelementptr inbounds %struct.z_stream_s, ptr %878, i32 0, i32 2
  %880 = load i64, ptr %879, align 8, !tbaa !25
  %881 = add i64 %880, %877
  store i64 %881, ptr %879, align 8, !tbaa !25
  %882 = load ptr, ptr %13, align 8, !tbaa !5
  %883 = load ptr, ptr %6, align 8, !tbaa !5
  %884 = getelementptr inbounds %struct.z_stream_s, ptr %883, i32 0, i32 0
  store ptr %882, ptr %884, align 8, !tbaa !12
  %885 = load ptr, ptr %15, align 8, !tbaa !5
  %886 = load ptr, ptr %5, align 8, !tbaa !5
  %887 = getelementptr inbounds %struct.inflate_blocks_state, ptr %886, i32 0, i32 9
  store ptr %885, ptr %887, align 8, !tbaa !20
  %888 = load ptr, ptr %5, align 8, !tbaa !5
  %889 = load ptr, ptr %6, align 8, !tbaa !5
  %890 = load i32, ptr %7, align 4, !tbaa !9
  %891 = call i32 @inflate_flush(ptr noundef %888, ptr noundef %889, i32 noundef %890)
  store i32 %891, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

892:                                              ; preds = %858
  br label %893

893:                                              ; preds = %892, %777
  br label %894

894:                                              ; preds = %893, %731
  store i32 0, ptr %7, align 4, !tbaa !9
  %895 = load ptr, ptr %17, align 8, !tbaa !5
  %896 = getelementptr inbounds i8, ptr %895, i32 1
  store ptr %896, ptr %17, align 8, !tbaa !5
  %897 = load i8, ptr %895, align 1, !tbaa !11
  %898 = load ptr, ptr %15, align 8, !tbaa !5
  %899 = getelementptr inbounds i8, ptr %898, i32 1
  store ptr %899, ptr %15, align 8, !tbaa !5
  store i8 %897, ptr %898, align 1, !tbaa !11
  %900 = load i32, ptr %16, align 4, !tbaa !9
  %901 = add i32 %900, -1
  store i32 %901, ptr %16, align 4, !tbaa !9
  %902 = load ptr, ptr %17, align 8, !tbaa !5
  %903 = load ptr, ptr %5, align 8, !tbaa !5
  %904 = getelementptr inbounds %struct.inflate_blocks_state, ptr %903, i32 0, i32 7
  %905 = load ptr, ptr %904, align 8, !tbaa !22
  %906 = icmp eq ptr %902, %905
  br i1 %906, label %907, label %911

907:                                              ; preds = %894
  %908 = load ptr, ptr %5, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.inflate_blocks_state, ptr %908, i32 0, i32 6
  %910 = load ptr, ptr %909, align 8, !tbaa !39
  store ptr %910, ptr %17, align 8, !tbaa !5
  br label %911

911:                                              ; preds = %907, %894
  %912 = load ptr, ptr %18, align 8, !tbaa !5
  %913 = getelementptr inbounds %struct.inflate_codes_state, ptr %912, i32 0, i32 1
  %914 = load i32, ptr %913, align 4, !tbaa !34
  %915 = add i32 %914, -1
  store i32 %915, ptr %913, align 4, !tbaa !34
  br label %726, !llvm.loop !41

916:                                              ; preds = %726
  %917 = load ptr, ptr %18, align 8, !tbaa !5
  %918 = getelementptr inbounds %struct.inflate_codes_state, ptr %917, i32 0, i32 0
  store i32 0, ptr %918, align 8, !tbaa !23
  br label %1273

919:                                              ; preds = %65
  %920 = load i32, ptr %16, align 4, !tbaa !9
  %921 = icmp eq i32 %920, 0
  br i1 %921, label %922, label %1082

922:                                              ; preds = %919
  %923 = load ptr, ptr %15, align 8, !tbaa !5
  %924 = load ptr, ptr %5, align 8, !tbaa !5
  %925 = getelementptr inbounds %struct.inflate_blocks_state, ptr %924, i32 0, i32 7
  %926 = load ptr, ptr %925, align 8, !tbaa !22
  %927 = icmp eq ptr %923, %926
  br i1 %927, label %928, label %965

928:                                              ; preds = %922
  %929 = load ptr, ptr %5, align 8, !tbaa !5
  %930 = getelementptr inbounds %struct.inflate_blocks_state, ptr %929, i32 0, i32 8
  %931 = load ptr, ptr %930, align 8, !tbaa !21
  %932 = load ptr, ptr %5, align 8, !tbaa !5
  %933 = getelementptr inbounds %struct.inflate_blocks_state, ptr %932, i32 0, i32 6
  %934 = load ptr, ptr %933, align 8, !tbaa !39
  %935 = icmp ne ptr %931, %934
  br i1 %935, label %936, label %965

936:                                              ; preds = %928
  %937 = load ptr, ptr %5, align 8, !tbaa !5
  %938 = getelementptr inbounds %struct.inflate_blocks_state, ptr %937, i32 0, i32 6
  %939 = load ptr, ptr %938, align 8, !tbaa !39
  store ptr %939, ptr %15, align 8, !tbaa !5
  %940 = load ptr, ptr %15, align 8, !tbaa !5
  %941 = load ptr, ptr %5, align 8, !tbaa !5
  %942 = getelementptr inbounds %struct.inflate_blocks_state, ptr %941, i32 0, i32 8
  %943 = load ptr, ptr %942, align 8, !tbaa !21
  %944 = icmp ult ptr %940, %943
  br i1 %944, label %945, label %954

945:                                              ; preds = %936
  %946 = load ptr, ptr %5, align 8, !tbaa !5
  %947 = getelementptr inbounds %struct.inflate_blocks_state, ptr %946, i32 0, i32 8
  %948 = load ptr, ptr %947, align 8, !tbaa !21
  %949 = load ptr, ptr %15, align 8, !tbaa !5
  %950 = ptrtoint ptr %948 to i64
  %951 = ptrtoint ptr %949 to i64
  %952 = sub i64 %950, %951
  %953 = sub nsw i64 %952, 1
  br label %962

954:                                              ; preds = %936
  %955 = load ptr, ptr %5, align 8, !tbaa !5
  %956 = getelementptr inbounds %struct.inflate_blocks_state, ptr %955, i32 0, i32 7
  %957 = load ptr, ptr %956, align 8, !tbaa !22
  %958 = load ptr, ptr %15, align 8, !tbaa !5
  %959 = ptrtoint ptr %957 to i64
  %960 = ptrtoint ptr %958 to i64
  %961 = sub i64 %959, %960
  br label %962

962:                                              ; preds = %954, %945
  %963 = phi i64 [ %953, %945 ], [ %961, %954 ]
  %964 = trunc i64 %963 to i32
  store i32 %964, ptr %16, align 4, !tbaa !9
  br label %965

965:                                              ; preds = %962, %928, %922
  %966 = load i32, ptr %16, align 4, !tbaa !9
  %967 = icmp eq i32 %966, 0
  br i1 %967, label %968, label %1081

968:                                              ; preds = %965
  %969 = load ptr, ptr %15, align 8, !tbaa !5
  %970 = load ptr, ptr %5, align 8, !tbaa !5
  %971 = getelementptr inbounds %struct.inflate_blocks_state, ptr %970, i32 0, i32 9
  store ptr %969, ptr %971, align 8, !tbaa !20
  %972 = load ptr, ptr %5, align 8, !tbaa !5
  %973 = load ptr, ptr %6, align 8, !tbaa !5
  %974 = load i32, ptr %7, align 4, !tbaa !9
  %975 = call i32 @inflate_flush(ptr noundef %972, ptr noundef %973, i32 noundef %974)
  store i32 %975, ptr %7, align 4, !tbaa !9
  %976 = load ptr, ptr %5, align 8, !tbaa !5
  %977 = getelementptr inbounds %struct.inflate_blocks_state, ptr %976, i32 0, i32 9
  %978 = load ptr, ptr %977, align 8, !tbaa !20
  store ptr %978, ptr %15, align 8, !tbaa !5
  %979 = load ptr, ptr %15, align 8, !tbaa !5
  %980 = load ptr, ptr %5, align 8, !tbaa !5
  %981 = getelementptr inbounds %struct.inflate_blocks_state, ptr %980, i32 0, i32 8
  %982 = load ptr, ptr %981, align 8, !tbaa !21
  %983 = icmp ult ptr %979, %982
  br i1 %983, label %984, label %993

984:                                              ; preds = %968
  %985 = load ptr, ptr %5, align 8, !tbaa !5
  %986 = getelementptr inbounds %struct.inflate_blocks_state, ptr %985, i32 0, i32 8
  %987 = load ptr, ptr %986, align 8, !tbaa !21
  %988 = load ptr, ptr %15, align 8, !tbaa !5
  %989 = ptrtoint ptr %987 to i64
  %990 = ptrtoint ptr %988 to i64
  %991 = sub i64 %989, %990
  %992 = sub nsw i64 %991, 1
  br label %1001

993:                                              ; preds = %968
  %994 = load ptr, ptr %5, align 8, !tbaa !5
  %995 = getelementptr inbounds %struct.inflate_blocks_state, ptr %994, i32 0, i32 7
  %996 = load ptr, ptr %995, align 8, !tbaa !22
  %997 = load ptr, ptr %15, align 8, !tbaa !5
  %998 = ptrtoint ptr %996 to i64
  %999 = ptrtoint ptr %997 to i64
  %1000 = sub i64 %998, %999
  br label %1001

1001:                                             ; preds = %993, %984
  %1002 = phi i64 [ %992, %984 ], [ %1000, %993 ]
  %1003 = trunc i64 %1002 to i32
  store i32 %1003, ptr %16, align 4, !tbaa !9
  %1004 = load ptr, ptr %15, align 8, !tbaa !5
  %1005 = load ptr, ptr %5, align 8, !tbaa !5
  %1006 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1005, i32 0, i32 7
  %1007 = load ptr, ptr %1006, align 8, !tbaa !22
  %1008 = icmp eq ptr %1004, %1007
  br i1 %1008, label %1009, label %1046

1009:                                             ; preds = %1001
  %1010 = load ptr, ptr %5, align 8, !tbaa !5
  %1011 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1010, i32 0, i32 8
  %1012 = load ptr, ptr %1011, align 8, !tbaa !21
  %1013 = load ptr, ptr %5, align 8, !tbaa !5
  %1014 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1013, i32 0, i32 6
  %1015 = load ptr, ptr %1014, align 8, !tbaa !39
  %1016 = icmp ne ptr %1012, %1015
  br i1 %1016, label %1017, label %1046

1017:                                             ; preds = %1009
  %1018 = load ptr, ptr %5, align 8, !tbaa !5
  %1019 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1018, i32 0, i32 6
  %1020 = load ptr, ptr %1019, align 8, !tbaa !39
  store ptr %1020, ptr %15, align 8, !tbaa !5
  %1021 = load ptr, ptr %15, align 8, !tbaa !5
  %1022 = load ptr, ptr %5, align 8, !tbaa !5
  %1023 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1022, i32 0, i32 8
  %1024 = load ptr, ptr %1023, align 8, !tbaa !21
  %1025 = icmp ult ptr %1021, %1024
  br i1 %1025, label %1026, label %1035

1026:                                             ; preds = %1017
  %1027 = load ptr, ptr %5, align 8, !tbaa !5
  %1028 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1027, i32 0, i32 8
  %1029 = load ptr, ptr %1028, align 8, !tbaa !21
  %1030 = load ptr, ptr %15, align 8, !tbaa !5
  %1031 = ptrtoint ptr %1029 to i64
  %1032 = ptrtoint ptr %1030 to i64
  %1033 = sub i64 %1031, %1032
  %1034 = sub nsw i64 %1033, 1
  br label %1043

1035:                                             ; preds = %1017
  %1036 = load ptr, ptr %5, align 8, !tbaa !5
  %1037 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1036, i32 0, i32 7
  %1038 = load ptr, ptr %1037, align 8, !tbaa !22
  %1039 = load ptr, ptr %15, align 8, !tbaa !5
  %1040 = ptrtoint ptr %1038 to i64
  %1041 = ptrtoint ptr %1039 to i64
  %1042 = sub i64 %1040, %1041
  br label %1043

1043:                                             ; preds = %1035, %1026
  %1044 = phi i64 [ %1034, %1026 ], [ %1042, %1035 ]
  %1045 = trunc i64 %1044 to i32
  store i32 %1045, ptr %16, align 4, !tbaa !9
  br label %1046

1046:                                             ; preds = %1043, %1009, %1001
  %1047 = load i32, ptr %16, align 4, !tbaa !9
  %1048 = icmp eq i32 %1047, 0
  br i1 %1048, label %1049, label %1080

1049:                                             ; preds = %1046
  %1050 = load i64, ptr %11, align 8, !tbaa !18
  %1051 = load ptr, ptr %5, align 8, !tbaa !5
  %1052 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1051, i32 0, i32 4
  store i64 %1050, ptr %1052, align 8, !tbaa !16
  %1053 = load i32, ptr %12, align 4, !tbaa !9
  %1054 = load ptr, ptr %5, align 8, !tbaa !5
  %1055 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1054, i32 0, i32 3
  store i32 %1053, ptr %1055, align 4, !tbaa !19
  %1056 = load i32, ptr %14, align 4, !tbaa !9
  %1057 = load ptr, ptr %6, align 8, !tbaa !5
  %1058 = getelementptr inbounds %struct.z_stream_s, ptr %1057, i32 0, i32 1
  store i32 %1056, ptr %1058, align 8, !tbaa !15
  %1059 = load ptr, ptr %13, align 8, !tbaa !5
  %1060 = load ptr, ptr %6, align 8, !tbaa !5
  %1061 = getelementptr inbounds %struct.z_stream_s, ptr %1060, i32 0, i32 0
  %1062 = load ptr, ptr %1061, align 8, !tbaa !12
  %1063 = ptrtoint ptr %1059 to i64
  %1064 = ptrtoint ptr %1062 to i64
  %1065 = sub i64 %1063, %1064
  %1066 = load ptr, ptr %6, align 8, !tbaa !5
  %1067 = getelementptr inbounds %struct.z_stream_s, ptr %1066, i32 0, i32 2
  %1068 = load i64, ptr %1067, align 8, !tbaa !25
  %1069 = add i64 %1068, %1065
  store i64 %1069, ptr %1067, align 8, !tbaa !25
  %1070 = load ptr, ptr %13, align 8, !tbaa !5
  %1071 = load ptr, ptr %6, align 8, !tbaa !5
  %1072 = getelementptr inbounds %struct.z_stream_s, ptr %1071, i32 0, i32 0
  store ptr %1070, ptr %1072, align 8, !tbaa !12
  %1073 = load ptr, ptr %15, align 8, !tbaa !5
  %1074 = load ptr, ptr %5, align 8, !tbaa !5
  %1075 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1074, i32 0, i32 9
  store ptr %1073, ptr %1075, align 8, !tbaa !20
  %1076 = load ptr, ptr %5, align 8, !tbaa !5
  %1077 = load ptr, ptr %6, align 8, !tbaa !5
  %1078 = load i32, ptr %7, align 4, !tbaa !9
  %1079 = call i32 @inflate_flush(ptr noundef %1076, ptr noundef %1077, i32 noundef %1078)
  store i32 %1079, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

1080:                                             ; preds = %1046
  br label %1081

1081:                                             ; preds = %1080, %965
  br label %1082

1082:                                             ; preds = %1081, %919
  store i32 0, ptr %7, align 4, !tbaa !9
  %1083 = load ptr, ptr %18, align 8, !tbaa !5
  %1084 = getelementptr inbounds %struct.inflate_codes_state, ptr %1083, i32 0, i32 2
  %1085 = load i32, ptr %1084, align 8, !tbaa !11
  %1086 = trunc i32 %1085 to i8
  %1087 = load ptr, ptr %15, align 8, !tbaa !5
  %1088 = getelementptr inbounds i8, ptr %1087, i32 1
  store ptr %1088, ptr %15, align 8, !tbaa !5
  store i8 %1086, ptr %1087, align 1, !tbaa !11
  %1089 = load i32, ptr %16, align 4, !tbaa !9
  %1090 = add i32 %1089, -1
  store i32 %1090, ptr %16, align 4, !tbaa !9
  %1091 = load ptr, ptr %18, align 8, !tbaa !5
  %1092 = getelementptr inbounds %struct.inflate_codes_state, ptr %1091, i32 0, i32 0
  store i32 0, ptr %1092, align 8, !tbaa !23
  br label %1273

1093:                                             ; preds = %65
  %1094 = load i32, ptr %12, align 4, !tbaa !9
  %1095 = icmp ugt i32 %1094, 7
  br i1 %1095, label %1096, label %1103

1096:                                             ; preds = %1093
  %1097 = load i32, ptr %12, align 4, !tbaa !9
  %1098 = sub i32 %1097, 8
  store i32 %1098, ptr %12, align 4, !tbaa !9
  %1099 = load i32, ptr %14, align 4, !tbaa !9
  %1100 = add i32 %1099, 1
  store i32 %1100, ptr %14, align 4, !tbaa !9
  %1101 = load ptr, ptr %13, align 8, !tbaa !5
  %1102 = getelementptr inbounds i8, ptr %1101, i32 -1
  store ptr %1102, ptr %13, align 8, !tbaa !5
  br label %1103

1103:                                             ; preds = %1096, %1093
  %1104 = load ptr, ptr %15, align 8, !tbaa !5
  %1105 = load ptr, ptr %5, align 8, !tbaa !5
  %1106 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1105, i32 0, i32 9
  store ptr %1104, ptr %1106, align 8, !tbaa !20
  %1107 = load ptr, ptr %5, align 8, !tbaa !5
  %1108 = load ptr, ptr %6, align 8, !tbaa !5
  %1109 = load i32, ptr %7, align 4, !tbaa !9
  %1110 = call i32 @inflate_flush(ptr noundef %1107, ptr noundef %1108, i32 noundef %1109)
  store i32 %1110, ptr %7, align 4, !tbaa !9
  %1111 = load ptr, ptr %5, align 8, !tbaa !5
  %1112 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1111, i32 0, i32 9
  %1113 = load ptr, ptr %1112, align 8, !tbaa !20
  store ptr %1113, ptr %15, align 8, !tbaa !5
  %1114 = load ptr, ptr %15, align 8, !tbaa !5
  %1115 = load ptr, ptr %5, align 8, !tbaa !5
  %1116 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1115, i32 0, i32 8
  %1117 = load ptr, ptr %1116, align 8, !tbaa !21
  %1118 = icmp ult ptr %1114, %1117
  br i1 %1118, label %1119, label %1128

1119:                                             ; preds = %1103
  %1120 = load ptr, ptr %5, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1120, i32 0, i32 8
  %1122 = load ptr, ptr %1121, align 8, !tbaa !21
  %1123 = load ptr, ptr %15, align 8, !tbaa !5
  %1124 = ptrtoint ptr %1122 to i64
  %1125 = ptrtoint ptr %1123 to i64
  %1126 = sub i64 %1124, %1125
  %1127 = sub nsw i64 %1126, 1
  br label %1136

1128:                                             ; preds = %1103
  %1129 = load ptr, ptr %5, align 8, !tbaa !5
  %1130 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1129, i32 0, i32 7
  %1131 = load ptr, ptr %1130, align 8, !tbaa !22
  %1132 = load ptr, ptr %15, align 8, !tbaa !5
  %1133 = ptrtoint ptr %1131 to i64
  %1134 = ptrtoint ptr %1132 to i64
  %1135 = sub i64 %1133, %1134
  br label %1136

1136:                                             ; preds = %1128, %1119
  %1137 = phi i64 [ %1127, %1119 ], [ %1135, %1128 ]
  %1138 = trunc i64 %1137 to i32
  store i32 %1138, ptr %16, align 4, !tbaa !9
  %1139 = load ptr, ptr %5, align 8, !tbaa !5
  %1140 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1139, i32 0, i32 8
  %1141 = load ptr, ptr %1140, align 8, !tbaa !21
  %1142 = load ptr, ptr %5, align 8, !tbaa !5
  %1143 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1142, i32 0, i32 9
  %1144 = load ptr, ptr %1143, align 8, !tbaa !20
  %1145 = icmp ne ptr %1141, %1144
  br i1 %1145, label %1146, label %1177

1146:                                             ; preds = %1136
  %1147 = load i64, ptr %11, align 8, !tbaa !18
  %1148 = load ptr, ptr %5, align 8, !tbaa !5
  %1149 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1148, i32 0, i32 4
  store i64 %1147, ptr %1149, align 8, !tbaa !16
  %1150 = load i32, ptr %12, align 4, !tbaa !9
  %1151 = load ptr, ptr %5, align 8, !tbaa !5
  %1152 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1151, i32 0, i32 3
  store i32 %1150, ptr %1152, align 4, !tbaa !19
  %1153 = load i32, ptr %14, align 4, !tbaa !9
  %1154 = load ptr, ptr %6, align 8, !tbaa !5
  %1155 = getelementptr inbounds %struct.z_stream_s, ptr %1154, i32 0, i32 1
  store i32 %1153, ptr %1155, align 8, !tbaa !15
  %1156 = load ptr, ptr %13, align 8, !tbaa !5
  %1157 = load ptr, ptr %6, align 8, !tbaa !5
  %1158 = getelementptr inbounds %struct.z_stream_s, ptr %1157, i32 0, i32 0
  %1159 = load ptr, ptr %1158, align 8, !tbaa !12
  %1160 = ptrtoint ptr %1156 to i64
  %1161 = ptrtoint ptr %1159 to i64
  %1162 = sub i64 %1160, %1161
  %1163 = load ptr, ptr %6, align 8, !tbaa !5
  %1164 = getelementptr inbounds %struct.z_stream_s, ptr %1163, i32 0, i32 2
  %1165 = load i64, ptr %1164, align 8, !tbaa !25
  %1166 = add i64 %1165, %1162
  store i64 %1166, ptr %1164, align 8, !tbaa !25
  %1167 = load ptr, ptr %13, align 8, !tbaa !5
  %1168 = load ptr, ptr %6, align 8, !tbaa !5
  %1169 = getelementptr inbounds %struct.z_stream_s, ptr %1168, i32 0, i32 0
  store ptr %1167, ptr %1169, align 8, !tbaa !12
  %1170 = load ptr, ptr %15, align 8, !tbaa !5
  %1171 = load ptr, ptr %5, align 8, !tbaa !5
  %1172 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1171, i32 0, i32 9
  store ptr %1170, ptr %1172, align 8, !tbaa !20
  %1173 = load ptr, ptr %5, align 8, !tbaa !5
  %1174 = load ptr, ptr %6, align 8, !tbaa !5
  %1175 = load i32, ptr %7, align 4, !tbaa !9
  %1176 = call i32 @inflate_flush(ptr noundef %1173, ptr noundef %1174, i32 noundef %1175)
  store i32 %1176, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

1177:                                             ; preds = %1136
  %1178 = load ptr, ptr %18, align 8, !tbaa !5
  %1179 = getelementptr inbounds %struct.inflate_codes_state, ptr %1178, i32 0, i32 0
  store i32 8, ptr %1179, align 8, !tbaa !23
  br label %1180

1180:                                             ; preds = %1177, %65
  store i32 1, ptr %7, align 4, !tbaa !9
  %1181 = load i64, ptr %11, align 8, !tbaa !18
  %1182 = load ptr, ptr %5, align 8, !tbaa !5
  %1183 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1182, i32 0, i32 4
  store i64 %1181, ptr %1183, align 8, !tbaa !16
  %1184 = load i32, ptr %12, align 4, !tbaa !9
  %1185 = load ptr, ptr %5, align 8, !tbaa !5
  %1186 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1185, i32 0, i32 3
  store i32 %1184, ptr %1186, align 4, !tbaa !19
  %1187 = load i32, ptr %14, align 4, !tbaa !9
  %1188 = load ptr, ptr %6, align 8, !tbaa !5
  %1189 = getelementptr inbounds %struct.z_stream_s, ptr %1188, i32 0, i32 1
  store i32 %1187, ptr %1189, align 8, !tbaa !15
  %1190 = load ptr, ptr %13, align 8, !tbaa !5
  %1191 = load ptr, ptr %6, align 8, !tbaa !5
  %1192 = getelementptr inbounds %struct.z_stream_s, ptr %1191, i32 0, i32 0
  %1193 = load ptr, ptr %1192, align 8, !tbaa !12
  %1194 = ptrtoint ptr %1190 to i64
  %1195 = ptrtoint ptr %1193 to i64
  %1196 = sub i64 %1194, %1195
  %1197 = load ptr, ptr %6, align 8, !tbaa !5
  %1198 = getelementptr inbounds %struct.z_stream_s, ptr %1197, i32 0, i32 2
  %1199 = load i64, ptr %1198, align 8, !tbaa !25
  %1200 = add i64 %1199, %1196
  store i64 %1200, ptr %1198, align 8, !tbaa !25
  %1201 = load ptr, ptr %13, align 8, !tbaa !5
  %1202 = load ptr, ptr %6, align 8, !tbaa !5
  %1203 = getelementptr inbounds %struct.z_stream_s, ptr %1202, i32 0, i32 0
  store ptr %1201, ptr %1203, align 8, !tbaa !12
  %1204 = load ptr, ptr %15, align 8, !tbaa !5
  %1205 = load ptr, ptr %5, align 8, !tbaa !5
  %1206 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1205, i32 0, i32 9
  store ptr %1204, ptr %1206, align 8, !tbaa !20
  %1207 = load ptr, ptr %5, align 8, !tbaa !5
  %1208 = load ptr, ptr %6, align 8, !tbaa !5
  %1209 = load i32, ptr %7, align 4, !tbaa !9
  %1210 = call i32 @inflate_flush(ptr noundef %1207, ptr noundef %1208, i32 noundef %1209)
  store i32 %1210, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

1211:                                             ; preds = %65
  store i32 -3, ptr %7, align 4, !tbaa !9
  %1212 = load i64, ptr %11, align 8, !tbaa !18
  %1213 = load ptr, ptr %5, align 8, !tbaa !5
  %1214 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1213, i32 0, i32 4
  store i64 %1212, ptr %1214, align 8, !tbaa !16
  %1215 = load i32, ptr %12, align 4, !tbaa !9
  %1216 = load ptr, ptr %5, align 8, !tbaa !5
  %1217 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1216, i32 0, i32 3
  store i32 %1215, ptr %1217, align 4, !tbaa !19
  %1218 = load i32, ptr %14, align 4, !tbaa !9
  %1219 = load ptr, ptr %6, align 8, !tbaa !5
  %1220 = getelementptr inbounds %struct.z_stream_s, ptr %1219, i32 0, i32 1
  store i32 %1218, ptr %1220, align 8, !tbaa !15
  %1221 = load ptr, ptr %13, align 8, !tbaa !5
  %1222 = load ptr, ptr %6, align 8, !tbaa !5
  %1223 = getelementptr inbounds %struct.z_stream_s, ptr %1222, i32 0, i32 0
  %1224 = load ptr, ptr %1223, align 8, !tbaa !12
  %1225 = ptrtoint ptr %1221 to i64
  %1226 = ptrtoint ptr %1224 to i64
  %1227 = sub i64 %1225, %1226
  %1228 = load ptr, ptr %6, align 8, !tbaa !5
  %1229 = getelementptr inbounds %struct.z_stream_s, ptr %1228, i32 0, i32 2
  %1230 = load i64, ptr %1229, align 8, !tbaa !25
  %1231 = add i64 %1230, %1227
  store i64 %1231, ptr %1229, align 8, !tbaa !25
  %1232 = load ptr, ptr %13, align 8, !tbaa !5
  %1233 = load ptr, ptr %6, align 8, !tbaa !5
  %1234 = getelementptr inbounds %struct.z_stream_s, ptr %1233, i32 0, i32 0
  store ptr %1232, ptr %1234, align 8, !tbaa !12
  %1235 = load ptr, ptr %15, align 8, !tbaa !5
  %1236 = load ptr, ptr %5, align 8, !tbaa !5
  %1237 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1236, i32 0, i32 9
  store ptr %1235, ptr %1237, align 8, !tbaa !20
  %1238 = load ptr, ptr %5, align 8, !tbaa !5
  %1239 = load ptr, ptr %6, align 8, !tbaa !5
  %1240 = load i32, ptr %7, align 4, !tbaa !9
  %1241 = call i32 @inflate_flush(ptr noundef %1238, ptr noundef %1239, i32 noundef %1240)
  store i32 %1241, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

1242:                                             ; preds = %65
  store i32 -2, ptr %7, align 4, !tbaa !9
  %1243 = load i64, ptr %11, align 8, !tbaa !18
  %1244 = load ptr, ptr %5, align 8, !tbaa !5
  %1245 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1244, i32 0, i32 4
  store i64 %1243, ptr %1245, align 8, !tbaa !16
  %1246 = load i32, ptr %12, align 4, !tbaa !9
  %1247 = load ptr, ptr %5, align 8, !tbaa !5
  %1248 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1247, i32 0, i32 3
  store i32 %1246, ptr %1248, align 4, !tbaa !19
  %1249 = load i32, ptr %14, align 4, !tbaa !9
  %1250 = load ptr, ptr %6, align 8, !tbaa !5
  %1251 = getelementptr inbounds %struct.z_stream_s, ptr %1250, i32 0, i32 1
  store i32 %1249, ptr %1251, align 8, !tbaa !15
  %1252 = load ptr, ptr %13, align 8, !tbaa !5
  %1253 = load ptr, ptr %6, align 8, !tbaa !5
  %1254 = getelementptr inbounds %struct.z_stream_s, ptr %1253, i32 0, i32 0
  %1255 = load ptr, ptr %1254, align 8, !tbaa !12
  %1256 = ptrtoint ptr %1252 to i64
  %1257 = ptrtoint ptr %1255 to i64
  %1258 = sub i64 %1256, %1257
  %1259 = load ptr, ptr %6, align 8, !tbaa !5
  %1260 = getelementptr inbounds %struct.z_stream_s, ptr %1259, i32 0, i32 2
  %1261 = load i64, ptr %1260, align 8, !tbaa !25
  %1262 = add i64 %1261, %1258
  store i64 %1262, ptr %1260, align 8, !tbaa !25
  %1263 = load ptr, ptr %13, align 8, !tbaa !5
  %1264 = load ptr, ptr %6, align 8, !tbaa !5
  %1265 = getelementptr inbounds %struct.z_stream_s, ptr %1264, i32 0, i32 0
  store ptr %1263, ptr %1265, align 8, !tbaa !12
  %1266 = load ptr, ptr %15, align 8, !tbaa !5
  %1267 = load ptr, ptr %5, align 8, !tbaa !5
  %1268 = getelementptr inbounds %struct.inflate_blocks_state, ptr %1267, i32 0, i32 9
  store ptr %1266, ptr %1268, align 8, !tbaa !20
  %1269 = load ptr, ptr %5, align 8, !tbaa !5
  %1270 = load ptr, ptr %6, align 8, !tbaa !5
  %1271 = load i32, ptr %7, align 4, !tbaa !9
  %1272 = call i32 @inflate_flush(ptr noundef %1269, ptr noundef %1270, i32 noundef %1271)
  store i32 %1272, ptr %4, align 4
  store i32 1, ptr %19, align 4
  br label %1274

1273:                                             ; preds = %1082, %916, %569, %551, %326, %308, %291, %279, %161
  br label %64

1274:                                             ; preds = %1242, %1211, %1180, %1146, %1049, %861, %631, %583, %469, %377, %329, %198
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #3
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #3
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #3
  %1275 = load i32, ptr %4, align 4
  ret i32 %1275
}

declare i32 @inflate_fast(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #2

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

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

!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 = !{!7, !7, i64 0}
!12 = !{!13, !6, i64 0}
!13 = !{!"z_stream_s", !6, i64 0, !10, i64 8, !14, i64 16, !6, i64 24, !10, i64 32, !14, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !10, i64 88, !14, i64 96, !14, i64 104}
!14 = !{!"long", !7, i64 0}
!15 = !{!13, !10, i64 8}
!16 = !{!17, !14, i64 48}
!17 = !{!"inflate_blocks_state", !10, i64 0, !7, i64 8, !10, i64 40, !10, i64 44, !14, i64 48, !6, i64 56, !6, i64 64, !6, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !14, i64 104}
!18 = !{!14, !14, i64 0}
!19 = !{!17, !10, i64 44}
!20 = !{!17, !6, i64 88}
!21 = !{!17, !6, i64 80}
!22 = !{!17, !6, i64 72}
!23 = !{!24, !10, i64 0}
!24 = !{!"inflate_codes_state", !10, i64 0, !10, i64 4, !7, i64 8, !7, i64 24, !7, i64 25, !6, i64 32, !6, i64 40}
!25 = !{!13, !14, i64 16}
!26 = !{!24, !7, i64 24}
!27 = !{!24, !7, i64 25}
!28 = !{!24, !6, i64 32}
!29 = !{!24, !6, i64 40}
!30 = distinct !{!30, !31}
!31 = !{!"llvm.loop.mustprogress"}
!32 = !{!33, !10, i64 4}
!33 = !{!"inflate_huft_s", !7, i64 0, !10, i64 4}
!34 = !{!24, !10, i64 4}
!35 = !{!13, !6, i64 48}
!36 = distinct !{!36, !31}
!37 = distinct !{!37, !31}
!38 = distinct !{!38, !31}
!39 = !{!17, !6, i64 64}
!40 = distinct !{!40, !31}
!41 = distinct !{!41, !31}


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

@inflate_mask = external local_unnamed_addr global [17 x i32], align 16
@.str = external hidden unnamed_addr constant [28 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [22 x i8], align 1

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

18:                                               ; preds = %3
  %19 = ptrtoint ptr %16 to i64
  %20 = ptrtoint ptr %14 to i64
  %21 = xor i64 %20, -1
  %22 = add i64 %19, %21
  br label %29

23:                                               ; preds = %3
  %24 = getelementptr inbounds i8, ptr %0, i64 72
  %25 = load ptr, ptr %24, align 8, !tbaa !19
  %26 = ptrtoint ptr %25 to i64
  %27 = ptrtoint ptr %14 to i64
  %28 = sub i64 %26, %27
  br label %29

29:                                               ; preds = %23, %18
  %30 = phi i64 [ %22, %18 ], [ %28, %23 ]
  %31 = trunc i64 %30 to i32
  %32 = getelementptr inbounds i8, ptr %0, i64 72
  %33 = getelementptr inbounds i8, ptr %0, i64 64
  %34 = getelementptr inbounds i8, ptr %5, i64 8
  %35 = getelementptr inbounds i8, ptr %5, i64 12
  %36 = getelementptr inbounds i8, ptr %5, i64 4
  %37 = getelementptr inbounds i8, ptr %5, i64 25
  %38 = getelementptr inbounds i8, ptr %5, i64 16
  %39 = getelementptr inbounds i8, ptr %5, i64 40
  %40 = getelementptr inbounds i8, ptr %1, i64 16
  %41 = getelementptr inbounds i8, ptr %5, i64 24
  %42 = getelementptr inbounds i8, ptr %5, i64 32
  %.pre = load i32, ptr %5, align 8, !tbaa !20
  br label %43

43:                                               ; preds = %.backedge, %29
  %44 = phi i32 [ %.pre, %29 ], [ %.be, %.backedge ]
  %.0526 = phi i32 [ %2, %29 ], [ %.0526.be, %.backedge ]
  %.0516 = phi i64 [ %10, %29 ], [ %.0516.be, %.backedge ]
  %.0504 = phi i32 [ %12, %29 ], [ %.0504.be, %.backedge ]
  %.0492 = phi ptr [ %6, %29 ], [ %.0492.be, %.backedge ]
  %.0480 = phi i32 [ %8, %29 ], [ %.0480.be, %.backedge ]
  %.0469 = phi ptr [ %14, %29 ], [ %.0469.be, %.backedge ]
  %.0466 = phi i32 [ %31, %29 ], [ %.0466.be, %.backedge ]
  switch i32 %44, label %561 [
    i32 0, label %45
    i32 1, label %._crit_edge933
    i32 2, label %166
    i32 3, label %._crit_edge926
    i32 4, label %282
    i32 5, label %._crit_edge922
    i32 6, label %467
    i32 7, label %530
    i32 8, label %.loopexit
    i32 9, label %553
  ]

._crit_edge933:                                   ; preds = %43
  %.pre934 = load i32, ptr %38, align 8, !tbaa !5
  br label %87

._crit_edge926:                                   ; preds = %43
  %.pre927 = load i32, ptr %38, align 8, !tbaa !5
  br label %211

._crit_edge922:                                   ; preds = %43
  %.pre923 = load i32, ptr %35, align 4, !tbaa !5
  br label %324

45:                                               ; preds = %43
  %46 = icmp ugt i32 %.0466, 257
  %47 = icmp ugt i32 %.0480, 9
  %or.cond = select i1 %46, i1 %47, i1 false
  %.pre930 = load i8, ptr %41, align 8, !tbaa !22
  %.pre932 = load ptr, ptr %42, align 8, !tbaa !23
  br i1 %or.cond, label %48, label %83

48:                                               ; preds = %45
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.0504, ptr %11, align 4, !tbaa !16
  store i32 %.0480, ptr %7, align 8, !tbaa !13
  %49 = load ptr, ptr %1, align 8, !tbaa !8
  %50 = ptrtoint ptr %.0492 to i64
  %51 = ptrtoint ptr %49 to i64
  %52 = sub i64 %50, %51
  %53 = load i64, ptr %40, align 8, !tbaa !24
  %54 = add i64 %52, %53
  store i64 %54, ptr %40, align 8, !tbaa !24
  store ptr %.0492, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %55 = zext i8 %.pre930 to i32
  %56 = load i8, ptr %37, align 1, !tbaa !25
  %57 = zext i8 %56 to i32
  %58 = load ptr, ptr %39, align 8, !tbaa !26
  %59 = tail call i32 @inflate_fast(i32 noundef %55, i32 noundef %57, ptr noundef %.pre932, ptr noundef %58, ptr noundef %0, ptr noundef %1) #2
  %60 = load ptr, ptr %1, align 8, !tbaa !8
  %61 = load i32, ptr %7, align 8, !tbaa !13
  %62 = load i64, ptr %9, align 8, !tbaa !14
  %63 = load i32, ptr %11, align 4, !tbaa !16
  %64 = load ptr, ptr %13, align 8, !tbaa !17
  %65 = load ptr, ptr %15, align 8, !tbaa !18
  %66 = icmp ult ptr %64, %65
  br i1 %66, label %67, label %72

67:                                               ; preds = %48
  %68 = ptrtoint ptr %65 to i64
  %69 = ptrtoint ptr %64 to i64
  %70 = xor i64 %69, -1
  %71 = add i64 %68, %70
  br label %77

72:                                               ; preds = %48
  %73 = load ptr, ptr %32, align 8, !tbaa !19
  %74 = ptrtoint ptr %73 to i64
  %75 = ptrtoint ptr %64 to i64
  %76 = sub i64 %74, %75
  br label %77

77:                                               ; preds = %72, %67
  %78 = phi i64 [ %71, %67 ], [ %76, %72 ]
  %79 = trunc i64 %78 to i32
  %.not586 = icmp eq i32 %59, 0
  br i1 %.not586, label %._crit_edge928, label %80

._crit_edge928:                                   ; preds = %77
  %.pre929 = load i8, ptr %41, align 8, !tbaa !22
  %.pre931 = load ptr, ptr %42, align 8, !tbaa !23
  br label %83

80:                                               ; preds = %77
  %81 = icmp eq i32 %59, 1
  %82 = select i1 %81, i32 7, i32 9
  store i32 %82, ptr %5, align 8, !tbaa !20
  br label %.backedge

83:                                               ; preds = %._crit_edge928, %45
  %84 = phi ptr [ %.pre931, %._crit_edge928 ], [ %.pre932, %45 ]
  %85 = phi i8 [ %.pre929, %._crit_edge928 ], [ %.pre930, %45 ]
  %.1527 = phi i32 [ 0, %._crit_edge928 ], [ %.0526, %45 ]
  %.1517 = phi i64 [ %62, %._crit_edge928 ], [ %.0516, %45 ]
  %.1505 = phi i32 [ %63, %._crit_edge928 ], [ %.0504, %45 ]
  %.1493 = phi ptr [ %60, %._crit_edge928 ], [ %.0492, %45 ]
  %.1481 = phi i32 [ %61, %._crit_edge928 ], [ %.0480, %45 ]
  %.1470 = phi ptr [ %64, %._crit_edge928 ], [ %.0469, %45 ]
  %.1467 = phi i32 [ %79, %._crit_edge928 ], [ %.0466, %45 ]
  %86 = zext i8 %85 to i32
  store i32 %86, ptr %38, align 8, !tbaa !5
  store ptr %84, ptr %34, align 8, !tbaa !5
  store i32 1, ptr %5, align 8, !tbaa !20
  br label %87

87:                                               ; preds = %._crit_edge933, %83
  %88 = phi i32 [ %.pre934, %._crit_edge933 ], [ %86, %83 ]
  %.2528 = phi i32 [ %.0526, %._crit_edge933 ], [ %.1527, %83 ]
  %.2518 = phi i64 [ %.0516, %._crit_edge933 ], [ %.1517, %83 ]
  %.2506 = phi i32 [ %.0504, %._crit_edge933 ], [ %.1505, %83 ]
  %.2494 = phi ptr [ %.0492, %._crit_edge933 ], [ %.1493, %83 ]
  %.2482 = phi i32 [ %.0480, %._crit_edge933 ], [ %.1481, %83 ]
  %.2471 = phi ptr [ %.0469, %._crit_edge933 ], [ %.1470, %83 ]
  %.2468 = phi i32 [ %.0466, %._crit_edge933 ], [ %.1467, %83 ]
  %89 = icmp ult i32 %.2506, %88
  br i1 %89, label %.lr.ph762.preheader, label %._crit_edge763

.lr.ph762.preheader:                              ; preds = %87
  %.not589.peel = icmp eq i32 %.2482, 0
  br i1 %.not589.peel, label %.loopexit914, label %90

90:                                               ; preds = %.lr.ph762.preheader
  %91 = add i32 %.2482, -1
  %92 = getelementptr inbounds i8, ptr %.2494, i64 1
  %93 = load i8, ptr %.2494, align 1, !tbaa !5
  %94 = zext i8 %93 to i64
  %95 = zext nneg i32 %.2506 to i64
  %96 = shl i64 %94, %95
  %97 = or i64 %96, %.2518
  %98 = add i32 %.2506, 8
  %99 = icmp ult i32 %98, %88
  br i1 %99, label %.lr.ph762, label %._crit_edge763

.lr.ph762:                                        ; preds = %90, %100
  %.3483760 = phi i32 [ %101, %100 ], [ %91, %90 ]
  %.3495759 = phi ptr [ %102, %100 ], [ %92, %90 ]
  %.3507758 = phi i32 [ %108, %100 ], [ %98, %90 ]
  %.3519757 = phi i64 [ %107, %100 ], [ %97, %90 ]
  %.not589 = icmp eq i32 %.3483760, 0
  br i1 %.not589, label %.loopexit914, label %100

100:                                              ; preds = %.lr.ph762
  %101 = add i32 %.3483760, -1
  %102 = getelementptr inbounds i8, ptr %.3495759, i64 1
  %103 = load i8, ptr %.3495759, align 1, !tbaa !5
  %104 = zext i8 %103 to i64
  %105 = zext nneg i32 %.3507758 to i64
  %106 = shl i64 %104, %105
  %107 = or i64 %106, %.3519757
  %108 = add i32 %.3507758, 8
  %109 = icmp ult i32 %108, %88
  br i1 %109, label %.lr.ph762, label %._crit_edge763, !llvm.loop !27

.loopexit914:                                     ; preds = %.lr.ph762.preheader, %.lr.ph762
  %.3519757.lcssa = phi i64 [ %.3519757, %.lr.ph762 ], [ %.2518, %.lr.ph762.preheader ]
  %.3529756.lcssa = phi i32 [ 0, %.lr.ph762 ], [ %.2528, %.lr.ph762.preheader ]
  %110 = zext i32 %.2482 to i64
  %scevgep912.le1150 = getelementptr i8, ptr %.2494, i64 %110
  %111 = shl i32 %.2482, 3
  %112 = add i32 %.2506, %111
  store i64 %.3519757.lcssa, ptr %9, align 8, !tbaa !14
  store i32 %112, ptr %11, align 4, !tbaa !16
  store i32 0, ptr %7, align 8, !tbaa !13
  %113 = load ptr, ptr %1, align 8, !tbaa !8
  %114 = ptrtoint ptr %scevgep912.le1150 to i64
  %115 = ptrtoint ptr %113 to i64
  %116 = sub i64 %114, %115
  %117 = load i64, ptr %40, align 8, !tbaa !24
  %118 = add i64 %116, %117
  store i64 %118, ptr %40, align 8, !tbaa !24
  store ptr %scevgep912.le1150, ptr %1, align 8, !tbaa !8
  store ptr %.2471, ptr %13, align 8, !tbaa !17
  %119 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef %1, i32 noundef %.3529756.lcssa) #2
  br label %569

._crit_edge763:                                   ; preds = %100, %90, %87
  %.3529.lcssa = phi i32 [ %.2528, %87 ], [ 0, %90 ], [ 0, %100 ]
  %.3519.lcssa = phi i64 [ %.2518, %87 ], [ %97, %90 ], [ %107, %100 ]
  %.3507.lcssa = phi i32 [ %.2506, %87 ], [ %98, %90 ], [ %108, %100 ]
  %.3495.lcssa = phi ptr [ %.2494, %87 ], [ %92, %90 ], [ %102, %100 ]
  %.3483.lcssa = phi i32 [ %.2482, %87 ], [ %91, %90 ], [ %101, %100 ]
  %120 = load ptr, ptr %34, align 8
  %121 = trunc i64 %.3519.lcssa to i32
  %122 = zext i32 %88 to i64
  %123 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %122
  %124 = load i32, ptr %123, align 4, !tbaa !30
  %125 = and i32 %124, %121
  %126 = zext i32 %125 to i64
  %127 = getelementptr inbounds %struct.inflate_huft_s, ptr %120, i64 %126
  %128 = getelementptr inbounds i8, ptr %127, i64 1
  %129 = load i8, ptr %128, align 1, !tbaa !5
  %130 = zext i8 %129 to i32
  %131 = zext nneg i8 %129 to i64
  %132 = lshr i64 %.3519.lcssa, %131
  %133 = sub i32 %.3507.lcssa, %130
  %134 = load i8, ptr %127, align 4, !tbaa !5
  %135 = zext i8 %134 to i32
  %136 = icmp eq i8 %134, 0
  br i1 %136, label %137, label %140

137:                                              ; preds = %._crit_edge763
  %138 = getelementptr inbounds i8, ptr %127, i64 4
  %139 = load i32, ptr %138, align 4, !tbaa !31
  store i32 %139, ptr %34, align 8, !tbaa !5
  store i32 6, ptr %5, align 8, !tbaa !20
  br label %.backedge

140:                                              ; preds = %._crit_edge763
  %141 = and i32 %135, 16
  %.not587 = icmp eq i32 %141, 0
  br i1 %.not587, label %146, label %142

142:                                              ; preds = %140
  %143 = and i32 %135, 15
  store i32 %143, ptr %34, align 8, !tbaa !5
  %144 = getelementptr inbounds i8, ptr %127, i64 4
  %145 = load i32, ptr %144, align 4, !tbaa !31
  store i32 %145, ptr %36, align 4, !tbaa !33
  store i32 2, ptr %5, align 8, !tbaa !20
  br label %.backedge

146:                                              ; preds = %140
  %147 = and i32 %135, 64
  %148 = icmp eq i32 %147, 0
  br i1 %148, label %149, label %154

149:                                              ; preds = %146
  store i32 %135, ptr %38, align 8, !tbaa !5
  %150 = getelementptr inbounds i8, ptr %127, i64 4
  %151 = load i32, ptr %150, align 4, !tbaa !31
  %152 = zext i32 %151 to i64
  %153 = getelementptr inbounds %struct.inflate_huft_s, ptr %127, i64 %152
  store ptr %153, ptr %34, align 8, !tbaa !5
  br label %.backedge

154:                                              ; preds = %146
  %155 = and i32 %135, 32
  %.not588 = icmp eq i32 %155, 0
  br i1 %.not588, label %157, label %156

156:                                              ; preds = %154
  store i32 7, ptr %5, align 8, !tbaa !20
  br label %.backedge

157:                                              ; preds = %154
  store i32 9, ptr %5, align 8, !tbaa !20
  %158 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str, ptr %158, align 8, !tbaa !34
  store i64 %132, ptr %9, align 8, !tbaa !14
  store i32 %133, ptr %11, align 4, !tbaa !16
  store i32 %.3483.lcssa, ptr %7, align 8, !tbaa !13
  %159 = load ptr, ptr %1, align 8, !tbaa !8
  %160 = ptrtoint ptr %.3495.lcssa to i64
  %161 = ptrtoint ptr %159 to i64
  %162 = sub i64 %160, %161
  %163 = load i64, ptr %40, align 8, !tbaa !24
  %164 = add i64 %162, %163
  store i64 %164, ptr %40, align 8, !tbaa !24
  store ptr %.3495.lcssa, ptr %1, align 8, !tbaa !8
  store ptr %.2471, ptr %13, align 8, !tbaa !17
  %165 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef %1, i32 noundef -3) #2
  br label %569

166:                                              ; preds = %43
  %167 = load i32, ptr %34, align 8, !tbaa !5
  %168 = icmp ult i32 %.0504, %167
  br i1 %168, label %.lr.ph736.preheader, label %._crit_edge737

.lr.ph736.preheader:                              ; preds = %166
  %.not585.peel = icmp eq i32 %.0480, 0
  br i1 %.not585.peel, label %.loopexit896, label %169

169:                                              ; preds = %.lr.ph736.preheader
  %170 = add i32 %.0480, -1
  %171 = getelementptr inbounds i8, ptr %.0492, i64 1
  %172 = load i8, ptr %.0492, align 1, !tbaa !5
  %173 = zext i8 %172 to i64
  %174 = zext nneg i32 %.0504 to i64
  %175 = shl i64 %173, %174
  %176 = or i64 %175, %.0516
  %177 = add i32 %.0504, 8
  %178 = icmp ult i32 %177, %167
  br i1 %178, label %.lr.ph736, label %._crit_edge737

.lr.ph736:                                        ; preds = %169, %179
  %.4484734 = phi i32 [ %180, %179 ], [ %170, %169 ]
  %.4496733 = phi ptr [ %181, %179 ], [ %171, %169 ]
  %.4508732 = phi i32 [ %187, %179 ], [ %177, %169 ]
  %.4520731 = phi i64 [ %186, %179 ], [ %176, %169 ]
  %.not585 = icmp eq i32 %.4484734, 0
  br i1 %.not585, label %.loopexit896, label %179

179:                                              ; preds = %.lr.ph736
  %180 = add i32 %.4484734, -1
  %181 = getelementptr inbounds i8, ptr %.4496733, i64 1
  %182 = load i8, ptr %.4496733, align 1, !tbaa !5
  %183 = zext i8 %182 to i64
  %184 = zext nneg i32 %.4508732 to i64
  %185 = shl i64 %183, %184
  %186 = or i64 %185, %.4520731
  %187 = add i32 %.4508732, 8
  %188 = icmp ult i32 %187, %167
  br i1 %188, label %.lr.ph736, label %._crit_edge737, !llvm.loop !35

.loopexit896:                                     ; preds = %.lr.ph736.preheader, %.lr.ph736
  %.4520731.lcssa = phi i64 [ %.4520731, %.lr.ph736 ], [ %.0516, %.lr.ph736.preheader ]
  %.4530730.lcssa = phi i32 [ 0, %.lr.ph736 ], [ %.0526, %.lr.ph736.preheader ]
  %189 = zext i32 %.0480 to i64
  %scevgep894.le1140 = getelementptr i8, ptr %.0492, i64 %189
  %190 = shl i32 %.0480, 3
  %191 = add i32 %.0504, %190
  store i64 %.4520731.lcssa, ptr %9, align 8, !tbaa !14
  store i32 %191, ptr %11, align 4, !tbaa !16
  store i32 0, ptr %7, align 8, !tbaa !13
  %192 = load ptr, ptr %1, align 8, !tbaa !8
  %193 = ptrtoint ptr %scevgep894.le1140 to i64
  %194 = ptrtoint ptr %192 to i64
  %195 = sub i64 %193, %194
  %196 = load i64, ptr %40, align 8, !tbaa !24
  %197 = add i64 %195, %196
  store i64 %197, ptr %40, align 8, !tbaa !24
  store ptr %scevgep894.le1140, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %198 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef %1, i32 noundef %.4530730.lcssa) #2
  br label %569

._crit_edge737:                                   ; preds = %179, %169, %166
  %.4530.lcssa = phi i32 [ %.0526, %166 ], [ 0, %169 ], [ 0, %179 ]
  %.4520.lcssa = phi i64 [ %.0516, %166 ], [ %176, %169 ], [ %186, %179 ]
  %.4508.lcssa = phi i32 [ %.0504, %166 ], [ %177, %169 ], [ %187, %179 ]
  %.4496.lcssa = phi ptr [ %.0492, %166 ], [ %171, %169 ], [ %181, %179 ]
  %.4484.lcssa = phi i32 [ %.0480, %166 ], [ %170, %169 ], [ %180, %179 ]
  %199 = trunc i64 %.4520.lcssa to i32
  %200 = zext i32 %167 to i64
  %201 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %200
  %202 = load i32, ptr %201, align 4, !tbaa !30
  %203 = and i32 %202, %199
  %204 = load i32, ptr %36, align 4, !tbaa !33
  %205 = add i32 %204, %203
  store i32 %205, ptr %36, align 4, !tbaa !33
  %206 = lshr i64 %.4520.lcssa, %200
  %207 = sub i32 %.4508.lcssa, %167
  %208 = load i8, ptr %37, align 1, !tbaa !25
  %209 = zext i8 %208 to i32
  store i32 %209, ptr %38, align 8, !tbaa !5
  %210 = load ptr, ptr %39, align 8, !tbaa !26
  store ptr %210, ptr %34, align 8, !tbaa !5
  store i32 3, ptr %5, align 8, !tbaa !20
  br label %211

211:                                              ; preds = %._crit_edge926, %._crit_edge737
  %212 = phi i32 [ %.pre927, %._crit_edge926 ], [ %209, %._crit_edge737 ]
  %.5531 = phi i32 [ %.0526, %._crit_edge926 ], [ %.4530.lcssa, %._crit_edge737 ]
  %.5521 = phi i64 [ %.0516, %._crit_edge926 ], [ %206, %._crit_edge737 ]
  %.5509 = phi i32 [ %.0504, %._crit_edge926 ], [ %207, %._crit_edge737 ]
  %.5497 = phi ptr [ %.0492, %._crit_edge926 ], [ %.4496.lcssa, %._crit_edge737 ]
  %.5485 = phi i32 [ %.0480, %._crit_edge926 ], [ %.4484.lcssa, %._crit_edge737 ]
  %213 = icmp ult i32 %.5509, %212
  br i1 %213, label %.lr.ph749.preheader, label %._crit_edge750

.lr.ph749.preheader:                              ; preds = %211
  %.not584.peel = icmp eq i32 %.5485, 0
  br i1 %.not584.peel, label %.loopexit905, label %214

214:                                              ; preds = %.lr.ph749.preheader
  %215 = add i32 %.5485, -1
  %216 = getelementptr inbounds i8, ptr %.5497, i64 1
  %217 = load i8, ptr %.5497, align 1, !tbaa !5
  %218 = zext i8 %217 to i64
  %219 = zext nneg i32 %.5509 to i64
  %220 = shl i64 %218, %219
  %221 = or i64 %220, %.5521
  %222 = add i32 %.5509, 8
  %223 = icmp ult i32 %222, %212
  br i1 %223, label %.lr.ph749, label %._crit_edge750

.lr.ph749:                                        ; preds = %214, %224
  %.6486747 = phi i32 [ %225, %224 ], [ %215, %214 ]
  %.6498746 = phi ptr [ %226, %224 ], [ %216, %214 ]
  %.6510745 = phi i32 [ %232, %224 ], [ %222, %214 ]
  %.6522744 = phi i64 [ %231, %224 ], [ %221, %214 ]
  %.not584 = icmp eq i32 %.6486747, 0
  br i1 %.not584, label %.loopexit905, label %224

224:                                              ; preds = %.lr.ph749
  %225 = add i32 %.6486747, -1
  %226 = getelementptr inbounds i8, ptr %.6498746, i64 1
  %227 = load i8, ptr %.6498746, align 1, !tbaa !5
  %228 = zext i8 %227 to i64
  %229 = zext nneg i32 %.6510745 to i64
  %230 = shl i64 %228, %229
  %231 = or i64 %230, %.6522744
  %232 = add i32 %.6510745, 8
  %233 = icmp ult i32 %232, %212
  br i1 %233, label %.lr.ph749, label %._crit_edge750, !llvm.loop !36

.loopexit905:                                     ; preds = %.lr.ph749.preheader, %.lr.ph749
  %.6522744.lcssa = phi i64 [ %.6522744, %.lr.ph749 ], [ %.5521, %.lr.ph749.preheader ]
  %.6532743.lcssa = phi i32 [ 0, %.lr.ph749 ], [ %.5531, %.lr.ph749.preheader ]
  %234 = zext i32 %.5485 to i64
  %scevgep903.le1127 = getelementptr i8, ptr %.5497, i64 %234
  %235 = shl i32 %.5485, 3
  %236 = add i32 %.5509, %235
  store i64 %.6522744.lcssa, ptr %9, align 8, !tbaa !14
  store i32 %236, ptr %11, align 4, !tbaa !16
  store i32 0, ptr %7, align 8, !tbaa !13
  %237 = load ptr, ptr %1, align 8, !tbaa !8
  %238 = ptrtoint ptr %scevgep903.le1127 to i64
  %239 = ptrtoint ptr %237 to i64
  %240 = sub i64 %238, %239
  %241 = load i64, ptr %40, align 8, !tbaa !24
  %242 = add i64 %240, %241
  store i64 %242, ptr %40, align 8, !tbaa !24
  store ptr %scevgep903.le1127, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %243 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef nonnull %1, i32 noundef %.6532743.lcssa) #2
  br label %569

._crit_edge750:                                   ; preds = %224, %214, %211
  %.6532.lcssa = phi i32 [ %.5531, %211 ], [ 0, %214 ], [ 0, %224 ]
  %.6522.lcssa = phi i64 [ %.5521, %211 ], [ %221, %214 ], [ %231, %224 ]
  %.6510.lcssa = phi i32 [ %.5509, %211 ], [ %222, %214 ], [ %232, %224 ]
  %.6498.lcssa = phi ptr [ %.5497, %211 ], [ %216, %214 ], [ %226, %224 ]
  %.6486.lcssa = phi i32 [ %.5485, %211 ], [ %215, %214 ], [ %225, %224 ]
  %244 = load ptr, ptr %34, align 8, !tbaa !5
  %245 = trunc i64 %.6522.lcssa to i32
  %246 = zext i32 %212 to i64
  %247 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %246
  %248 = load i32, ptr %247, align 4, !tbaa !30
  %249 = and i32 %248, %245
  %250 = zext i32 %249 to i64
  %251 = getelementptr inbounds %struct.inflate_huft_s, ptr %244, i64 %250
  %252 = getelementptr inbounds i8, ptr %251, i64 1
  %253 = load i8, ptr %252, align 1, !tbaa !5
  %254 = zext i8 %253 to i32
  %255 = zext nneg i8 %253 to i64
  %256 = lshr i64 %.6522.lcssa, %255
  %257 = sub i32 %.6510.lcssa, %254
  %258 = load i8, ptr %251, align 4, !tbaa !5
  %259 = zext i8 %258 to i32
  %260 = and i32 %259, 16
  %.not583 = icmp eq i32 %260, 0
  br i1 %.not583, label %265, label %261

261:                                              ; preds = %._crit_edge750
  %262 = and i32 %259, 15
  store i32 %262, ptr %34, align 8, !tbaa !5
  %263 = getelementptr inbounds i8, ptr %251, i64 4
  %264 = load i32, ptr %263, align 4, !tbaa !31
  store i32 %264, ptr %35, align 4, !tbaa !5
  store i32 4, ptr %5, align 8, !tbaa !20
  br label %.backedge

265:                                              ; preds = %._crit_edge750
  %266 = and i32 %259, 64
  %267 = icmp eq i32 %266, 0
  br i1 %267, label %268, label %273

268:                                              ; preds = %265
  store i32 %259, ptr %38, align 8, !tbaa !5
  %269 = getelementptr inbounds i8, ptr %251, i64 4
  %270 = load i32, ptr %269, align 4, !tbaa !31
  %271 = zext i32 %270 to i64
  %272 = getelementptr inbounds %struct.inflate_huft_s, ptr %251, i64 %271
  store ptr %272, ptr %34, align 8, !tbaa !5
  br label %.backedge

273:                                              ; preds = %265
  store i32 9, ptr %5, align 8, !tbaa !20
  %274 = getelementptr inbounds i8, ptr %1, i64 48
  store ptr @.str.1, ptr %274, align 8, !tbaa !34
  store i64 %256, ptr %9, align 8, !tbaa !14
  store i32 %257, ptr %11, align 4, !tbaa !16
  store i32 %.6486.lcssa, ptr %7, align 8, !tbaa !13
  %275 = load ptr, ptr %1, align 8, !tbaa !8
  %276 = ptrtoint ptr %.6498.lcssa to i64
  %277 = ptrtoint ptr %275 to i64
  %278 = sub i64 %276, %277
  %279 = load i64, ptr %40, align 8, !tbaa !24
  %280 = add i64 %278, %279
  store i64 %280, ptr %40, align 8, !tbaa !24
  store ptr %.6498.lcssa, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %281 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef nonnull %1, i32 noundef -3) #2
  br label %569

282:                                              ; preds = %43
  %283 = load i32, ptr %34, align 8, !tbaa !5
  %284 = icmp ult i32 %.0504, %283
  br i1 %284, label %.lr.ph.preheader, label %._crit_edge

.lr.ph.preheader:                                 ; preds = %282
  %.not582.peel = icmp eq i32 %.0480, 0
  br i1 %.not582.peel, label %.loopexit878, label %285

285:                                              ; preds = %.lr.ph.preheader
  %286 = add i32 %.0480, -1
  %287 = getelementptr inbounds i8, ptr %.0492, i64 1
  %288 = load i8, ptr %.0492, align 1, !tbaa !5
  %289 = zext i8 %288 to i64
  %290 = zext nneg i32 %.0504 to i64
  %291 = shl i64 %289, %290
  %292 = or i64 %291, %.0516
  %293 = add i32 %.0504, 8
  %294 = icmp ult i32 %293, %283
  br i1 %294, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %285, %295
  %.7487711 = phi i32 [ %296, %295 ], [ %286, %285 ]
  %.7499710 = phi ptr [ %297, %295 ], [ %287, %285 ]
  %.7511709 = phi i32 [ %303, %295 ], [ %293, %285 ]
  %.7523708 = phi i64 [ %302, %295 ], [ %292, %285 ]
  %.not582 = icmp eq i32 %.7487711, 0
  br i1 %.not582, label %.loopexit878, label %295

295:                                              ; preds = %.lr.ph
  %296 = add i32 %.7487711, -1
  %297 = getelementptr inbounds i8, ptr %.7499710, i64 1
  %298 = load i8, ptr %.7499710, align 1, !tbaa !5
  %299 = zext i8 %298 to i64
  %300 = zext nneg i32 %.7511709 to i64
  %301 = shl i64 %299, %300
  %302 = or i64 %301, %.7523708
  %303 = add i32 %.7511709, 8
  %304 = icmp ult i32 %303, %283
  br i1 %304, label %.lr.ph, label %._crit_edge, !llvm.loop !37

.loopexit878:                                     ; preds = %.lr.ph.preheader, %.lr.ph
  %.7523708.lcssa = phi i64 [ %.7523708, %.lr.ph ], [ %.0516, %.lr.ph.preheader ]
  %.7533707.lcssa = phi i32 [ 0, %.lr.ph ], [ %.0526, %.lr.ph.preheader ]
  %305 = zext i32 %.0480 to i64
  %scevgep.le1117 = getelementptr i8, ptr %.0492, i64 %305
  %306 = shl i32 %.0480, 3
  %307 = add i32 %.0504, %306
  store i64 %.7523708.lcssa, ptr %9, align 8, !tbaa !14
  store i32 %307, ptr %11, align 4, !tbaa !16
  store i32 0, ptr %7, align 8, !tbaa !13
  %308 = load ptr, ptr %1, align 8, !tbaa !8
  %309 = ptrtoint ptr %scevgep.le1117 to i64
  %310 = ptrtoint ptr %308 to i64
  %311 = sub i64 %309, %310
  %312 = load i64, ptr %40, align 8, !tbaa !24
  %313 = add i64 %311, %312
  store i64 %313, ptr %40, align 8, !tbaa !24
  store ptr %scevgep.le1117, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %314 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef nonnull %1, i32 noundef %.7533707.lcssa) #2
  br label %569

._crit_edge:                                      ; preds = %295, %285, %282
  %.7533.lcssa = phi i32 [ %.0526, %282 ], [ 0, %285 ], [ 0, %295 ]
  %.7523.lcssa = phi i64 [ %.0516, %282 ], [ %292, %285 ], [ %302, %295 ]
  %.7511.lcssa = phi i32 [ %.0504, %282 ], [ %293, %285 ], [ %303, %295 ]
  %.7499.lcssa = phi ptr [ %.0492, %282 ], [ %287, %285 ], [ %297, %295 ]
  %.7487.lcssa = phi i32 [ %.0480, %282 ], [ %286, %285 ], [ %296, %295 ]
  %315 = trunc i64 %.7523.lcssa to i32
  %316 = zext i32 %283 to i64
  %317 = getelementptr inbounds [17 x i32], ptr @inflate_mask, i64 0, i64 %316
  %318 = load i32, ptr %317, align 4, !tbaa !30
  %319 = and i32 %318, %315
  %320 = load i32, ptr %35, align 4, !tbaa !5
  %321 = add i32 %320, %319
  store i32 %321, ptr %35, align 4, !tbaa !5
  %322 = lshr i64 %.7523.lcssa, %316
  %323 = sub i32 %.7511.lcssa, %283
  store i32 5, ptr %5, align 8, !tbaa !20
  br label %324

324:                                              ; preds = %._crit_edge922, %._crit_edge
  %325 = phi i32 [ %.pre923, %._crit_edge922 ], [ %321, %._crit_edge ]
  %.8534 = phi i32 [ %.0526, %._crit_edge922 ], [ %.7533.lcssa, %._crit_edge ]
  %.8524 = phi i64 [ %.0516, %._crit_edge922 ], [ %322, %._crit_edge ]
  %.8512 = phi i32 [ %.0504, %._crit_edge922 ], [ %323, %._crit_edge ]
  %.8500 = phi ptr [ %.0492, %._crit_edge922 ], [ %.7499.lcssa, %._crit_edge ]
  %.8488 = phi i32 [ %.0480, %._crit_edge922 ], [ %.7487.lcssa, %._crit_edge ]
  %326 = zext i32 %325 to i64
  %327 = sub nsw i64 0, %326
  %328 = getelementptr inbounds i8, ptr %.0469, i64 %327
  %329 = load ptr, ptr %33, align 8, !tbaa !38
  %330 = icmp ult ptr %328, %329
  br i1 %330, label %.lr.ph718, label %.preheader

.lr.ph718:                                        ; preds = %324
  %331 = load ptr, ptr %32, align 8, !tbaa !19
  %332 = ptrtoint ptr %331 to i64
  %333 = ptrtoint ptr %329 to i64
  %334 = sub i64 %332, %333
  br label %396

.preheader:                                       ; preds = %396, %324
  %.0465.lcssa = phi ptr [ %328, %324 ], [ %397, %396 ]
  %335 = load i32, ptr %36, align 4, !tbaa !33
  %.not579720 = icmp eq i32 %335, 0
  br i1 %.not579720, label %._crit_edge726, label %.lr.ph725.preheader

.lr.ph725.preheader:                              ; preds = %.preheader
  %336 = icmp eq i32 %.0466, 0
  br i1 %336, label %337, label %384

337:                                              ; preds = %.lr.ph725.preheader
  %338 = load ptr, ptr %32, align 8, !tbaa !19
  %339 = icmp eq ptr %.0469, %338
  br i1 %339, label %340, label %.thread.peel

340:                                              ; preds = %337
  %341 = load ptr, ptr %15, align 8, !tbaa !18
  %.not580.peel = icmp eq ptr %341, %329
  br i1 %.not580.peel, label %.thread.peel, label %342

342:                                              ; preds = %340
  %343 = icmp ult ptr %329, %341
  %344 = ptrtoint ptr %341 to i64
  %345 = ptrtoint ptr %329 to i64
  %346 = xor i64 %345, -1
  %347 = add i64 %346, %344
  %348 = ptrtoint ptr %.0469 to i64
  %349 = sub i64 %348, %345
  %350 = select i1 %343, i64 %347, i64 %349
  %351 = trunc i64 %350 to i32
  %352 = icmp eq i32 %351, 0
  br i1 %352, label %.thread.peel, label %384

.thread.peel:                                     ; preds = %342, %340, %337
  %.4473592.peel = phi ptr [ %329, %342 ], [ %.0469, %340 ], [ %.0469, %337 ]
  store ptr %.4473592.peel, ptr %13, align 8, !tbaa !17
  %353 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.8534) #2
  %354 = load ptr, ptr %13, align 8, !tbaa !17
  %355 = load ptr, ptr %15, align 8, !tbaa !18
  %356 = icmp ult ptr %354, %355
  br i1 %356, label %362, label %357

357:                                              ; preds = %.thread.peel
  %358 = load ptr, ptr %32, align 8, !tbaa !19
  %359 = ptrtoint ptr %358 to i64
  %360 = ptrtoint ptr %354 to i64
  %361 = sub i64 %359, %360
  br label %367

362:                                              ; preds = %.thread.peel
  %363 = ptrtoint ptr %355 to i64
  %364 = ptrtoint ptr %354 to i64
  %365 = xor i64 %364, -1
  %366 = add i64 %363, %365
  %.pre924 = load ptr, ptr %32, align 8, !tbaa !19
  br label %367

367:                                              ; preds = %362, %357
  %368 = phi ptr [ %.pre924, %362 ], [ %358, %357 ]
  %369 = phi i64 [ %366, %362 ], [ %361, %357 ]
  %370 = icmp eq ptr %354, %368
  br i1 %370, label %371, label %382

371:                                              ; preds = %367
  %372 = load ptr, ptr %33, align 8, !tbaa !38
  %.not581.peel = icmp eq ptr %355, %372
  br i1 %.not581.peel, label %382, label %373

373:                                              ; preds = %371
  %374 = icmp ult ptr %372, %355
  %375 = ptrtoint ptr %355 to i64
  %376 = ptrtoint ptr %372 to i64
  %377 = xor i64 %376, -1
  %378 = add i64 %377, %375
  %379 = ptrtoint ptr %354 to i64
  %380 = sub i64 %379, %376
  %381 = select i1 %374, i64 %378, i64 %380
  br label %382

382:                                              ; preds = %373, %371, %367
  %.5474.peel = phi ptr [ %372, %373 ], [ %354, %371 ], [ %354, %367 ]
  %.5.in.peel = phi i64 [ %381, %373 ], [ %369, %371 ], [ %369, %367 ]
  %.5.peel = trunc i64 %.5.in.peel to i32
  %383 = icmp eq i32 %.5.peel, 0
  br i1 %383, label %.loopexit886, label %384

384:                                              ; preds = %382, %342, %.lr.ph725.preheader
  %.6475.peel = phi ptr [ %.5474.peel, %382 ], [ %329, %342 ], [ %.0469, %.lr.ph725.preheader ]
  %.6.peel = phi i32 [ %.5.peel, %382 ], [ %351, %342 ], [ %.0466, %.lr.ph725.preheader ]
  %385 = getelementptr inbounds i8, ptr %.0465.lcssa, i64 1
  %386 = load i8, ptr %.0465.lcssa, align 1, !tbaa !5
  %387 = getelementptr inbounds i8, ptr %.6475.peel, i64 1
  store i8 %386, ptr %.6475.peel, align 1, !tbaa !5
  %388 = add i32 %.6.peel, -1
  %389 = load ptr, ptr %32, align 8, !tbaa !19
  %390 = icmp eq ptr %385, %389
  br i1 %390, label %391, label %393

391:                                              ; preds = %384
  %392 = load ptr, ptr %33, align 8, !tbaa !38
  br label %393

393:                                              ; preds = %391, %384
  %.2.peel = phi ptr [ %392, %391 ], [ %385, %384 ]
  %394 = load i32, ptr %36, align 4, !tbaa !33
  %395 = add i32 %394, -1
  store i32 %395, ptr %36, align 4, !tbaa !33
  %.not579.peel = icmp eq i32 %395, 0
  br i1 %.not579.peel, label %._crit_edge726, label %.lr.ph725

396:                                              ; preds = %.lr.ph718, %396
  %.0465716 = phi ptr [ %328, %.lr.ph718 ], [ %397, %396 ]
  %397 = getelementptr inbounds i8, ptr %.0465716, i64 %334
  %398 = icmp ult ptr %397, %329
  br i1 %398, label %396, label %.preheader, !llvm.loop !39

.lr.ph725:                                        ; preds = %393, %464
  %399 = phi ptr [ %460, %464 ], [ %389, %393 ]
  %.1724 = phi ptr [ %.2, %464 ], [ %.2.peel, %393 ]
  %.3723 = phi i32 [ %459, %464 ], [ %388, %393 ]
  %.3472722 = phi ptr [ %458, %464 ], [ %387, %393 ]
  %400 = icmp eq i32 %.3723, 0
  br i1 %400, label %401, label %455

401:                                              ; preds = %.lr.ph725
  %402 = icmp eq ptr %.3472722, %399
  br i1 %402, label %403, label %.thread

403:                                              ; preds = %401
  %404 = load ptr, ptr %15, align 8, !tbaa !18
  %405 = load ptr, ptr %33, align 8, !tbaa !38
  %.not580 = icmp eq ptr %404, %405
  br i1 %.not580, label %.thread, label %406

406:                                              ; preds = %403
  %407 = icmp ult ptr %405, %404
  %408 = ptrtoint ptr %404 to i64
  %409 = ptrtoint ptr %405 to i64
  %410 = xor i64 %409, -1
  %411 = add i64 %410, %408
  %412 = ptrtoint ptr %399 to i64
  %413 = sub i64 %412, %409
  %414 = select i1 %407, i64 %411, i64 %413
  %415 = trunc i64 %414 to i32
  %416 = icmp eq i32 %415, 0
  br i1 %416, label %.thread, label %455

.thread:                                          ; preds = %401, %403, %406
  %.4473592 = phi ptr [ %405, %406 ], [ %.3472722, %403 ], [ %.3472722, %401 ]
  store ptr %.4473592, ptr %13, align 8, !tbaa !17
  %417 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef 0) #2
  %418 = load ptr, ptr %13, align 8, !tbaa !17
  %419 = load ptr, ptr %15, align 8, !tbaa !18
  %420 = icmp ult ptr %418, %419
  br i1 %420, label %421, label %426

421:                                              ; preds = %.thread
  %422 = ptrtoint ptr %419 to i64
  %423 = ptrtoint ptr %418 to i64
  %424 = xor i64 %423, -1
  %425 = add i64 %422, %424
  %.pre925 = load ptr, ptr %32, align 8, !tbaa !19
  br label %431

426:                                              ; preds = %.thread
  %427 = load ptr, ptr %32, align 8, !tbaa !19
  %428 = ptrtoint ptr %427 to i64
  %429 = ptrtoint ptr %418 to i64
  %430 = sub i64 %428, %429
  br label %431

431:                                              ; preds = %426, %421
  %432 = phi ptr [ %.pre925, %421 ], [ %427, %426 ]
  %433 = phi i64 [ %425, %421 ], [ %430, %426 ]
  %434 = icmp eq ptr %418, %432
  br i1 %434, label %435, label %446

435:                                              ; preds = %431
  %436 = load ptr, ptr %33, align 8, !tbaa !38
  %.not581 = icmp eq ptr %419, %436
  br i1 %.not581, label %446, label %437

437:                                              ; preds = %435
  %438 = icmp ult ptr %436, %419
  %439 = ptrtoint ptr %419 to i64
  %440 = ptrtoint ptr %436 to i64
  %441 = xor i64 %440, -1
  %442 = add i64 %441, %439
  %443 = ptrtoint ptr %418 to i64
  %444 = sub i64 %443, %440
  %445 = select i1 %438, i64 %442, i64 %444
  br label %446

446:                                              ; preds = %437, %435, %431
  %.5474 = phi ptr [ %436, %437 ], [ %418, %435 ], [ %418, %431 ]
  %.5.in = phi i64 [ %445, %437 ], [ %433, %435 ], [ %433, %431 ]
  %.5 = trunc i64 %.5.in to i32
  %447 = icmp eq i32 %.5, 0
  br i1 %447, label %.loopexit886, label %455

.loopexit886:                                     ; preds = %382, %446
  %.5474.lcssa = phi ptr [ %.5474, %446 ], [ %.5474.peel, %382 ]
  %.lcssa777 = phi i32 [ %417, %446 ], [ %353, %382 ]
  store i64 %.8524, ptr %9, align 8, !tbaa !14
  store i32 %.8512, ptr %11, align 4, !tbaa !16
  store i32 %.8488, ptr %7, align 8, !tbaa !13
  %448 = load ptr, ptr %1, align 8, !tbaa !8
  %449 = ptrtoint ptr %.8500 to i64
  %450 = ptrtoint ptr %448 to i64
  %451 = sub i64 %449, %450
  %452 = load i64, ptr %40, align 8, !tbaa !24
  %453 = add i64 %451, %452
  store i64 %453, ptr %40, align 8, !tbaa !24
  store ptr %.8500, ptr %1, align 8, !tbaa !8
  store ptr %.5474.lcssa, ptr %13, align 8, !tbaa !17
  %454 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %.lcssa777) #2
  br label %569

455:                                              ; preds = %406, %446, %.lr.ph725
  %.6475 = phi ptr [ %.5474, %446 ], [ %405, %406 ], [ %.3472722, %.lr.ph725 ]
  %.6 = phi i32 [ %.5, %446 ], [ %415, %406 ], [ %.3723, %.lr.ph725 ]
  %456 = getelementptr inbounds i8, ptr %.1724, i64 1
  %457 = load i8, ptr %.1724, align 1, !tbaa !5
  %458 = getelementptr inbounds i8, ptr %.6475, i64 1
  store i8 %457, ptr %.6475, align 1, !tbaa !5
  %459 = add i32 %.6, -1
  %460 = load ptr, ptr %32, align 8, !tbaa !19
  %461 = icmp eq ptr %456, %460
  br i1 %461, label %462, label %464

462:                                              ; preds = %455
  %463 = load ptr, ptr %33, align 8, !tbaa !38
  br label %464

464:                                              ; preds = %462, %455
  %.2 = phi ptr [ %463, %462 ], [ %456, %455 ]
  %465 = load i32, ptr %36, align 4, !tbaa !33
  %466 = add i32 %465, -1
  store i32 %466, ptr %36, align 4, !tbaa !33
  %.not579 = icmp eq i32 %466, 0
  br i1 %.not579, label %._crit_edge726, label %.lr.ph725, !llvm.loop !40

._crit_edge726:                                   ; preds = %464, %393, %.preheader
  %.9535.lcssa = phi i32 [ %.8534, %.preheader ], [ 0, %393 ], [ 0, %464 ]
  %.3472.lcssa = phi ptr [ %.0469, %.preheader ], [ %387, %393 ], [ %458, %464 ]
  %.3.lcssa = phi i32 [ %.0466, %.preheader ], [ %388, %393 ], [ %459, %464 ]
  store i32 0, ptr %5, align 8, !tbaa !20
  br label %.backedge

467:                                              ; preds = %43
  %468 = icmp eq i32 %.0466, 0
  br i1 %468, label %469, label %525

469:                                              ; preds = %467
  %470 = load ptr, ptr %32, align 8, !tbaa !19
  %471 = icmp eq ptr %.0469, %470
  br i1 %471, label %472, label %.thread594

472:                                              ; preds = %469
  %473 = load ptr, ptr %15, align 8, !tbaa !18
  %474 = load ptr, ptr %33, align 8, !tbaa !38
  %.not577 = icmp eq ptr %473, %474
  br i1 %.not577, label %.thread594, label %475

475:                                              ; preds = %472
  %476 = icmp ult ptr %474, %473
  %477 = ptrtoint ptr %473 to i64
  %478 = ptrtoint ptr %474 to i64
  %479 = xor i64 %478, -1
  %480 = add i64 %479, %477
  %481 = ptrtoint ptr %.0469 to i64
  %482 = sub i64 %481, %478
  %483 = select i1 %476, i64 %480, i64 %482
  %484 = trunc i64 %483 to i32
  %485 = icmp eq i32 %484, 0
  br i1 %485, label %.thread594, label %525

.thread594:                                       ; preds = %469, %472, %475
  %.7476597 = phi ptr [ %474, %475 ], [ %.0469, %472 ], [ %.0469, %469 ]
  store ptr %.7476597, ptr %13, align 8, !tbaa !17
  %486 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef %1, i32 noundef %.0526) #2
  %487 = load ptr, ptr %13, align 8, !tbaa !17
  %488 = load ptr, ptr %15, align 8, !tbaa !18
  %489 = icmp ult ptr %487, %488
  br i1 %489, label %490, label %495

490:                                              ; preds = %.thread594
  %491 = ptrtoint ptr %488 to i64
  %492 = ptrtoint ptr %487 to i64
  %493 = xor i64 %492, -1
  %494 = add i64 %491, %493
  %.pre921 = load ptr, ptr %32, align 8, !tbaa !19
  br label %500

495:                                              ; preds = %.thread594
  %496 = load ptr, ptr %32, align 8, !tbaa !19
  %497 = ptrtoint ptr %496 to i64
  %498 = ptrtoint ptr %487 to i64
  %499 = sub i64 %497, %498
  br label %500

500:                                              ; preds = %495, %490
  %501 = phi ptr [ %.pre921, %490 ], [ %496, %495 ]
  %502 = phi i64 [ %494, %490 ], [ %499, %495 ]
  %503 = icmp eq ptr %487, %501
  br i1 %503, label %504, label %515

504:                                              ; preds = %500
  %505 = load ptr, ptr %33, align 8, !tbaa !38
  %.not578 = icmp eq ptr %488, %505
  br i1 %.not578, label %515, label %506

506:                                              ; preds = %504
  %507 = icmp ult ptr %505, %488
  %508 = ptrtoint ptr %488 to i64
  %509 = ptrtoint ptr %505 to i64
  %510 = xor i64 %509, -1
  %511 = add i64 %510, %508
  %512 = ptrtoint ptr %487 to i64
  %513 = sub i64 %512, %509
  %514 = select i1 %507, i64 %511, i64 %513
  br label %515

515:                                              ; preds = %506, %504, %500
  %.8477 = phi ptr [ %505, %506 ], [ %487, %504 ], [ %487, %500 ]
  %.8.in = phi i64 [ %514, %506 ], [ %502, %504 ], [ %502, %500 ]
  %.8 = trunc i64 %.8.in to i32
  %516 = icmp eq i32 %.8, 0
  br i1 %516, label %517, label %525

517:                                              ; preds = %515
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.0504, ptr %11, align 4, !tbaa !16
  store i32 %.0480, ptr %7, align 8, !tbaa !13
  %518 = load ptr, ptr %1, align 8, !tbaa !8
  %519 = ptrtoint ptr %.0492 to i64
  %520 = ptrtoint ptr %518 to i64
  %521 = sub i64 %519, %520
  %522 = load i64, ptr %40, align 8, !tbaa !24
  %523 = add i64 %521, %522
  store i64 %523, ptr %40, align 8, !tbaa !24
  store ptr %.0492, ptr %1, align 8, !tbaa !8
  store ptr %.8477, ptr %13, align 8, !tbaa !17
  %524 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %486) #2
  br label %569

525:                                              ; preds = %475, %515, %467
  %.9478 = phi ptr [ %.8477, %515 ], [ %474, %475 ], [ %.0469, %467 ]
  %.9 = phi i32 [ %.8, %515 ], [ %484, %475 ], [ %.0466, %467 ]
  %526 = load i32, ptr %34, align 8, !tbaa !5
  %527 = trunc i32 %526 to i8
  %528 = getelementptr inbounds i8, ptr %.9478, i64 1
  store i8 %527, ptr %.9478, align 1, !tbaa !5
  %529 = add i32 %.9, -1
  store i32 0, ptr %5, align 8, !tbaa !20
  br label %.backedge

.backedge:                                        ; preds = %525, %._crit_edge726, %268, %261, %156, %149, %142, %137, %80
  %.be = phi i32 [ 0, %525 ], [ 0, %._crit_edge726 ], [ 4, %261 ], [ 3, %268 ], [ 6, %137 ], [ 2, %142 ], [ 1, %149 ], [ 7, %156 ], [ %82, %80 ]
  %.0526.be = phi i32 [ 0, %525 ], [ %.9535.lcssa, %._crit_edge726 ], [ %.6532.lcssa, %261 ], [ %.6532.lcssa, %268 ], [ %.3529.lcssa, %137 ], [ %.3529.lcssa, %142 ], [ %.3529.lcssa, %149 ], [ %.3529.lcssa, %156 ], [ %59, %80 ]
  %.0516.be = phi i64 [ %.0516, %525 ], [ %.8524, %._crit_edge726 ], [ %256, %261 ], [ %256, %268 ], [ %132, %137 ], [ %132, %142 ], [ %132, %149 ], [ %132, %156 ], [ %62, %80 ]
  %.0504.be = phi i32 [ %.0504, %525 ], [ %.8512, %._crit_edge726 ], [ %257, %261 ], [ %257, %268 ], [ %133, %137 ], [ %133, %142 ], [ %133, %149 ], [ %133, %156 ], [ %63, %80 ]
  %.0492.be = phi ptr [ %.0492, %525 ], [ %.8500, %._crit_edge726 ], [ %.6498.lcssa, %261 ], [ %.6498.lcssa, %268 ], [ %.3495.lcssa, %137 ], [ %.3495.lcssa, %142 ], [ %.3495.lcssa, %149 ], [ %.3495.lcssa, %156 ], [ %60, %80 ]
  %.0480.be = phi i32 [ %.0480, %525 ], [ %.8488, %._crit_edge726 ], [ %.6486.lcssa, %261 ], [ %.6486.lcssa, %268 ], [ %.3483.lcssa, %137 ], [ %.3483.lcssa, %142 ], [ %.3483.lcssa, %149 ], [ %.3483.lcssa, %156 ], [ %61, %80 ]
  %.0469.be = phi ptr [ %528, %525 ], [ %.3472.lcssa, %._crit_edge726 ], [ %.0469, %261 ], [ %.0469, %268 ], [ %.2471, %137 ], [ %.2471, %142 ], [ %.2471, %149 ], [ %.2471, %156 ], [ %64, %80 ]
  %.0466.be = phi i32 [ %529, %525 ], [ %.3.lcssa, %._crit_edge726 ], [ %.0466, %261 ], [ %.0466, %268 ], [ %.2468, %137 ], [ %.2468, %142 ], [ %.2468, %149 ], [ %.2468, %156 ], [ %79, %80 ]
  br label %43

530:                                              ; preds = %43
  %531 = icmp ugt i32 %.0504, 7
  %532 = add i32 %.0504, -8
  %.9513 = select i1 %531, i32 %532, i32 %.0504
  %.9501.idx = sext i1 %531 to i64
  %.9501 = getelementptr inbounds i8, ptr %.0492, i64 %.9501.idx
  %533 = zext i1 %531 to i32
  %.9489 = add i32 %.0480, %533
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %534 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef %1, i32 noundef %.0526) #2
  %535 = load ptr, ptr %13, align 8, !tbaa !17
  %536 = load ptr, ptr %15, align 8, !tbaa !18
  %.not = icmp eq ptr %536, %535
  br i1 %.not, label %545, label %537

537:                                              ; preds = %530
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.9513, ptr %11, align 4, !tbaa !16
  store i32 %.9489, ptr %7, align 8, !tbaa !13
  %538 = load ptr, ptr %1, align 8, !tbaa !8
  %539 = ptrtoint ptr %.9501 to i64
  %540 = ptrtoint ptr %538 to i64
  %541 = sub i64 %539, %540
  %542 = load i64, ptr %40, align 8, !tbaa !24
  %543 = add i64 %541, %542
  store i64 %543, ptr %40, align 8, !tbaa !24
  store ptr %.9501, ptr %1, align 8, !tbaa !8
  %544 = tail call i32 @inflate_flush(ptr noundef nonnull %0, ptr noundef nonnull %1, i32 noundef %534) #2
  br label %569

545:                                              ; preds = %530
  store i32 8, ptr %5, align 8, !tbaa !20
  br label %.loopexit

.loopexit:                                        ; preds = %43, %545
  %.10514 = phi i32 [ %.9513, %545 ], [ %.0504, %43 ]
  %.10502 = phi ptr [ %.9501, %545 ], [ %.0492, %43 ]
  %.10490 = phi i32 [ %.9489, %545 ], [ %.0480, %43 ]
  %.10479 = phi ptr [ %535, %545 ], [ %.0469, %43 ]
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.10514, ptr %11, align 4, !tbaa !16
  store i32 %.10490, ptr %7, align 8, !tbaa !13
  %546 = load ptr, ptr %1, align 8, !tbaa !8
  %547 = ptrtoint ptr %.10502 to i64
  %548 = ptrtoint ptr %546 to i64
  %549 = sub i64 %547, %548
  %550 = load i64, ptr %40, align 8, !tbaa !24
  %551 = add i64 %549, %550
  store i64 %551, ptr %40, align 8, !tbaa !24
  store ptr %.10502, ptr %1, align 8, !tbaa !8
  store ptr %.10479, ptr %13, align 8, !tbaa !17
  %552 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef nonnull %1, i32 noundef 1) #2
  br label %569

553:                                              ; preds = %43
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.0504, ptr %11, align 4, !tbaa !16
  store i32 %.0480, ptr %7, align 8, !tbaa !13
  %554 = load ptr, ptr %1, align 8, !tbaa !8
  %555 = ptrtoint ptr %.0492 to i64
  %556 = ptrtoint ptr %554 to i64
  %557 = sub i64 %555, %556
  %558 = load i64, ptr %40, align 8, !tbaa !24
  %559 = add i64 %557, %558
  store i64 %559, ptr %40, align 8, !tbaa !24
  store ptr %.0492, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %560 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef nonnull %1, i32 noundef -3) #2
  br label %569

561:                                              ; preds = %43
  store i64 %.0516, ptr %9, align 8, !tbaa !14
  store i32 %.0504, ptr %11, align 4, !tbaa !16
  store i32 %.0480, ptr %7, align 8, !tbaa !13
  %562 = load ptr, ptr %1, align 8, !tbaa !8
  %563 = ptrtoint ptr %.0492 to i64
  %564 = ptrtoint ptr %562 to i64
  %565 = sub i64 %563, %564
  %566 = load i64, ptr %40, align 8, !tbaa !24
  %567 = add i64 %565, %566
  store i64 %567, ptr %40, align 8, !tbaa !24
  store ptr %.0492, ptr %1, align 8, !tbaa !8
  store ptr %.0469, ptr %13, align 8, !tbaa !17
  %568 = tail call i32 @inflate_flush(ptr noundef %0, ptr noundef %1, i32 noundef -2) #2
  br label %569

569:                                              ; preds = %561, %553, %.loopexit, %537, %517, %.loopexit886, %.loopexit878, %273, %.loopexit905, %.loopexit896, %157, %.loopexit914
  %.0 = phi i32 [ %568, %561 ], [ %560, %553 ], [ %552, %.loopexit ], [ %544, %537 ], [ %524, %517 ], [ %454, %.loopexit886 ], [ %314, %.loopexit878 ], [ %243, %.loopexit905 ], [ %281, %273 ], [ %198, %.loopexit896 ], [ %119, %.loopexit914 ], [ %165, %157 ]
  ret i32 %.0
}

declare i32 @inflate_fast(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #1

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

attributes #0 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { nounwind }

!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 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9, !10, i64 0}
!9 = !{!"z_stream_s", !10, i64 0, !11, i64 8, !12, i64 16, !10, i64 24, !11, i64 32, !12, i64 40, !10, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !11, i64 88, !12, i64 96, !12, i64 104}
!10 = !{!"any pointer", !6, i64 0}
!11 = !{!"int", !6, i64 0}
!12 = !{!"long", !6, i64 0}
!13 = !{!9, !11, i64 8}
!14 = !{!15, !12, i64 48}
!15 = !{!"inflate_blocks_state", !11, i64 0, !6, i64 8, !11, i64 40, !11, i64 44, !12, i64 48, !10, i64 56, !10, i64 64, !10, i64 72, !10, i64 80, !10, i64 88, !10, i64 96, !12, i64 104}
!16 = !{!15, !11, i64 44}
!17 = !{!15, !10, i64 88}
!18 = !{!15, !10, i64 80}
!19 = !{!15, !10, i64 72}
!20 = !{!21, !11, i64 0}
!21 = !{!"inflate_codes_state", !11, i64 0, !11, i64 4, !6, i64 8, !6, i64 24, !6, i64 25, !10, i64 32, !10, i64 40}
!22 = !{!21, !6, i64 24}
!23 = !{!21, !10, i64 32}
!24 = !{!9, !12, i64 16}
!25 = !{!21, !6, i64 25}
!26 = !{!21, !10, i64 40}
!27 = distinct !{!27, !28, !29}
!28 = !{!"llvm.loop.mustprogress"}
!29 = !{!"llvm.loop.peeled.count", i32 1}
!30 = !{!11, !11, i64 0}
!31 = !{!32, !11, i64 4}
!32 = !{!"inflate_huft_s", !6, i64 0, !11, i64 4}
!33 = !{!21, !11, i64 4}
!34 = !{!9, !10, i64 48}
!35 = distinct !{!35, !28, !29}
!36 = distinct !{!36, !28, !29}
!37 = distinct !{!37, !28, !29}
!38 = !{!15, !10, i64 64}
!39 = distinct !{!39, !28}
!40 = distinct !{!40, !28, !29}


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