#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ AddBits(unsigned int, int, unsigned char *, unsigned char **,
                           size_t *);
int /*<<< orphan*/ AddHuffmanBits(unsigned int, unsigned int, unsigned char *,
                                  unsigned char **, size_t *);
int /*<<< orphan*/ CalculateBitLengths(size_t *, int, int, unsigned int *);
int /*<<< orphan*/ LengthsToSymbols(unsigned int *, int, int, unsigned int *);
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(unsigned int *);
unsigned int *malloc(int);
unsigned int *realloc(unsigned int *, size_t);
void AddDynamicTree(const unsigned *ll_lengths, const unsigned *d_lengths,
                    unsigned char *bp, unsigned char **out, size_t *outsize) {
  unsigned *lld_lengths = 0;
  unsigned lld_total;
  unsigned *rle = 0;
  unsigned *rle_bits = 0;
  size_t rle_size = 0;
  size_t rle_bits_size = 0;
  unsigned hlit = 29;
  unsigned hdist = 29;
  unsigned hclen;
  size_t i, j;
  size_t clcounts[19];
  unsigned clcl[19];
  unsigned clsymbols[19];
  unsigned order[19] = {16, 17, 18, 0, 8,  7, 9,  6, 10, 5,
                        11, 4,  12, 3, 13, 2, 14, 1, 15};
  while (hlit > 0 && ll_lengths[257 + hlit - 1] == 0)
    hlit--;
  while (hdist > 0 && d_lengths[1 + hdist - 1] == 0)
    hdist--;
  lld_total = hlit + 257 + hdist + 1;
  lld_lengths = (unsigned *)malloc(sizeof(*lld_lengths) * lld_total);
  if (!lld_lengths)
    exit(-1);
  for (i = 0; i < lld_total; i++) {
    lld_lengths[i] = i < 257 + hlit ? ll_lengths[i] : d_lengths[i - 257 - hlit];
    assert(lld_lengths[i] < 16);
  }
  for (i = 0; i < lld_total; i++) {
    size_t count = 0;
    for (j = i; j < lld_total && lld_lengths[i] == lld_lengths[j]; j++) {
      count++;
    }
    if (count >= 4 || (count >= 3 && lld_lengths[i] == 0)) {
      if (lld_lengths[i] == 0) {
        if (count > 10) {
          if (count > 138)
            count = 138;
          {
            if (!((*&rle_size) & ((*&rle_size) - 1))) {
              (*&rle) =
                  (*&rle_size) == 0
                      ? malloc(sizeof(**&rle))
                      : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
            }
            (*&rle)[(*&rle_size)] = (18);
            (*&rle_size)++;
          };
          {
            if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
              (*&rle_bits) =
                  (*&rle_bits_size) == 0
                      ? malloc(sizeof(**&rle_bits))
                      : realloc((*&rle_bits),
                                (*&rle_bits_size) * 2 * sizeof(**&rle_bits));
            }
            (*&rle_bits)[(*&rle_bits_size)] = (count - 11);
            (*&rle_bits_size)++;
          };
        } else {
          {
            if (!((*&rle_size) & ((*&rle_size) - 1))) {
              (*&rle) =
                  (*&rle_size) == 0
                      ? malloc(sizeof(**&rle))
                      : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
            }
            (*&rle)[(*&rle_size)] = (17);
            (*&rle_size)++;
          };
          {
            if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
              (*&rle_bits) =
                  (*&rle_bits_size) == 0
                      ? malloc(sizeof(**&rle_bits))
                      : realloc((*&rle_bits),
                                (*&rle_bits_size) * 2 * sizeof(**&rle_bits));
            }
            (*&rle_bits)[(*&rle_bits_size)] = (count - 3);
            (*&rle_bits_size)++;
          };
        }
      } else {
        unsigned repeat = count - 1;
        {
          if (!((*&rle_size) & ((*&rle_size) - 1))) {
            (*&rle) = (*&rle_size) == 0
                          ? malloc(sizeof(**&rle))
                          : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
          }
          (*&rle)[(*&rle_size)] = (lld_lengths[i]);
          (*&rle_size)++;
        };
        {
          if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
            (*&rle_bits) = (*&rle_bits_size) == 0
                               ? malloc(sizeof(**&rle_bits))
                               : realloc((*&rle_bits), (*&rle_bits_size) * 2 *
                                                           sizeof(**&rle_bits));
          }
          (*&rle_bits)[(*&rle_bits_size)] = (0);
          (*&rle_bits_size)++;
        };
        while (repeat >= 6) {
          {
            if (!((*&rle_size) & ((*&rle_size) - 1))) {
              (*&rle) =
                  (*&rle_size) == 0
                      ? malloc(sizeof(**&rle))
                      : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
            }
            (*&rle)[(*&rle_size)] = (16);
            (*&rle_size)++;
          };
          {
            if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
              (*&rle_bits) =
                  (*&rle_bits_size) == 0
                      ? malloc(sizeof(**&rle_bits))
                      : realloc((*&rle_bits),
                                (*&rle_bits_size) * 2 * sizeof(**&rle_bits));
            }
            (*&rle_bits)[(*&rle_bits_size)] = (6 - 3);
            (*&rle_bits_size)++;
          };
          repeat -= 6;
        }
        if (repeat >= 3) {
          {
            if (!((*&rle_size) & ((*&rle_size) - 1))) {
              (*&rle) =
                  (*&rle_size) == 0
                      ? malloc(sizeof(**&rle))
                      : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
            }
            (*&rle)[(*&rle_size)] = (16);
            (*&rle_size)++;
          };
          {
            if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
              (*&rle_bits) =
                  (*&rle_bits_size) == 0
                      ? malloc(sizeof(**&rle_bits))
                      : realloc((*&rle_bits),
                                (*&rle_bits_size) * 2 * sizeof(**&rle_bits));
            }
            (*&rle_bits)[(*&rle_bits_size)] = (3 - 3);
            (*&rle_bits_size)++;
          };
          repeat -= 3;
        }
        while (repeat != 0) {
          {
            if (!((*&rle_size) & ((*&rle_size) - 1))) {
              (*&rle) =
                  (*&rle_size) == 0
                      ? malloc(sizeof(**&rle))
                      : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
            }
            (*&rle)[(*&rle_size)] = (lld_lengths[i]);
            (*&rle_size)++;
          };
          {
            if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
              (*&rle_bits) =
                  (*&rle_bits_size) == 0
                      ? malloc(sizeof(**&rle_bits))
                      : realloc((*&rle_bits),
                                (*&rle_bits_size) * 2 * sizeof(**&rle_bits));
            }
            (*&rle_bits)[(*&rle_bits_size)] = (0);
            (*&rle_bits_size)++;
          };
          repeat--;
        }
      }
      i += count - 1;
    } else {
      {
        if (!((*&rle_size) & ((*&rle_size) - 1))) {
          (*&rle) = (*&rle_size) == 0
                        ? malloc(sizeof(**&rle))
                        : realloc((*&rle), (*&rle_size) * 2 * sizeof(**&rle));
        }
        (*&rle)[(*&rle_size)] = (lld_lengths[i]);
        (*&rle_size)++;
      };
      {
        if (!((*&rle_bits_size) & ((*&rle_bits_size) - 1))) {
          (*&rle_bits) = (*&rle_bits_size) == 0
                             ? malloc(sizeof(**&rle_bits))
                             : realloc((*&rle_bits), (*&rle_bits_size) * 2 *
                                                         sizeof(**&rle_bits));
        }
        (*&rle_bits)[(*&rle_bits_size)] = (0);
        (*&rle_bits_size)++;
      };
    }
    assert(rle[rle_size - 1] <= 18);
  }
  for (i = 0; i < 19; i++) {
    clcounts[i] = 0;
  }
  for (i = 0; i < rle_size; i++) {
    clcounts[rle[i]]++;
  }
  CalculateBitLengths(clcounts, 19, 7, clcl);
  LengthsToSymbols(clcl, 19, 7, clsymbols);
  hclen = 15;
  while (hclen > 0 && clcounts[order[hclen + 4 - 1]] == 0)
    hclen--;
  AddBits(hlit, 5, bp, out, outsize);
  AddBits(hdist, 5, bp, out, outsize);
  AddBits(hclen, 4, bp, out, outsize);
  for (i = 0; i < hclen + 4; i++) {
    AddBits(clcl[order[i]], 3, bp, out, outsize);
  }
  for (i = 0; i < rle_size; i++) {
    unsigned symbol = clsymbols[rle[i]];
    AddHuffmanBits(symbol, clcl[rle[i]], bp, out, outsize);
    if (rle[i] == 16)
      AddBits(rle_bits[i], 2, bp, out, outsize);
    else if (rle[i] == 17)
      AddBits(rle_bits[i], 3, bp, out, outsize);
    else if (rle[i] == 18)
      AddBits(rle_bits[i], 7, bp, out, outsize);
  }
  free(lld_lengths);
  free(rle);
  free(rle_bits);
}


x86 assembly (clang, -O0):
<AddDynamicTree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movl   $0x1d,-0x5c(%rbp)
movl   $0x1d,-0x60(%rbp)
lea    -0x200(%rbp),%rdi
lea    0xdfd(%rip),%rsi
mov    $0x4c,%edx
call   1070 <memcpy@plt>
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x211(%rbp)
jbe    123e <AddDynamicTree+0x9e>
mov    -0x8(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x101,%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
cmpl   $0x0,(%rax,%rcx,4)
sete   %al
mov    %al,-0x211(%rbp)
mov    -0x211(%rbp),%al
test   $0x1,%al
jne    1251 <AddDynamicTree+0xb1>
jmp    125f <AddDynamicTree+0xbf>
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    120d <AddDynamicTree+0x6d>
jmp    1264 <AddDynamicTree+0xc4>
xor    %eax,%eax
cmpl   $0x0,-0x60(%rbp)
mov    %al,-0x212(%rbp)
jbe    1292 <AddDynamicTree+0xf2>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
cmpl   $0x0,(%rax,%rcx,4)
sete   %al
mov    %al,-0x212(%rbp)
mov    -0x212(%rbp),%al
test   $0x1,%al
jne    12a5 <AddDynamicTree+0x105>
jmp    12b3 <AddDynamicTree+0x113>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
jmp    1264 <AddDynamicTree+0xc4>
mov    -0x5c(%rbp),%eax
add    $0x101,%eax
add    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    12eb <AddDynamicTree+0x14b>
mov    $0xffffffff,%edi
call   10b0 <exit@plt>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
cmp    %rcx,%rax
jae    138a <AddDynamicTree+0x1ea>
mov    -0x70(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x101,%ecx
mov    %ecx,%ecx
cmp    %rcx,%rax
jae    1331 <AddDynamicTree+0x191>
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x218(%rbp)
jmp    134f <AddDynamicTree+0x1af>
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    $0x101,%rcx
mov    -0x5c(%rbp),%edx
sub    %rdx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x218(%rbp)
mov    -0x218(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x10,(%rax,%rcx,4)
setb   %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    12f3 <AddDynamicTree+0x153>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
cmp    %rcx,%rax
jae    1c46 <AddDynamicTree+0xaa6>
movq   $0x0,-0x208(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    %eax,%edx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x219(%rbp)
jae    13ee <AddDynamicTree+0x24e>
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
mov    -0x78(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
sete   %al
mov    %al,-0x219(%rbp)
mov    -0x219(%rbp),%al
test   $0x1,%al
jne    1401 <AddDynamicTree+0x261>
jmp    1424 <AddDynamicTree+0x284>
mov    -0x208(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x208(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    13b5 <AddDynamicTree+0x215>
cmpq   $0x4,-0x208(%rbp)
04
jae    1452 <AddDynamicTree+0x2b2>
cmpq   $0x3,-0x208(%rbp)
03
jb     1b19 <AddDynamicTree+0x979>
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1b19 <AddDynamicTree+0x979>
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    169a <AddDynamicTree+0x4fa>
cmpq   $0xa,-0x208(%rbp)
0a
jbe    1594 <AddDynamicTree+0x3f4>
cmpq   $0x8a,-0x208(%rbp)
jbe    148e <AddDynamicTree+0x2ee>
movq   $0x8a,-0x208(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    14ef <AddDynamicTree+0x34f>
cmpq   $0x0,-0x50(%rbp)
jne    14c8 <AddDynamicTree+0x328>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x228(%rbp)
jmp    14e4 <AddDynamicTree+0x344>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x228(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movl   $0x12,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    156b <AddDynamicTree+0x3cb>
cmpq   $0x0,-0x58(%rbp)
jne    1544 <AddDynamicTree+0x3a4>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x230(%rbp)
jmp    1560 <AddDynamicTree+0x3c0>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x230(%rbp)
mov    -0x230(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x208(%rbp),%rax
sub    $0xb,%rax
mov    %eax,%edx
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1695 <AddDynamicTree+0x4f5>
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    15f5 <AddDynamicTree+0x455>
cmpq   $0x0,-0x50(%rbp)
jne    15ce <AddDynamicTree+0x42e>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x238(%rbp)
jmp    15ea <AddDynamicTree+0x44a>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x238(%rbp)
mov    -0x238(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movl   $0x11,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1671 <AddDynamicTree+0x4d1>
cmpq   $0x0,-0x58(%rbp)
jne    164a <AddDynamicTree+0x4aa>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x240(%rbp)
jmp    1666 <AddDynamicTree+0x4c6>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x240(%rbp)
mov    -0x240(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x208(%rbp),%rax
sub    $0x3,%rax
mov    %eax,%edx
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1b01 <AddDynamicTree+0x961>
mov    -0x208(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x20c(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    170c <AddDynamicTree+0x56c>
cmpq   $0x0,-0x50(%rbp)
jne    16e5 <AddDynamicTree+0x545>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x248(%rbp)
jmp    1701 <AddDynamicTree+0x561>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x248(%rbp)
mov    -0x248(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    178f <AddDynamicTree+0x5ef>
cmpq   $0x0,-0x58(%rbp)
jne    1768 <AddDynamicTree+0x5c8>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x250(%rbp)
jmp    1784 <AddDynamicTree+0x5e4>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x250(%rbp)
mov    -0x250(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x6,-0x20c(%rbp)
jb     18c3 <AddDynamicTree+0x723>
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1818 <AddDynamicTree+0x678>
cmpq   $0x0,-0x50(%rbp)
jne    17f1 <AddDynamicTree+0x651>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x258(%rbp)
jmp    180d <AddDynamicTree+0x66d>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x258(%rbp)
mov    -0x258(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movl   $0x10,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1894 <AddDynamicTree+0x6f4>
cmpq   $0x0,-0x58(%rbp)
jne    186d <AddDynamicTree+0x6cd>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x260(%rbp)
jmp    1889 <AddDynamicTree+0x6e9>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x260(%rbp)
mov    -0x260(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x3,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20c(%rbp),%eax
sub    $0x6,%eax
mov    %eax,-0x20c(%rbp)
jmp    17aa <AddDynamicTree+0x60a>
cmpl   $0x3,-0x20c(%rbp)
jb     19d7 <AddDynamicTree+0x837>
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1931 <AddDynamicTree+0x791>
cmpq   $0x0,-0x50(%rbp)
jne    190a <AddDynamicTree+0x76a>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x268(%rbp)
jmp    1926 <AddDynamicTree+0x786>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x268(%rbp)
mov    -0x268(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movl   $0x10,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    19ad <AddDynamicTree+0x80d>
cmpq   $0x0,-0x58(%rbp)
jne    1986 <AddDynamicTree+0x7e6>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x270(%rbp)
jmp    19a2 <AddDynamicTree+0x802>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x270(%rbp)
mov    -0x270(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20c(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x20c(%rbp)
jmp    19dc <AddDynamicTree+0x83c>
cmpl   $0x0,-0x20c(%rbp)
je     1afc <AddDynamicTree+0x95c>
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1a4a <AddDynamicTree+0x8aa>
cmpq   $0x0,-0x50(%rbp)
jne    1a23 <AddDynamicTree+0x883>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x278(%rbp)
jmp    1a3f <AddDynamicTree+0x89f>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x278(%rbp)
mov    -0x278(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1acd <AddDynamicTree+0x92d>
cmpq   $0x0,-0x58(%rbp)
jne    1aa6 <AddDynamicTree+0x906>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x280(%rbp)
jmp    1ac2 <AddDynamicTree+0x922>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x280(%rbp)
mov    -0x280(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20c(%rbp)
jmp    19dc <AddDynamicTree+0x83c>
jmp    1b01 <AddDynamicTree+0x961>
mov    -0x208(%rbp),%rax
sub    $0x1,%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1c18 <AddDynamicTree+0xa78>
mov    -0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1b7a <AddDynamicTree+0x9da>
cmpq   $0x0,-0x50(%rbp)
jne    1b53 <AddDynamicTree+0x9b3>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x288(%rbp)
jmp    1b6f <AddDynamicTree+0x9cf>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x288(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    1bfd <AddDynamicTree+0xa5d>
cmpq   $0x0,-0x58(%rbp)
jne    1bd6 <AddDynamicTree+0xa36>
mov    $0x4,%edi
call   1080 <malloc@plt>
mov    %rax,-0x290(%rbp)
jmp    1bf2 <AddDynamicTree+0xa52>
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
shl    $0x1,%rsi
shl    $0x2,%rsi
call   10a0 <realloc@plt>
mov    %rax,-0x290(%rbp)
mov    -0x290(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
cmpl   $0x12,(%rax,%rcx,4)
setbe  %al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1392 <AddDynamicTree+0x1f2>
movq   $0x0,-0x70(%rbp)
cmpq   $0x13,-0x70(%rbp)
jae    1c7a <AddDynamicTree+0xada>
mov    -0x70(%rbp),%rax
movq   $0x0,-0x110(%rbp,%rax,8)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1c4e <AddDynamicTree+0xaae>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1cc0 <AddDynamicTree+0xb20>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x110(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x110(%rbp,%rax,8)
ff
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1c82 <AddDynamicTree+0xae2>
lea    -0x110(%rbp),%rdi
lea    -0x160(%rbp),%rcx
mov    $0x13,%esi
mov    $0x7,%edx
call   10c0 <CalculateBitLengths@plt>
lea    -0x160(%rbp),%rdi
lea    -0x1b0(%rbp),%rcx
mov    $0x13,%esi
mov    $0x7,%edx
call   1050 <LengthsToSymbols@plt>
movl   $0xf,-0x64(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x64(%rbp)
mov    %al,-0x291(%rbp)
jbe    1d37 <AddDynamicTree+0xb97>
mov    -0x64(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    -0x200(%rbp,%rax,4),%eax
cmpq   $0x0,-0x110(%rbp,%rax,8)
sete   %al
mov    %al,-0x291(%rbp)
mov    -0x291(%rbp),%al
test   $0x1,%al
jne    1d4a <AddDynamicTree+0xbaa>
jmp    1d58 <AddDynamicTree+0xbb8>
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    1d01 <AddDynamicTree+0xb61>
mov    -0x5c(%rbp),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x5,%esi
call   1040 <AddBits@plt>
mov    -0x60(%rbp),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x5,%esi
call   1040 <AddBits@plt>
mov    -0x64(%rbp),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x4,%esi
call   1040 <AddBits@plt>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x4,%ecx
mov    %ecx,%ecx
cmp    %rcx,%rax
jae    1df9 <AddDynamicTree+0xc59>
mov    -0x70(%rbp),%rax
mov    -0x200(%rbp,%rax,4),%eax
mov    -0x160(%rbp,%rax,4),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x3,%esi
call   1040 <AddBits@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1dab <AddDynamicTree+0xc0b>
movq   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1f13 <AddDynamicTree+0xd73>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x1b0(%rbp,%rax,4),%eax
mov    %eax,-0x210(%rbp)
mov    -0x210(%rbp),%edi
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x160(%rbp,%rax,4),%esi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
call   1090 <AddHuffmanBits@plt>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x10,(%rax,%rcx,4)
jne    1e88 <AddDynamicTree+0xce8>
mov    -0x48(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x2,%esi
call   1040 <AddBits@plt>
jmp    1efd <AddDynamicTree+0xd5d>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x11,(%rax,%rcx,4)
jne    1ec0 <AddDynamicTree+0xd20>
mov    -0x48(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x3,%esi
call   1040 <AddBits@plt>
jmp    1ef8 <AddDynamicTree+0xd58>
mov    -0x40(%rbp),%rax
mov    -0x70(%rbp),%rcx
cmpl   $0x12,(%rax,%rcx,4)
jne    1ef3 <AddDynamicTree+0xd53>
mov    -0x48(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x7,%esi
call   1040 <AddBits@plt>
jmp    1ef8 <AddDynamicTree+0xd58>
jmp    1efd <AddDynamicTree+0xd5d>
jmp    1f02 <AddDynamicTree+0xd62>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    1e01 <AddDynamicTree+0xc61>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AddDynamicTree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    $0x1d,%r12d
cmpl   $0x0,0x474(%rdi)
mov    $0x1d,%ebp
jne    138e <AddDynamicTree+0x1fe>
mov    $0x1c,%ebp
cmpl   $0x0,0x470(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x1b,%ebp
cmpl   $0x0,0x46c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x1a,%ebp
cmpl   $0x0,0x468(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x19,%ebp
cmpl   $0x0,0x464(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x18,%ebp
cmpl   $0x0,0x460(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x17,%ebp
cmpl   $0x0,0x45c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x16,%ebp
cmpl   $0x0,0x458(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x15,%ebp
cmpl   $0x0,0x454(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x14,%ebp
cmpl   $0x0,0x450(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x13,%ebp
cmpl   $0x0,0x44c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x12,%ebp
cmpl   $0x0,0x448(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x11,%ebp
cmpl   $0x0,0x444(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x10,%ebp
cmpl   $0x0,0x440(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xf,%ebp
cmpl   $0x0,0x43c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xe,%ebp
cmpl   $0x0,0x438(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xd,%ebp
cmpl   $0x0,0x434(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xc,%ebp
cmpl   $0x0,0x430(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xb,%ebp
cmpl   $0x0,0x42c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0xa,%ebp
cmpl   $0x0,0x428(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x9,%ebp
cmpl   $0x0,0x424(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x8,%ebp
cmpl   $0x0,0x420(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x7,%ebp
cmpl   $0x0,0x41c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x6,%ebp
cmpl   $0x0,0x418(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x5,%ebp
cmpl   $0x0,0x414(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x4,%ebp
cmpl   $0x0,0x410(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x3,%ebp
cmpl   $0x0,0x40c(%rbx)
jne    138e <AddDynamicTree+0x1fe>
mov    $0x2,%ebp
cmpl   $0x0,0x408(%rbx)
jne    138e <AddDynamicTree+0x1fe>
xor    %ebp,%ebp
cmpl   $0x0,0x404(%rbx)
setne  %bpl
cmpl   $0x0,0x74(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x1c,%r12d
cmpl   $0x0,0x70(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x1b,%r12d
cmpl   $0x0,0x6c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x1a,%r12d
cmpl   $0x0,0x68(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x19,%r12d
cmpl   $0x0,0x64(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x18,%r12d
cmpl   $0x0,0x60(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x17,%r12d
cmpl   $0x0,0x5c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x16,%r12d
cmpl   $0x0,0x58(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x15,%r12d
cmpl   $0x0,0x54(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x14,%r12d
cmpl   $0x0,0x50(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x13,%r12d
cmpl   $0x0,0x4c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x12,%r12d
cmpl   $0x0,0x48(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x11,%r12d
cmpl   $0x0,0x44(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x10,%r12d
cmpl   $0x0,0x40(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xf,%r12d
cmpl   $0x0,0x3c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xe,%r12d
cmpl   $0x0,0x38(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xd,%r12d
cmpl   $0x0,0x34(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xc,%r12d
cmpl   $0x0,0x30(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xb,%r12d
cmpl   $0x0,0x2c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0xa,%r12d
cmpl   $0x0,0x28(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x9,%r12d
cmpl   $0x0,0x24(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x8,%r12d
cmpl   $0x0,0x20(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x7,%r12d
cmpl   $0x0,0x1c(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x6,%r12d
cmpl   $0x0,0x18(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x5,%r12d
cmpl   $0x0,0x14(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x4,%r12d
cmpl   $0x0,0x10(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x3,%r12d
cmpl   $0x0,0xc(%r14)
jne    154c <AddDynamicTree+0x3bc>
mov    $0x2,%r12d
cmpl   $0x0,0x8(%r14)
jne    154c <AddDynamicTree+0x3bc>
xor    %r12d,%r12d
cmpl   $0x0,0x4(%r14)
setne  %r12b
mov    %rdx,0x30(%rsp)
mov    %rcx,0x40(%rsp)
mov    %r8,0x58(%rsp)
lea    (%r12,%rbp,1),%eax
lea    0x408(,%rax,4),%edi
call   1070 <malloc@plt>
mov    %rax,0x28(%rsp)
test   %rax,%rax
je     1fbd <AddDynamicTree+0xe2d>
lea    (%r12,%rbp,1),%eax
add    $0x102,%eax
mov    %rax,0x18(%rsp)
lea    0x101(%rbp),%r13d
mov    %rbp,0x48(%rsp)
mov    %ebp,%eax
mov    %r12,0x50(%rsp)
mov    %r12d,%ecx
mov    %rcx,0x20(%rsp)
lea    (%rcx,%rax,1),%r12
add    $0x102,%r12
mov    %rax,0x10(%rsp)
xor    $0xfffffffffffffeff,%rax
lea    (%r14,%rax,4),%rbp
xor    %r14d,%r14d
mov    0x28(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r13,%r14
mov    %rbp,%rax
cmovb  %rbx,%rax
mov    (%rax),%eax
mov    %eax,(%r15,%r14,4)
xor    %edi,%edi
cmp    $0x10,%eax
setb   %dil
call   1060 <assert@plt>
add    $0x1,%r14
add    $0x4,%rbx
add    $0x4,%rbp
cmp    %r14,%r12
jne    15d0 <AddDynamicTree+0x440>
mov    %r15,%rax
add    $0x4,%rax
mov    %rax,0x68(%rsp)
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%rcx
add    %rcx,%rax
add    $0x101,%rax
mov    %rax,0x60(%rsp)
xor    %r12d,%r12d
xor    %r10d,%r10d
xor    %r14d,%r14d
xor    %r8d,%r8d
xor    %r9d,%r9d
mov    0x40(%rsp),%r13
mov    0x18(%rsp),%rbx
jmp    16a4 <AddDynamicTree+0x514>
xchg   %ax,%ax
lea    0x0(,%r10,8),%rsi
mov    %r8,%rdi
call   1090 <realloc@plt>
mov    0x8(%rsp),%r10
mov    %rax,%r8
mov    %rbx,%r9
mov    0x18(%rsp),%rbx
add    $0x1,%r14
mov    %r8,0x20(%rsp)
movl   $0x0,(%r8,%r10,4)
add    $0x1,%r10
mov    %r10,%rbp
xor    %edi,%edi
cmpl   $0x13,-0x4(%r9,%r14,4)
setb   %dil
mov    %r9,%r15
call   1060 <assert@plt>
mov    %r15,%r9
add    $0x1,%r12
cmp    %rbx,%r12
mov    0x20(%rsp),%r8
mov    %rbp,%r10
jae    1c4e <AddDynamicTree+0xabe>
mov    %r12,0x10(%rsp)
cmp    %rbx,%r12
mov    %r10,0x8(%rsp)
jae    1770 <AddDynamicTree+0x5e0>
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%rax
mov    (%rax,%rdi,4),%ecx
mov    %rbx,%rax
sub    %rdi,%rax
mov    0x68(%rsp),%rdx
lea    (%rdx,%rdi,4),%rdx
mov    0x60(%rsp),%rsi
sub    %rdi,%rsi
xor    %edi,%edi
nopl   (%rax)
cmp    %rdi,%rsi
je     1700 <AddDynamicTree+0x570>
lea    0x1(%rdi),%rbp
cmp    (%rdx,%rdi,4),%ecx
mov    %rbp,%rdi
je     16e0 <AddDynamicTree+0x550>
jmp    1703 <AddDynamicTree+0x573>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rbp
cmp    $0x3,%rbp
mov    %r14,%r12
jbe    1750 <AddDynamicTree+0x5c0>
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     17f6 <AddDynamicTree+0x666>
lea    -0x1(%r14),%rax
test   %rax,%r14
jne    1887 <AddDynamicTree+0x6f7>
mov    %r8,%rbx
test   %r14,%r14
je     186d <AddDynamicTree+0x6dd>
lea    0x0(,%r14,8),%rsi
mov    %r9,%rdi
call   1090 <realloc@plt>
jmp    1877 <AddDynamicTree+0x6e7>
xchg   %ax,%ax
jne    1770 <AddDynamicTree+0x5e0>
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     183a <AddDynamicTree+0x6aa>
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%r14),%rax
test   %rax,%r14
jne    17a0 <AddDynamicTree+0x610>
mov    %r8,%rbx
test   %r14,%r14
mov    0x10(%rsp),%r12
je     17a7 <AddDynamicTree+0x617>
lea    0x0(,%r14,8),%rsi
mov    %r9,%rdi
call   1090 <realloc@plt>
jmp    17b1 <AddDynamicTree+0x621>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r12
jmp    17c1 <AddDynamicTree+0x631>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %rbx,%r8
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%r10
mov    0x28(%rsp),%rax
mov    (%rax,%r12,4),%eax
mov    %eax,(%r9,%r14,4)
lea    -0x1(%r10),%rax
test   %rax,%r10
jne    1660 <AddDynamicTree+0x4d0>
mov    %r9,%rbx
test   %r10,%r10
jne    1640 <AddDynamicTree+0x4b0>
mov    $0x4,%edi
call   1070 <malloc@plt>
jmp    1650 <AddDynamicTree+0x4c0>
cmp    $0xb,%rbp
jb     183f <AddDynamicTree+0x6af>
cmp    $0x8a,%rbp
mov    $0x8a,%eax
cmovae %rax,%rbp
lea    -0x1(%r14),%rax
test   %rax,%r14
jne    1bd1 <AddDynamicTree+0xa41>
mov    %r8,%rbx
test   %r14,%r14
je     1bbc <AddDynamicTree+0xa2c>
lea    0x0(,%r14,8),%rsi
mov    %r9,%rdi
call   1090 <realloc@plt>
jmp    1bc6 <AddDynamicTree+0xa36>
mov    $0x3,%ebp
lea    -0x1(%r14),%rax
test   %rax,%r14
jne    1a5b <AddDynamicTree+0x8cb>
mov    %r8,%rbx
test   %r14,%r14
je     1a46 <AddDynamicTree+0x8b6>
lea    0x0(,%r14,8),%rsi
mov    %r9,%rdi
call   1090 <realloc@plt>
jmp    1a50 <AddDynamicTree+0x8c0>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %rbx,%r8
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%r10
lea    -0x1(%rbp),%r13d
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %eax,(%r9,%r14,4)
lea    -0x1(%r10),%rax
test   %rax,%r10
jne    18d9 <AddDynamicTree+0x749>
mov    %r9,%rbx
test   %r10,%r10
je     18bf <AddDynamicTree+0x72f>
lea    0x0(,%r10,8),%rsi
mov    %r8,%rdi
call   1090 <realloc@plt>
jmp    18c9 <AddDynamicTree+0x739>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    0x8(%rsp),%r10
mov    %rax,%r8
mov    %rbx,%r9
mov    0x18(%rsp),%rbx
mov    %rbp,0x38(%rsp)
movl   $0x0,(%r8,%r10,4)
cmp    $0x6,%r13d
jb     19e0 <AddDynamicTree+0x850>
lea    0x4(,%r14,4),%rax
mov    %rax,0x78(%rsp)
lea    0x8(,%r14,8),%rbx
lea    0x4(,%r10,4),%rax
mov    %rax,0x70(%rsp)
lea    0x8(,%r10,8),%r15
xor    %ebp,%ebp
jmp    1962 <AddDynamicTree+0x7d2>
xchg   %ax,%ax
mov    %r8,%rdi
mov    %r15,%rsi
call   1090 <realloc@plt>
mov    %rax,%r8
mov    %r14,%r9
mov    0x8(%rsp),%r10
mov    0x70(%rsp),%rax
add    %r8,%rax
movl   $0x3,(%rax,%rbp,4)
add    $0xfffffffa,%r13d
add    $0x1,%rbp
add    $0x8,%rbx
add    $0x8,%r15
cmp    $0x5,%r13d
mov    %r12,%r14
jbe    1a01 <AddDynamicTree+0x871>
lea    (%r14,%rbp,1),%rcx
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
lea    (%r10,%rbp,1),%r14
test   %rcx,%rax
jne    19a5 <AddDynamicTree+0x815>
mov    %r8,0x20(%rsp)
test   %rax,%rax
je     198e <AddDynamicTree+0x7fe>
mov    %r9,%rdi
mov    %rbx,%rsi
call   1090 <realloc@plt>
jmp    1998 <AddDynamicTree+0x808>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    0x20(%rsp),%r8
mov    0x8(%rsp),%r10
lea    (%r10,%rbp,1),%rax
add    $0x1,%rax
mov    0x78(%rsp),%rcx
add    %r9,%rcx
movl   $0x10,(%rcx,%rbp,4)
test   %r14,%rax
jne    1936 <AddDynamicTree+0x7a6>
mov    %r9,%r14
test   %rax,%rax
jne    1920 <AddDynamicTree+0x790>
mov    $0x4,%edi
call   1070 <malloc@plt>
jmp    192b <AddDynamicTree+0x79b>
lea    0x1(%r10),%r15
add    $0x1,%r14
cmp    $0x3,%r13d
jae    1a24 <AddDynamicTree+0x894>
mov    0x10(%rsp),%r12
test   %r13d,%r13d
jne    1b06 <AddDynamicTree+0x976>
jmp    1bb5 <AddDynamicTree+0xa25>
mov    %r14,%r12
add    %rbp,%r14
add    $0x1,%r14
add    %rbp,%r12
lea    (%r10,%rbp,1),%r15
add    $0x1,%r15
add    %rbp,%r10
mov    0x18(%rsp),%rbx
cmp    $0x3,%r13d
jb     19ee <AddDynamicTree+0x85e>
test   %r12,%r14
jne    1a92 <AddDynamicTree+0x902>
mov    %r10,%rbp
mov    %r8,%rbx
test   %r14,%r14
je     1a7a <AddDynamicTree+0x8ea>
lea    0x0(,%r14,8),%rsi
mov    %r9,%rdi
call   1090 <realloc@plt>
jmp    1a84 <AddDynamicTree+0x8f4>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %rbx,%r8
mov    0x8(%rsp),%r10
movl   $0x11,(%r9,%r14,4)
lea    -0x1(%r10),%rax
mov    $0xfffffffd,%ebx
test   %rax,%r10
je     1be7 <AddDynamicTree+0xa57>
jmp    1c19 <AddDynamicTree+0xa89>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %rbx,%r8
mov    0x18(%rsp),%rbx
mov    %rbp,%r10
movl   $0x10,(%r9,%r14,4)
test   %r10,%r15
je     1aa9 <AddDynamicTree+0x919>
mov    %r12,%r14
mov    0x10(%rsp),%r12
jmp    1ae6 <AddDynamicTree+0x956>
mov    %r10,%rbp
mov    %r9,%rbx
test   %r15,%r15
mov    %r12,%r14
je     1ac9 <AddDynamicTree+0x939>
lea    0x0(,%r15,8),%rsi
mov    %r8,%rdi
call   1090 <realloc@plt>
jmp    1ad3 <AddDynamicTree+0x943>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r8
mov    %rbx,%r9
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r12
mov    %rbp,%r10
add    $0x2,%r14
movl   $0x0,(%r8,%r15,4)
add    $0x2,%r10
add    $0xfffffffd,%r13d
mov    %r10,%r15
test   %r13d,%r13d
je     1bb5 <AddDynamicTree+0xa25>
lea    0x0(,%r15,8),%rbx
lea    0x0(,%r14,8),%rbp
jmp    1b4b <AddDynamicTree+0x9bb>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r8
mov    %r12,%r9
mov    0x10(%rsp),%r12
movl   $0x0,(%r8,%r15,4)
add    $0x1,%r15
add    $0x8,%rbx
add    $0x8,%rbp
add    $0x1,%r14
add    $0xffffffff,%r13d
je     1bb0 <AddDynamicTree+0xa20>
lea    -0x1(%r14),%rax
test   %rax,%r14
jne    1b7e <AddDynamicTree+0x9ee>
mov    %r8,%r12
test   %r14,%r14
je     1b69 <AddDynamicTree+0x9d9>
mov    %r9,%rdi
mov    %rbp,%rsi
call   1090 <realloc@plt>
jmp    1b73 <AddDynamicTree+0x9e3>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %r12,%r8
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%rax
mov    (%rax,%r12,4),%eax
mov    %eax,(%r9,%r14,4)
lea    -0x1(%r15),%rax
test   %rax,%r15
jne    1b2d <AddDynamicTree+0x99d>
mov    %r9,%r12
test   %r15,%r15
je     1b18 <AddDynamicTree+0x988>
mov    %r8,%rdi
mov    %rbx,%rsi
call   1090 <realloc@plt>
jmp    1b22 <AddDynamicTree+0x992>
mov    0x18(%rsp),%rbx
mov    0x38(%rsp),%rbp
jmp    1c35 <AddDynamicTree+0xaa5>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    %rax,%r9
mov    %rbx,%r8
mov    0x8(%rsp),%r10
movl   $0x12,(%r9,%r14,4)
lea    -0x1(%r10),%rax
mov    $0xfffffff5,%ebx
test   %rax,%r10
jne    1c19 <AddDynamicTree+0xa89>
mov    %r9,%r14
test   %r10,%r10
je     1c01 <AddDynamicTree+0xa71>
lea    0x0(,%r10,8),%rsi
mov    %r8,%rdi
call   1090 <realloc@plt>
jmp    1c0b <AddDynamicTree+0xa7b>
mov    $0x4,%edi
call   1070 <malloc@plt>
mov    0x8(%rsp),%r10
mov    %rax,%r8
mov    %r14,%r9
mov    %r12,%r14
add    $0x1,%r14
lea    (%rbx,%rbp,1),%eax
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
mov    %r10,%r15
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r12
mov    %r8,0x20(%rsp)
add    %rbp,%r12
add    $0xffffffffffffffff,%r12
mov    %r15,%rbp
mov    0x40(%rsp),%r13
jmp    1678 <AddDynamicTree+0x4e8>
xorps  %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movq   $0x0,0x110(%rsp)
test   %r14,%r14
mov    0x30(%rsp),%r12
je     1d35 <AddDynamicTree+0xba5>
lea    -0x1(%r14),%rcx
mov    %r14d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1cc7 <AddDynamicTree+0xb37>
xor    %ecx,%ecx
jmp    1d10 <AddDynamicTree+0xb80>
mov    %r14,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %ecx,%ecx
mov    (%r9,%rcx,4),%esi
addq   $0x1,0x80(%rsp,%rsi,8)
mov    0x4(%r9,%rcx,4),%esi
addq   $0x1,0x80(%rsp,%rsi,8)
mov    0x8(%r9,%rcx,4),%esi
addq   $0x1,0x80(%rsp,%rsi,8)
mov    0xc(%r9,%rcx,4),%esi
addq   $0x1,0x80(%rsp,%rsi,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1cd0 <AddDynamicTree+0xb40>
test   %rax,%rax
je     1d35 <AddDynamicTree+0xba5>
lea    (%r9,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,4),%esi
addq   $0x1,0x80(%rsp,%rsi,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1d20 <AddDynamicTree+0xb90>
mov    %r14,0x10(%rsp)
lea    0x80(%rsp),%rdi
lea    0x120(%rsp),%rbx
mov    $0x13,%esi
mov    $0x7,%edx
mov    %rbx,%rcx
call   10b0 <CalculateBitLengths@plt>
lea    0x170(%rsp),%rcx
mov    %rbx,%rdi
mov    $0x13,%esi
mov    $0x7,%edx
call   1050 <LengthsToSymbols@plt>
mov    $0xf,%ebx
cmpq   $0x0,0xf8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0xe,%ebx
cmpq   $0x0,0x88(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0xd,%ebx
cmpq   $0x0,0xf0(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0xc,%ebx
cmpq   $0x0,0x90(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0xb,%ebx
cmpq   $0x0,0xe8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0xa,%ebx
cmpq   $0x0,0x98(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x9,%ebx
cmpq   $0x0,0xe0(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x8,%ebx
cmpq   $0x0,0xa0(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x7,%ebx
cmpq   $0x0,0xd8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x6,%ebx
cmpq   $0x0,0xa8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x5,%ebx
cmpq   $0x0,0xd0(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x4,%ebx
cmpq   $0x0,0xb0(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x3,%ebx
cmpq   $0x0,0xc8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
mov    $0x2,%ebx
cmpq   $0x0,0xb8(%rsp)
jne    1e7c <AddDynamicTree+0xcec>
xor    %ebx,%ebx
cmpq   $0x0,0xc0(%rsp)
setne  %bl
mov    0x48(%rsp),%rdi
mov    $0x5,%esi
mov    %r12,%rdx
mov    %r13,%r14
mov    %r13,%rcx
mov    0x58(%rsp),%r13
mov    %r13,%r8
call   1040 <AddBits@plt>
mov    0x50(%rsp),%rdi
mov    $0x5,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   1040 <AddBits@plt>
mov    %ebx,%edi
mov    $0x4,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   1040 <AddBits@plt>
mov    %ebx,%eax
lea    0x10(,%rax,4),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x119(%rip),%rax
mov    0x0(%rbp,%rax,1),%eax
mov    0x120(%rsp,%rax,4),%edi
mov    $0x3,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   1040 <AddBits@plt>
add    $0x4,%rbp
cmp    %rbp,%rbx
jne    1ee0 <AddDynamicTree+0xd50>
mov    0x10(%rsp),%r12
test   %r12,%r12
mov    %r15,%rcx
je     1f8c <AddDynamicTree+0xdfc>
xor    %ebx,%ebx
lea    0x128(%rip),%rbp
jmp    1f39 <AddDynamicTree+0xda9>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r12
je     1f8c <AddDynamicTree+0xdfc>
mov    (%rcx,%rbx,4),%eax
mov    0x170(%rsp,%rax,4),%edi
mov    0x120(%rsp,%rax,4),%esi
mov    0x30(%rsp),%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   1080 <AddHuffmanBits@plt>
mov    %r15,%rcx
mov    (%r15,%rbx,4),%eax
add    $0xfffffff0,%eax
cmp    $0x2,%eax
ja     1f30 <AddDynamicTree+0xda0>
cltq
mov    0x0(%rbp,%rax,4),%esi
mov    0x20(%rsp),%rax
mov    (%rax,%rbx,4),%edi
mov    0x30(%rsp),%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   1040 <AddBits@plt>
mov    %r15,%rcx
jmp    1f30 <AddDynamicTree+0xda0>
mov    0x28(%rsp),%rdi
mov    %rcx,%rbx
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%edi
call   10a0 <exit@plt>

LLVM IR (-O0):
@__const.AddDynamicTree.order = [19 x i32] [i32 16, i32 17, i32 18, i32 0, i32 8, i32 7, i32 9, i32 6, i32 10, i32 5, i32 11, i32 4, i32 12, i32 3, i32 13, i32 2, i32 14, i32 1, i32 15]
define void @AddDynamicTree(i32* %0, i32* %1, i8* %2, i8** %3, i64* %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i8*
%9 = alloca i8**
%10 = alloca i64*
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i64
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i64
%21 = alloca i64
%22 = alloca [19 x i64]
%23 = alloca [19 x i32]
%24 = alloca [19 x i32]
%25 = alloca [19 x i32]
%26 = alloca i64
%27 = alloca i32
%28 = alloca i32
store i32* %0, i32** %6
store i32* %1, i32** %7
store i8* %2, i8** %8
store i8** %3, i8*** %9
store i64* %4, i64** %10
store i32* null, i32** %11
store i32* null, i32** %13
store i32* null, i32** %14
store i64 0, i64* %15
store i64 0, i64* %16
store i32 29, i32* %17
store i32 29, i32* %18
%29 = bitcast [19 x i32]* %25 to i8*
br label %30
30: ; preds = %44, %5
%31 = load i32, i32* %17
%32 = icmp ugt i32 %31, 0
br i1 %32, label %33, label %42
33: ; preds = %30
%34 = load i32*, i32** %6
%35 = load i32, i32* %17
%36 = add i32 257, %35
%37 = sub i32 %36, 1
%38 = zext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %34, i64 %38
%40 = load i32, i32* %39
%41 = icmp eq i32 %40, 0
br label %42
42: ; preds = %33, %30
%43 = phi i1 [ false, %30 ], [ %41, %33 ]
br i1 %43, label %44, label %47
44: ; preds = %42
%45 = load i32, i32* %17
%46 = add i32 %45, -1
store i32 %46, i32* %17
br label %30
47: ; preds = %42
br label %48
48: ; preds = %62, %47
%49 = load i32, i32* %18
%50 = icmp ugt i32 %49, 0
br i1 %50, label %51, label %60
51: ; preds = %48
%52 = load i32*, i32** %7
%53 = load i32, i32* %18
%54 = add i32 1, %53
%55 = sub i32 %54, 1
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %52, i64 %56
%58 = load i32, i32* %57
%59 = icmp eq i32 %58, 0
br label %60
60: ; preds = %51, %48
%61 = phi i1 [ false, %48 ], [ %59, %51 ]
br i1 %61, label %62, label %65
62: ; preds = %60
%63 = load i32, i32* %18
%64 = add i32 %63, -1
store i32 %64, i32* %18
br label %48
65: ; preds = %60
%66 = load i32, i32* %17
%67 = add i32 %66, 257
%68 = load i32, i32* %18
%69 = add i32 %67, %68
%70 = add i32 %69, 1
store i32 %70, i32* %12
%71 = load i32, i32* %12
%72 = zext i32 %71 to i64
%73 = mul i64 4, %72
%74 = trunc i64 %73 to i32
%75 = call i32* @malloc(i32 %74)
store i32* %75, i32** %11
%76 = load i32*, i32** %11
%77 = icmp ne i32* %76, null
br i1 %77, label %80, label %78
78: ; preds = %65
%79 = call i32 @exit(i32 -1)
unreachable
80: ; preds = %65
store i64 0, i64* %20
br label %81
81: ; preds = %118, %80
%82 = load i64, i64* %20
%83 = load i32, i32* %12
%84 = zext i32 %83 to i64
%85 = icmp ult i64 %82, %84
br i1 %85, label %86, label %121
86: ; preds = %81
%87 = load i64, i64* %20
%88 = load i32, i32* %17
%89 = add i32 257, %88
%90 = zext i32 %89 to i64
%91 = icmp ult i64 %87, %90
br i1 %91, label %92, label %97
92: ; preds = %86
%93 = load i32*, i32** %6
%94 = load i64, i64* %20
%95 = getelementptr inbounds i32, i32* %93, i64 %94
%96 = load i32, i32* %95
br label %106
97: ; preds = %86
%98 = load i32*, i32** %7
%99 = load i64, i64* %20
%100 = sub i64 %99, 257
%101 = load i32, i32* %17
%102 = zext i32 %101 to i64
%103 = sub i64 %100, %102
%104 = getelementptr inbounds i32, i32* %98, i64 %103
%105 = load i32, i32* %104
br label %106
106: ; preds = %97, %92
%107 = phi i32 [ %96, %92 ], [ %105, %97 ]
%108 = load i32*, i32** %11
%109 = load i64, i64* %20
%110 = getelementptr inbounds i32, i32* %108, i64 %109
store i32 %107, i32* %110
%111 = load i32*, i32** %11
%112 = load i64, i64* %20
%113 = getelementptr inbounds i32, i32* %111, i64 %112
%114 = load i32, i32* %113
%115 = icmp ult i32 %114, 16
%116 = zext i1 %115 to i32
%117 = call i32 @assert(i32 %116)
br label %118
118: ; preds = %106
%119 = load i64, i64* %20
%120 = add i64 %119, 1
store i64 %120, i64* %20
br label %81
121: ; preds = %81
store i64 0, i64* %20
br label %122
122: ; preds = %573, %121
%123 = load i64, i64* %20
%124 = load i32, i32* %12
%125 = zext i32 %124 to i64
%126 = icmp ult i64 %123, %125
br i1 %126, label %127, label %576
127: ; preds = %122
store i64 0, i64* %26
%128 = load i64, i64* %20
store i64 %128, i64* %21
br label %129
129: ; preds = %149, %127
%130 = load i64, i64* %21
%131 = load i32, i32* %12
%132 = zext i32 %131 to i64
%133 = icmp ult i64 %130, %132
br i1 %133, label %134, label %144
134: ; preds = %129
%135 = load i32*, i32** %11
%136 = load i64, i64* %20
%137 = getelementptr inbounds i32, i32* %135, i64 %136
%138 = load i32, i32* %137
%139 = load i32*, i32** %11
%140 = load i64, i64* %21
%141 = getelementptr inbounds i32, i32* %139, i64 %140
%142 = load i32, i32* %141
%143 = icmp eq i32 %138, %142
br label %144
144: ; preds = %134, %129
%145 = phi i1 [ false, %129 ], [ %143, %134 ]
br i1 %145, label %146, label %152
146: ; preds = %144
%147 = load i64, i64* %26
%148 = add i64 %147, 1
store i64 %148, i64* %26
br label %149
149: ; preds = %146
%150 = load i64, i64* %21
%151 = add i64 %150, 1
store i64 %151, i64* %21
br label %129
152: ; preds = %144
%153 = load i64, i64* %26
%154 = icmp uge i64 %153, 4
br i1 %154, label %164, label %155
155: ; preds = %152
%156 = load i64, i64* %26
%157 = icmp uge i64 %156, 3
br i1 %157, label %158, label %511
158: ; preds = %155
%159 = load i32*, i32** %11
%160 = load i64, i64* %20
%161 = getelementptr inbounds i32, i32* %159, i64 %160
%162 = load i32, i32* %161
%163 = icmp eq i32 %162, 0
br i1 %163, label %164, label %511
164: ; preds = %158, %152
%165 = load i32*, i32** %11
%166 = load i64, i64* %20
%167 = getelementptr inbounds i32, i32* %165, i64 %166
%168 = load i32, i32* %167
%169 = icmp eq i32 %168, 0
br i1 %169, label %170, label %282
170: ; preds = %164
%171 = load i64, i64* %26
%172 = icmp ugt i64 %171, 10
br i1 %172, label %173, label %229
173: ; preds = %170
%174 = load i64, i64* %26
%175 = icmp ugt i64 %174, 138
br i1 %175, label %176, label %177
176: ; preds = %173
store i64 138, i64* %26
br label %177
177: ; preds = %176, %173
%178 = load i64, i64* %15
%179 = load i64, i64* %15
%180 = sub i64 %179, 1
%181 = and i64 %178, %180
%182 = icmp ne i64 %181, 0
br i1 %182, label %196, label %183
183: ; preds = %177
%184 = load i64, i64* %15
%185 = icmp eq i64 %184, 0
br i1 %185, label %186, label %188
186: ; preds = %183
%187 = call i32* @malloc(i32 4)
br label %194
188: ; preds = %183
%189 = load i32*, i32** %13
%190 = load i64, i64* %15
%191 = mul i64 %190, 2
%192 = mul i64 %191, 4
%193 = call i32* @realloc(i32* %189, i64 %192)
br label %194
194: ; preds = %188, %186
%195 = phi i32* [ %187, %186 ], [ %193, %188 ]
store i32* %195, i32** %13
br label %196
196: ; preds = %194, %177
%197 = load i32*, i32** %13
%198 = load i64, i64* %15
%199 = getelementptr inbounds i32, i32* %197, i64 %198
store i32 18, i32* %199
%200 = load i64, i64* %15
%201 = add i64 %200, 1
store i64 %201, i64* %15
%202 = load i64, i64* %16
%203 = load i64, i64* %16
%204 = sub i64 %203, 1
%205 = and i64 %202, %204
%206 = icmp ne i64 %205, 0
br i1 %206, label %220, label %207
207: ; preds = %196
%208 = load i64, i64* %16
%209 = icmp eq i64 %208, 0
br i1 %209, label %210, label %212
210: ; preds = %207
%211 = call i32* @malloc(i32 4)
br label %218
212: ; preds = %207
%213 = load i32*, i32** %14
%214 = load i64, i64* %16
%215 = mul i64 %214, 2
%216 = mul i64 %215, 4
%217 = call i32* @realloc(i32* %213, i64 %216)
br label %218
218: ; preds = %212, %210
%219 = phi i32* [ %211, %210 ], [ %217, %212 ]
store i32* %219, i32** %14
br label %220
220: ; preds = %218, %196
%221 = load i64, i64* %26
%222 = sub i64 %221, 11
%223 = trunc i64 %222 to i32
%224 = load i32*, i32** %14
%225 = load i64, i64* %16
%226 = getelementptr inbounds i32, i32* %224, i64 %225
store i32 %223, i32* %226
%227 = load i64, i64* %16
%228 = add i64 %227, 1
store i64 %228, i64* %16
br label %281
229: ; preds = %170
%230 = load i64, i64* %15
%231 = load i64, i64* %15
%232 = sub i64 %231, 1
%233 = and i64 %230, %232
%234 = icmp ne i64 %233, 0
br i1 %234, label %248, label %235
235: ; preds = %229
%236 = load i64, i64* %15
%237 = icmp eq i64 %236, 0
br i1 %237, label %238, label %240
238: ; preds = %235
%239 = call i32* @malloc(i32 4)
br label %246
240: ; preds = %235
%241 = load i32*, i32** %13
%242 = load i64, i64* %15
%243 = mul i64 %242, 2
%244 = mul i64 %243, 4
%245 = call i32* @realloc(i32* %241, i64 %244)
br label %246
246: ; preds = %240, %238
%247 = phi i32* [ %239, %238 ], [ %245, %240 ]
store i32* %247, i32** %13
br label %248
248: ; preds = %246, %229
%249 = load i32*, i32** %13
%250 = load i64, i64* %15
%251 = getelementptr inbounds i32, i32* %249, i64 %250
store i32 17, i32* %251
%252 = load i64, i64* %15
%253 = add i64 %252, 1
store i64 %253, i64* %15
%254 = load i64, i64* %16
%255 = load i64, i64* %16
%256 = sub i64 %255, 1
%257 = and i64 %254, %256
%258 = icmp ne i64 %257, 0
br i1 %258, label %272, label %259
259: ; preds = %248
%260 = load i64, i64* %16
%261 = icmp eq i64 %260, 0
br i1 %261, label %262, label %264
262: ; preds = %259
%263 = call i32* @malloc(i32 4)
br label %270
264: ; preds = %259
%265 = load i32*, i32** %14
%266 = load i64, i64* %16
%267 = mul i64 %266, 2
%268 = mul i64 %267, 4
%269 = call i32* @realloc(i32* %265, i64 %268)
br label %270
270: ; preds = %264, %262
%271 = phi i32* [ %263, %262 ], [ %269, %264 ]
store i32* %271, i32** %14
br label %272
272: ; preds = %270, %248
%273 = load i64, i64* %26
%274 = sub i64 %273, 3
%275 = trunc i64 %274 to i32
%276 = load i32*, i32** %14
%277 = load i64, i64* %16
%278 = getelementptr inbounds i32, i32* %276, i64 %277
store i32 %275, i32* %278
%279 = load i64, i64* %16
%280 = add i64 %279, 1
store i64 %280, i64* %16
br label %281
281: ; preds = %272, %220
br label %506
282: ; preds = %164
%283 = load i64, i64* %26
%284 = sub i64 %283, 1
%285 = trunc i64 %284 to i32
store i32 %285, i32* %27
%286 = load i64, i64* %15
%287 = load i64, i64* %15
%288 = sub i64 %287, 1
%289 = and i64 %286, %288
%290 = icmp ne i64 %289, 0
br i1 %290, label %304, label %291
291: ; preds = %282
%292 = load i64, i64* %15
%293 = icmp eq i64 %292, 0
br i1 %293, label %294, label %296
294: ; preds = %291
%295 = call i32* @malloc(i32 4)
br label %302
296: ; preds = %291
%297 = load i32*, i32** %13
%298 = load i64, i64* %15
%299 = mul i64 %298, 2
%300 = mul i64 %299, 4
%301 = call i32* @realloc(i32* %297, i64 %300)
br label %302
302: ; preds = %296, %294
%303 = phi i32* [ %295, %294 ], [ %301, %296 ]
store i32* %303, i32** %13
br label %304
304: ; preds = %302, %282
%305 = load i32*, i32** %11
%306 = load i64, i64* %20
%307 = getelementptr inbounds i32, i32* %305, i64 %306
%308 = load i32, i32* %307
%309 = load i32*, i32** %13
%310 = load i64, i64* %15
%311 = getelementptr inbounds i32, i32* %309, i64 %310
store i32 %308, i32* %311
%312 = load i64, i64* %15
%313 = add i64 %312, 1
store i64 %313, i64* %15
%314 = load i64, i64* %16
%315 = load i64, i64* %16
%316 = sub i64 %315, 1
%317 = and i64 %314, %316
%318 = icmp ne i64 %317, 0
br i1 %318, label %332, label %319
319: ; preds = %304
%320 = load i64, i64* %16
%321 = icmp eq i64 %320, 0
br i1 %321, label %322, label %324
322: ; preds = %319
%323 = call i32* @malloc(i32 4)
br label %330
324: ; preds = %319
%325 = load i32*, i32** %14
%326 = load i64, i64* %16
%327 = mul i64 %326, 2
%328 = mul i64 %327, 4
%329 = call i32* @realloc(i32* %325, i64 %328)
br label %330
330: ; preds = %324, %322
%331 = phi i32* [ %323, %322 ], [ %329, %324 ]
store i32* %331, i32** %14
br label %332
332: ; preds = %330, %304
%333 = load i32*, i32** %14
%334 = load i64, i64* %16
%335 = getelementptr inbounds i32, i32* %333, i64 %334
store i32 0, i32* %335
%336 = load i64, i64* %16
%337 = add i64 %336, 1
store i64 %337, i64* %16
br label %338
338: ; preds = %384, %332
%339 = load i32, i32* %27
%340 = icmp uge i32 %339, 6
br i1 %340, label %341, label %392
341: ; preds = %338
%342 = load i64, i64* %15
%343 = load i64, i64* %15
%344 = sub i64 %343, 1
%345 = and i64 %342, %344
%346 = icmp ne i64 %345, 0
br i1 %346, label %360, label %347
347: ; preds = %341
%348 = load i64, i64* %15
%349 = icmp eq i64 %348, 0
br i1 %349, label %350, label %352
350: ; preds = %347
%351 = call i32* @malloc(i32 4)
br label %358
352: ; preds = %347
%353 = load i32*, i32** %13
%354 = load i64, i64* %15
%355 = mul i64 %354, 2
%356 = mul i64 %355, 4
%357 = call i32* @realloc(i32* %353, i64 %356)
br label %358
358: ; preds = %352, %350
%359 = phi i32* [ %351, %350 ], [ %357, %352 ]
store i32* %359, i32** %13
br label %360
360: ; preds = %358, %341
%361 = load i32*, i32** %13
%362 = load i64, i64* %15
%363 = getelementptr inbounds i32, i32* %361, i64 %362
store i32 16, i32* %363
%364 = load i64, i64* %15
%365 = add i64 %364, 1
store i64 %365, i64* %15
%366 = load i64, i64* %16
%367 = load i64, i64* %16
%368 = sub i64 %367, 1
%369 = and i64 %366, %368
%370 = icmp ne i64 %369, 0
br i1 %370, label %384, label %371
371: ; preds = %360
%372 = load i64, i64* %16
%373 = icmp eq i64 %372, 0
br i1 %373, label %374, label %376
374: ; preds = %371
%375 = call i32* @malloc(i32 4)
br label %382
376: ; preds = %371
%377 = load i32*, i32** %14
%378 = load i64, i64* %16
%379 = mul i64 %378, 2
%380 = mul i64 %379, 4
%381 = call i32* @realloc(i32* %377, i64 %380)
br label %382
382: ; preds = %376, %374
%383 = phi i32* [ %375, %374 ], [ %381, %376 ]
store i32* %383, i32** %14
br label %384
384: ; preds = %382, %360
%385 = load i32*, i32** %14
%386 = load i64, i64* %16
%387 = getelementptr inbounds i32, i32* %385, i64 %386
store i32 3, i32* %387
%388 = load i64, i64* %16
%389 = add i64 %388, 1
store i64 %389, i64* %16
%390 = load i32, i32* %27
%391 = sub i32 %390, 6
store i32 %391, i32* %27
br label %338
392: ; preds = %338
%393 = load i32, i32* %27
%394 = icmp uge i32 %393, 3
br i1 %394, label %395, label %446
395: ; preds = %392
%396 = load i64, i64* %15
%397 = load i64, i64* %15
%398 = sub i64 %397, 1
%399 = and i64 %396, %398
%400 = icmp ne i64 %399, 0
br i1 %400, label %414, label %401
401: ; preds = %395
%402 = load i64, i64* %15
%403 = icmp eq i64 %402, 0
br i1 %403, label %404, label %406
404: ; preds = %401
%405 = call i32* @malloc(i32 4)
br label %412
406: ; preds = %401
%407 = load i32*, i32** %13
%408 = load i64, i64* %15
%409 = mul i64 %408, 2
%410 = mul i64 %409, 4
%411 = call i32* @realloc(i32* %407, i64 %410)
br label %412
412: ; preds = %406, %404
%413 = phi i32* [ %405, %404 ], [ %411, %406 ]
store i32* %413, i32** %13
br label %414
414: ; preds = %412, %395
%415 = load i32*, i32** %13
%416 = load i64, i64* %15
%417 = getelementptr inbounds i32, i32* %415, i64 %416
store i32 16, i32* %417
%418 = load i64, i64* %15
%419 = add i64 %418, 1
store i64 %419, i64* %15
%420 = load i64, i64* %16
%421 = load i64, i64* %16
%422 = sub i64 %421, 1
%423 = and i64 %420, %422
%424 = icmp ne i64 %423, 0
br i1 %424, label %438, label %425
425: ; preds = %414
%426 = load i64, i64* %16
%427 = icmp eq i64 %426, 0
br i1 %427, label %428, label %430
428: ; preds = %425
%429 = call i32* @malloc(i32 4)
br label %436
430: ; preds = %425
%431 = load i32*, i32** %14
%432 = load i64, i64* %16
%433 = mul i64 %432, 2
%434 = mul i64 %433, 4
%435 = call i32* @realloc(i32* %431, i64 %434)
br label %436
436: ; preds = %430, %428
%437 = phi i32* [ %429, %428 ], [ %435, %430 ]
store i32* %437, i32** %14
br label %438
438: ; preds = %436, %414
%439 = load i32*, i32** %14
%440 = load i64, i64* %16
%441 = getelementptr inbounds i32, i32* %439, i64 %440
store i32 0, i32* %441
%442 = load i64, i64* %16
%443 = add i64 %442, 1
store i64 %443, i64* %16
%444 = load i32, i32* %27
%445 = sub i32 %444, 3
store i32 %445, i32* %27
br label %446
446: ; preds = %438, %392
br label %447
447: ; preds = %497, %446
%448 = load i32, i32* %27
%449 = icmp ne i32 %448, 0
br i1 %449, label %450, label %505
450: ; preds = %447
%451 = load i64, i64* %15
%452 = load i64, i64* %15
%453 = sub i64 %452, 1
%454 = and i64 %451, %453
%455 = icmp ne i64 %454, 0
br i1 %455, label %469, label %456
456: ; preds = %450
%457 = load i64, i64* %15
%458 = icmp eq i64 %457, 0
br i1 %458, label %459, label %461
459: ; preds = %456
%460 = call i32* @malloc(i32 4)
br label %467
461: ; preds = %456
%462 = load i32*, i32** %13
%463 = load i64, i64* %15
%464 = mul i64 %463, 2
%465 = mul i64 %464, 4
%466 = call i32* @realloc(i32* %462, i64 %465)
br label %467
467: ; preds = %461, %459
%468 = phi i32* [ %460, %459 ], [ %466, %461 ]
store i32* %468, i32** %13
br label %469
469: ; preds = %467, %450
%470 = load i32*, i32** %11
%471 = load i64, i64* %20
%472 = getelementptr inbounds i32, i32* %470, i64 %471
%473 = load i32, i32* %472
%474 = load i32*, i32** %13
%475 = load i64, i64* %15
%476 = getelementptr inbounds i32, i32* %474, i64 %475
store i32 %473, i32* %476
%477 = load i64, i64* %15
%478 = add i64 %477, 1
store i64 %478, i64* %15
%479 = load i64, i64* %16
%480 = load i64, i64* %16
%481 = sub i64 %480, 1
%482 = and i64 %479, %481
%483 = icmp ne i64 %482, 0
br i1 %483, label %497, label %484
484: ; preds = %469
%485 = load i64, i64* %16
%486 = icmp eq i64 %485, 0
br i1 %486, label %487, label %489
487: ; preds = %484
%488 = call i32* @malloc(i32 4)
br label %495
489: ; preds = %484
%490 = load i32*, i32** %14
%491 = load i64, i64* %16
%492 = mul i64 %491, 2
%493 = mul i64 %492, 4
%494 = call i32* @realloc(i32* %490, i64 %493)
br label %495
495: ; preds = %489, %487
%496 = phi i32* [ %488, %487 ], [ %494, %489 ]
store i32* %496, i32** %14
br label %497
497: ; preds = %495, %469
%498 = load i32*, i32** %14
%499 = load i64, i64* %16
%500 = getelementptr inbounds i32, i32* %498, i64 %499
store i32 0, i32* %500
%501 = load i64, i64* %16
%502 = add i64 %501, 1
store i64 %502, i64* %16
%503 = load i32, i32* %27
%504 = add i32 %503, -1
store i32 %504, i32* %27
br label %447
505: ; preds = %447
br label %506
506: ; preds = %505, %281
%507 = load i64, i64* %26
%508 = sub i64 %507, 1
%509 = load i64, i64* %20
%510 = add i64 %509, %508
store i64 %510, i64* %20
br label %564
511: ; preds = %158, %155
%512 = load i64, i64* %15
%513 = load i64, i64* %15
%514 = sub i64 %513, 1
%515 = and i64 %512, %514
%516 = icmp ne i64 %515, 0
br i1 %516, label %530, label %517
517: ; preds = %511
%518 = load i64, i64* %15
%519 = icmp eq i64 %518, 0
br i1 %519, label %520, label %522
520: ; preds = %517
%521 = call i32* @malloc(i32 4)
br label %528
522: ; preds = %517
%523 = load i32*, i32** %13
%524 = load i64, i64* %15
%525 = mul i64 %524, 2
%526 = mul i64 %525, 4
%527 = call i32* @realloc(i32* %523, i64 %526)
br label %528
528: ; preds = %522, %520
%529 = phi i32* [ %521, %520 ], [ %527, %522 ]
store i32* %529, i32** %13
br label %530
530: ; preds = %528, %511
%531 = load i32*, i32** %11
%532 = load i64, i64* %20
%533 = getelementptr inbounds i32, i32* %531, i64 %532
%534 = load i32, i32* %533
%535 = load i32*, i32** %13
%536 = load i64, i64* %15
%537 = getelementptr inbounds i32, i32* %535, i64 %536
store i32 %534, i32* %537
%538 = load i64, i64* %15
%539 = add i64 %538, 1
store i64 %539, i64* %15
%540 = load i64, i64* %16
%541 = load i64, i64* %16
%542 = sub i64 %541, 1
%543 = and i64 %540, %542
%544 = icmp ne i64 %543, 0
br i1 %544, label %558, label %545
545: ; preds = %530
%546 = load i64, i64* %16
%547 = icmp eq i64 %546, 0
br i1 %547, label %548, label %550
548: ; preds = %545
%549 = call i32* @malloc(i32 4)
br label %556
550: ; preds = %545
%551 = load i32*, i32** %14
%552 = load i64, i64* %16
%553 = mul i64 %552, 2
%554 = mul i64 %553, 4
%555 = call i32* @realloc(i32* %551, i64 %554)
br label %556
556: ; preds = %550, %548
%557 = phi i32* [ %549, %548 ], [ %555, %550 ]
store i32* %557, i32** %14
br label %558
558: ; preds = %556, %530
%559 = load i32*, i32** %14
%560 = load i64, i64* %16
%561 = getelementptr inbounds i32, i32* %559, i64 %560
store i32 0, i32* %561
%562 = load i64, i64* %16
%563 = add i64 %562, 1
store i64 %563, i64* %16
br label %564
564: ; preds = %558, %506
%565 = load i32*, i32** %13
%566 = load i64, i64* %15
%567 = sub i64 %566, 1
%568 = getelementptr inbounds i32, i32* %565, i64 %567
%569 = load i32, i32* %568
%570 = icmp ule i32 %569, 18
%571 = zext i1 %570 to i32
%572 = call i32 @assert(i32 %571)
br label %573
573: ; preds = %564
%574 = load i64, i64* %20
%575 = add i64 %574, 1
store i64 %575, i64* %20
br label %122
576: ; preds = %122
store i64 0, i64* %20
br label %577
577: ; preds = %583, %576
%578 = load i64, i64* %20
%579 = icmp ult i64 %578, 19
br i1 %579, label %580, label %586
580: ; preds = %577
%581 = load i64, i64* %20
%582 = getelementptr inbounds [19 x i64], [19 x i64]* %22, i64 0, i64 %581
store i64 0, i64* %582
br label %583
583: ; preds = %580
%584 = load i64, i64* %20
%585 = add i64 %584, 1
store i64 %585, i64* %20
br label %577
586: ; preds = %577
store i64 0, i64* %20
br label %587
587: ; preds = %600, %586
%588 = load i64, i64* %20
%589 = load i64, i64* %15
%590 = icmp ult i64 %588, %589
br i1 %590, label %591, label %603
591: ; preds = %587
%592 = load i32*, i32** %13
%593 = load i64, i64* %20
%594 = getelementptr inbounds i32, i32* %592, i64 %593
%595 = load i32, i32* %594
%596 = zext i32 %595 to i64
%597 = getelementptr inbounds [19 x i64], [19 x i64]* %22, i64 0, i64 %596
%598 = load i64, i64* %597
%599 = add i64 %598, 1
store i64 %599, i64* %597
br label %600
600: ; preds = %591
%601 = load i64, i64* %20
%602 = add i64 %601, 1
store i64 %602, i64* %20
br label %587
603: ; preds = %587
%604 = getelementptr inbounds [19 x i64], [19 x i64]* %22, i64 0, i64 0
%605 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%606 = call i32 @CalculateBitLengths(i64* %604, i32 19, i32 7, i32* %605)
%607 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 0
%608 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 0
%609 = call i32 @LengthsToSymbols(i32* %607, i32 19, i32 7, i32* %608)
store i32 15, i32* %19
br label %610
610: ; preds = %626, %603
%611 = load i32, i32* %19
%612 = icmp ugt i32 %611, 0
br i1 %612, label %613, label %624
613: ; preds = %610
%614 = load i32, i32* %19
%615 = add i32 %614, 4
%616 = sub i32 %615, 1
%617 = zext i32 %616 to i64
%618 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 %617
%619 = load i32, i32* %618
%620 = zext i32 %619 to i64
%621 = getelementptr inbounds [19 x i64], [19 x i64]* %22, i64 0, i64 %620
%622 = load i64, i64* %621
%623 = icmp eq i64 %622, 0
br label %624
624: ; preds = %613, %610
%625 = phi i1 [ false, %610 ], [ %623, %613 ]
br i1 %625, label %626, label %629
626: ; preds = %624
%627 = load i32, i32* %19
%628 = add i32 %627, -1
store i32 %628, i32* %19
br label %610
629: ; preds = %624
%630 = load i32, i32* %17
%631 = load i8*, i8** %8
%632 = load i8**, i8*** %9
%633 = load i64*, i64** %10
%634 = call i32 @AddBits(i32 %630, i32 5, i8* %631, i8** %632, i64* %633)
%635 = load i32, i32* %18
%636 = load i8*, i8** %8
%637 = load i8**, i8*** %9
%638 = load i64*, i64** %10
%639 = call i32 @AddBits(i32 %635, i32 5, i8* %636, i8** %637, i64* %638)
%640 = load i32, i32* %19
%641 = load i8*, i8** %8
%642 = load i8**, i8*** %9
%643 = load i64*, i64** %10
%644 = call i32 @AddBits(i32 %640, i32 4, i8* %641, i8** %642, i64* %643)
store i64 0, i64* %20
br label %645
645: ; preds = %662, %629
%646 = load i64, i64* %20
%647 = load i32, i32* %19
%648 = add i32 %647, 4
%649 = zext i32 %648 to i64
%650 = icmp ult i64 %646, %649
br i1 %650, label %651, label %665
651: ; preds = %645
%652 = load i64, i64* %20
%653 = getelementptr inbounds [19 x i32], [19 x i32]* %25, i64 0, i64 %652
%654 = load i32, i32* %653
%655 = zext i32 %654 to i64
%656 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 %655
%657 = load i32, i32* %656
%658 = load i8*, i8** %8
%659 = load i8**, i8*** %9
%660 = load i64*, i64** %10
%661 = call i32 @AddBits(i32 %657, i32 3, i8* %658, i8** %659, i64* %660)
br label %662
662: ; preds = %651
%663 = load i64, i64* %20
%664 = add i64 %663, 1
store i64 %664, i64* %20
br label %645
665: ; preds = %645
store i64 0, i64* %20
br label %666
666: ; preds = %737, %665
%667 = load i64, i64* %20
%668 = load i64, i64* %15
%669 = icmp ult i64 %667, %668
br i1 %669, label %670, label %740
670: ; preds = %666
%671 = load i32*, i32** %13
%672 = load i64, i64* %20
%673 = getelementptr inbounds i32, i32* %671, i64 %672
%674 = load i32, i32* %673
%675 = zext i32 %674 to i64
%676 = getelementptr inbounds [19 x i32], [19 x i32]* %24, i64 0, i64 %675
%677 = load i32, i32* %676
store i32 %677, i32* %28
%678 = load i32, i32* %28
%679 = load i32*, i32** %13
%680 = load i64, i64* %20
%681 = getelementptr inbounds i32, i32* %679, i64 %680
%682 = load i32, i32* %681
%683 = zext i32 %682 to i64
%684 = getelementptr inbounds [19 x i32], [19 x i32]* %23, i64 0, i64 %683
%685 = load i32, i32* %684
%686 = load i8*, i8** %8
%687 = load i8**, i8*** %9
%688 = load i64*, i64** %10
%689 = call i32 @AddHuffmanBits(i32 %678, i32 %685, i8* %686, i8** %687, i64* %688)
%690 = load i32*, i32** %13
%691 = load i64, i64* %20
%692 = getelementptr inbounds i32, i32* %690, i64 %691
%693 = load i32, i32* %692
%694 = icmp eq i32 %693, 16
br i1 %694, label %695, label %704
695: ; preds = %670
%696 = load i32*, i32** %14
%697 = load i64, i64* %20
%698 = getelementptr inbounds i32, i32* %696, i64 %697
%699 = load i32, i32* %698
%700 = load i8*, i8** %8
%701 = load i8**, i8*** %9
%702 = load i64*, i64** %10
%703 = call i32 @AddBits(i32 %699, i32 2, i8* %700, i8** %701, i64* %702)
br label %736
704: ; preds = %670
%705 = load i32*, i32** %13
%706 = load i64, i64* %20
%707 = getelementptr inbounds i32, i32* %705, i64 %706
%708 = load i32, i32* %707
%709 = icmp eq i32 %708, 17
br i1 %709, label %710, label %719
710: ; preds = %704
%711 = load i32*, i32** %14
%712 = load i64, i64* %20
%713 = getelementptr inbounds i32, i32* %711, i64 %712
%714 = load i32, i32* %713
%715 = load i8*, i8** %8
%716 = load i8**, i8*** %9
%717 = load i64*, i64** %10
%718 = call i32 @AddBits(i32 %714, i32 3, i8* %715, i8** %716, i64* %717)
br label %735
719: ; preds = %704
%720 = load i32*, i32** %13
%721 = load i64, i64* %20
%722 = getelementptr inbounds i32, i32* %720, i64 %721
%723 = load i32, i32* %722
%724 = icmp eq i32 %723, 18
br i1 %724, label %725, label %734
725: ; preds = %719
%726 = load i32*, i32** %14
%727 = load i64, i64* %20
%728 = getelementptr inbounds i32, i32* %726, i64 %727
%729 = load i32, i32* %728
%730 = load i8*, i8** %8
%731 = load i8**, i8*** %9
%732 = load i64*, i64** %10
%733 = call i32 @AddBits(i32 %729, i32 7, i8* %730, i8** %731, i64* %732)
br label %734
734: ; preds = %725, %719
br label %735
735: ; preds = %734, %710
br label %736
736: ; preds = %735, %695
br label %737
737: ; preds = %736
%738 = load i64, i64* %20
%739 = add i64 %738, 1
store i64 %739, i64* %20
br label %666
740: ; preds = %666
%741 = load i32*, i32** %11
%742 = call i32 @free(i32* %741)
%743 = load i32*, i32** %13
%744 = call i32 @free(i32* %743)
%745 = load i32*, i32** %14
%746 = call i32 @free(i32* %745)
ret void
}

LLVM IR (-O2):
@__const.AddDynamicTree.order = [19 x i32] [i32 16, i32 17, i32 18, i32 0, i32 8, i32 7, i32 9, i32 6, i32 10, i32 5, i32 11, i32 4, i32 12, i32 3, i32 13, i32 2, i32 14, i32 1, i32 15]
@switch.table.AddDynamicTree = [3 x i32] [i32 2, i32 3, i32 7]
define void @AddDynamicTree(i32* nocapture %0, i32* nocapture %1, i8* %2, i8** %3, i64* %4) {
%6 = alloca [19 x i64]
%7 = bitcast [19 x i64]* %6 to i8*
%8 = alloca [19 x i32]
%9 = alloca [19 x i32]
%10 = bitcast [19 x i32]* %8 to i8*
%11 = bitcast [19 x i32]* %9 to i8*
%12 = getelementptr inbounds i32, i32* %0, i64 285
%13 = load i32, i32* %12
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %128
15: ; preds = %5
%16 = getelementptr inbounds i32, i32* %0, i64 284
%17 = load i32, i32* %16
%18 = icmp eq i32 %17, 0
br i1 %18, label %19, label %128
19: ; preds = %15
%20 = getelementptr inbounds i32, i32* %0, i64 283
%21 = load i32, i32* %20
%22 = icmp eq i32 %21, 0
br i1 %22, label %23, label %128
23: ; preds = %19
%24 = getelementptr inbounds i32, i32* %0, i64 282
%25 = load i32, i32* %24
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %128
27: ; preds = %23
%28 = getelementptr inbounds i32, i32* %0, i64 281
%29 = load i32, i32* %28
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %128
31: ; preds = %27
%32 = getelementptr inbounds i32, i32* %0, i64 280
%33 = load i32, i32* %32
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %128
35: ; preds = %31
%36 = getelementptr inbounds i32, i32* %0, i64 279
%37 = load i32, i32* %36
%38 = icmp eq i32 %37, 0
br i1 %38, label %39, label %128
39: ; preds = %35
%40 = getelementptr inbounds i32, i32* %0, i64 278
%41 = load i32, i32* %40
%42 = icmp eq i32 %41, 0
br i1 %42, label %43, label %128
43: ; preds = %39
%44 = getelementptr inbounds i32, i32* %0, i64 277
%45 = load i32, i32* %44
%46 = icmp eq i32 %45, 0
br i1 %46, label %47, label %128
47: ; preds = %43
%48 = getelementptr inbounds i32, i32* %0, i64 276
%49 = load i32, i32* %48
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %128
51: ; preds = %47
%52 = getelementptr inbounds i32, i32* %0, i64 275
%53 = load i32, i32* %52
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %128
55: ; preds = %51
%56 = getelementptr inbounds i32, i32* %0, i64 274
%57 = load i32, i32* %56
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %128
59: ; preds = %55
%60 = getelementptr inbounds i32, i32* %0, i64 273
%61 = load i32, i32* %60
%62 = icmp eq i32 %61, 0
br i1 %62, label %63, label %128
63: ; preds = %59
%64 = getelementptr inbounds i32, i32* %0, i64 272
%65 = load i32, i32* %64
%66 = icmp eq i32 %65, 0
br i1 %66, label %67, label %128
67: ; preds = %63
%68 = getelementptr inbounds i32, i32* %0, i64 271
%69 = load i32, i32* %68
%70 = icmp eq i32 %69, 0
br i1 %70, label %71, label %128
71: ; preds = %67
%72 = getelementptr inbounds i32, i32* %0, i64 270
%73 = load i32, i32* %72
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %128
75: ; preds = %71
%76 = getelementptr inbounds i32, i32* %0, i64 269
%77 = load i32, i32* %76
%78 = icmp eq i32 %77, 0
br i1 %78, label %79, label %128
79: ; preds = %75
%80 = getelementptr inbounds i32, i32* %0, i64 268
%81 = load i32, i32* %80
%82 = icmp eq i32 %81, 0
br i1 %82, label %83, label %128
83: ; preds = %79
%84 = getelementptr inbounds i32, i32* %0, i64 267
%85 = load i32, i32* %84
%86 = icmp eq i32 %85, 0
br i1 %86, label %87, label %128
87: ; preds = %83
%88 = getelementptr inbounds i32, i32* %0, i64 266
%89 = load i32, i32* %88
%90 = icmp eq i32 %89, 0
br i1 %90, label %91, label %128
91: ; preds = %87
%92 = getelementptr inbounds i32, i32* %0, i64 265
%93 = load i32, i32* %92
%94 = icmp eq i32 %93, 0
br i1 %94, label %95, label %128
95: ; preds = %91
%96 = getelementptr inbounds i32, i32* %0, i64 264
%97 = load i32, i32* %96
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %128
99: ; preds = %95
%100 = getelementptr inbounds i32, i32* %0, i64 263
%101 = load i32, i32* %100
%102 = icmp eq i32 %101, 0
br i1 %102, label %103, label %128
103: ; preds = %99
%104 = getelementptr inbounds i32, i32* %0, i64 262
%105 = load i32, i32* %104
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %128
107: ; preds = %103
%108 = getelementptr inbounds i32, i32* %0, i64 261
%109 = load i32, i32* %108
%110 = icmp eq i32 %109, 0
br i1 %110, label %111, label %128
111: ; preds = %107
%112 = getelementptr inbounds i32, i32* %0, i64 260
%113 = load i32, i32* %112
%114 = icmp eq i32 %113, 0
br i1 %114, label %115, label %128
115: ; preds = %111
%116 = getelementptr inbounds i32, i32* %0, i64 259
%117 = load i32, i32* %116
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %128
119: ; preds = %115
%120 = getelementptr inbounds i32, i32* %0, i64 258
%121 = load i32, i32* %120
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %128
123: ; preds = %119
%124 = getelementptr inbounds i32, i32* %0, i64 257
%125 = load i32, i32* %124
%126 = icmp ne i32 %125, 0
%127 = zext i1 %126 to i32
br label %128
128: ; preds = %123, %119, %115, %111, %107, %103, %99, %95, %91, %87, %83, %79, %75, %71, %67, %63, %59, %55, %51, %47, %43, %39, %35, %31, %27, %23, %19, %15, %5
%129 = phi i32 [ 29, %5 ], [ 28, %15 ], [ 27, %19 ], [ 26, %23 ], [ 25, %27 ], [ 24, %31 ], [ 23, %35 ], [ 22, %39 ], [ 21, %43 ], [ 20, %47 ], [ 19, %51 ], [ 18, %55 ], [ 17, %59 ], [ 16, %63 ], [ 15, %67 ], [ 14, %71 ], [ 13, %75 ], [ 12, %79 ], [ 11, %83 ], [ 10, %87 ], [ 9, %91 ], [ 8, %95 ], [ 7, %99 ], [ 6, %103 ], [ 5, %107 ], [ 4, %111 ], [ 3, %115 ], [ 2, %119 ], [ %127, %123 ]
%130 = getelementptr inbounds i32, i32* %1, i64 29
%131 = load i32, i32* %130
%132 = icmp eq i32 %131, 0
br i1 %132, label %133, label %246
133: ; preds = %128
%134 = getelementptr inbounds i32, i32* %1, i64 28
%135 = load i32, i32* %134
%136 = icmp eq i32 %135, 0
br i1 %136, label %137, label %246
137: ; preds = %133
%138 = getelementptr inbounds i32, i32* %1, i64 27
%139 = load i32, i32* %138
%140 = icmp eq i32 %139, 0
br i1 %140, label %141, label %246
141: ; preds = %137
%142 = getelementptr inbounds i32, i32* %1, i64 26
%143 = load i32, i32* %142
%144 = icmp eq i32 %143, 0
br i1 %144, label %145, label %246
145: ; preds = %141
%146 = getelementptr inbounds i32, i32* %1, i64 25
%147 = load i32, i32* %146
%148 = icmp eq i32 %147, 0
br i1 %148, label %149, label %246
149: ; preds = %145
%150 = getelementptr inbounds i32, i32* %1, i64 24
%151 = load i32, i32* %150
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %246
153: ; preds = %149
%154 = getelementptr inbounds i32, i32* %1, i64 23
%155 = load i32, i32* %154
%156 = icmp eq i32 %155, 0
br i1 %156, label %157, label %246
157: ; preds = %153
%158 = getelementptr inbounds i32, i32* %1, i64 22
%159 = load i32, i32* %158
%160 = icmp eq i32 %159, 0
br i1 %160, label %161, label %246
161: ; preds = %157
%162 = getelementptr inbounds i32, i32* %1, i64 21
%163 = load i32, i32* %162
%164 = icmp eq i32 %163, 0
br i1 %164, label %165, label %246
165: ; preds = %161
%166 = getelementptr inbounds i32, i32* %1, i64 20
%167 = load i32, i32* %166
%168 = icmp eq i32 %167, 0
br i1 %168, label %169, label %246
169: ; preds = %165
%170 = getelementptr inbounds i32, i32* %1, i64 19
%171 = load i32, i32* %170
%172 = icmp eq i32 %171, 0
br i1 %172, label %173, label %246
173: ; preds = %169
%174 = getelementptr inbounds i32, i32* %1, i64 18
%175 = load i32, i32* %174
%176 = icmp eq i32 %175, 0
br i1 %176, label %177, label %246
177: ; preds = %173
%178 = getelementptr inbounds i32, i32* %1, i64 17
%179 = load i32, i32* %178
%180 = icmp eq i32 %179, 0
br i1 %180, label %181, label %246
181: ; preds = %177
%182 = getelementptr inbounds i32, i32* %1, i64 16
%183 = load i32, i32* %182
%184 = icmp eq i32 %183, 0
br i1 %184, label %185, label %246
185: ; preds = %181
%186 = getelementptr inbounds i32, i32* %1, i64 15
%187 = load i32, i32* %186
%188 = icmp eq i32 %187, 0
br i1 %188, label %189, label %246
189: ; preds = %185
%190 = getelementptr inbounds i32, i32* %1, i64 14
%191 = load i32, i32* %190
%192 = icmp eq i32 %191, 0
br i1 %192, label %193, label %246
193: ; preds = %189
%194 = getelementptr inbounds i32, i32* %1, i64 13
%195 = load i32, i32* %194
%196 = icmp eq i32 %195, 0
br i1 %196, label %197, label %246
197: ; preds = %193
%198 = getelementptr inbounds i32, i32* %1, i64 12
%199 = load i32, i32* %198
%200 = icmp eq i32 %199, 0
br i1 %200, label %201, label %246
201: ; preds = %197
%202 = getelementptr inbounds i32, i32* %1, i64 11
%203 = load i32, i32* %202
%204 = icmp eq i32 %203, 0
br i1 %204, label %205, label %246
205: ; preds = %201
%206 = getelementptr inbounds i32, i32* %1, i64 10
%207 = load i32, i32* %206
%208 = icmp eq i32 %207, 0
br i1 %208, label %209, label %246
209: ; preds = %205
%210 = getelementptr inbounds i32, i32* %1, i64 9
%211 = load i32, i32* %210
%212 = icmp eq i32 %211, 0
br i1 %212, label %213, label %246
213: ; preds = %209
%214 = getelementptr inbounds i32, i32* %1, i64 8
%215 = load i32, i32* %214
%216 = icmp eq i32 %215, 0
br i1 %216, label %217, label %246
217: ; preds = %213
%218 = getelementptr inbounds i32, i32* %1, i64 7
%219 = load i32, i32* %218
%220 = icmp eq i32 %219, 0
br i1 %220, label %221, label %246
221: ; preds = %217
%222 = getelementptr inbounds i32, i32* %1, i64 6
%223 = load i32, i32* %222
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %246
225: ; preds = %221
%226 = getelementptr inbounds i32, i32* %1, i64 5
%227 = load i32, i32* %226
%228 = icmp eq i32 %227, 0
br i1 %228, label %229, label %246
229: ; preds = %225
%230 = getelementptr inbounds i32, i32* %1, i64 4
%231 = load i32, i32* %230
%232 = icmp eq i32 %231, 0
br i1 %232, label %233, label %246
233: ; preds = %229
%234 = getelementptr inbounds i32, i32* %1, i64 3
%235 = load i32, i32* %234
%236 = icmp eq i32 %235, 0
br i1 %236, label %237, label %246
237: ; preds = %233
%238 = getelementptr inbounds i32, i32* %1, i64 2
%239 = load i32, i32* %238
%240 = icmp eq i32 %239, 0
br i1 %240, label %241, label %246
241: ; preds = %237
%242 = getelementptr inbounds i32, i32* %1, i64 1
%243 = load i32, i32* %242
%244 = icmp ne i32 %243, 0
%245 = zext i1 %244 to i32
br label %246
246: ; preds = %241, %237, %233, %229, %225, %221, %217, %213, %209, %205, %201, %197, %193, %189, %185, %181, %177, %173, %169, %165, %161, %157, %153, %149, %145, %141, %137, %133, %128
%247 = phi i32 [ 29, %128 ], [ 28, %133 ], [ 27, %137 ], [ 26, %141 ], [ 25, %145 ], [ 24, %149 ], [ 23, %153 ], [ 22, %157 ], [ 21, %161 ], [ 20, %165 ], [ 19, %169 ], [ 18, %173 ], [ 17, %177 ], [ 16, %181 ], [ 15, %185 ], [ 14, %189 ], [ 13, %193 ], [ 12, %197 ], [ 11, %201 ], [ 10, %205 ], [ 9, %209 ], [ 8, %213 ], [ 7, %217 ], [ 6, %221 ], [ 5, %225 ], [ 4, %229 ], [ 3, %233 ], [ 2, %237 ], [ %245, %241 ]
%248 = add nuw nsw i32 %129, 258
%249 = add nuw nsw i32 %248, %247
%250 = zext i32 %249 to i64
%251 = shl nuw nsw i32 %249, 2
%252 = tail call i32* @malloc(i32 %251)
%253 = icmp eq i32* %252, null
br i1 %253, label %259, label %254
254: ; preds = %246
%255 = add nuw nsw i32 %129, 257
%256 = zext i32 %255 to i64
%257 = zext i32 %129 to i64
%258 = sub nuw nsw i64 -257, %257
br label %261
259: ; preds = %246
%260 = tail call i32 @exit(i32 -1)
unreachable
261: ; preds = %254, %261
%262 = phi i64 [ 0, %254 ], [ %273, %261 ]
%263 = icmp ult i64 %262, %256
%264 = getelementptr inbounds i32, i32* %0, i64 %262
%265 = add nsw i64 %258, %262
%266 = getelementptr inbounds i32, i32* %1, i64 %265
%267 = select i1 %263, i32* %264, i32* %266
%268 = load i32, i32* %267
%269 = getelementptr inbounds i32, i32* %252, i64 %262
store i32 %268, i32* %269
%270 = icmp ult i32 %268, 16
%271 = zext i1 %270 to i32
%272 = tail call i32 @assert(i32 %271)
%273 = add nuw nsw i64 %262, 1
%274 = icmp eq i64 %273, %250
br i1 %274, label %275, label %261
275: ; preds = %261, %559
%276 = phi i64 [ %571, %559 ], [ 0, %261 ]
%277 = phi i64 [ %563, %559 ], [ 0, %261 ]
%278 = phi i64 [ %562, %559 ], [ 0, %261 ]
%279 = phi i32* [ %561, %559 ], [ null, %261 ]
%280 = phi i32* [ %560, %559 ], [ null, %261 ]
%281 = icmp ult i64 %276, %250
br i1 %281, label %282, label %530
282: ; preds = %275
%283 = getelementptr inbounds i32, i32* %252, i64 %276
%284 = load i32, i32* %283
%285 = sub i64 %250, %276
br label %294
286: ; preds = %559
%287 = icmp eq i64 %562, 0
br i1 %287, label %621, label %288
288: ; preds = %286
%289 = add i64 %562, -1
%290 = and i64 %562, 3
%291 = icmp ult i64 %289, 3
br i1 %291, label %606, label %292
292: ; preds = %288
%293 = and i64 %562, -4
br label %573
294: ; preds = %282, %300
%295 = phi i64 [ %276, %282 ], [ %298, %300 ]
%296 = phi i64 [ 0, %282 ], [ %297, %300 ]
%297 = add nuw nsw i64 %296, 1
%298 = add nuw nsw i64 %295, 1
%299 = icmp eq i64 %297, %285
br i1 %299, label %304, label %300
300: ; preds = %294
%301 = getelementptr inbounds i32, i32* %252, i64 %298
%302 = load i32, i32* %301
%303 = icmp eq i32 %284, %302
br i1 %303, label %294, label %304
304: ; preds = %300, %294
%305 = phi i64 [ %297, %300 ], [ %285, %294 ]
%306 = icmp ugt i64 %305, 3
br i1 %306, label %313, label %307
307: ; preds = %304
%308 = icmp eq i64 %305, 3
br i1 %308, label %309, label %530
309: ; preds = %307
%310 = getelementptr inbounds i32, i32* %252, i64 %276
%311 = load i32, i32* %310
%312 = icmp eq i32 %311, 0
br i1 %312, label %343, label %530
313: ; preds = %304
%314 = getelementptr inbounds i32, i32* %252, i64 %276
%315 = load i32, i32* %314
%316 = icmp eq i32 %315, 0
br i1 %316, label %317, label %366
317: ; preds = %313
%318 = icmp ugt i64 %305, 10
br i1 %318, label %319, label %343
319: ; preds = %317
%320 = icmp ult i64 %305, 138
%321 = select i1 %320, i64 %305, i64 138
%322 = tail call i64 @llvm.ctpop.i64(i64 %278)
%323 = icmp ult i64 %322, 2
br i1 %323, label %324, label %331
324: ; preds = %319
%325 = icmp eq i64 %278, 0
br i1 %325, label %326, label %328
326: ; preds = %324
%327 = tail call i32* @malloc(i32 4)
br label %331
328: ; preds = %324
%329 = shl i64 %278, 3
%330 = tail call i32* @realloc(i32* %280, i64 %329)
br label %331
331: ; preds = %326, %328, %319
%332 = phi i32* [ %280, %319 ], [ %327, %326 ], [ %330, %328 ]
%333 = getelementptr inbounds i32, i32* %332, i64 %278
store i32 18, i32* %333
%334 = tail call i64 @llvm.ctpop.i64(i64 %277)
%335 = icmp ult i64 %334, 2
br i1 %335, label %336, label %512
336: ; preds = %331
%337 = icmp eq i64 %277, 0
br i1 %337, label %338, label %340
338: ; preds = %336
%339 = tail call i32* @malloc(i32 4)
br label %512
340: ; preds = %336
%341 = shl i64 %277, 3
%342 = tail call i32* @realloc(i32* %279, i64 %341)
br label %512
343: ; preds = %309, %317
%344 = phi i64 [ %305, %317 ], [ 3, %309 ]
%345 = tail call i64 @llvm.ctpop.i64(i64 %278)
%346 = icmp ult i64 %345, 2
br i1 %346, label %347, label %354
347: ; preds = %343
%348 = icmp eq i64 %278, 0
br i1 %348, label %349, label %351
349: ; preds = %347
%350 = tail call i32* @malloc(i32 4)
br label %354
351: ; preds = %347
%352 = shl i64 %278, 3
%353 = tail call i32* @realloc(i32* %280, i64 %352)
br label %354
354: ; preds = %349, %351, %343
%355 = phi i32* [ %280, %343 ], [ %350, %349 ], [ %353, %351 ]
%356 = getelementptr inbounds i32, i32* %355, i64 %278
store i32 17, i32* %356
%357 = tail call i64 @llvm.ctpop.i64(i64 %277)
%358 = icmp ult i64 %357, 2
br i1 %358, label %359, label %512
359: ; preds = %354
%360 = icmp eq i64 %277, 0
br i1 %360, label %361, label %363
361: ; preds = %359
%362 = tail call i32* @malloc(i32 4)
br label %512
363: ; preds = %359
%364 = shl i64 %277, 3
%365 = tail call i32* @realloc(i32* %279, i64 %364)
br label %512
366: ; preds = %313
%367 = trunc i64 %305 to i32
%368 = add i32 %367, -1
%369 = tail call i64 @llvm.ctpop.i64(i64 %278)
%370 = icmp ult i64 %369, 2
br i1 %370, label %371, label %378
371: ; preds = %366
%372 = icmp eq i64 %278, 0
br i1 %372, label %373, label %375
373: ; preds = %371
%374 = tail call i32* @malloc(i32 4)
br label %378
375: ; preds = %371
%376 = shl i64 %278, 3
%377 = tail call i32* @realloc(i32* %280, i64 %376)
br label %378
378: ; preds = %373, %375, %366
%379 = phi i32* [ %280, %366 ], [ %374, %373 ], [ %377, %375 ]
%380 = load i32, i32* %314
%381 = getelementptr inbounds i32, i32* %379, i64 %278
store i32 %380, i32* %381
%382 = tail call i64 @llvm.ctpop.i64(i64 %277)
%383 = icmp ult i64 %382, 2
br i1 %383, label %384, label %391
384: ; preds = %378
%385 = icmp eq i64 %277, 0
br i1 %385, label %386, label %388
386: ; preds = %384
%387 = tail call i32* @malloc(i32 4)
br label %391
388: ; preds = %384
%389 = shl i64 %277, 3
%390 = tail call i32* @realloc(i32* %279, i64 %389)
br label %391
391: ; preds = %386, %388, %378
%392 = phi i32* [ %279, %378 ], [ %387, %386 ], [ %390, %388 ]
%393 = getelementptr inbounds i32, i32* %392, i64 %277
store i32 0, i32* %393
%394 = add i64 %277, 1
%395 = add i64 %278, 1
%396 = icmp ugt i32 %368, 5
br i1 %396, label %397, label %433
397: ; preds = %391, %426
%398 = phi i64 [ %431, %426 ], [ %395, %391 ]
%399 = phi i64 [ %430, %426 ], [ %394, %391 ]
%400 = phi i32 [ %429, %426 ], [ %368, %391 ]
%401 = phi i64 [ %399, %426 ], [ %277, %391 ]
%402 = phi i64 [ %398, %426 ], [ %278, %391 ]
%403 = phi i32* [ %427, %426 ], [ %392, %391 ]
%404 = phi i32* [ %415, %426 ], [ %379, %391 ]
%405 = and i64 %398, %402
%406 = icmp eq i64 %405, 0
br i1 %406, label %407, label %414
407: ; preds = %397
%408 = icmp eq i64 %398, 0
br i1 %408, label %409, label %411
409: ; preds = %407
%410 = tail call i32* @malloc(i32 4)
br label %414
411: ; preds = %407
%412 = shl i64 %398, 3
%413 = tail call i32* @realloc(i32* %404, i64 %412)
br label %414
414: ; preds = %409, %411, %397
%415 = phi i32* [ %404, %397 ], [ %410, %409 ], [ %413, %411 ]
%416 = getelementptr inbounds i32, i32* %415, i64 %398
store i32 16, i32* %416
%417 = and i64 %399, %401
%418 = icmp eq i64 %417, 0
br i1 %418, label %419, label %426
419: ; preds = %414
%420 = icmp eq i64 %399, 0
br i1 %420, label %421, label %423
421: ; preds = %419
%422 = tail call i32* @malloc(i32 4)
br label %426
423: ; preds = %419
%424 = shl i64 %399, 3
%425 = tail call i32* @realloc(i32* %403, i64 %424)
br label %426
426: ; preds = %421, %423, %414
%427 = phi i32* [ %403, %414 ], [ %422, %421 ], [ %425, %423 ]
%428 = getelementptr inbounds i32, i32* %427, i64 %399
store i32 3, i32* %428
%429 = add i32 %400, -6
%430 = add i64 %399, 1
%431 = add i64 %398, 1
%432 = icmp ugt i32 %429, 5
br i1 %432, label %397, label %433
433: ; preds = %426, %391
%434 = phi i32* [ %379, %391 ], [ %415, %426 ]
%435 = phi i32* [ %392, %391 ], [ %427, %426 ]
%436 = phi i64 [ %278, %391 ], [ %398, %426 ]
%437 = phi i64 [ %277, %391 ], [ %399, %426 ]
%438 = phi i32 [ %368, %391 ], [ %429, %426 ]
%439 = phi i64 [ %394, %391 ], [ %430, %426 ]
%440 = phi i64 [ %395, %391 ], [ %431, %426 ]
%441 = icmp ugt i32 %438, 2
br i1 %441, label %442, label %470
442: ; preds = %433
%443 = and i64 %440, %436
%444 = icmp eq i64 %443, 0
br i1 %444, label %445, label %452
445: ; preds = %442
%446 = icmp eq i64 %440, 0
br i1 %446, label %447, label %449
447: ; preds = %445
%448 = tail call i32* @malloc(i32 4)
br label %452
449: ; preds = %445
%450 = shl i64 %440, 3
%451 = tail call i32* @realloc(i32* %434, i64 %450)
br label %452
452: ; preds = %447, %449, %442
%453 = phi i32* [ %434, %442 ], [ %448, %447 ], [ %451, %449 ]
%454 = getelementptr inbounds i32, i32* %453, i64 %440
store i32 16, i32* %454
%455 = add i64 %436, 2
%456 = and i64 %439, %437
%457 = icmp eq i64 %456, 0
br i1 %457, label %458, label %465
458: ; preds = %452
%459 = icmp eq i64 %439, 0
br i1 %459, label %460, label %462
460: ; preds = %458
%461 = tail call i32* @malloc(i32 4)
br label %465
462: ; preds = %458
%463 = shl i64 %439, 3
%464 = tail call i32* @realloc(i32* %435, i64 %463)
br label %465
465: ; preds = %460, %462, %452
%466 = phi i32* [ %435, %452 ], [ %461, %460 ], [ %464, %462 ]
%467 = getelementptr inbounds i32, i32* %466, i64 %439
store i32 0, i32* %467
%468 = add i64 %437, 2
%469 = add nsw i32 %438, -3
br label %470
470: ; preds = %465, %433
%471 = phi i32* [ %453, %465 ], [ %434, %433 ]
%472 = phi i32* [ %466, %465 ], [ %435, %433 ]
%473 = phi i64 [ %455, %465 ], [ %440, %433 ]
%474 = phi i64 [ %468, %465 ], [ %439, %433 ]
%475 = phi i32 [ %469, %465 ], [ %438, %433 ]
%476 = icmp eq i32 %475, 0
br i1 %476, label %522, label %477
477: ; preds = %470, %506
%478 = phi i32 [ %510, %506 ], [ %475, %470 ]
%479 = phi i64 [ %509, %506 ], [ %474, %470 ]
%480 = phi i64 [ %496, %506 ], [ %473, %470 ]
%481 = phi i32* [ %507, %506 ], [ %472, %470 ]
%482 = phi i32* [ %493, %506 ], [ %471, %470 ]
%483 = tail call i64 @llvm.ctpop.i64(i64 %480)
%484 = icmp ult i64 %483, 2
br i1 %484, label %485, label %492
485: ; preds = %477
%486 = icmp eq i64 %480, 0
br i1 %486, label %487, label %489
487: ; preds = %485
%488 = tail call i32* @malloc(i32 4)
br label %492
489: ; preds = %485
%490 = shl i64 %480, 3
%491 = tail call i32* @realloc(i32* %482, i64 %490)
br label %492
492: ; preds = %487, %489, %477
%493 = phi i32* [ %482, %477 ], [ %488, %487 ], [ %491, %489 ]
%494 = load i32, i32* %314
%495 = getelementptr inbounds i32, i32* %493, i64 %480
store i32 %494, i32* %495
%496 = add i64 %480, 1
%497 = tail call i64 @llvm.ctpop.i64(i64 %479)
%498 = icmp ult i64 %497, 2
br i1 %498, label %499, label %506
499: ; preds = %492
%500 = icmp eq i64 %479, 0
br i1 %500, label %501, label %503
501: ; preds = %499
%502 = tail call i32* @malloc(i32 4)
br label %506
503: ; preds = %499
%504 = shl i64 %479, 3
%505 = tail call i32* @realloc(i32* %481, i64 %504)
br label %506
506: ; preds = %501, %503, %492
%507 = phi i32* [ %481, %492 ], [ %502, %501 ], [ %505, %503 ]
%508 = getelementptr inbounds i32, i32* %507, i64 %479
store i32 0, i32* %508
%509 = add i64 %479, 1
%510 = add i32 %478, -1
%511 = icmp eq i32 %510, 0
br i1 %511, label %522, label %477
512: ; preds = %354, %363, %361, %331, %340, %338
%513 = phi i64 [ %321, %338 ], [ %321, %340 ], [ %321, %331 ], [ %344, %361 ], [ %344, %363 ], [ %344, %354 ]
%514 = phi i32 [ -11, %338 ], [ -11, %340 ], [ -11, %331 ], [ -3, %361 ], [ -3, %363 ], [ -3, %354 ]
%515 = phi i32* [ %339, %338 ], [ %342, %340 ], [ %279, %331 ], [ %362, %361 ], [ %365, %363 ], [ %279, %354 ]
%516 = phi i32* [ %332, %338 ], [ %332, %340 ], [ %332, %331 ], [ %355, %361 ], [ %355, %363 ], [ %355, %354 ]
%517 = add i64 %278, 1
%518 = trunc i64 %513 to i32
%519 = add nsw i32 %514, %518
%520 = getelementptr inbounds i32, i32* %515, i64 %277
store i32 %519, i32* %520
%521 = add i64 %277, 1
br label %522
522: ; preds = %506, %512, %470
%523 = phi i32* [ %471, %470 ], [ %516, %512 ], [ %493, %506 ]
%524 = phi i32* [ %472, %470 ], [ %515, %512 ], [ %507, %506 ]
%525 = phi i64 [ %473, %470 ], [ %517, %512 ], [ %496, %506 ]
%526 = phi i64 [ %474, %470 ], [ %521, %512 ], [ %509, %506 ]
%527 = phi i64 [ %305, %470 ], [ %513, %512 ], [ %305, %506 ]
%528 = add i64 %276, -1
%529 = add i64 %528, %527
br label %559
530: ; preds = %275, %309, %307
%531 = tail call i64 @llvm.ctpop.i64(i64 %278)
%532 = icmp ult i64 %531, 2
br i1 %532, label %533, label %540
533: ; preds = %530
%534 = icmp eq i64 %278, 0
br i1 %534, label %535, label %537
535: ; preds = %533
%536 = tail call i32* @malloc(i32 4)
br label %540
537: ; preds = %533
%538 = shl i64 %278, 3
%539 = tail call i32* @realloc(i32* %280, i64 %538)
br label %540
540: ; preds = %535, %537, %530
%541 = phi i32* [ %280, %530 ], [ %536, %535 ], [ %539, %537 ]
%542 = getelementptr inbounds i32, i32* %252, i64 %276
%543 = load i32, i32* %542
%544 = getelementptr inbounds i32, i32* %541, i64 %278
store i32 %543, i32* %544
%545 = add i64 %278, 1
%546 = tail call i64 @llvm.ctpop.i64(i64 %277)
%547 = icmp ult i64 %546, 2
br i1 %547, label %548, label %555
548: ; preds = %540
%549 = icmp eq i64 %277, 0
br i1 %549, label %550, label %552
550: ; preds = %548
%551 = tail call i32* @malloc(i32 4)
br label %555
552: ; preds = %548
%553 = shl i64 %277, 3
%554 = tail call i32* @realloc(i32* %279, i64 %553)
br label %555
555: ; preds = %550, %552, %540
%556 = phi i32* [ %279, %540 ], [ %551, %550 ], [ %554, %552 ]
%557 = getelementptr inbounds i32, i32* %556, i64 %277
store i32 0, i32* %557
%558 = add i64 %277, 1
br label %559
559: ; preds = %555, %522
%560 = phi i32* [ %523, %522 ], [ %541, %555 ]
%561 = phi i32* [ %524, %522 ], [ %556, %555 ]
%562 = phi i64 [ %525, %522 ], [ %545, %555 ]
%563 = phi i64 [ %526, %522 ], [ %558, %555 ]
%564 = phi i64 [ %529, %522 ], [ %276, %555 ]
%565 = add i64 %562, -1
%566 = getelementptr inbounds i32, i32* %560, i64 %565
%567 = load i32, i32* %566
%568 = icmp ult i32 %567, 19
%569 = zext i1 %568 to i32
%570 = tail call i32 @assert(i32 %569)
%571 = add i64 %564, 1
%572 = icmp ult i64 %571, %250
br i1 %572, label %275, label %286
573: ; preds = %573, %292
%574 = phi i64 [ 0, %292 ], [ %603, %573 ]
%575 = phi i64 [ 0, %292 ], [ %604, %573 ]
%576 = getelementptr inbounds i32, i32* %560, i64 %574
%577 = load i32, i32* %576
%578 = zext i32 %577 to i64
%579 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 %578
%580 = load i64, i64* %579
%581 = add i64 %580, 1
store i64 %581, i64* %579
%582 = or i64 %574, 1
%583 = getelementptr inbounds i32, i32* %560, i64 %582
%584 = load i32, i32* %583
%585 = zext i32 %584 to i64
%586 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 %585
%587 = load i64, i64* %586
%588 = add i64 %587, 1
store i64 %588, i64* %586
%589 = or i64 %574, 2
%590 = getelementptr inbounds i32, i32* %560, i64 %589
%591 = load i32, i32* %590
%592 = zext i32 %591 to i64
%593 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 %592
%594 = load i64, i64* %593
%595 = add i64 %594, 1
store i64 %595, i64* %593
%596 = or i64 %574, 3
%597 = getelementptr inbounds i32, i32* %560, i64 %596
%598 = load i32, i32* %597
%599 = zext i32 %598 to i64
%600 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 %599
%601 = load i64, i64* %600
%602 = add i64 %601, 1
store i64 %602, i64* %600
%603 = add nuw i64 %574, 4
%604 = add i64 %575, 4
%605 = icmp eq i64 %604, %293
br i1 %605, label %606, label %573
606: ; preds = %573, %288
%607 = phi i64 [ 0, %288 ], [ %603, %573 ]
%608 = icmp eq i64 %290, 0
br i1 %608, label %621, label %609
609: ; preds = %606, %609
%610 = phi i64 [ %618, %609 ], [ %607, %606 ]
%611 = phi i64 [ %619, %609 ], [ 0, %606 ]
%612 = getelementptr inbounds i32, i32* %560, i64 %610
%613 = load i32, i32* %612
%614 = zext i32 %613 to i64
%615 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 %614
%616 = load i64, i64* %615
%617 = add i64 %616, 1
store i64 %617, i64* %615
%618 = add nuw i64 %610, 1
%619 = add i64 %611, 1
%620 = icmp eq i64 %619, %290
br i1 %620, label %621, label %609
621: ; preds = %606, %609, %286
%622 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 0
%623 = getelementptr inbounds [19 x i32], [19 x i32]* %8, i64 0, i64 0
%624 = call i32 @CalculateBitLengths(i64* %622, i32 19, i32 7, i32* %623)
%625 = getelementptr inbounds [19 x i32], [19 x i32]* %9, i64 0, i64 0
%626 = call i32 @LengthsToSymbols(i32* %623, i32 19, i32 7, i32* %625)
%627 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 15
%628 = load i64, i64* %627
%629 = icmp eq i64 %628, 0
br i1 %629, label %630, label %687
630: ; preds = %621
%631 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 1
%632 = load i64, i64* %631
%633 = icmp eq i64 %632, 0
br i1 %633, label %634, label %687
634: ; preds = %630
%635 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 14
%636 = load i64, i64* %635
%637 = icmp eq i64 %636, 0
br i1 %637, label %638, label %687
638: ; preds = %634
%639 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 2
%640 = load i64, i64* %639
%641 = icmp eq i64 %640, 0
br i1 %641, label %642, label %687
642: ; preds = %638
%643 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 13
%644 = load i64, i64* %643
%645 = icmp eq i64 %644, 0
br i1 %645, label %646, label %687
646: ; preds = %642
%647 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 3
%648 = load i64, i64* %647
%649 = icmp eq i64 %648, 0
br i1 %649, label %650, label %687
650: ; preds = %646
%651 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 12
%652 = load i64, i64* %651
%653 = icmp eq i64 %652, 0
br i1 %653, label %654, label %687
654: ; preds = %650
%655 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 4
%656 = load i64, i64* %655
%657 = icmp eq i64 %656, 0
br i1 %657, label %658, label %687
658: ; preds = %654
%659 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 11
%660 = load i64, i64* %659
%661 = icmp eq i64 %660, 0
br i1 %661, label %662, label %687
662: ; preds = %658
%663 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 5
%664 = load i64, i64* %663
%665 = icmp eq i64 %664, 0
br i1 %665, label %666, label %687
666: ; preds = %662
%667 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 10
%668 = load i64, i64* %667
%669 = icmp eq i64 %668, 0
br i1 %669, label %670, label %687
670: ; preds = %666
%671 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 6
%672 = load i64, i64* %671
%673 = icmp eq i64 %672, 0
br i1 %673, label %674, label %687
674: ; preds = %670
%675 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 9
%676 = load i64, i64* %675
%677 = icmp eq i64 %676, 0
br i1 %677, label %678, label %687
678: ; preds = %674
%679 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 7
%680 = load i64, i64* %679
%681 = icmp eq i64 %680, 0
br i1 %681, label %682, label %687
682: ; preds = %678
%683 = getelementptr inbounds [19 x i64], [19 x i64]* %6, i64 0, i64 8
%684 = load i64, i64* %683
%685 = icmp ne i64 %684, 0
%686 = zext i1 %685 to i32
br label %687
687: ; preds = %682, %621, %630, %634, %638, %642, %646, %650, %654, %658, %662, %666, %670, %674, %678
%688 = phi i32 [ 15, %621 ], [ 14, %630 ], [ 13, %634 ], [ 12, %638 ], [ 11, %642 ], [ 10, %646 ], [ 9, %650 ], [ 8, %654 ], [ 7, %658 ], [ 6, %662 ], [ 5, %666 ], [ 4, %670 ], [ 3, %674 ], [ 2, %678 ], [ %686, %682 ]
%689 = call i32 @AddBits(i32 %129, i32 5, i8* %2, i8** %3, i64* %4)
%690 = call i32 @AddBits(i32 %247, i32 5, i8* %2, i8** %3, i64* %4)
%691 = call i32 @AddBits(i32 %688, i32 4, i8* %2, i8** %3, i64* %4)
%692 = add nuw nsw i32 %688, 4
%693 = zext i32 %692 to i64
br label %695
694: ; preds = %695
br i1 %287, label %728, label %705
695: ; preds = %687, %695
%696 = phi i64 [ %703, %695 ], [ 0, %687 ]
%697 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.AddDynamicTree.order, i64 0, i64 %696
%698 = load i32, i32* %697
%699 = zext i32 %698 to i64
%700 = getelementptr inbounds [19 x i32], [19 x i32]* %8, i64 0, i64 %699
%701 = load i32, i32* %700
%702 = call i32 @AddBits(i32 %701, i32 3, i8* %2, i8** %3, i64* %4)
%703 = add nuw nsw i64 %696, 1
%704 = icmp eq i64 %703, %693
br i1 %704, label %694, label %695
705: ; preds = %694, %725
%706 = phi i64 [ %726, %725 ], [ 0, %694 ]
%707 = getelementptr inbounds i32, i32* %560, i64 %706
%708 = load i32, i32* %707
%709 = zext i32 %708 to i64
%710 = getelementptr inbounds [19 x i32], [19 x i32]* %9, i64 0, i64 %709
%711 = load i32, i32* %710
%712 = getelementptr inbounds [19 x i32], [19 x i32]* %8, i64 0, i64 %709
%713 = load i32, i32* %712
%714 = call i32 @AddHuffmanBits(i32 %711, i32 %713, i8* %2, i8** %3, i64* %4)
%715 = load i32, i32* %707
%716 = add i32 %715, -16
%717 = icmp ult i32 %716, 3
br i1 %717, label %718, label %725
718: ; preds = %705
%719 = sext i32 %716 to i64
%720 = getelementptr inbounds [3 x i32], [3 x i32]* @switch.table.AddDynamicTree, i64 0, i64 %719
%721 = load i32, i32* %720
%722 = getelementptr inbounds i32, i32* %561, i64 %706
%723 = load i32, i32* %722
%724 = call i32 @AddBits(i32 %723, i32 %721, i8* %2, i8** %3, i64* %4)
br label %725
725: ; preds = %705, %718
%726 = add nuw i64 %706, 1
%727 = icmp eq i64 %726, %562
br i1 %727, label %728, label %705
728: ; preds = %725, %694
%729 = call i32 @free(i32* %252)
%730 = call i32 @free(i32* %560)
%731 = call i32 @free(i32* %561)
ret void
}