long falcom_EncodeDataBlock(unsigned char *dst, long dst_size,
                            unsigned char *src, long src_size, int block_num) {
  if (src_size > 0xFFF0)
    src_size = 0xFFF0;
  int f, fill_mode;
  long fill_len;
  long j, n;
  long len;
  long block_size;
  long block_size_off;
  long block_src_size;
  long fill_size_min = 0x0E;
  unsigned long flags;
  long flags_len;
  long flags_off;
  long dst_off, src_off;
  long back_off;
  long back_off_max = -0x2000;
  dst_off = 0;
  src_off = 0;
  block_size = 4;
  block_size_off = dst_off;
  dst_off += 2;
  block_src_size = 0;
  flags = 0;
  flags_len = 8;
  flags_off = dst_off;
  dst_off += 2;
  while (dst_off < dst_size && src_off < src_size) {
    len = 0;
    fill_len = 0;
    back_off = 0;
    fill_mode = 0;
    if (src_off < src_size - fill_size_min) {
      fill_mode = 1;
      for (j = 0; j < fill_size_min; j++) {
        if (src[src_off] != src[src_off + j]) {
          fill_mode = 0;
          break;
        }
      }
      if (fill_mode) {
        for (n = fill_size_min;; n++) {
          if (src_off + n >= src_size)
            break;
          if (src[src_off] != src[src_off + n])
            break;
          if (n >= 0xFFF + 0x00)
            break;
        }
        fill_len = n;
      }
    }
    if (src_off < src_size - 2) {
      for (j = -1; j > back_off_max; j--) {
        if ((src_off + j) < 0)
          break;
        if (*(unsigned short *)(src + src_off) !=
            *(unsigned short *)(src + src_off + j))
          continue;
        for (n = 2;; n++) {
          if (src_off + n >= src_size)
            break;
          if (src[src_off + n] != src[src_off + j + n])
            break;
          if (n > 0xFF + 0x0E)
            break;
        }
        if (n > 0xFF + 0x0E)
          n = 0xFF + 0x0E;
        if (n > len) {
          len = n;
          back_off = j;
        }
      }
    }
    if (back_off && fill_len < 0x40 && len > 0x02)
      fill_mode = 0;
    if (fill_mode) {
      len = fill_len;
      flags |= (1 << flags_len);
      flags_len++;
      flags |= (1 << flags_len);
      flags_len++;
      flags_len++;
      flags_len += 4;
      if (flags_len == 16) {
        dst[dst_off++] = 0x01;
        block_size++;
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
      } else {
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
        dst[dst_off++] = 0x01;
        block_size++;
      }
      if (len <= 0x1d) {
        flags_len++;
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
        n = len - 0x0E;
        for (j = 3; j >= 0; j--) {
          flags |= ((n & 1) << (flags_len + j));
          n >>= 1;
        }
        flags_len += 4;
        if (flags_len == 16) {
          dst[dst_off++] = src[src_off];
          block_size++;
          block_size += falcom_write_bit_flags(dst, &dst_off, &flags,
                                               &flags_len, &flags_off);
        } else {
          block_size += falcom_write_bit_flags(dst, &dst_off, &flags,
                                               &flags_len, &flags_off);
          dst[dst_off++] = src[src_off];
          block_size++;
        }
      } else {
        flags |= (1 << flags_len);
        flags_len++;
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
        n = len - 0x0E;
        n = n / 0x100;
        for (j = 3; j >= 0; j--) {
          flags |= ((n & 1) << (flags_len + j));
          n >>= 1;
        }
        flags_len += 4;
        n = (len - 0x0E) & 0xFF;
        if (flags_len == 16) {
          dst[dst_off++] = (unsigned char)n;
          block_size++;
          dst[dst_off++] = src[src_off];
          block_size++;
          block_size += falcom_write_bit_flags(dst, &dst_off, &flags,
                                               &flags_len, &flags_off);
        } else {
          block_size += falcom_write_bit_flags(dst, &dst_off, &flags,
                                               &flags_len, &flags_off);
          dst[dst_off++] = (unsigned char)n;
          block_size++;
          dst[dst_off++] = src[src_off];
          block_size++;
        }
      }
      src_off += len;
      block_src_size += len;
      continue;
    }
    if (back_off == 0) {
      flags_len++;
      dst[dst_off++] = src[src_off++];
      block_src_size++;
      block_size++;
      block_size +=
          falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
      continue;
    }
    src_off += len;
    block_src_size += len;
    flags |= (1 << flags_len);
    flags_len++;
    block_size +=
        falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
    back_off *= -1;
    f = 0;
    if (back_off < 0x100) {
      dst[dst_off++] = (unsigned char)back_off;
      block_size++;
    } else {
      n = back_off;
      flags |= (1 << flags_len);
      flags_len++;
      if (n >= 0x1000) {
        flags |= (1 << flags_len);
        n -= 0x1000;
      }
      flags_len++;
      n = n / 0x100;
      for (j = 3; j >= 0; j--) {
        flags |= ((n & 1) << (flags_len + j));
        n >>= 1;
      }
      flags_len += 4;
      if (flags_len == 16) {
        dst[dst_off++] = (unsigned char)(back_off & 0xFF);
        block_size++;
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
      } else {
        block_size += falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len,
                                             &flags_off);
        dst[dst_off++] = (unsigned char)(back_off & 0xFF);
        block_size++;
      }
      f = 1;
    }
    if (len < 0x06) {
      flags_len += len - f;
      flags |= (1 << (flags_len - 1));
      block_size +=
          falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
      continue;
    }
    if (len < 0x0E) {
      flags_len += 5 - f;
      n = len + 2;
      for (j = 3; j >= 0; j--) {
        flags |= ((n & 1) << (flags_len + j));
        n >>= 1;
      }
      flags_len += 4;
      block_size +=
          falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
      continue;
    }
    flags_len++;
    flags_len += 5 - f;
    if (flags_len == 16) {
      dst[dst_off++] = (unsigned char)(len - 0x0E);
      block_size++;
      block_size +=
          falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
    } else {
      block_size +=
          falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
      dst[dst_off++] = (unsigned char)(len - 0x0E);
      block_size++;
    }
  }
  if (src_off == src_size) {
    flags |= (1 << flags_len);
    flags_len++;
    flags |= (1 << flags_len);
    flags_len++;
    flags_len += 5;
    block_size +=
        falcom_write_bit_flags(dst, &dst_off, &flags, &flags_len, &flags_off);
    dst[dst_off++] = 0x00;
    block_size++;
  }
  *(unsigned short *)(&dst[flags_off]) = (unsigned short)flags;
  *(unsigned short *)(&dst[block_size_off]) = (unsigned short)block_size;
  dst[dst_off++] = (unsigned char)block_num;
  return dst_off;
}


x86 assembly (clang, -O0):
<falcom_EncodeDataBlock>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpq   $0xfff0,-0x20(%rbp)
jle    1145 <falcom_EncodeDataBlock+0x35>
movq   $0xfff0,-0x20(%rbp)
movq   $0xe,-0x70(%rbp)
movq   $0xffffffffffffe000,-0xa8(%rbp)
movq   $0x0,-0x90(%rbp)
movq   $0x0,-0x98(%rbp)
movq   $0x4,-0x58(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x8,-0x80(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0xa9(%rbp)
jge    11f8 <falcom_EncodeDataBlock+0xe8>
mov    -0x98(%rbp),%rax
cmp    -0x20(%rbp),%rax
setl   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    120b <falcom_EncodeDataBlock+0xfb>
jmp    1ea1 <falcom_EncodeDataBlock+0xd91>
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0xa0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    -0x70(%rbp),%rcx
cmp    %rcx,%rax
jge    133f <falcom_EncodeDataBlock+0x22f>
movl   $0x1,-0x2c(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x70(%rbp),%rax
jge    12ae <falcom_EncodeDataBlock+0x19e>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x98(%rbp),%rdx
add    -0x40(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1298 <falcom_EncodeDataBlock+0x188>
movl   $0x0,-0x2c(%rbp)
jmp    12ae <falcom_EncodeDataBlock+0x19e>
jmp    129d <falcom_EncodeDataBlock+0x18d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1254 <falcom_EncodeDataBlock+0x144>
cmpl   $0x0,-0x2c(%rbp)
je     133a <falcom_EncodeDataBlock+0x22a>
mov    -0x70(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x98(%rbp),%rax
add    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jl     12da <falcom_EncodeDataBlock+0x1ca>
jmp    1332 <falcom_EncodeDataBlock+0x222>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x98(%rbp),%rdx
add    -0x48(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1309 <falcom_EncodeDataBlock+0x1f9>
jmp    1332 <falcom_EncodeDataBlock+0x222>
cmpq   $0xfff,-0x48(%rbp)
jl     131c <falcom_EncodeDataBlock+0x20c>
jmp    1332 <falcom_EncodeDataBlock+0x222>
jmp    1321 <falcom_EncodeDataBlock+0x211>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    12c0 <falcom_EncodeDataBlock+0x1b0>
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    133f <falcom_EncodeDataBlock+0x22f>
mov    -0x98(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jge    148d <falcom_EncodeDataBlock+0x37d>
movq   $0xffffffffffffffff,-0x40(%rbp)
ff
mov    -0x40(%rbp),%rax
cmp    -0xa8(%rbp),%rax
jle    1488 <falcom_EncodeDataBlock+0x378>
mov    -0x98(%rbp),%rax
add    -0x40(%rbp),%rax
cmp    $0x0,%rax
jge    138a <falcom_EncodeDataBlock+0x27a>
jmp    1488 <falcom_EncodeDataBlock+0x378>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movzwl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
add    -0x98(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movzwl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     13b9 <falcom_EncodeDataBlock+0x2a9>
jmp    1477 <falcom_EncodeDataBlock+0x367>
movq   $0x2,-0x48(%rbp)
mov    -0x98(%rbp),%rax
add    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jl     13db <falcom_EncodeDataBlock+0x2cb>
jmp    143b <falcom_EncodeDataBlock+0x32b>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
add    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x98(%rbp),%rdx
add    -0x40(%rbp),%rdx
add    -0x48(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1412 <falcom_EncodeDataBlock+0x302>
jmp    143b <falcom_EncodeDataBlock+0x32b>
cmpq   $0x10d,-0x48(%rbp)
jle    1425 <falcom_EncodeDataBlock+0x315>
jmp    143b <falcom_EncodeDataBlock+0x32b>
jmp    142a <falcom_EncodeDataBlock+0x31a>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    13c1 <falcom_EncodeDataBlock+0x2b1>
cmpq   $0x10d,-0x48(%rbp)
jle    1451 <falcom_EncodeDataBlock+0x341>
movq   $0x10d,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jle    1472 <falcom_EncodeDataBlock+0x362>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xa0(%rbp)
jmp    1477 <falcom_EncodeDataBlock+0x367>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    135f <falcom_EncodeDataBlock+0x24f>
jmp    148d <falcom_EncodeDataBlock+0x37d>
cmpq   $0x0,-0xa0(%rbp)
je     14b8 <falcom_EncodeDataBlock+0x3a8>
cmpq   $0x40,-0x38(%rbp)
jge    14b8 <falcom_EncodeDataBlock+0x3a8>
cmpq   $0x2,-0x50(%rbp)
jle    14b8 <falcom_EncodeDataBlock+0x3a8>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1987 <falcom_EncodeDataBlock+0x877>
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x10,-0x80(%rbp)
jne    158c <falcom_EncodeDataBlock+0x47c>
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x90(%rbp)
movb   $0x1,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e0 <falcom_EncodeDataBlock+0x4d0>
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x90(%rbp)
movb   $0x1,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x1d,-0x50(%rbp)
jg     175c <falcom_EncodeDataBlock+0x64c>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
sub    $0xe,%rax
mov    %rax,-0x48(%rbp)
movq   $0x3,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     1679 <falcom_EncodeDataBlock+0x569>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
mov    -0x80(%rbp),%rcx
add    -0x40(%rbp),%rcx
shl    %cl,%rax
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
sar    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1636 <falcom_EncodeDataBlock+0x526>
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x10,-0x80(%rbp)
jne    16f6 <falcom_EncodeDataBlock+0x5e6>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    1757 <falcom_EncodeDataBlock+0x647>
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1964 <falcom_EncodeDataBlock+0x854>
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
sub    $0xe,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x100,%ecx
cqto
idiv   %rcx
mov    %rax,-0x48(%rbp)
movq   $0x3,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     1813 <falcom_EncodeDataBlock+0x703>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
mov    -0x80(%rbp),%rcx
add    -0x40(%rbp),%rcx
shl    %cl,%rax
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
sar    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    17d0 <falcom_EncodeDataBlock+0x6c0>
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
sub    $0xe,%rax
and    $0xff,%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x10,-0x80(%rbp)
jne    18d0 <falcom_EncodeDataBlock+0x7c0>
mov    -0x48(%rbp),%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    195f <falcom_EncodeDataBlock+0x84f>
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1964 <falcom_EncodeDataBlock+0x854>
mov    -0x50(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x50(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
jmp    11cb <falcom_EncodeDataBlock+0xbb>
cmpq   $0x0,-0xa0(%rbp)
jne    1a21 <falcom_EncodeDataBlock+0x911>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x98(%rbp)
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    11cb <falcom_EncodeDataBlock+0xbb>
mov    -0x50(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x50(%rbp),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
imul   $0xffffffffffffffff,-0xa0(%rbp),%rax
ff
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x28(%rbp)
cmpq   $0x100,-0xa0(%rbp)
jge    1aea <falcom_EncodeDataBlock+0x9da>
mov    -0xa0(%rbp),%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1c9b <falcom_EncodeDataBlock+0xb8b>
mov    -0xa0(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x1000,-0x48(%rbp)
jl     1b4b <falcom_EncodeDataBlock+0xa3b>
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
sub    $0x1000,%rax
mov    %rax,-0x48(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x100,%ecx
cqto
idiv   %rcx
mov    %rax,-0x48(%rbp)
movq   $0x3,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     1bb4 <falcom_EncodeDataBlock+0xaa4>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
mov    -0x80(%rbp),%rcx
add    -0x40(%rbp),%rcx
shl    %cl,%rax
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
sar    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1b71 <falcom_EncodeDataBlock+0xa61>
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x10,-0x80(%rbp)
jne    1c32 <falcom_EncodeDataBlock+0xb22>
mov    -0xa0(%rbp),%rax
and    $0xff,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    1c94 <falcom_EncodeDataBlock+0xb84>
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0xa0(%rbp),%rax
and    $0xff,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
movl   $0x1,-0x28(%rbp)
cmpq   $0x6,-0x50(%rbp)
jge    1d04 <falcom_EncodeDataBlock+0xbf4>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
sub    %rcx,%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
sub    $0x1,%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    11cb <falcom_EncodeDataBlock+0xbb>
cmpq   $0xe,-0x50(%rbp)
jge    1db4 <falcom_EncodeDataBlock+0xca4>
mov    $0x5,%eax
sub    -0x28(%rbp),%eax
cltq
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x48(%rbp)
movq   $0x3,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     1d78 <falcom_EncodeDataBlock+0xc68>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
mov    -0x80(%rbp),%rcx
add    -0x40(%rbp),%rcx
shl    %cl,%rax
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
sar    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1d35 <falcom_EncodeDataBlock+0xc25>
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    11cb <falcom_EncodeDataBlock+0xbb>
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    $0x5,%eax
sub    -0x28(%rbp),%eax
cltq
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x10,-0x80(%rbp)
jne    1e3f <falcom_EncodeDataBlock+0xd2f>
mov    -0x50(%rbp),%rax
sub    $0xe,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    1e9c <falcom_EncodeDataBlock+0xd8c>
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
sub    $0xe,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    11cb <falcom_EncodeDataBlock+0xbb>
mov    -0x98(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1f58 <falcom_EncodeDataBlock+0xe48>
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x78(%rbp),%rdx
lea    -0x80(%rbp),%rcx
lea    -0x88(%rbp),%r8
mov    $0x0,%al
call   1030 <falcom_write_bit_flags@plt>
cltq
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x90(%rbp)
movb   $0x0,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x78(%rbp),%rax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%rcx
mov    %dx,(%rax,%rcx,1)
mov    -0x58(%rbp),%rax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %dx,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x90(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x90(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x90(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<falcom_EncodeDataBlock>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
cmp    $0xfff0,%rcx
mov    $0xfff0,%r15d
cmovl  %rcx,%r15
mov    %r8d,0x4c(%rsp)
mov    %rdi,%r12
movq   $0x0,0x10(%rsp)
movq   $0x8,(%rsp)
movq   $0x2,0x20(%rsp)
movq   $0x4,0x8(%rsp)
xor    %r14d,%r14d
mov    $0x4,%eax
mov    %rsi,0x70(%rsp)
mov    $0x4,%ebp
cmp    $0x5,%rsi
jl     1aa4 <falcom_EncodeDataBlock+0x994>
test   %rcx,%rcx
jle    1aa4 <falcom_EncodeDataBlock+0x994>
mov    %rdx,%rbx
lea    -0xe(%r15),%rax
mov    %rax,0x68(%rsp)
lea    -0x2(%r15),%rdi
lea    0x2(%rdx),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x58(%rsp)
mov    $0x4,%eax
xor    %r14d,%r14d
mov    $0x4,%ebp
mov    %r15,0x40(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r12,0x28(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,0x18(%rsp)
mov    $0x1,%r8b
cmp    0x68(%rsp),%r14
jge    1290 <falcom_EncodeDataBlock+0x180>
mov    (%rbx,%r14,1),%cl
cmp    0x1(%rbx,%r14,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x2(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x3(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x4(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x5(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x6(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x7(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x8(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0x9(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0xa(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0xb(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0xc(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
cmp    0xd(%r14,%rbx,1),%cl
jne    1290 <falcom_EncodeDataBlock+0x180>
lea    0xe(%r14),%rdx
cmp    %r15,%rdx
jge    1a97 <falcom_EncodeDataBlock+0x987>
lea    (%rbx,%r14,1),%rsi
mov    %r15,%rbp
sub    %r14,%rbp
mov    $0xe,%edx
xor    %r8d,%r8d
cmp    (%rsi,%rdx,1),%cl
jne    1292 <falcom_EncodeDataBlock+0x182>
cmp    $0xffe,%rdx
ja     1292 <falcom_EncodeDataBlock+0x182>
add    $0x1,%rdx
xor    %r8d,%r8d
cmp    %rdx,%rbp
jne    126e <falcom_EncodeDataBlock+0x15e>
mov    %rbp,%rdx
jmp    1292 <falcom_EncodeDataBlock+0x182>
xor    %edx,%edx
mov    %rdx,0x50(%rsp)
cmp    %rdi,%r14
jge    1360 <falcom_EncodeDataBlock+0x250>
lea    (%rbx,%r14,1),%r11
lea    0x2(%r14),%r10
mov    %r15,%r9
sub    %r14,%r9
mov    0x60(%rsp),%rcx
lea    (%rcx,%r14,1),%rbp
mov    0x58(%rsp),%rcx
add    %r14,%rcx
sub    %r14,%rdi
mov    $0xffffffffffffffff,%rsi
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    12ff <falcom_EncodeDataBlock+0x1ef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdx
cmp    %r12,%rdx
cmovg  %rdx,%r12
cmovg  %rsi,%r13
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%rcx
cmp    $0xffffffffffffe000,%rsi
jbe    1366 <falcom_EncodeDataBlock+0x256>
mov    %rsi,%rdx
add    %r14,%rdx
js     1366 <falcom_EncodeDataBlock+0x256>
movzwl (%r11),%edx
cmp    (%r11,%rsi,1),%dx
jne    12ee <falcom_EncodeDataBlock+0x1de>
mov    $0x2,%ebx
cmp    %r15,%r10
jge    12e0 <falcom_EncodeDataBlock+0x1d0>
xor    %edx,%edx
xchg   %ax,%ax
lea    0x2(%rdx),%rbx
movzbl 0x0(%rbp,%rdx,1),%r15d
cmp    (%rcx,%rdx,1),%r15b
jne    1345 <falcom_EncodeDataBlock+0x235>
cmp    $0x10d,%rbx
ja     1345 <falcom_EncodeDataBlock+0x235>
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1320 <falcom_EncodeDataBlock+0x210>
mov    %r9,%rbx
mov    0x40(%rsp),%r15
mov    $0x10d,%edx
cmp    $0x10c,%rbx
jbe    12e0 <falcom_EncodeDataBlock+0x1d0>
jmp    12e3 <falcom_EncodeDataBlock+0x1d3>
nopw   0x0(%rax,%rax,1)
xor    %r12d,%r12d
xor    %r13d,%r13d
test   %r13,%r13
setne  %cl
cmpq   $0x40,0x50(%rsp)
setb   %dl
and    %cl,%dl
cmp    $0x3,%r12
setge  %cl
and    %dl,%cl
or     %cl,%r8b
je     1420 <falcom_EncodeDataBlock+0x310>
test   %r13,%r13
lea    0x8(%rsp),%rsi
je     16cc <falcom_EncodeDataBlock+0x5bc>
mov    (%rsp),%rcx
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     %rax,0x10(%rsp)
add    $0x1,%rcx
mov    %rcx,(%rsp)
mov    0x28(%rsp),%rbx
mov    %rbx,%rdi
lea    0x10(%rsp),%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x18(%rsp),%r8
add    %rax,%r8
mov    %r13,%rbp
neg    %rbp
cmp    $0xffffffffffffff01,%r13
jl     171a <falcom_EncodeDataBlock+0x60a>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    %bpl,(%rbx,%rax,1)
add    $0x1,%r8
xor    %r9d,%r9d
lea    0x8(%rsp),%rbx
lea    0x10(%rsp),%rbp
lea    0x20(%rsp),%r13
jmp    18f7 <falcom_EncodeDataBlock+0x7e7>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rdx
mov    $0x1,%esi
mov    %edx,%ecx
shl    %cl,%esi
movslq %esi,%rsi
lea    0x1(%rdx),%ecx
mov    $0x1,%edi
shl    %cl,%edi
or     0x10(%rsp),%rsi
movslq %edi,%rcx
or     %rsi,%rcx
mov    %rcx,0x10(%rsp)
add    $0x7,%rdx
mov    %rdx,(%rsp)
cmp    $0x10,%rdx
lea    0x8(%rsp),%rbp
jne    14a0 <falcom_EncodeDataBlock+0x390>
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x28(%rsp),%rdi
movb   $0x1,(%rdi,%rax,1)
mov    %rdi,%r15
mov    %rbp,%rsi
lea    0x10(%rsp),%rdx
mov    %rsp,%rbx
mov    %rbx,%rcx
lea    0x20(%rsp),%r12
mov    %r12,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
jmp    14e2 <falcom_EncodeDataBlock+0x3d2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
lea    0x10(%rsp),%rdx
mov    %rsp,%r12
mov    %r12,%rcx
lea    0x20(%rsp),%r13
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
mov    %rbx,%r15
movb   $0x1,(%rbx,%rcx,1)
mov    %r12,%rbx
mov    %r13,%r12
mov    0x18(%rsp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
mov    (%rsp),%rcx
mov    0x50(%rsp),%r13
cmp    $0x1d,%r13
ja     15e0 <falcom_EncodeDataBlock+0x4d0>
add    $0x1,%rcx
mov    %rcx,(%rsp)
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r12,%r8
lea    0x10(%rsp),%r12
mov    %r12,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %rbp,%rsi
lea    -0xe(%r13),%ebx
mov    (%rsp),%rdx
mov    %r13d,%r8d
and    $0x1,%r8d
lea    0x3(%rdx),%ecx
shl    %cl,%r8
or     0x10(%rsp),%r8
mov    %ebx,%edi
shr    %edi
and    $0x1,%edi
lea    0x2(%rdx),%ecx
shl    %cl,%rdi
mov    %eax,%eax
mov    %ebx,%ebp
shr    $0x2,%ebp
and    $0x1,%ebp
lea    0x1(%rdx),%ecx
shl    %cl,%rbp
shr    $0x3,%ebx
and    $0x1,%ebx
mov    %edx,%ecx
shl    %cl,%rbx
or     %rdi,%rbp
or     %rbp,%rbx
or     %r8,%rbx
mov    0x18(%rsp),%r13
add    %rax,%r13
mov    %rbx,0x10(%rsp)
add    $0x4,%rdx
mov    %rdx,(%rsp)
cmp    $0x10,%rdx
jne    1809 <falcom_EncodeDataBlock+0x6f9>
mov    0x30(%rsp),%rbx
mov    (%rbx,%r14,1),%al
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
mov    %al,(%r15,%rcx,1)
mov    %r15,%rdi
mov    %r12,%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
lea    (%rax,%r13,1),%rbp
add    $0x1,%rbp
jmp    1886 <falcom_EncodeDataBlock+0x776>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%eax
shl    %cl,%eax
cltq
or     %rax,0x10(%rsp)
add    $0x1,%rcx
mov    %rcx,(%rsp)
mov    %r15,%rdi
mov    %rbp,%rsi
lea    0x10(%rsp),%rdx
mov    %rbx,%rcx
mov    %r12,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
lea    -0xe(%r13),%r10
lea    0xf1(%r13),%rdi
test   %r10,%r10
cmovns %r10,%rdi
sar    $0x8,%rdi
mov    (%rsp),%rdx
mov    %edi,%r8d
and    $0x1,%r8d
lea    0x3(%rdx),%ecx
shl    %cl,%r8
or     0x10(%rsp),%r8
mov    %rbx,%r9
mov    %edi,%ebx
shr    %ebx
and    $0x1,%ebx
lea    0x2(%rdx),%ecx
shl    %cl,%rbx
mov    %eax,%eax
mov    %rbp,%rsi
mov    %edi,%ebp
shr    $0x2,%ebp
and    $0x1,%ebp
lea    0x1(%rdx),%ecx
shl    %cl,%rbp
shr    $0x3,%edi
and    $0x1,%edi
mov    %edx,%ecx
shl    %cl,%rdi
or     %rbx,%rbp
or     %rbp,%rdi
or     %r8,%rdi
mov    0x18(%rsp),%rbp
add    %rax,%rbp
mov    %rdi,0x10(%rsp)
add    $0x4,%rdx
mov    %rdx,(%rsp)
cmp    $0x10,%rdx
jne    1845 <falcom_EncodeDataBlock+0x735>
mov    0x8(%rsp),%rax
mov    %r10b,(%r15,%rax,1)
mov    0x30(%rsp),%rbx
mov    (%rbx,%r14,1),%cl
lea    0x2(%rax),%rdx
mov    %rdx,0x8(%rsp)
mov    %cl,0x1(%r15,%rax,1)
mov    %r15,%rdi
lea    0x10(%rsp),%rdx
mov    %r9,%rcx
mov    %r12,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
jmp    187f <falcom_EncodeDataBlock+0x76f>
addq   $0x1,(%rsp)
mov    0x30(%rsp),%rbx
mov    (%rbx,%r14,1),%cl
add    $0x1,%r14
lea    0x1(%rax),%rdx
mov    %rdx,0x8(%rsp)
mov    0x28(%rsp),%r12
mov    %cl,(%r12,%rax,1)
mov    %r12,%rdi
lea    0x10(%rsp),%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x18(%rsp),%rbp
add    %rax,%rbp
add    $0x1,%rbp
jmp    1a7b <falcom_EncodeDataBlock+0x96b>
mov    %r8,0x18(%rsp)
mov    (%rsp),%rax
mov    $0x1,%edx
mov    %eax,%ecx
shl    %cl,%edx
movslq %edx,%r8
lea    0x1(%rax),%ecx
mov    $0x1,%edx
shl    %cl,%edx
or     0x10(%rsp),%r8
mov    $0xfffffffffffff000,%rcx
sub    %r13,%rcx
cmp    $0xfffffffffffff001,%r13
movslq %edx,%r9
mov    $0x0,%edx
cmovae %rdx,%r9
cmovae %rbp,%rcx
lea    0xff(%rcx),%rsi
test   %rcx,%rcx
cmovns %rcx,%rsi
sar    $0x8,%rsi
mov    %esi,%ebx
and    $0x1,%ebx
lea    0x5(%rax),%ecx
shl    %cl,%rbx
mov    %esi,%edx
shr    %edx
and    $0x1,%edx
lea    0x4(%rax),%ecx
shl    %cl,%rdx
mov    %esi,%edi
shr    $0x2,%edi
and    $0x1,%edi
lea    0x3(%rax),%ecx
shl    %cl,%rdi
or     %r9,%rbx
shr    $0x3,%esi
and    $0x1,%esi
lea    0x2(%rax),%ecx
shl    %cl,%rsi
or     %rbx,%rdx
or     %r8,%rdx
or     %rdi,%rsi
or     %rdx,%rsi
mov    %rsi,0x10(%rsp)
add    $0x6,%rax
mov    %rax,(%rsp)
cmp    $0x10,%rax
jne    189d <falcom_EncodeDataBlock+0x78d>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x28(%rsp),%rdi
mov    %bpl,(%rdi,%rax,1)
lea    0x8(%rsp),%rbx
mov    %rbx,%rsi
lea    0x10(%rsp),%rbp
mov    %rbp,%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r13
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
jmp    18e5 <falcom_EncodeDataBlock+0x7d5>
mov    %r15,%rdi
mov    %r12,%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x30(%rsp),%rbx
mov    (%rbx,%r14,1),%cl
mov    0x8(%rsp),%rdx
lea    0x1(%rdx),%rsi
mov    %rsi,0x8(%rsp)
mov    %cl,(%r15,%rdx,1)
lea    (%rax,%r13,1),%rbp
add    $0x1,%rbp
jmp    1886 <falcom_EncodeDataBlock+0x776>
mov    %r15,%rdi
lea    0x10(%rsp),%rdx
mov    %r9,%rcx
mov    %r12,%r8
xor    %eax,%eax
mov    %r10,%rbx
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x8(%rsp),%rcx
mov    %bl,(%r15,%rcx,1)
mov    0x30(%rsp),%rbx
mov    (%rbx,%r14,1),%dl
lea    0x2(%rcx),%rsi
mov    %rsi,0x8(%rsp)
mov    %dl,0x1(%r15,%rcx,1)
add    %rax,%rbp
add    $0x2,%rbp
mov    %r15,%r12
add    0x50(%rsp),%r14
mov    0x38(%rsp),%rdi
mov    0x40(%rsp),%r15
jmp    1a80 <falcom_EncodeDataBlock+0x970>
mov    0x28(%rsp),%r15
mov    %r15,%rdi
lea    0x8(%rsp),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r13
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
mov    %bpl,(%r15,%rcx,1)
mov    0x40(%rsp),%r15
mov    %rbx,%rbp
lea    0x8(%rsp),%rbx
mov    0x18(%rsp),%r8
add    %rax,%r8
add    $0x1,%r8
mov    $0x1,%r9d
add    %r12,%r14
cmp    $0x5,%r12
jg     1946 <falcom_EncodeDataBlock+0x836>
mov    %r9d,%eax
sub    %rax,%r12
add    (%rsp),%r12
mov    %r12,(%rsp)
add    $0xff,%r12b
mov    $0x1,%eax
mov    %r12d,%ecx
shl    %cl,%eax
cltq
or     %rax,0x10(%rsp)
mov    0x28(%rsp),%r12
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %rsp,%rcx
mov    %r8,%rbp
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
jmp    19d7 <falcom_EncodeDataBlock+0x8c7>
cmp    $0xd,%r12
mov    %r8,0x18(%rsp)
ja     19e1 <falcom_EncodeDataBlock+0x8d1>
xor    $0x5,%r9d
mov    (%rsp),%r8
lea    (%r8,%r9,1),%rax
lea    0x2(%r12),%rbx
and    $0x1,%r12d
lea    0x3(%rax),%ecx
shl    %cl,%r12
mov    %ebx,%edi
shr    %edi
and    $0x1,%edi
lea    0x2(%rax),%ecx
shl    %cl,%rdi
mov    %ebx,%ebp
shr    $0x2,%ebp
and    $0x1,%ebp
lea    0x1(%rax),%ecx
shl    %cl,%rbp
or     0x10(%rsp),%r12
or     %rdi,%rbp
shr    $0x3,%rbx
mov    %eax,%ecx
shl    %cl,%rbx
or     %rbp,%rbx
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rsi
or     %r12,%rbx
mov    %rbx,0x10(%rsp)
lea    (%r8,%r9,1),%rax
add    $0x4,%rax
mov    %rax,(%rsp)
mov    0x28(%rsp),%r12
mov    %r12,%rdi
mov    %rsp,%rcx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    0x18(%rsp),%rbp
mov    %eax,%eax
add    %rax,%rbp
jmp    1a76 <falcom_EncodeDataBlock+0x966>
mov    $0x6,%eax
sub    %r9d,%eax
add    (%rsp),%rax
mov    %rax,(%rsp)
cmp    $0x10,%rax
jne    1a2f <falcom_EncodeDataBlock+0x91f>
add    $0xf2,%r12b
mov    0x8(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x8(%rsp)
mov    0x28(%rsp),%rcx
mov    %r12b,(%rcx,%rax,1)
mov    %rcx,%r12
mov    %rcx,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %rsp,%rcx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
jmp    1a6a <falcom_EncodeDataBlock+0x95a>
mov    0x28(%rsp),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %rsp,%rcx
mov    %r13,%r8
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%eax
add    $0xf2,%r12b
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,0x8(%rsp)
mov    %r12b,(%r15,%rcx,1)
mov    %r15,%r12
mov    0x40(%rsp),%r15
mov    0x18(%rsp),%rbp
add    %rax,%rbp
add    $0x1,%rbp
mov    0x30(%rsp),%rbx
mov    0x38(%rsp),%rdi
mov    0x8(%rsp),%rax
cmp    0x70(%rsp),%rax
jge    1aa4 <falcom_EncodeDataBlock+0x994>
cmp    %r15,%r14
jl     11d0 <falcom_EncodeDataBlock+0xc0>
jmp    1aa4 <falcom_EncodeDataBlock+0x994>
mov    $0xe,%edx
xor    %r8d,%r8d
jmp    1292 <falcom_EncodeDataBlock+0x182>
cmp    %r15,%r14
jne    1b0e <falcom_EncodeDataBlock+0x9fe>
mov    (%rsp),%rax
mov    $0x1,%edx
mov    $0x1,%esi
mov    %eax,%ecx
shl    %cl,%esi
movslq %esi,%rsi
or     0x10(%rsp),%rsi
lea    0x1(%rax),%ecx
shl    %cl,%edx
movslq %edx,%rcx
or     %rsi,%rcx
mov    %rcx,0x10(%rsp)
add    $0x7,%rax
mov    %rax,(%rsp)
lea    0x8(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %rsp,%rcx
lea    0x20(%rsp),%r8
mov    %r12,%rdi
xor    %eax,%eax
call   1030 <falcom_write_bit_flags@plt>
mov    %eax,%ecx
mov    0x8(%rsp),%rax
movb   $0x0,(%r12,%rax,1)
add    $0x1,%rax
add    %rcx,%rbp
add    $0x1,%rbp
mov    0x4c(%rsp),%esi
movzwl 0x10(%rsp),%ecx
mov    0x20(%rsp),%rdx
mov    %cx,(%r12,%rdx,1)
mov    %bp,(%r12)
mov    %sil,(%r12,%rax,1)
add    $0x1,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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