; ModuleID = 'src/encode.o'
source_filename = "src/encode.c"
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-pc-linux-gnu"

%struct.encoder_state = type { [256 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, %union.anon, [0 x i32] }
%union.anon = type { [65792 x i32] }
%struct.anon = type { [18002 x i8], [18008 x i8], i32, i32, i32, [6 x [259 x i8]], [6 x [259 x i32]], [6 x [259 x i32]], [6 x i32], [6 x i32] }

@.str = private unnamed_addr constant [7 x i8] c"s != 0\00", align 1
@.str.1 = private unnamed_addr constant [13 x i8] c"src/encode.c\00", align 1
@__PRETTY_FUNCTION__.encoder_init = private unnamed_addr constant [71 x i8] c"void encoder_init(struct encoder_state *, unsigned long, unsigned int)\00", align 1
@.str.2 = private unnamed_addr constant [55 x i8] c"max_block_size > 0 && max_block_size <= MAX_BLOCK_SIZE\00", align 1
@.str.3 = private unnamed_addr constant [46 x i8] c"cluster_factor > 0 && cluster_factor <= 65535\00", align 1
@.str.4 = private unnamed_addr constant [51 x i8] c"s->rle_state >= 0 && s->rle_state < MAX_RUN_LENGTH\00", align 1
@__PRETTY_FUNCTION__.collect = private unnamed_addr constant [63 x i8] c"int collect(struct encoder_state *, const uint8_t *, size_t *)\00", align 1
@crc_table = external local_unnamed_addr global [256 x i32], align 16
@.str.5 = private unnamed_addr constant [9 x i8] c"q < qMax\00", align 1
@.str.6 = private unnamed_addr constant [10 x i8] c"q <= qMax\00", align 1
@.str.7 = private unnamed_addr constant [30 x i8] c"s->nblock < s->max_block_size\00", align 1
@__PRETTY_FUNCTION__.encode = private unnamed_addr constant [50 x i8] c"size_t encode(struct encoder_state *, uint32_t *)\00", align 1
@.str.8 = private unnamed_addr constant [14 x i8] c"s->nblock > 0\00", align 1
@.str.9 = private unnamed_addr constant [9 x i8] c"EOB >= 2\00", align 1
@.str.10 = private unnamed_addr constant [10 x i8] c"EOB < 258\00", align 1
@.str.11 = private unnamed_addr constant [16 x i8] c"*sp < MAX_TREES\00", align 1
@.str.12 = private unnamed_addr constant [30 x i8] c"s->u.s.tmap_old2new[*sp] == 0\00", align 1
@.str.13 = private unnamed_addr constant [21 x i8] c"c < s->u.s.num_trees\00", align 1
@.str.14 = private unnamed_addr constant [54 x i8] c"(size_t)(sp - s->u.s.selector) < s->u.s.num_selectors\00", align 1
@.str.15 = private unnamed_addr constant [14 x i8] c"cost % 8 == 0\00", align 1
@.str.16 = private unnamed_addr constant [8 x i8] c"nm >= 2\00", align 1
@__PRETTY_FUNCTION__.generate_prefix_code = private unnamed_addr constant [58 x i8] c"unsigned int generate_prefix_code(struct encoder_state *)\00", align 1
@.str.17 = private unnamed_addr constant [7 x i8] c"t < nt\00", align 1
@.str.18 = private unnamed_addr constant [55 x i8] c"(size_t)(sp - s->u.s.selector) == s->u.s.num_selectors\00", align 1
@.str.19 = private unnamed_addr constant [8 x i8] c"nt >= 1\00", align 1
@.str.20 = private unnamed_addr constant [99 x i8] c"(char *)buf + (s->out_expect_len + 3) / 4 * 4 <= (char *)s + encoder_alloc_size(s->max_block_size)\00", align 1
@__PRETTY_FUNCTION__.transmit = private unnamed_addr constant [47 x i8] c"void *transmit(struct encoder_state *, void *)\00", align 1
@.str.21 = private unnamed_addr constant [7 x i8] c"k == 9\00", align 1
@.str.22 = private unnamed_addr constant [63 x i8] c"s->u.s.num_trees >= MIN_TREES && s->u.s.num_trees <= MAX_TREES\00", align 1
@.str.23 = private unnamed_addr constant [19 x i8] c"k == 12 || k == 28\00", align 1
@.str.24 = private unnamed_addr constant [11 x i8] c"k % 8 == 0\00", align 1
@.str.25 = private unnamed_addr constant [31 x i8] c"k / 8 == s->out_expect_len % 4\00", align 1
@.str.26 = private unnamed_addr constant [45 x i8] c"p == (uint32_t *)buf + s->out_expect_len / 4\00", align 1
@.str.27 = private unnamed_addr constant [10 x i8] c"cum == nm\00", align 1
@__PRETTY_FUNCTION__.generate_initial_trees = private unnamed_addr constant [80 x i8] c"void generate_initial_trees(struct encoder_state *, unsigned int, unsigned int)\00", align 1
@.str.28 = private unnamed_addr constant [7 x i8] c"nm > 0\00", align 1
@.str.29 = private unnamed_addr constant [9 x i8] c"as >= nt\00", align 1
@.str.30 = private unnamed_addr constant [6 x i8] c"a < b\00", align 1
@.str.31 = private unnamed_addr constant [8 x i8] c"cum > 0\00", align 1
@.str.32 = private unnamed_addr constant [10 x i8] c"cum <= nm\00", align 1
@.str.33 = private unnamed_addr constant [11 x i8] c"as >= nt-1\00", align 1
@.str.34 = private unnamed_addr constant [8 x i8] c"as == 0\00", align 1
@.str.35 = private unnamed_addr constant [8 x i8] c"nm == 0\00", align 1
@.str.36 = private unnamed_addr constant [21 x i8] c"as >= MIN_ALPHA_SIZE\00", align 1
@__PRETTY_FUNCTION__.make_code_lengths = private unnamed_addr constant [56 x i8] c"void make_code_lengths(uint8_t *, uint32_t *, uint32_t)\00", align 1
@.str.37 = private unnamed_addr constant [21 x i8] c"as <= MAX_ALPHA_SIZE\00", align 1
@.str.38 = private unnamed_addr constant [7 x i8] c"i < as\00", align 1
@.str.39 = private unnamed_addr constant [41 x i8] c"c == (1UL << (MAX_HUFF_CODE_LENGTH + 1))\00", align 1
@.str.40 = private unnamed_addr constant [8 x i8] c"i == as\00", align 1
@.str.41 = private unnamed_addr constant [7 x i8] c"r == 2\00", align 1
@__PRETTY_FUNCTION__.build_tree = private unnamed_addr constant [65 x i8] c"void build_tree(uint32_t *restrict, uint64_t *restrict, int32_t)\00", align 1
@.str.42 = private unnamed_addr constant [7 x i8] c"s == 0\00", align 1
@.str.43 = private unnamed_addr constant [7 x i8] c"t == 0\00", align 1
@.str.44 = private unnamed_addr constant [13 x i8] c"avail > used\00", align 1
@__PRETTY_FUNCTION__.compute_depths = private unnamed_addr constant [70 x i8] c"void compute_depths(uint32_t *restrict, uint32_t *restrict, uint32_t)\00", align 1
@.str.45 = private unnamed_addr constant [11 x i8] c"avail == 0\00", align 1
@.str.46 = private unnamed_addr constant [10 x i8] c"leaf < as\00", align 1
@__PRETTY_FUNCTION__.assign_codes = private unnamed_addr constant [73 x i8] c"uint32_t assign_codes(uint32_t *, uint8_t *, const uint32_t *, uint32_t)\00", align 1

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define dso_local i64 @encoder_alloc_size(i64 noundef %max_block_size) local_unnamed_addr #0 {
entry:
  %max_block_size.addr = alloca i64, align 8
  store i64 %max_block_size, ptr %max_block_size.addr, align 8, !tbaa !8
  %0 = load i64, ptr %max_block_size.addr, align 8, !tbaa !8
  %add = add i64 %0, 50
  %mul = mul i64 %add, 4
  %add1 = add i64 263464, %mul
  %1 = load i64, ptr %max_block_size.addr, align 8, !tbaa !8
  %add2 = add i64 %add1, %1
  %add3 = add i64 %add2, 1
  ret i64 %add3
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define dso_local void @encoder_init(ptr noundef %s, i64 noundef %max_block_size, i32 noundef %cluster_factor) local_unnamed_addr #0 {
entry:
  %s.addr = alloca ptr, align 8
  %max_block_size.addr = alloca i64, align 8
  %cluster_factor.addr = alloca i32, align 4
  store ptr %s, ptr %s.addr, align 8, !tbaa !12
  store i64 %max_block_size, ptr %max_block_size.addr, align 8, !tbaa !8
  store i32 %cluster_factor, ptr %cluster_factor.addr, align 4, !tbaa !14
  %0 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmp = icmp ne ptr %0, null
  br i1 %cmp, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  br label %if.end

if.else:                                          ; preds = %entry
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 121, ptr noundef @__PRETTY_FUNCTION__.encoder_init) #11
  unreachable

if.end:                                           ; preds = %if.then
  %1 = load i64, ptr %max_block_size.addr, align 8, !tbaa !8
  %cmp1 = icmp ugt i64 %1, 0
  br i1 %cmp1, label %land.lhs.true, label %if.else4

land.lhs.true:                                    ; preds = %if.end
  %2 = load i64, ptr %max_block_size.addr, align 8, !tbaa !8
  %cmp2 = icmp ule i64 %2, 900000
  br i1 %cmp2, label %if.then3, label %if.else4

if.then3:                                         ; preds = %land.lhs.true
  br label %if.end5

if.else4:                                         ; preds = %land.lhs.true, %if.end
  call void @__assert_fail(ptr noundef @.str.2, ptr noundef @.str.1, i32 noundef 122, ptr noundef @__PRETTY_FUNCTION__.encoder_init) #11
  unreachable

if.end5:                                          ; preds = %if.then3
  %3 = load i32, ptr %cluster_factor.addr, align 4, !tbaa !14
  %cmp6 = icmp ugt i32 %3, 0
  br i1 %cmp6, label %land.lhs.true7, label %if.else10

land.lhs.true7:                                   ; preds = %if.end5
  %4 = load i32, ptr %cluster_factor.addr, align 4, !tbaa !14
  %cmp8 = icmp ule i32 %4, 65535
  br i1 %cmp8, label %if.then9, label %if.else10

if.then9:                                         ; preds = %land.lhs.true7
  br label %if.end11

if.else10:                                        ; preds = %land.lhs.true7, %if.end5
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 123, ptr noundef @__PRETTY_FUNCTION__.encoder_init) #11
  unreachable

if.end11:                                         ; preds = %if.then9
  %5 = load i64, ptr %max_block_size.addr, align 8, !tbaa !8
  %conv = trunc i64 %5 to i32
  %6 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size12 = getelementptr inbounds %struct.encoder_state, ptr %6, i32 0, i32 9
  store i32 %conv, ptr %max_block_size12, align 4, !tbaa !16
  %7 = load i32, ptr %cluster_factor.addr, align 4, !tbaa !14
  %8 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cluster_factor13 = getelementptr inbounds %struct.encoder_state, ptr %8, i32 0, i32 10
  store i32 %7, ptr %cluster_factor13, align 4, !tbaa !18
  %9 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap = getelementptr inbounds %struct.encoder_state, ptr %9, i32 0, i32 0
  %arraydecay = getelementptr inbounds [256 x i8], ptr %cmap, i64 0, i64 0
  %10 = call i64 @llvm.objectsize.i64.p0(ptr %arraydecay, i1 false, i1 true, i1 false)
  %call.i = call ptr @__memset_chk(ptr noundef nonnull %arraydecay, i32 noundef 0, i64 noundef 256, i64 noundef %10) #12
  %11 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state = getelementptr inbounds %struct.encoder_state, ptr %11, i32 0, i32 1
  store i32 0, ptr %rle_state, align 4, !tbaa !19
  %12 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %block_crc = getelementptr inbounds %struct.encoder_state, ptr %12, i32 0, i32 3
  store i32 -1, ptr %block_crc, align 4, !tbaa !20
  %13 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock = getelementptr inbounds %struct.encoder_state, ptr %13, i32 0, i32 7
  store i32 0, ptr %nblock, align 4, !tbaa !21
  ret void
}

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

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define dso_local i32 @collect(ptr noundef %s, ptr noundef %inbuf, ptr noundef %buf_sz) local_unnamed_addr #0 {
entry:
  %s.addr = alloca ptr, align 8
  %inbuf.addr = alloca ptr, align 8
  %buf_sz.addr = alloca ptr, align 8
  %avail = alloca i64, align 8
  %p = alloca ptr, align 8
  %pLim = alloca ptr, align 8
  %block = alloca ptr, align 8
  %q = alloca ptr, align 8
  %qMax = alloca ptr, align 8
  %ch = alloca i32, align 4
  %last = alloca i32, align 4
  %run = alloca i32, align 4
  %save_crc = alloca i32, align 4
  %crc = alloca i32, align 4
  store ptr %s, ptr %s.addr, align 8, !tbaa !12
  store ptr %inbuf, ptr %inbuf.addr, align 8, !tbaa !12
  store ptr %buf_sz, ptr %buf_sz.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %avail) #12
  %0 = load ptr, ptr %buf_sz.addr, align 8, !tbaa !12
  %1 = load i64, ptr %0, align 8, !tbaa !8
  store i64 %1, ptr %avail, align 8, !tbaa !8
  call void @llvm.lifetime.start.p0(i64 8, ptr %p) #12
  %2 = load ptr, ptr %inbuf.addr, align 8, !tbaa !12
  store ptr %2, ptr %p, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %pLim) #12
  %3 = load ptr, ptr %p, align 8, !tbaa !12
  %4 = load i64, ptr %avail, align 8, !tbaa !8
  %add.ptr = getelementptr inbounds i8, ptr %3, i64 %4
  store ptr %add.ptr, ptr %pLim, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %block) #12
  %5 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %SA = getelementptr inbounds %struct.encoder_state, ptr %5, i32 0, i32 12
  %arraydecay = getelementptr inbounds [0 x i32], ptr %SA, i64 0, i64 0
  %6 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size = getelementptr inbounds %struct.encoder_state, ptr %6, i32 0, i32 9
  %7 = load i32, ptr %max_block_size, align 4, !tbaa !16
  %idx.ext = zext i32 %7 to i64
  %add.ptr1 = getelementptr inbounds i32, ptr %arraydecay, i64 %idx.ext
  %add.ptr2 = getelementptr inbounds i32, ptr %add.ptr1, i64 50
  store ptr %add.ptr2, ptr %block, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %q) #12
  %8 = load ptr, ptr %block, align 8, !tbaa !12
  %9 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock = getelementptr inbounds %struct.encoder_state, ptr %9, i32 0, i32 7
  %10 = load i32, ptr %nblock, align 4, !tbaa !21
  %idx.ext3 = zext i32 %10 to i64
  %add.ptr4 = getelementptr inbounds i8, ptr %8, i64 %idx.ext3
  store ptr %add.ptr4, ptr %q, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %qMax) #12
  %11 = load ptr, ptr %block, align 8, !tbaa !12
  %12 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size5 = getelementptr inbounds %struct.encoder_state, ptr %12, i32 0, i32 9
  %13 = load i32, ptr %max_block_size5, align 4, !tbaa !16
  %idx.ext6 = zext i32 %13 to i64
  %add.ptr7 = getelementptr inbounds i8, ptr %11, i64 %idx.ext6
  %add.ptr8 = getelementptr inbounds i8, ptr %add.ptr7, i64 -1
  store ptr %add.ptr8, ptr %qMax, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %ch) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %last) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %run) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %save_crc) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %crc) #12
  %14 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %block_crc = getelementptr inbounds %struct.encoder_state, ptr %14, i32 0, i32 3
  %15 = load i32, ptr %block_crc, align 4, !tbaa !20
  store i32 %15, ptr %crc, align 4, !tbaa !14
  %16 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state = getelementptr inbounds %struct.encoder_state, ptr %16, i32 0, i32 1
  %17 = load i32, ptr %rle_state, align 4, !tbaa !19
  %cmp = icmp sge i32 %17, 0
  br i1 %cmp, label %land.lhs.true, label %if.else

land.lhs.true:                                    ; preds = %entry
  %18 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state9 = getelementptr inbounds %struct.encoder_state, ptr %18, i32 0, i32 1
  %19 = load i32, ptr %rle_state9, align 4, !tbaa !19
  %cmp10 = icmp slt i32 %19, 259
  br i1 %cmp10, label %if.then, label %if.else

if.then:                                          ; preds = %land.lhs.true
  br label %if.end

if.else:                                          ; preds = %land.lhs.true, %entry
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 152, ptr noundef @__PRETTY_FUNCTION__.collect) #11
  unreachable

if.end:                                           ; preds = %if.then
  %20 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state11 = getelementptr inbounds %struct.encoder_state, ptr %20, i32 0, i32 1
  %21 = load i32, ptr %rle_state11, align 4, !tbaa !19
  %cmp12 = icmp ne i32 %21, 0
  %conv = zext i1 %cmp12 to i32
  %conv13 = zext nneg i32 %conv to i64
  %expval = call i64 @llvm.expect.i64(i64 %conv13, i64 0)
  %tobool = icmp ne i64 %expval, 0
  br i1 %tobool, label %if.then14, label %if.end15

if.then14:                                        ; preds = %if.end
  %22 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character = getelementptr inbounds %struct.encoder_state, ptr %22, i32 0, i32 2
  %23 = load i32, ptr %rle_character, align 4, !tbaa !22
  store i32 %23, ptr %ch, align 4, !tbaa !14
  br label %finish_run

if.end15:                                         ; preds = %if.end
  br label %state0

state0:                                           ; preds = %if.then368, %if.then359, %if.then336, %for.end, %if.end15
  %24 = load ptr, ptr %q, align 8, !tbaa !12
  %25 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp16 = icmp ugt ptr %24, %25
  %conv17 = zext i1 %cmp16 to i32
  %conv18 = zext nneg i32 %conv17 to i64
  %expval19 = call i64 @llvm.expect.i64(i64 %conv18, i64 0)
  %tobool20 = icmp ne i64 %expval19, 0
  br i1 %tobool20, label %if.then21, label %if.end23

if.then21:                                        ; preds = %state0
  %26 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state22 = getelementptr inbounds %struct.encoder_state, ptr %26, i32 0, i32 1
  store i32 -1, ptr %rle_state22, align 4, !tbaa !19
  br label %done

if.end23:                                         ; preds = %state0
  %27 = load ptr, ptr %p, align 8, !tbaa !12
  %28 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp24 = icmp eq ptr %27, %28
  %conv25 = zext i1 %cmp24 to i32
  %conv26 = zext nneg i32 %conv25 to i64
  %expval27 = call i64 @llvm.expect.i64(i64 %conv26, i64 0)
  %tobool28 = icmp ne i64 %expval27, 0
  br i1 %tobool28, label %if.then29, label %if.end31

if.then29:                                        ; preds = %if.end23
  %29 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state30 = getelementptr inbounds %struct.encoder_state, ptr %29, i32 0, i32 1
  store i32 0, ptr %rle_state30, align 4, !tbaa !19
  br label %done

if.end31:                                         ; preds = %if.end23
  %30 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr = getelementptr inbounds i8, ptr %30, i32 1
  store ptr %incdec.ptr, ptr %p, align 8, !tbaa !12
  %31 = load i8, ptr %30, align 1, !tbaa !23
  %conv32 = zext i8 %31 to i32
  store i32 %conv32, ptr %ch, align 4, !tbaa !14
  %32 = load i32, ptr %crc, align 4, !tbaa !14
  %shl = shl i32 %32, 8
  %33 = load i32, ptr %crc, align 4, !tbaa !14
  %shr = lshr i32 %33, 24
  %34 = load i32, ptr %ch, align 4, !tbaa !14
  %xor = xor i32 %shr, %34
  %idxprom = zext i32 %xor to i64
  %arrayidx = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom
  %35 = load i32, ptr %arrayidx, align 4, !tbaa !14
  %xor33 = xor i32 %shl, %35
  store i32 %xor33, ptr %crc, align 4, !tbaa !14
  br label %state1

state1:                                           ; preds = %if.then292, %if.then250, %if.then210, %if.end180, %if.end31
  %36 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap = getelementptr inbounds %struct.encoder_state, ptr %36, i32 0, i32 0
  %37 = load i32, ptr %ch, align 4, !tbaa !14
  %idxprom34 = zext i32 %37 to i64
  %arrayidx35 = getelementptr inbounds [256 x i8], ptr %cmap, i64 0, i64 %idxprom34
  store i8 1, ptr %arrayidx35, align 1, !tbaa !24
  %38 = load i32, ptr %ch, align 4, !tbaa !14
  %conv36 = trunc i32 %38 to i8
  %39 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr37 = getelementptr inbounds i8, ptr %39, i32 1
  store ptr %incdec.ptr37, ptr %q, align 8, !tbaa !12
  store i8 %conv36, ptr %39, align 1, !tbaa !23
  %40 = load ptr, ptr %q, align 8, !tbaa !12
  %41 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp38 = icmp ugt ptr %40, %41
  %conv39 = zext i1 %cmp38 to i32
  %conv40 = zext nneg i32 %conv39 to i64
  %expval41 = call i64 @llvm.expect.i64(i64 %conv40, i64 0)
  %tobool42 = icmp ne i64 %expval41, 0
  br i1 %tobool42, label %if.then43, label %if.end45

if.then43:                                        ; preds = %state1
  %42 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state44 = getelementptr inbounds %struct.encoder_state, ptr %42, i32 0, i32 1
  store i32 -1, ptr %rle_state44, align 4, !tbaa !19
  br label %done

if.end45:                                         ; preds = %state1
  %43 = load ptr, ptr %p, align 8, !tbaa !12
  %44 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp46 = icmp eq ptr %43, %44
  %conv47 = zext i1 %cmp46 to i32
  %conv48 = zext nneg i32 %conv47 to i64
  %expval49 = call i64 @llvm.expect.i64(i64 %conv48, i64 0)
  %tobool50 = icmp ne i64 %expval49, 0
  br i1 %tobool50, label %if.then51, label %if.end54

if.then51:                                        ; preds = %if.end45
  %45 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state52 = getelementptr inbounds %struct.encoder_state, ptr %45, i32 0, i32 1
  store i32 1, ptr %rle_state52, align 4, !tbaa !19
  %46 = load i32, ptr %ch, align 4, !tbaa !14
  %47 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character53 = getelementptr inbounds %struct.encoder_state, ptr %47, i32 0, i32 2
  store i32 %46, ptr %rle_character53, align 4, !tbaa !22
  br label %done

if.end54:                                         ; preds = %if.end45
  %48 = load i32, ptr %ch, align 4, !tbaa !14
  store i32 %48, ptr %last, align 4, !tbaa !14
  %49 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr55 = getelementptr inbounds i8, ptr %49, i32 1
  store ptr %incdec.ptr55, ptr %p, align 8, !tbaa !12
  %50 = load i8, ptr %49, align 1, !tbaa !23
  %conv56 = zext i8 %50 to i32
  store i32 %conv56, ptr %ch, align 4, !tbaa !14
  %51 = load i32, ptr %crc, align 4, !tbaa !14
  %shl57 = shl i32 %51, 8
  %52 = load i32, ptr %crc, align 4, !tbaa !14
  %shr58 = lshr i32 %52, 24
  %53 = load i32, ptr %ch, align 4, !tbaa !14
  %xor59 = xor i32 %shr58, %53
  %idxprom60 = zext i32 %xor59 to i64
  %arrayidx61 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom60
  %54 = load i32, ptr %arrayidx61, align 4, !tbaa !14
  %xor62 = xor i32 %shl57, %54
  store i32 %xor62, ptr %crc, align 4, !tbaa !14
  %55 = load i32, ptr %ch, align 4, !tbaa !14
  %56 = load i32, ptr %last, align 4, !tbaa !14
  %cmp63 = icmp eq i32 %55, %56
  %conv64 = zext i1 %cmp63 to i32
  %conv65 = zext nneg i32 %conv64 to i64
  %expval66 = call i64 @llvm.expect.i64(i64 %conv65, i64 0)
  %tobool67 = icmp ne i64 %expval66, 0
  br i1 %tobool67, label %if.then68, label %if.end69

if.then68:                                        ; preds = %if.end54
  br label %state2

if.end69:                                         ; preds = %if.end54
  %57 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap70 = getelementptr inbounds %struct.encoder_state, ptr %57, i32 0, i32 0
  %58 = load i32, ptr %ch, align 4, !tbaa !14
  %idxprom71 = zext i32 %58 to i64
  %arrayidx72 = getelementptr inbounds [256 x i8], ptr %cmap70, i64 0, i64 %idxprom71
  store i8 1, ptr %arrayidx72, align 1, !tbaa !24
  %59 = load i32, ptr %ch, align 4, !tbaa !14
  %conv73 = trunc i32 %59 to i8
  %60 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr74 = getelementptr inbounds i8, ptr %60, i32 1
  store ptr %incdec.ptr74, ptr %q, align 8, !tbaa !12
  store i8 %conv73, ptr %60, align 1, !tbaa !23
  %61 = load ptr, ptr %q, align 8, !tbaa !12
  %62 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp75 = icmp ugt ptr %61, %62
  %conv76 = zext i1 %cmp75 to i32
  %conv77 = zext nneg i32 %conv76 to i64
  %expval78 = call i64 @llvm.expect.i64(i64 %conv77, i64 0)
  %tobool79 = icmp ne i64 %expval78, 0
  br i1 %tobool79, label %if.then80, label %if.end82

if.then80:                                        ; preds = %if.end69
  %63 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state81 = getelementptr inbounds %struct.encoder_state, ptr %63, i32 0, i32 1
  store i32 -1, ptr %rle_state81, align 4, !tbaa !19
  br label %done

if.end82:                                         ; preds = %if.end69
  %64 = load ptr, ptr %p, align 8, !tbaa !12
  %65 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp83 = icmp eq ptr %64, %65
  %conv84 = zext i1 %cmp83 to i32
  %conv85 = zext nneg i32 %conv84 to i64
  %expval86 = call i64 @llvm.expect.i64(i64 %conv85, i64 0)
  %tobool87 = icmp ne i64 %expval86, 0
  br i1 %tobool87, label %if.then88, label %if.end91

if.then88:                                        ; preds = %if.end82
  %66 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state89 = getelementptr inbounds %struct.encoder_state, ptr %66, i32 0, i32 1
  store i32 1, ptr %rle_state89, align 4, !tbaa !19
  %67 = load i32, ptr %ch, align 4, !tbaa !14
  %68 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character90 = getelementptr inbounds %struct.encoder_state, ptr %68, i32 0, i32 2
  store i32 %67, ptr %rle_character90, align 4, !tbaa !22
  br label %done

if.end91:                                         ; preds = %if.end82
  %69 = load i32, ptr %ch, align 4, !tbaa !14
  store i32 %69, ptr %last, align 4, !tbaa !14
  %70 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr92 = getelementptr inbounds i8, ptr %70, i32 1
  store ptr %incdec.ptr92, ptr %p, align 8, !tbaa !12
  %71 = load i8, ptr %70, align 1, !tbaa !23
  %conv93 = zext i8 %71 to i32
  store i32 %conv93, ptr %ch, align 4, !tbaa !14
  %72 = load i32, ptr %crc, align 4, !tbaa !14
  %shl94 = shl i32 %72, 8
  %73 = load i32, ptr %crc, align 4, !tbaa !14
  %shr95 = lshr i32 %73, 24
  %74 = load i32, ptr %ch, align 4, !tbaa !14
  %xor96 = xor i32 %shr95, %74
  %idxprom97 = zext i32 %xor96 to i64
  %arrayidx98 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom97
  %75 = load i32, ptr %arrayidx98, align 4, !tbaa !14
  %xor99 = xor i32 %shl94, %75
  store i32 %xor99, ptr %crc, align 4, !tbaa !14
  %76 = load i32, ptr %ch, align 4, !tbaa !14
  %77 = load i32, ptr %last, align 4, !tbaa !14
  %cmp100 = icmp eq i32 %76, %77
  %conv101 = zext i1 %cmp100 to i32
  %conv102 = zext nneg i32 %conv101 to i64
  %expval103 = call i64 @llvm.expect.i64(i64 %conv102, i64 0)
  %tobool104 = icmp ne i64 %expval103, 0
  br i1 %tobool104, label %if.then105, label %if.end106

if.then105:                                       ; preds = %if.end91
  br label %state2

if.end106:                                        ; preds = %if.end91
  %78 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap107 = getelementptr inbounds %struct.encoder_state, ptr %78, i32 0, i32 0
  %79 = load i32, ptr %ch, align 4, !tbaa !14
  %idxprom108 = zext i32 %79 to i64
  %arrayidx109 = getelementptr inbounds [256 x i8], ptr %cmap107, i64 0, i64 %idxprom108
  store i8 1, ptr %arrayidx109, align 1, !tbaa !24
  %80 = load i32, ptr %ch, align 4, !tbaa !14
  %conv110 = trunc i32 %80 to i8
  %81 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr111 = getelementptr inbounds i8, ptr %81, i32 1
  store ptr %incdec.ptr111, ptr %q, align 8, !tbaa !12
  store i8 %conv110, ptr %81, align 1, !tbaa !23
  %82 = load ptr, ptr %q, align 8, !tbaa !12
  %83 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp112 = icmp ugt ptr %82, %83
  %conv113 = zext i1 %cmp112 to i32
  %conv114 = zext nneg i32 %conv113 to i64
  %expval115 = call i64 @llvm.expect.i64(i64 %conv114, i64 0)
  %tobool116 = icmp ne i64 %expval115, 0
  br i1 %tobool116, label %if.then117, label %if.end119

if.then117:                                       ; preds = %if.end106
  %84 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state118 = getelementptr inbounds %struct.encoder_state, ptr %84, i32 0, i32 1
  store i32 -1, ptr %rle_state118, align 4, !tbaa !19
  br label %done

if.end119:                                        ; preds = %if.end106
  %85 = load ptr, ptr %p, align 8, !tbaa !12
  %86 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp120 = icmp eq ptr %85, %86
  %conv121 = zext i1 %cmp120 to i32
  %conv122 = zext nneg i32 %conv121 to i64
  %expval123 = call i64 @llvm.expect.i64(i64 %conv122, i64 0)
  %tobool124 = icmp ne i64 %expval123, 0
  br i1 %tobool124, label %if.then125, label %if.end128

if.then125:                                       ; preds = %if.end119
  %87 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state126 = getelementptr inbounds %struct.encoder_state, ptr %87, i32 0, i32 1
  store i32 1, ptr %rle_state126, align 4, !tbaa !19
  %88 = load i32, ptr %ch, align 4, !tbaa !14
  %89 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character127 = getelementptr inbounds %struct.encoder_state, ptr %89, i32 0, i32 2
  store i32 %88, ptr %rle_character127, align 4, !tbaa !22
  br label %done

if.end128:                                        ; preds = %if.end119
  %90 = load i32, ptr %ch, align 4, !tbaa !14
  store i32 %90, ptr %last, align 4, !tbaa !14
  %91 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr129 = getelementptr inbounds i8, ptr %91, i32 1
  store ptr %incdec.ptr129, ptr %p, align 8, !tbaa !12
  %92 = load i8, ptr %91, align 1, !tbaa !23
  %conv130 = zext i8 %92 to i32
  store i32 %conv130, ptr %ch, align 4, !tbaa !14
  %93 = load i32, ptr %crc, align 4, !tbaa !14
  %shl131 = shl i32 %93, 8
  %94 = load i32, ptr %crc, align 4, !tbaa !14
  %shr132 = lshr i32 %94, 24
  %95 = load i32, ptr %ch, align 4, !tbaa !14
  %xor133 = xor i32 %shr132, %95
  %idxprom134 = zext i32 %xor133 to i64
  %arrayidx135 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom134
  %96 = load i32, ptr %arrayidx135, align 4, !tbaa !14
  %xor136 = xor i32 %shl131, %96
  store i32 %xor136, ptr %crc, align 4, !tbaa !14
  %97 = load i32, ptr %ch, align 4, !tbaa !14
  %98 = load i32, ptr %last, align 4, !tbaa !14
  %cmp137 = icmp eq i32 %97, %98
  %conv138 = zext i1 %cmp137 to i32
  %conv139 = zext nneg i32 %conv138 to i64
  %expval140 = call i64 @llvm.expect.i64(i64 %conv139, i64 0)
  %tobool141 = icmp ne i64 %expval140, 0
  br i1 %tobool141, label %if.then142, label %if.end143

if.then142:                                       ; preds = %if.end128
  br label %state2

if.end143:                                        ; preds = %if.end128
  %99 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap144 = getelementptr inbounds %struct.encoder_state, ptr %99, i32 0, i32 0
  %100 = load i32, ptr %ch, align 4, !tbaa !14
  %idxprom145 = zext i32 %100 to i64
  %arrayidx146 = getelementptr inbounds [256 x i8], ptr %cmap144, i64 0, i64 %idxprom145
  store i8 1, ptr %arrayidx146, align 1, !tbaa !24
  %101 = load i32, ptr %ch, align 4, !tbaa !14
  %conv147 = trunc i32 %101 to i8
  %102 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr148 = getelementptr inbounds i8, ptr %102, i32 1
  store ptr %incdec.ptr148, ptr %q, align 8, !tbaa !12
  store i8 %conv147, ptr %102, align 1, !tbaa !23
  %103 = load ptr, ptr %q, align 8, !tbaa !12
  %104 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp149 = icmp ugt ptr %103, %104
  %conv150 = zext i1 %cmp149 to i32
  %conv151 = zext nneg i32 %conv150 to i64
  %expval152 = call i64 @llvm.expect.i64(i64 %conv151, i64 0)
  %tobool153 = icmp ne i64 %expval152, 0
  br i1 %tobool153, label %if.then154, label %if.end156

if.then154:                                       ; preds = %if.end143
  %105 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state155 = getelementptr inbounds %struct.encoder_state, ptr %105, i32 0, i32 1
  store i32 -1, ptr %rle_state155, align 4, !tbaa !19
  br label %done

if.end156:                                        ; preds = %if.end143
  %106 = load ptr, ptr %p, align 8, !tbaa !12
  %107 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp157 = icmp eq ptr %106, %107
  %conv158 = zext i1 %cmp157 to i32
  %conv159 = zext nneg i32 %conv158 to i64
  %expval160 = call i64 @llvm.expect.i64(i64 %conv159, i64 0)
  %tobool161 = icmp ne i64 %expval160, 0
  br i1 %tobool161, label %if.then162, label %if.end165

if.then162:                                       ; preds = %if.end156
  %108 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state163 = getelementptr inbounds %struct.encoder_state, ptr %108, i32 0, i32 1
  store i32 1, ptr %rle_state163, align 4, !tbaa !19
  %109 = load i32, ptr %ch, align 4, !tbaa !14
  %110 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character164 = getelementptr inbounds %struct.encoder_state, ptr %110, i32 0, i32 2
  store i32 %109, ptr %rle_character164, align 4, !tbaa !22
  br label %done

if.end165:                                        ; preds = %if.end156
  %111 = load i32, ptr %ch, align 4, !tbaa !14
  store i32 %111, ptr %last, align 4, !tbaa !14
  %112 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr166 = getelementptr inbounds i8, ptr %112, i32 1
  store ptr %incdec.ptr166, ptr %p, align 8, !tbaa !12
  %113 = load i8, ptr %112, align 1, !tbaa !23
  %conv167 = zext i8 %113 to i32
  store i32 %conv167, ptr %ch, align 4, !tbaa !14
  %114 = load i32, ptr %crc, align 4, !tbaa !14
  %shl168 = shl i32 %114, 8
  %115 = load i32, ptr %crc, align 4, !tbaa !14
  %shr169 = lshr i32 %115, 24
  %116 = load i32, ptr %ch, align 4, !tbaa !14
  %xor170 = xor i32 %shr169, %116
  %idxprom171 = zext i32 %xor170 to i64
  %arrayidx172 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom171
  %117 = load i32, ptr %arrayidx172, align 4, !tbaa !14
  %xor173 = xor i32 %shl168, %117
  store i32 %xor173, ptr %crc, align 4, !tbaa !14
  %118 = load i32, ptr %ch, align 4, !tbaa !14
  %119 = load i32, ptr %last, align 4, !tbaa !14
  %cmp174 = icmp eq i32 %118, %119
  %conv175 = zext i1 %cmp174 to i32
  %conv176 = zext nneg i32 %conv175 to i64
  %expval177 = call i64 @llvm.expect.i64(i64 %conv176, i64 0)
  %tobool178 = icmp ne i64 %expval177, 0
  br i1 %tobool178, label %if.then179, label %if.end180

if.then179:                                       ; preds = %if.end165
  br label %state2

if.end180:                                        ; preds = %if.end165
  br label %state1

state2:                                           ; preds = %if.then179, %if.then142, %if.then105, %if.then68
  %120 = load i32, ptr %ch, align 4, !tbaa !14
  %conv181 = trunc i32 %120 to i8
  %121 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr182 = getelementptr inbounds i8, ptr %121, i32 1
  store ptr %incdec.ptr182, ptr %q, align 8, !tbaa !12
  store i8 %conv181, ptr %121, align 1, !tbaa !23
  %122 = load ptr, ptr %q, align 8, !tbaa !12
  %123 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp183 = icmp ugt ptr %122, %123
  %conv184 = zext i1 %cmp183 to i32
  %conv185 = zext nneg i32 %conv184 to i64
  %expval186 = call i64 @llvm.expect.i64(i64 %conv185, i64 0)
  %tobool187 = icmp ne i64 %expval186, 0
  br i1 %tobool187, label %if.then188, label %if.end190

if.then188:                                       ; preds = %state2
  %124 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state189 = getelementptr inbounds %struct.encoder_state, ptr %124, i32 0, i32 1
  store i32 -1, ptr %rle_state189, align 4, !tbaa !19
  br label %done

if.end190:                                        ; preds = %state2
  %125 = load ptr, ptr %p, align 8, !tbaa !12
  %126 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp191 = icmp eq ptr %125, %126
  %conv192 = zext i1 %cmp191 to i32
  %conv193 = zext nneg i32 %conv192 to i64
  %expval194 = call i64 @llvm.expect.i64(i64 %conv193, i64 0)
  %tobool195 = icmp ne i64 %expval194, 0
  br i1 %tobool195, label %if.then196, label %if.end199

if.then196:                                       ; preds = %if.end190
  %127 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state197 = getelementptr inbounds %struct.encoder_state, ptr %127, i32 0, i32 1
  store i32 2, ptr %rle_state197, align 4, !tbaa !19
  %128 = load i32, ptr %ch, align 4, !tbaa !14
  %129 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character198 = getelementptr inbounds %struct.encoder_state, ptr %129, i32 0, i32 2
  store i32 %128, ptr %rle_character198, align 4, !tbaa !22
  br label %done

if.end199:                                        ; preds = %if.end190
  %130 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr200 = getelementptr inbounds i8, ptr %130, i32 1
  store ptr %incdec.ptr200, ptr %p, align 8, !tbaa !12
  %131 = load i8, ptr %130, align 1, !tbaa !23
  %conv201 = zext i8 %131 to i32
  store i32 %conv201, ptr %ch, align 4, !tbaa !14
  %132 = load i32, ptr %crc, align 4, !tbaa !14
  %shl202 = shl i32 %132, 8
  %133 = load i32, ptr %crc, align 4, !tbaa !14
  %shr203 = lshr i32 %133, 24
  %134 = load i32, ptr %ch, align 4, !tbaa !14
  %xor204 = xor i32 %shr203, %134
  %idxprom205 = zext i32 %xor204 to i64
  %arrayidx206 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom205
  %135 = load i32, ptr %arrayidx206, align 4, !tbaa !14
  %xor207 = xor i32 %shl202, %135
  store i32 %xor207, ptr %crc, align 4, !tbaa !14
  %136 = load i32, ptr %ch, align 4, !tbaa !14
  %137 = load i32, ptr %last, align 4, !tbaa !14
  %cmp208 = icmp ne i32 %136, %137
  br i1 %cmp208, label %if.then210, label %if.end211

if.then210:                                       ; preds = %if.end199
  br label %state1

if.end211:                                        ; preds = %if.end199
  %138 = load i32, ptr %ch, align 4, !tbaa !14
  %conv212 = trunc i32 %138 to i8
  %139 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr213 = getelementptr inbounds i8, ptr %139, i32 1
  store ptr %incdec.ptr213, ptr %q, align 8, !tbaa !12
  store i8 %conv212, ptr %139, align 1, !tbaa !23
  %140 = load ptr, ptr %q, align 8, !tbaa !12
  %141 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp214 = icmp uge ptr %140, %141
  br i1 %cmp214, label %land.rhs, label %land.end224

land.rhs:                                         ; preds = %if.end211
  %142 = load ptr, ptr %q, align 8, !tbaa !12
  %143 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp216 = icmp ugt ptr %142, %143
  br i1 %cmp216, label %lor.end, label %lor.rhs

lor.rhs:                                          ; preds = %land.rhs
  %144 = load ptr, ptr %p, align 8, !tbaa !12
  %145 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp218 = icmp ult ptr %144, %145
  br i1 %cmp218, label %land.rhs220, label %land.end

land.rhs220:                                      ; preds = %lor.rhs
  %146 = load ptr, ptr %p, align 8, !tbaa !12
  %147 = load i8, ptr %146, align 1, !tbaa !23
  %conv221 = zext i8 %147 to i32
  %148 = load i32, ptr %last, align 4, !tbaa !14
  %cmp222 = icmp eq i32 %conv221, %148
  br label %land.end

land.end:                                         ; preds = %land.rhs220, %lor.rhs
  %149 = phi i1 [ false, %lor.rhs ], [ %cmp222, %land.rhs220 ]
  br label %lor.end

lor.end:                                          ; preds = %land.end, %land.rhs
  %150 = phi i1 [ true, %land.rhs ], [ %149, %land.end ]
  br label %land.end224

land.end224:                                      ; preds = %lor.end, %if.end211
  %151 = phi i1 [ false, %if.end211 ], [ %150, %lor.end ]
  %land.ext = zext i1 %151 to i32
  %conv225 = zext nneg i32 %land.ext to i64
  %expval226 = call i64 @llvm.expect.i64(i64 %conv225, i64 0)
  %tobool227 = icmp ne i64 %expval226, 0
  br i1 %tobool227, label %if.then228, label %if.end230

if.then228:                                       ; preds = %land.end224
  %152 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state229 = getelementptr inbounds %struct.encoder_state, ptr %152, i32 0, i32 1
  store i32 -1, ptr %rle_state229, align 4, !tbaa !19
  br label %done

if.end230:                                        ; preds = %land.end224
  %153 = load ptr, ptr %p, align 8, !tbaa !12
  %154 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp231 = icmp eq ptr %153, %154
  %conv232 = zext i1 %cmp231 to i32
  %conv233 = zext nneg i32 %conv232 to i64
  %expval234 = call i64 @llvm.expect.i64(i64 %conv233, i64 0)
  %tobool235 = icmp ne i64 %expval234, 0
  br i1 %tobool235, label %if.then236, label %if.end239

if.then236:                                       ; preds = %if.end230
  %155 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state237 = getelementptr inbounds %struct.encoder_state, ptr %155, i32 0, i32 1
  store i32 3, ptr %rle_state237, align 4, !tbaa !19
  %156 = load i32, ptr %ch, align 4, !tbaa !14
  %157 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character238 = getelementptr inbounds %struct.encoder_state, ptr %157, i32 0, i32 2
  store i32 %156, ptr %rle_character238, align 4, !tbaa !22
  br label %done

if.end239:                                        ; preds = %if.end230
  %158 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr240 = getelementptr inbounds i8, ptr %158, i32 1
  store ptr %incdec.ptr240, ptr %p, align 8, !tbaa !12
  %159 = load i8, ptr %158, align 1, !tbaa !23
  %conv241 = zext i8 %159 to i32
  store i32 %conv241, ptr %ch, align 4, !tbaa !14
  %160 = load i32, ptr %crc, align 4, !tbaa !14
  %shl242 = shl i32 %160, 8
  %161 = load i32, ptr %crc, align 4, !tbaa !14
  %shr243 = lshr i32 %161, 24
  %162 = load i32, ptr %ch, align 4, !tbaa !14
  %xor244 = xor i32 %shr243, %162
  %idxprom245 = zext i32 %xor244 to i64
  %arrayidx246 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom245
  %163 = load i32, ptr %arrayidx246, align 4, !tbaa !14
  %xor247 = xor i32 %shl242, %163
  store i32 %xor247, ptr %crc, align 4, !tbaa !14
  %164 = load i32, ptr %ch, align 4, !tbaa !14
  %165 = load i32, ptr %last, align 4, !tbaa !14
  %cmp248 = icmp ne i32 %164, %165
  br i1 %cmp248, label %if.then250, label %if.end251

if.then250:                                       ; preds = %if.end239
  br label %state1

if.end251:                                        ; preds = %if.end239
  %166 = load ptr, ptr %q, align 8, !tbaa !12
  %167 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp252 = icmp ult ptr %166, %167
  br i1 %cmp252, label %if.then254, label %if.else255

if.then254:                                       ; preds = %if.end251
  br label %if.end256

if.else255:                                       ; preds = %if.end251
  call void @__assert_fail(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 233, ptr noundef @__PRETTY_FUNCTION__.collect) #11
  unreachable

if.end256:                                        ; preds = %if.then254
  %168 = load i32, ptr %ch, align 4, !tbaa !14
  %conv257 = trunc i32 %168 to i8
  %169 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr258 = getelementptr inbounds i8, ptr %169, i32 1
  store ptr %incdec.ptr258, ptr %q, align 8, !tbaa !12
  store i8 %conv257, ptr %169, align 1, !tbaa !23
  store i32 4, ptr %run, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %if.end256
  %170 = load i32, ptr %run, align 4, !tbaa !14
  %cmp259 = icmp ult i32 %170, 259
  br i1 %cmp259, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %171 = load ptr, ptr %p, align 8, !tbaa !12
  %172 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp261 = icmp eq ptr %171, %172
  %conv262 = zext i1 %cmp261 to i32
  %conv263 = zext nneg i32 %conv262 to i64
  %expval264 = call i64 @llvm.expect.i64(i64 %conv263, i64 0)
  %tobool265 = icmp ne i64 %expval264, 0
  br i1 %tobool265, label %if.then266, label %if.end269

if.then266:                                       ; preds = %for.body
  %173 = load i32, ptr %run, align 4, !tbaa !14
  %174 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state267 = getelementptr inbounds %struct.encoder_state, ptr %174, i32 0, i32 1
  store i32 %173, ptr %rle_state267, align 4, !tbaa !19
  %175 = load i32, ptr %ch, align 4, !tbaa !14
  %176 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_character268 = getelementptr inbounds %struct.encoder_state, ptr %176, i32 0, i32 2
  store i32 %175, ptr %rle_character268, align 4, !tbaa !22
  br label %done

if.end269:                                        ; preds = %for.body
  %177 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr270 = getelementptr inbounds i8, ptr %177, i32 1
  store ptr %incdec.ptr270, ptr %p, align 8, !tbaa !12
  %178 = load i8, ptr %177, align 1, !tbaa !23
  %conv271 = zext i8 %178 to i32
  store i32 %conv271, ptr %ch, align 4, !tbaa !14
  %179 = load i32, ptr %crc, align 4, !tbaa !14
  store i32 %179, ptr %save_crc, align 4, !tbaa !14
  %180 = load i32, ptr %crc, align 4, !tbaa !14
  %shl272 = shl i32 %180, 8
  %181 = load i32, ptr %crc, align 4, !tbaa !14
  %shr273 = lshr i32 %181, 24
  %182 = load i32, ptr %ch, align 4, !tbaa !14
  %xor274 = xor i32 %shr273, %182
  %idxprom275 = zext i32 %xor274 to i64
  %arrayidx276 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom275
  %183 = load i32, ptr %arrayidx276, align 4, !tbaa !14
  %xor277 = xor i32 %shl272, %183
  store i32 %xor277, ptr %crc, align 4, !tbaa !14
  %184 = load i32, ptr %ch, align 4, !tbaa !14
  %185 = load i32, ptr %last, align 4, !tbaa !14
  %cmp278 = icmp ne i32 %184, %185
  br i1 %cmp278, label %if.then280, label %if.end296

if.then280:                                       ; preds = %if.end269
  %186 = load i32, ptr %run, align 4, !tbaa !14
  %sub = sub i32 %186, 4
  %conv281 = trunc i32 %sub to i8
  %187 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr282 = getelementptr inbounds i8, ptr %187, i32 1
  store ptr %incdec.ptr282, ptr %q, align 8, !tbaa !12
  store i8 %conv281, ptr %187, align 1, !tbaa !23
  %188 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap283 = getelementptr inbounds %struct.encoder_state, ptr %188, i32 0, i32 0
  %189 = load i32, ptr %run, align 4, !tbaa !14
  %sub284 = sub i32 %189, 4
  %idxprom285 = zext i32 %sub284 to i64
  %arrayidx286 = getelementptr inbounds [256 x i8], ptr %cmap283, i64 0, i64 %idxprom285
  store i8 1, ptr %arrayidx286, align 1, !tbaa !24
  %190 = load ptr, ptr %q, align 8, !tbaa !12
  %191 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp287 = icmp ule ptr %190, %191
  %conv288 = zext i1 %cmp287 to i32
  %conv289 = zext nneg i32 %conv288 to i64
  %expval290 = call i64 @llvm.expect.i64(i64 %conv289, i64 1)
  %tobool291 = icmp ne i64 %expval290, 0
  br i1 %tobool291, label %if.then292, label %if.end293

if.then292:                                       ; preds = %if.then280
  br label %state1

if.end293:                                        ; preds = %if.then280
  %192 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr294 = getelementptr inbounds i8, ptr %192, i32 -1
  store ptr %incdec.ptr294, ptr %p, align 8, !tbaa !12
  %193 = load i32, ptr %save_crc, align 4, !tbaa !14
  store i32 %193, ptr %crc, align 4, !tbaa !14
  %194 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state295 = getelementptr inbounds %struct.encoder_state, ptr %194, i32 0, i32 1
  store i32 -1, ptr %rle_state295, align 4, !tbaa !19
  br label %done

if.end296:                                        ; preds = %if.end269
  br label %for.inc

for.inc:                                          ; preds = %if.end296
  %195 = load i32, ptr %run, align 4, !tbaa !14
  %inc = add i32 %195, 1
  store i32 %inc, ptr %run, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !26

for.end:                                          ; preds = %for.cond
  %196 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr297 = getelementptr inbounds i8, ptr %196, i32 1
  store ptr %incdec.ptr297, ptr %q, align 8, !tbaa !12
  store i8 -1, ptr %196, align 1, !tbaa !23
  %197 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap298 = getelementptr inbounds %struct.encoder_state, ptr %197, i32 0, i32 0
  %arrayidx299 = getelementptr inbounds [256 x i8], ptr %cmap298, i64 0, i64 255
  store i8 1, ptr %arrayidx299, align 1, !tbaa !24
  br label %state0

finish_run:                                       ; preds = %if.end369, %if.then14
  %198 = load ptr, ptr %q, align 8, !tbaa !12
  %199 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp300 = icmp uge ptr %198, %199
  br i1 %cmp300, label %land.lhs.true302, label %if.end317

land.lhs.true302:                                 ; preds = %finish_run
  %200 = load ptr, ptr %q, align 8, !tbaa !12
  %201 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp303 = icmp ugt ptr %200, %201
  br i1 %cmp303, label %if.then315, label %lor.lhs.false

lor.lhs.false:                                    ; preds = %land.lhs.true302
  %202 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state305 = getelementptr inbounds %struct.encoder_state, ptr %202, i32 0, i32 1
  %203 = load i32, ptr %rle_state305, align 4, !tbaa !19
  %cmp306 = icmp eq i32 %203, 3
  br i1 %cmp306, label %land.lhs.true308, label %if.end317

land.lhs.true308:                                 ; preds = %lor.lhs.false
  %204 = load ptr, ptr %p, align 8, !tbaa !12
  %205 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp309 = icmp ult ptr %204, %205
  br i1 %cmp309, label %land.lhs.true311, label %if.end317

land.lhs.true311:                                 ; preds = %land.lhs.true308
  %206 = load ptr, ptr %p, align 8, !tbaa !12
  %207 = load i8, ptr %206, align 1, !tbaa !23
  %conv312 = zext i8 %207 to i32
  %208 = load i32, ptr %ch, align 4, !tbaa !14
  %cmp313 = icmp eq i32 %conv312, %208
  br i1 %cmp313, label %if.then315, label %if.end317

if.then315:                                       ; preds = %land.lhs.true311, %land.lhs.true302
  %209 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state316 = getelementptr inbounds %struct.encoder_state, ptr %209, i32 0, i32 1
  store i32 -1, ptr %rle_state316, align 4, !tbaa !19
  br label %done

if.end317:                                        ; preds = %land.lhs.true311, %land.lhs.true308, %lor.lhs.false, %finish_run
  %210 = load ptr, ptr %p, align 8, !tbaa !12
  %211 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp318 = icmp eq ptr %210, %211
  br i1 %cmp318, label %if.then320, label %if.end321

if.then320:                                       ; preds = %if.end317
  br label %done

if.end321:                                        ; preds = %if.end317
  %212 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state322 = getelementptr inbounds %struct.encoder_state, ptr %212, i32 0, i32 1
  %213 = load i32, ptr %rle_state322, align 4, !tbaa !19
  %cmp323 = icmp sge i32 %213, 4
  br i1 %cmp323, label %if.then325, label %if.end364

if.then325:                                       ; preds = %if.end321
  %214 = load ptr, ptr %q, align 8, !tbaa !12
  %215 = load ptr, ptr %qMax, align 8, !tbaa !12
  %cmp326 = icmp ule ptr %214, %215
  br i1 %cmp326, label %if.then328, label %if.else329

if.then328:                                       ; preds = %if.then325
  br label %if.end330

if.else329:                                       ; preds = %if.then325
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 287, ptr noundef @__PRETTY_FUNCTION__.collect) #11
  unreachable

if.end330:                                        ; preds = %if.then328
  br label %while.cond

while.cond:                                       ; preds = %if.end363, %if.end330
  %216 = load ptr, ptr %p, align 8, !tbaa !12
  %217 = load ptr, ptr %pLim, align 8, !tbaa !12
  %cmp331 = icmp ult ptr %216, %217
  br i1 %cmp331, label %while.body, label %while.end

while.body:                                       ; preds = %while.cond
  %218 = load ptr, ptr %p, align 8, !tbaa !12
  %219 = load i8, ptr %218, align 1, !tbaa !23
  %conv333 = zext i8 %219 to i32
  %220 = load i32, ptr %ch, align 4, !tbaa !14
  %cmp334 = icmp ne i32 %conv333, %220
  br i1 %cmp334, label %if.then336, label %if.end346

if.then336:                                       ; preds = %while.body
  %221 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state337 = getelementptr inbounds %struct.encoder_state, ptr %221, i32 0, i32 1
  %222 = load i32, ptr %rle_state337, align 4, !tbaa !19
  %sub338 = sub nsw i32 %222, 4
  %conv339 = trunc i32 %sub338 to i8
  %223 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr340 = getelementptr inbounds i8, ptr %223, i32 1
  store ptr %incdec.ptr340, ptr %q, align 8, !tbaa !12
  store i8 %conv339, ptr %223, align 1, !tbaa !23
  %224 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap341 = getelementptr inbounds %struct.encoder_state, ptr %224, i32 0, i32 0
  %225 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state342 = getelementptr inbounds %struct.encoder_state, ptr %225, i32 0, i32 1
  %226 = load i32, ptr %rle_state342, align 4, !tbaa !19
  %sub343 = sub nsw i32 %226, 4
  %idxprom344 = sext i32 %sub343 to i64
  %arrayidx345 = getelementptr inbounds [256 x i8], ptr %cmap341, i64 0, i64 %idxprom344
  store i8 1, ptr %arrayidx345, align 1, !tbaa !24
  br label %state0

if.end346:                                        ; preds = %while.body
  %227 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr347 = getelementptr inbounds i8, ptr %227, i32 1
  store ptr %incdec.ptr347, ptr %p, align 8, !tbaa !12
  %228 = load i32, ptr %crc, align 4, !tbaa !14
  %shl348 = shl i32 %228, 8
  %229 = load i32, ptr %crc, align 4, !tbaa !14
  %shr349 = lshr i32 %229, 24
  %230 = load i32, ptr %ch, align 4, !tbaa !14
  %xor350 = xor i32 %shr349, %230
  %idxprom351 = zext i32 %xor350 to i64
  %arrayidx352 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom351
  %231 = load i32, ptr %arrayidx352, align 4, !tbaa !14
  %xor353 = xor i32 %shl348, %231
  store i32 %xor353, ptr %crc, align 4, !tbaa !14
  %232 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state354 = getelementptr inbounds %struct.encoder_state, ptr %232, i32 0, i32 1
  %233 = load i32, ptr %rle_state354, align 4, !tbaa !19
  %inc355 = add nsw i32 %233, 1
  store i32 %inc355, ptr %rle_state354, align 4, !tbaa !19
  %234 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state356 = getelementptr inbounds %struct.encoder_state, ptr %234, i32 0, i32 1
  %235 = load i32, ptr %rle_state356, align 4, !tbaa !19
  %cmp357 = icmp eq i32 %235, 259
  br i1 %cmp357, label %if.then359, label %if.end363

if.then359:                                       ; preds = %if.end346
  %236 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr360 = getelementptr inbounds i8, ptr %236, i32 1
  store ptr %incdec.ptr360, ptr %q, align 8, !tbaa !12
  store i8 -1, ptr %236, align 1, !tbaa !23
  %237 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap361 = getelementptr inbounds %struct.encoder_state, ptr %237, i32 0, i32 0
  %arrayidx362 = getelementptr inbounds [256 x i8], ptr %cmap361, i64 0, i64 255
  store i8 1, ptr %arrayidx362, align 1, !tbaa !24
  br label %state0

if.end363:                                        ; preds = %if.end346
  br label %while.cond, !llvm.loop !29

while.end:                                        ; preds = %while.cond
  br label %done

if.end364:                                        ; preds = %if.end321
  %238 = load ptr, ptr %p, align 8, !tbaa !12
  %239 = load i8, ptr %238, align 1, !tbaa !23
  %conv365 = zext i8 %239 to i32
  %240 = load i32, ptr %ch, align 4, !tbaa !14
  %cmp366 = icmp ne i32 %conv365, %240
  br i1 %cmp366, label %if.then368, label %if.end369

if.then368:                                       ; preds = %if.end364
  br label %state0

if.end369:                                        ; preds = %if.end364
  %241 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr370 = getelementptr inbounds i8, ptr %241, i32 1
  store ptr %incdec.ptr370, ptr %p, align 8, !tbaa !12
  %242 = load i32, ptr %crc, align 4, !tbaa !14
  %shl371 = shl i32 %242, 8
  %243 = load i32, ptr %crc, align 4, !tbaa !14
  %shr372 = lshr i32 %243, 24
  %244 = load i32, ptr %ch, align 4, !tbaa !14
  %xor373 = xor i32 %shr372, %244
  %idxprom374 = zext i32 %xor373 to i64
  %arrayidx375 = getelementptr inbounds [256 x i32], ptr @crc_table, i64 0, i64 %idxprom374
  %245 = load i32, ptr %arrayidx375, align 4, !tbaa !14
  %xor376 = xor i32 %shl371, %245
  store i32 %xor376, ptr %crc, align 4, !tbaa !14
  %246 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state377 = getelementptr inbounds %struct.encoder_state, ptr %246, i32 0, i32 1
  %247 = load i32, ptr %rle_state377, align 4, !tbaa !19
  %inc378 = add nsw i32 %247, 1
  store i32 %inc378, ptr %rle_state377, align 4, !tbaa !19
  %248 = load i32, ptr %ch, align 4, !tbaa !14
  %conv379 = trunc i32 %248 to i8
  %249 = load ptr, ptr %q, align 8, !tbaa !12
  %incdec.ptr380 = getelementptr inbounds i8, ptr %249, i32 1
  store ptr %incdec.ptr380, ptr %q, align 8, !tbaa !12
  store i8 %conv379, ptr %249, align 1, !tbaa !23
  br label %finish_run

done:                                             ; preds = %while.end, %if.then320, %if.then315, %if.end293, %if.then266, %if.then236, %if.then228, %if.then196, %if.then188, %if.then162, %if.then154, %if.then125, %if.then117, %if.then88, %if.then80, %if.then51, %if.then43, %if.then29, %if.then21
  %250 = load ptr, ptr %q, align 8, !tbaa !12
  %251 = load ptr, ptr %block, align 8, !tbaa !12
  %sub.ptr.lhs.cast = ptrtoint ptr %250 to i64
  %sub.ptr.rhs.cast = ptrtoint ptr %251 to i64
  %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
  %conv381 = trunc i64 %sub.ptr.sub to i32
  %252 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock382 = getelementptr inbounds %struct.encoder_state, ptr %252, i32 0, i32 7
  store i32 %conv381, ptr %nblock382, align 4, !tbaa !21
  %253 = load i32, ptr %crc, align 4, !tbaa !14
  %254 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %block_crc383 = getelementptr inbounds %struct.encoder_state, ptr %254, i32 0, i32 3
  store i32 %253, ptr %block_crc383, align 4, !tbaa !20
  %255 = load ptr, ptr %p, align 8, !tbaa !12
  %256 = load ptr, ptr %inbuf.addr, align 8, !tbaa !12
  %sub.ptr.lhs.cast384 = ptrtoint ptr %255 to i64
  %sub.ptr.rhs.cast385 = ptrtoint ptr %256 to i64
  %sub.ptr.sub386 = sub i64 %sub.ptr.lhs.cast384, %sub.ptr.rhs.cast385
  %257 = load ptr, ptr %buf_sz.addr, align 8, !tbaa !12
  %258 = load i64, ptr %257, align 8, !tbaa !8
  %sub387 = sub i64 %258, %sub.ptr.sub386
  store i64 %sub387, ptr %257, align 8, !tbaa !8
  %259 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state388 = getelementptr inbounds %struct.encoder_state, ptr %259, i32 0, i32 1
  %260 = load i32, ptr %rle_state388, align 4, !tbaa !19
  %cmp389 = icmp slt i32 %260, 0
  %conv390 = zext i1 %cmp389 to i32
  call void @llvm.lifetime.end.p0(i64 4, ptr %crc) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %save_crc) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %run) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %last) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %ch) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %qMax) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %q) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %block) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %pLim) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %p) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %avail) #12
  ret i32 %conv390
}

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

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

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

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define dso_local i64 @encode(ptr noundef %s, ptr noundef %crc) local_unnamed_addr #0 {
entry:
  %s.addr = alloca ptr, align 8
  %crc.addr = alloca ptr, align 8
  %cost = alloca i32, align 4
  %pk = alloca i32, align 4
  %i = alloca i32, align 4
  %sp = alloca ptr, align 8
  %smp = alloca ptr, align 8
  %c = alloca i8, align 1
  %j = alloca i8, align 1
  %p = alloca i32, align 4
  %EOB = alloca i32, align 4
  %cmap = alloca [256 x i8], align 16
  %block = alloca ptr, align 8
  %v = alloca i32, align 4
  %z = alloca i32, align 4
  %l = alloca i32, align 4
  %h = alloca i32, align 4
  store ptr %s, ptr %s.addr, align 8, !tbaa !12
  store ptr %crc, ptr %crc.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %cost) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %pk) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %sp) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %smp) #12
  call void @llvm.lifetime.start.p0(i64 1, ptr %c) #12
  call void @llvm.lifetime.start.p0(i64 1, ptr %j) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %p) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %EOB) #12
  call void @llvm.lifetime.start.p0(i64 256, ptr %cmap) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %block) #12
  %0 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %SA = getelementptr inbounds %struct.encoder_state, ptr %0, i32 0, i32 12
  %arraydecay = getelementptr inbounds [0 x i32], ptr %SA, i64 0, i64 0
  %1 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size = getelementptr inbounds %struct.encoder_state, ptr %1, i32 0, i32 9
  %2 = load i32, ptr %max_block_size, align 4, !tbaa !16
  %idx.ext = zext i32 %2 to i64
  %add.ptr = getelementptr inbounds i32, ptr %arraydecay, i64 %idx.ext
  %add.ptr1 = getelementptr inbounds i32, ptr %add.ptr, i64 50
  store ptr %add.ptr1, ptr %block, align 8, !tbaa !12
  %3 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state = getelementptr inbounds %struct.encoder_state, ptr %3, i32 0, i32 1
  %4 = load i32, ptr %rle_state, align 4, !tbaa !19
  %cmp = icmp sge i32 %4, 4
  br i1 %cmp, label %if.then, label %if.end12

if.then:                                          ; preds = %entry
  %5 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock = getelementptr inbounds %struct.encoder_state, ptr %5, i32 0, i32 7
  %6 = load i32, ptr %nblock, align 4, !tbaa !21
  %7 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size2 = getelementptr inbounds %struct.encoder_state, ptr %7, i32 0, i32 9
  %8 = load i32, ptr %max_block_size2, align 4, !tbaa !16
  %cmp3 = icmp ult i32 %6, %8
  br i1 %cmp3, label %if.then4, label %if.else

if.then4:                                         ; preds = %if.then
  br label %if.end

if.else:                                          ; preds = %if.then
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 444, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end:                                           ; preds = %if.then4
  %9 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state5 = getelementptr inbounds %struct.encoder_state, ptr %9, i32 0, i32 1
  %10 = load i32, ptr %rle_state5, align 4, !tbaa !19
  %sub = sub nsw i32 %10, 4
  %conv = trunc i32 %sub to i8
  %11 = load ptr, ptr %block, align 8, !tbaa !12
  %12 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock6 = getelementptr inbounds %struct.encoder_state, ptr %12, i32 0, i32 7
  %13 = load i32, ptr %nblock6, align 4, !tbaa !21
  %inc = add i32 %13, 1
  store i32 %inc, ptr %nblock6, align 4, !tbaa !21
  %idxprom = zext i32 %13 to i64
  %arrayidx = getelementptr inbounds i8, ptr %11, i64 %idxprom
  store i8 %conv, ptr %arrayidx, align 1, !tbaa !23
  %14 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap7 = getelementptr inbounds %struct.encoder_state, ptr %14, i32 0, i32 0
  %15 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %rle_state8 = getelementptr inbounds %struct.encoder_state, ptr %15, i32 0, i32 1
  %16 = load i32, ptr %rle_state8, align 4, !tbaa !19
  %sub9 = sub nsw i32 %16, 4
  %idxprom10 = sext i32 %sub9 to i64
  %arrayidx11 = getelementptr inbounds [256 x i8], ptr %cmap7, i64 0, i64 %idxprom10
  store i8 1, ptr %arrayidx11, align 1, !tbaa !24
  br label %if.end12

if.end12:                                         ; preds = %if.end, %entry
  %17 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock13 = getelementptr inbounds %struct.encoder_state, ptr %17, i32 0, i32 7
  %18 = load i32, ptr %nblock13, align 4, !tbaa !21
  %cmp14 = icmp ugt i32 %18, 0
  br i1 %cmp14, label %if.then16, label %if.else17

if.then16:                                        ; preds = %if.end12
  br label %if.end18

if.else17:                                        ; preds = %if.end12
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 448, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end18:                                         ; preds = %if.then16
  %arraydecay19 = getelementptr inbounds [256 x i8], ptr %cmap, i64 0, i64 0
  %19 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap20 = getelementptr inbounds %struct.encoder_state, ptr %19, i32 0, i32 0
  %arraydecay21 = getelementptr inbounds [256 x i8], ptr %cmap20, i64 0, i64 0
  %call = call fastcc i32 @make_map_e(ptr noundef %arraydecay19, ptr noundef %arraydecay21)
  %add = add i32 %call, 1
  store i32 %add, ptr %EOB, align 4, !tbaa !14
  %20 = load i32, ptr %EOB, align 4, !tbaa !14
  %cmp22 = icmp uge i32 %20, 2
  br i1 %cmp22, label %if.then24, label %if.else25

if.then24:                                        ; preds = %if.end18
  br label %if.end26

if.else25:                                        ; preds = %if.end18
  call void @__assert_fail(ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 451, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end26:                                         ; preds = %if.then24
  %21 = load i32, ptr %EOB, align 4, !tbaa !14
  %cmp27 = icmp ult i32 %21, 258
  br i1 %cmp27, label %if.then29, label %if.else30

if.then29:                                        ; preds = %if.end26
  br label %if.end31

if.else30:                                        ; preds = %if.end26
  call void @__assert_fail(ptr noundef @.str.10, ptr noundef @.str.1, i32 noundef 452, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end31:                                         ; preds = %if.then29
  %22 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock32 = getelementptr inbounds %struct.encoder_state, ptr %22, i32 0, i32 7
  %23 = load i32, ptr %nblock32, align 4, !tbaa !21
  %cmp33 = icmp ugt i32 %23, 0
  br i1 %cmp33, label %if.then35, label %if.else36

if.then35:                                        ; preds = %if.end31
  br label %if.end37

if.else36:                                        ; preds = %if.end31
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 455, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end37:                                         ; preds = %if.then35
  %24 = load ptr, ptr %block, align 8, !tbaa !12
  %25 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %SA38 = getelementptr inbounds %struct.encoder_state, ptr %25, i32 0, i32 12
  %arraydecay39 = getelementptr inbounds [0 x i32], ptr %SA38, i64 0, i64 0
  %26 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u = getelementptr inbounds %struct.encoder_state, ptr %26, i32 0, i32 11
  %arraydecay40 = getelementptr inbounds [65792 x i32], ptr %u, i64 0, i64 0
  %27 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock41 = getelementptr inbounds %struct.encoder_state, ptr %27, i32 0, i32 7
  %28 = load i32, ptr %nblock41, align 4, !tbaa !21
  %call42 = call i32 @divbwt(ptr noundef %24, ptr noundef %arraydecay39, ptr noundef %arraydecay40, i32 noundef %28)
  %29 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %bwt_idx = getelementptr inbounds %struct.encoder_state, ptr %29, i32 0, i32 4
  store i32 %call42, ptr %bwt_idx, align 4, !tbaa !30
  %30 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %SA43 = getelementptr inbounds %struct.encoder_state, ptr %30, i32 0, i32 12
  %arraydecay44 = getelementptr inbounds [0 x i32], ptr %SA43, i64 0, i64 0
  %31 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u45 = getelementptr inbounds %struct.encoder_state, ptr %31, i32 0, i32 11
  %code = getelementptr inbounds %struct.anon, ptr %u45, i32 0, i32 6
  %arrayidx46 = getelementptr inbounds [6 x [259 x i32]], ptr %code, i64 0, i64 0
  %arraydecay47 = getelementptr inbounds [259 x i32], ptr %arrayidx46, i64 0, i64 0
  %arraydecay48 = getelementptr inbounds [256 x i8], ptr %cmap, i64 0, i64 0
  %32 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nblock49 = getelementptr inbounds %struct.encoder_state, ptr %32, i32 0, i32 7
  %33 = load i32, ptr %nblock49, align 4, !tbaa !21
  %34 = load i32, ptr %EOB, align 4, !tbaa !14
  %call50 = call fastcc i32 @do_mtf(ptr noundef %arraydecay44, ptr noundef %arraydecay47, ptr noundef %arraydecay48, i32 noundef %33, i32 noundef %34)
  %35 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nmtf = getelementptr inbounds %struct.encoder_state, ptr %35, i32 0, i32 6
  store i32 %call50, ptr %nmtf, align 4, !tbaa !31
  store i32 123, ptr %cost, align 4, !tbaa !14
  %36 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %call51 = call i32 @generate_prefix_code(ptr noundef %36)
  %37 = load i32, ptr %cost, align 4, !tbaa !14
  %add52 = add i32 %37, %call51
  store i32 %add52, ptr %cost, align 4, !tbaa !14
  %38 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u53 = getelementptr inbounds %struct.encoder_state, ptr %38, i32 0, i32 11
  %selector = getelementptr inbounds %struct.anon, ptr %u53, i32 0, i32 0
  %arraydecay54 = getelementptr inbounds [18002 x i8], ptr %selector, i64 0, i64 0
  store ptr %arraydecay54, ptr %sp, align 8, !tbaa !12
  %39 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u55 = getelementptr inbounds %struct.encoder_state, ptr %39, i32 0, i32 11
  %selectorMTF = getelementptr inbounds %struct.anon, ptr %u55, i32 0, i32 1
  %arraydecay56 = getelementptr inbounds [18008 x i8], ptr %selectorMTF, i64 0, i64 0
  store ptr %arraydecay56, ptr %smp, align 8, !tbaa !12
  store i32 5517840, ptr %p, align 4, !tbaa !14
  %40 = load ptr, ptr %sp, align 8, !tbaa !12
  %41 = load i8, ptr %40, align 1, !tbaa !23
  %conv57 = zext i8 %41 to i32
  %cmp58 = icmp slt i32 %conv57, 6
  br i1 %cmp58, label %if.then60, label %if.else61

if.then60:                                        ; preds = %if.end37
  br label %if.end62

if.else61:                                        ; preds = %if.end37
  call void @__assert_fail(ptr noundef @.str.11, ptr noundef @.str.1, i32 noundef 484, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end62:                                         ; preds = %if.then60
  %42 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u63 = getelementptr inbounds %struct.encoder_state, ptr %42, i32 0, i32 11
  %tmap_old2new = getelementptr inbounds %struct.anon, ptr %u63, i32 0, i32 8
  %43 = load ptr, ptr %sp, align 8, !tbaa !12
  %44 = load i8, ptr %43, align 1, !tbaa !23
  %idxprom64 = zext i8 %44 to i64
  %arrayidx65 = getelementptr inbounds [6 x i32], ptr %tmap_old2new, i64 0, i64 %idxprom64
  %45 = load i32, ptr %arrayidx65, align 4, !tbaa !23
  %cmp66 = icmp eq i32 %45, 0
  br i1 %cmp66, label %if.then68, label %if.else69

if.then68:                                        ; preds = %if.end62
  br label %if.end70

if.else69:                                        ; preds = %if.end62
  call void @__assert_fail(ptr noundef @.str.12, ptr noundef @.str.1, i32 noundef 485, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end70:                                         ; preds = %if.then68
  br label %while.cond

while.cond:                                       ; preds = %if.end95, %if.end70
  %46 = load ptr, ptr %sp, align 8, !tbaa !12
  %47 = load i8, ptr %46, align 1, !tbaa !23
  store i8 %47, ptr %c, align 1, !tbaa !23
  %conv71 = zext i8 %47 to i32
  %cmp72 = icmp ne i32 %conv71, 6
  br i1 %cmp72, label %while.body, label %while.end

while.body:                                       ; preds = %while.cond
  call void @llvm.lifetime.start.p0(i64 4, ptr %v) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %z) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %l) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %h) #12
  %48 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u74 = getelementptr inbounds %struct.encoder_state, ptr %48, i32 0, i32 11
  %tmap_old2new75 = getelementptr inbounds %struct.anon, ptr %u74, i32 0, i32 8
  %49 = load i8, ptr %c, align 1, !tbaa !23
  %idxprom76 = zext i8 %49 to i64
  %arrayidx77 = getelementptr inbounds [6 x i32], ptr %tmap_old2new75, i64 0, i64 %idxprom76
  %50 = load i32, ptr %arrayidx77, align 4, !tbaa !23
  %conv78 = trunc i32 %50 to i8
  store i8 %conv78, ptr %c, align 1, !tbaa !23
  %51 = load i8, ptr %c, align 1, !tbaa !23
  %conv79 = zext i8 %51 to i32
  %52 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u80 = getelementptr inbounds %struct.encoder_state, ptr %52, i32 0, i32 11
  %num_trees = getelementptr inbounds %struct.anon, ptr %u80, i32 0, i32 3
  %53 = load i32, ptr %num_trees, align 4, !tbaa !23
  %cmp81 = icmp ult i32 %conv79, %53
  br i1 %cmp81, label %if.then83, label %if.else84

if.then83:                                        ; preds = %while.body
  br label %if.end85

if.else84:                                        ; preds = %while.body
  call void @__assert_fail(ptr noundef @.str.13, ptr noundef @.str.1, i32 noundef 491, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end85:                                         ; preds = %if.then83
  %54 = load ptr, ptr %sp, align 8, !tbaa !12
  %55 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u86 = getelementptr inbounds %struct.encoder_state, ptr %55, i32 0, i32 11
  %selector87 = getelementptr inbounds %struct.anon, ptr %u86, i32 0, i32 0
  %arraydecay88 = getelementptr inbounds [18002 x i8], ptr %selector87, i64 0, i64 0
  %sub.ptr.lhs.cast = ptrtoint ptr %54 to i64
  %sub.ptr.rhs.cast = ptrtoint ptr %arraydecay88 to i64
  %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
  %56 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u89 = getelementptr inbounds %struct.encoder_state, ptr %56, i32 0, i32 11
  %num_selectors = getelementptr inbounds %struct.anon, ptr %u89, i32 0, i32 2
  %57 = load i32, ptr %num_selectors, align 4, !tbaa !23
  %conv90 = zext i32 %57 to i64
  %cmp91 = icmp ult i64 %sub.ptr.sub, %conv90
  br i1 %cmp91, label %if.then93, label %if.else94

if.then93:                                        ; preds = %if.end85
  br label %if.end95

if.else94:                                        ; preds = %if.end85
  call void @__assert_fail(ptr noundef @.str.14, ptr noundef @.str.1, i32 noundef 492, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end95:                                         ; preds = %if.then93
  %58 = load i32, ptr %p, align 4, !tbaa !14
  %59 = load i8, ptr %c, align 1, !tbaa !23
  %conv96 = zext i8 %59 to i32
  %mul = mul nuw nsw i32 1118481, %conv96
  %xor = xor i32 %58, %mul
  store i32 %xor, ptr %v, align 4, !tbaa !14
  %60 = load i32, ptr %v, align 4, !tbaa !14
  %add97 = add i32 %60, 15658735
  %and = and i32 %add97, 8947848
  store i32 %and, ptr %z, align 4, !tbaa !14
  %61 = load i32, ptr %z, align 4, !tbaa !14
  %62 = load i32, ptr %z, align 4, !tbaa !14
  %sub98 = sub i32 %62, 1
  %xor99 = xor i32 %61, %sub98
  store i32 %xor99, ptr %l, align 4, !tbaa !14
  %63 = load i32, ptr %l, align 4, !tbaa !14
  %not = xor i32 %63, -1
  store i32 %not, ptr %h, align 4, !tbaa !14
  %64 = load i32, ptr %p, align 4, !tbaa !14
  %65 = load i32, ptr %l, align 4, !tbaa !14
  %or = or i32 %64, %65
  %66 = load i32, ptr %p, align 4, !tbaa !14
  %shl = shl i32 %66, 4
  %67 = load i32, ptr %h, align 4, !tbaa !14
  %or100 = or i32 %shl, %67
  %68 = load i8, ptr %c, align 1, !tbaa !23
  %conv101 = zext i8 %68 to i32
  %or102 = or i32 %or100, %conv101
  %and103 = and i32 %or, %or102
  store i32 %and103, ptr %p, align 4, !tbaa !14
  %69 = load i32, ptr %h, align 4, !tbaa !14
  %70 = call i32 @llvm.cttz.i32(i32 %69, i1 true)
  %shr = lshr i32 %70, 2
  %sub104 = sub nsw i32 %shr, 1
  %conv105 = trunc i32 %sub104 to i8
  store i8 %conv105, ptr %j, align 1, !tbaa !23
  %71 = load ptr, ptr %sp, align 8, !tbaa !12
  %incdec.ptr = getelementptr inbounds i8, ptr %71, i32 1
  store ptr %incdec.ptr, ptr %sp, align 8, !tbaa !12
  %72 = load i8, ptr %j, align 1, !tbaa !23
  %73 = load ptr, ptr %smp, align 8, !tbaa !12
  %incdec.ptr106 = getelementptr inbounds i8, ptr %73, i32 1
  store ptr %incdec.ptr106, ptr %smp, align 8, !tbaa !12
  store i8 %72, ptr %73, align 1, !tbaa !23
  %74 = load i8, ptr %j, align 1, !tbaa !23
  %conv107 = zext i8 %74 to i32
  %add108 = add nuw nsw i32 %conv107, 1
  %75 = load i32, ptr %cost, align 4, !tbaa !14
  %add109 = add i32 %75, %add108
  store i32 %add109, ptr %cost, align 4, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 4, ptr %h) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %l) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %z) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %v) #12
  br label %while.cond, !llvm.loop !32

while.end:                                        ; preds = %while.cond
  %76 = load i32, ptr %cost, align 4, !tbaa !14
  %and110 = and i32 %76, 7
  %conv111 = trunc i32 %and110 to i8
  store i8 %conv111, ptr %j, align 1, !tbaa !23
  %77 = load i8, ptr %j, align 1, !tbaa !23
  %conv112 = zext i8 %77 to i32
  %sub113 = sub nsw i32 8, %conv112
  %and114 = and i32 %sub113, 7
  %conv115 = trunc i32 %and114 to i8
  store i8 %conv115, ptr %j, align 1, !tbaa !23
  %78 = load i8, ptr %j, align 1, !tbaa !23
  %conv116 = zext i8 %78 to i32
  %79 = load i32, ptr %cost, align 4, !tbaa !14
  %add117 = add i32 %79, %conv116
  store i32 %add117, ptr %cost, align 4, !tbaa !14
  %80 = load i8, ptr %j, align 1, !tbaa !23
  %conv118 = zext i8 %80 to i32
  %shr119 = lshr i32 %conv118, 1
  %81 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u120 = getelementptr inbounds %struct.encoder_state, ptr %81, i32 0, i32 11
  %tree_pad = getelementptr inbounds %struct.anon, ptr %u120, i32 0, i32 4
  store i32 %shr119, ptr %tree_pad, align 4, !tbaa !23
  %82 = load i8, ptr %j, align 1, !tbaa !23
  %conv121 = zext i8 %82 to i32
  %and122 = and i32 %conv121, 1
  %conv123 = trunc i32 %and122 to i8
  store i8 %conv123, ptr %j, align 1, !tbaa !23
  %83 = load i8, ptr %j, align 1, !tbaa !23
  %conv124 = zext i8 %83 to i32
  %84 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u125 = getelementptr inbounds %struct.encoder_state, ptr %84, i32 0, i32 11
  %num_selectors126 = getelementptr inbounds %struct.anon, ptr %u125, i32 0, i32 2
  %85 = load i32, ptr %num_selectors126, align 4, !tbaa !23
  %add127 = add i32 %85, %conv124
  store i32 %add127, ptr %num_selectors126, align 4, !tbaa !23
  br label %while.cond128

while.cond128:                                    ; preds = %while.body129, %while.end
  %86 = load i8, ptr %j, align 1, !tbaa !23
  %dec = add i8 %86, -1
  store i8 %dec, ptr %j, align 1, !tbaa !23
  %tobool = icmp ne i8 %86, 0
  br i1 %tobool, label %while.body129, label %while.end131

while.body129:                                    ; preds = %while.cond128
  %87 = load ptr, ptr %smp, align 8, !tbaa !12
  %incdec.ptr130 = getelementptr inbounds i8, ptr %87, i32 1
  store ptr %incdec.ptr130, ptr %smp, align 8, !tbaa !12
  store i8 0, ptr %87, align 1, !tbaa !23
  br label %while.cond128, !llvm.loop !33

while.end131:                                     ; preds = %while.cond128
  %88 = load i32, ptr %cost, align 4, !tbaa !14
  %rem = urem i32 %88, 8
  %cmp132 = icmp eq i32 %rem, 0
  br i1 %cmp132, label %if.then134, label %if.else135

if.then134:                                       ; preds = %while.end131
  br label %if.end136

if.else135:                                       ; preds = %while.end131
  call void @__assert_fail(ptr noundef @.str.15, ptr noundef @.str.1, i32 noundef 525, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end136:                                        ; preds = %if.then134
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc156, %if.end136
  %89 = load i32, ptr %i, align 4, !tbaa !14
  %cmp137 = icmp ult i32 %89, 16
  br i1 %cmp137, label %for.body, label %for.end158

for.body:                                         ; preds = %for.cond
  store i32 0, ptr %pk, align 4, !tbaa !14
  store i8 0, ptr %j, align 1, !tbaa !23
  br label %for.cond139

for.cond139:                                      ; preds = %for.inc, %for.body
  %90 = load i8, ptr %j, align 1, !tbaa !23
  %conv140 = zext i8 %90 to i32
  %cmp141 = icmp slt i32 %conv140, 16
  br i1 %cmp141, label %for.body143, label %for.end

for.body143:                                      ; preds = %for.cond139
  %91 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap144 = getelementptr inbounds %struct.encoder_state, ptr %91, i32 0, i32 0
  %92 = load i32, ptr %i, align 4, !tbaa !14
  %mul145 = mul i32 16, %92
  %93 = load i8, ptr %j, align 1, !tbaa !23
  %conv146 = zext i8 %93 to i32
  %add147 = add i32 %mul145, %conv146
  %idxprom148 = zext i32 %add147 to i64
  %arrayidx149 = getelementptr inbounds [256 x i8], ptr %cmap144, i64 0, i64 %idxprom148
  %94 = load i8, ptr %arrayidx149, align 1, !tbaa !24, !range !34, !noundef !35
  %tobool150 = trunc i8 %94 to i1
  %conv151 = zext i1 %tobool150 to i32
  %95 = load i32, ptr %pk, align 4, !tbaa !14
  %or152 = or i32 %95, %conv151
  store i32 %or152, ptr %pk, align 4, !tbaa !14
  br label %for.inc

for.inc:                                          ; preds = %for.body143
  %96 = load i8, ptr %j, align 1, !tbaa !23
  %inc153 = add i8 %96, 1
  store i8 %inc153, ptr %j, align 1, !tbaa !23
  br label %for.cond139, !llvm.loop !36

for.end:                                          ; preds = %for.cond139
  %97 = load i32, ptr %pk, align 4, !tbaa !14
  %shl154 = shl i32 %97, 4
  %98 = load i32, ptr %cost, align 4, !tbaa !14
  %add155 = add i32 %98, %shl154
  store i32 %add155, ptr %cost, align 4, !tbaa !14
  br label %for.inc156

for.inc156:                                       ; preds = %for.end
  %99 = load i32, ptr %i, align 4, !tbaa !14
  %inc157 = add i32 %99, 1
  store i32 %inc157, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !37

for.end158:                                       ; preds = %for.cond
  %100 = load i32, ptr %cost, align 4, !tbaa !14
  %add159 = add i32 %100, 16
  store i32 %add159, ptr %cost, align 4, !tbaa !14
  %101 = load i32, ptr %cost, align 4, !tbaa !14
  %rem160 = urem i32 %101, 8
  %cmp161 = icmp eq i32 %rem160, 0
  br i1 %cmp161, label %if.then163, label %if.else164

if.then163:                                       ; preds = %for.end158
  br label %if.end165

if.else164:                                       ; preds = %for.end158
  call void @__assert_fail(ptr noundef @.str.15, ptr noundef @.str.1, i32 noundef 537, ptr noundef @__PRETTY_FUNCTION__.encode) #11
  unreachable

if.end165:                                        ; preds = %if.then163
  %102 = load i32, ptr %cost, align 4, !tbaa !14
  %shr166 = lshr i32 %102, 3
  store i32 %shr166, ptr %cost, align 4, !tbaa !14
  %103 = load i32, ptr %cost, align 4, !tbaa !14
  %104 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %out_expect_len = getelementptr inbounds %struct.encoder_state, ptr %104, i32 0, i32 5
  store i32 %103, ptr %out_expect_len, align 4, !tbaa !38
  %105 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %block_crc = getelementptr inbounds %struct.encoder_state, ptr %105, i32 0, i32 3
  %106 = load i32, ptr %block_crc, align 4, !tbaa !20
  %107 = load ptr, ptr %crc.addr, align 8, !tbaa !12
  store i32 %106, ptr %107, align 4, !tbaa !14
  %108 = load i32, ptr %cost, align 4, !tbaa !14
  %conv167 = zext i32 %108 to i64
  call void @llvm.lifetime.end.p0(i64 8, ptr %block) #12
  call void @llvm.lifetime.end.p0(i64 256, ptr %cmap) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %EOB) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %p) #12
  call void @llvm.lifetime.end.p0(i64 1, ptr %j) #12
  call void @llvm.lifetime.end.p0(i64 1, ptr %c) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %smp) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %sp) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %pk) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %cost) #12
  ret i64 %conv167
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc i32 @make_map_e(ptr noundef %cmap, ptr noundef %inuse) unnamed_addr #0 {
entry:
  %cmap.addr = alloca ptr, align 8
  %inuse.addr = alloca ptr, align 8
  %i = alloca i32, align 4
  %j = alloca i32, align 4
  %k = alloca i32, align 4
  store ptr %cmap, ptr %cmap.addr, align 8, !tbaa !12
  store ptr %inuse, ptr %inuse.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %j) #12
  store i32 0, ptr %j, align 4, !tbaa !14
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %0 = load i32, ptr %i, align 4, !tbaa !14
  %cmp = icmp ult i32 %0, 256
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  call void @llvm.lifetime.start.p0(i64 4, ptr %k) #12
  %1 = load ptr, ptr %inuse.addr, align 8, !tbaa !12
  %2 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom = zext i32 %2 to i64
  %arrayidx = getelementptr inbounds i8, ptr %1, i64 %idxprom
  %3 = load i8, ptr %arrayidx, align 1, !tbaa !24, !range !34, !noundef !35
  %tobool = trunc i8 %3 to i1
  %conv = zext i1 %tobool to i32
  store i32 %conv, ptr %k, align 4, !tbaa !14
  %4 = load i32, ptr %j, align 4, !tbaa !14
  %conv1 = trunc i32 %4 to i8
  %5 = load ptr, ptr %cmap.addr, align 8, !tbaa !12
  %6 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom2 = zext i32 %6 to i64
  %arrayidx3 = getelementptr inbounds i8, ptr %5, i64 %idxprom2
  store i8 %conv1, ptr %arrayidx3, align 1, !tbaa !23
  %7 = load i32, ptr %k, align 4, !tbaa !14
  %8 = load i32, ptr %j, align 4, !tbaa !14
  %add = add i32 %8, %7
  store i32 %add, ptr %j, align 4, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 4, ptr %k) #12
  br label %for.inc

for.inc:                                          ; preds = %for.body
  %9 = load i32, ptr %i, align 4, !tbaa !14
  %inc = add i32 %9, 1
  store i32 %inc, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !39

for.end:                                          ; preds = %for.cond
  %10 = load i32, ptr %j, align 4, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 4, ptr %j) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  ret i32 %10
}

declare i32 @divbwt(ptr noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #4

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc i32 @do_mtf(ptr noundef %bwt, ptr noundef %mtffreq, ptr noundef %cmap, i32 noundef %nblock, i32 noundef %EOB) unnamed_addr #0 {
entry:
  %bwt.addr = alloca ptr, align 8
  %mtffreq.addr = alloca ptr, align 8
  %cmap.addr = alloca ptr, align 8
  %nblock.addr = alloca i32, align 4
  %EOB.addr = alloca i32, align 4
  %order = alloca [255 x i8], align 16
  %i = alloca i32, align 4
  %k = alloca i32, align 4
  %t = alloca i32, align 4
  %c = alloca i8, align 1
  %u = alloca i8, align 1
  %mtfv = alloca ptr, align 8
  %mtfv0 = alloca ptr, align 8
  %p = alloca ptr, align 8
  store ptr %bwt, ptr %bwt.addr, align 8, !tbaa !12
  store ptr %mtffreq, ptr %mtffreq.addr, align 8, !tbaa !12
  store ptr %cmap, ptr %cmap.addr, align 8, !tbaa !12
  store i32 %nblock, ptr %nblock.addr, align 4, !tbaa !14
  store i32 %EOB, ptr %EOB.addr, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 255, ptr %order) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.start.p0(i64 1, ptr %c) #12
  call void @llvm.lifetime.start.p0(i64 1, ptr %u) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %mtfv) #12
  %0 = load ptr, ptr %bwt.addr, align 8, !tbaa !12
  store ptr %0, ptr %mtfv, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %mtfv0) #12
  %1 = load ptr, ptr %mtfv, align 8, !tbaa !12
  store ptr %1, ptr %mtfv0, align 8, !tbaa !12
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %2 = load i32, ptr %i, align 4, !tbaa !14
  %3 = load i32, ptr %EOB.addr, align 4, !tbaa !14
  %cmp = icmp sle i32 %2, %3
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %4 = load ptr, ptr %mtffreq.addr, align 8, !tbaa !12
  %5 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom = sext i32 %5 to i64
  %arrayidx = getelementptr inbounds i32, ptr %4, i64 %idxprom
  store i32 0, ptr %arrayidx, align 4, !tbaa !14
  br label %for.inc

for.inc:                                          ; preds = %for.body
  %6 = load i32, ptr %i, align 4, !tbaa !14
  %inc = add nsw i32 %6, 1
  store i32 %inc, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !40

for.end:                                          ; preds = %for.cond
  store i32 0, ptr %k, align 4, !tbaa !14
  store i8 0, ptr %u, align 1, !tbaa !23
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond1

for.cond1:                                        ; preds = %for.inc6, %for.end
  %7 = load i32, ptr %i, align 4, !tbaa !14
  %cmp2 = icmp slt i32 %7, 255
  br i1 %cmp2, label %for.body3, label %for.end8

for.body3:                                        ; preds = %for.cond1
  %8 = load i32, ptr %i, align 4, !tbaa !14
  %add = add nsw i32 %8, 1
  %conv = trunc i32 %add to i8
  %9 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom4 = sext i32 %9 to i64
  %arrayidx5 = getelementptr inbounds [255 x i8], ptr %order, i64 0, i64 %idxprom4
  store i8 %conv, ptr %arrayidx5, align 1, !tbaa !23
  br label %for.inc6

for.inc6:                                         ; preds = %for.body3
  %10 = load i32, ptr %i, align 4, !tbaa !14
  %inc7 = add nsw i32 %10, 1
  store i32 %inc7, ptr %i, align 4, !tbaa !14
  br label %for.cond1, !llvm.loop !41

for.end8:                                         ; preds = %for.cond1
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond9

for.cond9:                                        ; preds = %for.inc56, %for.end8
  %11 = load i32, ptr %i, align 4, !tbaa !14
  %12 = load i32, ptr %nblock.addr, align 4, !tbaa !14
  %cmp10 = icmp slt i32 %11, %12
  br i1 %cmp10, label %for.body12, label %for.end58

for.body12:                                       ; preds = %for.cond9
  %13 = load ptr, ptr %cmap.addr, align 8, !tbaa !12
  %14 = load ptr, ptr %bwt.addr, align 8, !tbaa !12
  %incdec.ptr = getelementptr inbounds i32, ptr %14, i32 1
  store ptr %incdec.ptr, ptr %bwt.addr, align 8, !tbaa !12
  %15 = load i32, ptr %14, align 4, !tbaa !14
  %idxprom13 = sext i32 %15 to i64
  %arrayidx14 = getelementptr inbounds i8, ptr %13, i64 %idxprom13
  %16 = load i8, ptr %arrayidx14, align 1, !tbaa !23
  store i8 %16, ptr %c, align 1, !tbaa !23
  %conv15 = zext i8 %16 to i32
  %17 = load i8, ptr %u, align 1, !tbaa !23
  %conv16 = zext i8 %17 to i32
  %cmp17 = icmp eq i32 %conv15, %conv16
  br i1 %cmp17, label %if.then, label %if.end

if.then:                                          ; preds = %for.body12
  %18 = load i32, ptr %k, align 4, !tbaa !14
  %inc19 = add nsw i32 %18, 1
  store i32 %inc19, ptr %k, align 4, !tbaa !14
  br label %for.inc56

if.end:                                           ; preds = %for.body12
  %19 = load i32, ptr %k, align 4, !tbaa !14
  %conv20 = sext i32 %19 to i64
  %expval = call i64 @llvm.expect.i64(i64 %conv20, i64 0)
  %tobool = icmp ne i64 %expval, 0
  br i1 %tobool, label %if.then21, label %if.end28

if.then21:                                        ; preds = %if.end
  br label %do.body

do.body:                                          ; preds = %do.cond, %if.then21
  %20 = load ptr, ptr %mtffreq.addr, align 8, !tbaa !12
  %21 = load i32, ptr %k, align 4, !tbaa !14
  %dec = add nsw i32 %21, -1
  store i32 %dec, ptr %k, align 4, !tbaa !14
  %and = and i32 %dec, 1
  %conv22 = trunc i32 %and to i16
  %22 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %incdec.ptr23 = getelementptr inbounds i16, ptr %22, i32 1
  store ptr %incdec.ptr23, ptr %mtfv, align 8, !tbaa !12
  store i16 %conv22, ptr %22, align 2, !tbaa !42
  %idxprom24 = zext nneg i16 %conv22 to i64
  %arrayidx25 = getelementptr inbounds i32, ptr %20, i64 %idxprom24
  %23 = load i32, ptr %arrayidx25, align 4, !tbaa !14
  %inc26 = add i32 %23, 1
  store i32 %inc26, ptr %arrayidx25, align 4, !tbaa !14
  %24 = load i32, ptr %k, align 4, !tbaa !14
  %shr = ashr i32 %24, 1
  store i32 %shr, ptr %k, align 4, !tbaa !14
  br label %do.cond

do.cond:                                          ; preds = %do.body
  %25 = load i32, ptr %k, align 4, !tbaa !14
  %tobool27 = icmp ne i32 %25, 0
  br i1 %tobool27, label %do.body, label %do.end, !llvm.loop !44

do.end:                                           ; preds = %do.cond
  br label %if.end28

if.end28:                                         ; preds = %do.end, %if.end
  call void @llvm.lifetime.start.p0(i64 8, ptr %p) #12
  %arraydecay = getelementptr inbounds [255 x i8], ptr %order, i64 0, i64 0
  store ptr %arraydecay, ptr %p, align 8, !tbaa !12
  %26 = load ptr, ptr %p, align 8, !tbaa !12
  %27 = load i8, ptr %26, align 1, !tbaa !23
  %conv29 = zext i8 %27 to i32
  store i32 %conv29, ptr %t, align 4, !tbaa !14
  %28 = load i8, ptr %u, align 1, !tbaa !23
  %29 = load ptr, ptr %p, align 8, !tbaa !12
  store i8 %28, ptr %29, align 1, !tbaa !23
  br label %for.cond30

for.cond30:                                       ; preds = %if.end44, %if.end28
  %30 = load i8, ptr %c, align 1, !tbaa !23
  %conv31 = zext i8 %30 to i32
  %31 = load i32, ptr %t, align 4, !tbaa !14
  %cmp32 = icmp eq i32 %conv31, %31
  br i1 %cmp32, label %if.then34, label %if.end36

if.then34:                                        ; preds = %for.cond30
  %32 = load i32, ptr %t, align 4, !tbaa !14
  %conv35 = trunc i32 %32 to i8
  store i8 %conv35, ptr %u, align 1, !tbaa !23
  br label %for.end47

if.end36:                                         ; preds = %for.cond30
  %33 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr37 = getelementptr inbounds i8, ptr %33, i32 1
  store ptr %incdec.ptr37, ptr %p, align 8, !tbaa !12
  %34 = load i8, ptr %incdec.ptr37, align 1, !tbaa !23
  store i8 %34, ptr %u, align 1, !tbaa !23
  %35 = load i32, ptr %t, align 4, !tbaa !14
  %conv38 = trunc i32 %35 to i8
  %36 = load ptr, ptr %p, align 8, !tbaa !12
  store i8 %conv38, ptr %36, align 1, !tbaa !23
  %37 = load i8, ptr %c, align 1, !tbaa !23
  %conv39 = zext i8 %37 to i32
  %38 = load i8, ptr %u, align 1, !tbaa !23
  %conv40 = zext i8 %38 to i32
  %cmp41 = icmp eq i32 %conv39, %conv40
  br i1 %cmp41, label %if.then43, label %if.end44

if.then43:                                        ; preds = %if.end36
  br label %for.end47

if.end44:                                         ; preds = %if.end36
  %39 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr45 = getelementptr inbounds i8, ptr %39, i32 1
  store ptr %incdec.ptr45, ptr %p, align 8, !tbaa !12
  %40 = load i8, ptr %incdec.ptr45, align 1, !tbaa !23
  %conv46 = zext i8 %40 to i32
  store i32 %conv46, ptr %t, align 4, !tbaa !14
  %41 = load i8, ptr %u, align 1, !tbaa !23
  %42 = load ptr, ptr %p, align 8, !tbaa !12
  store i8 %41, ptr %42, align 1, !tbaa !23
  br label %for.cond30, !llvm.loop !45

for.end47:                                        ; preds = %if.then43, %if.then34
  %43 = load ptr, ptr %p, align 8, !tbaa !12
  %arraydecay48 = getelementptr inbounds [255 x i8], ptr %order, i64 0, i64 0
  %sub.ptr.lhs.cast = ptrtoint ptr %43 to i64
  %sub.ptr.rhs.cast = ptrtoint ptr %arraydecay48 to i64
  %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
  %add49 = add nsw i64 %sub.ptr.sub, 2
  %conv50 = trunc i64 %add49 to i32
  store i32 %conv50, ptr %t, align 4, !tbaa !14
  %44 = load i32, ptr %t, align 4, !tbaa !14
  %conv51 = trunc i32 %44 to i16
  %45 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %incdec.ptr52 = getelementptr inbounds i16, ptr %45, i32 1
  store ptr %incdec.ptr52, ptr %mtfv, align 8, !tbaa !12
  store i16 %conv51, ptr %45, align 2, !tbaa !42
  %46 = load ptr, ptr %mtffreq.addr, align 8, !tbaa !12
  %47 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom53 = sext i32 %47 to i64
  %arrayidx54 = getelementptr inbounds i32, ptr %46, i64 %idxprom53
  %48 = load i32, ptr %arrayidx54, align 4, !tbaa !14
  %inc55 = add i32 %48, 1
  store i32 %inc55, ptr %arrayidx54, align 4, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 8, ptr %p) #12
  br label %for.inc56

for.inc56:                                        ; preds = %for.end47, %if.then
  %49 = load i32, ptr %i, align 4, !tbaa !14
  %inc57 = add nsw i32 %49, 1
  store i32 %inc57, ptr %i, align 4, !tbaa !14
  br label %for.cond9, !llvm.loop !46

for.end58:                                        ; preds = %for.cond9
  %50 = load i32, ptr %k, align 4, !tbaa !14
  %conv59 = sext i32 %50 to i64
  %expval60 = call i64 @llvm.expect.i64(i64 %conv59, i64 0)
  %tobool61 = icmp ne i64 %expval60, 0
  br i1 %tobool61, label %if.then62, label %if.end75

if.then62:                                        ; preds = %for.end58
  br label %do.body63

do.body63:                                        ; preds = %do.cond72, %if.then62
  %51 = load ptr, ptr %mtffreq.addr, align 8, !tbaa !12
  %52 = load i32, ptr %k, align 4, !tbaa !14
  %dec64 = add nsw i32 %52, -1
  store i32 %dec64, ptr %k, align 4, !tbaa !14
  %and65 = and i32 %dec64, 1
  %conv66 = trunc i32 %and65 to i16
  %53 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %incdec.ptr67 = getelementptr inbounds i16, ptr %53, i32 1
  store ptr %incdec.ptr67, ptr %mtfv, align 8, !tbaa !12
  store i16 %conv66, ptr %53, align 2, !tbaa !42
  %idxprom68 = zext nneg i16 %conv66 to i64
  %arrayidx69 = getelementptr inbounds i32, ptr %51, i64 %idxprom68
  %54 = load i32, ptr %arrayidx69, align 4, !tbaa !14
  %inc70 = add i32 %54, 1
  store i32 %inc70, ptr %arrayidx69, align 4, !tbaa !14
  %55 = load i32, ptr %k, align 4, !tbaa !14
  %shr71 = ashr i32 %55, 1
  store i32 %shr71, ptr %k, align 4, !tbaa !14
  br label %do.cond72

do.cond72:                                        ; preds = %do.body63
  %56 = load i32, ptr %k, align 4, !tbaa !14
  %tobool73 = icmp ne i32 %56, 0
  br i1 %tobool73, label %do.body63, label %do.end74, !llvm.loop !47

do.end74:                                         ; preds = %do.cond72
  br label %if.end75

if.end75:                                         ; preds = %do.end74, %for.end58
  %57 = load i32, ptr %EOB.addr, align 4, !tbaa !14
  %conv76 = trunc i32 %57 to i16
  %58 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %incdec.ptr77 = getelementptr inbounds i16, ptr %58, i32 1
  store ptr %incdec.ptr77, ptr %mtfv, align 8, !tbaa !12
  store i16 %conv76, ptr %58, align 2, !tbaa !42
  %59 = load ptr, ptr %mtffreq.addr, align 8, !tbaa !12
  %60 = load i32, ptr %EOB.addr, align 4, !tbaa !14
  %idxprom78 = sext i32 %60 to i64
  %arrayidx79 = getelementptr inbounds i32, ptr %59, i64 %idxprom78
  %61 = load i32, ptr %arrayidx79, align 4, !tbaa !14
  %inc80 = add i32 %61, 1
  store i32 %inc80, ptr %arrayidx79, align 4, !tbaa !14
  %62 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %63 = load ptr, ptr %mtfv0, align 8, !tbaa !12
  %sub.ptr.lhs.cast81 = ptrtoint ptr %62 to i64
  %sub.ptr.rhs.cast82 = ptrtoint ptr %63 to i64
  %sub.ptr.sub83 = sub i64 %sub.ptr.lhs.cast81, %sub.ptr.rhs.cast82
  %sub.ptr.div = sdiv exact i64 %sub.ptr.sub83, 2
  %conv84 = trunc i64 %sub.ptr.div to i32
  call void @llvm.lifetime.end.p0(i64 8, ptr %mtfv0) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %mtfv) #12
  call void @llvm.lifetime.end.p0(i64 1, ptr %u) #12
  call void @llvm.lifetime.end.p0(i64 1, ptr %c) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.end.p0(i64 255, ptr %order) #12
  ret i32 %conv84
}

; Function Attrs: noinline nounwind sspstrong uwtable
define dso_local i32 @generate_prefix_code(ptr noundef %s) local_unnamed_addr #5 {
entry:
  %leaf_weight.i = alloca [259 x i64], align 16
  %count.i = alloca [32 x i32], align 16
  %base_code.i = alloca [21 x i32], align 16
  %tree.i = alloca [21 x [21 x i16]], align 16
  %len_pack = alloca [259 x i64], align 16
  %SA.ptr = getelementptr inbounds i8, ptr %s, i64 263464
  %nmtf = getelementptr inbounds i8, ptr %s, i64 276
  %0 = load i32, ptr %nmtf, align 4, !tbaa !31
  %sub = add i32 %0, -1
  %idxprom = zext i32 %sub to i64
  %arrayidx = getelementptr inbounds i16, ptr %SA.ptr, i64 %idxprom
  %1 = load i16, ptr %arrayidx, align 2, !tbaa !42
  %conv = zext i16 %1 to i32
  %add = add nuw nsw i32 %conv, 1
  %sub2 = add i32 %0, 49
  %div = udiv i32 %sub2, 50
  %u = getelementptr inbounds i8, ptr %s, i64 296
  %num_selectors = getelementptr inbounds i8, ptr %s, i64 36308
  store i32 %div, ptr %num_selectors, align 4, !tbaa !23
  %cmp = icmp ugt i32 %0, 1
  br i1 %cmp, label %if.end, label %if.else

if.else:                                          ; preds = %entry
  tail call void @__assert_fail(ptr noundef nonnull @.str.16, ptr noundef nonnull @.str.1, i32 noundef 1015, ptr noundef nonnull @__PRETTY_FUNCTION__.generate_prefix_code) #11
  unreachable

if.end:                                           ; preds = %entry
  %cmp4 = icmp ugt i32 %0, 2400
  br i1 %cmp4, label %cond.end25, label %cond.false

cond.false:                                       ; preds = %if.end
  %cmp6 = icmp ugt i32 %0, 1200
  br i1 %cmp6, label %cond.end25, label %cond.false9

cond.false9:                                      ; preds = %cond.false
  %cmp10 = icmp ugt i32 %0, 600
  br i1 %cmp10, label %cond.end25, label %cond.false13

cond.false13:                                     ; preds = %cond.false9
  %cmp14 = icmp ugt i32 %0, 300
  br i1 %cmp14, label %cond.end25, label %cond.false17

cond.false17:                                     ; preds = %cond.false13
  %cmp18 = icmp ugt i32 %0, 150
  %cond = select i1 %cmp18, i32 2, i32 1
  br label %cond.end25

cond.end25:                                       ; preds = %cond.false, %cond.false17, %cond.false13, %cond.false9, %if.end
  %cond26 = phi i32 [ 6, %if.end ], [ 5, %cond.false ], [ 4, %cond.false9 ], [ %cond, %cond.false17 ], [ 3, %cond.false13 ]
  %mul = mul nuw i32 %div, 50
  %cmp29414 = icmp ult i32 %0, %mul
  br i1 %cmp29414, label %for.body.lr.ph, label %for.end

for.body.lr.ph:                                   ; preds = %cond.end25
  %conv31 = trunc i32 %add to i16
  %2 = zext i32 %0 to i64
  %wide.trip.count = zext i32 %mul to i64
  br label %for.body

for.body:                                         ; preds = %for.body.lr.ph, %for.body
  %indvars.iv = phi i64 [ %2, %for.body.lr.ph ], [ %indvars.iv.next, %for.body ]
  %arrayidx33 = getelementptr inbounds i16, ptr %SA.ptr, i64 %indvars.iv
  store i16 %conv31, ptr %arrayidx33, align 2, !tbaa !42
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %for.end, label %for.body, !llvm.loop !48

for.end:                                          ; preds = %for.body, %cond.end25
  tail call fastcc void @generate_initial_trees(ptr noundef %s, i32 noundef %0, i32 noundef %cond26)
  %cluster_factor = getelementptr inbounds i8, ptr %s, i64 292
  %3 = load i32, ptr %cluster_factor, align 4, !tbaa !18
  %cmp34.not423 = icmp eq i32 %3, 0
  br i1 %cmp34.not423, label %while.end, label %while.body.lr.ph

while.body.lr.ph:                                 ; preds = %for.end
  %length = getelementptr inbounds i8, ptr %s, i64 36320
  %arrayidx47 = getelementptr inbounds i8, ptr %s, i64 36579
  %arrayidx54 = getelementptr inbounds i8, ptr %s, i64 36838
  %arrayidx62 = getelementptr inbounds i8, ptr %s, i64 37097
  %arrayidx70 = getelementptr inbounds i8, ptr %s, i64 37356
  %arrayidx78 = getelementptr inbounds i8, ptr %s, i64 37615
  %idxprom89 = zext nneg i32 %add to i64
  %arrayidx90 = getelementptr inbounds [259 x i64], ptr %len_pack, i64 0, i64 %idxprom89
  %frequency = getelementptr inbounds i8, ptr %s, i64 44092
  %narrow = mul nuw nsw i32 %cond26, 1036
  %mul96 = zext nneg i32 %narrow to i64
  %idx.ext = zext i32 %0 to i64
  %add.ptr.idx = shl nuw nsw i64 %idx.ext, 1
  %4 = getelementptr i8, ptr %s, i64 %add.ptr.idx
  %add.ptr.ptr = getelementptr i8, ptr %4, i64 263464
  %sub.ptr.rhs.cast = ptrtoint ptr %u to i64
  %length144 = getelementptr inbounds i8, ptr %s, i64 36320
  %5 = add nuw nsw i32 %conv, 1
  %wide.trip.count464 = zext nneg i32 %5 to i64
  %wide.trip.count473 = zext nneg i32 %cond26 to i64
  br label %while.body

while.body:                                       ; preds = %while.body.lr.ph, %for.end155
  %dec424.in = phi i32 [ %3, %while.body.lr.ph ], [ %dec424, %for.end155 ]
  call void @llvm.lifetime.start.p0(i64 2072, ptr nonnull %len_pack) #12
  br label %for.body39

for.body39:                                       ; preds = %while.body, %for.body39
  %indvars.iv461 = phi i64 [ 0, %while.body ], [ %indvars.iv.next462, %for.body39 ]
  %arrayidx43 = getelementptr inbounds [259 x i8], ptr %length, i64 0, i64 %indvars.iv461
  %6 = load i8, ptr %arrayidx43, align 1, !tbaa !23
  %conv44 = zext i8 %6 to i64
  %arrayidx49 = getelementptr inbounds [259 x i8], ptr %arrayidx47, i64 0, i64 %indvars.iv461
  %7 = load i8, ptr %arrayidx49, align 1, !tbaa !23
  %conv50 = zext i8 %7 to i64
  %shl = shl nuw nsw i64 %conv50, 10
  %add51 = or disjoint i64 %shl, %conv44
  %arrayidx56 = getelementptr inbounds [259 x i8], ptr %arrayidx54, i64 0, i64 %indvars.iv461
  %8 = load i8, ptr %arrayidx56, align 1, !tbaa !23
  %conv57 = zext i8 %8 to i64
  %shl58 = shl nuw nsw i64 %conv57, 20
  %add59 = or disjoint i64 %add51, %shl58
  %arrayidx64 = getelementptr inbounds [259 x i8], ptr %arrayidx62, i64 0, i64 %indvars.iv461
  %9 = load i8, ptr %arrayidx64, align 1, !tbaa !23
  %conv65 = zext i8 %9 to i64
  %shl66 = shl nuw nsw i64 %conv65, 30
  %add67 = or disjoint i64 %add59, %shl66
  %arrayidx72 = getelementptr inbounds [259 x i8], ptr %arrayidx70, i64 0, i64 %indvars.iv461
  %10 = load i8, ptr %arrayidx72, align 1, !tbaa !23
  %conv73 = zext i8 %10 to i64
  %shl74 = shl nuw nsw i64 %conv73, 40
  %add75 = or disjoint i64 %add67, %shl74
  %arrayidx80 = getelementptr inbounds [259 x i8], ptr %arrayidx78, i64 0, i64 %indvars.iv461
  %11 = load i8, ptr %arrayidx80, align 1, !tbaa !23
  %conv81 = zext i8 %11 to i64
  %shl82 = shl nuw nsw i64 %conv81, 50
  %add83 = or disjoint i64 %add75, %shl82
  %arrayidx85 = getelementptr inbounds [259 x i64], ptr %len_pack, i64 0, i64 %indvars.iv461
  store i64 %add83, ptr %arrayidx85, align 8, !tbaa !8
  %indvars.iv.next462 = add nuw nsw i64 %indvars.iv461, 1
  %exitcond465.not = icmp eq i64 %indvars.iv.next462, %wide.trip.count464
  br i1 %exitcond465.not, label %for.end88, label %for.body39, !llvm.loop !50

for.end88:                                        ; preds = %for.body39
  %dec424 = add i32 %dec424.in, -1
  store i64 0, ptr %arrayidx90, align 8, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(1) %frequency, i8 noundef 0, i64 noundef %mul96, i1 noundef false) #12
  br label %for.body100

for.body100:                                      ; preds = %for.end88, %for.inc125
  %sp.0420 = phi ptr [ %incdec.ptr, %for.inc125 ], [ %u, %for.end88 ]
  %gs.0419 = phi ptr [ %add.ptr126, %for.inc125 ], [ %SA.ptr, %for.end88 ]
  %call102 = call fastcc i32 @find_best_tree(ptr noundef nonnull %gs.0419, i32 noundef %cond26, ptr noundef nonnull %len_pack)
  %cmp103 = icmp ult i32 %call102, %cond26
  br i1 %cmp103, label %if.end107, label %if.else106

if.else106:                                       ; preds = %for.body100
  call void @__assert_fail(ptr noundef nonnull @.str.17, ptr noundef nonnull @.str.1, i32 noundef 1065, ptr noundef nonnull @__PRETTY_FUNCTION__.generate_prefix_code) #11
  unreachable

if.end107:                                        ; preds = %for.body100
  %conv108 = trunc i32 %call102 to i8
  store i8 %conv108, ptr %sp.0420, align 1, !tbaa !23
  %idxprom115 = zext nneg i32 %call102 to i64
  br label %for.body112

for.body112:                                      ; preds = %if.end107, %for.body112
  %indvars.iv466 = phi i64 [ 0, %if.end107 ], [ %indvars.iv.next467, %for.body112 ]
  %arrayidx118 = getelementptr inbounds i16, ptr %gs.0419, i64 %indvars.iv466
  %12 = load i16, ptr %arrayidx118, align 2, !tbaa !42
  %idxprom119 = zext i16 %12 to i64
  %arrayidx120 = getelementptr inbounds [6 x [259 x i32]], ptr %frequency, i64 0, i64 %idxprom115, i64 %idxprom119
  %13 = load i32, ptr %arrayidx120, align 4, !tbaa !23
  %inc121 = add i32 %13, 1
  store i32 %inc121, ptr %arrayidx120, align 4, !tbaa !23
  %indvars.iv.next467 = add nuw nsw i64 %indvars.iv466, 1
  %exitcond469.not = icmp eq i64 %indvars.iv.next467, 50
  br i1 %exitcond469.not, label %for.inc125, label %for.body112, !llvm.loop !51

for.inc125:                                       ; preds = %for.body112
  %incdec.ptr = getelementptr inbounds i8, ptr %sp.0420, i64 1
  %add.ptr126 = getelementptr inbounds i8, ptr %gs.0419, i64 100
  %cmp98 = icmp ult ptr %add.ptr126, %add.ptr.ptr
  br i1 %cmp98, label %for.body100, label %for.end127, !llvm.loop !52

for.end127:                                       ; preds = %for.inc125
  %sub.ptr.lhs.cast = ptrtoint ptr %incdec.ptr to i64
  %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast
  %14 = load i32, ptr %num_selectors, align 4, !tbaa !23
  %conv133 = zext i32 %14 to i64
  %cmp134 = icmp eq i64 %sub.ptr.sub, %conv133
  br i1 %cmp134, label %if.end138, label %if.else137

if.else137:                                       ; preds = %for.end127
  call void @__assert_fail(ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.1, i32 noundef 1071, ptr noundef nonnull @__PRETTY_FUNCTION__.generate_prefix_code) #11
  unreachable

if.end138:                                        ; preds = %for.end127
  store i8 6, ptr %incdec.ptr, align 1, !tbaa !23
  br label %for.body142

for.body142:                                      ; preds = %if.end138, %for.body142
  %indvars.iv470 = phi i64 [ 0, %if.end138 ], [ %indvars.iv.next471, %for.body142 ]
  %arrayidx146 = getelementptr inbounds [6 x [259 x i8]], ptr %length144, i64 0, i64 %indvars.iv470
  %arrayidx151 = getelementptr inbounds [6 x [259 x i32]], ptr %frequency, i64 0, i64 %indvars.iv470
  call fastcc void @make_code_lengths(ptr noundef nonnull %arrayidx146, ptr noundef nonnull %arrayidx151, i32 noundef %add)
  %indvars.iv.next471 = add nuw nsw i64 %indvars.iv470, 1
  %exitcond474.not = icmp eq i64 %indvars.iv.next471, %wide.trip.count473
  br i1 %exitcond474.not, label %for.end155, label %for.body142, !llvm.loop !53

for.end155:                                       ; preds = %for.body142
  call void @llvm.lifetime.end.p0(i64 2072, ptr nonnull %len_pack) #12
  %cmp34.not = icmp eq i32 %dec424, 0
  br i1 %cmp34.not, label %while.end, label %while.body, !llvm.loop !54

while.end:                                        ; preds = %for.end155, %for.end
  %notmask = shl nsw i32 -1, %cond26
  %sub157 = xor i32 %notmask, -1
  %invariant.gep = getelementptr inbounds i8, ptr %leaf_weight.i, i64 8
  %tmap_old2new = getelementptr inbounds i8, ptr %s, i64 50308
  %tmap_new2old = getelementptr inbounds i8, ptr %s, i64 50332
  %code = getelementptr inbounds i8, ptr %s, i64 37876
  %length188 = getelementptr inbounds i8, ptr %s, i64 36320
  %frequency193 = getelementptr inbounds i8, ptr %s, i64 44092
  %add.ptr.i = getelementptr inbounds i8, ptr %leaf_weight.i, i64 8
  %idx.ext.i = zext nneg i32 %add to i64
  %gep = getelementptr inbounds i64, ptr %invariant.gep, i64 %idx.ext.i
  %cmp76.i.not435 = icmp eq i16 %1, 0
  %add118.i = add nuw nsw i32 %conv, 6
  %15 = add nuw nsw i32 %conv, 1
  %wide.trip.count479 = zext nneg i32 %15 to i64
  %wide.trip.count499 = zext nneg i32 %add to i64
  %wide.trip.count525 = zext nneg i32 %add to i64
  br label %land.rhs

land.rhs:                                         ; preds = %while.end, %if.end211
  %nt.0454 = phi i32 [ 0, %while.end ], [ %nt.1, %if.end211 ]
  %sp160.0453 = phi ptr [ %u, %while.end ], [ %incdec.ptr167, %if.end211 ]
  %not_seen.0452 = phi i32 [ %sub157, %while.end ], [ %not_seen.1, %if.end211 ]
  %cost.0451 = phi i32 [ 0, %while.end ], [ %cost.1, %if.end211 ]
  %incdec.ptr167 = getelementptr inbounds i8, ptr %sp160.0453, i64 1
  %16 = load i8, ptr %sp160.0453, align 1, !tbaa !23
  %conv168 = zext i8 %16 to i32
  %cmp169 = icmp ult i8 %16, 6
  br i1 %cmp169, label %while.body171, label %while.end212

while.body171:                                    ; preds = %land.rhs
  %shl172 = shl nuw nsw i32 1, %conv168
  %and = and i32 %shl172, %not_seen.0452
  %tobool.not = icmp eq i32 %and, 0
  br i1 %tobool.not, label %if.end211, label %if.then173

if.then173:                                       ; preds = %while.body171
  %idxprom177 = zext nneg i8 %16 to i64
  %arrayidx178 = getelementptr inbounds [6 x i32], ptr %tmap_old2new, i64 0, i64 %idxprom177
  store i32 %nt.0454, ptr %arrayidx178, align 4, !tbaa !23
  %idxprom180 = zext i32 %nt.0454 to i64
  %arrayidx181 = getelementptr inbounds [6 x i32], ptr %tmap_new2old, i64 0, i64 %idxprom180
  store i32 %conv168, ptr %arrayidx181, align 4, !tbaa !23
  %arrayidx185 = getelementptr inbounds [6 x [259 x i32]], ptr %code, i64 0, i64 %idxprom177
  %arrayidx195 = getelementptr inbounds [6 x [259 x i32]], ptr %frequency193, i64 0, i64 %idxprom177
  call void @llvm.lifetime.start.p0(i64 2072, ptr nonnull %leaf_weight.i) #12
  call void @llvm.lifetime.start.p0(i64 128, ptr nonnull %count.i) #12
  call void @llvm.lifetime.start.p0(i64 84, ptr nonnull %base_code.i) #12
  call void @llvm.lifetime.start.p0(i64 882, ptr nonnull %tree.i) #12
  br label %for.body.i

for.body.i:                                       ; preds = %if.then173, %for.body.i
  %indvars.iv475 = phi i64 [ 0, %if.then173 ], [ %indvars.iv.next476, %for.body.i ]
  %arrayidx.i = getelementptr inbounds i32, ptr %arrayidx195, i64 %indvars.iv475
  %17 = load i32, ptr %arrayidx.i, align 4, !tbaa !14
  %conv.i = zext i32 %17 to i64
  %shl.i = shl nuw i64 %conv.i, 32
  %18 = sub nsw i64 258, %indvars.iv475
  %conv1.i = and i64 %18, 4294901759
  %or.i = or disjoint i64 %shl.i, %conv1.i
  %or2.i = or disjoint i64 %or.i, 65536
  %indvars.iv.next476 = add nuw nsw i64 %indvars.iv475, 1
  %arrayidx4.i = getelementptr inbounds [259 x i64], ptr %leaf_weight.i, i64 0, i64 %indvars.iv.next476
  store i64 %or2.i, ptr %arrayidx4.i, align 8, !tbaa !8
  %exitcond480.not = icmp eq i64 %indvars.iv.next476, %wide.trip.count479
  br i1 %exitcond480.not, label %for.end.i, label %for.body.i, !llvm.loop !55

for.end.i:                                        ; preds = %for.body.i
  %sub175 = sub i32 %not_seen.0452, %shl172
  %inc182 = add i32 %nt.0454, 1
  %arrayidx190 = getelementptr inbounds [6 x [259 x i8]], ptr %length188, i64 0, i64 %idxprom177
  call fastcc void @sort_alphabet(ptr noundef nonnull %add.ptr.i, ptr noundef nonnull %gep)
  store i64 -1, ptr %leaf_weight.i, align 16, !tbaa !8
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(882) %tree.i, i8 noundef 0, i64 noundef 882, i1 noundef false) #12
  call fastcc void @package_merge(ptr noundef nonnull %tree.i, ptr noundef nonnull %count.i, ptr noundef nonnull %leaf_weight.i, i64 noundef %idx.ext.i)
  %invariant.gep538 = getelementptr i8, ptr %arrayidx190, i64 -1
  br label %for.body17.i

for.body17.i:                                     ; preds = %for.end.i, %for.inc124.i
  %indvars.iv503 = phi i64 [ 2, %for.end.i ], [ %indvars.iv.next504, %for.inc124.i ]
  %indvars.iv501 = phi i64 [ 3, %for.end.i ], [ %indvars.iv.next502, %for.inc124.i ]
  %best_height.0.i441 = phi i32 [ 20, %for.end.i ], [ %best_height.1.i, %for.inc124.i ]
  %best_cost.0.i440 = phi i32 [ -1, %for.end.i ], [ %best_cost.1.i, %for.inc124.i ]
  %shl18.i = shl nuw nsw i64 1, %indvars.iv503
  %cmp20.i = icmp ult i64 %shl18.i, %idx.ext.i
  br i1 %cmp20.i, label %for.inc124.i, label %if.end.i

if.end.i:                                         ; preds = %for.body17.i
  %19 = add nsw i64 %indvars.iv503, -1
  %arrayidx26.i = getelementptr inbounds [21 x [21 x i16]], ptr %tree.i, i64 0, i64 %indvars.iv503, i64 %19
  %20 = load i16, ptr %arrayidx26.i, align 2, !tbaa !42
  %cmp28.i = icmp eq i16 %20, 0
  br i1 %cmp28.i, label %for.end126.i, label %for.body35.i

for.cond75.i.preheader:                           ; preds = %for.inc72.i
  br i1 %cmp76.i.not435, label %for.end117.i, label %for.body78.i

for.body35.i:                                     ; preds = %if.end.i, %for.inc72.i
  %indvars.iv487 = phi i64 [ %indvars.iv.next488, %for.inc72.i ], [ 1, %if.end.i ]
  %cost.0.i434 = phi i32 [ %cost.1.i.lcssa, %for.inc72.i ], [ 0, %if.end.i ]
  %leaf.1.i432 = phi i32 [ %leaf.2.i.lcssa, %for.inc72.i ], [ 0, %if.end.i ]
  %21 = add nsw i64 %indvars.iv487, -1
  %arrayidx40.i = getelementptr inbounds [21 x [21 x i16]], ptr %tree.i, i64 0, i64 %indvars.iv503, i64 %21
  %22 = load i16, ptr %arrayidx40.i, align 2, !tbaa !42
  %conv41.i = zext i16 %22 to i32
  %arrayidx45.i = getelementptr inbounds [21 x [21 x i16]], ptr %tree.i, i64 0, i64 %indvars.iv503, i64 %indvars.iv487
  %23 = load i16, ptr %arrayidx45.i, align 2, !tbaa !42
  %conv46.i = zext i16 %23 to i32
  %sub47.i = sub nsw i32 %conv41.i, %conv46.i
  %cmp49.not.i426 = icmp eq i32 %sub47.i, 0
  br i1 %cmp49.not.i426, label %for.inc72.i, label %for.body51.i.lr.ph

for.body51.i.lr.ph:                               ; preds = %for.body35.i
  %conv61.i = trunc i64 %indvars.iv487 to i8
  %24 = zext i32 %leaf.1.i432 to i64
  %umax484 = call i32 @llvm.umax.i32(i32 %leaf.1.i432, i32 %add)
  %wide.trip.count485 = zext i32 %umax484 to i64
  %25 = trunc i64 %indvars.iv487 to i32
  br label %for.body51.i

for.body51.i:                                     ; preds = %for.body51.i.lr.ph, %if.end55.i
  %indvars.iv481 = phi i64 [ %24, %for.body51.i.lr.ph ], [ %indvars.iv.next482, %if.end55.i ]
  %cost.1.i429 = phi i32 [ %cost.0.i434, %for.body51.i.lr.ph ], [ %add68.i, %if.end55.i ]
  %avail.0.i428 = phi i32 [ %sub47.i, %for.body51.i.lr.ph ], [ %dec.i, %if.end55.i ]
  %exitcond486 = icmp eq i64 %indvars.iv481, %wide.trip.count485
  br i1 %exitcond486, label %if.else.i, label %if.end55.i

if.else.i:                                        ; preds = %for.body51.i
  call void @__assert_fail(ptr noundef nonnull @.str.46, ptr noundef nonnull @.str.1, i32 noundef 930, ptr noundef nonnull @__PRETTY_FUNCTION__.assign_codes) #11
  unreachable

if.end55.i:                                       ; preds = %for.body51.i
  %indvars.iv.next482 = add nuw nsw i64 %indvars.iv481, 1
  %arrayidx58.i = getelementptr inbounds [259 x i64], ptr %leaf_weight.i, i64 0, i64 %indvars.iv.next482
  %26 = load i64, ptr %arrayidx58.i, align 8, !tbaa !8
  %27 = and i64 %26, 65535
  %conv60.i = sub nsw i64 258, %27
  %idxprom62.i = and i64 %conv60.i, 4294967295
  %arrayidx63.i = getelementptr inbounds i8, ptr %arrayidx190, i64 %idxprom62.i
  store i8 %conv61.i, ptr %arrayidx63.i, align 1, !tbaa !23
  %shr.i = lshr i64 %26, 32
  %conv67.i = trunc i64 %shr.i to i32
  %mul.i = mul i32 %25, %conv67.i
  %add68.i = add i32 %mul.i, %cost.1.i429
  %dec.i = add nsw i32 %avail.0.i428, -1
  %cmp49.not.i = icmp eq i32 %dec.i, 0
  br i1 %cmp49.not.i, label %for.inc72.i.loopexit, label %for.body51.i, !llvm.loop !56

for.inc72.i.loopexit:                             ; preds = %if.end55.i
  %28 = trunc i64 %indvars.iv.next482 to i32
  br label %for.inc72.i

for.inc72.i:                                      ; preds = %for.inc72.i.loopexit, %for.body35.i
  %leaf.2.i.lcssa = phi i32 [ %leaf.1.i432, %for.body35.i ], [ %28, %for.inc72.i.loopexit ]
  %cost.1.i.lcssa = phi i32 [ %cost.0.i434, %for.body35.i ], [ %add68.i, %for.inc72.i.loopexit ]
  %indvars.iv.next488 = add nuw nsw i64 %indvars.iv487, 1
  %exitcond494.not = icmp eq i64 %indvars.iv.next488, %indvars.iv501
  br i1 %exitcond494.not, label %for.cond75.i.preheader, label %for.body35.i, !llvm.loop !57

for.body78.i:                                     ; preds = %for.cond75.i.preheader, %for.body78.i
  %indvars.iv495 = phi i64 [ %indvars.iv.next496, %for.body78.i ], [ 1, %for.cond75.i.preheader ]
  %cost.2.i437 = phi i32 [ %add114.i, %for.body78.i ], [ %cost.1.i.lcssa, %for.cond75.i.preheader ]
  %gep539 = getelementptr i8, ptr %invariant.gep538, i64 %indvars.iv495
  %29 = load i8, ptr %gep539, align 1, !tbaa !23
  %conv82.i = zext i8 %29 to i32
  %arrayidx84.i = getelementptr inbounds i8, ptr %arrayidx190, i64 %indvars.iv495
  %30 = load i8, ptr %arrayidx84.i, align 1, !tbaa !23
  %conv85.i = zext i8 %30 to i32
  %sub86.i = sub nsw i32 %conv82.i, %conv85.i
  %sub94.sub86.i = call i32 @llvm.abs.i32(i32 %sub86.i, i1 true)
  %mul113.i = shl nuw nsw i32 %sub94.sub86.i, 1
  %add114.i = add i32 %mul113.i, %cost.2.i437
  %indvars.iv.next496 = add nuw nsw i64 %indvars.iv495, 1
  %exitcond500.not = icmp eq i64 %indvars.iv.next496, %wide.trip.count499
  br i1 %exitcond500.not, label %for.end117.i, label %for.body78.i, !llvm.loop !58

for.end117.i:                                     ; preds = %for.body78.i, %for.cond75.i.preheader
  %cost.2.i.lcssa = phi i32 [ %cost.1.i.lcssa, %for.cond75.i.preheader ], [ %add114.i, %for.body78.i ]
  %add119.i = add i32 %add118.i, %cost.2.i.lcssa
  %cmp120.i = icmp ult i32 %add119.i, %best_cost.0.i440
  %spec.select.i = call i32 @llvm.umin.i32(i32 %add119.i, i32 %best_cost.0.i440)
  %31 = trunc i64 %indvars.iv503 to i32
  %spec.select257.i = select i1 %cmp120.i, i32 %31, i32 %best_height.0.i441
  br label %for.inc124.i

for.inc124.i:                                     ; preds = %for.end117.i, %for.body17.i
  %best_cost.1.i = phi i32 [ %best_cost.0.i440, %for.body17.i ], [ %spec.select.i, %for.end117.i ]
  %best_height.1.i = phi i32 [ %best_height.0.i441, %for.body17.i ], [ %spec.select257.i, %for.end117.i ]
  %indvars.iv.next504 = add nuw nsw i64 %indvars.iv503, 1
  %indvars.iv.next502 = add nuw nsw i64 %indvars.iv501, 1
  %exitcond509.not = icmp eq i64 %indvars.iv.next504, 21
  br i1 %exitcond509.not, label %for.end126.i, label %for.body17.i, !llvm.loop !59

for.end126.i:                                     ; preds = %if.end.i, %for.inc124.i
  %best_cost.0.i.lcssa = phi i32 [ %best_cost.0.i440, %if.end.i ], [ %best_cost.1.i, %for.inc124.i ]
  %best_height.0.i.lcssa = phi i32 [ %best_height.0.i441, %if.end.i ], [ %best_height.1.i, %for.inc124.i ]
  %cmp128.not.i446 = icmp eq i32 %best_height.0.i.lcssa, 0
  br i1 %cmp128.not.i446, label %for.end167.i, label %for.body130.i.lr.ph

for.body130.i.lr.ph:                              ; preds = %for.end126.i
  %idxprom131.i = zext nneg i32 %best_height.0.i.lcssa to i64
  %32 = add i32 %best_height.0.i.lcssa, 1
  %wide.trip.count520 = zext i32 %32 to i64
  br label %for.body130.i

for.body130.i:                                    ; preds = %for.body130.i.lr.ph, %for.inc165.i
  %indvars.iv516 = phi i64 [ 1, %for.body130.i.lr.ph ], [ %indvars.iv.next517, %for.inc165.i ]
  %next_code.0.i448 = phi i32 [ 0, %for.body130.i.lr.ph ], [ %shl146.i, %for.inc165.i ]
  %leaf.3.i447 = phi i32 [ 0, %for.body130.i.lr.ph ], [ %leaf.4.i.lcssa, %for.inc165.i ]
  %33 = add nsw i64 %indvars.iv516, -1
  %arrayidx135.i = getelementptr inbounds [21 x [21 x i16]], ptr %tree.i, i64 0, i64 %idxprom131.i, i64 %33
  %34 = load i16, ptr %arrayidx135.i, align 2, !tbaa !42
  %conv136.i = zext i16 %34 to i32
  %arrayidx140.i = getelementptr inbounds [21 x [21 x i16]], ptr %tree.i, i64 0, i64 %idxprom131.i, i64 %indvars.iv516
  %35 = load i16, ptr %arrayidx140.i, align 2, !tbaa !42
  %conv141.i = zext i16 %35 to i32
  %sub142.i = sub nsw i32 %conv136.i, %conv141.i
  %arrayidx144.i = getelementptr inbounds [21 x i32], ptr %base_code.i, i64 0, i64 %indvars.iv516
  store i32 %next_code.0.i448, ptr %arrayidx144.i, align 4, !tbaa !14
  %add145.i = add i32 %sub142.i, %next_code.0.i448
  %shl146.i = shl i32 %add145.i, 1
  %cmp147.not.i442 = icmp eq i32 %sub142.i, 0
  br i1 %cmp147.not.i442, label %for.inc165.i, label %while.body.i.lr.ph

while.body.i.lr.ph:                               ; preds = %for.body130.i
  %conv160.i = trunc i64 %indvars.iv516 to i8
  %36 = zext i32 %leaf.3.i447 to i64
  %umax513 = call i32 @llvm.umax.i32(i32 %leaf.3.i447, i32 %add)
  %wide.trip.count514 = zext i32 %umax513 to i64
  br label %while.body.i

while.body.i:                                     ; preds = %while.body.i.lr.ph, %if.end153.i
  %indvars.iv510 = phi i64 [ %36, %while.body.i.lr.ph ], [ %indvars.iv.next511, %if.end153.i ]
  %avail.1.i444 = phi i32 [ %sub142.i, %while.body.i.lr.ph ], [ %dec164.i, %if.end153.i ]
  %exitcond515 = icmp eq i64 %indvars.iv510, %wide.trip.count514
  br i1 %exitcond515, label %if.else152.i, label %if.end153.i

if.else152.i:                                     ; preds = %while.body.i
  call void @__assert_fail(ptr noundef nonnull @.str.46, ptr noundef nonnull @.str.1, i32 noundef 961, ptr noundef nonnull @__PRETTY_FUNCTION__.assign_codes) #11
  unreachable

if.end153.i:                                      ; preds = %while.body.i
  %indvars.iv.next511 = add nuw nsw i64 %indvars.iv510, 1
  %arrayidx156.i = getelementptr inbounds [259 x i64], ptr %leaf_weight.i, i64 0, i64 %indvars.iv.next511
  %37 = load i64, ptr %arrayidx156.i, align 8, !tbaa !8
  %38 = and i64 %37, 65535
  %conv159.i = sub nsw i64 258, %38
  %idxprom161.i = and i64 %conv159.i, 4294967295
  %arrayidx162.i = getelementptr inbounds i8, ptr %arrayidx190, i64 %idxprom161.i
  store i8 %conv160.i, ptr %arrayidx162.i, align 1, !tbaa !23
  %dec164.i = add nsw i32 %avail.1.i444, -1
  %cmp147.not.i = icmp eq i32 %dec164.i, 0
  br i1 %cmp147.not.i, label %for.inc165.i.loopexit, label %while.body.i, !llvm.loop !60

for.inc165.i.loopexit:                            ; preds = %if.end153.i
  %39 = trunc i64 %indvars.iv.next511 to i32
  br label %for.inc165.i

for.inc165.i:                                     ; preds = %for.inc165.i.loopexit, %for.body130.i
  %leaf.4.i.lcssa = phi i32 [ %leaf.3.i447, %for.body130.i ], [ %39, %for.inc165.i.loopexit ]
  %indvars.iv.next517 = add nuw nsw i64 %indvars.iv516, 1
  %exitcond521.not = icmp eq i64 %indvars.iv.next517, %wide.trip.count520
  br i1 %exitcond521.not, label %for.end167.i, label %for.body130.i, !llvm.loop !61

for.end167.i:                                     ; preds = %for.inc165.i, %for.end126.i
  call void asm sideeffect "# LLVM-MCA-BEGIN foo", "~{memory},~{dirflag},~{fpsr},~{flags}"() #12, !srcloc !62
  br label %for.body171.i

for.body171.i:                                    ; preds = %for.end167.i, %for.body171.i
  %indvars.iv522 = phi i64 [ 0, %for.end167.i ], [ %indvars.iv.next523, %for.body171.i ]
  %arrayidx173.i = getelementptr inbounds i8, ptr %arrayidx190, i64 %indvars.iv522
  %40 = load i8, ptr %arrayidx173.i, align 1, !tbaa !23
  %idxprom174.i = zext i8 %40 to i64
  %arrayidx175.i = getelementptr inbounds [21 x i32], ptr %base_code.i, i64 0, i64 %idxprom174.i
  %41 = load i32, ptr %arrayidx175.i, align 4, !tbaa !14
  %inc176.i = add i32 %41, 1
  store i32 %inc176.i, ptr %arrayidx175.i, align 4, !tbaa !14
  %arrayidx178.i = getelementptr inbounds i32, ptr %arrayidx185, i64 %indvars.iv522
  store i32 %41, ptr %arrayidx178.i, align 4, !tbaa !14
  %indvars.iv.next523 = add nuw nsw i64 %indvars.iv522, 1
  %exitcond526.not = icmp eq i64 %indvars.iv.next523, %wide.trip.count525
  br i1 %exitcond526.not, label %assign_codes.exit, label %for.body171.i, !llvm.loop !63

assign_codes.exit:                                ; preds = %for.body171.i
  call void asm sideeffect "# LLVM-MCA-END", "~{memory},~{dirflag},~{fpsr},~{flags}"() #12, !srcloc !64
  call void @llvm.lifetime.end.p0(i64 882, ptr nonnull %tree.i) #12
  call void @llvm.lifetime.end.p0(i64 84, ptr nonnull %base_code.i) #12
  call void @llvm.lifetime.end.p0(i64 128, ptr nonnull %count.i) #12
  call void @llvm.lifetime.end.p0(i64 2072, ptr nonnull %leaf_weight.i) #12
  %add198 = add i32 %best_cost.0.i.lcssa, %cost.0451
  %arrayidx204 = getelementptr inbounds [6 x [259 x i32]], ptr %code, i64 0, i64 %idxprom177, i64 %idx.ext.i
  store i32 0, ptr %arrayidx204, align 4, !tbaa !23
  %arrayidx210 = getelementptr inbounds [6 x [259 x i8]], ptr %length188, i64 0, i64 %idxprom177, i64 %idx.ext.i
  store i8 0, ptr %arrayidx210, align 1, !tbaa !23
  br label %if.end211

if.end211:                                        ; preds = %assign_codes.exit, %while.body171
  %cost.1 = phi i32 [ %add198, %assign_codes.exit ], [ %cost.0451, %while.body171 ]
  %not_seen.1 = phi i32 [ %sub175, %assign_codes.exit ], [ %not_seen.0452, %while.body171 ]
  %nt.1 = phi i32 [ %inc182, %assign_codes.exit ], [ %nt.0454, %while.body171 ]
  %cmp165.not = icmp eq i32 %not_seen.1, 0
  br i1 %cmp165.not, label %while.end212, label %land.rhs, !llvm.loop !65

while.end212:                                     ; preds = %if.end211, %land.rhs
  %cost.0.lcssa = phi i32 [ %cost.1, %if.end211 ], [ %cost.0451, %land.rhs ]
  %nt.0.lcssa = phi i32 [ %nt.1, %if.end211 ], [ %nt.0454, %land.rhs ]
  switch i32 %nt.0.lcssa, label %if.end282 [
    i32 0, label %if.else216
    i32 1, label %if.then220
  ]

if.else216:                                       ; preds = %while.end212
  call void @__assert_fail(ptr noundef nonnull @.str.19, ptr noundef nonnull @.str.1, i32 noundef 1111, ptr noundef nonnull @__PRETTY_FUNCTION__.generate_prefix_code) #11
  unreachable

if.then220:                                       ; preds = %while.end212
  %tmap_new2old222 = getelementptr inbounds i8, ptr %s, i64 50332
  %42 = load i32, ptr %tmap_new2old222, align 4, !tbaa !23
  %xor = xor i32 %42, 1
  %tmap_old2new225 = getelementptr inbounds i8, ptr %s, i64 50308
  %idxprom226 = zext i32 %xor to i64
  %arrayidx227 = getelementptr inbounds [6 x i32], ptr %tmap_old2new225, i64 0, i64 %idxprom226
  store i32 1, ptr %arrayidx227, align 4, !tbaa !23
  %arrayidx230 = getelementptr inbounds i8, ptr %s, i64 50336
  store i32 %xor, ptr %arrayidx230, align 4, !tbaa !23
  %cmp231 = icmp ult i16 %1, 31
  %shr = lshr i32 %add, 4
  %cond236 = select i1 %cmp231, i32 %add, i32 %shr
  %and237 = and i32 %cond236, 30
  %shr238 = lshr i32 -21936, %and237
  %and239 = and i32 %shr238, 3
  %cond242 = select i1 %cmp231, i32 1, i32 5
  %add243 = add nuw nsw i32 %and239, %cond242
  %shl245 = shl nuw nsw i32 2, %add243
  %cmp247455.not = icmp eq i32 %shl245, %add
  br i1 %cmp247455.not, label %for.end259, label %for.body249.lr.ph

for.body249.lr.ph:                                ; preds = %if.then220
  %sub246 = sub nsw i32 %shl245, %add
  %conv250 = trunc i32 %add243 to i8
  %43 = mul nuw nsw i64 %idxprom226, 259
  %44 = getelementptr i8, ptr %s, i64 %43
  %scevgep = getelementptr i8, ptr %44, i64 36320
  %45 = call i32 @llvm.umax.i32(i32 %sub246, i32 1)
  %umax527 = zext i32 %45 to i64
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(1) %scevgep, i8 %conv250, i64 %umax527, i1 false), !tbaa !23
  %umax530 = call i32 @llvm.umax.i32(i32 %sub246, i32 1)
  br label %for.end259

for.end259:                                       ; preds = %for.body249.lr.ph, %if.then220
  %v159.0.lcssa = phi i32 [ 0, %if.then220 ], [ %umax530, %for.body249.lr.ph ]
  %cmp260.not = icmp ugt i32 %v159.0.lcssa, %conv
  %add263 = add i32 %cost.0.lcssa, 2
  %spec.select = select i1 %cmp260.not, i32 %cost.0.lcssa, i32 %add263
  %cmp266.not458 = icmp ugt i32 %v159.0.lcssa, %conv
  br i1 %cmp266.not458, label %for.end279, label %for.body268.lr.ph

for.body268.lr.ph:                                ; preds = %for.end259
  %46 = trunc i32 %add243 to i8
  %conv270 = add nuw nsw i8 %46, 1
  %47 = mul nuw nsw i64 %idxprom226, 259
  %48 = zext i32 %v159.0.lcssa to i64
  %49 = getelementptr i8, ptr %s, i64 %47
  %50 = getelementptr i8, ptr %49, i64 %48
  %scevgep534 = getelementptr i8, ptr %50, i64 36320
  %51 = sub i32 %conv, %v159.0.lcssa
  %52 = zext i32 %51 to i64
  %53 = add nuw nsw i64 %52, 1
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(1) %scevgep534, i8 %conv270, i64 %53, i1 false), !tbaa !23
  br label %for.end279

for.end279:                                       ; preds = %for.body268.lr.ph, %for.end259
  %add280 = add nuw nsw i32 %conv, 6
  %add281 = add i32 %add280, %spec.select
  br label %if.end282

if.end282:                                        ; preds = %while.end212, %for.end279
  %cost.3 = phi i32 [ %add281, %for.end279 ], [ %cost.0.lcssa, %while.end212 ]
  %nt.2 = phi i32 [ 2, %for.end279 ], [ %nt.0.lcssa, %while.end212 ]
  %num_trees = getelementptr inbounds i8, ptr %s, i64 36312
  store i32 %nt.2, ptr %num_trees, align 4, !tbaa !23
  ret i32 %cost.3
}

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.cttz.i32(i32, i1 immarg) #6

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @generate_initial_trees(ptr noundef %s, i32 noundef %nm, i32 noundef %nt) unnamed_addr #0 {
entry:
  %s.addr = alloca ptr, align 8
  %nm.addr = alloca i32, align 4
  %nt.addr = alloca i32, align 4
  %a = alloca i32, align 4
  %b = alloca i32, align 4
  %freq = alloca i32, align 4
  %cum = alloca i32, align 4
  %as = alloca i32, align 4
  %t = alloca i32, align 4
  store ptr %s, ptr %s.addr, align 8, !tbaa !12
  store i32 %nm, ptr %nm.addr, align 4, !tbaa !14
  store i32 %nt, ptr %nt.addr, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %a) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %b) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %freq) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %cum) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %as) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %t) #12
  %0 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u = getelementptr inbounds %struct.encoder_state, ptr %0, i32 0, i32 11
  %length = getelementptr inbounds %struct.anon, ptr %u, i32 0, i32 5
  %arraydecay = getelementptr inbounds [6 x [259 x i8]], ptr %length, i64 0, i64 0
  %1 = call i64 @llvm.objectsize.i64.p0(ptr %arraydecay, i1 false, i1 true, i1 false)
  %call.i104 = call ptr @__memset_chk(ptr noundef nonnull %arraydecay, i32 noundef 1, i64 noundef 1554, i64 noundef %1) #12
  store i32 0, ptr %as, align 4, !tbaa !14
  store i32 0, ptr %a, align 4, !tbaa !14
  store i32 0, ptr %cum, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %2 = load i32, ptr %cum, align 4, !tbaa !14
  %3 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp = icmp ult i32 %2, %3
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %4 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u1 = getelementptr inbounds %struct.encoder_state, ptr %4, i32 0, i32 11
  %code = getelementptr inbounds %struct.anon, ptr %u1, i32 0, i32 6
  %arrayidx = getelementptr inbounds [6 x [259 x i32]], ptr %code, i64 0, i64 0
  %5 = load i32, ptr %a, align 4, !tbaa !14
  %idxprom = zext i32 %5 to i64
  %arrayidx2 = getelementptr inbounds [259 x i32], ptr %arrayidx, i64 0, i64 %idxprom
  %6 = load i32, ptr %arrayidx2, align 4, !tbaa !23
  store i32 %6, ptr %freq, align 4, !tbaa !14
  %7 = load i32, ptr %freq, align 4, !tbaa !14
  %8 = load i32, ptr %cum, align 4, !tbaa !14
  %add = add i32 %8, %7
  store i32 %add, ptr %cum, align 4, !tbaa !14
  %9 = load i32, ptr %freq, align 4, !tbaa !14
  %cmp3 = icmp ult i32 %9, 1
  br i1 %cmp3, label %cond.true, label %cond.false

cond.true:                                        ; preds = %for.body
  %10 = load i32, ptr %freq, align 4, !tbaa !14
  br label %cond.end

cond.false:                                       ; preds = %for.body
  br label %cond.end

cond.end:                                         ; preds = %cond.false, %cond.true
  %cond = phi i32 [ %10, %cond.true ], [ 1, %cond.false ]
  %11 = load i32, ptr %as, align 4, !tbaa !14
  %add4 = add i32 %11, %cond
  store i32 %add4, ptr %as, align 4, !tbaa !14
  br label %for.inc

for.inc:                                          ; preds = %cond.end
  %12 = load i32, ptr %a, align 4, !tbaa !14
  %inc = add i32 %12, 1
  store i32 %inc, ptr %a, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !66

for.end:                                          ; preds = %for.cond
  %13 = load i32, ptr %cum, align 4, !tbaa !14
  %14 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp5 = icmp eq i32 %13, %14
  br i1 %cmp5, label %if.then, label %if.else

if.then:                                          ; preds = %for.end
  br label %if.end

if.else:                                          ; preds = %for.end
  call void @__assert_fail(ptr noundef @.str.27, ptr noundef @.str.1, i32 noundef 799, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end:                                           ; preds = %if.then
  %15 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %16 = load i32, ptr %as, align 4, !tbaa !14
  %cmp6 = icmp ult i32 %15, %16
  br i1 %cmp6, label %cond.true7, label %cond.false8

cond.true7:                                       ; preds = %if.end
  %17 = load i32, ptr %nt.addr, align 4, !tbaa !14
  br label %cond.end9

cond.false8:                                      ; preds = %if.end
  %18 = load i32, ptr %as, align 4, !tbaa !14
  br label %cond.end9

cond.end9:                                        ; preds = %cond.false8, %cond.true7
  %cond10 = phi i32 [ %17, %cond.true7 ], [ %18, %cond.false8 ]
  store i32 %cond10, ptr %nt.addr, align 4, !tbaa !14
  store i32 0, ptr %a, align 4, !tbaa !14
  store i32 0, ptr %t, align 4, !tbaa !14
  br label %for.cond11

for.cond11:                                       ; preds = %for.inc90, %cond.end9
  %19 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %cmp12 = icmp ugt i32 %19, 0
  br i1 %cmp12, label %for.body13, label %for.end93

for.body13:                                       ; preds = %for.cond11
  %20 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp14 = icmp ugt i32 %20, 0
  br i1 %cmp14, label %if.then15, label %if.else16

if.then15:                                        ; preds = %for.body13
  br label %if.end17

if.else16:                                        ; preds = %for.body13
  call void @__assert_fail(ptr noundef @.str.28, ptr noundef @.str.1, i32 noundef 808, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end17:                                         ; preds = %if.then15
  %21 = load i32, ptr %as, align 4, !tbaa !14
  %22 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %cmp18 = icmp uge i32 %21, %22
  br i1 %cmp18, label %if.then19, label %if.else20

if.then19:                                        ; preds = %if.end17
  br label %if.end21

if.else20:                                        ; preds = %if.end17
  call void @__assert_fail(ptr noundef @.str.29, ptr noundef @.str.1, i32 noundef 809, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end21:                                         ; preds = %if.then19
  %23 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u22 = getelementptr inbounds %struct.encoder_state, ptr %23, i32 0, i32 11
  %code23 = getelementptr inbounds %struct.anon, ptr %u22, i32 0, i32 6
  %arrayidx24 = getelementptr inbounds [6 x [259 x i32]], ptr %code23, i64 0, i64 0
  %24 = load i32, ptr %a, align 4, !tbaa !14
  %idxprom25 = zext i32 %24 to i64
  %arrayidx26 = getelementptr inbounds [259 x i32], ptr %arrayidx24, i64 0, i64 %idxprom25
  %25 = load i32, ptr %arrayidx26, align 4, !tbaa !23
  store i32 %25, ptr %freq, align 4, !tbaa !14
  %26 = load i32, ptr %freq, align 4, !tbaa !14
  store i32 %26, ptr %cum, align 4, !tbaa !14
  %27 = load i32, ptr %freq, align 4, !tbaa !14
  %cmp27 = icmp ult i32 %27, 1
  br i1 %cmp27, label %cond.true28, label %cond.false29

cond.true28:                                      ; preds = %if.end21
  %28 = load i32, ptr %freq, align 4, !tbaa !14
  br label %cond.end30

cond.false29:                                     ; preds = %if.end21
  br label %cond.end30

cond.end30:                                       ; preds = %cond.false29, %cond.true28
  %cond31 = phi i32 [ %28, %cond.true28 ], [ 1, %cond.false29 ]
  %29 = load i32, ptr %as, align 4, !tbaa !14
  %sub = sub i32 %29, %cond31
  store i32 %sub, ptr %as, align 4, !tbaa !14
  %30 = load i32, ptr %a, align 4, !tbaa !14
  %add32 = add i32 %30, 1
  store i32 %add32, ptr %b, align 4, !tbaa !14
  br label %while.cond

while.cond:                                       ; preds = %cond.end45, %cond.end30
  %31 = load i32, ptr %as, align 4, !tbaa !14
  %32 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %sub33 = sub i32 %32, 1
  %cmp34 = icmp ugt i32 %31, %sub33
  br i1 %cmp34, label %land.rhs, label %land.end

land.rhs:                                         ; preds = %while.cond
  %33 = load i32, ptr %cum, align 4, !tbaa !14
  %34 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %mul = mul i32 %33, %34
  %35 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp35 = icmp ult i32 %mul, %35
  br label %land.end

land.end:                                         ; preds = %land.rhs, %while.cond
  %36 = phi i1 [ false, %while.cond ], [ %cmp35, %land.rhs ]
  br i1 %36, label %while.body, label %while.end

while.body:                                       ; preds = %land.end
  %37 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u36 = getelementptr inbounds %struct.encoder_state, ptr %37, i32 0, i32 11
  %code37 = getelementptr inbounds %struct.anon, ptr %u36, i32 0, i32 6
  %arrayidx38 = getelementptr inbounds [6 x [259 x i32]], ptr %code37, i64 0, i64 0
  %38 = load i32, ptr %b, align 4, !tbaa !14
  %idxprom39 = zext i32 %38 to i64
  %arrayidx40 = getelementptr inbounds [259 x i32], ptr %arrayidx38, i64 0, i64 %idxprom39
  %39 = load i32, ptr %arrayidx40, align 4, !tbaa !23
  store i32 %39, ptr %freq, align 4, !tbaa !14
  %40 = load i32, ptr %freq, align 4, !tbaa !14
  %41 = load i32, ptr %cum, align 4, !tbaa !14
  %add41 = add i32 %41, %40
  store i32 %add41, ptr %cum, align 4, !tbaa !14
  %42 = load i32, ptr %freq, align 4, !tbaa !14
  %cmp42 = icmp ult i32 %42, 1
  br i1 %cmp42, label %cond.true43, label %cond.false44

cond.true43:                                      ; preds = %while.body
  %43 = load i32, ptr %freq, align 4, !tbaa !14
  br label %cond.end45

cond.false44:                                     ; preds = %while.body
  br label %cond.end45

cond.end45:                                       ; preds = %cond.false44, %cond.true43
  %cond46 = phi i32 [ %43, %cond.true43 ], [ 1, %cond.false44 ]
  %44 = load i32, ptr %as, align 4, !tbaa !14
  %sub47 = sub i32 %44, %cond46
  store i32 %sub47, ptr %as, align 4, !tbaa !14
  %45 = load i32, ptr %b, align 4, !tbaa !14
  %inc48 = add i32 %45, 1
  store i32 %inc48, ptr %b, align 4, !tbaa !14
  br label %while.cond, !llvm.loop !67

while.end:                                        ; preds = %land.end
  %46 = load i32, ptr %cum, align 4, !tbaa !14
  %47 = load i32, ptr %freq, align 4, !tbaa !14
  %cmp49 = icmp ugt i32 %46, %47
  br i1 %cmp49, label %land.lhs.true, label %if.end63

land.lhs.true:                                    ; preds = %while.end
  %48 = load i32, ptr %cum, align 4, !tbaa !14
  %mul50 = mul i32 2, %48
  %49 = load i32, ptr %freq, align 4, !tbaa !14
  %sub51 = sub i32 %mul50, %49
  %50 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %mul52 = mul i32 %sub51, %50
  %51 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %mul53 = mul i32 2, %51
  %cmp54 = icmp ugt i32 %mul52, %mul53
  br i1 %cmp54, label %if.then55, label %if.end63

if.then55:                                        ; preds = %land.lhs.true
  %52 = load i32, ptr %freq, align 4, !tbaa !14
  %53 = load i32, ptr %cum, align 4, !tbaa !14
  %sub56 = sub i32 %53, %52
  store i32 %sub56, ptr %cum, align 4, !tbaa !14
  %54 = load i32, ptr %freq, align 4, !tbaa !14
  %cmp57 = icmp ult i32 %54, 1
  br i1 %cmp57, label %cond.true58, label %cond.false59

cond.true58:                                      ; preds = %if.then55
  %55 = load i32, ptr %freq, align 4, !tbaa !14
  br label %cond.end60

cond.false59:                                     ; preds = %if.then55
  br label %cond.end60

cond.end60:                                       ; preds = %cond.false59, %cond.true58
  %cond61 = phi i32 [ %55, %cond.true58 ], [ 1, %cond.false59 ]
  %56 = load i32, ptr %as, align 4, !tbaa !14
  %add62 = add i32 %56, %cond61
  store i32 %add62, ptr %as, align 4, !tbaa !14
  %57 = load i32, ptr %b, align 4, !tbaa !14
  %dec = add i32 %57, -1
  store i32 %dec, ptr %b, align 4, !tbaa !14
  br label %if.end63

if.end63:                                         ; preds = %cond.end60, %land.lhs.true, %while.end
  %58 = load i32, ptr %a, align 4, !tbaa !14
  %59 = load i32, ptr %b, align 4, !tbaa !14
  %cmp64 = icmp ult i32 %58, %59
  br i1 %cmp64, label %if.then65, label %if.else66

if.then65:                                        ; preds = %if.end63
  br label %if.end67

if.else66:                                        ; preds = %if.end63
  call void @__assert_fail(ptr noundef @.str.30, ptr noundef @.str.1, i32 noundef 828, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end67:                                         ; preds = %if.then65
  %60 = load i32, ptr %cum, align 4, !tbaa !14
  %cmp68 = icmp ugt i32 %60, 0
  br i1 %cmp68, label %if.then69, label %if.else70

if.then69:                                        ; preds = %if.end67
  br label %if.end71

if.else70:                                        ; preds = %if.end67
  call void @__assert_fail(ptr noundef @.str.31, ptr noundef @.str.1, i32 noundef 829, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end71:                                         ; preds = %if.then69
  %61 = load i32, ptr %cum, align 4, !tbaa !14
  %62 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp72 = icmp ule i32 %61, %62
  br i1 %cmp72, label %if.then73, label %if.else74

if.then73:                                        ; preds = %if.end71
  br label %if.end75

if.else74:                                        ; preds = %if.end71
  call void @__assert_fail(ptr noundef @.str.32, ptr noundef @.str.1, i32 noundef 830, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end75:                                         ; preds = %if.then73
  %63 = load i32, ptr %as, align 4, !tbaa !14
  %64 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %sub76 = sub i32 %64, 1
  %cmp77 = icmp uge i32 %63, %sub76
  br i1 %cmp77, label %if.then78, label %if.else79

if.then78:                                        ; preds = %if.end75
  br label %if.end80

if.else79:                                        ; preds = %if.end75
  call void @__assert_fail(ptr noundef @.str.33, ptr noundef @.str.1, i32 noundef 831, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end80:                                         ; preds = %if.then78
  %65 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u81 = getelementptr inbounds %struct.encoder_state, ptr %65, i32 0, i32 11
  %length82 = getelementptr inbounds %struct.anon, ptr %u81, i32 0, i32 5
  %66 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom83 = zext i32 %66 to i64
  %arrayidx84 = getelementptr inbounds [6 x [259 x i8]], ptr %length82, i64 0, i64 %idxprom83
  %67 = load i32, ptr %a, align 4, !tbaa !14
  %idxprom85 = zext i32 %67 to i64
  %arrayidx86 = getelementptr inbounds [259 x i8], ptr %arrayidx84, i64 0, i64 %idxprom85
  %68 = load i32, ptr %b, align 4, !tbaa !14
  %69 = load i32, ptr %a, align 4, !tbaa !14
  %sub87 = sub i32 %68, %69
  %conv = zext i32 %sub87 to i64
  %70 = call i64 @llvm.objectsize.i64.p0(ptr %arrayidx86, i1 false, i1 true, i1 false)
  %call.i = call ptr @__memset_chk(ptr noundef nonnull %arrayidx86, i32 noundef 0, i64 noundef %conv, i64 noundef %70) #12
  %71 = load i32, ptr %b, align 4, !tbaa !14
  store i32 %71, ptr %a, align 4, !tbaa !14
  %72 = load i32, ptr %cum, align 4, !tbaa !14
  %73 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %sub89 = sub i32 %73, %72
  store i32 %sub89, ptr %nm.addr, align 4, !tbaa !14
  br label %for.inc90

for.inc90:                                        ; preds = %if.end80
  %74 = load i32, ptr %t, align 4, !tbaa !14
  %inc91 = add i32 %74, 1
  store i32 %inc91, ptr %t, align 4, !tbaa !14
  %75 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %dec92 = add i32 %75, -1
  store i32 %dec92, ptr %nt.addr, align 4, !tbaa !14
  br label %for.cond11, !llvm.loop !68

for.end93:                                        ; preds = %for.cond11
  %76 = load i32, ptr %as, align 4, !tbaa !14
  %cmp94 = icmp eq i32 %76, 0
  br i1 %cmp94, label %if.then96, label %if.else97

if.then96:                                        ; preds = %for.end93
  br label %if.end98

if.else97:                                        ; preds = %for.end93
  call void @__assert_fail(ptr noundef @.str.34, ptr noundef @.str.1, i32 noundef 839, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end98:                                         ; preds = %if.then96
  %77 = load i32, ptr %nm.addr, align 4, !tbaa !14
  %cmp99 = icmp eq i32 %77, 0
  br i1 %cmp99, label %if.then101, label %if.else102

if.then101:                                       ; preds = %if.end98
  br label %if.end103

if.else102:                                       ; preds = %if.end98
  call void @__assert_fail(ptr noundef @.str.35, ptr noundef @.str.1, i32 noundef 840, ptr noundef @__PRETTY_FUNCTION__.generate_initial_trees) #11
  unreachable

if.end103:                                        ; preds = %if.then101
  call void @llvm.lifetime.end.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %as) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %cum) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %freq) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %b) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %a) #12
  ret void
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc i32 @find_best_tree(ptr noundef %gs, i32 noundef %nt, ptr noundef %len_pack) unnamed_addr #0 {
entry:
  %gs.addr = alloca ptr, align 8
  %nt.addr = alloca i32, align 4
  %len_pack.addr = alloca ptr, align 8
  %c = alloca i32, align 4
  %bc = alloca i32, align 4
  %t = alloca i32, align 4
  %bt = alloca i32, align 4
  %cp = alloca i64, align 8
  %i = alloca i32, align 4
  store ptr %gs, ptr %gs.addr, align 8, !tbaa !12
  store i32 %nt, ptr %nt.addr, align 4, !tbaa !14
  store ptr %len_pack, ptr %len_pack.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 4, ptr %c) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %bc) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %bt) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %cp) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  store i64 0, ptr %cp, align 8, !tbaa !8
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %0 = load i32, ptr %i, align 4, !tbaa !14
  %cmp = icmp ult i32 %0, 50
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %1 = load ptr, ptr %len_pack.addr, align 8, !tbaa !12
  %2 = load ptr, ptr %gs.addr, align 8, !tbaa !12
  %3 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom = zext i32 %3 to i64
  %arrayidx = getelementptr inbounds i16, ptr %2, i64 %idxprom
  %4 = load i16, ptr %arrayidx, align 2, !tbaa !42
  %idxprom1 = zext i16 %4 to i64
  %arrayidx2 = getelementptr inbounds i64, ptr %1, i64 %idxprom1
  %5 = load i64, ptr %arrayidx2, align 8, !tbaa !8
  %6 = load i64, ptr %cp, align 8, !tbaa !8
  %add = add i64 %6, %5
  store i64 %add, ptr %cp, align 8, !tbaa !8
  br label %for.inc

for.inc:                                          ; preds = %for.body
  %7 = load i32, ptr %i, align 4, !tbaa !14
  %inc = add i32 %7, 1
  store i32 %inc, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !69

for.end:                                          ; preds = %for.cond
  %8 = load i64, ptr %cp, align 8, !tbaa !8
  %and = and i64 %8, 1023
  %conv = trunc i64 %and to i32
  store i32 %conv, ptr %bc, align 4, !tbaa !14
  store i32 0, ptr %bt, align 4, !tbaa !14
  store i32 1, ptr %t, align 4, !tbaa !14
  br label %for.cond3

for.cond3:                                        ; preds = %for.inc11, %for.end
  %9 = load i32, ptr %t, align 4, !tbaa !14
  %10 = load i32, ptr %nt.addr, align 4, !tbaa !14
  %cmp4 = icmp ult i32 %9, %10
  br i1 %cmp4, label %for.body6, label %for.end13

for.body6:                                        ; preds = %for.cond3
  %11 = load i64, ptr %cp, align 8, !tbaa !8
  %shr = lshr i64 %11, 10
  store i64 %shr, ptr %cp, align 8, !tbaa !8
  %12 = load i64, ptr %cp, align 8, !tbaa !8
  %and7 = and i64 %12, 1023
  %conv8 = trunc i64 %and7 to i32
  store i32 %conv8, ptr %c, align 4, !tbaa !14
  %13 = load i32, ptr %c, align 4, !tbaa !14
  %14 = load i32, ptr %bc, align 4, !tbaa !14
  %cmp9 = icmp ult i32 %13, %14
  br i1 %cmp9, label %if.then, label %if.end

if.then:                                          ; preds = %for.body6
  %15 = load i32, ptr %c, align 4, !tbaa !14
  store i32 %15, ptr %bc, align 4, !tbaa !14
  %16 = load i32, ptr %t, align 4, !tbaa !14
  store i32 %16, ptr %bt, align 4, !tbaa !14
  br label %if.end

if.end:                                           ; preds = %if.then, %for.body6
  br label %for.inc11

for.inc11:                                        ; preds = %if.end
  %17 = load i32, ptr %t, align 4, !tbaa !14
  %inc12 = add i32 %17, 1
  store i32 %inc12, ptr %t, align 4, !tbaa !14
  br label %for.cond3, !llvm.loop !70

for.end13:                                        ; preds = %for.cond3
  %18 = load i32, ptr %bt, align 4, !tbaa !14
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %cp) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %bt) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %bc) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %c) #12
  ret i32 %18
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @make_code_lengths(ptr noundef %length, ptr noundef %frequency, i32 noundef %as) unnamed_addr #0 {
entry:
  %length.addr = alloca ptr, align 8
  %frequency.addr = alloca ptr, align 8
  %as.addr = alloca i32, align 4
  %i = alloca i32, align 4
  %k = alloca i32, align 4
  %d = alloca i32, align 4
  %c = alloca i32, align 4
  %weight = alloca [258 x i64], align 16
  %V = alloca [258 x i32], align 16
  %count = alloca [32 x i32], align 16
  store ptr %length, ptr %length.addr, align 8, !tbaa !12
  store ptr %frequency, ptr %frequency.addr, align 8, !tbaa !12
  store i32 %as, ptr %as.addr, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %d) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %c) #12
  call void @llvm.lifetime.start.p0(i64 2064, ptr %weight) #12
  call void @llvm.lifetime.start.p0(i64 1032, ptr %V) #12
  call void @llvm.lifetime.start.p0(i64 128, ptr %count) #12
  %0 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp = icmp uge i32 %0, 3
  br i1 %cmp, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  br label %if.end

if.else:                                          ; preds = %entry
  call void @__assert_fail(ptr noundef @.str.36, ptr noundef @.str.1, i32 noundef 724, ptr noundef @__PRETTY_FUNCTION__.make_code_lengths) #11
  unreachable

if.end:                                           ; preds = %if.then
  %1 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp1 = icmp ule i32 %1, 258
  br i1 %cmp1, label %if.then2, label %if.else3

if.then2:                                         ; preds = %if.end
  br label %if.end4

if.else3:                                         ; preds = %if.end
  call void @__assert_fail(ptr noundef @.str.37, ptr noundef @.str.1, i32 noundef 725, ptr noundef @__PRETTY_FUNCTION__.make_code_lengths) #11
  unreachable

if.end4:                                          ; preds = %if.then2
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %if.end4
  %2 = load i32, ptr %i, align 4, !tbaa !14
  %3 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp5 = icmp ult i32 %2, %3
  br i1 %cmp5, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %4 = load ptr, ptr %frequency.addr, align 8, !tbaa !12
  %5 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom = zext i32 %5 to i64
  %arrayidx = getelementptr inbounds i32, ptr %4, i64 %idxprom
  %6 = load i32, ptr %arrayidx, align 4, !tbaa !14
  %cmp6 = icmp ult i32 %6, 1
  br i1 %cmp6, label %cond.true, label %cond.false

cond.true:                                        ; preds = %for.body
  br label %cond.end

cond.false:                                       ; preds = %for.body
  %7 = load ptr, ptr %frequency.addr, align 8, !tbaa !12
  %8 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom7 = zext i32 %8 to i64
  %arrayidx8 = getelementptr inbounds i32, ptr %7, i64 %idxprom7
  %9 = load i32, ptr %arrayidx8, align 4, !tbaa !14
  br label %cond.end

cond.end:                                         ; preds = %cond.false, %cond.true
  %cond = phi i32 [ 1, %cond.true ], [ %9, %cond.false ]
  %conv = zext i32 %cond to i64
  %shl = shl nuw i64 %conv, 32
  %or = or i64 %shl, 65536
  %10 = load i32, ptr %i, align 4, !tbaa !14
  %sub = sub i32 258, %10
  %conv9 = zext i32 %sub to i64
  %or10 = or i64 %or, %conv9
  %11 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom11 = zext i32 %11 to i64
  %arrayidx12 = getelementptr inbounds [258 x i64], ptr %weight, i64 0, i64 %idxprom11
  store i64 %or10, ptr %arrayidx12, align 8, !tbaa !8
  br label %for.inc

for.inc:                                          ; preds = %cond.end
  %12 = load i32, ptr %i, align 4, !tbaa !14
  %inc = add i32 %12, 1
  store i32 %inc, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !71

for.end:                                          ; preds = %for.cond
  %arraydecay = getelementptr inbounds [258 x i64], ptr %weight, i64 0, i64 0
  %arraydecay13 = getelementptr inbounds [258 x i64], ptr %weight, i64 0, i64 0
  %13 = load i32, ptr %as.addr, align 4, !tbaa !14
  %idx.ext = zext i32 %13 to i64
  %add.ptr = getelementptr inbounds i64, ptr %arraydecay13, i64 %idx.ext
  call fastcc void @sort_alphabet(ptr noundef %arraydecay, ptr noundef %add.ptr)
  %arraydecay14 = getelementptr inbounds [258 x i32], ptr %V, i64 0, i64 0
  %arraydecay15 = getelementptr inbounds [258 x i64], ptr %weight, i64 0, i64 0
  %14 = load i32, ptr %as.addr, align 4, !tbaa !14
  call fastcc void @build_tree(ptr noundef %arraydecay14, ptr noundef %arraydecay15, i32 noundef %14)
  %arraydecay16 = getelementptr inbounds [32 x i32], ptr %count, i64 0, i64 0
  %arraydecay17 = getelementptr inbounds [258 x i32], ptr %V, i64 0, i64 0
  %15 = load i32, ptr %as.addr, align 4, !tbaa !14
  call fastcc void @compute_depths(ptr noundef %arraydecay16, ptr noundef %arraydecay17, i32 noundef %15)
  store i32 0, ptr %i, align 4, !tbaa !14
  store i32 0, ptr %c, align 4, !tbaa !14
  store i32 0, ptr %d, align 4, !tbaa !14
  br label %for.cond18

for.cond18:                                       ; preds = %for.inc38, %for.end
  %16 = load i32, ptr %d, align 4, !tbaa !14
  %cmp19 = icmp ule i32 %16, 30
  br i1 %cmp19, label %for.body21, label %for.end40

for.body21:                                       ; preds = %for.cond18
  %17 = load i32, ptr %d, align 4, !tbaa !14
  %idxprom22 = zext i32 %17 to i64
  %arrayidx23 = getelementptr inbounds [32 x i32], ptr %count, i64 0, i64 %idxprom22
  %18 = load i32, ptr %arrayidx23, align 4, !tbaa !14
  store i32 %18, ptr %k, align 4, !tbaa !14
  %19 = load i32, ptr %c, align 4, !tbaa !14
  %20 = load i32, ptr %k, align 4, !tbaa !14
  %add = add i32 %19, %20
  %shl24 = shl i32 %add, 1
  store i32 %shl24, ptr %c, align 4, !tbaa !14
  br label %while.cond

while.cond:                                       ; preds = %if.end31, %for.body21
  %21 = load i32, ptr %k, align 4, !tbaa !14
  %cmp25 = icmp ne i32 %21, 0
  br i1 %cmp25, label %while.body, label %while.end

while.body:                                       ; preds = %while.cond
  %22 = load i32, ptr %i, align 4, !tbaa !14
  %23 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp27 = icmp ult i32 %22, %23
  br i1 %cmp27, label %if.then29, label %if.else30

if.then29:                                        ; preds = %while.body
  br label %if.end31

if.else30:                                        ; preds = %while.body
  call void @__assert_fail(ptr noundef @.str.38, ptr noundef @.str.1, i32 noundef 758, ptr noundef @__PRETTY_FUNCTION__.make_code_lengths) #11
  unreachable

if.end31:                                         ; preds = %if.then29
  %24 = load i32, ptr %d, align 4, !tbaa !14
  %conv32 = trunc i32 %24 to i8
  %25 = load ptr, ptr %length.addr, align 8, !tbaa !12
  %26 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom33 = zext i32 %26 to i64
  %arrayidx34 = getelementptr inbounds [258 x i64], ptr %weight, i64 0, i64 %idxprom33
  %27 = load i64, ptr %arrayidx34, align 8, !tbaa !8
  %and = and i64 %27, 65535
  %sub35 = sub nsw i64 258, %and
  %arrayidx36 = getelementptr inbounds i8, ptr %25, i64 %sub35
  store i8 %conv32, ptr %arrayidx36, align 1, !tbaa !23
  %28 = load i32, ptr %i, align 4, !tbaa !14
  %inc37 = add i32 %28, 1
  store i32 %inc37, ptr %i, align 4, !tbaa !14
  %29 = load i32, ptr %k, align 4, !tbaa !14
  %dec = add i32 %29, -1
  store i32 %dec, ptr %k, align 4, !tbaa !14
  br label %while.cond, !llvm.loop !72

while.end:                                        ; preds = %while.cond
  br label %for.inc38

for.inc38:                                        ; preds = %while.end
  %30 = load i32, ptr %d, align 4, !tbaa !14
  %inc39 = add i32 %30, 1
  store i32 %inc39, ptr %d, align 4, !tbaa !14
  br label %for.cond18, !llvm.loop !73

for.end40:                                        ; preds = %for.cond18
  %31 = load i32, ptr %c, align 4, !tbaa !14
  %conv41 = zext i32 %31 to i64
  %cmp42 = icmp eq i64 %conv41, 2147483648
  br i1 %cmp42, label %if.then44, label %if.else45

if.then44:                                        ; preds = %for.end40
  br label %if.end46

if.else45:                                        ; preds = %for.end40
  call void @__assert_fail(ptr noundef @.str.39, ptr noundef @.str.1, i32 noundef 764, ptr noundef @__PRETTY_FUNCTION__.make_code_lengths) #11
  unreachable

if.end46:                                         ; preds = %if.then44
  %32 = load i32, ptr %i, align 4, !tbaa !14
  %33 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp47 = icmp eq i32 %32, %33
  br i1 %cmp47, label %if.then49, label %if.else50

if.then49:                                        ; preds = %if.end46
  br label %if.end51

if.else50:                                        ; preds = %if.end46
  call void @__assert_fail(ptr noundef @.str.40, ptr noundef @.str.1, i32 noundef 765, ptr noundef @__PRETTY_FUNCTION__.make_code_lengths) #11
  unreachable

if.end51:                                         ; preds = %if.then49
  call void @llvm.lifetime.end.p0(i64 128, ptr %count) #12
  call void @llvm.lifetime.end.p0(i64 1032, ptr %V) #12
  call void @llvm.lifetime.end.p0(i64 2064, ptr %weight) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %c) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %d) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  ret void
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define dso_local ptr @transmit(ptr noundef %s, ptr noundef %buf) local_unnamed_addr #0 {
entry:
  %s.addr = alloca ptr, align 8
  %buf.addr = alloca ptr, align 8
  %b = alloca i64, align 8
  %k = alloca i32, align 4
  %sp = alloca ptr, align 8
  %t = alloca i32, align 4
  %v = alloca i32, align 4
  %mtfv = alloca ptr, align 8
  %p = alloca ptr, align 8
  %ns = alloca i32, align 4
  %as = alloca i32, align 4
  %gr = alloca i32, align 4
  %pack = alloca [16 x i32], align 16
  %pk = alloca i32, align 4
  %i = alloca i32, align 4
  %j = alloca i32, align 4
  %big = alloca i32, align 4
  %a = alloca i32, align 4
  %c = alloca i32, align 4
  %len = alloca ptr, align 8
  %i275 = alloca i32, align 4
  %L = alloca ptr, align 8
  %B = alloca ptr, align 8
  %mv = alloca i32, align 4
  store ptr %s, ptr %s.addr, align 8, !tbaa !12
  store ptr %buf, ptr %buf.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %b) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %sp) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %v) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %mtfv) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %p) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %ns) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %as) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %gr) #12
  store i64 0, ptr %b, align 8, !tbaa !8
  store i32 0, ptr %k, align 4, !tbaa !14
  %0 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  store ptr %0, ptr %p, align 8, !tbaa !12
  %1 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %SA = getelementptr inbounds %struct.encoder_state, ptr %1, i32 0, i32 12
  %arraydecay = getelementptr inbounds [0 x i32], ptr %SA, i64 0, i64 0
  store ptr %arraydecay, ptr %mtfv, align 8, !tbaa !12
  %2 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %3 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nmtf = getelementptr inbounds %struct.encoder_state, ptr %3, i32 0, i32 6
  %4 = load i32, ptr %nmtf, align 4, !tbaa !31
  %sub = sub i32 %4, 1
  %idxprom = zext i32 %sub to i64
  %arrayidx = getelementptr inbounds i16, ptr %2, i64 %idxprom
  %5 = load i16, ptr %arrayidx, align 2, !tbaa !42
  %conv = zext i16 %5 to i32
  %add = add nuw nsw i32 %conv, 1
  store i32 %add, ptr %as, align 4, !tbaa !14
  %6 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %nmtf1 = getelementptr inbounds %struct.encoder_state, ptr %6, i32 0, i32 6
  %7 = load i32, ptr %nmtf1, align 4, !tbaa !31
  %add2 = add i32 %7, 50
  %sub3 = sub i32 %add2, 1
  %div = udiv i32 %sub3, 50
  store i32 %div, ptr %ns, align 4, !tbaa !14
  %8 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  %tobool = icmp ne ptr %8, null
  br i1 %tobool, label %if.end13, label %if.then

if.then:                                          ; preds = %entry
  %9 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %10 = load i32, ptr %ns, align 4, !tbaa !14
  %mul = mul i32 %10, 50
  %idxprom4 = zext i32 %mul to i64
  %arrayidx5 = getelementptr inbounds i16, ptr %9, i64 %idxprom4
  store ptr %arrayidx5, ptr %buf.addr, align 8, !tbaa !12
  %11 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  %12 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %out_expect_len = getelementptr inbounds %struct.encoder_state, ptr %12, i32 0, i32 5
  %13 = load i32, ptr %out_expect_len, align 4, !tbaa !38
  %add6 = add i32 %13, 3
  %div7 = udiv i32 %add6, 4
  %mul8 = mul nuw i32 %div7, 4
  %idx.ext = zext i32 %mul8 to i64
  %add.ptr = getelementptr inbounds i8, ptr %11, i64 %idx.ext
  %14 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %15 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %max_block_size = getelementptr inbounds %struct.encoder_state, ptr %15, i32 0, i32 9
  %16 = load i32, ptr %max_block_size, align 4, !tbaa !16
  %conv9 = zext i32 %16 to i64
  %call = call i64 @encoder_alloc_size(i64 noundef %conv9)
  %add.ptr10 = getelementptr inbounds i8, ptr %14, i64 %call
  %cmp = icmp ule ptr %add.ptr, %add.ptr10
  br i1 %cmp, label %if.then12, label %if.else

if.then12:                                        ; preds = %if.then
  br label %if.end

if.else:                                          ; preds = %if.then
  call void @__assert_fail(ptr noundef @.str.20, ptr noundef @.str.1, i32 noundef 1177, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end:                                           ; preds = %if.then12
  %17 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  store ptr %17, ptr %p, align 8, !tbaa !12
  br label %if.end13

if.end13:                                         ; preds = %if.end, %entry
  %18 = load i64, ptr %b, align 8, !tbaa !8
  %shl = shl i64 %18, 24
  %or = or i64 %shl, 3227993
  store i64 %or, ptr %b, align 8, !tbaa !8
  %19 = load i32, ptr %k, align 4, !tbaa !14
  %add14 = add i32 %19, 24
  store i32 %add14, ptr %k, align 4, !tbaa !14
  %20 = load i64, ptr %b, align 8, !tbaa !8
  %shl15 = shl i64 %20, 24
  %or16 = or i64 %shl15, 2511705
  store i64 %or16, ptr %b, align 8, !tbaa !8
  %21 = load i32, ptr %k, align 4, !tbaa !14
  %add17 = add i32 %21, 24
  store i32 %add17, ptr %k, align 4, !tbaa !14
  %22 = load i32, ptr %k, align 4, !tbaa !14
  %sub18 = sub i32 %22, 32
  store i32 %sub18, ptr %k, align 4, !tbaa !14
  %23 = load i64, ptr %b, align 8, !tbaa !8
  %24 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom = zext i32 %24 to i64
  %shr = lshr i64 %23, %sh_prom
  %conv19 = trunc i64 %shr to i32
  %call20 = call fastcc i32 @__bswap_32(i32 noundef %conv19)
  %25 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr = getelementptr inbounds i32, ptr %25, i32 1
  store ptr %incdec.ptr, ptr %p, align 8, !tbaa !12
  store i32 %call20, ptr %25, align 4, !tbaa !14
  %26 = load i64, ptr %b, align 8, !tbaa !8
  %shl21 = shl i64 %26, 32
  %27 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %block_crc = getelementptr inbounds %struct.encoder_state, ptr %27, i32 0, i32 3
  %28 = load i32, ptr %block_crc, align 4, !tbaa !20
  %xor = xor i32 %28, -1
  %conv22 = zext i32 %xor to i64
  %or23 = or i64 %shl21, %conv22
  store i64 %or23, ptr %b, align 8, !tbaa !8
  %29 = load i32, ptr %k, align 4, !tbaa !14
  %add24 = add i32 %29, 32
  store i32 %add24, ptr %k, align 4, !tbaa !14
  %30 = load i32, ptr %k, align 4, !tbaa !14
  %sub25 = sub i32 %30, 32
  store i32 %sub25, ptr %k, align 4, !tbaa !14
  %31 = load i64, ptr %b, align 8, !tbaa !8
  %32 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom26 = zext i32 %32 to i64
  %shr27 = lshr i64 %31, %sh_prom26
  %conv28 = trunc i64 %shr27 to i32
  %call29 = call fastcc i32 @__bswap_32(i32 noundef %conv28)
  %33 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr30 = getelementptr inbounds i32, ptr %33, i32 1
  store ptr %incdec.ptr30, ptr %p, align 8, !tbaa !12
  store i32 %call29, ptr %33, align 4, !tbaa !14
  %34 = load i64, ptr %b, align 8, !tbaa !8
  %shl31 = shl i64 %34, 1
  %or32 = or i64 %shl31, 0
  store i64 %or32, ptr %b, align 8, !tbaa !8
  %35 = load i32, ptr %k, align 4, !tbaa !14
  %add33 = add i32 %35, 1
  store i32 %add33, ptr %k, align 4, !tbaa !14
  %36 = load i64, ptr %b, align 8, !tbaa !8
  %shl34 = shl i64 %36, 24
  %37 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %bwt_idx = getelementptr inbounds %struct.encoder_state, ptr %37, i32 0, i32 4
  %38 = load i32, ptr %bwt_idx, align 4, !tbaa !30
  %conv35 = zext i32 %38 to i64
  %or36 = or i64 %shl34, %conv35
  store i64 %or36, ptr %b, align 8, !tbaa !8
  %39 = load i32, ptr %k, align 4, !tbaa !14
  %add37 = add i32 %39, 24
  store i32 %add37, ptr %k, align 4, !tbaa !14
  %40 = load i32, ptr %k, align 4, !tbaa !14
  %sub38 = sub i32 %40, 32
  store i32 %sub38, ptr %k, align 4, !tbaa !14
  %41 = load i64, ptr %b, align 8, !tbaa !8
  %42 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom39 = zext i32 %42 to i64
  %shr40 = lshr i64 %41, %sh_prom39
  %conv41 = trunc i64 %shr40 to i32
  %call42 = call fastcc i32 @__bswap_32(i32 noundef %conv41)
  %43 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr43 = getelementptr inbounds i32, ptr %43, i32 1
  store ptr %incdec.ptr43, ptr %p, align 8, !tbaa !12
  store i32 %call42, ptr %43, align 4, !tbaa !14
  %44 = load i32, ptr %k, align 4, !tbaa !14
  %cmp44 = icmp eq i32 %44, 9
  br i1 %cmp44, label %if.then46, label %if.else47

if.then46:                                        ; preds = %if.end13
  br label %if.end48

if.else47:                                        ; preds = %if.end13
  call void @__assert_fail(ptr noundef @.str.21, ptr noundef @.str.1, i32 noundef 1190, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end48:                                         ; preds = %if.then46
  call void @llvm.lifetime.start.p0(i64 64, ptr %pack) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %pk) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %j) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %big) #12
  store i32 0, ptr %big, align 4, !tbaa !14
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc69, %if.end48
  %45 = load i32, ptr %i, align 4, !tbaa !14
  %cmp49 = icmp ult i32 %45, 16
  br i1 %cmp49, label %for.body, label %for.end71

for.body:                                         ; preds = %for.cond
  store i32 0, ptr %pk, align 4, !tbaa !14
  store i32 0, ptr %j, align 4, !tbaa !14
  br label %for.cond51

for.cond51:                                       ; preds = %for.inc, %for.body
  %46 = load i32, ptr %j, align 4, !tbaa !14
  %cmp52 = icmp ult i32 %46, 16
  br i1 %cmp52, label %for.body54, label %for.end

for.body54:                                       ; preds = %for.cond51
  %47 = load i32, ptr %pk, align 4, !tbaa !14
  %shl55 = shl i32 %47, 1
  %48 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %cmap = getelementptr inbounds %struct.encoder_state, ptr %48, i32 0, i32 0
  %49 = load i32, ptr %i, align 4, !tbaa !14
  %mul56 = mul i32 16, %49
  %50 = load i32, ptr %j, align 4, !tbaa !14
  %add57 = add i32 %mul56, %50
  %idxprom58 = zext i32 %add57 to i64
  %arrayidx59 = getelementptr inbounds [256 x i8], ptr %cmap, i64 0, i64 %idxprom58
  %51 = load i8, ptr %arrayidx59, align 1, !tbaa !24, !range !34, !noundef !35
  %tobool60 = trunc i8 %51 to i1
  %conv61 = zext i1 %tobool60 to i32
  %add62 = add nuw i32 %shl55, %conv61
  store i32 %add62, ptr %pk, align 4, !tbaa !14
  br label %for.inc

for.inc:                                          ; preds = %for.body54
  %52 = load i32, ptr %j, align 4, !tbaa !14
  %inc = add i32 %52, 1
  store i32 %inc, ptr %j, align 4, !tbaa !14
  br label %for.cond51, !llvm.loop !74

for.end:                                          ; preds = %for.cond51
  %53 = load i32, ptr %pk, align 4, !tbaa !14
  %54 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom63 = zext i32 %54 to i64
  %arrayidx64 = getelementptr inbounds [16 x i32], ptr %pack, i64 0, i64 %idxprom63
  store i32 %53, ptr %arrayidx64, align 4, !tbaa !14
  %55 = load i32, ptr %big, align 4, !tbaa !14
  %shl65 = shl i32 %55, 1
  %56 = load i32, ptr %pk, align 4, !tbaa !14
  %tobool66 = icmp ne i32 %56, 0
  %lnot = xor i1 %tobool66, true
  %lnot67 = xor i1 %lnot, true
  %lnot.ext = zext i1 %lnot67 to i32
  %add68 = add nuw i32 %shl65, %lnot.ext
  store i32 %add68, ptr %big, align 4, !tbaa !14
  br label %for.inc69

for.inc69:                                        ; preds = %for.end
  %57 = load i32, ptr %i, align 4, !tbaa !14
  %inc70 = add i32 %57, 1
  store i32 %inc70, ptr %i, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !75

for.end71:                                        ; preds = %for.cond
  %58 = load i64, ptr %b, align 8, !tbaa !8
  %shl72 = shl i64 %58, 16
  %59 = load i32, ptr %big, align 4, !tbaa !14
  %conv73 = zext i32 %59 to i64
  %or74 = or i64 %shl72, %conv73
  store i64 %or74, ptr %b, align 8, !tbaa !8
  %60 = load i32, ptr %k, align 4, !tbaa !14
  %add75 = add i32 %60, 16
  store i32 %add75, ptr %k, align 4, !tbaa !14
  store i32 0, ptr %i, align 4, !tbaa !14
  br label %for.cond76

for.cond76:                                       ; preds = %for.inc101, %for.end71
  %61 = load i32, ptr %i, align 4, !tbaa !14
  %cmp77 = icmp ult i32 %61, 16
  br i1 %cmp77, label %for.body79, label %for.end103

for.body79:                                       ; preds = %for.cond76
  %62 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom80 = zext i32 %62 to i64
  %arrayidx81 = getelementptr inbounds [16 x i32], ptr %pack, i64 0, i64 %idxprom80
  %63 = load i32, ptr %arrayidx81, align 4, !tbaa !14
  %tobool82 = icmp ne i32 %63, 0
  br i1 %tobool82, label %if.then83, label %if.end100

if.then83:                                        ; preds = %for.body79
  %64 = load i64, ptr %b, align 8, !tbaa !8
  %shl84 = shl i64 %64, 16
  %65 = load i32, ptr %i, align 4, !tbaa !14
  %idxprom85 = zext i32 %65 to i64
  %arrayidx86 = getelementptr inbounds [16 x i32], ptr %pack, i64 0, i64 %idxprom85
  %66 = load i32, ptr %arrayidx86, align 4, !tbaa !14
  %conv87 = zext i32 %66 to i64
  %or88 = or i64 %shl84, %conv87
  store i64 %or88, ptr %b, align 8, !tbaa !8
  %67 = load i32, ptr %k, align 4, !tbaa !14
  %add89 = add i32 %67, 16
  store i32 %add89, ptr %k, align 4, !tbaa !14
  %68 = load i32, ptr %k, align 4, !tbaa !14
  %cmp90 = icmp uge i32 %68, 32
  br i1 %cmp90, label %if.then92, label %if.end99

if.then92:                                        ; preds = %if.then83
  %69 = load i32, ptr %k, align 4, !tbaa !14
  %sub93 = sub i32 %69, 32
  store i32 %sub93, ptr %k, align 4, !tbaa !14
  %70 = load i64, ptr %b, align 8, !tbaa !8
  %71 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom94 = zext i32 %71 to i64
  %shr95 = lshr i64 %70, %sh_prom94
  %conv96 = trunc i64 %shr95 to i32
  %call97 = call fastcc i32 @__bswap_32(i32 noundef %conv96)
  %72 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr98 = getelementptr inbounds i32, ptr %72, i32 1
  store ptr %incdec.ptr98, ptr %p, align 8, !tbaa !12
  store i32 %call97, ptr %72, align 4, !tbaa !14
  br label %if.end99

if.end99:                                         ; preds = %if.then92, %if.then83
  br label %if.end100

if.end100:                                        ; preds = %if.end99, %for.body79
  br label %for.inc101

for.inc101:                                       ; preds = %if.end100
  %73 = load i32, ptr %i, align 4, !tbaa !14
  %inc102 = add i32 %73, 1
  store i32 %inc102, ptr %i, align 4, !tbaa !14
  br label %for.cond76, !llvm.loop !76

for.end103:                                       ; preds = %for.cond76
  call void @llvm.lifetime.end.p0(i64 4, ptr %big) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %j) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %pk) #12
  call void @llvm.lifetime.end.p0(i64 64, ptr %pack) #12
  %74 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u = getelementptr inbounds %struct.encoder_state, ptr %74, i32 0, i32 11
  %num_trees = getelementptr inbounds %struct.anon, ptr %u, i32 0, i32 3
  %75 = load i32, ptr %num_trees, align 4, !tbaa !23
  %cmp104 = icmp uge i32 %75, 2
  br i1 %cmp104, label %land.lhs.true, label %if.else111

land.lhs.true:                                    ; preds = %for.end103
  %76 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u106 = getelementptr inbounds %struct.encoder_state, ptr %76, i32 0, i32 11
  %num_trees107 = getelementptr inbounds %struct.anon, ptr %u106, i32 0, i32 3
  %77 = load i32, ptr %num_trees107, align 4, !tbaa !23
  %cmp108 = icmp ule i32 %77, 6
  br i1 %cmp108, label %if.then110, label %if.else111

if.then110:                                       ; preds = %land.lhs.true
  br label %if.end112

if.else111:                                       ; preds = %land.lhs.true, %for.end103
  call void @__assert_fail(ptr noundef @.str.22, ptr noundef @.str.1, i32 noundef 1216, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end112:                                        ; preds = %if.then110
  %78 = load i64, ptr %b, align 8, !tbaa !8
  %shl113 = shl i64 %78, 3
  %79 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u114 = getelementptr inbounds %struct.encoder_state, ptr %79, i32 0, i32 11
  %num_trees115 = getelementptr inbounds %struct.anon, ptr %u114, i32 0, i32 3
  %80 = load i32, ptr %num_trees115, align 4, !tbaa !23
  %conv116 = zext i32 %80 to i64
  %or117 = or i64 %shl113, %conv116
  store i64 %or117, ptr %b, align 8, !tbaa !8
  %81 = load i32, ptr %k, align 4, !tbaa !14
  %add118 = add i32 %81, 3
  store i32 %add118, ptr %k, align 4, !tbaa !14
  %82 = load i32, ptr %k, align 4, !tbaa !14
  %cmp119 = icmp eq i32 %82, 12
  br i1 %cmp119, label %if.then123, label %lor.lhs.false

lor.lhs.false:                                    ; preds = %if.end112
  %83 = load i32, ptr %k, align 4, !tbaa !14
  %cmp121 = icmp eq i32 %83, 28
  br i1 %cmp121, label %if.then123, label %if.else124

if.then123:                                       ; preds = %lor.lhs.false, %if.end112
  br label %if.end125

if.else124:                                       ; preds = %lor.lhs.false
  call void @__assert_fail(ptr noundef @.str.23, ptr noundef @.str.1, i32 noundef 1218, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end125:                                        ; preds = %if.then123
  %84 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u126 = getelementptr inbounds %struct.encoder_state, ptr %84, i32 0, i32 11
  %num_selectors = getelementptr inbounds %struct.anon, ptr %u126, i32 0, i32 2
  %85 = load i32, ptr %num_selectors, align 4, !tbaa !23
  store i32 %85, ptr %t, align 4, !tbaa !14
  %86 = load i64, ptr %b, align 8, !tbaa !8
  %shl127 = shl i64 %86, 15
  %87 = load i32, ptr %t, align 4, !tbaa !14
  %conv128 = zext i32 %87 to i64
  %or129 = or i64 %shl127, %conv128
  store i64 %or129, ptr %b, align 8, !tbaa !8
  %88 = load i32, ptr %k, align 4, !tbaa !14
  %add130 = add i32 %88, 15
  store i32 %add130, ptr %k, align 4, !tbaa !14
  %89 = load i32, ptr %k, align 4, !tbaa !14
  %cmp131 = icmp uge i32 %89, 32
  br i1 %cmp131, label %if.then133, label %if.end140

if.then133:                                       ; preds = %if.end125
  %90 = load i32, ptr %k, align 4, !tbaa !14
  %sub134 = sub i32 %90, 32
  store i32 %sub134, ptr %k, align 4, !tbaa !14
  %91 = load i64, ptr %b, align 8, !tbaa !8
  %92 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom135 = zext i32 %92 to i64
  %shr136 = lshr i64 %91, %sh_prom135
  %conv137 = trunc i64 %shr136 to i32
  %call138 = call fastcc i32 @__bswap_32(i32 noundef %conv137)
  %93 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr139 = getelementptr inbounds i32, ptr %93, i32 1
  store ptr %incdec.ptr139, ptr %p, align 8, !tbaa !12
  store i32 %call138, ptr %93, align 4, !tbaa !14
  br label %if.end140

if.end140:                                        ; preds = %if.then133, %if.end125
  %94 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u141 = getelementptr inbounds %struct.encoder_state, ptr %94, i32 0, i32 11
  %selectorMTF = getelementptr inbounds %struct.anon, ptr %u141, i32 0, i32 1
  %arraydecay142 = getelementptr inbounds [18008 x i8], ptr %selectorMTF, i64 0, i64 0
  store ptr %arraydecay142, ptr %sp, align 8, !tbaa !12
  br label %while.cond

while.cond:                                       ; preds = %if.end163, %if.end140
  %95 = load i32, ptr %t, align 4, !tbaa !14
  %dec = add i32 %95, -1
  store i32 %dec, ptr %t, align 4, !tbaa !14
  %tobool143 = icmp ne i32 %95, 0
  br i1 %tobool143, label %while.body, label %while.end

while.body:                                       ; preds = %while.cond
  %96 = load ptr, ptr %sp, align 8, !tbaa !12
  %incdec.ptr144 = getelementptr inbounds i8, ptr %96, i32 1
  store ptr %incdec.ptr144, ptr %sp, align 8, !tbaa !12
  %97 = load i8, ptr %96, align 1, !tbaa !23
  %conv145 = zext i8 %97 to i32
  %add146 = add nuw nsw i32 1, %conv145
  store i32 %add146, ptr %v, align 4, !tbaa !14
  %98 = load i64, ptr %b, align 8, !tbaa !8
  %99 = load i32, ptr %v, align 4, !tbaa !14
  %sh_prom147 = zext i32 %99 to i64
  %shl148 = shl i64 %98, %sh_prom147
  %100 = load i32, ptr %v, align 4, !tbaa !14
  %shl149 = shl nuw i32 1, %100
  %sub150 = sub nsw i32 %shl149, 2
  %conv151 = sext i32 %sub150 to i64
  %or152 = or i64 %shl148, %conv151
  store i64 %or152, ptr %b, align 8, !tbaa !8
  %101 = load i32, ptr %v, align 4, !tbaa !14
  %102 = load i32, ptr %k, align 4, !tbaa !14
  %add153 = add i32 %102, %101
  store i32 %add153, ptr %k, align 4, !tbaa !14
  %103 = load i32, ptr %k, align 4, !tbaa !14
  %cmp154 = icmp uge i32 %103, 32
  br i1 %cmp154, label %if.then156, label %if.end163

if.then156:                                       ; preds = %while.body
  %104 = load i32, ptr %k, align 4, !tbaa !14
  %sub157 = sub i32 %104, 32
  store i32 %sub157, ptr %k, align 4, !tbaa !14
  %105 = load i64, ptr %b, align 8, !tbaa !8
  %106 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom158 = zext i32 %106 to i64
  %shr159 = lshr i64 %105, %sh_prom158
  %conv160 = trunc i64 %shr159 to i32
  %call161 = call fastcc i32 @__bswap_32(i32 noundef %conv160)
  %107 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr162 = getelementptr inbounds i32, ptr %107, i32 1
  store ptr %incdec.ptr162, ptr %p, align 8, !tbaa !12
  store i32 %call161, ptr %107, align 4, !tbaa !14
  br label %if.end163

if.end163:                                        ; preds = %if.then156, %while.body
  br label %while.cond, !llvm.loop !77

while.end:                                        ; preds = %while.cond
  store i32 0, ptr %t, align 4, !tbaa !14
  br label %for.cond164

for.cond164:                                      ; preds = %for.inc268, %while.end
  %108 = load i32, ptr %t, align 4, !tbaa !14
  %109 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u165 = getelementptr inbounds %struct.encoder_state, ptr %109, i32 0, i32 11
  %num_trees166 = getelementptr inbounds %struct.anon, ptr %u165, i32 0, i32 3
  %110 = load i32, ptr %num_trees166, align 4, !tbaa !23
  %cmp167 = icmp ult i32 %108, %110
  br i1 %cmp167, label %for.body169, label %for.end270

for.body169:                                      ; preds = %for.cond164
  call void @llvm.lifetime.start.p0(i64 4, ptr %a) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %c) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %len) #12
  %111 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u170 = getelementptr inbounds %struct.encoder_state, ptr %111, i32 0, i32 11
  %length = getelementptr inbounds %struct.anon, ptr %u170, i32 0, i32 5
  %112 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u171 = getelementptr inbounds %struct.encoder_state, ptr %112, i32 0, i32 11
  %tmap_new2old = getelementptr inbounds %struct.anon, ptr %u171, i32 0, i32 9
  %113 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom172 = zext i32 %113 to i64
  %arrayidx173 = getelementptr inbounds [6 x i32], ptr %tmap_new2old, i64 0, i64 %idxprom172
  %114 = load i32, ptr %arrayidx173, align 4, !tbaa !23
  %idxprom174 = zext i32 %114 to i64
  %arrayidx175 = getelementptr inbounds [6 x [259 x i8]], ptr %length, i64 0, i64 %idxprom174
  %arraydecay176 = getelementptr inbounds [259 x i8], ptr %arrayidx175, i64 0, i64 0
  store ptr %arraydecay176, ptr %len, align 8, !tbaa !12
  %115 = load ptr, ptr %len, align 8, !tbaa !12
  %arrayidx177 = getelementptr inbounds i8, ptr %115, i64 0
  %116 = load i8, ptr %arrayidx177, align 1, !tbaa !23
  %conv178 = zext i8 %116 to i32
  store i32 %conv178, ptr %a, align 4, !tbaa !14
  %117 = load i32, ptr %t, align 4, !tbaa !14
  %cmp179 = icmp eq i32 %117, 0
  br i1 %cmp179, label %if.then181, label %if.end192

if.then181:                                       ; preds = %for.body169
  %118 = load i32, ptr %a, align 4, !tbaa !14
  %cmp182 = icmp slt i32 %118, 4
  br i1 %cmp182, label %if.then184, label %if.else187

if.then184:                                       ; preds = %if.then181
  %119 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u185 = getelementptr inbounds %struct.encoder_state, ptr %119, i32 0, i32 11
  %tree_pad = getelementptr inbounds %struct.anon, ptr %u185, i32 0, i32 4
  %120 = load i32, ptr %tree_pad, align 4, !tbaa !23
  %121 = load i32, ptr %a, align 4, !tbaa !14
  %add186 = add i32 %121, %120
  store i32 %add186, ptr %a, align 4, !tbaa !14
  br label %if.end191

if.else187:                                       ; preds = %if.then181
  %122 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u188 = getelementptr inbounds %struct.encoder_state, ptr %122, i32 0, i32 11
  %tree_pad189 = getelementptr inbounds %struct.anon, ptr %u188, i32 0, i32 4
  %123 = load i32, ptr %tree_pad189, align 4, !tbaa !23
  %124 = load i32, ptr %a, align 4, !tbaa !14
  %sub190 = sub i32 %124, %123
  store i32 %sub190, ptr %a, align 4, !tbaa !14
  br label %if.end191

if.end191:                                        ; preds = %if.else187, %if.then184
  br label %if.end192

if.end192:                                        ; preds = %if.end191, %for.body169
  %125 = load i64, ptr %b, align 8, !tbaa !8
  %shl193 = shl i64 %125, 5
  %126 = load i32, ptr %a, align 4, !tbaa !14
  %conv194 = sext i32 %126 to i64
  %or195 = or i64 %shl193, %conv194
  store i64 %or195, ptr %b, align 8, !tbaa !8
  %127 = load i32, ptr %k, align 4, !tbaa !14
  %add196 = add i32 %127, 5
  store i32 %add196, ptr %k, align 4, !tbaa !14
  %128 = load i32, ptr %k, align 4, !tbaa !14
  %cmp197 = icmp uge i32 %128, 32
  br i1 %cmp197, label %if.then199, label %if.end206

if.then199:                                       ; preds = %if.end192
  %129 = load i32, ptr %k, align 4, !tbaa !14
  %sub200 = sub i32 %129, 32
  store i32 %sub200, ptr %k, align 4, !tbaa !14
  %130 = load i64, ptr %b, align 8, !tbaa !8
  %131 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom201 = zext i32 %131 to i64
  %shr202 = lshr i64 %130, %sh_prom201
  %conv203 = trunc i64 %shr202 to i32
  %call204 = call fastcc i32 @__bswap_32(i32 noundef %conv203)
  %132 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr205 = getelementptr inbounds i32, ptr %132, i32 1
  store ptr %incdec.ptr205, ptr %p, align 8, !tbaa !12
  store i32 %call204, ptr %132, align 4, !tbaa !14
  br label %if.end206

if.end206:                                        ; preds = %if.then199, %if.end192
  store i32 0, ptr %v, align 4, !tbaa !14
  br label %for.cond207

for.cond207:                                      ; preds = %for.inc265, %if.end206
  %133 = load i32, ptr %v, align 4, !tbaa !14
  %134 = load i32, ptr %as, align 4, !tbaa !14
  %cmp208 = icmp ult i32 %133, %134
  br i1 %cmp208, label %for.body210, label %for.end267

for.body210:                                      ; preds = %for.cond207
  %135 = load ptr, ptr %len, align 8, !tbaa !12
  %136 = load i32, ptr %v, align 4, !tbaa !14
  %idxprom211 = zext i32 %136 to i64
  %arrayidx212 = getelementptr inbounds i8, ptr %135, i64 %idxprom211
  %137 = load i8, ptr %arrayidx212, align 1, !tbaa !23
  %conv213 = zext i8 %137 to i32
  store i32 %conv213, ptr %c, align 4, !tbaa !14
  br label %while.cond214

while.cond214:                                    ; preds = %if.end230, %for.body210
  %138 = load i32, ptr %a, align 4, !tbaa !14
  %139 = load i32, ptr %c, align 4, !tbaa !14
  %cmp215 = icmp slt i32 %138, %139
  br i1 %cmp215, label %while.body217, label %while.end232

while.body217:                                    ; preds = %while.cond214
  %140 = load i64, ptr %b, align 8, !tbaa !8
  %shl218 = shl i64 %140, 2
  %or219 = or i64 %shl218, 2
  store i64 %or219, ptr %b, align 8, !tbaa !8
  %141 = load i32, ptr %k, align 4, !tbaa !14
  %add220 = add i32 %141, 2
  store i32 %add220, ptr %k, align 4, !tbaa !14
  %142 = load i32, ptr %k, align 4, !tbaa !14
  %cmp221 = icmp uge i32 %142, 32
  br i1 %cmp221, label %if.then223, label %if.end230

if.then223:                                       ; preds = %while.body217
  %143 = load i32, ptr %k, align 4, !tbaa !14
  %sub224 = sub i32 %143, 32
  store i32 %sub224, ptr %k, align 4, !tbaa !14
  %144 = load i64, ptr %b, align 8, !tbaa !8
  %145 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom225 = zext i32 %145 to i64
  %shr226 = lshr i64 %144, %sh_prom225
  %conv227 = trunc i64 %shr226 to i32
  %call228 = call fastcc i32 @__bswap_32(i32 noundef %conv227)
  %146 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr229 = getelementptr inbounds i32, ptr %146, i32 1
  store ptr %incdec.ptr229, ptr %p, align 8, !tbaa !12
  store i32 %call228, ptr %146, align 4, !tbaa !14
  br label %if.end230

if.end230:                                        ; preds = %if.then223, %while.body217
  %147 = load i32, ptr %a, align 4, !tbaa !14
  %inc231 = add nsw i32 %147, 1
  store i32 %inc231, ptr %a, align 4, !tbaa !14
  br label %while.cond214, !llvm.loop !78

while.end232:                                     ; preds = %while.cond214
  br label %while.cond233

while.cond233:                                    ; preds = %if.end249, %while.end232
  %148 = load i32, ptr %a, align 4, !tbaa !14
  %149 = load i32, ptr %c, align 4, !tbaa !14
  %cmp234 = icmp sgt i32 %148, %149
  br i1 %cmp234, label %while.body236, label %while.end251

while.body236:                                    ; preds = %while.cond233
  %150 = load i64, ptr %b, align 8, !tbaa !8
  %shl237 = shl i64 %150, 2
  %or238 = or i64 %shl237, 3
  store i64 %or238, ptr %b, align 8, !tbaa !8
  %151 = load i32, ptr %k, align 4, !tbaa !14
  %add239 = add i32 %151, 2
  store i32 %add239, ptr %k, align 4, !tbaa !14
  %152 = load i32, ptr %k, align 4, !tbaa !14
  %cmp240 = icmp uge i32 %152, 32
  br i1 %cmp240, label %if.then242, label %if.end249

if.then242:                                       ; preds = %while.body236
  %153 = load i32, ptr %k, align 4, !tbaa !14
  %sub243 = sub i32 %153, 32
  store i32 %sub243, ptr %k, align 4, !tbaa !14
  %154 = load i64, ptr %b, align 8, !tbaa !8
  %155 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom244 = zext i32 %155 to i64
  %shr245 = lshr i64 %154, %sh_prom244
  %conv246 = trunc i64 %shr245 to i32
  %call247 = call fastcc i32 @__bswap_32(i32 noundef %conv246)
  %156 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr248 = getelementptr inbounds i32, ptr %156, i32 1
  store ptr %incdec.ptr248, ptr %p, align 8, !tbaa !12
  store i32 %call247, ptr %156, align 4, !tbaa !14
  br label %if.end249

if.end249:                                        ; preds = %if.then242, %while.body236
  %157 = load i32, ptr %a, align 4, !tbaa !14
  %dec250 = add nsw i32 %157, -1
  store i32 %dec250, ptr %a, align 4, !tbaa !14
  br label %while.cond233, !llvm.loop !79

while.end251:                                     ; preds = %while.cond233
  %158 = load i64, ptr %b, align 8, !tbaa !8
  %shl252 = shl i64 %158, 1
  %or253 = or i64 %shl252, 0
  store i64 %or253, ptr %b, align 8, !tbaa !8
  %159 = load i32, ptr %k, align 4, !tbaa !14
  %add254 = add i32 %159, 1
  store i32 %add254, ptr %k, align 4, !tbaa !14
  %160 = load i32, ptr %k, align 4, !tbaa !14
  %cmp255 = icmp uge i32 %160, 32
  br i1 %cmp255, label %if.then257, label %if.end264

if.then257:                                       ; preds = %while.end251
  %161 = load i32, ptr %k, align 4, !tbaa !14
  %sub258 = sub i32 %161, 32
  store i32 %sub258, ptr %k, align 4, !tbaa !14
  %162 = load i64, ptr %b, align 8, !tbaa !8
  %163 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom259 = zext i32 %163 to i64
  %shr260 = lshr i64 %162, %sh_prom259
  %conv261 = trunc i64 %shr260 to i32
  %call262 = call fastcc i32 @__bswap_32(i32 noundef %conv261)
  %164 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr263 = getelementptr inbounds i32, ptr %164, i32 1
  store ptr %incdec.ptr263, ptr %p, align 8, !tbaa !12
  store i32 %call262, ptr %164, align 4, !tbaa !14
  br label %if.end264

if.end264:                                        ; preds = %if.then257, %while.end251
  br label %for.inc265

for.inc265:                                       ; preds = %if.end264
  %165 = load i32, ptr %v, align 4, !tbaa !14
  %inc266 = add i32 %165, 1
  store i32 %inc266, ptr %v, align 4, !tbaa !14
  br label %for.cond207, !llvm.loop !80

for.end267:                                       ; preds = %for.cond207
  call void @llvm.lifetime.end.p0(i64 8, ptr %len) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %c) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %a) #12
  br label %for.inc268

for.inc268:                                       ; preds = %for.end267
  %166 = load i32, ptr %t, align 4, !tbaa !14
  %inc269 = add i32 %166, 1
  store i32 %inc269, ptr %t, align 4, !tbaa !14
  br label %for.cond164, !llvm.loop !81

for.end270:                                       ; preds = %for.cond164
  store i32 0, ptr %gr, align 4, !tbaa !14
  br label %for.cond271

for.cond271:                                      ; preds = %for.inc321, %for.end270
  %167 = load i32, ptr %gr, align 4, !tbaa !14
  %168 = load i32, ptr %ns, align 4, !tbaa !14
  %cmp272 = icmp ult i32 %167, %168
  br i1 %cmp272, label %for.body274, label %for.end323

for.body274:                                      ; preds = %for.cond271
  call void @llvm.lifetime.start.p0(i64 4, ptr %i275) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %L) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %B) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %mv) #12
  %169 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u276 = getelementptr inbounds %struct.encoder_state, ptr %169, i32 0, i32 11
  %selector = getelementptr inbounds %struct.anon, ptr %u276, i32 0, i32 0
  %170 = load i32, ptr %gr, align 4, !tbaa !14
  %idxprom277 = zext i32 %170 to i64
  %arrayidx278 = getelementptr inbounds [18002 x i8], ptr %selector, i64 0, i64 %idxprom277
  %171 = load i8, ptr %arrayidx278, align 1, !tbaa !23
  %conv279 = zext i8 %171 to i32
  store i32 %conv279, ptr %t, align 4, !tbaa !14
  %172 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u280 = getelementptr inbounds %struct.encoder_state, ptr %172, i32 0, i32 11
  %code = getelementptr inbounds %struct.anon, ptr %u280, i32 0, i32 6
  %173 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom281 = zext i32 %173 to i64
  %arrayidx282 = getelementptr inbounds [6 x [259 x i32]], ptr %code, i64 0, i64 %idxprom281
  %arraydecay283 = getelementptr inbounds [259 x i32], ptr %arrayidx282, i64 0, i64 0
  store ptr %arraydecay283, ptr %L, align 8, !tbaa !12
  %174 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %u284 = getelementptr inbounds %struct.encoder_state, ptr %174, i32 0, i32 11
  %length285 = getelementptr inbounds %struct.anon, ptr %u284, i32 0, i32 5
  %175 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom286 = zext i32 %175 to i64
  %arrayidx287 = getelementptr inbounds [6 x [259 x i8]], ptr %length285, i64 0, i64 %idxprom286
  %arraydecay288 = getelementptr inbounds [259 x i8], ptr %arrayidx287, i64 0, i64 0
  store ptr %arraydecay288, ptr %B, align 8, !tbaa !12
  store i32 0, ptr %i275, align 4, !tbaa !14
  br label %for.cond289

for.cond289:                                      ; preds = %for.inc318, %for.body274
  %176 = load i32, ptr %i275, align 4, !tbaa !14
  %cmp290 = icmp ult i32 %176, 50
  br i1 %cmp290, label %for.body292, label %for.end320

for.body292:                                      ; preds = %for.cond289
  %177 = load ptr, ptr %mtfv, align 8, !tbaa !12
  %incdec.ptr293 = getelementptr inbounds i16, ptr %177, i32 1
  store ptr %incdec.ptr293, ptr %mtfv, align 8, !tbaa !12
  %178 = load i16, ptr %177, align 2, !tbaa !42
  %conv294 = zext i16 %178 to i32
  store i32 %conv294, ptr %mv, align 4, !tbaa !14
  %179 = load i64, ptr %b, align 8, !tbaa !8
  %180 = load ptr, ptr %B, align 8, !tbaa !12
  %181 = load i32, ptr %mv, align 4, !tbaa !14
  %idxprom295 = zext i32 %181 to i64
  %arrayidx296 = getelementptr inbounds i8, ptr %180, i64 %idxprom295
  %182 = load i8, ptr %arrayidx296, align 1, !tbaa !23
  %conv297 = zext i8 %182 to i32
  %sh_prom298 = zext nneg i32 %conv297 to i64
  %shl299 = shl i64 %179, %sh_prom298
  %183 = load ptr, ptr %L, align 8, !tbaa !12
  %184 = load i32, ptr %mv, align 4, !tbaa !14
  %idxprom300 = zext i32 %184 to i64
  %arrayidx301 = getelementptr inbounds i32, ptr %183, i64 %idxprom300
  %185 = load i32, ptr %arrayidx301, align 4, !tbaa !14
  %conv302 = zext i32 %185 to i64
  %or303 = or i64 %shl299, %conv302
  store i64 %or303, ptr %b, align 8, !tbaa !8
  %186 = load ptr, ptr %B, align 8, !tbaa !12
  %187 = load i32, ptr %mv, align 4, !tbaa !14
  %idxprom304 = zext i32 %187 to i64
  %arrayidx305 = getelementptr inbounds i8, ptr %186, i64 %idxprom304
  %188 = load i8, ptr %arrayidx305, align 1, !tbaa !23
  %conv306 = zext i8 %188 to i32
  %189 = load i32, ptr %k, align 4, !tbaa !14
  %add307 = add i32 %189, %conv306
  store i32 %add307, ptr %k, align 4, !tbaa !14
  %190 = load i32, ptr %k, align 4, !tbaa !14
  %cmp308 = icmp uge i32 %190, 32
  br i1 %cmp308, label %if.then310, label %if.end317

if.then310:                                       ; preds = %for.body292
  %191 = load i32, ptr %k, align 4, !tbaa !14
  %sub311 = sub i32 %191, 32
  store i32 %sub311, ptr %k, align 4, !tbaa !14
  %192 = load i64, ptr %b, align 8, !tbaa !8
  %193 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom312 = zext i32 %193 to i64
  %shr313 = lshr i64 %192, %sh_prom312
  %conv314 = trunc i64 %shr313 to i32
  %call315 = call fastcc i32 @__bswap_32(i32 noundef %conv314)
  %194 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr316 = getelementptr inbounds i32, ptr %194, i32 1
  store ptr %incdec.ptr316, ptr %p, align 8, !tbaa !12
  store i32 %call315, ptr %194, align 4, !tbaa !14
  br label %if.end317

if.end317:                                        ; preds = %if.then310, %for.body292
  br label %for.inc318

for.inc318:                                       ; preds = %if.end317
  %195 = load i32, ptr %i275, align 4, !tbaa !14
  %inc319 = add i32 %195, 1
  store i32 %inc319, ptr %i275, align 4, !tbaa !14
  br label %for.cond289, !llvm.loop !82

for.end320:                                       ; preds = %for.cond289
  call void @llvm.lifetime.end.p0(i64 4, ptr %mv) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %B) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %L) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %i275) #12
  br label %for.inc321

for.inc321:                                       ; preds = %for.end320
  %196 = load i32, ptr %gr, align 4, !tbaa !14
  %inc322 = add i32 %196, 1
  store i32 %inc322, ptr %gr, align 4, !tbaa !14
  br label %for.cond271, !llvm.loop !83

for.end323:                                       ; preds = %for.cond271
  %197 = load i32, ptr %k, align 4, !tbaa !14
  %rem = urem i32 %197, 8
  %cmp324 = icmp eq i32 %rem, 0
  br i1 %cmp324, label %if.then326, label %if.else327

if.then326:                                       ; preds = %for.end323
  br label %if.end328

if.else327:                                       ; preds = %for.end323
  call void @__assert_fail(ptr noundef @.str.24, ptr noundef @.str.1, i32 noundef 1272, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end328:                                        ; preds = %if.then326
  %198 = load i32, ptr %k, align 4, !tbaa !14
  %div329 = udiv i32 %198, 8
  %199 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %out_expect_len330 = getelementptr inbounds %struct.encoder_state, ptr %199, i32 0, i32 5
  %200 = load i32, ptr %out_expect_len330, align 4, !tbaa !38
  %rem331 = urem i32 %200, 4
  %cmp332 = icmp eq i32 %div329, %rem331
  br i1 %cmp332, label %if.then334, label %if.else335

if.then334:                                       ; preds = %if.end328
  br label %if.end336

if.else335:                                       ; preds = %if.end328
  call void @__assert_fail(ptr noundef @.str.25, ptr noundef @.str.1, i32 noundef 1273, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end336:                                        ; preds = %if.then334
  %201 = load ptr, ptr %p, align 8, !tbaa !12
  %202 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  %203 = load ptr, ptr %s.addr, align 8, !tbaa !12
  %out_expect_len337 = getelementptr inbounds %struct.encoder_state, ptr %203, i32 0, i32 5
  %204 = load i32, ptr %out_expect_len337, align 4, !tbaa !38
  %div338 = udiv i32 %204, 4
  %idx.ext339 = zext nneg i32 %div338 to i64
  %add.ptr340 = getelementptr inbounds i32, ptr %202, i64 %idx.ext339
  %cmp341 = icmp eq ptr %201, %add.ptr340
  br i1 %cmp341, label %if.then343, label %if.else344

if.then343:                                       ; preds = %if.end336
  br label %if.end345

if.else344:                                       ; preds = %if.end336
  call void @__assert_fail(ptr noundef @.str.26, ptr noundef @.str.1, i32 noundef 1274, ptr noundef @__PRETTY_FUNCTION__.transmit) #11
  unreachable

if.end345:                                        ; preds = %if.then343
  %205 = load i64, ptr %b, align 8, !tbaa !8
  %shl346 = shl i64 %205, 31
  %or347 = or i64 %shl346, 0
  store i64 %or347, ptr %b, align 8, !tbaa !8
  %206 = load i32, ptr %k, align 4, !tbaa !14
  %add348 = add i32 %206, 31
  store i32 %add348, ptr %k, align 4, !tbaa !14
  %207 = load i32, ptr %k, align 4, !tbaa !14
  %cmp349 = icmp uge i32 %207, 32
  br i1 %cmp349, label %if.then351, label %if.end358

if.then351:                                       ; preds = %if.end345
  %208 = load i32, ptr %k, align 4, !tbaa !14
  %sub352 = sub i32 %208, 32
  store i32 %sub352, ptr %k, align 4, !tbaa !14
  %209 = load i64, ptr %b, align 8, !tbaa !8
  %210 = load i32, ptr %k, align 4, !tbaa !14
  %sh_prom353 = zext i32 %210 to i64
  %shr354 = lshr i64 %209, %sh_prom353
  %conv355 = trunc i64 %shr354 to i32
  %call356 = call fastcc i32 @__bswap_32(i32 noundef %conv355)
  %211 = load ptr, ptr %p, align 8, !tbaa !12
  %incdec.ptr357 = getelementptr inbounds i32, ptr %211, i32 1
  store ptr %incdec.ptr357, ptr %p, align 8, !tbaa !12
  store i32 %call356, ptr %211, align 4, !tbaa !14
  br label %if.end358

if.end358:                                        ; preds = %if.then351, %if.end345
  %212 = load ptr, ptr %buf.addr, align 8, !tbaa !12
  call void @llvm.lifetime.end.p0(i64 4, ptr %gr) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %as) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %ns) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %p) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %mtfv) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %v) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %sp) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %k) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %b) #12
  ret ptr %212
}

; Function Attrs: inlinehint mustprogress nofree norecurse nosync nounwind sspstrong willreturn memory(none) uwtable
define internal fastcc noundef i32 @__bswap_32(i32 noundef %__bsx) unnamed_addr #7 {
entry:
  %or7 = tail call i32 @llvm.bswap.i32(i32 %__bsx)
  ret i32 %or7
}

; Function Attrs: nofree nounwind memory(argmem: readwrite)
declare ptr @__memset_chk(ptr noundef writeonly, i32 noundef, i64 noundef, i64 noundef) local_unnamed_addr #8

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i64 @llvm.objectsize.i64.p0(ptr, i1 immarg, i1 immarg, i1 immarg) #6

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @sort_alphabet(ptr noundef %first, ptr noundef %last) unnamed_addr #0 {
entry:
  %first.addr = alloca ptr, align 8
  %last.addr = alloca ptr, align 8
  %t = alloca i64, align 8
  %a = alloca ptr, align 8
  %b = alloca ptr, align 8
  %b1 = alloca ptr, align 8
  store ptr %first, ptr %first.addr, align 8, !tbaa !12
  store ptr %last, ptr %last.addr, align 8, !tbaa !12
  call void @llvm.lifetime.start.p0(i64 8, ptr %t) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %a) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %b) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %b1) #12
  %0 = load ptr, ptr %first.addr, align 8, !tbaa !12
  %add.ptr = getelementptr inbounds i64, ptr %0, i64 1
  store ptr %add.ptr, ptr %a, align 8, !tbaa !12
  br label %for.cond

for.cond:                                         ; preds = %for.inc6, %entry
  %1 = load ptr, ptr %a, align 8, !tbaa !12
  %2 = load ptr, ptr %last.addr, align 8, !tbaa !12
  %cmp = icmp ult ptr %1, %2
  br i1 %cmp, label %for.body, label %for.end8

for.body:                                         ; preds = %for.cond
  %3 = load ptr, ptr %a, align 8, !tbaa !12
  store ptr %3, ptr %b1, align 8, !tbaa !12
  %4 = load i64, ptr %3, align 8, !tbaa !8
  store i64 %4, ptr %t, align 8, !tbaa !8
  %5 = load ptr, ptr %b1, align 8, !tbaa !12
  %add.ptr1 = getelementptr inbounds i64, ptr %5, i64 -1
  store ptr %add.ptr1, ptr %b, align 8, !tbaa !12
  br label %for.cond2

for.cond2:                                        ; preds = %for.inc, %for.body
  %6 = load ptr, ptr %b, align 8, !tbaa !12
  %7 = load i64, ptr %6, align 8, !tbaa !8
  %8 = load i64, ptr %t, align 8, !tbaa !8
  %cmp3 = icmp ult i64 %7, %8
  br i1 %cmp3, label %for.body4, label %for.end

for.body4:                                        ; preds = %for.cond2
  %9 = load ptr, ptr %b, align 8, !tbaa !12
  %10 = load i64, ptr %9, align 8, !tbaa !8
  %11 = load ptr, ptr %b1, align 8, !tbaa !12
  store i64 %10, ptr %11, align 8, !tbaa !8
  %12 = load ptr, ptr %b, align 8, !tbaa !12
  store ptr %12, ptr %b1, align 8, !tbaa !12
  %13 = load ptr, ptr %first.addr, align 8, !tbaa !12
  %cmp5 = icmp eq ptr %12, %13
  br i1 %cmp5, label %if.then, label %if.end

if.then:                                          ; preds = %for.body4
  br label %for.end

if.end:                                           ; preds = %for.body4
  br label %for.inc

for.inc:                                          ; preds = %if.end
  %14 = load ptr, ptr %b, align 8, !tbaa !12
  %incdec.ptr = getelementptr inbounds i64, ptr %14, i32 -1
  store ptr %incdec.ptr, ptr %b, align 8, !tbaa !12
  br label %for.cond2, !llvm.loop !84

for.end:                                          ; preds = %if.then, %for.cond2
  %15 = load i64, ptr %t, align 8, !tbaa !8
  %16 = load ptr, ptr %b1, align 8, !tbaa !12
  store i64 %15, ptr %16, align 8, !tbaa !8
  br label %for.inc6

for.inc6:                                         ; preds = %for.end
  %17 = load ptr, ptr %a, align 8, !tbaa !12
  %incdec.ptr7 = getelementptr inbounds i64, ptr %17, i32 1
  store ptr %incdec.ptr7, ptr %a, align 8, !tbaa !12
  br label %for.cond, !llvm.loop !85

for.end8:                                         ; preds = %for.cond
  call void @llvm.lifetime.end.p0(i64 8, ptr %b1) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %b) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %a) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %t) #12
  ret void
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @build_tree(ptr noalias noundef %tree, ptr noalias noundef %weight, i32 noundef %as) unnamed_addr #0 {
entry:
  %tree.addr = alloca ptr, align 8
  %weight.addr = alloca ptr, align 8
  %as.addr = alloca i32, align 4
  %r = alloca i32, align 4
  %s = alloca i32, align 4
  %t = alloca i32, align 4
  %w1 = alloca i64, align 8
  %w2 = alloca i64, align 8
  store ptr %tree, ptr %tree.addr, align 8, !tbaa !12
  store ptr %weight, ptr %weight.addr, align 8, !tbaa !12
  store i32 %as, ptr %as.addr, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %r) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %s) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %w1) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %w2) #12
  %0 = load i32, ptr %as.addr, align 4, !tbaa !14
  store i32 %0, ptr %r, align 4, !tbaa !14
  %1 = load i32, ptr %as.addr, align 4, !tbaa !14
  store i32 %1, ptr %s, align 4, !tbaa !14
  %2 = load i32, ptr %as.addr, align 4, !tbaa !14
  %sub = sub nsw i32 %2, 1
  store i32 %sub, ptr %t, align 4, !tbaa !14
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %3 = load i32, ptr %t, align 4, !tbaa !14
  %cmp = icmp ugt i32 %3, 0
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %4 = load i32, ptr %s, align 4, !tbaa !14
  %cmp1 = icmp ult i32 %4, 1
  br i1 %cmp1, label %if.then, label %lor.lhs.false

lor.lhs.false:                                    ; preds = %for.body
  %5 = load i32, ptr %r, align 4, !tbaa !14
  %6 = load i32, ptr %t, align 4, !tbaa !14
  %add = add i32 %6, 2
  %cmp2 = icmp ugt i32 %5, %add
  br i1 %cmp2, label %land.lhs.true, label %if.else

land.lhs.true:                                    ; preds = %lor.lhs.false
  %7 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %8 = load i32, ptr %r, align 4, !tbaa !14
  %sub3 = sub i32 %8, 2
  %idxprom = zext i32 %sub3 to i64
  %arrayidx = getelementptr inbounds i64, ptr %7, i64 %idxprom
  %9 = load i64, ptr %arrayidx, align 8, !tbaa !8
  %10 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %11 = load i32, ptr %s, align 4, !tbaa !14
  %sub4 = sub i32 %11, 1
  %idxprom5 = zext i32 %sub4 to i64
  %arrayidx6 = getelementptr inbounds i64, ptr %10, i64 %idxprom5
  %12 = load i64, ptr %arrayidx6, align 8, !tbaa !8
  %cmp7 = icmp ult i64 %9, %12
  br i1 %cmp7, label %if.then, label %if.else

if.then:                                          ; preds = %land.lhs.true, %for.body
  %13 = load i32, ptr %t, align 4, !tbaa !14
  %14 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %15 = load i32, ptr %r, align 4, !tbaa !14
  %sub8 = sub i32 %15, 1
  %idxprom9 = zext i32 %sub8 to i64
  %arrayidx10 = getelementptr inbounds i32, ptr %14, i64 %idxprom9
  store i32 %13, ptr %arrayidx10, align 4, !tbaa !14
  %16 = load i32, ptr %t, align 4, !tbaa !14
  %17 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %18 = load i32, ptr %r, align 4, !tbaa !14
  %sub11 = sub i32 %18, 2
  %idxprom12 = zext i32 %sub11 to i64
  %arrayidx13 = getelementptr inbounds i32, ptr %17, i64 %idxprom12
  store i32 %16, ptr %arrayidx13, align 4, !tbaa !14
  %19 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %20 = load i32, ptr %r, align 4, !tbaa !14
  %sub14 = sub i32 %20, 1
  %idxprom15 = zext i32 %sub14 to i64
  %arrayidx16 = getelementptr inbounds i64, ptr %19, i64 %idxprom15
  %21 = load i64, ptr %arrayidx16, align 8, !tbaa !8
  store i64 %21, ptr %w1, align 8, !tbaa !8
  %22 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %23 = load i32, ptr %r, align 4, !tbaa !14
  %sub17 = sub i32 %23, 2
  %idxprom18 = zext i32 %sub17 to i64
  %arrayidx19 = getelementptr inbounds i64, ptr %22, i64 %idxprom18
  %24 = load i64, ptr %arrayidx19, align 8, !tbaa !8
  store i64 %24, ptr %w2, align 8, !tbaa !8
  %25 = load i32, ptr %r, align 4, !tbaa !14
  %sub20 = sub i32 %25, 2
  store i32 %sub20, ptr %r, align 4, !tbaa !14
  br label %if.end52

if.else:                                          ; preds = %land.lhs.true, %lor.lhs.false
  %26 = load i32, ptr %r, align 4, !tbaa !14
  %27 = load i32, ptr %t, align 4, !tbaa !14
  %add21 = add i32 %27, 2
  %cmp22 = icmp ult i32 %26, %add21
  br i1 %cmp22, label %if.then33, label %lor.lhs.false23

lor.lhs.false23:                                  ; preds = %if.else
  %28 = load i32, ptr %s, align 4, !tbaa !14
  %cmp24 = icmp ugt i32 %28, 1
  br i1 %cmp24, label %land.lhs.true25, label %if.else41

land.lhs.true25:                                  ; preds = %lor.lhs.false23
  %29 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %30 = load i32, ptr %s, align 4, !tbaa !14
  %sub26 = sub i32 %30, 2
  %idxprom27 = zext i32 %sub26 to i64
  %arrayidx28 = getelementptr inbounds i64, ptr %29, i64 %idxprom27
  %31 = load i64, ptr %arrayidx28, align 8, !tbaa !8
  %32 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %33 = load i32, ptr %r, align 4, !tbaa !14
  %sub29 = sub i32 %33, 1
  %idxprom30 = zext i32 %sub29 to i64
  %arrayidx31 = getelementptr inbounds i64, ptr %32, i64 %idxprom30
  %34 = load i64, ptr %arrayidx31, align 8, !tbaa !8
  %cmp32 = icmp ule i64 %31, %34
  br i1 %cmp32, label %if.then33, label %if.else41

if.then33:                                        ; preds = %land.lhs.true25, %if.else
  %35 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %36 = load i32, ptr %s, align 4, !tbaa !14
  %sub34 = sub i32 %36, 1
  %idxprom35 = zext i32 %sub34 to i64
  %arrayidx36 = getelementptr inbounds i64, ptr %35, i64 %idxprom35
  %37 = load i64, ptr %arrayidx36, align 8, !tbaa !8
  store i64 %37, ptr %w1, align 8, !tbaa !8
  %38 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %39 = load i32, ptr %s, align 4, !tbaa !14
  %sub37 = sub i32 %39, 2
  %idxprom38 = zext i32 %sub37 to i64
  %arrayidx39 = getelementptr inbounds i64, ptr %38, i64 %idxprom38
  %40 = load i64, ptr %arrayidx39, align 8, !tbaa !8
  store i64 %40, ptr %w2, align 8, !tbaa !8
  %41 = load i32, ptr %s, align 4, !tbaa !14
  %sub40 = sub i32 %41, 2
  store i32 %sub40, ptr %s, align 4, !tbaa !14
  br label %if.end

if.else41:                                        ; preds = %land.lhs.true25, %lor.lhs.false23
  %42 = load i32, ptr %t, align 4, !tbaa !14
  %43 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %44 = load i32, ptr %r, align 4, !tbaa !14
  %sub42 = sub i32 %44, 1
  %idxprom43 = zext i32 %sub42 to i64
  %arrayidx44 = getelementptr inbounds i32, ptr %43, i64 %idxprom43
  store i32 %42, ptr %arrayidx44, align 4, !tbaa !14
  %45 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %46 = load i32, ptr %r, align 4, !tbaa !14
  %sub45 = sub i32 %46, 1
  %idxprom46 = zext i32 %sub45 to i64
  %arrayidx47 = getelementptr inbounds i64, ptr %45, i64 %idxprom46
  %47 = load i64, ptr %arrayidx47, align 8, !tbaa !8
  store i64 %47, ptr %w1, align 8, !tbaa !8
  %48 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %49 = load i32, ptr %s, align 4, !tbaa !14
  %sub48 = sub i32 %49, 1
  %idxprom49 = zext i32 %sub48 to i64
  %arrayidx50 = getelementptr inbounds i64, ptr %48, i64 %idxprom49
  %50 = load i64, ptr %arrayidx50, align 8, !tbaa !8
  store i64 %50, ptr %w2, align 8, !tbaa !8
  %51 = load i32, ptr %s, align 4, !tbaa !14
  %dec = add i32 %51, -1
  store i32 %dec, ptr %s, align 4, !tbaa !14
  %52 = load i32, ptr %r, align 4, !tbaa !14
  %dec51 = add i32 %52, -1
  store i32 %dec51, ptr %r, align 4, !tbaa !14
  br label %if.end

if.end:                                           ; preds = %if.else41, %if.then33
  br label %if.end52

if.end52:                                         ; preds = %if.end, %if.then
  %53 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %54 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom53 = zext i32 %54 to i64
  %arrayidx54 = getelementptr inbounds i64, ptr %53, i64 %idxprom53
  %55 = load i64, ptr %arrayidx54, align 8, !tbaa !8
  %and = and i64 %55, 65535
  %56 = load i64, ptr %w1, align 8, !tbaa !8
  %57 = load i64, ptr %w2, align 8, !tbaa !8
  %add55 = add i64 %56, %57
  %and56 = and i64 %add55, -4278255616
  %add57 = add nuw i64 %and, %and56
  %58 = load i64, ptr %w1, align 8, !tbaa !8
  %and58 = and i64 %58, 4278190080
  %59 = load i64, ptr %w2, align 8, !tbaa !8
  %and59 = and i64 %59, 4278190080
  %cmp60 = icmp ult i64 %and58, %and59
  br i1 %cmp60, label %cond.true, label %cond.false

cond.true:                                        ; preds = %if.end52
  %60 = load i64, ptr %w2, align 8, !tbaa !8
  %and61 = and i64 %60, 4278190080
  br label %cond.end

cond.false:                                       ; preds = %if.end52
  %61 = load i64, ptr %w1, align 8, !tbaa !8
  %and62 = and i64 %61, 4278190080
  br label %cond.end

cond.end:                                         ; preds = %cond.false, %cond.true
  %cond = phi i64 [ %and61, %cond.true ], [ %and62, %cond.false ]
  %add63 = add nuw i64 %add57, %cond
  %add64 = add i64 %add63, 16777216
  %62 = load ptr, ptr %weight.addr, align 8, !tbaa !12
  %63 = load i32, ptr %t, align 4, !tbaa !14
  %idxprom65 = zext i32 %63 to i64
  %arrayidx66 = getelementptr inbounds i64, ptr %62, i64 %idxprom65
  store i64 %add64, ptr %arrayidx66, align 8, !tbaa !8
  br label %for.inc

for.inc:                                          ; preds = %cond.end
  %64 = load i32, ptr %t, align 4, !tbaa !14
  %dec67 = add i32 %64, -1
  store i32 %dec67, ptr %t, align 4, !tbaa !14
  br label %for.cond, !llvm.loop !86

for.end:                                          ; preds = %for.cond
  %65 = load i32, ptr %r, align 4, !tbaa !14
  %cmp68 = icmp eq i32 %65, 2
  br i1 %cmp68, label %if.then69, label %if.else70

if.then69:                                        ; preds = %for.end
  br label %if.end71

if.else70:                                        ; preds = %for.end
  call void @__assert_fail(ptr noundef @.str.41, ptr noundef @.str.1, i32 noundef 612, ptr noundef @__PRETTY_FUNCTION__.build_tree) #11
  unreachable

if.end71:                                         ; preds = %if.then69
  %66 = load i32, ptr %s, align 4, !tbaa !14
  %cmp72 = icmp eq i32 %66, 0
  br i1 %cmp72, label %if.then73, label %if.else74

if.then73:                                        ; preds = %if.end71
  br label %if.end75

if.else74:                                        ; preds = %if.end71
  call void @__assert_fail(ptr noundef @.str.42, ptr noundef @.str.1, i32 noundef 613, ptr noundef @__PRETTY_FUNCTION__.build_tree) #11
  unreachable

if.end75:                                         ; preds = %if.then73
  %67 = load i32, ptr %t, align 4, !tbaa !14
  %cmp76 = icmp eq i32 %67, 0
  br i1 %cmp76, label %if.then77, label %if.else78

if.then77:                                        ; preds = %if.end75
  br label %if.end79

if.else78:                                        ; preds = %if.end75
  call void @__assert_fail(ptr noundef @.str.43, ptr noundef @.str.1, i32 noundef 614, ptr noundef @__PRETTY_FUNCTION__.build_tree) #11
  unreachable

if.end79:                                         ; preds = %if.then77
  call void @llvm.lifetime.end.p0(i64 8, ptr %w2) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %w1) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %t) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %s) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %r) #12
  ret void
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @compute_depths(ptr noalias noundef %count, ptr noalias noundef %tree, i32 noundef %as) unnamed_addr #0 {
entry:
  %count.addr = alloca ptr, align 8
  %tree.addr = alloca ptr, align 8
  %as.addr = alloca i32, align 4
  %avail = alloca i32, align 4
  %used = alloca i32, align 4
  %node = alloca i32, align 4
  %depth = alloca i32, align 4
  store ptr %count, ptr %count.addr, align 8, !tbaa !12
  store ptr %tree, ptr %tree.addr, align 8, !tbaa !12
  store i32 %as, ptr %as.addr, align 4, !tbaa !14
  call void @llvm.lifetime.start.p0(i64 4, ptr %avail) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %used) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %node) #12
  call void @llvm.lifetime.start.p0(i64 4, ptr %depth) #12
  %0 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %arrayidx = getelementptr inbounds i32, ptr %0, i64 1
  store i32 0, ptr %arrayidx, align 4, !tbaa !14
  %1 = load ptr, ptr %count.addr, align 8, !tbaa !12
  %arrayidx1 = getelementptr inbounds i32, ptr %1, i64 0
  store i32 0, ptr %arrayidx1, align 4, !tbaa !14
  store i32 2, ptr %node, align 4, !tbaa !14
  store i32 1, ptr %depth, align 4, !tbaa !14
  store i32 2, ptr %avail, align 4, !tbaa !14
  br label %while.cond

while.cond:                                       ; preds = %while.end, %entry
  %2 = load i32, ptr %depth, align 4, !tbaa !14
  %cmp = icmp ule i32 %2, 30
  br i1 %cmp, label %while.body, label %while.end16

while.body:                                       ; preds = %while.cond
  store i32 0, ptr %used, align 4, !tbaa !14
  br label %while.cond2

while.cond2:                                      ; preds = %if.end, %while.body
  %3 = load i32, ptr %node, align 4, !tbaa !14
  %4 = load i32, ptr %as.addr, align 4, !tbaa !14
  %cmp3 = icmp ult i32 %3, %4
  br i1 %cmp3, label %land.rhs, label %land.end

land.rhs:                                         ; preds = %while.cond2
  %5 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %6 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %7 = load i32, ptr %node, align 4, !tbaa !14
  %idxprom = zext i32 %7 to i64
  %arrayidx4 = getelementptr inbounds i32, ptr %6, i64 %idxprom
  %8 = load i32, ptr %arrayidx4, align 4, !tbaa !14
  %idxprom5 = zext i32 %8 to i64
  %arrayidx6 = getelementptr inbounds i32, ptr %5, i64 %idxprom5
  %9 = load i32, ptr %arrayidx6, align 4, !tbaa !14
  %add = add i32 %9, 1
  %10 = load i32, ptr %depth, align 4, !tbaa !14
  %cmp7 = icmp eq i32 %add, %10
  br label %land.end

land.end:                                         ; preds = %land.rhs, %while.cond2
  %11 = phi i1 [ false, %while.cond2 ], [ %cmp7, %land.rhs ]
  br i1 %11, label %while.body8, label %while.end

while.body8:                                      ; preds = %land.end
  %12 = load i32, ptr %avail, align 4, !tbaa !14
  %13 = load i32, ptr %used, align 4, !tbaa !14
  %cmp9 = icmp ugt i32 %12, %13
  br i1 %cmp9, label %if.then, label %if.else

if.then:                                          ; preds = %while.body8
  br label %if.end

if.else:                                          ; preds = %while.body8
  call void @__assert_fail(ptr noundef @.str.44, ptr noundef @.str.1, i32 noundef 638, ptr noundef @__PRETTY_FUNCTION__.compute_depths) #11
  unreachable

if.end:                                           ; preds = %if.then
  %14 = load i32, ptr %used, align 4, !tbaa !14
  %inc = add i32 %14, 1
  store i32 %inc, ptr %used, align 4, !tbaa !14
  %15 = load i32, ptr %depth, align 4, !tbaa !14
  %16 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %17 = load i32, ptr %node, align 4, !tbaa !14
  %inc10 = add i32 %17, 1
  store i32 %inc10, ptr %node, align 4, !tbaa !14
  %idxprom11 = zext i32 %17 to i64
  %arrayidx12 = getelementptr inbounds i32, ptr %16, i64 %idxprom11
  store i32 %15, ptr %arrayidx12, align 4, !tbaa !14
  br label %while.cond2, !llvm.loop !87

while.end:                                        ; preds = %land.end
  %18 = load i32, ptr %avail, align 4, !tbaa !14
  %19 = load i32, ptr %used, align 4, !tbaa !14
  %sub = sub i32 %18, %19
  %20 = load ptr, ptr %count.addr, align 8, !tbaa !12
  %21 = load i32, ptr %depth, align 4, !tbaa !14
  %idxprom13 = zext i32 %21 to i64
  %arrayidx14 = getelementptr inbounds i32, ptr %20, i64 %idxprom13
  store i32 %sub, ptr %arrayidx14, align 4, !tbaa !14
  %22 = load i32, ptr %depth, align 4, !tbaa !14
  %inc15 = add i32 %22, 1
  store i32 %inc15, ptr %depth, align 4, !tbaa !14
  %23 = load i32, ptr %used, align 4, !tbaa !14
  %shl = shl i32 %23, 1
  store i32 %shl, ptr %avail, align 4, !tbaa !14
  br label %while.cond, !llvm.loop !88

while.end16:                                      ; preds = %while.cond
  %24 = load i32, ptr %avail, align 4, !tbaa !14
  %cmp17 = icmp eq i32 %24, 0
  br i1 %cmp17, label %if.then18, label %if.else19

if.then18:                                        ; preds = %while.end16
  br label %if.end20

if.else19:                                        ; preds = %while.end16
  call void @__assert_fail(ptr noundef @.str.45, ptr noundef @.str.1, i32 noundef 648, ptr noundef @__PRETTY_FUNCTION__.compute_depths) #11
  unreachable

if.end20:                                         ; preds = %if.then18
  call void @llvm.lifetime.end.p0(i64 4, ptr %depth) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %node) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %used) #12
  call void @llvm.lifetime.end.p0(i64 4, ptr %avail) #12
  ret void
}

; Function Attrs: noinline nounwind optnone sspstrong uwtable
define internal fastcc void @package_merge(ptr noundef %tree, ptr noalias noundef %count, ptr noalias noundef %leaf_weight, i64 noundef %as) unnamed_addr #0 {
entry:
  %tree.addr = alloca ptr, align 8
  %count.addr = alloca ptr, align 8
  %leaf_weight.addr = alloca ptr, align 8
  %as.addr = alloca i64, align 8
  %pkg_weight = alloca [21 x i64], align 16
  %prev_weight = alloca [21 x i64], align 16
  %curr_weight = alloca [21 x i64], align 16
  %width = alloca i64, align 8
  %next_depth = alloca i64, align 8
  %depth = alloca i64, align 8
  store ptr %tree, ptr %tree.addr, align 8, !tbaa !12
  store ptr %count, ptr %count.addr, align 8, !tbaa !12
  store ptr %leaf_weight, ptr %leaf_weight.addr, align 8, !tbaa !12
  store i64 %as, ptr %as.addr, align 8, !tbaa !8
  call void @llvm.lifetime.start.p0(i64 168, ptr %pkg_weight) #12
  call void @llvm.lifetime.start.p0(i64 168, ptr %prev_weight) #12
  call void @llvm.lifetime.start.p0(i64 168, ptr %curr_weight) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %width) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %next_depth) #12
  call void @llvm.lifetime.start.p0(i64 8, ptr %depth) #12
  %arrayidx = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 0
  store i64 -1, ptr %arrayidx, align 16, !tbaa !8
  store i64 1, ptr %depth, align 8, !tbaa !8
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %0 = load i64, ptr %depth, align 8, !tbaa !8
  %cmp = icmp ule i64 %0, 20
  br i1 %cmp, label %for.body, label %for.end

for.body:                                         ; preds = %for.cond
  %1 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %2 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx1 = getelementptr inbounds [21 x i16], ptr %1, i64 %2
  %arrayidx2 = getelementptr inbounds [21 x i16], ptr %arrayidx1, i64 0, i64 0
  store i16 2, ptr %arrayidx2, align 2, !tbaa !42
  %3 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %4 = load i64, ptr %as.addr, align 8, !tbaa !8
  %arrayidx3 = getelementptr inbounds i64, ptr %3, i64 %4
  %5 = load i64, ptr %arrayidx3, align 8, !tbaa !8
  %6 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %7 = load i64, ptr %as.addr, align 8, !tbaa !8
  %sub = sub i64 %7, 1
  %arrayidx4 = getelementptr inbounds i64, ptr %6, i64 %sub
  %8 = load i64, ptr %arrayidx4, align 8, !tbaa !8
  %add = add i64 %5, %8
  %and = and i64 %add, -4294967296
  %9 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %10 = load i64, ptr %as.addr, align 8, !tbaa !8
  %arrayidx5 = getelementptr inbounds i64, ptr %9, i64 %10
  %11 = load i64, ptr %arrayidx5, align 8, !tbaa !8
  %and6 = and i64 %11, 4278190080
  %12 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %13 = load i64, ptr %as.addr, align 8, !tbaa !8
  %sub7 = sub i64 %13, 1
  %arrayidx8 = getelementptr inbounds i64, ptr %12, i64 %sub7
  %14 = load i64, ptr %arrayidx8, align 8, !tbaa !8
  %and9 = and i64 %14, 4278190080
  %cmp10 = icmp ult i64 %and6, %and9
  br i1 %cmp10, label %cond.true, label %cond.false

cond.true:                                        ; preds = %for.body
  %15 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %16 = load i64, ptr %as.addr, align 8, !tbaa !8
  %sub11 = sub i64 %16, 1
  %arrayidx12 = getelementptr inbounds i64, ptr %15, i64 %sub11
  %17 = load i64, ptr %arrayidx12, align 8, !tbaa !8
  %and13 = and i64 %17, 4278190080
  br label %cond.end

cond.false:                                       ; preds = %for.body
  %18 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %19 = load i64, ptr %as.addr, align 8, !tbaa !8
  %arrayidx14 = getelementptr inbounds i64, ptr %18, i64 %19
  %20 = load i64, ptr %arrayidx14, align 8, !tbaa !8
  %and15 = and i64 %20, 4278190080
  br label %cond.end

cond.end:                                         ; preds = %cond.false, %cond.true
  %cond = phi i64 [ %and13, %cond.true ], [ %and15, %cond.false ]
  %add16 = add nuw i64 %and, %cond
  %add17 = add i64 %add16, 16777216
  %21 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx18 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %21
  store i64 %add17, ptr %arrayidx18, align 8, !tbaa !8
  %22 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %23 = load i64, ptr %as.addr, align 8, !tbaa !8
  %sub19 = sub i64 %23, 1
  %arrayidx20 = getelementptr inbounds i64, ptr %22, i64 %sub19
  %24 = load i64, ptr %arrayidx20, align 8, !tbaa !8
  %25 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx21 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %25
  store i64 %24, ptr %arrayidx21, align 8, !tbaa !8
  %26 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %27 = load i64, ptr %as.addr, align 8, !tbaa !8
  %sub22 = sub i64 %27, 2
  %arrayidx23 = getelementptr inbounds i64, ptr %26, i64 %sub22
  %28 = load i64, ptr %arrayidx23, align 8, !tbaa !8
  %29 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx24 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %29
  store i64 %28, ptr %arrayidx24, align 8, !tbaa !8
  br label %for.inc

for.inc:                                          ; preds = %cond.end
  %30 = load i64, ptr %depth, align 8, !tbaa !8
  %inc = add i64 %30, 1
  store i64 %inc, ptr %depth, align 8, !tbaa !8
  br label %for.cond, !llvm.loop !89

for.end:                                          ; preds = %for.cond
  store i64 2, ptr %width, align 8, !tbaa !8
  br label %for.cond25

for.cond25:                                       ; preds = %for.inc116, %for.end
  %31 = load i64, ptr %width, align 8, !tbaa !8
  %32 = load i64, ptr %as.addr, align 8, !tbaa !8
  %cmp26 = icmp ult i64 %31, %32
  br i1 %cmp26, label %for.body27, label %for.end118

for.body27:                                       ; preds = %for.cond25
  %33 = load ptr, ptr %count.addr, align 8, !tbaa !12
  %arrayidx28 = getelementptr inbounds i32, ptr %33, i64 0
  store i32 20, ptr %arrayidx28, align 4, !tbaa !14
  store i64 20, ptr %depth, align 8, !tbaa !8
  store i64 1, ptr %next_depth, align 8, !tbaa !8
  br label %for.cond29

for.cond29:                                       ; preds = %if.end111, %cond.end61, %for.body27
  %34 = load i64, ptr %depth, align 8, !tbaa !8
  %sub30 = sub i64 %34, 1
  %arrayidx31 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %sub30
  %35 = load i64, ptr %arrayidx31, align 8, !tbaa !8
  %36 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx32 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %36
  %37 = load i64, ptr %arrayidx32, align 8, !tbaa !8
  %cmp33 = icmp ule i64 %35, %37
  br i1 %cmp33, label %if.then, label %if.else

if.then:                                          ; preds = %for.cond29
  %38 = load i64, ptr %depth, align 8, !tbaa !8
  %cmp34 = icmp ne i64 %38, 1
  %conv = zext i1 %cmp34 to i32
  %conv35 = zext nneg i32 %conv to i64
  %expval = call i64 @llvm.expect.i64(i64 %conv35, i64 1)
  %tobool = icmp ne i64 %expval, 0
  br i1 %tobool, label %if.then36, label %if.end

if.then36:                                        ; preds = %if.then
  %39 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %40 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx37 = getelementptr inbounds [21 x i16], ptr %39, i64 %40
  %arrayidx38 = getelementptr inbounds [21 x i16], ptr %arrayidx37, i64 0, i64 1
  %41 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %42 = load i64, ptr %depth, align 8, !tbaa !8
  %sub39 = sub i64 %42, 1
  %arrayidx40 = getelementptr inbounds [21 x i16], ptr %41, i64 %sub39
  %arrayidx41 = getelementptr inbounds [21 x i16], ptr %arrayidx40, i64 0, i64 0
  call void @llvm.experimental.noalias.scope.decl(metadata !90)
  call void @llvm.experimental.noalias.scope.decl(metadata !93)
  %43 = call i64 @llvm.objectsize.i64.p0(ptr %arrayidx38, i1 false, i1 true, i1 false)
  %call.i = call ptr @__memcpy_chk(ptr noundef nonnull %arrayidx38, ptr noundef nonnull %arrayidx41, i64 noundef 40, i64 noundef %43) #12, !alias.scope !95
  %44 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx42 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %44
  %45 = load i64, ptr %arrayidx42, align 8, !tbaa !8
  %46 = load i64, ptr %depth, align 8, !tbaa !8
  %sub43 = sub i64 %46, 1
  %arrayidx44 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %sub43
  %47 = load i64, ptr %arrayidx44, align 8, !tbaa !8
  %add45 = add i64 %45, %47
  %and46 = and i64 %add45, -4294967296
  %48 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx47 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %48
  %49 = load i64, ptr %arrayidx47, align 8, !tbaa !8
  %and48 = and i64 %49, 4278190080
  %50 = load i64, ptr %depth, align 8, !tbaa !8
  %sub49 = sub i64 %50, 1
  %arrayidx50 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %sub49
  %51 = load i64, ptr %arrayidx50, align 8, !tbaa !8
  %and51 = and i64 %51, 4278190080
  %cmp52 = icmp ult i64 %and48, %and51
  br i1 %cmp52, label %cond.true54, label %cond.false58

cond.true54:                                      ; preds = %if.then36
  %52 = load i64, ptr %depth, align 8, !tbaa !8
  %sub55 = sub i64 %52, 1
  %arrayidx56 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %sub55
  %53 = load i64, ptr %arrayidx56, align 8, !tbaa !8
  %and57 = and i64 %53, 4278190080
  br label %cond.end61

cond.false58:                                     ; preds = %if.then36
  %54 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx59 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %54
  %55 = load i64, ptr %arrayidx59, align 8, !tbaa !8
  %and60 = and i64 %55, 4278190080
  br label %cond.end61

cond.end61:                                       ; preds = %cond.false58, %cond.true54
  %cond62 = phi i64 [ %and57, %cond.true54 ], [ %and60, %cond.false58 ]
  %add63 = add nuw i64 %and46, %cond62
  %add64 = add i64 %add63, 16777216
  %56 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx65 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %56
  store i64 %add64, ptr %arrayidx65, align 8, !tbaa !8
  %57 = load i64, ptr %depth, align 8, !tbaa !8
  %sub66 = sub i64 %57, 1
  %arrayidx67 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %sub66
  %58 = load i64, ptr %arrayidx67, align 8, !tbaa !8
  %59 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx68 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %59
  store i64 %58, ptr %arrayidx68, align 8, !tbaa !8
  %60 = load i64, ptr %depth, align 8, !tbaa !8
  %dec = add i64 %60, -1
  store i64 %dec, ptr %depth, align 8, !tbaa !8
  %61 = load i64, ptr %depth, align 8, !tbaa !8
  %conv69 = trunc i64 %61 to i32
  %62 = load ptr, ptr %count.addr, align 8, !tbaa !12
  %63 = load i64, ptr %next_depth, align 8, !tbaa !8
  %inc70 = add i64 %63, 1
  store i64 %inc70, ptr %next_depth, align 8, !tbaa !8
  %arrayidx71 = getelementptr inbounds i32, ptr %62, i64 %63
  store i32 %conv69, ptr %arrayidx71, align 4, !tbaa !14
  br label %for.cond29, !llvm.loop !96

if.end:                                           ; preds = %if.then
  br label %if.end104

if.else:                                          ; preds = %for.cond29
  %64 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %65 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx72 = getelementptr inbounds [21 x i16], ptr %64, i64 %65
  %arrayidx73 = getelementptr inbounds [21 x i16], ptr %arrayidx72, i64 0, i64 0
  %66 = load i16, ptr %arrayidx73, align 2, !tbaa !42
  %inc74 = add i16 %66, 1
  store i16 %inc74, ptr %arrayidx73, align 2, !tbaa !42
  %67 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx75 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %67
  %68 = load i64, ptr %arrayidx75, align 8, !tbaa !8
  %69 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx76 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %69
  %70 = load i64, ptr %arrayidx76, align 8, !tbaa !8
  %add77 = add i64 %68, %70
  %and78 = and i64 %add77, -4294967296
  %71 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx79 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %71
  %72 = load i64, ptr %arrayidx79, align 8, !tbaa !8
  %and80 = and i64 %72, 4278190080
  %73 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx81 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %73
  %74 = load i64, ptr %arrayidx81, align 8, !tbaa !8
  %and82 = and i64 %74, 4278190080
  %cmp83 = icmp ult i64 %and80, %and82
  br i1 %cmp83, label %cond.true85, label %cond.false88

cond.true85:                                      ; preds = %if.else
  %75 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx86 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %75
  %76 = load i64, ptr %arrayidx86, align 8, !tbaa !8
  %and87 = and i64 %76, 4278190080
  br label %cond.end91

cond.false88:                                     ; preds = %if.else
  %77 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx89 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %77
  %78 = load i64, ptr %arrayidx89, align 8, !tbaa !8
  %and90 = and i64 %78, 4278190080
  br label %cond.end91

cond.end91:                                       ; preds = %cond.false88, %cond.true85
  %cond92 = phi i64 [ %and87, %cond.true85 ], [ %and90, %cond.false88 ]
  %add93 = add nuw i64 %and78, %cond92
  %add94 = add i64 %add93, 16777216
  %79 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx95 = getelementptr inbounds [21 x i64], ptr %pkg_weight, i64 0, i64 %79
  store i64 %add94, ptr %arrayidx95, align 8, !tbaa !8
  %80 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx96 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %80
  %81 = load i64, ptr %arrayidx96, align 8, !tbaa !8
  %82 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx97 = getelementptr inbounds [21 x i64], ptr %prev_weight, i64 0, i64 %82
  store i64 %81, ptr %arrayidx97, align 8, !tbaa !8
  %83 = load ptr, ptr %leaf_weight.addr, align 8, !tbaa !12
  %84 = load i64, ptr %as.addr, align 8, !tbaa !8
  %85 = load ptr, ptr %tree.addr, align 8, !tbaa !12
  %86 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx98 = getelementptr inbounds [21 x i16], ptr %85, i64 %86
  %arrayidx99 = getelementptr inbounds [21 x i16], ptr %arrayidx98, i64 0, i64 0
  %87 = load i16, ptr %arrayidx99, align 2, !tbaa !42
  %conv100 = zext i16 %87 to i64
  %sub101 = sub i64 %84, %conv100
  %arrayidx102 = getelementptr inbounds i64, ptr %83, i64 %sub101
  %88 = load i64, ptr %arrayidx102, align 8, !tbaa !8
  %89 = load i64, ptr %depth, align 8, !tbaa !8
  %arrayidx103 = getelementptr inbounds [21 x i64], ptr %curr_weight, i64 0, i64 %89
  store i64 %88, ptr %arrayidx103, align 8, !tbaa !8
  br label %if.end104

if.end104:                                        ; preds = %cond.end91, %if.end
  %90 = load i64, ptr %next_depth, align 8, !tbaa !8
  %cmp105 = icmp eq i64 %90, 0
  %conv106 = zext i1 %cmp105 to i32
  %conv107 = zext nneg i32 %conv106 to i64
  %expval108 = call i64 @llvm.expect.i64(i64 %conv107, i64 0)
  %tobool109 = icmp ne i64 %expval108, 0
  br i1 %tobool109, label %if.then110, label %if.end111

if.then110:                                       ; preds = %if.end104
  br label %for.end115

if.end111:                                        ; preds = %if.end104
  %91 = load i64, ptr %next_depth, align 8, !tbaa !8
  %dec112 = add i64 %91, -1
  store i64 %dec112, ptr %next_depth, align 8, !tbaa !8
  %92 = load ptr, ptr %count.addr, align 8, !tbaa !12
  %93 = load i64, ptr %next_depth, align 8, !tbaa !8
  %arrayidx113 = getelementptr inbounds i32, ptr %92, i64 %93
  %94 = load i32, ptr %arrayidx113, align 4, !tbaa !14
  %conv114 = zext i32 %94 to i64
  store i64 %conv114, ptr %depth, align 8, !tbaa !8
  br label %for.cond29, !llvm.loop !96

for.end115:                                       ; preds = %if.then110
  br label %for.inc116

for.inc116:                                       ; preds = %for.end115
  %95 = load i64, ptr %width, align 8, !tbaa !8
  %inc117 = add i64 %95, 1
  store i64 %inc117, ptr %width, align 8, !tbaa !8
  br label %for.cond25, !llvm.loop !97

for.end118:                                       ; preds = %for.cond25
  call void @llvm.lifetime.end.p0(i64 8, ptr %depth) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %next_depth) #12
  call void @llvm.lifetime.end.p0(i64 8, ptr %width) #12
  call void @llvm.lifetime.end.p0(i64 168, ptr %curr_weight) #12
  call void @llvm.lifetime.end.p0(i64 168, ptr %prev_weight) #12
  call void @llvm.lifetime.end.p0(i64 168, ptr %pkg_weight) #12
  ret void
}

; Function Attrs: nofree nounwind memory(argmem: readwrite)
declare ptr @__memcpy_chk(ptr noalias noundef writeonly, ptr noalias nocapture noundef readonly, i64 noundef, i64 noundef) local_unnamed_addr #8

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

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite)
declare void @llvm.experimental.noalias.scope.decl(metadata) #9

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.abs.i32(i32, i1 immarg) #6

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

attributes #0 = { noinline nounwind optnone sspstrong uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="inline-asm" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #1 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #2 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) "target-cpu"="znver4" }
attributes #3 = { nocallback nofree nosync nounwind willreturn memory(none) "target-cpu"="znver4" }
attributes #4 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #5 = { noinline nounwind sspstrong uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="inline-asm" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #6 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) "target-cpu"="znver4" }
attributes #7 = { inlinehint mustprogress nofree norecurse nosync nounwind sspstrong willreturn memory(none) uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "probe-stack"="inline-asm" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #8 = { nofree nounwind memory(argmem: readwrite) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+avx,+avx2,+avx512f,+cmov,+crc32,+cx8,+evex512,+f16c,+fma,+fxsr,+mmx,+popcnt,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave" "tune-cpu"="generic" }
attributes #9 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) "target-cpu"="znver4" }
attributes #10 = { nocallback nofree nounwind willreturn memory(argmem: write) "target-cpu"="znver4" }
attributes #11 = { noreturn nounwind }
attributes #12 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"cf-protection-return", i32 1}
!2 = !{i32 8, !"cf-protection-branch", i32 1}
!3 = !{i32 4, !"probe-stack", !"inline-asm"}
!4 = !{i32 8, !"PIC Level", i32 2}
!5 = !{i32 7, !"PIE Level", i32 2}
!6 = !{i32 7, !"uwtable", i32 2}
!7 = !{!"clang version 19.0.0gita8b0ecd2"}
!8 = !{!9, !9, i64 0}
!9 = !{!"long", !10, i64 0}
!10 = !{!"omnipotent char", !11, i64 0}
!11 = !{!"Simple C/C++ TBAA"}
!12 = !{!13, !13, i64 0}
!13 = !{!"any pointer", !10, i64 0}
!14 = !{!15, !15, i64 0}
!15 = !{!"int", !10, i64 0}
!16 = !{!17, !15, i64 288}
!17 = !{!"encoder_state", !10, i64 0, !15, i64 256, !15, i64 260, !15, i64 264, !15, i64 268, !15, i64 272, !15, i64 276, !15, i64 280, !15, i64 284, !15, i64 288, !15, i64 292, !10, i64 296, !10, i64 263464}
!18 = !{!17, !15, i64 292}
!19 = !{!17, !15, i64 256}
!20 = !{!17, !15, i64 264}
!21 = !{!17, !15, i64 280}
!22 = !{!17, !15, i64 260}
!23 = !{!10, !10, i64 0}
!24 = !{!25, !25, i64 0}
!25 = !{!"_Bool", !10, i64 0}
!26 = distinct !{!26, !27, !28}
!27 = !{!"llvm.loop.mustprogress"}
!28 = !{!"llvm.loop.unroll.disable"}
!29 = distinct !{!29, !27, !28}
!30 = !{!17, !15, i64 268}
!31 = !{!17, !15, i64 276}
!32 = distinct !{!32, !27, !28}
!33 = distinct !{!33, !27, !28}
!34 = !{i8 0, i8 2}
!35 = !{}
!36 = distinct !{!36, !27, !28}
!37 = distinct !{!37, !27, !28}
!38 = !{!17, !15, i64 272}
!39 = distinct !{!39, !27, !28}
!40 = distinct !{!40, !27, !28}
!41 = distinct !{!41, !27, !28}
!42 = !{!43, !43, i64 0}
!43 = !{!"short", !10, i64 0}
!44 = distinct !{!44, !27, !28}
!45 = distinct !{!45, !28}
!46 = distinct !{!46, !27, !28}
!47 = distinct !{!47, !27, !28}
!48 = distinct !{!48, !27, !28, !49}
!49 = !{!"llvm.loop.vectorize.width", i32 1}
!50 = distinct !{!50, !27, !28, !49}
!51 = distinct !{!51, !27, !28}
!52 = distinct !{!52, !27, !28, !49}
!53 = distinct !{!53, !27, !28, !49}
!54 = distinct !{!54, !27, !28, !49}
!55 = distinct !{!55, !27, !28, !49}
!56 = distinct !{!56, !27, !28, !49}
!57 = distinct !{!57, !27, !28, !49}
!58 = distinct !{!58, !27, !28, !49}
!59 = distinct !{!59, !27, !28, !49}
!60 = distinct !{!60, !27, !28, !49}
!61 = distinct !{!61, !27, !28, !49}
!62 = !{i64 26974}
!63 = distinct !{!63, !27, !28}
!64 = !{i64 27117}
!65 = distinct !{!65, !27, !28, !49}
!66 = distinct !{!66, !27, !28}
!67 = distinct !{!67, !27, !28}
!68 = distinct !{!68, !27, !28}
!69 = distinct !{!69, !27, !28}
!70 = distinct !{!70, !27, !28}
!71 = distinct !{!71, !27, !28}
!72 = distinct !{!72, !27, !28}
!73 = distinct !{!73, !27, !28}
!74 = distinct !{!74, !27, !28}
!75 = distinct !{!75, !27, !28}
!76 = distinct !{!76, !27, !28}
!77 = distinct !{!77, !27, !28}
!78 = distinct !{!78, !27, !28}
!79 = distinct !{!79, !27, !28}
!80 = distinct !{!80, !27, !28}
!81 = distinct !{!81, !27, !28}
!82 = distinct !{!82, !27, !28}
!83 = distinct !{!83, !27, !28}
!84 = distinct !{!84, !27, !28}
!85 = distinct !{!85, !27, !28}
!86 = distinct !{!86, !27, !28}
!87 = distinct !{!87, !27, !28}
!88 = distinct !{!88, !27, !28}
!89 = distinct !{!89, !27, !28}
!90 = !{!91}
!91 = distinct !{!91, !92, !"memcpy.inline: %__dest"}
!92 = distinct !{!92, !"memcpy.inline"}
!93 = !{!94}
!94 = distinct !{!94, !92, !"memcpy.inline: %__src"}
!95 = !{!91, !94}
!96 = distinct !{!96, !28}
!97 = distinct !{!97, !27, !28}