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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BLZ_Invert(unsigned char *, unsigned int);
scalar_t__ Memory(unsigned int, int);
int /*<<< orphan*/ free(unsigned char *);
char *BLZ_Code(unsigned char *raw_buffer, int raw_len, int *new_len, int best) {
  unsigned char *pak_buffer, *pak, *raw, *raw_end, *flg, *tmp;
  unsigned int pak_len, inc_len, hdr_len, enc_len, len, pos, max;
  unsigned int len_best, pos_best, len_next, pos_next, len_post, pos_post;
  unsigned int pak_tmp, raw_tmp;
  unsigned char mask;
  pak_tmp = 0;
  raw_tmp = raw_len;
  pak_len = raw_len + ((raw_len + 7) / 8) + 11;
  pak_buffer = (unsigned char *)Memory(pak_len, sizeof(char));
  BLZ_Invert(raw_buffer, raw_len);
  pak = pak_buffer;
  raw = raw_buffer;
  raw_end = raw_buffer + raw_len;
  mask = 0;
  while (raw < raw_end) {
    if (!(mask >>= 1)) {
      *(flg = pak) = 0;
      pak++;
      mask = 0x80;
    }
    {
      len_best = 2;
      max = raw - raw_buffer >= 0x1002 ? 0x1002 : raw - raw_buffer;
      for (pos = 3; pos <= max; pos++) {
        for (len = 0; len < 0x12; len++) {
          if (raw + len == raw_end)
            break;
          if (len >= pos)
            break;
          if (*(raw + len) != *(raw + len - pos))
            break;
        }
        if (len > len_best) {
          pos_best = pos;
          if ((len_best = len) == 0x12)
            break;
        }
      }
    };
    if (best) {
      if (len_best > 2) {
        if (raw + len_best < raw_end) {
          raw += len_best;
          {
            len_next = 2;
            max = raw - raw_buffer >= 0x1002 ? 0x1002 : raw - raw_buffer;
            for (pos = 3; pos <= max; pos++) {
              for (len = 0; len < 0x12; len++) {
                if (raw + len == raw_end)
                  break;
                if (len >= pos)
                  break;
                if (*(raw + len) != *(raw + len - pos))
                  break;
              }
              if (len > len_next) {
                pos_next = pos;
                if ((len_next = len) == 0x12)
                  break;
              }
            }
          };
          raw -= len_best - 1;
          {
            len_post = 2;
            max = raw - raw_buffer >= 0x1002 ? 0x1002 : raw - raw_buffer;
            for (pos = 3; pos <= max; pos++) {
              for (len = 0; len < 0x12; len++) {
                if (raw + len == raw_end)
                  break;
                if (len >= pos)
                  break;
                if (*(raw + len) != *(raw + len - pos))
                  break;
              }
              if (len > len_post) {
                pos_post = pos;
                if ((len_post = len) == 0x12)
                  break;
              }
            }
          };
          raw--;
          if (len_next <= 2)
            len_next = 1;
          if (len_post <= 2)
            len_post = 1;
          if (len_best + len_next <= 1 + len_post)
            len_best = 1;
        }
      }
    }
    *flg <<= 1;
    if (len_best > 2) {
      raw += len_best;
      *flg |= 1;
      *pak = ((len_best - (2 + 1)) << 4) | ((pos_best - 3) >> 8);
      pak++;
      *pak = (pos_best - 3) & 0xFF;
      pak++;
    } else {
      *pak = *raw;
      pak++;
      raw++;
    }
    if (pak - pak_buffer + raw_len - (raw - raw_buffer) < pak_tmp + raw_tmp) {
      pak_tmp = pak - pak_buffer;
      raw_tmp = raw_len - (raw - raw_buffer);
    }
  }
  while (mask && (mask != 1)) {
    mask >>= 1;
    *flg <<= 1;
  }
  pak_len = pak - pak_buffer;
  BLZ_Invert(raw_buffer, raw_len);
  BLZ_Invert(pak_buffer, pak_len);
  if (!pak_tmp || (raw_len + 4 < ((pak_tmp + raw_tmp + 3) & -4) + 8)) {
    pak = pak_buffer;
    raw = raw_buffer;
    raw_end = raw_buffer + raw_len;
    while (raw < raw_end) {
      *pak = *raw;
      pak++;
      raw++;
    }
    while ((pak - pak_buffer) & 3) {
      *pak = 0;
      pak++;
    }
    *(unsigned int *)pak = 0;
    pak += 4;
  } else {
    tmp = (unsigned char *)Memory(raw_tmp + pak_tmp + 11, sizeof(char));
    for (len = 0; len < raw_tmp; len++)
      tmp[len] = raw_buffer[len];
    for (len = 0; len < pak_tmp; len++)
      tmp[raw_tmp + len] = pak_buffer[len + pak_len - pak_tmp];
    pak = pak_buffer;
    pak_buffer = tmp;
    free(pak);
    pak = pak_buffer + raw_tmp + pak_tmp;
    enc_len = pak_tmp;
    hdr_len = 8;
    inc_len = raw_len - pak_tmp - raw_tmp;
    while ((pak - pak_buffer) & 3) {
      *pak = 0xFF;
      pak++;
      hdr_len++;
    }
    *(unsigned int *)pak = enc_len + hdr_len;
    pak += 3;
    *pak = hdr_len;
    pak++;
    *(unsigned int *)pak = inc_len - hdr_len;
    pak += 4;
  }
  *new_len = pak - pak_buffer;
  return (pak_buffer);
}


x86 assembly (clang, -O0):
<BLZ_Code>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
add    %ecx,%eax
add    $0xb,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
mov    $0x1,%esi
call   1050 <Memory@plt>
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1040 <BLZ_Invert@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movb   $0x0,-0x8d(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    170c <BLZ_Code+0x5dc>
movzbl -0x8d(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x8d(%rbp)
cmp    $0x0,%al
jne    120a <BLZ_Code+0xda>
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
movb   $0x80,-0x8d(%rbp)
movl   $0x2,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x1002,%rax
jl     1239 <BLZ_Code+0x109>
mov    $0x1002,%eax
mov    %rax,-0xa0(%rbp)
jmp    124b <BLZ_Code+0x11b>
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %eax,-0x6c(%rbp)
movl   $0x3,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
ja     1324 <BLZ_Code+0x1f4>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    12e6 <BLZ_Code+0x1b6>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    1292 <BLZ_Code+0x162>
jmp    12e6 <BLZ_Code+0x1b6>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     12a3 <BLZ_Code+0x173>
jmp    12e6 <BLZ_Code+0x1b6>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
mov    -0x64(%rbp),%edx
add    %rdx,%rcx
mov    -0x68(%rbp),%edx
mov    %edx,%esi
xor    %edx,%edx
sub    %rsi,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     12d3 <BLZ_Code+0x1a3>
jmp    12e6 <BLZ_Code+0x1b6>
jmp    12d8 <BLZ_Code+0x1a8>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    126f <BLZ_Code+0x13f>
mov    -0x64(%rbp),%eax
cmp    -0x70(%rbp),%eax
jbe    1311 <BLZ_Code+0x1e1>
mov    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmp    $0x12,%eax
jne    130c <BLZ_Code+0x1dc>
jmp    1324 <BLZ_Code+0x1f4>
jmp    1311 <BLZ_Code+0x1e1>
jmp    1316 <BLZ_Code+0x1e6>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    125c <BLZ_Code+0x12c>
cmpl   $0x0,-0x1c(%rbp)
je     1605 <BLZ_Code+0x4d5>
cmpl   $0x2,-0x70(%rbp)
jbe    1600 <BLZ_Code+0x4d0>
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jae    15fb <BLZ_Code+0x4cb>
mov    -0x70(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x2,-0x78(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x1002,%rax
jl     138b <BLZ_Code+0x25b>
mov    $0x1002,%eax
mov    %rax,-0xa8(%rbp)
jmp    139d <BLZ_Code+0x26d>
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %eax,-0x6c(%rbp)
movl   $0x3,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
ja     1476 <BLZ_Code+0x346>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    1438 <BLZ_Code+0x308>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    13e4 <BLZ_Code+0x2b4>
jmp    1438 <BLZ_Code+0x308>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     13f5 <BLZ_Code+0x2c5>
jmp    1438 <BLZ_Code+0x308>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
mov    -0x64(%rbp),%edx
add    %rdx,%rcx
mov    -0x68(%rbp),%edx
mov    %edx,%esi
xor    %edx,%edx
sub    %rsi,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1425 <BLZ_Code+0x2f5>
jmp    1438 <BLZ_Code+0x308>
jmp    142a <BLZ_Code+0x2fa>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13c1 <BLZ_Code+0x291>
mov    -0x64(%rbp),%eax
cmp    -0x78(%rbp),%eax
jbe    1463 <BLZ_Code+0x333>
mov    -0x68(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
cmp    $0x12,%eax
jne    145e <BLZ_Code+0x32e>
jmp    1476 <BLZ_Code+0x346>
jmp    1463 <BLZ_Code+0x333>
jmp    1468 <BLZ_Code+0x338>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ae <BLZ_Code+0x27e>
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x2,-0x80(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x1002,%rax
jl     14bf <BLZ_Code+0x38f>
mov    $0x1002,%eax
mov    %rax,-0xb0(%rbp)
jmp    14d1 <BLZ_Code+0x3a1>
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %eax,-0x6c(%rbp)
movl   $0x3,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
ja     15ad <BLZ_Code+0x47d>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    156c <BLZ_Code+0x43c>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    1518 <BLZ_Code+0x3e8>
jmp    156c <BLZ_Code+0x43c>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     1529 <BLZ_Code+0x3f9>
jmp    156c <BLZ_Code+0x43c>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
mov    -0x64(%rbp),%edx
add    %rdx,%rcx
mov    -0x68(%rbp),%edx
mov    %edx,%esi
xor    %edx,%edx
sub    %rsi,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1559 <BLZ_Code+0x429>
jmp    156c <BLZ_Code+0x43c>
jmp    155e <BLZ_Code+0x42e>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14f5 <BLZ_Code+0x3c5>
mov    -0x64(%rbp),%eax
cmp    -0x80(%rbp),%eax
jbe    159a <BLZ_Code+0x46a>
mov    -0x68(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmp    $0x12,%eax
jne    1595 <BLZ_Code+0x465>
jmp    15ad <BLZ_Code+0x47d>
jmp    159a <BLZ_Code+0x46a>
jmp    159f <BLZ_Code+0x46f>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14e2 <BLZ_Code+0x3b2>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x2,-0x78(%rbp)
ja     15ca <BLZ_Code+0x49a>
movl   $0x1,-0x78(%rbp)
cmpl   $0x2,-0x80(%rbp)
ja     15db <BLZ_Code+0x4ab>
movl   $0x1,-0x80(%rbp)
mov    -0x70(%rbp),%eax
add    -0x78(%rbp),%eax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
ja     15f6 <BLZ_Code+0x4c6>
movl   $0x1,-0x70(%rbp)
jmp    15fb <BLZ_Code+0x4cb>
jmp    1600 <BLZ_Code+0x4d0>
jmp    1605 <BLZ_Code+0x4d5>
mov    -0x48(%rbp),%rax
movzbl (%rax),%ecx
shl    $0x1,%ecx
mov    %cl,(%rax)
cmpl   $0x2,-0x70(%rbp)
jbe    1683 <BLZ_Code+0x553>
mov    -0x70(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
movzbl (%rax),%ecx
or     $0x1,%ecx
mov    %cl,(%rax)
mov    -0x70(%rbp),%eax
sub    $0x3,%eax
shl    $0x4,%eax
mov    -0x74(%rbp),%ecx
sub    $0x3,%ecx
shr    $0x8,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x74(%rbp),%eax
sub    $0x3,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    16a7 <BLZ_Code+0x577>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
sub    %rdx,%rcx
sub    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    -0x8c(%rbp),%ecx
mov    %ecx,%ecx
cmp    %rcx,%rax
jge    1707 <BLZ_Code+0x5d7>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x88(%rbp)
movslq -0xc(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x8(%rbp),%rdx
sub    %rdx,%rcx
sub    %rcx,%rax
mov    %eax,-0x8c(%rbp)
jmp    11c6 <BLZ_Code+0x96>
jmp    1711 <BLZ_Code+0x5e1>
movzbl -0x8d(%rbp),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xb1(%rbp)
je     173c <BLZ_Code+0x60c>
movzbl -0x8d(%rbp),%eax
cmp    $0x1,%eax
setne  %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    174f <BLZ_Code+0x61f>
jmp    1770 <BLZ_Code+0x640>
movzbl -0x8d(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x8d(%rbp)
mov    -0x48(%rbp),%rax
movzbl (%rax),%ecx
shl    $0x1,%ecx
mov    %cl,(%rax)
jmp    1711 <BLZ_Code+0x5e1>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1040 <BLZ_Invert@plt>
mov    -0x28(%rbp),%rdi
mov    -0x54(%rbp),%esi
call   1040 <BLZ_Invert@plt>
cmpl   $0x0,-0x88(%rbp)
je     17c6 <BLZ_Code+0x696>
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    -0x88(%rbp),%ecx
add    -0x8c(%rbp),%ecx
add    $0x3,%ecx
and    $0xfffffffc,%ecx
add    $0x8,%ecx
cmp    %ecx,%eax
jae    186d <BLZ_Code+0x73d>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    181c <BLZ_Code+0x6ec>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    17e5 <BLZ_Code+0x6b5>
jmp    1821 <BLZ_Code+0x6f1>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
and    $0x3,%rax
cmp    $0x0,%rax
je     1852 <BLZ_Code+0x722>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1821 <BLZ_Code+0x6f1>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    19e3 <BLZ_Code+0x8b3>
mov    -0x8c(%rbp),%edi
add    -0x88(%rbp),%edi
add    $0xb,%edi
mov    $0x1,%esi
call   1050 <Memory@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jae    18c2 <BLZ_Code+0x792>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1891 <BLZ_Code+0x761>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x88(%rbp),%eax
jae    190d <BLZ_Code+0x7dd>
mov    -0x28(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    -0x88(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x64(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18c9 <BLZ_Code+0x799>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x8,-0x5c(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x88(%rbp),%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
and    $0x3,%rax
cmp    $0x0,%rax
je     199c <BLZ_Code+0x86c>
mov    -0x30(%rbp),%rax
movb   $0xff,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1962 <BLZ_Code+0x832>
mov    -0x60(%rbp),%ecx
add    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x30(%rbp)
mov    -0x5c(%rbp),%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BLZ_Code>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %ecx,0x54(%rsp)
mov    %rdx,%r13
mov    %esi,%ebx
mov    %rdi,%rbp
lea    0x7(%rbx),%eax
lea    0xe(%rbx),%ecx
test   %eax,%eax
cmovns %eax,%ecx
sar    $0x3,%ecx
lea    (%rbx,%rcx,1),%edi
add    $0xb,%edi
mov    $0x1,%esi
call   1060 <Memory@plt>
mov    %rax,%r15
mov    %rax,%r12
mov    %rbp,%rdi
mov    %ebx,%esi
call   1040 <BLZ_Invert@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
movslq %esi,%rax
lea    (%rax,%rbp,1),%r14
mov    %rax,0x60(%rsp)
test   %eax,%eax
mov    %rbx,0x40(%rsp)
mov    %r15,0x20(%rsp)
mov    %rbp,(%rsp)
mov    %r13,0x30(%rsp)
mov    %r12,0x10(%rsp)
jle    1673 <BLZ_Code+0x533>
xor    %ebx,%ebx
mov    %esi,%ebp
xor    %r9d,%r9d
mov    %r12,%rax
mov    %rdi,%r8
mov    %r15,%r13
mov    %rax,%r15
jmp    1215 <BLZ_Code+0xd5>
mov    0x48(%rsp),%r15
mov    (%r8),%al
mov    %al,(%r15)
add    $0x1,%r15
add    $0x1,%r8
mov    %r15,%rax
sub    %r13,%rax
mov    %r8,%rcx
sub    %rdx,%rcx
mov    0x60(%rsp),%rdi
mov    %rdi,%rdx
sub    %rcx,%rdx
add    %rax,%rdx
lea    (%r9,%rbp,1),%esi
sub    %ecx,%edi
cmp    %rsi,%rdx
cmovl  %eax,%r9d
cmovl  %edi,%ebp
cmp    %r14,%r8
jae    1646 <BLZ_Code+0x506>
cmp    $0x1,%bl
jbe    1230 <BLZ_Code+0xf0>
mov    %r10,0x38(%rsp)
shr    %bl
mov    %rbx,0x8(%rsp)
jmp    1244 <BLZ_Code+0x104>
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%r15)
mov    %r15,0x38(%rsp)
add    $0x1,%r15
mov    $0x80,%cl
mov    %rcx,0x8(%rsp)
mov    (%rsp),%rdx
mov    %r8,%r10
sub    %rdx,%r10
cmp    $0x1002,%r10
mov    $0x1002,%eax
cmovge %eax,%r10d
cmp    $0x3,%r10d
jae    1280 <BLZ_Code+0x140>
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%r10
shlb   (%r10)
jmp    11d4 <BLZ_Code+0x94>
cs nopw 0x0(%rax,%rax,1)
mov    %r15,0x48(%rsp)
mov    %rbp,0x28(%rsp)
mov    $0x3,%edx
mov    $0x2,%r15d
jmp    12ac <BLZ_Code+0x16c>
nopw   0x0(%rax,%rax,1)
add    $0x1,%edx
cmp    %r10d,%edx
ja     1334 <BLZ_Code+0x1f4>
mov    %edx,%eax
mov    %r8,%rbx
sub    %rax,%rbx
mov    $0x1,%edi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%rbp
lea    (%r8,%rdi,1),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %r14,%rcx
je     1317 <BLZ_Code+0x1d7>
cmp    %rax,%rbp
jae    1317 <BLZ_Code+0x1d7>
movzbl (%rcx),%ecx
cmp    -0x1(%rbx,%rdi,1),%cl
jne    1314 <BLZ_Code+0x1d4>
lea    (%r8,%rdi,1),%rcx
cmp    %r14,%rcx
je     130b <BLZ_Code+0x1cb>
cmp    %rax,%rdi
jae    130b <BLZ_Code+0x1cb>
movzbl (%rcx),%ecx
cmp    (%rbx,%rdi,1),%cl
jne    1310 <BLZ_Code+0x1d0>
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x13,%rdi
jne    12c0 <BLZ_Code+0x180>
cmp    $0x12,%r15d
jae    12a0 <BLZ_Code+0x160>
jmp    132b <BLZ_Code+0x1eb>
mov    %rdi,%rbp
jmp    1317 <BLZ_Code+0x1d7>
or     $0x1,%rsi
mov    %rsi,%rbp
cmp    %ebp,%r15d
jae    12a0 <BLZ_Code+0x160>
mov    %ebp,%r15d
mov    %edx,%r12d
cmp    $0x12,%ebp
jne    12a0 <BLZ_Code+0x160>
mov    $0x12,%r15d
mov    %edx,%r12d
cmpl   $0x0,0x54(%rsp)
je     1490 <BLZ_Code+0x350>
cmp    $0x3,%r15d
jb     1490 <BLZ_Code+0x350>
mov    %r15d,%ecx
lea    (%r8,%rcx,1),%rbx
cmp    %r14,%rbx
jae    14bf <BLZ_Code+0x37f>
mov    %rcx,0x58(%rsp)
mov    %r9,%r13
mov    %rbx,%r9
sub    (%rsp),%r9
cmp    $0x1002,%r9
mov    $0x1002,%eax
cmovge %eax,%r9d
mov    $0x2,%r10d
cmp    $0x3,%r9d
jb     1430 <BLZ_Code+0x2f0>
mov    $0x3,%edx
mov    $0x2,%r10d
jmp    13ac <BLZ_Code+0x26c>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%edx
cmp    %r9d,%edx
ja     1430 <BLZ_Code+0x2f0>
mov    %edx,%edx
mov    %rbx,%rsi
sub    %rdx,%rsi
mov    $0x1,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%rbp
lea    (%rbx,%rdi,1),%r11
add    $0xffffffffffffffff,%r11
cmp    %r14,%r11
je     1419 <BLZ_Code+0x2d9>
cmp    %rdx,%rbp
jae    1419 <BLZ_Code+0x2d9>
movzbl (%r11),%ecx
cmp    -0x1(%rsi,%rdi,1),%cl
jne    1416 <BLZ_Code+0x2d6>
lea    (%rbx,%rdi,1),%rbp
cmp    %r14,%rbp
je     140d <BLZ_Code+0x2cd>
cmp    %rdx,%rdi
jae    140d <BLZ_Code+0x2cd>
movzbl 0x0(%rbp),%ecx
cmp    (%rsi,%rdi,1),%cl
jne    1412 <BLZ_Code+0x2d2>
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x13,%rdi
jne    13c0 <BLZ_Code+0x280>
cmp    $0x12,%r10d
jae    13a0 <BLZ_Code+0x260>
jmp    142a <BLZ_Code+0x2ea>
mov    %rdi,%rbp
jmp    1419 <BLZ_Code+0x2d9>
or     $0x1,%rax
mov    %rax,%rbp
cmp    %ebp,%r10d
jae    13a0 <BLZ_Code+0x260>
mov    %ebp,%r10d
cmp    $0x12,%ebp
jne    13a0 <BLZ_Code+0x260>
mov    $0x12,%r10d
mov    %r13,0x18(%rsp)
lea    -0x1(%r15),%eax
sub    %rax,%rbx
mov    %rbx,%r13
mov    (%rsp),%rdx
sub    %rdx,%r13
cmp    $0x1002,%r13
mov    $0x1002,%ecx
cmovge %ecx,%r13d
cmp    $0x3,%r13d
jae    1511 <BLZ_Code+0x3d1>
add    $0xffffffffffffffff,%rbx
cmp    $0x3,%r10d
mov    $0x1,%eax
cmovb  %eax,%r10d
add    %r15d,%r10d
mov    $0x2,%eax
mov    %rbx,%r8
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%rbp
jmp    160c <BLZ_Code+0x4cc>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r13
mov    (%rsp),%rdx
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%r10
mov    (%r10),%al
add    %al,%al
mov    %al,(%r10)
cmp    $0x3,%r15d
jb     11cf <BLZ_Code+0x8f>
mov    %r15d,%ecx
jmp    14dc <BLZ_Code+0x39c>
mov    0x38(%rsp),%r10
mov    (%r10),%al
add    %al,%al
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r13
mov    (%rsp),%rdx
mov    0x8(%rsp),%rbx
add    %rcx,%r8
or     $0x1,%al
mov    %al,(%r10)
shl    $0x4,%r15d
add    $0xd0,%r15d
lea    -0x3(%r12),%eax
mov    %eax,%ecx
shr    $0x8,%ecx
or     %r15d,%ecx
mov    0x48(%rsp),%r15
mov    %cl,(%r15)
mov    %al,0x1(%r15)
add    $0x2,%r15
jmp    11e2 <BLZ_Code+0xa2>
mov    0x58(%rsp),%rcx
sub    %rax,%rcx
add    %rcx,%r8
mov    $0x3,%edx
mov    $0x2,%r11d
jmp    153c <BLZ_Code+0x3fc>
nopl   0x0(%rax)
add    $0x1,%edx
cmp    %r13d,%edx
ja     15d5 <BLZ_Code+0x495>
mov    %edx,%edx
mov    %r8,%rsi
sub    %rdx,%rsi
mov    $0x1,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdi),%rbp
lea    (%rbx,%rdi,1),%r9
add    $0xffffffffffffffff,%r9
cmp    %r14,%r9
je     15a9 <BLZ_Code+0x469>
cmp    %rdx,%rbp
jae    15a9 <BLZ_Code+0x469>
movzbl (%r9),%ecx
cmp    -0x1(%rsi,%rdi,1),%cl
jne    15a6 <BLZ_Code+0x466>
lea    (%rbx,%rdi,1),%rbp
cmp    %r14,%rbp
je     159d <BLZ_Code+0x45d>
cmp    %rdx,%rdi
jae    159d <BLZ_Code+0x45d>
movzbl 0x0(%rbp),%ecx
cmp    (%rsi,%rdi,1),%cl
jne    15a2 <BLZ_Code+0x462>
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x13,%rdi
jne    1550 <BLZ_Code+0x410>
cmp    $0x12,%r11d
jae    1530 <BLZ_Code+0x3f0>
jmp    15ba <BLZ_Code+0x47a>
mov    %rdi,%rbp
jmp    15a9 <BLZ_Code+0x469>
or     $0x1,%rax
mov    %rax,%rbp
cmp    %ebp,%r11d
jae    1530 <BLZ_Code+0x3f0>
mov    %ebp,%r11d
cmp    $0x12,%ebp
jne    1530 <BLZ_Code+0x3f0>
add    $0xffffffffffffffff,%rbx
cmp    $0x3,%r10d
mov    $0x1,%eax
cmovb  %eax,%r10d
add    %r15d,%r10d
mov    $0x13,%eax
jmp    15fb <BLZ_Code+0x4bb>
add    $0xffffffffffffffff,%rbx
cmp    $0x3,%r10d
mov    $0x1,%eax
cmovb  %eax,%r10d
add    %r15d,%r10d
mov    $0x2,%eax
cmp    $0x3,%r11d
jb     162e <BLZ_Code+0x4ee>
add    $0x1,%r11d
mov    %r11d,%eax
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%rbp
mov    (%rsp),%rdx
mov    %rbx,%r8
mov    0x20(%rsp),%r13
cmp    %eax,%r10d
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%r10
ja     14a8 <BLZ_Code+0x368>
mov    0x48(%rsp),%r15
jmp    126e <BLZ_Code+0x12e>
mov    %rbx,%r8
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%rbp
mov    0x20(%rsp),%r13
mov    (%rsp),%rdx
jmp    1611 <BLZ_Code+0x4d1>
cmp    $0x2,%bl
jb     165e <BLZ_Code+0x51e>
mov    (%r10),%al
mov    %ebx,%ecx
shr    %cl
add    %al,%al
cmp    $0x3,%bl
mov    %ecx,%ebx
ja     1650 <BLZ_Code+0x510>
mov    %al,(%r10)
mov    0x10(%rsp),%rbx
mov    0x40(%rsp),%rsi
mov    (%rsp),%rdi
mov    %r9,0x18(%rsp)
jmp    1685 <BLZ_Code+0x545>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %esi,%ebp
mov    %r15,%rax
mov    %r15,%r13
mov    %r12,%rbx
mov    %r15d,%r12d
sub    %ebx,%r12d
call   1040 <BLZ_Invert@plt>
mov    %rbx,%rdi
mov    %r12,0x8(%rsp)
mov    %r12d,%esi
call   1040 <BLZ_Invert@plt>
mov    0x40(%rsp),%rdx
mov    0x18(%rsp),%rbx
test   %ebx,%ebx
je     16c0 <BLZ_Code+0x580>
lea    0x4(%rdx),%eax
lea    (%rbx,%rbp,1),%edi
add    $0xb,%edi
mov    %edi,%ecx
and    $0xfffffffc,%ecx
cmp    %ecx,%eax
jae    1729 <BLZ_Code+0x5e9>
test   %edx,%edx
jle    17a7 <BLZ_Code+0x667>
mov    (%rsp),%rdx
lea    0x1(%rdx),%rcx
cmp    %rcx,%r14
mov    %rcx,%rax
cmova  %r14,%rax
sub    %rdx,%rax
cmp    $0x20,%rax
jb     1702 <BLZ_Code+0x5c2>
cmp    %rcx,%r14
cmova  %r14,%rcx
cmp    %r13,%rcx
jbe    17f0 <BLZ_Code+0x6b0>
sub    %rdx,%rcx
add    %r13,%rcx
cmp    %rdx,%rcx
jbe    17f0 <BLZ_Code+0x6b0>
mov    0x10(%rsp),%rbx
mov    %rbx,%r13
mov    0x30(%rsp),%r15
nop
movzbl (%rdx),%eax
mov    %al,0x0(%r13)
add    $0x1,%r13
add    $0x1,%rdx
cmp    %r14,%rdx
jb     1710 <BLZ_Code+0x5d0>
jmp    17b4 <BLZ_Code+0x674>
mov    %rbx,%r14
mov    $0x1,%esi
call   1060 <Memory@plt>
mov    %rbp,%rcx
mov    %rax,%rbp
mov    %ecx,%r10d
mov    %rcx,%r9
test   %ecx,%ecx
mov    (%rsp),%rcx
mov    0x10(%rsp),%r12
je     186c <BLZ_Code+0x72c>
cmp    $0x8,%r9d
jb     1773 <BLZ_Code+0x633>
lea    (%rcx,%r10,1),%rax
cmp    %rbp,%rax
jbe    1b43 <BLZ_Code+0xa03>
lea    (%r10,%rbp,1),%rax
cmp    %rcx,%rax
jbe    1b43 <BLZ_Code+0xa03>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r10,%rcx
mov    %r10,%rdx
and    $0x3,%rdx
je     1826 <BLZ_Code+0x6e6>
mov    (%rsp),%rsi
nop
movzbl (%rsi,%rax,1),%ebx
mov    %bl,0x0(%rbp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1790 <BLZ_Code+0x650>
jmp    182a <BLZ_Code+0x6ea>
mov    0x10(%rsp),%rbx
mov    %rbx,%r13
mov    0x30(%rsp),%r15
mov    %r13d,%eax
sub    %ebx,%eax
test   $0x3,%al
je     17e6 <BLZ_Code+0x6a6>
mov    %r13d,%ebp
not    %ebp
add    %ebx,%ebp
and    $0x3,%ebp
lea    0x1(%rbp),%rdx
mov    %r13,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
xor    %eax,%eax
add    %rbp,%r13
add    $0x1,%r13
mov    %rbx,%rbp
jmp    1a4f <BLZ_Code+0x90f>
xor    %eax,%eax
mov    %rbx,%rbp
jmp    1a4f <BLZ_Code+0x90f>
mov    %rax,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    1a6f <BLZ_Code+0x92f>
xor    %edi,%edi
mov    0x30(%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    1ae9 <BLZ_Code+0x9a9>
mov    (%rsp),%rsi
cmp    $0x3,%rcx
mov    0x20(%rsp),%r13
jb     186c <BLZ_Code+0x72c>
mov    %rsi,%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%rdx,%rax,1),%ecx
mov    %cl,0x0(%rbp,%rax,1)
movzbl 0x1(%rdx,%rax,1),%ecx
mov    %cl,0x1(%rbp,%rax,1)
movzbl 0x2(%rdx,%rax,1),%ecx
mov    %cl,0x2(%rbp,%rax,1)
movzbl 0x3(%rdx,%rax,1),%ecx
mov    %cl,0x3(%rbp,%rax,1)
add    $0x4,%rax
cmp    %rax,%r10
jne    1840 <BLZ_Code+0x700>
mov    %r14,%rax
cmp    $0x2,%eax
mov    $0x1,%r11d
cmovae %eax,%r11d
cmp    $0x8,%r11d
jae    19b1 <BLZ_Code+0x871>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     18ca <BLZ_Code+0x78a>
mov    %r15d,%esi
sub    %r14d,%esi
sub    %r12d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rax,1),%edi
movzbl (%r12,%rdi,1),%ebx
lea    (%r10,%rax,1),%edi
mov    %bl,0x0(%rbp,%rdi,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18b0 <BLZ_Code+0x770>
cmp    $0x3,%rcx
jb     193b <BLZ_Code+0x7fb>
add    %eax,%r15d
sub    %r14d,%r15d
sub    %r12d,%r15d
lea    (%r9,%rax,1),%ecx
sub    %rax,%r11
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r15,%rax,1),%rdx
mov    %edx,%esi
movzbl (%r12,%rsi,1),%ebx
lea    (%rcx,%rax,1),%rsi
mov    %esi,%edi
mov    %bl,0x0(%rbp,%rdi,1)
lea    0x1(%rdx),%edi
movzbl (%r12,%rdi,1),%ebx
lea    0x1(%rsi),%edi
mov    %bl,0x0(%rbp,%rdi,1)
lea    0x2(%rdx),%edi
movzbl (%r12,%rdi,1),%ebx
lea    0x2(%rsi),%edi
mov    %bl,0x0(%rbp,%rdi,1)
add    $0x3,%edx
movzbl (%r12,%rdx,1),%edx
add    $0x3,%esi
mov    %dl,0x0(%rbp,%rsi,1)
add    $0x4,%rax
cmp    %rax,%r11
jne    18f0 <BLZ_Code+0x7b0>
mov    %r14,%r13
mov    %r12,%rdi
mov    %r9,%rbx
lea    (%r9,%r14,1),%r12d
mov    %r10,%r14
call   1030 <free@plt>
lea    (%r14,%rbp,1),%rdi
mov    %r13d,%r15d
add    %r15,%rdi
mov    %edi,%eax
sub    %ebp,%eax
test   $0x3,%al
je     1a2a <BLZ_Code+0x8ea>
mov    %r14,%rcx
xor    $0x3,%bl
add    %bpl,%bl
lea    0x0(%r13,%rbp,1),%eax
sub    %al,%bl
movzbl %bl,%ebx
mov    %ebx,%r14d
and    $0x3,%r14d
lea    0x1(%r14),%rdx
mov    $0xff,%esi
mov    %r12d,0x8(%rsp)
mov    %rcx,%r12
call   1050 <memset@plt>
add    %r12,%r15
mov    0x8(%rsp),%r12d
add    %r14,%r15
and    $0x3,%ebx
lea    (%r15,%rbp,1),%rdi
add    $0x1,%rdi
add    $0x9,%ebx
jmp    1a2f <BLZ_Code+0x8ef>
lea    -0x1(%r11),%rcx
xor    %eax,%eax
mov    %r9d,%edx
add    %ecx,%edx
jb     1888 <BLZ_Code+0x748>
mov    %rcx,%rdx
shr    $0x20,%rdx
jne    1888 <BLZ_Code+0x748>
mov    %r15d,%edi
not    %edi
add    %r14d,%edi
add    %r12d,%edi
cmp    %ecx,%edi
jb     1888 <BLZ_Code+0x748>
test   %rdx,%rdx
jne    1888 <BLZ_Code+0x748>
lea    (%r10,%rbp,1),%rcx
mov    %r15d,%eax
sub    %r14d,%eax
sub    %r12d,%eax
lea    (%r11,%rax,1),%rdx
add    %r13,%rdx
cmp    %rdx,%rcx
jae    1a17 <BLZ_Code+0x8d7>
lea    (%r10,%r11,1),%rcx
add    %rbp,%rcx
add    %rax,%r13
cmp    %rcx,%r13
jb     1886 <BLZ_Code+0x746>
xor    %ecx,%ecx
cmp    $0x20,%r11d
jae    1b7b <BLZ_Code+0xa3b>
xor    %eax,%eax
jmp    1c3e <BLZ_Code+0xafe>
mov    $0x8,%ebx
mov    0x40(%rsp),%rax
add    %ebx,%r13d
mov    %r13d,(%rdi)
mov    %bl,0x3(%rdi)
add    $0x4,%rdi
add    %ebx,%r12d
sub    %r12d,%eax
mov    0x30(%rsp),%r15
mov    %rdi,%r13
mov    %eax,0x0(%r13)
sub    %ebp,%r13d
add    $0x4,%r13d
mov    %r13d,(%r15)
mov    %rbp,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
mov    (%rsp),%rbp
mov    0x30(%rsp),%r15
mov    0x10(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rdi,1),%xmm0
movups 0x10(%rbp,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
movups 0x20(%rbp,%rdi,1),%xmm0
movups 0x30(%rbp,%rdi,1),%xmm1
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm1,0x30(%rbx,%rdi,1)
movups 0x40(%rbp,%rdi,1),%xmm0
movups 0x50(%rbp,%rdi,1),%xmm1
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm1,0x50(%rbx,%rdi,1)
movups 0x60(%rbp,%rdi,1),%xmm0
movups 0x70(%rbp,%rdi,1),%xmm1
movups %xmm0,0x60(%rbx,%rdi,1)
movups %xmm1,0x70(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1a90 <BLZ_Code+0x950>
test   %rdx,%rdx
je     1b2b <BLZ_Code+0x9eb>
mov    (%rsp),%rsi
add    %rdi,%rsi
add    $0x10,%rsi
add    %r13,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1b10 <BLZ_Code+0x9d0>
add    %rcx,%r13
cmp    %rcx,%rax
je     17b4 <BLZ_Code+0x674>
mov    (%rsp),%rdx
add    %rcx,%rdx
jmp    1710 <BLZ_Code+0x5d0>
cmp    $0x20,%r9d
jae    1b50 <BLZ_Code+0xa10>
xor    %eax,%eax
jmp    1d4e <BLZ_Code+0xc0e>
mov    %r10d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x60,%rsi
jae    1c87 <BLZ_Code+0xb47>
xor    %esi,%esi
jmp    1cf9 <BLZ_Code+0xbb9>
mov    %r11d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rsi
mov    %rsi,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1c03 <BLZ_Code+0xac3>
movabs $0xffffffffffffffc,%rsi
ff ff 0f
or     $0x2,%rsi
and    %r8,%rsi
mov    %r15d,%edi
sub    %r14d,%edi
sub    %r12d,%edi
xor    %ecx,%ecx
mov    %r9d,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%edx
movups (%r12,%rdx,1),%xmm0
movups 0x10(%r12,%rdx,1),%xmm1
mov    %ebx,%edx
movups %xmm0,0x0(%rbp,%rdx,1)
movups %xmm1,0x10(%rbp,%rdx,1)
lea    0x20(%rdi),%edx
movups (%r12,%rdx,1),%xmm0
movups 0x10(%r12,%rdx,1),%xmm1
lea    0x20(%rbx),%edx
movups %xmm0,0x0(%rbp,%rdx,1)
movups %xmm1,0x10(%rbp,%rdx,1)
add    $0x40,%edi
add    $0x40,%ebx
add    $0x40,%ecx
add    $0xfffffffffffffffe,%rsi
jne    1bc0 <BLZ_Code+0xa80>
test   $0x1,%r8b
je     1c2b <BLZ_Code+0xaeb>
mov    0x8(%rsp),%rdx
sub    %r14d,%edx
add    %ecx,%edx
movups (%r12,%rdx,1),%xmm0
movups 0x10(%r12,%rdx,1),%xmm1
add    %r9d,%ecx
movups %xmm0,0x0(%rbp,%rcx,1)
movups %xmm1,0x10(%rbp,%rcx,1)
cmp    %r11,%rax
je     193b <BLZ_Code+0x7fb>
test   $0x18,%r11b
je     1888 <BLZ_Code+0x748>
mov    %rax,%rcx
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rcx,%rdx
sub    %rax,%rdx
lea    (%r15,%rcx,1),%esi
sub    %r14d,%esi
sub    %r12d,%esi
add    %r9d,%ecx
nopw   0x0(%rax,%rax,1)
mov    %esi,%edi
mov    (%r12,%rdi,1),%rdi
mov    %ecx,%ebx
mov    %rdi,0x0(%rbp,%rbx,1)
add    $0x8,%esi
add    $0x8,%ecx
add    $0x8,%rdx
jne    1c60 <BLZ_Code+0xb20>
cmp    %r11,%rax
jne    1888 <BLZ_Code+0x748>
jmp    193b <BLZ_Code+0x7fb>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rsi,1),%xmm0
movups 0x10(%rdi,%rsi,1),%xmm1
movups %xmm0,0x0(%rbp,%rsi,1)
movups %xmm1,0x10(%rbp,%rsi,1)
movups 0x20(%rdi,%rsi,1),%xmm0
movups 0x30(%rdi,%rsi,1),%xmm1
movups %xmm0,0x20(%rbp,%rsi,1)
movups %xmm1,0x30(%rbp,%rsi,1)
movups 0x40(%rdi,%rsi,1),%xmm0
movups 0x50(%rdi,%rsi,1),%xmm1
movups %xmm0,0x40(%rbp,%rsi,1)
movups %xmm1,0x50(%rbp,%rsi,1)
movups 0x60(%rdi,%rsi,1),%xmm0
movups 0x70(%rdi,%rsi,1),%xmm1
movups %xmm0,0x60(%rbp,%rsi,1)
movups %xmm1,0x70(%rbp,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1ca0 <BLZ_Code+0xb60>
test   %rcx,%rcx
je     1d3b <BLZ_Code+0xbfb>
lea    (%rsi,%rbp,1),%rdx
add    $0x10,%rdx
mov    (%rsp),%rdi
add    %rdi,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1d20 <BLZ_Code+0xbe0>
cmp    %r10,%rax
je     186c <BLZ_Code+0x72c>
test   $0x18,%r10b
je     1775 <BLZ_Code+0x635>
mov    %rax,%rcx
mov    %r10d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rdx
mov    (%rdx,%rcx,1),%rdx
mov    %rdx,0x0(%rbp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1d60 <BLZ_Code+0xc20>
cmp    %r10,%rax
je     186c <BLZ_Code+0x72c>
jmp    1775 <BLZ_Code+0x635>

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

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