#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;
      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++ = (pos_best - 3) & 0xFF;
    } else {
      *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++;
    while ((pak - pak_buffer) & 3)
      *pak++ = 0;
    *(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;
      hdr_len++;
    }
    *(unsigned int *)pak = enc_len + hdr_len;
    pak += 3;
    *pak++ = hdr_len;
    *(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    1707 <BLZ_Code+0x5d7>
movzbl -0x8d(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x8d(%rbp)
cmp    $0x0,%al
jne    1209 <BLZ_Code+0xd9>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x48(%rbp)
movb   $0x0,(%rax)
movb   $0x80,-0x8d(%rbp)
movl   $0x2,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x1002,%rax
jl     1238 <BLZ_Code+0x108>
mov    $0x1002,%eax
mov    %rax,-0xa0(%rbp)
jmp    124a <BLZ_Code+0x11a>
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     1323 <BLZ_Code+0x1f3>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    12e5 <BLZ_Code+0x1b5>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    1291 <BLZ_Code+0x161>
jmp    12e5 <BLZ_Code+0x1b5>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     12a2 <BLZ_Code+0x172>
jmp    12e5 <BLZ_Code+0x1b5>
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     12d2 <BLZ_Code+0x1a2>
jmp    12e5 <BLZ_Code+0x1b5>
jmp    12d7 <BLZ_Code+0x1a7>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    126e <BLZ_Code+0x13e>
mov    -0x64(%rbp),%eax
cmp    -0x70(%rbp),%eax
jbe    1310 <BLZ_Code+0x1e0>
mov    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmp    $0x12,%eax
jne    130b <BLZ_Code+0x1db>
jmp    1323 <BLZ_Code+0x1f3>
jmp    1310 <BLZ_Code+0x1e0>
jmp    1315 <BLZ_Code+0x1e5>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    125b <BLZ_Code+0x12b>
cmpl   $0x0,-0x1c(%rbp)
je     1604 <BLZ_Code+0x4d4>
cmpl   $0x2,-0x70(%rbp)
jbe    15ff <BLZ_Code+0x4cf>
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jae    15fa <BLZ_Code+0x4ca>
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     138a <BLZ_Code+0x25a>
mov    $0x1002,%eax
mov    %rax,-0xa8(%rbp)
jmp    139c <BLZ_Code+0x26c>
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     1475 <BLZ_Code+0x345>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    1437 <BLZ_Code+0x307>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    13e3 <BLZ_Code+0x2b3>
jmp    1437 <BLZ_Code+0x307>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     13f4 <BLZ_Code+0x2c4>
jmp    1437 <BLZ_Code+0x307>
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     1424 <BLZ_Code+0x2f4>
jmp    1437 <BLZ_Code+0x307>
jmp    1429 <BLZ_Code+0x2f9>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13c0 <BLZ_Code+0x290>
mov    -0x64(%rbp),%eax
cmp    -0x78(%rbp),%eax
jbe    1462 <BLZ_Code+0x332>
mov    -0x68(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
cmp    $0x12,%eax
jne    145d <BLZ_Code+0x32d>
jmp    1475 <BLZ_Code+0x345>
jmp    1462 <BLZ_Code+0x332>
jmp    1467 <BLZ_Code+0x337>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ad <BLZ_Code+0x27d>
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     14be <BLZ_Code+0x38e>
mov    $0x1002,%eax
mov    %rax,-0xb0(%rbp)
jmp    14d0 <BLZ_Code+0x3a0>
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     15ac <BLZ_Code+0x47c>
movl   $0x0,-0x64(%rbp)
cmpl   $0x12,-0x64(%rbp)
jae    156b <BLZ_Code+0x43b>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    %rcx,%rax
cmp    -0x40(%rbp),%rax
jne    1517 <BLZ_Code+0x3e7>
jmp    156b <BLZ_Code+0x43b>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jb     1528 <BLZ_Code+0x3f8>
jmp    156b <BLZ_Code+0x43b>
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     1558 <BLZ_Code+0x428>
jmp    156b <BLZ_Code+0x43b>
jmp    155d <BLZ_Code+0x42d>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14f4 <BLZ_Code+0x3c4>
mov    -0x64(%rbp),%eax
cmp    -0x80(%rbp),%eax
jbe    1599 <BLZ_Code+0x469>
mov    -0x68(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmp    $0x12,%eax
jne    1594 <BLZ_Code+0x464>
jmp    15ac <BLZ_Code+0x47c>
jmp    1599 <BLZ_Code+0x469>
jmp    159e <BLZ_Code+0x46e>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    14e1 <BLZ_Code+0x3b1>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x2,-0x78(%rbp)
ja     15c9 <BLZ_Code+0x499>
movl   $0x1,-0x78(%rbp)
cmpl   $0x2,-0x80(%rbp)
ja     15da <BLZ_Code+0x4aa>
movl   $0x1,-0x80(%rbp)
mov    -0x70(%rbp),%eax
add    -0x78(%rbp),%eax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
ja     15f5 <BLZ_Code+0x4c5>
movl   $0x1,-0x70(%rbp)
jmp    15fa <BLZ_Code+0x4ca>
jmp    15ff <BLZ_Code+0x4cf>
jmp    1604 <BLZ_Code+0x4d4>
mov    -0x48(%rbp),%rax
movzbl (%rax),%ecx
shl    $0x1,%ecx
mov    %cl,(%rax)
cmpl   $0x2,-0x70(%rbp)
jbe    1680 <BLZ_Code+0x550>
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    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x74(%rbp),%eax
sub    $0x3,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    16a2 <BLZ_Code+0x572>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
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    1702 <BLZ_Code+0x5d2>
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    170c <BLZ_Code+0x5dc>
movzbl -0x8d(%rbp),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0xb1(%rbp)
je     1737 <BLZ_Code+0x607>
movzbl -0x8d(%rbp),%eax
cmp    $0x1,%eax
setne  %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    174a <BLZ_Code+0x61a>
jmp    176b <BLZ_Code+0x63b>
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    170c <BLZ_Code+0x5dc>
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     17c1 <BLZ_Code+0x691>
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    1865 <BLZ_Code+0x735>
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    1815 <BLZ_Code+0x6e5>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    17e0 <BLZ_Code+0x6b0>
jmp    181a <BLZ_Code+0x6ea>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
and    $0x3,%rax
cmp    $0x0,%rax
je     184a <BLZ_Code+0x71a>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
jmp    181a <BLZ_Code+0x6ea>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    19d9 <BLZ_Code+0x8a9>
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    18ba <BLZ_Code+0x78a>
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    1889 <BLZ_Code+0x759>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x88(%rbp),%eax
jae    1905 <BLZ_Code+0x7d5>
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    18c1 <BLZ_Code+0x791>
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     1993 <BLZ_Code+0x863>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0xff,(%rax)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    195a <BLZ_Code+0x82a>
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    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
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
add    $0x1,%r8
mov    %al,(%r15)
add    $0x1,%r15
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
add    $0x1,%rdx
mov    %al,0x0(%r13)
add    $0x1,%r13
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 = %408, %4
%51 = load i8*, i8** %11
%52 = load i8*, i8** %12
%53 = icmp ult i8* %51, %52
br i1 %53, label %54, label %409
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 %63, label %60
60: ; preds = %54
%61 = load i8*, i8** %10
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %10
store i8* %61, i8** %13
store i8 0, i8* %61
store i8 -128, i8* %30
br label %63
63: ; preds = %60, %54
store i32 2, i32* %22
%64 = load i8*, i8** %11
%65 = load i8*, i8** %5
%66 = ptrtoint i8* %64 to i64
%67 = ptrtoint i8* %65 to i64
%68 = sub i64 %66, %67
%69 = icmp sge i64 %68, 4098
br i1 %69, label %70, label %71
70: ; preds = %63
br label %77
71: ; preds = %63
%72 = load i8*, i8** %11
%73 = load i8*, i8** %5
%74 = ptrtoint i8* %72 to i64
%75 = ptrtoint i8* %73 to i64
%76 = sub i64 %74, %75
br label %77
77: ; preds = %71, %70
%78 = phi i64 [ 4098, %70 ], [ %76, %71 ]
%79 = trunc i64 %78 to i32
store i32 %79, i32* %21
store i32 3, i32* %20
br label %80
80: ; preds = %135, %77
%81 = load i32, i32* %20
%82 = load i32, i32* %21
%83 = icmp ule i32 %81, %82
br i1 %83, label %84, label %138
84: ; preds = %80
store i32 0, i32* %19
br label %85
85: ; preds = %121, %84
%86 = load i32, i32* %19
%87 = icmp ult i32 %86, 18
br i1 %87, label %88, label %124
88: ; preds = %85
%89 = load i8*, i8** %11
%90 = load i32, i32* %19
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
%93 = load i8*, i8** %12
%94 = icmp eq i8* %92, %93
br i1 %94, label %95, label %96
95: ; preds = %88
br label %124
96: ; preds = %88
%97 = load i32, i32* %19
%98 = load i32, i32* %20
%99 = icmp uge i32 %97, %98
br i1 %99, label %100, label %101
100: ; preds = %96
br label %124
101: ; preds = %96
%102 = load i8*, i8** %11
%103 = load i32, i32* %19
%104 = zext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %102, i64 %104
%106 = load i8, i8* %105
%107 = zext i8 %106 to i32
%108 = load i8*, i8** %11
%109 = load i32, i32* %19
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %108, i64 %110
%112 = load i32, i32* %20
%113 = zext i32 %112 to i64
%114 = sub i64 0, %113
%115 = getelementptr inbounds i8, i8* %111, i64 %114
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = icmp ne i32 %107, %117
br i1 %118, label %119, label %120
119: ; preds = %101
br label %124
120: ; preds = %101
br label %121
121: ; preds = %120
%122 = load i32, i32* %19
%123 = add i32 %122, 1
store i32 %123, i32* %19
br label %85
124: ; preds = %119, %100, %95, %85
%125 = load i32, i32* %19
%126 = load i32, i32* %22
%127 = icmp ugt i32 %125, %126
br i1 %127, label %128, label %134
128: ; preds = %124
%129 = load i32, i32* %20
store i32 %129, i32* %23
%130 = load i32, i32* %19
store i32 %130, i32* %22
%131 = icmp eq i32 %130, 18
br i1 %131, label %132, label %133
132: ; preds = %128
br label %138
133: ; preds = %128
br label %134
134: ; preds = %133, %124
br label %135
135: ; preds = %134
%136 = load i32, i32* %20
%137 = add i32 %136, 1
store i32 %137, i32* %20
br label %80
138: ; preds = %132, %80
%139 = load i32, i32* %8
%140 = icmp ne i32 %139, 0
br i1 %140, label %141, label %332
141: ; preds = %138
%142 = load i32, i32* %22
%143 = icmp ugt i32 %142, 2
br i1 %143, label %144, label %331
144: ; preds = %141
%145 = load i8*, i8** %11
%146 = load i32, i32* %22
%147 = zext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %145, i64 %147
%149 = load i8*, i8** %12
%150 = icmp ult i8* %148, %149
br i1 %150, label %151, label %330
151: ; preds = %144
%152 = load i32, i32* %22
%153 = load i8*, i8** %11
%154 = zext i32 %152 to i64
%155 = getelementptr inbounds i8, i8* %153, i64 %154
store i8* %155, i8** %11
store i32 2, i32* %24
%156 = load i8*, i8** %11
%157 = load i8*, i8** %5
%158 = ptrtoint i8* %156 to i64
%159 = ptrtoint i8* %157 to i64
%160 = sub i64 %158, %159
%161 = icmp sge i64 %160, 4098
br i1 %161, label %162, label %163
162: ; preds = %151
br label %169
163: ; preds = %151
%164 = load i8*, i8** %11
%165 = load i8*, i8** %5
%166 = ptrtoint i8* %164 to i64
%167 = ptrtoint i8* %165 to i64
%168 = sub i64 %166, %167
br label %169
169: ; preds = %163, %162
%170 = phi i64 [ 4098, %162 ], [ %168, %163 ]
%171 = trunc i64 %170 to i32
store i32 %171, i32* %21
store i32 3, i32* %20
br label %172
172: ; preds = %227, %169
%173 = load i32, i32* %20
%174 = load i32, i32* %21
%175 = icmp ule i32 %173, %174
br i1 %175, label %176, label %230
176: ; preds = %172
store i32 0, i32* %19
br label %177
177: ; preds = %213, %176
%178 = load i32, i32* %19
%179 = icmp ult i32 %178, 18
br i1 %179, label %180, label %216
180: ; preds = %177
%181 = load i8*, i8** %11
%182 = load i32, i32* %19
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %181, i64 %183
%185 = load i8*, i8** %12
%186 = icmp eq i8* %184, %185
br i1 %186, label %187, label %188
187: ; preds = %180
br label %216
188: ; preds = %180
%189 = load i32, i32* %19
%190 = load i32, i32* %20
%191 = icmp uge i32 %189, %190
br i1 %191, label %192, label %193
192: ; preds = %188
br label %216
193: ; preds = %188
%194 = load i8*, i8** %11
%195 = load i32, i32* %19
%196 = zext i32 %195 to i64
%197 = getelementptr inbounds i8, i8* %194, i64 %196
%198 = load i8, i8* %197
%199 = zext i8 %198 to i32
%200 = load i8*, i8** %11
%201 = load i32, i32* %19
%202 = zext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
%204 = load i32, i32* %20
%205 = zext i32 %204 to i64
%206 = sub i64 0, %205
%207 = getelementptr inbounds i8, i8* %203, i64 %206
%208 = load i8, i8* %207
%209 = zext i8 %208 to i32
%210 = icmp ne i32 %199, %209
br i1 %210, label %211, label %212
211: ; preds = %193
br label %216
212: ; preds = %193
br label %213
213: ; preds = %212
%214 = load i32, i32* %19
%215 = add i32 %214, 1
store i32 %215, i32* %19
br label %177
216: ; preds = %211, %192, %187, %177
%217 = load i32, i32* %19
%218 = load i32, i32* %24
%219 = icmp ugt i32 %217, %218
br i1 %219, label %220, label %226
220: ; preds = %216
%221 = load i32, i32* %20
store i32 %221, i32* %25
%222 = load i32, i32* %19
store i32 %222, i32* %24
%223 = icmp eq i32 %222, 18
br i1 %223, label %224, label %225
224: ; preds = %220
br label %230
225: ; preds = %220
br label %226
226: ; preds = %225, %216
br label %227
227: ; preds = %226
%228 = load i32, i32* %20
%229 = add i32 %228, 1
store i32 %229, i32* %20
br label %172
230: ; preds = %224, %172
%231 = load i32, i32* %22
%232 = sub i32 %231, 1
%233 = load i8*, i8** %11
%234 = zext i32 %232 to i64
%235 = sub i64 0, %234
%236 = getelementptr inbounds i8, i8* %233, i64 %235
store i8* %236, i8** %11
store i32 2, i32* %26
%237 = load i8*, i8** %11
%238 = load i8*, i8** %5
%239 = ptrtoint i8* %237 to i64
%240 = ptrtoint i8* %238 to i64
%241 = sub i64 %239, %240
%242 = icmp sge i64 %241, 4098
br i1 %242, label %243, label %244
243: ; preds = %230
br label %250
244: ; preds = %230
%245 = load i8*, i8** %11
%246 = load i8*, i8** %5
%247 = ptrtoint i8* %245 to i64
%248 = ptrtoint i8* %246 to i64
%249 = sub i64 %247, %248
br label %250
250: ; preds = %244, %243
%251 = phi i64 [ 4098, %243 ], [ %249, %244 ]
%252 = trunc i64 %251 to i32
store i32 %252, i32* %21
store i32 3, i32* %20
br label %253
253: ; preds = %308, %250
%254 = load i32, i32* %20
%255 = load i32, i32* %21
%256 = icmp ule i32 %254, %255
br i1 %256, label %257, label %311
257: ; preds = %253
store i32 0, i32* %19
br label %258
258: ; preds = %294, %257
%259 = load i32, i32* %19
%260 = icmp ult i32 %259, 18
br i1 %260, label %261, label %297
261: ; preds = %258
%262 = load i8*, i8** %11
%263 = load i32, i32* %19
%264 = zext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
%266 = load i8*, i8** %12
%267 = icmp eq i8* %265, %266
br i1 %267, label %268, label %269
268: ; preds = %261
br label %297
269: ; preds = %261
%270 = load i32, i32* %19
%271 = load i32, i32* %20
%272 = icmp uge i32 %270, %271
br i1 %272, label %273, label %274
273: ; preds = %269
br label %297
274: ; preds = %269
%275 = load i8*, i8** %11
%276 = load i32, i32* %19
%277 = zext i32 %276 to i64
%278 = getelementptr inbounds i8, i8* %275, i64 %277
%279 = load i8, i8* %278
%280 = zext i8 %279 to i32
%281 = load i8*, i8** %11
%282 = load i32, i32* %19
%283 = zext i32 %282 to i64
%284 = getelementptr inbounds i8, i8* %281, i64 %283
%285 = load i32, i32* %20
%286 = zext i32 %285 to i64
%287 = sub i64 0, %286
%288 = getelementptr inbounds i8, i8* %284, i64 %287
%289 = load i8, i8* %288
%290 = zext i8 %289 to i32
%291 = icmp ne i32 %280, %290
br i1 %291, label %292, label %293
292: ; preds = %274
br label %297
293: ; preds = %274
br label %294
294: ; preds = %293
%295 = load i32, i32* %19
%296 = add i32 %295, 1
store i32 %296, i32* %19
br label %258
297: ; preds = %292, %273, %268, %258
%298 = load i32, i32* %19
%299 = load i32, i32* %26
%300 = icmp ugt i32 %298, %299
br i1 %300, label %301, label %307
301: ; preds = %297
%302 = load i32, i32* %20
store i32 %302, i32* %27
%303 = load i32, i32* %19
store i32 %303, i32* %26
%304 = icmp eq i32 %303, 18
br i1 %304, label %305, label %306
305: ; preds = %301
br label %311
306: ; preds = %301
br label %307
307: ; preds = %306, %297
br label %308
308: ; preds = %307
%309 = load i32, i32* %20
%310 = add i32 %309, 1
store i32 %310, i32* %20
br label %253
311: ; preds = %305, %253
%312 = load i8*, i8** %11
%313 = getelementptr inbounds i8, i8* %312, i32 -1
store i8* %313, i8** %11
%314 = load i32, i32* %24
%315 = icmp ule i32 %314, 2
br i1 %315, label %316, label %317
316: ; preds = %311
store i32 1, i32* %24
br label %317
317: ; preds = %316, %311
%318 = load i32, i32* %26
%319 = icmp ule i32 %318, 2
br i1 %319, label %320, label %321
320: ; preds = %317
store i32 1, i32* %26
br label %321
321: ; preds = %320, %317
%322 = load i32, i32* %22
%323 = load i32, i32* %24
%324 = add i32 %322, %323
%325 = load i32, i32* %26
%326 = add i32 1, %325
%327 = icmp ule i32 %324, %326
br i1 %327, label %328, label %329
328: ; preds = %321
store i32 1, i32* %22
br label %329
329: ; preds = %328, %321
br label %330
330: ; preds = %329, %144
br label %331
331: ; preds = %330, %141
br label %332
332: ; preds = %331, %138
%333 = load i8*, i8** %13
%334 = load i8, i8* %333
%335 = zext i8 %334 to i32
%336 = shl i32 %335, 1
%337 = trunc i32 %336 to i8
store i8 %337, i8* %333
%338 = load i32, i32* %22
%339 = icmp ugt i32 %338, 2
br i1 %339, label %340, label %366
340: ; preds = %332
%341 = load i32, i32* %22
%342 = load i8*, i8** %11
%343 = zext i32 %341 to i64
%344 = getelementptr inbounds i8, i8* %342, i64 %343
store i8* %344, i8** %11
%345 = load i8*, i8** %13
%346 = load i8, i8* %345
%347 = zext i8 %346 to i32
%348 = or i32 %347, 1
%349 = trunc i32 %348 to i8
store i8 %349, i8* %345
%350 = load i32, i32* %22
%351 = sub i32 %350, 3
%352 = shl i32 %351, 4
%353 = load i32, i32* %23
%354 = sub i32 %353, 3
%355 = lshr i32 %354, 8
%356 = or i32 %352, %355
%357 = trunc i32 %356 to i8
%358 = load i8*, i8** %10
%359 = getelementptr inbounds i8, i8* %358, i32 1
store i8* %359, i8** %10
store i8 %357, i8* %358
%360 = load i32, i32* %23
%361 = sub i32 %360, 3
%362 = and i32 %361, 255
%363 = trunc i32 %362 to i8
%364 = load i8*, i8** %10
%365 = getelementptr inbounds i8, i8* %364, i32 1
store i8* %365, i8** %10
store i8 %363, i8* %364
br label %372
366: ; preds = %332
%367 = load i8*, i8** %11
%368 = getelementptr inbounds i8, i8* %367, i32 1
store i8* %368, i8** %11
%369 = load i8, i8* %367
%370 = load i8*, i8** %10
%371 = getelementptr inbounds i8, i8* %370, i32 1
store i8* %371, i8** %10
store i8 %369, i8* %370
br label %372
372: ; preds = %366, %340
%373 = load i8*, i8** %10
%374 = load i8*, i8** %9
%375 = ptrtoint i8* %373 to i64
%376 = ptrtoint i8* %374 to i64
%377 = sub i64 %375, %376
%378 = load i32, i32* %6
%379 = sext i32 %378 to i64
%380 = add nsw i64 %377, %379
%381 = load i8*, i8** %11
%382 = load i8*, i8** %5
%383 = ptrtoint i8* %381 to i64
%384 = ptrtoint i8* %382 to i64
%385 = sub i64 %383, %384
%386 = sub nsw i64 %380, %385
%387 = load i32, i32* %28
%388 = load i32, i32* %29
%389 = add i32 %387, %388
%390 = zext i32 %389 to i64
%391 = icmp slt i64 %386, %390
br i1 %391, label %392, label %408
392: ; preds = %372
%393 = load i8*, i8** %10
%394 = load i8*, i8** %9
%395 = ptrtoint i8* %393 to i64
%396 = ptrtoint i8* %394 to i64
%397 = sub i64 %395, %396
%398 = trunc i64 %397 to i32
store i32 %398, i32* %28
%399 = load i32, i32* %6
%400 = sext i32 %399 to i64
%401 = load i8*, i8** %11
%402 = load i8*, i8** %5
%403 = ptrtoint i8* %401 to i64
%404 = ptrtoint i8* %402 to i64
%405 = sub i64 %403, %404
%406 = sub nsw i64 %400, %405
%407 = trunc i64 %406 to i32
store i32 %407, i32* %29
br label %408
408: ; preds = %392, %372
br label %50
409: ; preds = %50
br label %410
410: ; preds = %420, %409
%411 = load i8, i8* %30
%412 = zext i8 %411 to i32
%413 = icmp ne i32 %412, 0
br i1 %413, label %414, label %418
414: ; preds = %410
%415 = load i8, i8* %30
%416 = zext i8 %415 to i32
%417 = icmp ne i32 %416, 1
br label %418
418: ; preds = %414, %410
%419 = phi i1 [ false, %410 ], [ %417, %414 ]
br i1 %419, label %420, label %430
420: ; preds = %418
%421 = load i8, i8* %30
%422 = zext i8 %421 to i32
%423 = ashr i32 %422, 1
%424 = trunc i32 %423 to i8
store i8 %424, i8* %30
%425 = load i8*, i8** %13
%426 = load i8, i8* %425
%427 = zext i8 %426 to i32
%428 = shl i32 %427, 1
%429 = trunc i32 %428 to i8
store i8 %429, i8* %425
br label %410
430: ; preds = %418
%431 = load i8*, i8** %10
%432 = load i8*, i8** %9
%433 = ptrtoint i8* %431 to i64
%434 = ptrtoint i8* %432 to i64
%435 = sub i64 %433, %434
%436 = trunc i64 %435 to i32
store i32 %436, i32* %15
%437 = load i8*, i8** %5
%438 = load i32, i32* %6
%439 = call i32 @BLZ_Invert(i8* %437, i32 %438)
%440 = load i8*, i8** %9
%441 = load i32, i32* %15
%442 = call i32 @BLZ_Invert(i8* %440, i32 %441)
%443 = load i32, i32* %28
%444 = icmp ne i32 %443, 0
br i1 %444, label %445, label %455
445: ; preds = %430
%446 = load i32, i32* %6
%447 = add nsw i32 %446, 4
%448 = load i32, i32* %28
%449 = load i32, i32* %29
%450 = add i32 %448, %449
%451 = add i32 %450, 3
%452 = and i32 %451, -4
%453 = add i32 %452, 8
%454 = icmp ult i32 %447, %453
br i1 %454, label %455, label %489
455: ; preds = %445, %430
%456 = load i8*, i8** %9
store i8* %456, i8** %10
%457 = load i8*, i8** %5
store i8* %457, i8** %11
%458 = load i8*, i8** %5
%459 = load i32, i32* %6
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds i8, i8* %458, i64 %460
store i8* %461, i8** %12
br label %462
462: ; preds = %466, %455
%463 = load i8*, i8** %11
%464 = load i8*, i8** %12
%465 = icmp ult i8* %463, %464
br i1 %465, label %466, label %472
466: ; preds = %462
%467 = load i8*, i8** %11
%468 = getelementptr inbounds i8, i8* %467, i32 1
store i8* %468, i8** %11
%469 = load i8, i8* %467
%470 = load i8*, i8** %10
%471 = getelementptr inbounds i8, i8* %470, i32 1
store i8* %471, i8** %10
store i8 %469, i8* %470
br label %462
472: ; preds = %462
br label %473
473: ; preds = %481, %472
%474 = load i8*, i8** %10
%475 = load i8*, i8** %9
%476 = ptrtoint i8* %474 to i64
%477 = ptrtoint i8* %475 to i64
%478 = sub i64 %476, %477
%479 = and i64 %478, 3
%480 = icmp ne i64 %479, 0
br i1 %480, label %481, label %484
481: ; preds = %473
%482 = load i8*, i8** %10
%483 = getelementptr inbounds i8, i8* %482, i32 1
store i8* %483, i8** %10
store i8 0, i8* %482
br label %473
484: ; preds = %473
%485 = load i8*, i8** %10
%486 = bitcast i8* %485 to i32*
store i32 0, i32* %486
%487 = load i8*, i8** %10
%488 = getelementptr inbounds i8, i8* %487, i64 4
store i8* %488, i8** %10
br label %587
489: ; preds = %445
%490 = load i32, i32* %29
%491 = load i32, i32* %28
%492 = add i32 %490, %491
%493 = add i32 %492, 11
%494 = call i64 @Memory(i32 %493, i32 1)
%495 = inttoptr i64 %494 to i8*
store i8* %495, i8** %14
store i32 0, i32* %19
br label %496
496: ; preds = %510, %489
%497 = load i32, i32* %19
%498 = load i32, i32* %29
%499 = icmp ult i32 %497, %498
br i1 %499, label %500, label %513
500: ; preds = %496
%501 = load i8*, i8** %5
%502 = load i32, i32* %19
%503 = zext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %501, i64 %503
%505 = load i8, i8* %504
%506 = load i8*, i8** %14
%507 = load i32, i32* %19
%508 = zext i32 %507 to i64
%509 = getelementptr inbounds i8, i8* %506, i64 %508
store i8 %505, i8* %509
br label %510
510: ; preds = %500
%511 = load i32, i32* %19
%512 = add i32 %511, 1
store i32 %512, i32* %19
br label %496
513: ; preds = %496
store i32 0, i32* %19
br label %514
514: ; preds = %534, %513
%515 = load i32, i32* %19
%516 = load i32, i32* %28
%517 = icmp ult i32 %515, %516
br i1 %517, label %518, label %537
518: ; preds = %514
%519 = load i8*, i8** %9
%520 = load i32, i32* %19
%521 = load i32, i32* %15
%522 = add i32 %520, %521
%523 = load i32, i32* %28
%524 = sub i32 %522, %523
%525 = zext i32 %524 to i64
%526 = getelementptr inbounds i8, i8* %519, i64 %525
%527 = load i8, i8* %526
%528 = load i8*, i8** %14
%529 = load i32, i32* %29
%530 = load i32, i32* %19
%531 = add i32 %529, %530
%532 = zext i32 %531 to i64
%533 = getelementptr inbounds i8, i8* %528, i64 %532
store i8 %527, i8* %533
br label %534
534: ; preds = %518
%535 = load i32, i32* %19
%536 = add i32 %535, 1
store i32 %536, i32* %19
br label %514
537: ; preds = %514
%538 = load i8*, i8** %9
store i8* %538, i8** %10
%539 = load i8*, i8** %14
store i8* %539, i8** %9
%540 = load i8*, i8** %10
%541 = call i32 @free(i8* %540)
%542 = load i8*, i8** %9
%543 = load i32, i32* %29
%544 = zext i32 %543 to i64
%545 = getelementptr inbounds i8, i8* %542, i64 %544
%546 = load i32, i32* %28
%547 = zext i32 %546 to i64
%548 = getelementptr inbounds i8, i8* %545, i64 %547
store i8* %548, i8** %10
%549 = load i32, i32* %28
store i32 %549, i32* %18
store i32 8, i32* %17
%550 = load i32, i32* %6
%551 = load i32, i32* %28
%552 = sub i32 %550, %551
%553 = load i32, i32* %29
%554 = sub i32 %552, %553
store i32 %554, i32* %16
br label %555
555: ; preds = %563, %537
%556 = load i8*, i8** %10
%557 = load i8*, i8** %9
%558 = ptrtoint i8* %556 to i64
%559 = ptrtoint i8* %557 to i64
%560 = sub i64 %558, %559
%561 = and i64 %560, 3
%562 = icmp ne i64 %561, 0
br i1 %562, label %563, label %568
563: ; preds = %555
%564 = load i8*, i8** %10
%565 = getelementptr inbounds i8, i8* %564, i32 1
store i8* %565, i8** %10
store i8 -1, i8* %564
%566 = load i32, i32* %17
%567 = add i32 %566, 1
store i32 %567, i32* %17
br label %555
568: ; preds = %555
%569 = load i32, i32* %18
%570 = load i32, i32* %17
%571 = add i32 %569, %570
%572 = load i8*, i8** %10
%573 = bitcast i8* %572 to i32*
store i32 %571, i32* %573
%574 = load i8*, i8** %10
%575 = getelementptr inbounds i8, i8* %574, i64 3
store i8* %575, i8** %10
%576 = load i32, i32* %17
%577 = trunc i32 %576 to i8
%578 = load i8*, i8** %10
%579 = getelementptr inbounds i8, i8* %578, i32 1
store i8* %579, i8** %10
store i8 %577, i8* %578
%580 = load i32, i32* %16
%581 = load i32, i32* %17
%582 = sub i32 %580, %581
%583 = load i8*, i8** %10
%584 = bitcast i8* %583 to i32*
store i32 %582, i32* %584
%585 = load i8*, i8** %10
%586 = getelementptr inbounds i8, i8* %585, i64 4
store i8* %586, i8** %10
br label %587
587: ; preds = %568, %484
%588 = load i8*, i8** %10
%589 = load i8*, i8** %9
%590 = ptrtoint i8* %588 to i64
%591 = ptrtoint i8* %589 to i64
%592 = sub i64 %590, %591
%593 = trunc i64 %592 to i32
%594 = load i32*, i32** %7
store i32 %593, i32* %594
%595 = load i8*, i8** %9
ret i8* %595
}

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
%34 = getelementptr inbounds i8, i8* %27, i64 1
store i8 0, i8* %27
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
%248 = getelementptr inbounds i8, i8* %37, i64 1
store i8 %247, i8* %37
%249 = trunc i32 %244 to i8
%250 = getelementptr inbounds i8, i8* %37, i64 2
store i8 %249, i8* %248
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 = getelementptr inbounds i8, i8* %258, i64 1
%260 = load i8, i8* %258
%261 = getelementptr inbounds i8, i8* %37, i64 1
store i8 %260, i8* %37
br label %262
262: ; preds = %256, %236
%263 = phi i32 [ %91, %236 ], [ %257, %256 ]
%264 = phi i8* [ %240, %236 ], [ %259, %256 ]
%265 = phi i8* [ %250, %236 ], [ %261, %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 ], [ %422, %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* [ %422, %417 ], [ %403, %402 ]
%419 = phi i8* [ %420, %417 ], [ %404, %402 ]
%420 = getelementptr inbounds i8, i8* %419, i64 1
%421 = load i8, i8* %419
%422 = getelementptr inbounds i8, i8* %418, i64 1
store i8 %421, i8* %418
%423 = icmp ult i8* %420, %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
%797 = getelementptr inbounds i8, i8* %792, i64 4
store i8 %796, i8* %795
%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
}