; LLVM IR from lzfse/lzfse :: src (lzfse_decode_base)

; 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.lzfse_compressed_block_header_v1 = type { i32, i32, i32, i32, i32, i32, i32, i32, [4 x i16], i32, i16, i16, i16, [20 x i16], [20 x i16], [64 x i16], [256 x i16] }
%struct.fse_in_stream64 = type { i64, i32 }
%struct.lzvn_decoder_state = type { ptr, ptr, ptr, ptr, ptr, ptr, i64, i64, i64, i64, i32 }
%struct.lzfse_decoder_state = type { ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, %struct.lzfse_compressed_block_decoder_state, %struct.lzvn_compressed_block_decoder_state, %struct.uncompressed_block_decoder_state }
%struct.lzfse_compressed_block_decoder_state = type { i32, i32, ptr, i32, i32, i32, %struct.fse_in_stream64, i32, i16, i16, i16, [6 x i8], [64 x %struct.fse_value_decoder_entry], [64 x %struct.fse_value_decoder_entry], [256 x %struct.fse_value_decoder_entry], [1024 x i32], [40064 x i8] }
%struct.fse_value_decoder_entry = type { i8, i8, i16, i32 }
%struct.lzvn_compressed_block_decoder_state = type { i32, i32, i32 }
%struct.uncompressed_block_decoder_state = type { i32 }

@l_extra_bits = external hidden constant [20 x i8], align 16
@l_base_value = external hidden constant [20 x i32], align 16
@m_extra_bits = external hidden constant [20 x i8], align 16
@m_base_value = external hidden constant [20 x i32], align 16
@d_extra_bits = external hidden constant [64 x i8], align 16
@d_base_value = external hidden constant [64 x i32], align 16

; Function Attrs: nounwind uwtable
define dso_local i32 @lzfse_decode(ptr noundef %0) #0 {
  %2 = alloca i32, align 4
  %3 = alloca ptr, align 8
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca %struct.lzfse_compressed_block_header_v1, align 4
  %9 = alloca i64, align 8
  %10 = alloca ptr, align 8
  %11 = alloca i32, align 4
  %12 = alloca ptr, align 8
  %13 = alloca %struct.fse_in_stream64, align 8
  %14 = alloca ptr, align 8
  %15 = alloca ptr, align 8
  %16 = alloca i16, align 2
  %17 = alloca i16, align 2
  %18 = alloca i16, align 2
  %19 = alloca i16, align 2
  %20 = alloca i32, align 4
  %21 = alloca %struct.fse_in_stream64, align 8
  %22 = alloca ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca i32, align 4
  %25 = alloca i64, align 8
  %26 = alloca i64, align 8
  %27 = alloca ptr, align 8
  %28 = alloca i32, align 4
  %29 = alloca ptr, align 8
  %30 = alloca %struct.lzvn_decoder_state, align 8
  %31 = alloca i64, align 8
  %32 = alloca i64, align 8
  store ptr %0, ptr %3, align 8, !tbaa !5
  br label %33

33:                                               ; preds = %729, %1
  %34 = load ptr, ptr %3, align 8, !tbaa !5
  %35 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %34, i32 0, i32 7
  %36 = load i32, ptr %35, align 4, !tbaa !9
  switch i32 %36, label %728 [
    i32 0, label %37
    i32 762869346, label %407
    i32 829978210, label %499
    i32 846755426, label %499
    i32 1853388386, label %546
  ]

37:                                               ; preds = %33
  %38 = load ptr, ptr %3, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %38, i32 0, i32 0
  %40 = load ptr, ptr %39, align 8, !tbaa !18
  %41 = getelementptr inbounds i8, ptr %40, i64 4
  %42 = load ptr, ptr %3, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %42, i32 0, i32 2
  %44 = load ptr, ptr %43, align 8, !tbaa !19
  %45 = icmp ugt ptr %41, %44
  br i1 %45, label %46, label %47

46:                                               ; preds = %37
  store i32 -1, ptr %2, align 4
  br label %730

47:                                               ; preds = %37
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #7
  %48 = load ptr, ptr %3, align 8, !tbaa !5
  %49 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %48, i32 0, i32 0
  %50 = load ptr, ptr %49, align 8, !tbaa !18
  %51 = call i32 @load4(ptr noundef %50)
  store i32 %51, ptr %4, align 4, !tbaa !20
  %52 = load i32, ptr %4, align 4, !tbaa !20
  %53 = icmp eq i32 %52, 611874402
  br i1 %53, label %54, label %61

54:                                               ; preds = %47
  %55 = load ptr, ptr %3, align 8, !tbaa !5
  %56 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %55, i32 0, i32 0
  %57 = load ptr, ptr %56, align 8, !tbaa !18
  %58 = getelementptr inbounds i8, ptr %57, i64 4
  store ptr %58, ptr %56, align 8, !tbaa !18
  %59 = load ptr, ptr %3, align 8, !tbaa !5
  %60 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %59, i32 0, i32 6
  store i32 1, ptr %60, align 8, !tbaa !21
  store i32 0, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %405

61:                                               ; preds = %47
  %62 = load i32, ptr %4, align 4, !tbaa !20
  %63 = icmp eq i32 %62, 762869346
  br i1 %63, label %64, label %91

64:                                               ; preds = %61
  %65 = load ptr, ptr %3, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %65, i32 0, i32 0
  %67 = load ptr, ptr %66, align 8, !tbaa !18
  %68 = getelementptr inbounds i8, ptr %67, i64 8
  %69 = load ptr, ptr %3, align 8, !tbaa !5
  %70 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %69, i32 0, i32 2
  %71 = load ptr, ptr %70, align 8, !tbaa !19
  %72 = icmp ugt ptr %68, %71
  br i1 %72, label %73, label %74

73:                                               ; preds = %64
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %405

74:                                               ; preds = %64
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #7
  %75 = load ptr, ptr %3, align 8, !tbaa !5
  %76 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %75, i32 0, i32 10
  store ptr %76, ptr %6, align 8, !tbaa !5
  %77 = load ptr, ptr %3, align 8, !tbaa !5
  %78 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %77, i32 0, i32 0
  %79 = load ptr, ptr %78, align 8, !tbaa !18
  %80 = getelementptr inbounds i8, ptr %79, i64 4
  %81 = call i32 @load4(ptr noundef %80)
  %82 = load ptr, ptr %6, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.uncompressed_block_decoder_state, ptr %82, i32 0, i32 0
  store i32 %81, ptr %83, align 4, !tbaa !22
  %84 = load ptr, ptr %3, align 8, !tbaa !5
  %85 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %84, i32 0, i32 0
  %86 = load ptr, ptr %85, align 8, !tbaa !18
  %87 = getelementptr inbounds i8, ptr %86, i64 8
  store ptr %87, ptr %85, align 8, !tbaa !18
  %88 = load i32, ptr %4, align 4, !tbaa !20
  %89 = load ptr, ptr %3, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %89, i32 0, i32 7
  store i32 %88, ptr %90, align 4, !tbaa !9
  store i32 4, ptr %5, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #7
  br label %405

91:                                               ; preds = %61
  %92 = load i32, ptr %4, align 4, !tbaa !20
  %93 = icmp eq i32 %92, 1853388386
  br i1 %93, label %94, label %130

94:                                               ; preds = %91
  %95 = load ptr, ptr %3, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %95, i32 0, i32 0
  %97 = load ptr, ptr %96, align 8, !tbaa !18
  %98 = getelementptr inbounds i8, ptr %97, i64 12
  %99 = load ptr, ptr %3, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %99, i32 0, i32 2
  %101 = load ptr, ptr %100, align 8, !tbaa !19
  %102 = icmp ugt ptr %98, %101
  br i1 %102, label %103, label %104

103:                                              ; preds = %94
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %405

104:                                              ; preds = %94
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #7
  %105 = load ptr, ptr %3, align 8, !tbaa !5
  %106 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %105, i32 0, i32 9
  store ptr %106, ptr %7, align 8, !tbaa !5
  %107 = load ptr, ptr %3, align 8, !tbaa !5
  %108 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %107, i32 0, i32 0
  %109 = load ptr, ptr %108, align 8, !tbaa !18
  %110 = getelementptr inbounds i8, ptr %109, i64 4
  %111 = call i32 @load4(ptr noundef %110)
  %112 = load ptr, ptr %7, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %112, i32 0, i32 0
  store i32 %111, ptr %113, align 4, !tbaa !23
  %114 = load ptr, ptr %3, align 8, !tbaa !5
  %115 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %114, i32 0, i32 0
  %116 = load ptr, ptr %115, align 8, !tbaa !18
  %117 = getelementptr inbounds i8, ptr %116, i64 8
  %118 = call i32 @load4(ptr noundef %117)
  %119 = load ptr, ptr %7, align 8, !tbaa !5
  %120 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %119, i32 0, i32 1
  store i32 %118, ptr %120, align 4, !tbaa !24
  %121 = load ptr, ptr %7, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %121, i32 0, i32 2
  store i32 0, ptr %122, align 4, !tbaa !25
  %123 = load ptr, ptr %3, align 8, !tbaa !5
  %124 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %123, i32 0, i32 0
  %125 = load ptr, ptr %124, align 8, !tbaa !18
  %126 = getelementptr inbounds i8, ptr %125, i64 12
  store ptr %126, ptr %124, align 8, !tbaa !18
  %127 = load i32, ptr %4, align 4, !tbaa !20
  %128 = load ptr, ptr %3, align 8, !tbaa !5
  %129 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %128, i32 0, i32 7
  store i32 %127, ptr %129, align 4, !tbaa !9
  store i32 4, ptr %5, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #7
  br label %405

130:                                              ; preds = %91
  %131 = load i32, ptr %4, align 4, !tbaa !20
  %132 = icmp eq i32 %131, 829978210
  br i1 %132, label %136, label %133

133:                                              ; preds = %130
  %134 = load i32, ptr %4, align 4, !tbaa !20
  %135 = icmp eq i32 %134, 846755426
  br i1 %135, label %136, label %404

136:                                              ; preds = %133, %130
  call void @llvm.lifetime.start.p0(i64 772, ptr %8) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #7
  store i64 0, ptr %9, align 8, !tbaa !26
  %137 = load i32, ptr %4, align 4, !tbaa !20
  %138 = icmp eq i32 %137, 846755426
  br i1 %138, label %139, label %177

139:                                              ; preds = %136
  %140 = load ptr, ptr %3, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %140, i32 0, i32 0
  %142 = load ptr, ptr %141, align 8, !tbaa !18
  %143 = getelementptr inbounds i8, ptr %142, i64 32
  %144 = load ptr, ptr %3, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %144, i32 0, i32 2
  %146 = load ptr, ptr %145, align 8, !tbaa !19
  %147 = icmp ugt ptr %143, %146
  br i1 %147, label %148, label %149

148:                                              ; preds = %139
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %403

149:                                              ; preds = %139
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #7
  %150 = load ptr, ptr %3, align 8, !tbaa !5
  %151 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %150, i32 0, i32 0
  %152 = load ptr, ptr %151, align 8, !tbaa !18
  store ptr %152, ptr %10, align 8, !tbaa !5
  %153 = load ptr, ptr %10, align 8, !tbaa !5
  %154 = call i32 @lzfse_decode_v2_header_size(ptr noundef %153)
  %155 = zext i32 %154 to i64
  store i64 %155, ptr %9, align 8, !tbaa !26
  %156 = load ptr, ptr %3, align 8, !tbaa !5
  %157 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %156, i32 0, i32 0
  %158 = load ptr, ptr %157, align 8, !tbaa !18
  %159 = load i64, ptr %9, align 8, !tbaa !26
  %160 = getelementptr inbounds i8, ptr %158, i64 %159
  %161 = load ptr, ptr %3, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %161, i32 0, i32 2
  %163 = load ptr, ptr %162, align 8, !tbaa !19
  %164 = icmp ugt ptr %160, %163
  br i1 %164, label %165, label %166

165:                                              ; preds = %149
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %174

166:                                              ; preds = %149
  call void @llvm.lifetime.start.p0(i64 4, ptr %11) #7
  %167 = load ptr, ptr %10, align 8, !tbaa !5
  %168 = call i32 @lzfse_decode_v1(ptr noundef %8, ptr noundef %167)
  store i32 %168, ptr %11, align 4, !tbaa !20
  %169 = load i32, ptr %11, align 4, !tbaa !20
  %170 = icmp ne i32 %169, 0
  br i1 %170, label %171, label %172

171:                                              ; preds = %166
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %173

172:                                              ; preds = %166
  store i32 0, ptr %5, align 4
  br label %173

173:                                              ; preds = %172, %171
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #7
  br label %174

174:                                              ; preds = %173, %165
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #7
  %175 = load i32, ptr %5, align 4
  switch i32 %175, label %403 [
    i32 0, label %176
  ]

176:                                              ; preds = %174
  br label %191

177:                                              ; preds = %136
  %178 = load ptr, ptr %3, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %178, i32 0, i32 0
  %180 = load ptr, ptr %179, align 8, !tbaa !18
  %181 = getelementptr inbounds i8, ptr %180, i64 772
  %182 = load ptr, ptr %3, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %182, i32 0, i32 2
  %184 = load ptr, ptr %183, align 8, !tbaa !19
  %185 = icmp ugt ptr %181, %184
  br i1 %185, label %186, label %187

186:                                              ; preds = %177
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %403

187:                                              ; preds = %177
  %188 = load ptr, ptr %3, align 8, !tbaa !5
  %189 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %188, i32 0, i32 0
  %190 = load ptr, ptr %189, align 8, !tbaa !18
  call void @llvm.memcpy.p0.p0.i64(ptr align 4 %8, ptr align 1 %190, i64 772, i1 false)
  store i64 772, ptr %9, align 8, !tbaa !26
  br label %191

191:                                              ; preds = %187, %176
  %192 = load ptr, ptr %3, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %192, i32 0, i32 0
  %194 = load ptr, ptr %193, align 8, !tbaa !18
  %195 = load i64, ptr %9, align 8, !tbaa !26
  %196 = getelementptr inbounds i8, ptr %194, i64 %195
  %197 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 5
  %198 = load i32, ptr %197, align 4, !tbaa !27
  %199 = zext i32 %198 to i64
  %200 = getelementptr inbounds i8, ptr %196, i64 %199
  %201 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 6
  %202 = load i32, ptr %201, align 4, !tbaa !29
  %203 = zext i32 %202 to i64
  %204 = getelementptr inbounds i8, ptr %200, i64 %203
  %205 = load ptr, ptr %3, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %205, i32 0, i32 2
  %207 = load ptr, ptr %206, align 8, !tbaa !19
  %208 = icmp ugt ptr %204, %207
  br i1 %208, label %209, label %210

209:                                              ; preds = %191
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %403

210:                                              ; preds = %191
  %211 = call i32 @lzfse_check_block_header_v1(ptr noundef %8)
  %212 = icmp ne i32 %211, 0
  br i1 %212, label %213, label %214

213:                                              ; preds = %210
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %403

214:                                              ; preds = %210
  %215 = load i64, ptr %9, align 8, !tbaa !26
  %216 = load ptr, ptr %3, align 8, !tbaa !5
  %217 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %216, i32 0, i32 0
  %218 = load ptr, ptr %217, align 8, !tbaa !18
  %219 = getelementptr inbounds i8, ptr %218, i64 %215
  store ptr %219, ptr %217, align 8, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #7
  %220 = load ptr, ptr %3, align 8, !tbaa !5
  %221 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %220, i32 0, i32 8
  store ptr %221, ptr %12, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 6
  %223 = load i32, ptr %222, align 4, !tbaa !29
  %224 = load ptr, ptr %12, align 8, !tbaa !5
  %225 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %224, i32 0, i32 1
  store i32 %223, ptr %225, align 4, !tbaa !30
  %226 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 4
  %227 = load i32, ptr %226, align 4, !tbaa !31
  %228 = load ptr, ptr %12, align 8, !tbaa !5
  %229 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %228, i32 0, i32 0
  store i32 %227, ptr %229, align 8, !tbaa !32
  %230 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 16
  %231 = getelementptr inbounds [256 x i16], ptr %230, i64 0, i64 0
  %232 = load ptr, ptr %12, align 8, !tbaa !5
  %233 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %232, i32 0, i32 15
  %234 = getelementptr inbounds [1024 x i32], ptr %233, i64 0, i64 0
  %235 = call i32 @fse_init_decoder_table(i32 noundef 1024, i32 noundef 256, ptr noundef %231, ptr noundef %234)
  %236 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 13
  %237 = getelementptr inbounds [20 x i16], ptr %236, i64 0, i64 0
  %238 = load ptr, ptr %12, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %238, i32 0, i32 12
  %240 = getelementptr inbounds [64 x %struct.fse_value_decoder_entry], ptr %239, i64 0, i64 0
  call void @fse_init_value_decoder_table(i32 noundef 64, i32 noundef 20, ptr noundef %237, ptr noundef @l_extra_bits, ptr noundef @l_base_value, ptr noundef %240)
  %241 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 14
  %242 = getelementptr inbounds [20 x i16], ptr %241, i64 0, i64 0
  %243 = load ptr, ptr %12, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %243, i32 0, i32 13
  %245 = getelementptr inbounds [64 x %struct.fse_value_decoder_entry], ptr %244, i64 0, i64 0
  call void @fse_init_value_decoder_table(i32 noundef 64, i32 noundef 20, ptr noundef %242, ptr noundef @m_extra_bits, ptr noundef @m_base_value, ptr noundef %245)
  %246 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 15
  %247 = getelementptr inbounds [64 x i16], ptr %246, i64 0, i64 0
  %248 = load ptr, ptr %12, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %248, i32 0, i32 14
  %250 = getelementptr inbounds [256 x %struct.fse_value_decoder_entry], ptr %249, i64 0, i64 0
  call void @fse_init_value_decoder_table(i32 noundef 256, i32 noundef 64, ptr noundef %247, ptr noundef @d_extra_bits, ptr noundef @d_base_value, ptr noundef %250)
  call void @llvm.lifetime.start.p0(i64 16, ptr %13) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #7
  %251 = load ptr, ptr %3, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %251, i32 0, i32 1
  %253 = load ptr, ptr %252, align 8, !tbaa !33
  store ptr %253, ptr %14, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 5
  %255 = load i32, ptr %254, align 4, !tbaa !27
  %256 = load ptr, ptr %3, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %256, i32 0, i32 0
  %258 = load ptr, ptr %257, align 8, !tbaa !18
  %259 = zext i32 %255 to i64
  %260 = getelementptr inbounds i8, ptr %258, i64 %259
  store ptr %260, ptr %257, align 8, !tbaa !18
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #7
  %261 = load ptr, ptr %3, align 8, !tbaa !5
  %262 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %261, i32 0, i32 0
  %263 = load ptr, ptr %262, align 8, !tbaa !18
  store ptr %263, ptr %15, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 7
  %265 = load i32, ptr %264, align 4, !tbaa !34
  %266 = load ptr, ptr %14, align 8, !tbaa !5
  %267 = call i32 @fse_in_checked_init64(ptr noundef %13, i32 noundef %265, ptr noundef %15, ptr noundef %266)
  %268 = icmp ne i32 %267, 0
  br i1 %268, label %269, label %270

269:                                              ; preds = %214
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %347

270:                                              ; preds = %214
  call void @llvm.lifetime.start.p0(i64 2, ptr %16) #7
  %271 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 8
  %272 = getelementptr inbounds [4 x i16], ptr %271, i64 0, i64 0
  %273 = load i16, ptr %272, align 4, !tbaa !35
  store i16 %273, ptr %16, align 2, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 2, ptr %17) #7
  %274 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 8
  %275 = getelementptr inbounds [4 x i16], ptr %274, i64 0, i64 1
  %276 = load i16, ptr %275, align 2, !tbaa !35
  store i16 %276, ptr %17, align 2, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 2, ptr %18) #7
  %277 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 8
  %278 = getelementptr inbounds [4 x i16], ptr %277, i64 0, i64 2
  %279 = load i16, ptr %278, align 4, !tbaa !35
  store i16 %279, ptr %18, align 2, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 2, ptr %19) #7
  %280 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 8
  %281 = getelementptr inbounds [4 x i16], ptr %280, i64 0, i64 3
  %282 = load i16, ptr %281, align 2, !tbaa !35
  store i16 %282, ptr %19, align 2, !tbaa !35
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #7
  store i32 0, ptr %20, align 4, !tbaa !20
  br label %283

283:                                              ; preds = %335, %270
  %284 = load i32, ptr %20, align 4, !tbaa !20
  %285 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 3
  %286 = load i32, ptr %285, align 4, !tbaa !36
  %287 = icmp ult i32 %284, %286
  br i1 %287, label %289, label %288

288:                                              ; preds = %283
  store i32 5, ptr %5, align 4
  br label %338

289:                                              ; preds = %283
  %290 = load ptr, ptr %14, align 8, !tbaa !5
  %291 = call i32 @fse_in_checked_flush64(ptr noundef %13, ptr noundef %15, ptr noundef %290)
  %292 = icmp ne i32 %291, 0
  br i1 %292, label %293, label %294

293:                                              ; preds = %289
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %338

294:                                              ; preds = %289
  %295 = load ptr, ptr %12, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %295, i32 0, i32 15
  %297 = getelementptr inbounds [1024 x i32], ptr %296, i64 0, i64 0
  %298 = call zeroext i8 @fse_decode(ptr noundef %16, ptr noundef %297, ptr noundef %13)
  %299 = load ptr, ptr %12, align 8, !tbaa !5
  %300 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %299, i32 0, i32 16
  %301 = load i32, ptr %20, align 4, !tbaa !20
  %302 = add i32 %301, 0
  %303 = zext i32 %302 to i64
  %304 = getelementptr inbounds [40064 x i8], ptr %300, i64 0, i64 %303
  store i8 %298, ptr %304, align 1, !tbaa !37
  %305 = load ptr, ptr %12, align 8, !tbaa !5
  %306 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %305, i32 0, i32 15
  %307 = getelementptr inbounds [1024 x i32], ptr %306, i64 0, i64 0
  %308 = call zeroext i8 @fse_decode(ptr noundef %17, ptr noundef %307, ptr noundef %13)
  %309 = load ptr, ptr %12, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %309, i32 0, i32 16
  %311 = load i32, ptr %20, align 4, !tbaa !20
  %312 = add i32 %311, 1
  %313 = zext i32 %312 to i64
  %314 = getelementptr inbounds [40064 x i8], ptr %310, i64 0, i64 %313
  store i8 %308, ptr %314, align 1, !tbaa !37
  %315 = load ptr, ptr %12, align 8, !tbaa !5
  %316 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %315, i32 0, i32 15
  %317 = getelementptr inbounds [1024 x i32], ptr %316, i64 0, i64 0
  %318 = call zeroext i8 @fse_decode(ptr noundef %18, ptr noundef %317, ptr noundef %13)
  %319 = load ptr, ptr %12, align 8, !tbaa !5
  %320 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %319, i32 0, i32 16
  %321 = load i32, ptr %20, align 4, !tbaa !20
  %322 = add i32 %321, 2
  %323 = zext i32 %322 to i64
  %324 = getelementptr inbounds [40064 x i8], ptr %320, i64 0, i64 %323
  store i8 %318, ptr %324, align 1, !tbaa !37
  %325 = load ptr, ptr %12, align 8, !tbaa !5
  %326 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %325, i32 0, i32 15
  %327 = getelementptr inbounds [1024 x i32], ptr %326, i64 0, i64 0
  %328 = call zeroext i8 @fse_decode(ptr noundef %19, ptr noundef %327, ptr noundef %13)
  %329 = load ptr, ptr %12, align 8, !tbaa !5
  %330 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %329, i32 0, i32 16
  %331 = load i32, ptr %20, align 4, !tbaa !20
  %332 = add i32 %331, 3
  %333 = zext i32 %332 to i64
  %334 = getelementptr inbounds [40064 x i8], ptr %330, i64 0, i64 %333
  store i8 %328, ptr %334, align 1, !tbaa !37
  br label %335

335:                                              ; preds = %294
  %336 = load i32, ptr %20, align 4, !tbaa !20
  %337 = add i32 %336, 4
  store i32 %337, ptr %20, align 4, !tbaa !20
  br label %283, !llvm.loop !38

338:                                              ; preds = %293, %288
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #7
  %339 = load i32, ptr %5, align 4
  switch i32 %339, label %346 [
    i32 5, label %340
  ]

340:                                              ; preds = %338
  %341 = load ptr, ptr %12, align 8, !tbaa !5
  %342 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %341, i32 0, i32 16
  %343 = getelementptr inbounds [40064 x i8], ptr %342, i64 0, i64 0
  %344 = load ptr, ptr %12, align 8, !tbaa !5
  %345 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %344, i32 0, i32 2
  store ptr %343, ptr %345, align 8, !tbaa !40
  store i32 0, ptr %5, align 4
  br label %346

346:                                              ; preds = %340, %338
  call void @llvm.lifetime.end.p0(i64 2, ptr %19) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr %18) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr %17) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr %16) #7
  br label %347

347:                                              ; preds = %346, %269
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %13) #7
  %348 = load i32, ptr %5, align 4
  switch i32 %348, label %402 [
    i32 0, label %349
  ]

349:                                              ; preds = %347
  call void @llvm.lifetime.start.p0(i64 16, ptr %21) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #7
  %350 = load ptr, ptr %3, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %350, i32 0, i32 0
  %352 = load ptr, ptr %351, align 8, !tbaa !18
  %353 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 6
  %354 = load i32, ptr %353, align 4, !tbaa !29
  %355 = zext i32 %354 to i64
  %356 = getelementptr inbounds i8, ptr %352, i64 %355
  store ptr %356, ptr %22, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 9
  %358 = load i32, ptr %357, align 4, !tbaa !41
  %359 = load ptr, ptr %3, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %359, i32 0, i32 0
  %361 = load ptr, ptr %360, align 8, !tbaa !18
  %362 = call i32 @fse_in_checked_init64(ptr noundef %21, i32 noundef %358, ptr noundef %22, ptr noundef %361)
  %363 = icmp ne i32 %362, 0
  br i1 %363, label %364, label %365

364:                                              ; preds = %349
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %396

365:                                              ; preds = %349
  %366 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 10
  %367 = load i16, ptr %366, align 4, !tbaa !42
  %368 = load ptr, ptr %12, align 8, !tbaa !5
  %369 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %368, i32 0, i32 8
  store i16 %367, ptr %369, align 4, !tbaa !43
  %370 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 11
  %371 = load i16, ptr %370, align 2, !tbaa !44
  %372 = load ptr, ptr %12, align 8, !tbaa !5
  %373 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %372, i32 0, i32 9
  store i16 %371, ptr %373, align 2, !tbaa !45
  %374 = getelementptr inbounds %struct.lzfse_compressed_block_header_v1, ptr %8, i32 0, i32 12
  %375 = load i16, ptr %374, align 4, !tbaa !46
  %376 = load ptr, ptr %12, align 8, !tbaa !5
  %377 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %376, i32 0, i32 10
  store i16 %375, ptr %377, align 8, !tbaa !47
  %378 = load ptr, ptr %22, align 8, !tbaa !5
  %379 = load ptr, ptr %3, align 8, !tbaa !5
  %380 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %379, i32 0, i32 0
  %381 = load ptr, ptr %380, align 8, !tbaa !18
  %382 = ptrtoint ptr %378 to i64
  %383 = ptrtoint ptr %381 to i64
  %384 = sub i64 %382, %383
  %385 = trunc i64 %384 to i32
  %386 = load ptr, ptr %12, align 8, !tbaa !5
  %387 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %386, i32 0, i32 7
  store i32 %385, ptr %387, align 8, !tbaa !48
  %388 = load ptr, ptr %12, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %388, i32 0, i32 4
  store i32 0, ptr %389, align 4, !tbaa !49
  %390 = load ptr, ptr %12, align 8, !tbaa !5
  %391 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %390, i32 0, i32 3
  store i32 0, ptr %391, align 8, !tbaa !50
  %392 = load ptr, ptr %12, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %392, i32 0, i32 5
  store i32 -1, ptr %393, align 8, !tbaa !51
  %394 = load ptr, ptr %12, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %394, i32 0, i32 6
  call void @llvm.memcpy.p0.p0.i64(ptr align 8 %395, ptr align 8 %21, i64 16, i1 false), !tbaa.struct !52
  store i32 0, ptr %5, align 4
  br label %396

396:                                              ; preds = %365, %364
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr %21) #7
  %397 = load i32, ptr %5, align 4
  switch i32 %397, label %402 [
    i32 0, label %398
  ]

398:                                              ; preds = %396
  %399 = load i32, ptr %4, align 4, !tbaa !20
  %400 = load ptr, ptr %3, align 8, !tbaa !5
  %401 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %400, i32 0, i32 7
  store i32 %399, ptr %401, align 4, !tbaa !9
  store i32 4, ptr %5, align 4
  br label %402

402:                                              ; preds = %398, %396, %347
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #7
  br label %403

403:                                              ; preds = %402, %213, %209, %186, %174, %148
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #7
  call void @llvm.lifetime.end.p0(i64 772, ptr %8) #7
  br label %405

404:                                              ; preds = %133
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %405

405:                                              ; preds = %404, %403, %104, %103, %74, %73, %54
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #7
  %406 = load i32, ptr %5, align 4
  switch i32 %406, label %732 [
    i32 1, label %730
    i32 4, label %729
  ]

407:                                              ; preds = %33
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #7
  %408 = load ptr, ptr %3, align 8, !tbaa !5
  %409 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %408, i32 0, i32 10
  store ptr %409, ptr %23, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #7
  %410 = load ptr, ptr %23, align 8, !tbaa !5
  %411 = getelementptr inbounds %struct.uncompressed_block_decoder_state, ptr %410, i32 0, i32 0
  %412 = load i32, ptr %411, align 4, !tbaa !22
  store i32 %412, ptr %24, align 4, !tbaa !20
  %413 = load i32, ptr %24, align 4, !tbaa !20
  %414 = icmp eq i32 %413, 0
  br i1 %414, label %415, label %418

415:                                              ; preds = %407
  %416 = load ptr, ptr %3, align 8, !tbaa !5
  %417 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %416, i32 0, i32 7
  store i32 0, ptr %417, align 4, !tbaa !9
  store i32 4, ptr %5, align 4
  br label %497

418:                                              ; preds = %407
  %419 = load ptr, ptr %3, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %419, i32 0, i32 2
  %421 = load ptr, ptr %420, align 8, !tbaa !19
  %422 = load ptr, ptr %3, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %422, i32 0, i32 0
  %424 = load ptr, ptr %423, align 8, !tbaa !18
  %425 = icmp ule ptr %421, %424
  br i1 %425, label %426, label %427

426:                                              ; preds = %418
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %497

427:                                              ; preds = %418
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #7
  %428 = load ptr, ptr %3, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %428, i32 0, i32 2
  %430 = load ptr, ptr %429, align 8, !tbaa !19
  %431 = load ptr, ptr %3, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %431, i32 0, i32 0
  %433 = load ptr, ptr %432, align 8, !tbaa !18
  %434 = ptrtoint ptr %430 to i64
  %435 = ptrtoint ptr %433 to i64
  %436 = sub i64 %434, %435
  store i64 %436, ptr %25, align 8, !tbaa !26
  %437 = load i32, ptr %24, align 4, !tbaa !20
  %438 = zext i32 %437 to i64
  %439 = load i64, ptr %25, align 8, !tbaa !26
  %440 = icmp ugt i64 %438, %439
  br i1 %440, label %441, label %444

441:                                              ; preds = %427
  %442 = load i64, ptr %25, align 8, !tbaa !26
  %443 = trunc i64 %442 to i32
  store i32 %443, ptr %24, align 4, !tbaa !20
  br label %444

444:                                              ; preds = %441, %427
  %445 = load ptr, ptr %3, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %445, i32 0, i32 5
  %447 = load ptr, ptr %446, align 8, !tbaa !53
  %448 = load ptr, ptr %3, align 8, !tbaa !5
  %449 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %448, i32 0, i32 3
  %450 = load ptr, ptr %449, align 8, !tbaa !54
  %451 = icmp ule ptr %447, %450
  br i1 %451, label %452, label %453

452:                                              ; preds = %444
  store i32 -2, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %496

453:                                              ; preds = %444
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #7
  %454 = load ptr, ptr %3, align 8, !tbaa !5
  %455 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %454, i32 0, i32 5
  %456 = load ptr, ptr %455, align 8, !tbaa !53
  %457 = load ptr, ptr %3, align 8, !tbaa !5
  %458 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %457, i32 0, i32 3
  %459 = load ptr, ptr %458, align 8, !tbaa !54
  %460 = ptrtoint ptr %456 to i64
  %461 = ptrtoint ptr %459 to i64
  %462 = sub i64 %460, %461
  store i64 %462, ptr %26, align 8, !tbaa !26
  %463 = load i32, ptr %24, align 4, !tbaa !20
  %464 = zext i32 %463 to i64
  %465 = load i64, ptr %26, align 8, !tbaa !26
  %466 = icmp ugt i64 %464, %465
  br i1 %466, label %467, label %470

467:                                              ; preds = %453
  %468 = load i64, ptr %26, align 8, !tbaa !26
  %469 = trunc i64 %468 to i32
  store i32 %469, ptr %24, align 4, !tbaa !20
  br label %470

470:                                              ; preds = %467, %453
  %471 = load ptr, ptr %3, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %471, i32 0, i32 3
  %473 = load ptr, ptr %472, align 8, !tbaa !54
  %474 = load ptr, ptr %3, align 8, !tbaa !5
  %475 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %474, i32 0, i32 0
  %476 = load ptr, ptr %475, align 8, !tbaa !18
  %477 = load i32, ptr %24, align 4, !tbaa !20
  %478 = zext i32 %477 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %473, ptr align 1 %476, i64 %478, i1 false)
  %479 = load i32, ptr %24, align 4, !tbaa !20
  %480 = load ptr, ptr %3, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %480, i32 0, i32 0
  %482 = load ptr, ptr %481, align 8, !tbaa !18
  %483 = zext i32 %479 to i64
  %484 = getelementptr inbounds i8, ptr %482, i64 %483
  store ptr %484, ptr %481, align 8, !tbaa !18
  %485 = load i32, ptr %24, align 4, !tbaa !20
  %486 = load ptr, ptr %3, align 8, !tbaa !5
  %487 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %486, i32 0, i32 3
  %488 = load ptr, ptr %487, align 8, !tbaa !54
  %489 = zext i32 %485 to i64
  %490 = getelementptr inbounds i8, ptr %488, i64 %489
  store ptr %490, ptr %487, align 8, !tbaa !54
  %491 = load i32, ptr %24, align 4, !tbaa !20
  %492 = load ptr, ptr %23, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.uncompressed_block_decoder_state, ptr %492, i32 0, i32 0
  %494 = load i32, ptr %493, align 4, !tbaa !22
  %495 = sub i32 %494, %491
  store i32 %495, ptr %493, align 4, !tbaa !22
  store i32 4, ptr %5, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #7
  br label %496

496:                                              ; preds = %470, %452
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #7
  br label %497

497:                                              ; preds = %496, %426, %415
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #7
  %498 = load i32, ptr %5, align 4
  switch i32 %498, label %732 [
    i32 4, label %729
    i32 1, label %730
  ]

499:                                              ; preds = %33, %33
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #7
  %500 = load ptr, ptr %3, align 8, !tbaa !5
  %501 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %500, i32 0, i32 8
  store ptr %501, ptr %27, align 8, !tbaa !5
  %502 = load ptr, ptr %3, align 8, !tbaa !5
  %503 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %502, i32 0, i32 2
  %504 = load ptr, ptr %503, align 8, !tbaa !19
  %505 = load ptr, ptr %3, align 8, !tbaa !5
  %506 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %505, i32 0, i32 0
  %507 = load ptr, ptr %506, align 8, !tbaa !18
  %508 = icmp ule ptr %504, %507
  br i1 %508, label %524, label %509

509:                                              ; preds = %499
  %510 = load ptr, ptr %27, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %510, i32 0, i32 1
  %512 = load i32, ptr %511, align 4, !tbaa !30
  %513 = zext i32 %512 to i64
  %514 = load ptr, ptr %3, align 8, !tbaa !5
  %515 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %514, i32 0, i32 2
  %516 = load ptr, ptr %515, align 8, !tbaa !19
  %517 = load ptr, ptr %3, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %517, i32 0, i32 0
  %519 = load ptr, ptr %518, align 8, !tbaa !18
  %520 = ptrtoint ptr %516 to i64
  %521 = ptrtoint ptr %519 to i64
  %522 = sub i64 %520, %521
  %523 = icmp ugt i64 %513, %522
  br i1 %523, label %524, label %525

524:                                              ; preds = %509, %499
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %544

525:                                              ; preds = %509
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #7
  %526 = load ptr, ptr %3, align 8, !tbaa !5
  %527 = call i32 @lzfse_decode_lmd(ptr noundef %526)
  store i32 %527, ptr %28, align 4, !tbaa !20
  %528 = load i32, ptr %28, align 4, !tbaa !20
  %529 = icmp ne i32 %528, 0
  br i1 %529, label %530, label %532

530:                                              ; preds = %525
  %531 = load i32, ptr %28, align 4, !tbaa !20
  store i32 %531, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %543

532:                                              ; preds = %525
  %533 = load ptr, ptr %3, align 8, !tbaa !5
  %534 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %533, i32 0, i32 7
  store i32 0, ptr %534, align 4, !tbaa !9
  %535 = load ptr, ptr %27, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.lzfse_compressed_block_decoder_state, ptr %535, i32 0, i32 1
  %537 = load i32, ptr %536, align 4, !tbaa !30
  %538 = load ptr, ptr %3, align 8, !tbaa !5
  %539 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %538, i32 0, i32 0
  %540 = load ptr, ptr %539, align 8, !tbaa !18
  %541 = zext i32 %537 to i64
  %542 = getelementptr inbounds i8, ptr %540, i64 %541
  store ptr %542, ptr %539, align 8, !tbaa !18
  store i32 4, ptr %5, align 4
  br label %543

543:                                              ; preds = %532, %530
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #7
  br label %544

544:                                              ; preds = %543, %524
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #7
  %545 = load i32, ptr %5, align 4
  switch i32 %545, label %732 [
    i32 1, label %730
    i32 4, label %729
  ]

546:                                              ; preds = %33
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #7
  %547 = load ptr, ptr %3, align 8, !tbaa !5
  %548 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %547, i32 0, i32 9
  store ptr %548, ptr %29, align 8, !tbaa !5
  %549 = load ptr, ptr %29, align 8, !tbaa !5
  %550 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %549, i32 0, i32 1
  %551 = load i32, ptr %550, align 4, !tbaa !24
  %552 = icmp ugt i32 %551, 0
  br i1 %552, label %553, label %562

553:                                              ; preds = %546
  %554 = load ptr, ptr %3, align 8, !tbaa !5
  %555 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %554, i32 0, i32 2
  %556 = load ptr, ptr %555, align 8, !tbaa !19
  %557 = load ptr, ptr %3, align 8, !tbaa !5
  %558 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %557, i32 0, i32 0
  %559 = load ptr, ptr %558, align 8, !tbaa !18
  %560 = icmp ule ptr %556, %559
  br i1 %560, label %561, label %562

561:                                              ; preds = %553
  store i32 -1, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %726

562:                                              ; preds = %553, %546
  call void @llvm.lifetime.start.p0(i64 88, ptr %30) #7
  call void @llvm.memset.p0.i64(ptr align 8 %30, i8 0, i64 88, i1 false)
  %563 = load ptr, ptr %3, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %563, i32 0, i32 0
  %565 = load ptr, ptr %564, align 8, !tbaa !18
  %566 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 0
  store ptr %565, ptr %566, align 8, !tbaa !55
  %567 = load ptr, ptr %3, align 8, !tbaa !5
  %568 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %567, i32 0, i32 2
  %569 = load ptr, ptr %568, align 8, !tbaa !19
  %570 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 1
  store ptr %569, ptr %570, align 8, !tbaa !57
  %571 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 1
  %572 = load ptr, ptr %571, align 8, !tbaa !57
  %573 = load ptr, ptr %3, align 8, !tbaa !5
  %574 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %573, i32 0, i32 0
  %575 = load ptr, ptr %574, align 8, !tbaa !18
  %576 = ptrtoint ptr %572 to i64
  %577 = ptrtoint ptr %575 to i64
  %578 = sub i64 %576, %577
  %579 = load ptr, ptr %29, align 8, !tbaa !5
  %580 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %579, i32 0, i32 1
  %581 = load i32, ptr %580, align 4, !tbaa !24
  %582 = zext i32 %581 to i64
  %583 = icmp sgt i64 %578, %582
  br i1 %583, label %584, label %594

584:                                              ; preds = %562
  %585 = load ptr, ptr %3, align 8, !tbaa !5
  %586 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %585, i32 0, i32 0
  %587 = load ptr, ptr %586, align 8, !tbaa !18
  %588 = load ptr, ptr %29, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %588, i32 0, i32 1
  %590 = load i32, ptr %589, align 4, !tbaa !24
  %591 = zext i32 %590 to i64
  %592 = getelementptr inbounds i8, ptr %587, i64 %591
  %593 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 1
  store ptr %592, ptr %593, align 8, !tbaa !57
  br label %594

594:                                              ; preds = %584, %562
  %595 = load ptr, ptr %3, align 8, !tbaa !5
  %596 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %595, i32 0, i32 4
  %597 = load ptr, ptr %596, align 8, !tbaa !58
  %598 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 3
  store ptr %597, ptr %598, align 8, !tbaa !59
  %599 = load ptr, ptr %3, align 8, !tbaa !5
  %600 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %599, i32 0, i32 3
  %601 = load ptr, ptr %600, align 8, !tbaa !54
  %602 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 2
  store ptr %601, ptr %602, align 8, !tbaa !60
  %603 = load ptr, ptr %3, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %603, i32 0, i32 5
  %605 = load ptr, ptr %604, align 8, !tbaa !53
  %606 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 4
  store ptr %605, ptr %606, align 8, !tbaa !61
  %607 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 4
  %608 = load ptr, ptr %607, align 8, !tbaa !61
  %609 = load ptr, ptr %3, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %609, i32 0, i32 3
  %611 = load ptr, ptr %610, align 8, !tbaa !54
  %612 = ptrtoint ptr %608 to i64
  %613 = ptrtoint ptr %611 to i64
  %614 = sub i64 %612, %613
  %615 = load ptr, ptr %29, align 8, !tbaa !5
  %616 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %615, i32 0, i32 0
  %617 = load i32, ptr %616, align 4, !tbaa !23
  %618 = zext i32 %617 to i64
  %619 = icmp sgt i64 %614, %618
  br i1 %619, label %620, label %630

620:                                              ; preds = %594
  %621 = load ptr, ptr %3, align 8, !tbaa !5
  %622 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %621, i32 0, i32 3
  %623 = load ptr, ptr %622, align 8, !tbaa !54
  %624 = load ptr, ptr %29, align 8, !tbaa !5
  %625 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %624, i32 0, i32 0
  %626 = load i32, ptr %625, align 4, !tbaa !23
  %627 = zext i32 %626 to i64
  %628 = getelementptr inbounds i8, ptr %623, i64 %627
  %629 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 4
  store ptr %628, ptr %629, align 8, !tbaa !61
  br label %630

630:                                              ; preds = %620, %594
  %631 = load ptr, ptr %29, align 8, !tbaa !5
  %632 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %631, i32 0, i32 2
  %633 = load i32, ptr %632, align 4, !tbaa !25
  %634 = zext i32 %633 to i64
  %635 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 9
  store i64 %634, ptr %635, align 8, !tbaa !62
  %636 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 10
  store i32 0, ptr %636, align 8, !tbaa !63
  call void @lzvn_decode(ptr noundef %30)
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #7
  %637 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 0
  %638 = load ptr, ptr %637, align 8, !tbaa !55
  %639 = load ptr, ptr %3, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %639, i32 0, i32 0
  %641 = load ptr, ptr %640, align 8, !tbaa !18
  %642 = ptrtoint ptr %638 to i64
  %643 = ptrtoint ptr %641 to i64
  %644 = sub i64 %642, %643
  store i64 %644, ptr %31, align 8, !tbaa !26
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #7
  %645 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 2
  %646 = load ptr, ptr %645, align 8, !tbaa !60
  %647 = load ptr, ptr %3, align 8, !tbaa !5
  %648 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %647, i32 0, i32 3
  %649 = load ptr, ptr %648, align 8, !tbaa !54
  %650 = ptrtoint ptr %646 to i64
  %651 = ptrtoint ptr %649 to i64
  %652 = sub i64 %650, %651
  store i64 %652, ptr %32, align 8, !tbaa !26
  %653 = load i64, ptr %31, align 8, !tbaa !26
  %654 = load ptr, ptr %29, align 8, !tbaa !5
  %655 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %654, i32 0, i32 1
  %656 = load i32, ptr %655, align 4, !tbaa !24
  %657 = zext i32 %656 to i64
  %658 = icmp ugt i64 %653, %657
  br i1 %658, label %666, label %659

659:                                              ; preds = %630
  %660 = load i64, ptr %32, align 8, !tbaa !26
  %661 = load ptr, ptr %29, align 8, !tbaa !5
  %662 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %661, i32 0, i32 0
  %663 = load i32, ptr %662, align 4, !tbaa !23
  %664 = zext i32 %663 to i64
  %665 = icmp ugt i64 %660, %664
  br i1 %665, label %666, label %667

666:                                              ; preds = %659, %630
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %725

667:                                              ; preds = %659
  %668 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 0
  %669 = load ptr, ptr %668, align 8, !tbaa !55
  %670 = load ptr, ptr %3, align 8, !tbaa !5
  %671 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %670, i32 0, i32 0
  store ptr %669, ptr %671, align 8, !tbaa !18
  %672 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 2
  %673 = load ptr, ptr %672, align 8, !tbaa !60
  %674 = load ptr, ptr %3, align 8, !tbaa !5
  %675 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %674, i32 0, i32 3
  store ptr %673, ptr %675, align 8, !tbaa !54
  %676 = load i64, ptr %31, align 8, !tbaa !26
  %677 = trunc i64 %676 to i32
  %678 = load ptr, ptr %29, align 8, !tbaa !5
  %679 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %678, i32 0, i32 1
  %680 = load i32, ptr %679, align 4, !tbaa !24
  %681 = sub i32 %680, %677
  store i32 %681, ptr %679, align 4, !tbaa !24
  %682 = load i64, ptr %32, align 8, !tbaa !26
  %683 = trunc i64 %682 to i32
  %684 = load ptr, ptr %29, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %684, i32 0, i32 0
  %686 = load i32, ptr %685, align 4, !tbaa !23
  %687 = sub i32 %686, %683
  store i32 %687, ptr %685, align 4, !tbaa !23
  %688 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 9
  %689 = load i64, ptr %688, align 8, !tbaa !62
  %690 = trunc i64 %689 to i32
  %691 = load ptr, ptr %29, align 8, !tbaa !5
  %692 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %691, i32 0, i32 2
  store i32 %690, ptr %692, align 4, !tbaa !25
  %693 = load ptr, ptr %29, align 8, !tbaa !5
  %694 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %693, i32 0, i32 1
  %695 = load i32, ptr %694, align 4, !tbaa !24
  %696 = icmp eq i32 %695, 0
  br i1 %696, label %697, label %709

697:                                              ; preds = %667
  %698 = load ptr, ptr %29, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %698, i32 0, i32 0
  %700 = load i32, ptr %699, align 4, !tbaa !23
  %701 = icmp eq i32 %700, 0
  br i1 %701, label %702, label %709

702:                                              ; preds = %697
  %703 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 10
  %704 = load i32, ptr %703, align 8, !tbaa !63
  %705 = icmp ne i32 %704, 0
  br i1 %705, label %706, label %709

706:                                              ; preds = %702
  %707 = load ptr, ptr %3, align 8, !tbaa !5
  %708 = getelementptr inbounds %struct.lzfse_decoder_state, ptr %707, i32 0, i32 7
  store i32 0, ptr %708, align 4, !tbaa !9
  store i32 4, ptr %5, align 4
  br label %725

709:                                              ; preds = %702, %697, %667
  %710 = load ptr, ptr %29, align 8, !tbaa !5
  %711 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %710, i32 0, i32 1
  %712 = load i32, ptr %711, align 4, !tbaa !24
  %713 = icmp eq i32 %712, 0
  br i1 %713, label %723, label %714

714:                                              ; preds = %709
  %715 = load ptr, ptr %29, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.lzvn_compressed_block_decoder_state, ptr %715, i32 0, i32 0
  %717 = load i32, ptr %716, align 4, !tbaa !23
  %718 = icmp eq i32 %717, 0
  br i1 %718, label %723, label %719

719:                                              ; preds = %714
  %720 = getelementptr inbounds %struct.lzvn_decoder_state, ptr %30, i32 0, i32 10
  %721 = load i32, ptr %720, align 8, !tbaa !63
  %722 = icmp ne i32 %721, 0
  br i1 %722, label %723, label %724

723:                                              ; preds = %719, %714, %709
  store i32 -3, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %725

724:                                              ; preds = %719
  store i32 -2, ptr %2, align 4
  store i32 1, ptr %5, align 4
  br label %725

725:                                              ; preds = %724, %723, %706, %666
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #7
  call void @llvm.lifetime.end.p0(i64 88, ptr %30) #7
  br label %726

726:                                              ; preds = %725, %561
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #7
  %727 = load i32, ptr %5, align 4
  switch i32 %727, label %732 [
    i32 1, label %730
    i32 4, label %729
  ]

728:                                              ; preds = %33
  store i32 -3, ptr %2, align 4
  br label %730

729:                                              ; preds = %726, %544, %497, %405
  br label %33

730:                                              ; preds = %728, %726, %544, %497, %405, %46
  %731 = load i32, ptr %2, align 4
  ret i32 %731

732:                                              ; preds = %726, %544, %497, %405
  unreachable
}

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

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @load4(ptr noundef) #2

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden i32 @lzfse_decode_v2_header_size(ptr noundef) #3

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

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

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @lzfse_check_block_header_v1(ptr noundef) #2

declare i32 @fse_init_decoder_table(i32 noundef, i32 noundef, ptr noundef, ptr noundef) #5

declare void @fse_init_value_decoder_table(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) #5

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @fse_in_checked_init64(ptr noundef, i32 noundef, ptr noundef, ptr noundef) #2

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @fse_in_checked_flush64(ptr noundef, ptr noundef, ptr noundef) #2

; Function Attrs: alwaysinline nounwind uwtable
declare hidden zeroext i8 @fse_decode(ptr noalias noundef, ptr noalias noundef, ptr noalias noundef) #2

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

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

declare void @lzvn_decode(ptr noundef) #5

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !11, i64 52}
!10 = !{!"", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !11, i64 48, !11, i64 52, !12, i64 56, !16, i64 47352, !17, i64 47364}
!11 = !{!"int", !7, i64 0}
!12 = !{!"", !11, i64 0, !11, i64 4, !6, i64 8, !11, i64 16, !11, i64 20, !11, i64 24, !13, i64 32, !11, i64 48, !15, i64 52, !15, i64 54, !15, i64 56, !7, i64 64, !7, i64 576, !7, i64 1088, !7, i64 3136, !7, i64 7232}
!13 = !{!"", !14, i64 0, !11, i64 8}
!14 = !{!"long", !7, i64 0}
!15 = !{!"short", !7, i64 0}
!16 = !{!"", !11, i64 0, !11, i64 4, !11, i64 8}
!17 = !{!"", !11, i64 0}
!18 = !{!10, !6, i64 0}
!19 = !{!10, !6, i64 16}
!20 = !{!11, !11, i64 0}
!21 = !{!10, !11, i64 48}
!22 = !{!17, !11, i64 0}
!23 = !{!16, !11, i64 0}
!24 = !{!16, !11, i64 4}
!25 = !{!16, !11, i64 8}
!26 = !{!14, !14, i64 0}
!27 = !{!28, !11, i64 20}
!28 = !{!"", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !11, i64 16, !11, i64 20, !11, i64 24, !11, i64 28, !7, i64 32, !11, i64 40, !15, i64 44, !15, i64 46, !15, i64 48, !7, i64 50, !7, i64 90, !7, i64 130, !7, i64 258}
!29 = !{!28, !11, i64 24}
!30 = !{!12, !11, i64 4}
!31 = !{!28, !11, i64 16}
!32 = !{!12, !11, i64 0}
!33 = !{!10, !6, i64 8}
!34 = !{!28, !11, i64 28}
!35 = !{!15, !15, i64 0}
!36 = !{!28, !11, i64 12}
!37 = !{!7, !7, i64 0}
!38 = distinct !{!38, !39}
!39 = !{!"llvm.loop.mustprogress"}
!40 = !{!12, !6, i64 8}
!41 = !{!28, !11, i64 40}
!42 = !{!28, !15, i64 44}
!43 = !{!12, !15, i64 52}
!44 = !{!28, !15, i64 46}
!45 = !{!12, !15, i64 54}
!46 = !{!28, !15, i64 48}
!47 = !{!12, !15, i64 56}
!48 = !{!12, !11, i64 48}
!49 = !{!12, !11, i64 20}
!50 = !{!12, !11, i64 16}
!51 = !{!12, !11, i64 24}
!52 = !{i64 0, i64 8, !26, i64 8, i64 4, !20}
!53 = !{!10, !6, i64 40}
!54 = !{!10, !6, i64 24}
!55 = !{!56, !6, i64 0}
!56 = !{!"", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !14, i64 48, !14, i64 56, !14, i64 64, !14, i64 72, !11, i64 80}
!57 = !{!56, !6, i64 8}
!58 = !{!10, !6, i64 32}
!59 = !{!56, !6, i64 24}
!60 = !{!56, !6, i64 16}
!61 = !{!56, !6, i64 32}
!62 = !{!56, !14, i64 72}
!63 = !{!56, !11, i64 80}


; 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.lzfse_compressed_block_header_v1 = type { i32, i32, i32, i32, i32, i32, i32, i32, [4 x i16], i32, i16, i16, i16, [20 x i16], [20 x i16], [64 x i16], [256 x i16] }
%struct.fse_in_stream64 = type { i64, i32 }
%struct.lzvn_decoder_state = type { ptr, ptr, ptr, ptr, ptr, ptr, i64, i64, i64, i64, i32 }

@l_extra_bits = external hidden constant [20 x i8], align 16
@l_base_value = external hidden constant [20 x i32], align 16
@m_extra_bits = external hidden constant [20 x i8], align 16
@m_base_value = external hidden constant [20 x i32], align 16
@d_extra_bits = external hidden constant [64 x i8], align 16
@d_base_value = external hidden constant [64 x i32], align 16

; Function Attrs: nounwind uwtable
define dso_local i32 @lzfse_decode(ptr noundef %0) local_unnamed_addr #0 {
  %2 = alloca %struct.lzfse_compressed_block_header_v1, align 4
  %3 = alloca %struct.fse_in_stream64, align 8
  %4 = alloca ptr, align 8
  %5 = alloca i16, align 2
  %6 = alloca i16, align 2
  %7 = alloca i16, align 2
  %8 = alloca i16, align 2
  %9 = alloca %struct.fse_in_stream64, align 8
  %10 = alloca ptr, align 8
  %11 = alloca %struct.lzvn_decoder_state, align 8
  %12 = getelementptr inbounds i8, ptr %0, i64 52
  %13 = getelementptr inbounds i8, ptr %0, i64 47352
  %14 = getelementptr inbounds i8, ptr %0, i64 47356
  %15 = getelementptr inbounds i8, ptr %0, i64 16
  %16 = getelementptr inbounds i8, ptr %11, i64 8
  %17 = getelementptr inbounds i8, ptr %0, i64 32
  %18 = getelementptr inbounds i8, ptr %11, i64 24
  %19 = getelementptr inbounds i8, ptr %0, i64 24
  %20 = getelementptr inbounds i8, ptr %11, i64 16
  %21 = getelementptr inbounds i8, ptr %0, i64 40
  %22 = getelementptr inbounds i8, ptr %11, i64 32
  %23 = getelementptr inbounds i8, ptr %0, i64 47360
  %24 = getelementptr inbounds i8, ptr %11, i64 72
  %25 = getelementptr inbounds i8, ptr %11, i64 80
  %26 = getelementptr inbounds i8, ptr %0, i64 60
  %27 = getelementptr inbounds i8, ptr %0, i64 47364
  %28 = getelementptr inbounds i8, ptr %2, i64 20
  %29 = getelementptr inbounds i8, ptr %2, i64 24
  %30 = getelementptr inbounds i8, ptr %0, i64 56
  %31 = getelementptr inbounds i8, ptr %2, i64 16
  %32 = getelementptr inbounds i8, ptr %2, i64 258
  %33 = getelementptr inbounds i8, ptr %0, i64 3192
  %34 = getelementptr inbounds i8, ptr %2, i64 50
  %35 = getelementptr inbounds i8, ptr %0, i64 120
  %36 = getelementptr inbounds i8, ptr %2, i64 90
  %37 = getelementptr inbounds i8, ptr %0, i64 632
  %38 = getelementptr inbounds i8, ptr %2, i64 130
  %39 = getelementptr inbounds i8, ptr %0, i64 1144
  %40 = getelementptr inbounds i8, ptr %0, i64 8
  %41 = getelementptr inbounds i8, ptr %2, i64 28
  %42 = getelementptr inbounds i8, ptr %2, i64 32
  %43 = getelementptr inbounds i8, ptr %2, i64 34
  %44 = getelementptr inbounds i8, ptr %2, i64 36
  %45 = getelementptr inbounds i8, ptr %2, i64 38
  %46 = getelementptr inbounds i8, ptr %2, i64 12
  %47 = getelementptr inbounds i8, ptr %0, i64 7288
  %48 = getelementptr inbounds i8, ptr %0, i64 64
  %49 = getelementptr inbounds i8, ptr %2, i64 40
  %50 = getelementptr inbounds i8, ptr %2, i64 44
  %51 = getelementptr inbounds i8, ptr %0, i64 108
  %52 = getelementptr inbounds i8, ptr %2, i64 48
  %53 = getelementptr inbounds i8, ptr %0, i64 112
  %54 = getelementptr inbounds i8, ptr %0, i64 104
  %55 = getelementptr inbounds i8, ptr %0, i64 76
  %56 = getelementptr inbounds i8, ptr %0, i64 72
  %57 = getelementptr inbounds i8, ptr %0, i64 80
  %58 = getelementptr inbounds i8, ptr %0, i64 88
  %59 = getelementptr inbounds i8, ptr %11, i64 40
  br label %.thread261

.thread261:                                       ; preds = %.thread261.backedge, %1
  %60 = load i32, ptr %12, align 4, !tbaa !5
  switch i32 %60, label %.thread255 [
    i32 0, label %61
    i32 762869346, label %183
    i32 829978210, label %213
    i32 846755426, label %213
    i32 1853388386, label %230
  ]

61:                                               ; preds = %.thread261
  %62 = load ptr, ptr %0, align 8, !tbaa !17
  %63 = getelementptr inbounds i8, ptr %62, i64 4
  %64 = load ptr, ptr %15, align 8, !tbaa !18
  %65 = icmp ugt ptr %63, %64
  br i1 %65, label %.thread255, label %66

66:                                               ; preds = %61
  %67 = call i32 @load4(ptr noundef %62)
  switch i32 %67, label %.thread255 [
    i32 611874402, label %68
    i32 762869346, label %72
    i32 1853388386, label %82
    i32 846755426, label %95
    i32 829978210, label %95
  ]

68:                                               ; preds = %66
  %69 = load ptr, ptr %0, align 8, !tbaa !17
  %70 = getelementptr inbounds i8, ptr %69, i64 4
  store ptr %70, ptr %0, align 8, !tbaa !17
  %71 = getelementptr inbounds i8, ptr %0, i64 48
  store i32 1, ptr %71, align 8, !tbaa !19
  br label %.thread255

72:                                               ; preds = %66
  %73 = load ptr, ptr %0, align 8, !tbaa !17
  %74 = getelementptr inbounds i8, ptr %73, i64 8
  %75 = load ptr, ptr %15, align 8, !tbaa !18
  %76 = icmp ugt ptr %74, %75
  br i1 %76, label %.thread255, label %77

77:                                               ; preds = %72
  %78 = getelementptr inbounds i8, ptr %73, i64 4
  %79 = call i32 @load4(ptr noundef nonnull %78)
  store i32 %79, ptr %27, align 4, !tbaa !20
  %80 = load ptr, ptr %0, align 8, !tbaa !17
  %81 = getelementptr inbounds i8, ptr %80, i64 8
  store ptr %81, ptr %0, align 8, !tbaa !17
  store i32 762869346, ptr %12, align 4, !tbaa !5
  br label %.thread261.backedge

82:                                               ; preds = %66
  %83 = load ptr, ptr %0, align 8, !tbaa !17
  %84 = getelementptr inbounds i8, ptr %83, i64 12
  %85 = load ptr, ptr %15, align 8, !tbaa !18
  %86 = icmp ugt ptr %84, %85
  br i1 %86, label %.thread255, label %87

87:                                               ; preds = %82
  %88 = getelementptr inbounds i8, ptr %83, i64 4
  %89 = call i32 @load4(ptr noundef nonnull %88)
  store i32 %89, ptr %13, align 4, !tbaa !21
  %90 = load ptr, ptr %0, align 8, !tbaa !17
  %91 = getelementptr inbounds i8, ptr %90, i64 8
  %92 = call i32 @load4(ptr noundef nonnull %91)
  store i32 %92, ptr %14, align 4, !tbaa !22
  store i32 0, ptr %23, align 4, !tbaa !23
  %93 = load ptr, ptr %0, align 8, !tbaa !17
  %94 = getelementptr inbounds i8, ptr %93, i64 12
  store ptr %94, ptr %0, align 8, !tbaa !17
  store i32 1853388386, ptr %12, align 4, !tbaa !5
  br label %.thread261.backedge

95:                                               ; preds = %66, %66
  %96 = icmp eq i32 %67, 846755426
  call void @llvm.lifetime.start.p0(i64 772, ptr nonnull %2) #7
  %97 = load ptr, ptr %0, align 8, !tbaa !17
  %98 = load ptr, ptr %15, align 8, !tbaa !18
  br i1 %96, label %99, label %111

99:                                               ; preds = %95
  %100 = getelementptr inbounds i8, ptr %97, i64 32
  %101 = icmp ugt ptr %100, %98
  br i1 %101, label %.thread267, label %102

102:                                              ; preds = %99
  %103 = call i32 @lzfse_decode_v2_header_size(ptr noundef %97)
  %104 = zext i32 %103 to i64
  %105 = load ptr, ptr %0, align 8, !tbaa !17
  %106 = getelementptr inbounds i8, ptr %105, i64 %104
  %107 = load ptr, ptr %15, align 8, !tbaa !18
  %108 = icmp ugt ptr %106, %107
  br i1 %108, label %.thread267, label %109

109:                                              ; preds = %102
  %110 = call i32 @lzfse_decode_v1(ptr noundef nonnull %2, ptr noundef %97)
  %.not221 = icmp eq i32 %110, 0
  br i1 %.not221, label %._crit_edge304, label %.thread267

._crit_edge304:                                   ; preds = %109
  %.pre305 = load ptr, ptr %0, align 8, !tbaa !17
  %.pre306 = load ptr, ptr %15, align 8, !tbaa !18
  br label %115

111:                                              ; preds = %95
  %112 = getelementptr inbounds i8, ptr %97, i64 772
  %113 = icmp ugt ptr %112, %98
  br i1 %113, label %.thread267, label %114

114:                                              ; preds = %111
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 4 dereferenceable(772) %2, ptr noundef nonnull align 1 dereferenceable(772) %97, i64 772, i1 false)
  br label %115

115:                                              ; preds = %._crit_edge304, %114
  %116 = phi ptr [ %98, %114 ], [ %.pre306, %._crit_edge304 ]
  %117 = phi ptr [ %97, %114 ], [ %.pre305, %._crit_edge304 ]
  %.0197 = phi i64 [ 772, %114 ], [ %104, %._crit_edge304 ]
  %118 = getelementptr inbounds i8, ptr %117, i64 %.0197
  %119 = load i32, ptr %28, align 4, !tbaa !24
  %120 = zext i32 %119 to i64
  %121 = getelementptr inbounds i8, ptr %118, i64 %120
  %122 = load i32, ptr %29, align 4, !tbaa !26
  %123 = zext i32 %122 to i64
  %124 = getelementptr inbounds i8, ptr %121, i64 %123
  %125 = icmp ugt ptr %124, %116
  br i1 %125, label %.thread267, label %126

126:                                              ; preds = %115
  %127 = call i32 @lzfse_check_block_header_v1(ptr noundef nonnull %2)
  %.not222 = icmp eq i32 %127, 0
  br i1 %.not222, label %128, label %.thread267

128:                                              ; preds = %126
  %129 = load ptr, ptr %0, align 8, !tbaa !17
  %130 = getelementptr inbounds i8, ptr %129, i64 %.0197
  store ptr %130, ptr %0, align 8, !tbaa !17
  %131 = load i32, ptr %29, align 4, !tbaa !26
  store i32 %131, ptr %26, align 4, !tbaa !27
  %132 = load i32, ptr %31, align 4, !tbaa !28
  store i32 %132, ptr %30, align 8, !tbaa !29
  %133 = call i32 @fse_init_decoder_table(i32 noundef 1024, i32 noundef 256, ptr noundef nonnull %32, ptr noundef nonnull %33) #7
  call void @fse_init_value_decoder_table(i32 noundef 64, i32 noundef 20, ptr noundef nonnull %34, ptr noundef nonnull @l_extra_bits, ptr noundef nonnull @l_base_value, ptr noundef nonnull %35) #7
  call void @fse_init_value_decoder_table(i32 noundef 64, i32 noundef 20, ptr noundef nonnull %36, ptr noundef nonnull @m_extra_bits, ptr noundef nonnull @m_base_value, ptr noundef nonnull %37) #7
  call void @fse_init_value_decoder_table(i32 noundef 256, i32 noundef 64, ptr noundef nonnull %38, ptr noundef nonnull @d_extra_bits, ptr noundef nonnull @d_base_value, ptr noundef nonnull %39) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %3) #7
  %134 = load ptr, ptr %40, align 8, !tbaa !30
  %135 = load i32, ptr %28, align 4, !tbaa !24
  %136 = load ptr, ptr %0, align 8, !tbaa !17
  %137 = zext i32 %135 to i64
  %138 = getelementptr inbounds i8, ptr %136, i64 %137
  store ptr %138, ptr %0, align 8, !tbaa !17
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %4) #7
  store ptr %138, ptr %4, align 8, !tbaa !31
  %139 = load i32, ptr %41, align 4, !tbaa !32
  %140 = call i32 @fse_in_checked_init64(ptr noundef nonnull %3, i32 noundef %139, ptr noundef nonnull %4, ptr noundef %134)
  %.not223 = icmp eq i32 %140, 0
  br i1 %.not223, label %141, label %.thread242

.thread242:                                       ; preds = %128
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %3) #7
  br label %.thread267

141:                                              ; preds = %128
  call void @llvm.lifetime.start.p0(i64 2, ptr nonnull %5) #7
  %142 = load i16, ptr %42, align 4, !tbaa !33
  store i16 %142, ptr %5, align 2, !tbaa !33
  call void @llvm.lifetime.start.p0(i64 2, ptr nonnull %6) #7
  %143 = load i16, ptr %43, align 2, !tbaa !33
  store i16 %143, ptr %6, align 2, !tbaa !33
  call void @llvm.lifetime.start.p0(i64 2, ptr nonnull %7) #7
  %144 = load i16, ptr %44, align 4, !tbaa !33
  store i16 %144, ptr %7, align 2, !tbaa !33
  call void @llvm.lifetime.start.p0(i64 2, ptr nonnull %8) #7
  %145 = load i16, ptr %45, align 2, !tbaa !33
  store i16 %145, ptr %8, align 2, !tbaa !33
  %146 = load i32, ptr %46, align 4, !tbaa !34
  %.not225300.not = icmp eq i32 %146, 0
  br i1 %.not225300.not, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %141, %148
  %.0198301 = phi i32 [ %164, %148 ], [ 0, %141 ]
  %147 = call i32 @fse_in_checked_flush64(ptr noundef nonnull %3, ptr noundef nonnull %4, ptr noundef %134)
  %.not224 = icmp eq i32 %147, 0
  br i1 %.not224, label %148, label %166

148:                                              ; preds = %.lr.ph
  %149 = call zeroext i8 @fse_decode(ptr noundef nonnull %5, ptr noundef nonnull %33, ptr noundef nonnull %3)
  %150 = zext i32 %.0198301 to i64
  %151 = getelementptr inbounds [40064 x i8], ptr %47, i64 0, i64 %150
  store i8 %149, ptr %151, align 1, !tbaa !35
  %152 = call zeroext i8 @fse_decode(ptr noundef nonnull %6, ptr noundef nonnull %33, ptr noundef nonnull %3)
  %153 = or disjoint i32 %.0198301, 1
  %154 = zext i32 %153 to i64
  %155 = getelementptr inbounds [40064 x i8], ptr %47, i64 0, i64 %154
  store i8 %152, ptr %155, align 1, !tbaa !35
  %156 = call zeroext i8 @fse_decode(ptr noundef nonnull %7, ptr noundef nonnull %33, ptr noundef nonnull %3)
  %157 = or disjoint i32 %.0198301, 2
  %158 = zext i32 %157 to i64
  %159 = getelementptr inbounds [40064 x i8], ptr %47, i64 0, i64 %158
  store i8 %156, ptr %159, align 1, !tbaa !35
  %160 = call zeroext i8 @fse_decode(ptr noundef nonnull %8, ptr noundef nonnull %33, ptr noundef nonnull %3)
  %161 = or disjoint i32 %.0198301, 3
  %162 = zext i32 %161 to i64
  %163 = getelementptr inbounds [40064 x i8], ptr %47, i64 0, i64 %162
  store i8 %160, ptr %163, align 1, !tbaa !35
  %164 = add i32 %.0198301, 4
  %165 = load i32, ptr %46, align 4, !tbaa !34
  %.not225 = icmp ult i32 %164, %165
  br i1 %.not225, label %.lr.ph, label %._crit_edge, !llvm.loop !36

166:                                              ; preds = %.lr.ph
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %8) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %7) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %6) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %5) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %3) #7
  br label %.thread267

._crit_edge:                                      ; preds = %148, %141
  store ptr %47, ptr %48, align 8, !tbaa !38
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %8) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %7) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %6) #7
  call void @llvm.lifetime.end.p0(i64 2, ptr nonnull %5) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %3) #7
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %9) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %10) #7
  %167 = load ptr, ptr %0, align 8, !tbaa !17
  %168 = load i32, ptr %29, align 4, !tbaa !26
  %169 = zext i32 %168 to i64
  %170 = getelementptr inbounds i8, ptr %167, i64 %169
  store ptr %170, ptr %10, align 8, !tbaa !31
  %171 = load i32, ptr %49, align 4, !tbaa !39
  %172 = call i32 @fse_in_checked_init64(ptr noundef nonnull %9, i32 noundef %171, ptr noundef nonnull %10, ptr noundef %167)
  %.not226 = icmp eq i32 %172, 0
  br i1 %.not226, label %174, label %173

173:                                              ; preds = %._crit_edge
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #7
  br label %.thread267

.thread267:                                       ; preds = %99, %111, %115, %126, %109, %102, %173, %166, %.thread242
  %.8.ph = phi i32 [ -3, %.thread242 ], [ -3, %166 ], [ -3, %173 ], [ -3, %109 ], [ -1, %102 ], [ -1, %99 ], [ -1, %111 ], [ -1, %115 ], [ -3, %126 ]
  call void @llvm.lifetime.end.p0(i64 772, ptr nonnull %2) #7
  br label %.thread255

174:                                              ; preds = %._crit_edge
  %175 = load <2 x i16>, ptr %50, align 4, !tbaa !33
  store <2 x i16> %175, ptr %51, align 4, !tbaa !33
  %176 = load i16, ptr %52, align 4, !tbaa !40
  store i16 %176, ptr %53, align 8, !tbaa !41
  %177 = load ptr, ptr %10, align 8, !tbaa !31
  %178 = load ptr, ptr %0, align 8, !tbaa !17
  %179 = ptrtoint ptr %177 to i64
  %180 = ptrtoint ptr %178 to i64
  %181 = sub i64 %179, %180
  %182 = trunc i64 %181 to i32
  store i32 %182, ptr %54, align 8, !tbaa !42
  store i32 0, ptr %55, align 4, !tbaa !43
  store i32 0, ptr %56, align 8, !tbaa !44
  store i32 -1, ptr %57, align 8, !tbaa !45
  call void @llvm.memcpy.p0.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %58, ptr noundef nonnull align 8 dereferenceable(16) %9, i64 16, i1 false), !tbaa.struct !46
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %10) #7
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %9) #7
  store i32 %67, ptr %12, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 772, ptr nonnull %2) #7
  br label %.thread261.backedge

183:                                              ; preds = %.thread261
  %184 = load i32, ptr %27, align 4, !tbaa !20
  %185 = icmp eq i32 %184, 0
  br i1 %185, label %186, label %187

186:                                              ; preds = %183
  store i32 0, ptr %12, align 4, !tbaa !5
  br label %.thread261.backedge

187:                                              ; preds = %183
  %188 = load ptr, ptr %15, align 8, !tbaa !18
  %189 = load ptr, ptr %0, align 8, !tbaa !17
  %.not219 = icmp ugt ptr %188, %189
  br i1 %.not219, label %190, label %.thread255

190:                                              ; preds = %187
  %191 = load ptr, ptr %21, align 8, !tbaa !49
  %192 = load ptr, ptr %19, align 8, !tbaa !50
  %.not220 = icmp ugt ptr %191, %192
  br i1 %.not220, label %193, label %.thread255

193:                                              ; preds = %190
  %194 = ptrtoint ptr %188 to i64
  %195 = ptrtoint ptr %189 to i64
  %196 = sub i64 %194, %195
  %197 = zext i32 %184 to i64
  %198 = icmp ult i64 %196, %197
  %199 = trunc nuw i64 %196 to i32
  %spec.select = select i1 %198, i32 %199, i32 %184
  %200 = ptrtoint ptr %191 to i64
  %201 = ptrtoint ptr %192 to i64
  %202 = sub i64 %200, %201
  %203 = zext i32 %spec.select to i64
  %204 = icmp ult i64 %202, %203
  %205 = trunc nuw i64 %202 to i32
  %spec.select227 = select i1 %204, i32 %205, i32 %spec.select
  %206 = zext i32 %spec.select227 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %192, ptr align 1 %189, i64 %206, i1 false)
  %207 = load ptr, ptr %0, align 8, !tbaa !17
  %208 = getelementptr inbounds i8, ptr %207, i64 %206
  store ptr %208, ptr %0, align 8, !tbaa !17
  %209 = load ptr, ptr %19, align 8, !tbaa !50
  %210 = getelementptr inbounds i8, ptr %209, i64 %206
  store ptr %210, ptr %19, align 8, !tbaa !50
  %211 = load i32, ptr %27, align 4, !tbaa !20
  %212 = sub i32 %211, %spec.select227
  store i32 %212, ptr %27, align 4, !tbaa !20
  br label %.thread261.backedge

.thread261.backedge:                              ; preds = %193, %186, %87, %77, %283, %225, %174
  br label %.thread261

213:                                              ; preds = %.thread261, %.thread261
  %214 = load ptr, ptr %15, align 8, !tbaa !18
  %215 = load ptr, ptr %0, align 8, !tbaa !17
  %.not217 = icmp ugt ptr %214, %215
  br i1 %.not217, label %216, label %.thread255

216:                                              ; preds = %213
  %217 = load i32, ptr %26, align 4, !tbaa !27
  %218 = zext i32 %217 to i64
  %219 = ptrtoint ptr %214 to i64
  %220 = ptrtoint ptr %215 to i64
  %221 = sub i64 %219, %220
  %222 = icmp ult i64 %221, %218
  br i1 %222, label %.thread255, label %223

223:                                              ; preds = %216
  %224 = call i32 @lzfse_decode_lmd(ptr noundef nonnull %0)
  %.not218 = icmp eq i32 %224, 0
  br i1 %.not218, label %225, label %.thread255

225:                                              ; preds = %223
  store i32 0, ptr %12, align 4, !tbaa !5
  %226 = load i32, ptr %26, align 4, !tbaa !27
  %227 = load ptr, ptr %0, align 8, !tbaa !17
  %228 = zext i32 %226 to i64
  %229 = getelementptr inbounds i8, ptr %227, i64 %228
  store ptr %229, ptr %0, align 8, !tbaa !17
  br label %.thread261.backedge

230:                                              ; preds = %.thread261
  %231 = load i32, ptr %14, align 4, !tbaa !22
  %.not = icmp eq i32 %231, 0
  %.pre = load ptr, ptr %0, align 8, !tbaa !17
  %.pre303 = load ptr, ptr %15, align 8, !tbaa !18
  %.not216 = icmp ugt ptr %.pre303, %.pre
  %or.cond = select i1 %.not, i1 true, i1 %.not216
  br i1 %or.cond, label %232, label %.thread255

232:                                              ; preds = %230
  call void @llvm.lifetime.start.p0(i64 88, ptr nonnull %11) #7
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(88) %59, i8 0, i64 48, i1 false)
  store ptr %.pre, ptr %11, align 8, !tbaa !51
  %233 = ptrtoint ptr %.pre303 to i64
  %234 = ptrtoint ptr %.pre to i64
  %235 = sub i64 %233, %234
  %236 = zext i32 %231 to i64
  %237 = icmp sgt i64 %235, %236
  %238 = getelementptr inbounds i8, ptr %.pre, i64 %236
  %spec.select296 = select i1 %237, ptr %238, ptr %.pre303
  store ptr %spec.select296, ptr %16, align 8, !tbaa !53
  %239 = load ptr, ptr %17, align 8, !tbaa !54
  store ptr %239, ptr %18, align 8, !tbaa !55
  %240 = load ptr, ptr %19, align 8, !tbaa !50
  store ptr %240, ptr %20, align 8, !tbaa !56
  %241 = load ptr, ptr %21, align 8, !tbaa !49
  store ptr %241, ptr %22, align 8, !tbaa !57
  %242 = ptrtoint ptr %241 to i64
  %243 = ptrtoint ptr %240 to i64
  %244 = sub i64 %242, %243
  %245 = load i32, ptr %13, align 4, !tbaa !21
  %246 = zext i32 %245 to i64
  %247 = icmp sgt i64 %244, %246
  br i1 %247, label %248, label %250

248:                                              ; preds = %232
  %249 = getelementptr inbounds i8, ptr %240, i64 %246
  store ptr %249, ptr %22, align 8, !tbaa !57
  br label %250

250:                                              ; preds = %248, %232
  %251 = load i32, ptr %23, align 4, !tbaa !23
  %252 = zext i32 %251 to i64
  store i64 %252, ptr %24, align 8, !tbaa !58
  store i32 0, ptr %25, align 8, !tbaa !59
  call void @lzvn_decode(ptr noundef nonnull %11) #7
  %253 = load ptr, ptr %11, align 8, !tbaa !51
  %254 = load ptr, ptr %0, align 8, !tbaa !17
  %255 = ptrtoint ptr %253 to i64
  %256 = ptrtoint ptr %254 to i64
  %257 = sub i64 %255, %256
  %258 = load ptr, ptr %20, align 8, !tbaa !56
  %259 = load ptr, ptr %19, align 8, !tbaa !50
  %260 = ptrtoint ptr %258 to i64
  %261 = ptrtoint ptr %259 to i64
  %262 = sub i64 %260, %261
  %263 = load i32, ptr %14, align 4, !tbaa !22
  %264 = zext i32 %263 to i64
  %265 = icmp ugt i64 %257, %264
  br i1 %265, label %.thread291, label %266

266:                                              ; preds = %250
  %267 = load i32, ptr %13, align 4, !tbaa !21
  %268 = zext i32 %267 to i64
  %269 = icmp ugt i64 %262, %268
  br i1 %269, label %.thread291, label %270

270:                                              ; preds = %266
  store ptr %253, ptr %0, align 8, !tbaa !17
  store ptr %258, ptr %19, align 8, !tbaa !50
  %271 = trunc nuw i64 %257 to i32
  %272 = sub i32 %263, %271
  store i32 %272, ptr %14, align 4, !tbaa !22
  %273 = trunc nuw i64 %262 to i32
  %274 = sub i32 %267, %273
  store i32 %274, ptr %13, align 4, !tbaa !21
  %275 = load i64, ptr %24, align 8, !tbaa !58
  %276 = trunc i64 %275 to i32
  store i32 %276, ptr %23, align 4, !tbaa !23
  %277 = icmp eq i32 %263, %271
  %278 = icmp eq i32 %267, %273
  %279 = load i32, ptr %25, align 8
  %280 = icmp ne i32 %279, 0
  br i1 %277, label %281, label %282

281:                                              ; preds = %270
  %or.cond7 = select i1 %278, i1 %280, i1 false
  br i1 %or.cond7, label %283, label %.thread291

282:                                              ; preds = %270
  %or.cond10 = select i1 %278, i1 true, i1 %280
  %spec.select234 = select i1 %or.cond10, i32 -3, i32 -2
  br label %.thread291

.thread291:                                       ; preds = %266, %250, %281, %282
  %.14.ph = phi i32 [ %spec.select234, %282 ], [ -3, %281 ], [ -3, %250 ], [ -3, %266 ]
  call void @llvm.lifetime.end.p0(i64 88, ptr nonnull %11) #7
  br label %.thread255

283:                                              ; preds = %281
  store i32 0, ptr %12, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 88, ptr nonnull %11) #7
  br label %.thread261.backedge

.thread255:                                       ; preds = %187, %190, %66, %223, %213, %216, %82, %72, %.thread261, %61, %230, %68, %.thread291, %.thread267
  %.17 = phi i32 [ %.8.ph, %.thread267 ], [ %.14.ph, %.thread291 ], [ 0, %68 ], [ -2, %190 ], [ -1, %187 ], [ -3, %66 ], [ -1, %216 ], [ -1, %213 ], [ %224, %223 ], [ -1, %72 ], [ -1, %82 ], [ -3, %.thread261 ], [ -1, %61 ], [ -1, %230 ]
  ret i32 %.17
}

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

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @load4(ptr noundef) local_unnamed_addr #2

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden i32 @lzfse_decode_v2_header_size(ptr noundef) local_unnamed_addr #3

; Function Attrs: inlinehint nounwind uwtable
declare hidden i32 @lzfse_decode_v1(ptr noundef, ptr noundef) local_unnamed_addr #3

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

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @lzfse_check_block_header_v1(ptr noundef) local_unnamed_addr #2

declare i32 @fse_init_decoder_table(i32 noundef, i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #5

declare void @fse_init_value_decoder_table(i32 noundef, i32 noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #5

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @fse_in_checked_init64(ptr noundef, i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: alwaysinline nounwind uwtable
declare hidden i32 @fse_in_checked_flush64(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: alwaysinline nounwind uwtable
declare hidden zeroext i8 @fse_decode(ptr noalias noundef, ptr noalias noundef, ptr noalias noundef) local_unnamed_addr #2

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

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

declare void @lzvn_decode(ptr noundef) local_unnamed_addr #5

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 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { alwaysinline nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { inlinehint nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #5 = { "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 #6 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #7 = { 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, !10, i64 52}
!6 = !{!"", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !10, i64 48, !10, i64 52, !11, i64 56, !15, i64 47352, !16, i64 47364}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"int", !8, i64 0}
!11 = !{!"", !10, i64 0, !10, i64 4, !7, i64 8, !10, i64 16, !10, i64 20, !10, i64 24, !12, i64 32, !10, i64 48, !14, i64 52, !14, i64 54, !14, i64 56, !8, i64 64, !8, i64 576, !8, i64 1088, !8, i64 3136, !8, i64 7232}
!12 = !{!"", !13, i64 0, !10, i64 8}
!13 = !{!"long", !8, i64 0}
!14 = !{!"short", !8, i64 0}
!15 = !{!"", !10, i64 0, !10, i64 4, !10, i64 8}
!16 = !{!"", !10, i64 0}
!17 = !{!6, !7, i64 0}
!18 = !{!6, !7, i64 16}
!19 = !{!6, !10, i64 48}
!20 = !{!16, !10, i64 0}
!21 = !{!15, !10, i64 0}
!22 = !{!15, !10, i64 4}
!23 = !{!15, !10, i64 8}
!24 = !{!25, !10, i64 20}
!25 = !{!"", !10, i64 0, !10, i64 4, !10, i64 8, !10, i64 12, !10, i64 16, !10, i64 20, !10, i64 24, !10, i64 28, !8, i64 32, !10, i64 40, !14, i64 44, !14, i64 46, !14, i64 48, !8, i64 50, !8, i64 90, !8, i64 130, !8, i64 258}
!26 = !{!25, !10, i64 24}
!27 = !{!11, !10, i64 4}
!28 = !{!25, !10, i64 16}
!29 = !{!11, !10, i64 0}
!30 = !{!6, !7, i64 8}
!31 = !{!7, !7, i64 0}
!32 = !{!25, !10, i64 28}
!33 = !{!14, !14, i64 0}
!34 = !{!25, !10, i64 12}
!35 = !{!8, !8, i64 0}
!36 = distinct !{!36, !37}
!37 = !{!"llvm.loop.mustprogress"}
!38 = !{!11, !7, i64 8}
!39 = !{!25, !10, i64 40}
!40 = !{!25, !14, i64 48}
!41 = !{!11, !14, i64 56}
!42 = !{!11, !10, i64 48}
!43 = !{!11, !10, i64 20}
!44 = !{!11, !10, i64 16}
!45 = !{!11, !10, i64 24}
!46 = !{i64 0, i64 8, !47, i64 8, i64 4, !48}
!47 = !{!13, !13, i64 0}
!48 = !{!10, !10, i64 0}
!49 = !{!6, !7, i64 40}
!50 = !{!6, !7, i64 24}
!51 = !{!52, !7, i64 0}
!52 = !{!"", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !13, i64 48, !13, i64 56, !13, i64 64, !13, i64 72, !10, i64 80}
!53 = !{!52, !7, i64 8}
!54 = !{!6, !7, i64 32}
!55 = !{!52, !7, i64 24}
!56 = !{!52, !7, i64 16}
!57 = !{!52, !7, i64 32}
!58 = !{!52, !13, i64 72}
!59 = !{!52, !10, i64 80}


; Effective O3 passes: CorrelatedValuePropagationPass,DSEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass