#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 */
unsigned int decode_one(unsigned char const *, long *, char *, int,
                        unsigned int *, int);
int /*<<< orphan*/ make_code_table(char *, int, unsigned int *, int);
void *read_bits(unsigned char const *, long *, int);
int get_tables(const unsigned char *data, long *p, char hlit_size_table[288],
               unsigned int hlit_code_table[288], char hdist_size_table[30],
               unsigned int hdist_code_table[30]) {
  char hlit, hdist, hclen;
  const int clen_weird_tangle[19] = {16, 17, 18, 0, 8,  7, 9,  6, 10, 5,
                                     11, 4,  12, 3, 13, 2, 14, 1, 15};
  char clen_size_table[19];
  unsigned int clen_code_table[19];
  int j;
  unsigned int b;
  int remainder;
  char rem_val;
  hlit = read_bits(data, p, 5);
  hdist = read_bits(data, p, 5);
  hclen = read_bits(data, p, 4);
  for (j = 0; j < 4 + hclen; j++)
    clen_size_table[clen_weird_tangle[j]] = read_bits(data, p, 3);
  for (; j < 19; j++)
    clen_size_table[clen_weird_tangle[j]] = 0;
  make_code_table(clen_size_table, 19, clen_code_table, 15);
  remainder = 0;
  rem_val = 0;
  for (j = 0; j < 257 + hlit; j++) {
    b = decode_one(data, p, clen_size_table, 19, clen_code_table, 15);
    if (b < 0)
      return -1;
    if (b < 16)
      hlit_size_table[j] = b;
    else if (b == 16) {
      int k, l;
      k = read_bits(data, p, 2);
      for (l = 0; l < k + 3 && j + l < 257 + hlit; l++)
        hlit_size_table[j + l] = hlit_size_table[j - 1];
      j += l - 1;
      remainder = k + 3 - l;
      rem_val = hlit_size_table[j - 1];
    } else if (b == 17) {
      int k, l;
      k = read_bits(data, p, 3);
      for (l = 0; l < k + 3 && j + l < 257 + hlit; l++)
        hlit_size_table[j + l] = 0;
      j += l - 1;
      remainder = k + 3 - l;
      rem_val = 0;
    } else if (b == 18) {
      int k, l;
      k = read_bits(data, p, 7);
      for (l = 0; l < k + 11 && j + l < 257 + hlit; l++)
        hlit_size_table[j + l] = 0;
      j += l - 1;
      remainder = k + 11 - l;
      rem_val = 0;
    }
  }
  for (; j < 288; j++)
    hlit_size_table[j] = 0;
  make_code_table(hlit_size_table, 288, hlit_code_table, 15);
  for (j = 0; j < remainder; j++)
    hdist_size_table[j] = rem_val;
  for (; j < 1 + hdist; j++) {
    b = decode_one(data, p, clen_size_table, 19, clen_code_table, 15);
    if (b < 0)
      return -1;
    if (b < 16)
      hdist_size_table[j] = b;
    else if (b == 16) {
      int k, l;
      k = read_bits(data, p, 2);
      for (l = 0; l < k + 3 && j + l < 1 + hdist; l++)
        hdist_size_table[j + l] = hdist_size_table[j - 1];
      j += l - 1;
    } else if (b == 17) {
      int k, l;
      k = read_bits(data, p, 3);
      for (l = 0; l < k + 3 && j + l < 1 + hdist; l++)
        hdist_size_table[j + l] = 0;
      j += l - 1;
    } else if (b == 18) {
      int k, l;
      k = read_bits(data, p, 7);
      for (l = 0; l < k + 11 && j + l < 1 + hdist; l++)
        hdist_size_table[j + l] = 0;
      j += l - 1;
    }
  }
  for (; j < 30; j++)
    hdist_size_table[j] = 0;
  make_code_table(hdist_size_table, 30, hdist_code_table, 15);
  return 0;
}


x86 assembly (clang, -O0):
<get_tables>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xe8f(%rip),%rsi
mov    $0x4c,%edx
call   1030 <memcpy@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x5,%edx
call   1050 <read_bits@plt>
mov    %al,-0x39(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x5,%edx
call   1050 <read_bits@plt>
mov    %al,-0x3a(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x4,%edx
call   1050 <read_bits@plt>
mov    %al,-0x3b(%rbp)
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
movsbl -0x3b(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1217 <get_tables+0xd7>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
mov    %al,%cl
movslq -0x104(%rbp),%rax
movslq -0x90(%rbp,%rax,4),%rax
ff
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    11c4 <get_tables+0x84>
jmp    121c <get_tables+0xdc>
cmpl   $0x13,-0x104(%rbp)
jge    1254 <get_tables+0x114>
movslq -0x104(%rbp),%rax
movslq -0x90(%rbp,%rax,4),%rax
ff
movb   $0x0,-0xb0(%rbp,%rax,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    121c <get_tables+0xdc>
lea    -0xb0(%rbp),%rdi
lea    -0x100(%rbp),%rdx
mov    $0x13,%esi
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
movl   $0x0,-0x10c(%rbp)
movb   $0x0,-0x10d(%rbp)
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
movsbl -0x39(%rbp),%ecx
add    $0x101,%ecx
cmp    %ecx,%eax
jge    1601 <get_tables+0x4c1>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0xb0(%rbp),%rdx
lea    -0x100(%rbp),%r8
mov    $0x13,%ecx
mov    $0xf,%r9d
call   1040 <decode_one@plt>
mov    %eax,-0x108(%rbp)
cmpl   $0x0,-0x108(%rbp)
jae    12e9 <get_tables+0x1a9>
movl   $0xffffffff,-0x4(%rbp)
jmp    19ef <get_tables+0x8af>
cmpl   $0x10,-0x108(%rbp)
jae    1311 <get_tables+0x1d1>
mov    -0x108(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x104(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    15e8 <get_tables+0x4a8>
cmpl   $0x10,-0x108(%rbp)
jne    1418 <get_tables+0x2d8>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x2,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x114(%rbp)
movl   $0x0,-0x118(%rbp)
mov    -0x118(%rbp),%ecx
mov    -0x114(%rbp),%edx
add    $0x3,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x141(%rbp)
jge    1380 <get_tables+0x240>
mov    -0x104(%rbp),%eax
add    -0x118(%rbp),%eax
movsbl -0x39(%rbp),%ecx
add    $0x101,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x141(%rbp)
mov    -0x141(%rbp),%al
test   $0x1,%al
jne    1393 <get_tables+0x253>
jmp    13d0 <get_tables+0x290>
mov    -0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x118(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1340 <get_tables+0x200>
mov    -0x118(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x114(%rbp),%eax
add    $0x3,%eax
sub    -0x118(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x10d(%rbp)
jmp    15e3 <get_tables+0x4a3>
cmpl   $0x11,-0x108(%rbp)
jne    14fb <get_tables+0x3bb>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x11c(%rbp)
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%ecx
mov    -0x11c(%rbp),%edx
add    $0x3,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x142(%rbp)
jge    1487 <get_tables+0x347>
mov    -0x104(%rbp),%eax
add    -0x120(%rbp),%eax
movsbl -0x39(%rbp),%ecx
add    $0x101,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x142(%rbp)
mov    -0x142(%rbp),%al
test   $0x1,%al
jne    149a <get_tables+0x35a>
jmp    14c5 <get_tables+0x385>
mov    -0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x120(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    1447 <get_tables+0x307>
mov    -0x120(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x11c(%rbp),%eax
add    $0x3,%eax
sub    -0x120(%rbp),%eax
mov    %eax,-0x10c(%rbp)
movb   $0x0,-0x10d(%rbp)
jmp    15de <get_tables+0x49e>
cmpl   $0x12,-0x108(%rbp)
jne    15d9 <get_tables+0x499>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x7,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x124(%rbp)
movl   $0x0,-0x128(%rbp)
mov    -0x128(%rbp),%ecx
mov    -0x124(%rbp),%edx
add    $0xb,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x143(%rbp)
jge    156a <get_tables+0x42a>
mov    -0x104(%rbp),%eax
add    -0x128(%rbp),%eax
movsbl -0x39(%rbp),%ecx
add    $0x101,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x143(%rbp)
mov    -0x143(%rbp),%al
test   $0x1,%al
jne    157d <get_tables+0x43d>
jmp    15a8 <get_tables+0x468>
mov    -0x20(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x128(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    152a <get_tables+0x3ea>
mov    -0x128(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x124(%rbp),%eax
add    $0xb,%eax
sub    -0x128(%rbp),%eax
mov    %eax,-0x10c(%rbp)
movb   $0x0,-0x10d(%rbp)
jmp    15de <get_tables+0x49e>
jmp    15e3 <get_tables+0x4a3>
jmp    15e8 <get_tables+0x4a8>
jmp    15ed <get_tables+0x4ad>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    128c <get_tables+0x14c>
jmp    1606 <get_tables+0x4c6>
cmpl   $0x120,-0x104(%rbp)
jge    1639 <get_tables+0x4f9>
mov    -0x20(%rbp),%rax
movslq -0x104(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1606 <get_tables+0x4c6>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rdx
mov    $0x120,%esi
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    1694 <get_tables+0x554>
mov    -0x10d(%rbp),%dl
mov    -0x30(%rbp),%rax
movslq -0x104(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    165a <get_tables+0x51a>
jmp    1699 <get_tables+0x559>
mov    -0x104(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    199c <get_tables+0x85c>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0xb0(%rbp),%rdx
lea    -0x100(%rbp),%r8
mov    $0x13,%ecx
mov    $0xf,%r9d
call   1040 <decode_one@plt>
mov    %eax,-0x108(%rbp)
cmpl   $0x0,-0x108(%rbp)
jae    16f3 <get_tables+0x5b3>
movl   $0xffffffff,-0x4(%rbp)
jmp    19ef <get_tables+0x8af>
cmpl   $0x10,-0x108(%rbp)
jae    171b <get_tables+0x5db>
mov    -0x108(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x104(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1983 <get_tables+0x843>
cmpl   $0x10,-0x108(%rbp)
jne    17f1 <get_tables+0x6b1>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x2,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x12c(%rbp)
movl   $0x0,-0x130(%rbp)
mov    -0x130(%rbp),%ecx
mov    -0x12c(%rbp),%edx
add    $0x3,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x144(%rbp)
jge    1787 <get_tables+0x647>
mov    -0x104(%rbp),%eax
add    -0x130(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x144(%rbp)
mov    -0x144(%rbp),%al
test   $0x1,%al
jne    179a <get_tables+0x65a>
jmp    17d7 <get_tables+0x697>
mov    -0x30(%rbp),%rax
mov    -0x104(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x130(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    174a <get_tables+0x60a>
mov    -0x130(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    197e <get_tables+0x83e>
cmpl   $0x11,-0x108(%rbp)
jne    18b5 <get_tables+0x775>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x134(%rbp)
movl   $0x0,-0x138(%rbp)
mov    -0x138(%rbp),%ecx
mov    -0x134(%rbp),%edx
add    $0x3,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x145(%rbp)
jge    185d <get_tables+0x71d>
mov    -0x104(%rbp),%eax
add    -0x138(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x145(%rbp)
mov    -0x145(%rbp),%al
test   $0x1,%al
jne    1870 <get_tables+0x730>
jmp    189b <get_tables+0x75b>
mov    -0x30(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x138(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1820 <get_tables+0x6e0>
mov    -0x138(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    1979 <get_tables+0x839>
cmpl   $0x12,-0x108(%rbp)
jne    1974 <get_tables+0x834>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x7,%edx
call   1050 <read_bits@plt>
mov    %eax,-0x13c(%rbp)
movl   $0x0,-0x140(%rbp)
mov    -0x140(%rbp),%ecx
mov    -0x13c(%rbp),%edx
add    $0xb,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x146(%rbp)
jge    1921 <get_tables+0x7e1>
mov    -0x104(%rbp),%eax
add    -0x140(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
setl   %al
mov    %al,-0x146(%rbp)
mov    -0x146(%rbp),%al
test   $0x1,%al
jne    1934 <get_tables+0x7f4>
jmp    195f <get_tables+0x81f>
mov    -0x30(%rbp),%rax
mov    -0x104(%rbp),%ecx
add    -0x140(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x140(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    18e4 <get_tables+0x7a4>
mov    -0x140(%rbp),%eax
sub    $0x1,%eax
add    -0x104(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    1979 <get_tables+0x839>
jmp    197e <get_tables+0x83e>
jmp    1983 <get_tables+0x843>
jmp    1988 <get_tables+0x848>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1699 <get_tables+0x559>
jmp    19a1 <get_tables+0x861>
cmpl   $0x1e,-0x104(%rbp)
jge    19d1 <get_tables+0x891>
mov    -0x30(%rbp),%rax
movslq -0x104(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    19a1 <get_tables+0x861>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x1e,%esi
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_tables>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x58(%rsp)
mov    %r8,%r12
mov    %rcx,0x40(%rsp)
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    $0x5,%edx
call   1050 <read_bits@plt>
mov    %rax,%r15
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x5,%edx
call   1050 <read_bits@plt>
mov    %rax,0x48(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x4,%edx
call   1050 <read_bits@plt>
shl    $0x18,%eax
xor    %esi,%esi
cmp    $0xfc000001,%eax
mov    %r12,0x50(%rsp)
jl     121a <get_tables+0xda>
mov    %r15,0x10(%rsp)
sar    $0x18,%eax
cmp    $0xfffffffe,%eax
mov    $0xfffffffd,%ecx
cmovge %eax,%ecx
add    $0x4,%ecx
mov    %rbp,%r15
mov    %rcx,0x18(%rsp)
lea    0x0(,%rcx,4),%rbp
mov    %rbx,%r12
xor    %ebx,%ebx
lea    0xe24(%rip),%r13
nopl   0x0(%rax)
mov    %r15,%rdi
mov    %r12,%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
movslq (%rbx,%r13,1),%rcx
mov    %al,0x20(%rsp,%rcx,1)
add    $0x4,%rbx
cmp    %rbx,%rbp
jne    11e0 <get_tables+0xa0>
mov    0x18(%rsp),%rsi
cmp    $0x12,%esi
mov    %r12,%rbx
mov    %r15,%rbp
mov    0x10(%rsp),%r15
ja     12a1 <get_tables+0x161>
mov    %esi,%ecx
mov    $0x3,%edx
sub    %esi,%edx
mov    %rcx,%rax
and    $0x3,%rdx
je     1255 <get_tables+0x115>
lea    0xdcd(%rip),%rax
lea    (%rax,%rcx,4),%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movslq (%rsi,%rax,4),%rdi
movb   $0x0,0x20(%rsp,%rdi,1)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1240 <get_tables+0x100>
add    %rcx,%rax
add    $0xfffffffffffffff0,%rcx
cmp    $0x3,%rcx
jb     12a1 <get_tables+0x161>
add    $0x3,%rax
lea    0xd96(%rip),%rcx
nopw   0x0(%rax,%rax,1)
movslq -0xc(%rcx,%rax,4),%rdx
movb   $0x0,0x20(%rsp,%rdx,1)
movslq -0x8(%rcx,%rax,4),%rdx
movb   $0x0,0x20(%rsp,%rdx,1)
movslq -0x4(%rcx,%rax,4),%rdx
movb   $0x0,0x20(%rsp,%rdx,1)
movslq (%rcx,%rax,4),%rdx
movb   $0x0,0x20(%rsp,%rdx,1)
add    $0x4,%rax
cmp    $0x16,%rax
jne    1270 <get_tables+0x130>
lea    0x20(%rsp),%rdi
lea    0x60(%rsp),%rdx
mov    $0x13,%esi
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
movsbl %r15b,%r12d
add    $0x101,%r12d
xor    %r13d,%r13d
xor    %r15d,%r15d
movl   $0x0,0xc(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rbp,0x10(%rsp)
jmp    12ff <get_tables+0x1bf>
nop
lea    (%rdx,%r13,1),%ecx
add    $0xffffffff,%ecx
sub    %edx,%r15d
movl   $0x0,0xc(%rsp)
lea    0x1(%rcx),%r13d
cmp    %r12d,%r13d
jge    153b <get_tables+0x3fb>
mov    %rbp,%rdi
mov    %rbx,%rsi
lea    0x20(%rsp),%rdx
mov    $0x13,%ecx
lea    0x60(%rsp),%r8
mov    $0xf,%r9d
call   1040 <decode_one@plt>
cmp    $0xf,%eax
ja     1330 <get_tables+0x1f0>
movslq %r13d,%rcx
mov    %al,(%r14,%rcx,1)
mov    %r13d,%ecx
jmp    12f2 <get_tables+0x1b2>
cmp    $0x12,%eax
je     13c6 <get_tables+0x286>
cmp    $0x11,%eax
je     141c <get_tables+0x2dc>
cmp    $0x10,%eax
jne    132b <get_tables+0x1eb>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x2,%edx
call   1050 <read_bits@plt>
lea    0x3(%rax),%r15d
lea    -0x1(%r13),%ecx
xor    %edx,%edx
cmp    $0xfffffffe,%eax
jl     13b0 <get_tables+0x270>
movslq %ecx,%rbp
cmp    %r12d,%r13d
mov    %r12d,%esi
cmovg  %r13d,%esi
movslq %r13d,%rdi
sub    %r13d,%esi
cmp    $0x2,%r15d
mov    $0x1,%ebx
cmovge %r15d,%ebx
add    %r14,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
cmp    %rdx,%rsi
je     13a6 <get_tables+0x266>
movzbl (%r14,%rbp,1),%eax
mov    %al,(%rdi,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1390 <get_tables+0x250>
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%rbp
add    %edx,%ecx
sub    %edx,%r15d
movslq %ecx,%rax
mov    -0x1(%rax,%r14,1),%al
mov    %eax,0xc(%rsp)
jmp    12f2 <get_tables+0x1b2>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
call   1050 <read_bits@plt>
lea    0xb(%rax),%r15d
xor    %edx,%edx
cmp    $0xfffffff6,%eax
xorps  %xmm0,%xmm0
jl     12e0 <get_tables+0x1a0>
movslq %r13d,%rax
cmp    %r12d,%eax
mov    %r12d,%ecx
cmovg  %r13d,%ecx
sub    %eax,%ecx
cmp    $0x2,%r15d
mov    $0x1,%esi
cmovge %r15d,%esi
lea    -0x1(%rsi),%rdx
cmp    %rcx,%rdx
cmovae %rcx,%rdx
cmp    $0x10,%rdx
jae    1473 <get_tables+0x333>
xor    %edx,%edx
jmp    14b2 <get_tables+0x372>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
lea    0x3(%rax),%r15d
xor    %edx,%edx
cmp    $0xfffffffe,%eax
xorps  %xmm0,%xmm0
jl     12e0 <get_tables+0x1a0>
movslq %r13d,%rax
cmp    %r12d,%r13d
mov    %r12d,%ecx
cmovg  %r13d,%ecx
sub    %r13d,%ecx
cmp    $0x2,%r15d
mov    $0x1,%esi
cmovge %r15d,%esi
lea    -0x1(%rsi),%rdx
cmp    %rcx,%rdx
cmovae %rcx,%rdx
cmp    $0x10,%rdx
jae    14db <get_tables+0x39b>
xor    %edx,%edx
jmp    1512 <get_tables+0x3d2>
add    $0x1,%rdx
mov    %edx,%edi
and    $0xf,%edi
test   %rdi,%rdi
mov    $0x10,%ebx
cmove  %rbx,%rdi
sub    %rdi,%rdx
lea    (%r14,%rax,1),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%rdi,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%rdx
jne    14a0 <get_tables+0x360>
mov    0x18(%rsp),%rbx
add    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rdx,%rcx
je     12e0 <get_tables+0x1a0>
movb   $0x0,(%rax,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    14c0 <get_tables+0x380>
jmp    12e0 <get_tables+0x1a0>
add    $0x1,%rdx
mov    %edx,%edi
and    $0xf,%edi
test   %rdi,%rdi
mov    $0x10,%ebx
cmove  %rbx,%rdi
sub    %rdi,%rdx
lea    (%r14,%rax,1),%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movups %xmm0,(%rdi,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%rdx
jne    1500 <get_tables+0x3c0>
mov    0x18(%rsp),%rbx
add    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %rdx,%rcx
je     12e0 <get_tables+0x1a0>
movb   $0x0,(%rax,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1520 <get_tables+0x3e0>
jmp    12e0 <get_tables+0x1a0>
cmp    $0x11e,%ecx
jg     155b <get_tables+0x41b>
movslq %r13d,%rdi
add    %r14,%rdi
mov    $0x11e,%edx
sub    %ecx,%edx
add    $0x1,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r14,%rdi
mov    $0x120,%esi
mov    0x40(%rsp),%rdx
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
test   %r15d,%r15d
mov    0x50(%rsp),%rbp
jle    158e <get_tables+0x44e>
mov    %r15d,%edx
movzbl 0xc(%rsp),%esi
mov    %rbp,%rdi
call   1030 <memset@plt>
jmp    1591 <get_tables+0x451>
xor    %r15d,%r15d
mov    0x48(%rsp),%rax
movsbl %al,%r12d
cmp    %r12d,%r15d
jle    15ea <get_tables+0x4aa>
mov    %r15d,%eax
cmp    $0x1d,%eax
jg     15bf <get_tables+0x47f>
movslq %eax,%rdi
add    %rbp,%rdi
mov    $0x1d,%edx
sub    %eax,%edx
add    $0x1,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %rbp,%rdi
mov    $0x1e,%esi
mov    0x58(%rsp),%rdx
mov    $0xf,%ecx
call   1060 <make_code_table@plt>
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsbq %al,%r14
lea    0x60(%rsp),%r13
jmp    1613 <get_tables+0x4d3>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %r15d,%rcx
mov    %al,0x0(%rbp,%rcx,1)
lea    0x1(%r15),%eax
cmp    %r12d,%r15d
mov    %eax,%r15d
jge    15a2 <get_tables+0x462>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
lea    0x20(%rsp),%rdx
mov    $0x13,%ecx
mov    %r13,%r8
mov    $0xf,%r9d
call   1040 <decode_one@plt>
cmp    $0xf,%eax
jbe    1600 <get_tables+0x4c0>
cmp    $0x12,%eax
je     16b8 <get_tables+0x578>
cmp    $0x11,%eax
je     1708 <get_tables+0x5c8>
cmp    $0x10,%eax
jne    1607 <get_tables+0x4c7>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x2,%edx
call   1050 <read_bits@plt>
movslq %r15d,%rcx
lea    -0x1(%rcx),%r15
xor    %edx,%edx
cmp    $0xfffffffe,%eax
jl     16b0 <get_tables+0x570>
add    $0x2,%eax
test   %eax,%eax
mov    $0x0,%edx
cmovle %edx,%eax
add    $0x1,%eax
lea    (%rcx,%rbp,1),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rdx,1),%rdi
cmp    %r14,%rdi
jg     16b0 <get_tables+0x570>
movzbl 0x0(%rbp,%r15,1),%ebx
mov    %bl,(%rsi,%rdx,1)
mov    0x18(%rsp),%rbx
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1690 <get_tables+0x550>
add    %edx,%r15d
jmp    1607 <get_tables+0x4c7>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x7,%edx
call   1050 <read_bits@plt>
xor    %ecx,%ecx
cmp    $0xfffffff6,%eax
jl     1760 <get_tables+0x620>
add    $0xa,%eax
test   %eax,%eax
mov    $0x0,%ecx
cmovle %ecx,%eax
movslq %r15d,%rdx
add    $0x1,%eax
lea    (%rdx,%rbp,1),%rsi
xor    %ecx,%ecx
xchg   %ax,%ax
lea    (%rdx,%rcx,1),%rdi
cmp    %r14,%rdi
jg     1760 <get_tables+0x620>
movb   $0x0,(%rsi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    16f0 <get_tables+0x5b0>
jmp    1760 <get_tables+0x620>
mov    0x10(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x3,%edx
call   1050 <read_bits@plt>
xor    %ecx,%ecx
cmp    $0xfffffffe,%eax
jl     1760 <get_tables+0x620>
add    $0x2,%eax
test   %eax,%eax
mov    $0x0,%ecx
cmovle %ecx,%eax
movslq %r15d,%rdx
add    $0x1,%eax
lea    (%rdx,%rbp,1),%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%rcx,1),%rdi
cmp    %r14,%rdi
jg     1760 <get_tables+0x620>
movb   $0x0,(%rsi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1740 <get_tables+0x600>
cs nopw 0x0(%rax,%rax,1)
add    %ecx,%r15d
add    $0xffffffff,%r15d
jmp    1607 <get_tables+0x4c7>

LLVM IR (-O0):
@__const.get_tables.clen_weird_tangle = [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 i32 @get_tables(i8* %0, i64* %1, i8* %2, i32* %3, i8* %4, i32* %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64*
%10 = alloca i8*
%11 = alloca i32*
%12 = alloca i8*
%13 = alloca i32*
%14 = alloca i8
%15 = alloca i8
%16 = alloca i8
%17 = alloca [19 x i32]
%18 = alloca [19 x i8]
%19 = alloca [19 x i32]
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i8
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
store i8* %0, i8** %8
store i64* %1, i64** %9
store i8* %2, i8** %10
store i32* %3, i32** %11
store i8* %4, i8** %12
store i32* %5, i32** %13
%36 = bitcast [19 x i32]* %17 to i8*
%37 = load i8*, i8** %8
%38 = load i64*, i64** %9
%39 = call i8* @read_bits(i8* %37, i64* %38, i32 5)
%40 = ptrtoint i8* %39 to i8
store i8 %40, i8* %14
%41 = load i8*, i8** %8
%42 = load i64*, i64** %9
%43 = call i8* @read_bits(i8* %41, i64* %42, i32 5)
%44 = ptrtoint i8* %43 to i8
store i8 %44, i8* %15
%45 = load i8*, i8** %8
%46 = load i64*, i64** %9
%47 = call i8* @read_bits(i8* %45, i64* %46, i32 4)
%48 = ptrtoint i8* %47 to i8
store i8 %48, i8* %16
store i32 0, i32* %20
br label %49
49: ; preds = %66, %6
%50 = load i32, i32* %20
%51 = load i8, i8* %16
%52 = sext i8 %51 to i32
%53 = add nsw i32 4, %52
%54 = icmp slt i32 %50, %53
br i1 %54, label %55, label %69
55: ; preds = %49
%56 = load i8*, i8** %8
%57 = load i64*, i64** %9
%58 = call i8* @read_bits(i8* %56, i64* %57, i32 3)
%59 = ptrtoint i8* %58 to i8
%60 = load i32, i32* %20
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [19 x i32], [19 x i32]* %17, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [19 x i8], [19 x i8]* %18, i64 0, i64 %64
store i8 %59, i8* %65
br label %66
66: ; preds = %55
%67 = load i32, i32* %20
%68 = add nsw i32 %67, 1
store i32 %68, i32* %20
br label %49
69: ; preds = %49
br label %70
70: ; preds = %80, %69
%71 = load i32, i32* %20
%72 = icmp slt i32 %71, 19
br i1 %72, label %73, label %83
73: ; preds = %70
%74 = load i32, i32* %20
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [19 x i32], [19 x i32]* %17, i64 0, i64 %75
%77 = load i32, i32* %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [19 x i8], [19 x i8]* %18, i64 0, i64 %78
store i8 0, i8* %79
br label %80
80: ; preds = %73
%81 = load i32, i32* %20
%82 = add nsw i32 %81, 1
store i32 %82, i32* %20
br label %70
83: ; preds = %70
%84 = getelementptr inbounds [19 x i8], [19 x i8]* %18, i64 0, i64 0
%85 = getelementptr inbounds [19 x i32], [19 x i32]* %19, i64 0, i64 0
%86 = call i32 @make_code_table(i8* %84, i32 19, i32* %85, i32 15)
store i32 0, i32* %22
store i8 0, i8* %23
store i32 0, i32* %20
br label %87
87: ; preds = %254, %83
%88 = load i32, i32* %20
%89 = load i8, i8* %14
%90 = sext i8 %89 to i32
%91 = add nsw i32 257, %90
%92 = icmp slt i32 %88, %91
br i1 %92, label %93, label %257
93: ; preds = %87
%94 = load i8*, i8** %8
%95 = load i64*, i64** %9
%96 = getelementptr inbounds [19 x i8], [19 x i8]* %18, i64 0, i64 0
%97 = getelementptr inbounds [19 x i32], [19 x i32]* %19, i64 0, i64 0
%98 = call i32 @decode_one(i8* %94, i64* %95, i8* %96, i32 19, i32* %97, i32 15)
store i32 %98, i32* %21
%99 = load i32, i32* %21
%100 = icmp ult i32 %99, 0
br i1 %100, label %101, label %102
101: ; preds = %93
store i32 -1, i32* %7
br label %455
102: ; preds = %93
%103 = load i32, i32* %21
%104 = icmp ult i32 %103, 16
br i1 %104, label %105, label %112
105: ; preds = %102
%106 = load i32, i32* %21
%107 = trunc i32 %106 to i8
%108 = load i8*, i8** %10
%109 = load i32, i32* %20
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %108, i64 %110
store i8 %107, i8* %111
br label %253
112: ; preds = %102
%113 = load i32, i32* %21
%114 = icmp eq i32 %113, 16
br i1 %114, label %115, label %166
115: ; preds = %112
%116 = load i8*, i8** %8
%117 = load i64*, i64** %9
%118 = call i8* @read_bits(i8* %116, i64* %117, i32 2)
%119 = ptrtoint i8* %118 to i32
store i32 %119, i32* %24
store i32 0, i32* %25
br label %120
120: ; preds = %148, %115
%121 = load i32, i32* %25
%122 = load i32, i32* %24
%123 = add nsw i32 %122, 3
%124 = icmp slt i32 %121, %123
br i1 %124, label %125, label %133
125: ; preds = %120
%126 = load i32, i32* %20
%127 = load i32, i32* %25
%128 = add nsw i32 %126, %127
%129 = load i8, i8* %14
%130 = sext i8 %129 to i32
%131 = add nsw i32 257, %130
%132 = icmp slt i32 %128, %131
br label %133
133: ; preds = %125, %120
%134 = phi i1 [ false, %120 ], [ %132, %125 ]
br i1 %134, label %135, label %151
135: ; preds = %133
%136 = load i8*, i8** %10
%137 = load i32, i32* %20
%138 = sub nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %136, i64 %139
%141 = load i8, i8* %140
%142 = load i8*, i8** %10
%143 = load i32, i32* %20
%144 = load i32, i32* %25
%145 = add nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %142, i64 %146
store i8 %141, i8* %147
br label %148
148: ; preds = %135
%149 = load i32, i32* %25
%150 = add nsw i32 %149, 1
store i32 %150, i32* %25
br label %120
151: ; preds = %133
%152 = load i32, i32* %25
%153 = sub nsw i32 %152, 1
%154 = load i32, i32* %20
%155 = add nsw i32 %154, %153
store i32 %155, i32* %20
%156 = load i32, i32* %24
%157 = add nsw i32 %156, 3
%158 = load i32, i32* %25
%159 = sub nsw i32 %157, %158
store i32 %159, i32* %22
%160 = load i8*, i8** %10
%161 = load i32, i32* %20
%162 = sub nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %160, i64 %163
%165 = load i8, i8* %164
store i8 %165, i8* %23
br label %252
166: ; preds = %112
%167 = load i32, i32* %21
%168 = icmp eq i32 %167, 17
br i1 %168, label %169, label %208
169: ; preds = %166
%170 = load i8*, i8** %8
%171 = load i64*, i64** %9
%172 = call i8* @read_bits(i8* %170, i64* %171, i32 3)
%173 = ptrtoint i8* %172 to i32
store i32 %173, i32* %26
store i32 0, i32* %27
br label %174
174: ; preds = %196, %169
%175 = load i32, i32* %27
%176 = load i32, i32* %26
%177 = add nsw i32 %176, 3
%178 = icmp slt i32 %175, %177
br i1 %178, label %179, label %187
179: ; preds = %174
%180 = load i32, i32* %20
%181 = load i32, i32* %27
%182 = add nsw i32 %180, %181
%183 = load i8, i8* %14
%184 = sext i8 %183 to i32
%185 = add nsw i32 257, %184
%186 = icmp slt i32 %182, %185
br label %187
187: ; preds = %179, %174
%188 = phi i1 [ false, %174 ], [ %186, %179 ]
br i1 %188, label %189, label %199
189: ; preds = %187
%190 = load i8*, i8** %10
%191 = load i32, i32* %20
%192 = load i32, i32* %27
%193 = add nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8, i8* %190, i64 %194
store i8 0, i8* %195
br label %196
196: ; preds = %189
%197 = load i32, i32* %27
%198 = add nsw i32 %197, 1
store i32 %198, i32* %27
br label %174
199: ; preds = %187
%200 = load i32, i32* %27
%201 = sub nsw i32 %200, 1
%202 = load i32, i32* %20
%203 = add nsw i32 %202, %201
store i32 %203, i32* %20
%204 = load i32, i32* %26
%205 = add nsw i32 %204, 3
%206 = load i32, i32* %27
%207 = sub nsw i32 %205, %206
store i32 %207, i32* %22
store i8 0, i8* %23
br label %251
208: ; preds = %166
%209 = load i32, i32* %21
%210 = icmp eq i32 %209, 18
br i1 %210, label %211, label %250
211: ; preds = %208
%212 = load i8*, i8** %8
%213 = load i64*, i64** %9
%214 = call i8* @read_bits(i8* %212, i64* %213, i32 7)
%215 = ptrtoint i8* %214 to i32
store i32 %215, i32* %28
store i32 0, i32* %29
br label %216
216: ; preds = %238, %211
%217 = load i32, i32* %29
%218 = load i32, i32* %28
%219 = add nsw i32 %218, 11
%220 = icmp slt i32 %217, %219
br i1 %220, label %221, label %229
221: ; preds = %216
%222 = load i32, i32* %20
%223 = load i32, i32* %29
%224 = add nsw i32 %222, %223
%225 = load i8, i8* %14
%226 = sext i8 %225 to i32
%227 = add nsw i32 257, %226
%228 = icmp slt i32 %224, %227
br label %229
229: ; preds = %221, %216
%230 = phi i1 [ false, %216 ], [ %228, %221 ]
br i1 %230, label %231, label %241
231: ; preds = %229
%232 = load i8*, i8** %10
%233 = load i32, i32* %20
%234 = load i32, i32* %29
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i8, i8* %232, i64 %236
store i8 0, i8* %237
br label %238
238: ; preds = %231
%239 = load i32, i32* %29
%240 = add nsw i32 %239, 1
store i32 %240, i32* %29
br label %216
241: ; preds = %229
%242 = load i32, i32* %29
%243 = sub nsw i32 %242, 1
%244 = load i32, i32* %20
%245 = add nsw i32 %244, %243
store i32 %245, i32* %20
%246 = load i32, i32* %28
%247 = add nsw i32 %246, 11
%248 = load i32, i32* %29
%249 = sub nsw i32 %247, %248
store i32 %249, i32* %22
store i8 0, i8* %23
br label %250
250: ; preds = %241, %208
br label %251
251: ; preds = %250, %199
br label %252
252: ; preds = %251, %151
br label %253
253: ; preds = %252, %105
br label %254
254: ; preds = %253
%255 = load i32, i32* %20
%256 = add nsw i32 %255, 1
store i32 %256, i32* %20
br label %87
257: ; preds = %87
br label %258
258: ; preds = %266, %257
%259 = load i32, i32* %20
%260 = icmp slt i32 %259, 288
br i1 %260, label %261, label %269
261: ; preds = %258
%262 = load i8*, i8** %10
%263 = load i32, i32* %20
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
store i8 0, i8* %265
br label %266
266: ; preds = %261
%267 = load i32, i32* %20
%268 = add nsw i32 %267, 1
store i32 %268, i32* %20
br label %258
269: ; preds = %258
%270 = load i8*, i8** %10
%271 = load i32*, i32** %11
%272 = call i32 @make_code_table(i8* %270, i32 288, i32* %271, i32 15)
store i32 0, i32* %20
br label %273
273: ; preds = %283, %269
%274 = load i32, i32* %20
%275 = load i32, i32* %22
%276 = icmp slt i32 %274, %275
br i1 %276, label %277, label %286
277: ; preds = %273
%278 = load i8, i8* %23
%279 = load i8*, i8** %12
%280 = load i32, i32* %20
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i8, i8* %279, i64 %281
store i8 %278, i8* %282
br label %283
283: ; preds = %277
%284 = load i32, i32* %20
%285 = add nsw i32 %284, 1
store i32 %285, i32* %20
br label %273
286: ; preds = %273
br label %287
287: ; preds = %436, %286
%288 = load i32, i32* %20
%289 = load i8, i8* %15
%290 = sext i8 %289 to i32
%291 = add nsw i32 1, %290
%292 = icmp slt i32 %288, %291
br i1 %292, label %293, label %439
293: ; preds = %287
%294 = load i8*, i8** %8
%295 = load i64*, i64** %9
%296 = getelementptr inbounds [19 x i8], [19 x i8]* %18, i64 0, i64 0
%297 = getelementptr inbounds [19 x i32], [19 x i32]* %19, i64 0, i64 0
%298 = call i32 @decode_one(i8* %294, i64* %295, i8* %296, i32 19, i32* %297, i32 15)
store i32 %298, i32* %21
%299 = load i32, i32* %21
%300 = icmp ult i32 %299, 0
br i1 %300, label %301, label %302
301: ; preds = %293
store i32 -1, i32* %7
br label %455
302: ; preds = %293
%303 = load i32, i32* %21
%304 = icmp ult i32 %303, 16
br i1 %304, label %305, label %312
305: ; preds = %302
%306 = load i32, i32* %21
%307 = trunc i32 %306 to i8
%308 = load i8*, i8** %12
%309 = load i32, i32* %20
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i8, i8* %308, i64 %310
store i8 %307, i8* %311
br label %435
312: ; preds = %302
%313 = load i32, i32* %21
%314 = icmp eq i32 %313, 16
br i1 %314, label %315, label %356
315: ; preds = %312
%316 = load i8*, i8** %8
%317 = load i64*, i64** %9
%318 = call i8* @read_bits(i8* %316, i64* %317, i32 2)
%319 = ptrtoint i8* %318 to i32
store i32 %319, i32* %30
store i32 0, i32* %31
br label %320
320: ; preds = %348, %315
%321 = load i32, i32* %31
%322 = load i32, i32* %30
%323 = add nsw i32 %322, 3
%324 = icmp slt i32 %321, %323
br i1 %324, label %325, label %333
325: ; preds = %320
%326 = load i32, i32* %20
%327 = load i32, i32* %31
%328 = add nsw i32 %326, %327
%329 = load i8, i8* %15
%330 = sext i8 %329 to i32
%331 = add nsw i32 1, %330
%332 = icmp slt i32 %328, %331
br label %333
333: ; preds = %325, %320
%334 = phi i1 [ false, %320 ], [ %332, %325 ]
br i1 %334, label %335, label %351
335: ; preds = %333
%336 = load i8*, i8** %12
%337 = load i32, i32* %20
%338 = sub nsw i32 %337, 1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i8, i8* %336, i64 %339
%341 = load i8, i8* %340
%342 = load i8*, i8** %12
%343 = load i32, i32* %20
%344 = load i32, i32* %31
%345 = add nsw i32 %343, %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %342, i64 %346
store i8 %341, i8* %347
br label %348
348: ; preds = %335
%349 = load i32, i32* %31
%350 = add nsw i32 %349, 1
store i32 %350, i32* %31
br label %320
351: ; preds = %333
%352 = load i32, i32* %31
%353 = sub nsw i32 %352, 1
%354 = load i32, i32* %20
%355 = add nsw i32 %354, %353
store i32 %355, i32* %20
br label %434
356: ; preds = %312
%357 = load i32, i32* %21
%358 = icmp eq i32 %357, 17
br i1 %358, label %359, label %394
359: ; preds = %356
%360 = load i8*, i8** %8
%361 = load i64*, i64** %9
%362 = call i8* @read_bits(i8* %360, i64* %361, i32 3)
%363 = ptrtoint i8* %362 to i32
store i32 %363, i32* %32
store i32 0, i32* %33
br label %364
364: ; preds = %386, %359
%365 = load i32, i32* %33
%366 = load i32, i32* %32
%367 = add nsw i32 %366, 3
%368 = icmp slt i32 %365, %367
br i1 %368, label %369, label %377
369: ; preds = %364
%370 = load i32, i32* %20
%371 = load i32, i32* %33
%372 = add nsw i32 %370, %371
%373 = load i8, i8* %15
%374 = sext i8 %373 to i32
%375 = add nsw i32 1, %374
%376 = icmp slt i32 %372, %375
br label %377
377: ; preds = %369, %364
%378 = phi i1 [ false, %364 ], [ %376, %369 ]
br i1 %378, label %379, label %389
379: ; preds = %377
%380 = load i8*, i8** %12
%381 = load i32, i32* %20
%382 = load i32, i32* %33
%383 = add nsw i32 %381, %382
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i8, i8* %380, i64 %384
store i8 0, i8* %385
br label %386
386: ; preds = %379
%387 = load i32, i32* %33
%388 = add nsw i32 %387, 1
store i32 %388, i32* %33
br label %364
389: ; preds = %377
%390 = load i32, i32* %33
%391 = sub nsw i32 %390, 1
%392 = load i32, i32* %20
%393 = add nsw i32 %392, %391
store i32 %393, i32* %20
br label %433
394: ; preds = %356
%395 = load i32, i32* %21
%396 = icmp eq i32 %395, 18
br i1 %396, label %397, label %432
397: ; preds = %394
%398 = load i8*, i8** %8
%399 = load i64*, i64** %9
%400 = call i8* @read_bits(i8* %398, i64* %399, i32 7)
%401 = ptrtoint i8* %400 to i32
store i32 %401, i32* %34
store i32 0, i32* %35
br label %402
402: ; preds = %424, %397
%403 = load i32, i32* %35
%404 = load i32, i32* %34
%405 = add nsw i32 %404, 11
%406 = icmp slt i32 %403, %405
br i1 %406, label %407, label %415
407: ; preds = %402
%408 = load i32, i32* %20
%409 = load i32, i32* %35
%410 = add nsw i32 %408, %409
%411 = load i8, i8* %15
%412 = sext i8 %411 to i32
%413 = add nsw i32 1, %412
%414 = icmp slt i32 %410, %413
br label %415
415: ; preds = %407, %402
%416 = phi i1 [ false, %402 ], [ %414, %407 ]
br i1 %416, label %417, label %427
417: ; preds = %415
%418 = load i8*, i8** %12
%419 = load i32, i32* %20
%420 = load i32, i32* %35
%421 = add nsw i32 %419, %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i8, i8* %418, i64 %422
store i8 0, i8* %423
br label %424
424: ; preds = %417
%425 = load i32, i32* %35
%426 = add nsw i32 %425, 1
store i32 %426, i32* %35
br label %402
427: ; preds = %415
%428 = load i32, i32* %35
%429 = sub nsw i32 %428, 1
%430 = load i32, i32* %20
%431 = add nsw i32 %430, %429
store i32 %431, i32* %20
br label %432
432: ; preds = %427, %394
br label %433
433: ; preds = %432, %389
br label %434
434: ; preds = %433, %351
br label %435
435: ; preds = %434, %305
br label %436
436: ; preds = %435
%437 = load i32, i32* %20
%438 = add nsw i32 %437, 1
store i32 %438, i32* %20
br label %287
439: ; preds = %287
br label %440
440: ; preds = %448, %439
%441 = load i32, i32* %20
%442 = icmp slt i32 %441, 30
br i1 %442, label %443, label %451
443: ; preds = %440
%444 = load i8*, i8** %12
%445 = load i32, i32* %20
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i8, i8* %444, i64 %446
store i8 0, i8* %447
br label %448
448: ; preds = %443
%449 = load i32, i32* %20
%450 = add nsw i32 %449, 1
store i32 %450, i32* %20
br label %440
451: ; preds = %440
%452 = load i8*, i8** %12
%453 = load i32*, i32** %13
%454 = call i32 @make_code_table(i8* %452, i32 30, i32* %453, i32 15)
store i32 0, i32* %7
br label %455
455: ; preds = %451, %301, %101
%456 = load i32, i32* %7
ret i32 %456
}

LLVM IR (-O2):
@__const.get_tables.clen_weird_tangle = [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 i32 @get_tables(i8* %0, i64* %1, i8* %2, i32* %3, i8* %4, i32* %5) {
%7 = alloca [19 x i8]
%8 = alloca [19 x i32]
%9 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 0
%10 = bitcast [19 x i32]* %8 to i8*
%11 = tail call i8* @read_bits(i8* %0, i64* %1, i32 5)
%12 = ptrtoint i8* %11 to i64
%13 = trunc i64 %12 to i32
%14 = tail call i8* @read_bits(i8* %0, i64* %1, i32 5)
%15 = ptrtoint i8* %14 to i64
%16 = trunc i64 %15 to i32
%17 = tail call i8* @read_bits(i8* %0, i64* %1, i32 4)
%18 = ptrtoint i8* %17 to i64
%19 = trunc i64 %18 to i32
%20 = shl i32 %19, 24
%21 = icmp sgt i32 %20, -67108864
br i1 %21, label %22, label %29
22: ; preds = %6
%23 = ashr exact i32 %20, 24
%24 = call i32 @llvm.smax.i32(i32 %23, i32 -3)
%25 = add nsw i32 %24, 4
%26 = zext i32 %25 to i64
br label %49
27: ; preds = %49
%28 = icmp ult i32 %25, 19
br i1 %28, label %29, label %83
29: ; preds = %6, %27
%30 = phi i32 [ %25, %27 ], [ 0, %6 ]
%31 = zext i32 %30 to i64
%32 = sub nsw i64 3, %31
%33 = and i64 %32, 3
%34 = icmp eq i64 %33, 0
br i1 %34, label %45, label %35
35: ; preds = %29, %35
%36 = phi i64 [ %42, %35 ], [ %31, %29 ]
%37 = phi i64 [ %43, %35 ], [ 0, %29 ]
%38 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %36
%39 = load i32, i32* %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %40
store i8 0, i8* %41
%42 = add nuw nsw i64 %36, 1
%43 = add i64 %37, 1
%44 = icmp eq i64 %43, %33
br i1 %44, label %45, label %35
45: ; preds = %35, %29
%46 = phi i64 [ %31, %29 ], [ %42, %35 ]
%47 = add nsw i64 %31, -16
%48 = icmp ult i64 %47, 3
br i1 %48, label %83, label %60
49: ; preds = %22, %49
%50 = phi i64 [ 0, %22 ], [ %58, %49 ]
%51 = tail call i8* @read_bits(i8* %0, i64* %1, i32 3)
%52 = ptrtoint i8* %51 to i64
%53 = trunc i64 %52 to i8
%54 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %50
%55 = load i32, i32* %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %56
store i8 %53, i8* %57
%58 = add nuw nsw i64 %50, 1
%59 = icmp eq i64 %58, %26
br i1 %59, label %27, label %49
60: ; preds = %45, %60
%61 = phi i64 [ %81, %60 ], [ %46, %45 ]
%62 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %64
store i8 0, i8* %65
%66 = add nuw nsw i64 %61, 1
%67 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %66
%68 = load i32, i32* %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %69
store i8 0, i8* %70
%71 = add nuw nsw i64 %61, 2
%72 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %74
store i8 0, i8* %75
%76 = add nuw nsw i64 %61, 3
%77 = getelementptr inbounds [19 x i32], [19 x i32]* @__const.get_tables.clen_weird_tangle, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [19 x i8], [19 x i8]* %7, i64 0, i64 %79
store i8 0, i8* %80
%81 = add nuw nsw i64 %61, 4
%82 = icmp eq i64 %81, 19
br i1 %82, label %83, label %60
83: ; preds = %45, %60, %27
%84 = getelementptr inbounds [19 x i32], [19 x i32]* %8, i64 0, i64 0
%85 = call i32 @make_code_table(i8* %9, i32 19, i32* %84, i32 15)
%86 = shl i32 %13, 24
%87 = ashr exact i32 %86, 24
%88 = add nsw i32 %87, 257
br label %97
89: ; preds = %238
%90 = icmp slt i32 %241, 287
br i1 %90, label %91, label %244
91: ; preds = %89
%92 = sext i32 %242 to i64
%93 = getelementptr i8, i8* %2, i64 %92
%94 = sub i32 286, %241
%95 = zext i32 %94 to i64
%96 = add nuw nsw i64 %95, 1
br label %244
97: ; preds = %83, %238
%98 = phi i32 [ %242, %238 ], [ 0, %83 ]
%99 = phi i32 [ %240, %238 ], [ 0, %83 ]
%100 = phi i8 [ %239, %238 ], [ 0, %83 ]
%101 = call i32 @decode_one(i8* %0, i64* %1, i8* %9, i32 19, i32* %84, i32 15)
%102 = icmp ult i32 %101, 16
br i1 %102, label %103, label %107
103: ; preds = %97
%104 = trunc i32 %101 to i8
%105 = sext i32 %98 to i64
%106 = getelementptr inbounds i8, i8* %2, i64 %105
store i8 %104, i8* %106
br label %238
107: ; preds = %97
switch i32 %101, label %238 [
i32 16, label %108
i32 17, label %144
i32 18, label %191
]
108: ; preds = %107
%109 = call i8* @read_bits(i8* %0, i64* %1, i32 2)
%110 = ptrtoint i8* %109 to i64
%111 = trunc i64 %110 to i32
%112 = add i32 %111, 3
%113 = icmp sgt i32 %111, -3
%114 = add i32 %98, -1
br i1 %113, label %115, label %136
115: ; preds = %108
%116 = sext i32 %114 to i64
%117 = getelementptr inbounds i8, i8* %2, i64 %116
%118 = sext i32 %98 to i64
%119 = call i32 @llvm.smax.i32(i32 %98, i32 %88)
%120 = sub i32 %119, %98
%121 = zext i32 %120 to i64
%122 = call i32 @llvm.smax.i32(i32 %112, i32 1)
%123 = zext i32 %122 to i64
br label %124
124: ; preds = %115, %127
%125 = phi i64 [ 0, %115 ], [ %131, %127 ]
%126 = icmp eq i64 %125, %121
br i1 %126, label %133, label %127
127: ; preds = %124
%128 = add nsw i64 %125, %118
%129 = load i8, i8* %117
%130 = getelementptr inbounds i8, i8* %2, i64 %128
store i8 %129, i8* %130
%131 = add nuw nsw i64 %125, 1
%132 = icmp eq i64 %131, %123
br i1 %132, label %133, label %124
133: ; preds = %127, %124
%134 = phi i64 [ %125, %124 ], [ %131, %127 ]
%135 = trunc i64 %134 to i32
br label %136
136: ; preds = %108, %133
%137 = phi i32 [ %135, %133 ], [ 0, %108 ]
%138 = add i32 %114, %137
%139 = sub nsw i32 %112, %137
%140 = add nsw i32 %138, -1
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i8, i8* %2, i64 %141
%143 = load i8, i8* %142
br label %238
144: ; preds = %107
%145 = call i8* @read_bits(i8* %0, i64* %1, i32 3)
%146 = ptrtoint i8* %145 to i64
%147 = trunc i64 %146 to i32
%148 = add i32 %147, 3
%149 = icmp sgt i32 %147, -3
br i1 %149, label %150, label %186
150: ; preds = %144
%151 = sext i32 %98 to i64
%152 = call i32 @llvm.smax.i32(i32 %98, i32 %88)
%153 = sub i32 %152, %98
%154 = zext i32 %153 to i64
%155 = call i32 @llvm.smax.i32(i32 %148, i32 1)
%156 = zext i32 %155 to i64
%157 = add nsw i64 %156, -1
%158 = call i64 @llvm.umin.i64(i64 %157, i64 %154)
%159 = add nuw nsw i64 %158, 1
%160 = icmp ult i64 %158, 16
br i1 %160, label %173, label %161
161: ; preds = %150
%162 = and i64 %159, 15
%163 = icmp eq i64 %162, 0
%164 = select i1 %163, i64 16, i64 %162
%165 = sub nsw i64 %159, %164
br label %166
166: ; preds = %166, %161
%167 = phi i64 [ 0, %161 ], [ %171, %166 ]
%168 = add nsw i64 %167, %151
%169 = getelementptr inbounds i8, i8* %2, i64 %168
%170 = bitcast i8* %169 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %170
%171 = add nuw i64 %167, 16
%172 = icmp eq i64 %171, %165
br i1 %172, label %173, label %166
173: ; preds = %166, %150
%174 = phi i64 [ 0, %150 ], [ %165, %166 ]
br label %175
175: ; preds = %173, %178
%176 = phi i64 [ %181, %178 ], [ %174, %173 ]
%177 = icmp eq i64 %176, %154
br i1 %177, label %183, label %178
178: ; preds = %175
%179 = add nsw i64 %176, %151
%180 = getelementptr inbounds i8, i8* %2, i64 %179
store i8 0, i8* %180
%181 = add nuw nsw i64 %176, 1
%182 = icmp eq i64 %181, %156
br i1 %182, label %183, label %175
183: ; preds = %178, %175
%184 = phi i64 [ %176, %175 ], [ %181, %178 ]
%185 = trunc i64 %184 to i32
br label %186
186: ; preds = %183, %144
%187 = phi i32 [ 0, %144 ], [ %185, %183 ]
%188 = add i32 %98, -1
%189 = add i32 %188, %187
%190 = sub nsw i32 %148, %187
br label %238
191: ; preds = %107
%192 = call i8* @read_bits(i8* %0, i64* %1, i32 7)
%193 = ptrtoint i8* %192 to i64
%194 = trunc i64 %193 to i32
%195 = add i32 %194, 11
%196 = icmp sgt i32 %194, -11
br i1 %196, label %197, label %233
197: ; preds = %191
%198 = sext i32 %98 to i64
%199 = call i32 @llvm.smax.i32(i32 %98, i32 %88)
%200 = sub i32 %199, %98
%201 = zext i32 %200 to i64
%202 = call i32 @llvm.smax.i32(i32 %195, i32 1)
%203 = zext i32 %202 to i64
%204 = add nsw i64 %203, -1
%205 = call i64 @llvm.umin.i64(i64 %204, i64 %201)
%206 = add nuw nsw i64 %205, 1
%207 = icmp ult i64 %205, 16
br i1 %207, label %220, label %208
208: ; preds = %197
%209 = and i64 %206, 15
%210 = icmp eq i64 %209, 0
%211 = select i1 %210, i64 16, i64 %209
%212 = sub nsw i64 %206, %211
br label %213
213: ; preds = %213, %208
%214 = phi i64 [ 0, %208 ], [ %218, %213 ]
%215 = add nsw i64 %214, %198
%216 = getelementptr inbounds i8, i8* %2, i64 %215
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> zeroinitializer, <16 x i8>* %217
%218 = add nuw i64 %214, 16
%219 = icmp eq i64 %218, %212
br i1 %219, label %220, label %213
220: ; preds = %213, %197
%221 = phi i64 [ 0, %197 ], [ %212, %213 ]
br label %222
222: ; preds = %220, %225
%223 = phi i64 [ %228, %225 ], [ %221, %220 ]
%224 = icmp eq i64 %223, %201
br i1 %224, label %230, label %225
225: ; preds = %222
%226 = add nsw i64 %223, %198
%227 = getelementptr inbounds i8, i8* %2, i64 %226
store i8 0, i8* %227
%228 = add nuw nsw i64 %223, 1
%229 = icmp eq i64 %228, %203
br i1 %229, label %230, label %222
230: ; preds = %225, %222
%231 = phi i64 [ %223, %222 ], [ %228, %225 ]
%232 = trunc i64 %231 to i32
br label %233
233: ; preds = %230, %191
%234 = phi i32 [ 0, %191 ], [ %232, %230 ]
%235 = add i32 %98, -1
%236 = add i32 %235, %234
%237 = sub nsw i32 %195, %234
br label %238
238: ; preds = %107, %103, %186, %233, %136
%239 = phi i8 [ %100, %103 ], [ %143, %136 ], [ 0, %186 ], [ 0, %233 ], [ %100, %107 ]
%240 = phi i32 [ %99, %103 ], [ %139, %136 ], [ %190, %186 ], [ %237, %233 ], [ %99, %107 ]
%241 = phi i32 [ %98, %103 ], [ %138, %136 ], [ %189, %186 ], [ %236, %233 ], [ %98, %107 ]
%242 = add nsw i32 %241, 1
%243 = icmp slt i32 %242, %88
br i1 %243, label %97, label %89
244: ; preds = %91, %89
%245 = call i32 @make_code_table(i8* %2, i32 288, i32* %3, i32 15)
%246 = icmp sgt i32 %240, 0
br i1 %246, label %247, label %249
247: ; preds = %244
%248 = zext i32 %240 to i64
br label %249
249: ; preds = %247, %244
%250 = phi i32 [ 0, %244 ], [ %240, %247 ]
%251 = shl i32 %16, 24
%252 = ashr exact i32 %251, 24
%253 = icmp sgt i32 %250, %252
br i1 %253, label %257, label %254
254: ; preds = %249
%255 = shl i64 %15, 56
%256 = ashr exact i64 %255, 56
br label %266
257: ; preds = %356, %249
%258 = phi i32 [ %250, %249 ], [ %358, %356 ]
%259 = icmp slt i32 %258, 30
br i1 %259, label %260, label %360
260: ; preds = %257
%261 = sext i32 %258 to i64
%262 = getelementptr i8, i8* %4, i64 %261
%263 = sub i32 29, %258
%264 = zext i32 %263 to i64
%265 = add nuw nsw i64 %264, 1
br label %360
266: ; preds = %254, %356
%267 = phi i32 [ %358, %356 ], [ %250, %254 ]
%268 = call i32 @decode_one(i8* %0, i64* %1, i8* %9, i32 19, i32* %84, i32 15)
%269 = icmp ult i32 %268, 16
br i1 %269, label %270, label %274
270: ; preds = %266
%271 = trunc i32 %268 to i8
%272 = sext i32 %267 to i64
%273 = getelementptr inbounds i8, i8* %4, i64 %272
store i8 %271, i8* %273
br label %356
274: ; preds = %266
switch i32 %268, label %356 [
i32 16, label %275
i32 17, label %304
i32 18, label %330
]
275: ; preds = %274
%276 = call i8* @read_bits(i8* %0, i64* %1, i32 2)
%277 = ptrtoint i8* %276 to i64
%278 = trunc i64 %277 to i32
%279 = icmp sgt i32 %278, -3
%280 = add nsw i32 %267, -1
br i1 %279, label %281, label %301
281: ; preds = %275
%282 = sext i32 %280 to i64
%283 = getelementptr inbounds i8, i8* %4, i64 %282
%284 = sext i32 %267 to i64
%285 = add i32 %278, 2
%286 = call i32 @llvm.smax.i32(i32 %285, i32 0)
%287 = add nuw i32 %286, 1
%288 = zext i32 %287 to i64
br label %289
289: ; preds = %281, %293
%290 = phi i64 [ 0, %281 ], [ %296, %293 ]
%291 = add nsw i64 %290, %284
%292 = icmp sgt i64 %291, %256
br i1 %292, label %298, label %293
293: ; preds = %289
%294 = load i8, i8* %283
%295 = getelementptr inbounds i8, i8* %4, i64 %291
store i8 %294, i8* %295
%296 = add nuw nsw i64 %290, 1
%297 = icmp eq i64 %296, %288
br i1 %297, label %298, label %289
298: ; preds = %293, %289
%299 = phi i64 [ %290, %289 ], [ %296, %293 ]
%300 = trunc i64 %299 to i32
br label %301
301: ; preds = %275, %298
%302 = phi i32 [ %300, %298 ], [ 0, %275 ]
%303 = add i32 %280, %302
br label %356
304: ; preds = %274
%305 = call i8* @read_bits(i8* %0, i64* %1, i32 3)
%306 = ptrtoint i8* %305 to i64
%307 = trunc i64 %306 to i32
%308 = icmp sgt i32 %307, -3
br i1 %308, label %309, label %326
309: ; preds = %304
%310 = sext i32 %267 to i64
%311 = add i32 %307, 2
%312 = call i32 @llvm.smax.i32(i32 %311, i32 0)
%313 = add nuw i32 %312, 1
%314 = zext i32 %313 to i64
br label %315
315: ; preds = %309, %319
%316 = phi i64 [ 0, %309 ], [ %321, %319 ]
%317 = add nsw i64 %316, %310
%318 = icmp sgt i64 %317, %256
br i1 %318, label %323, label %319
319: ; preds = %315
%320 = getelementptr inbounds i8, i8* %4, i64 %317
store i8 0, i8* %320
%321 = add nuw nsw i64 %316, 1
%322 = icmp eq i64 %321, %314
br i1 %322, label %323, label %315
323: ; preds = %319, %315
%324 = phi i64 [ %316, %315 ], [ %321, %319 ]
%325 = trunc i64 %324 to i32
br label %326
326: ; preds = %323, %304
%327 = phi i32 [ 0, %304 ], [ %325, %323 ]
%328 = add i32 %267, -1
%329 = add i32 %328, %327
br label %356
330: ; preds = %274
%331 = call i8* @read_bits(i8* %0, i64* %1, i32 7)
%332 = ptrtoint i8* %331 to i64
%333 = trunc i64 %332 to i32
%334 = icmp sgt i32 %333, -11
br i1 %334, label %335, label %352
335: ; preds = %330
%336 = sext i32 %267 to i64
%337 = add i32 %333, 10
%338 = call i32 @llvm.smax.i32(i32 %337, i32 0)
%339 = add nuw i32 %338, 1
%340 = zext i32 %339 to i64
br label %341
341: ; preds = %335, %345
%342 = phi i64 [ 0, %335 ], [ %347, %345 ]
%343 = add nsw i64 %342, %336
%344 = icmp sgt i64 %343, %256
br i1 %344, label %349, label %345
345: ; preds = %341
%346 = getelementptr inbounds i8, i8* %4, i64 %343
store i8 0, i8* %346
%347 = add nuw nsw i64 %342, 1
%348 = icmp eq i64 %347, %340
br i1 %348, label %349, label %341
349: ; preds = %345, %341
%350 = phi i64 [ %342, %341 ], [ %347, %345 ]
%351 = trunc i64 %350 to i32
br label %352
352: ; preds = %349, %330
%353 = phi i32 [ 0, %330 ], [ %351, %349 ]
%354 = add i32 %267, -1
%355 = add i32 %354, %353
br label %356
356: ; preds = %274, %270, %326, %352, %301
%357 = phi i32 [ %267, %270 ], [ %303, %301 ], [ %329, %326 ], [ %355, %352 ], [ %267, %274 ]
%358 = add nsw i32 %357, 1
%359 = icmp slt i32 %357, %252
br i1 %359, label %266, label %257
360: ; preds = %260, %257
%361 = call i32 @make_code_table(i8* %4, i32 30, i32* %5, i32 15)
ret i32 0
}