void BLZ_Decode(char *filename) {
  unsigned char *pak_buffer, *raw_buffer, *pak, *raw, *pak_end, *raw_end;
  unsigned int pak_len, raw_len, len, pos, inc_len, hdr_len, enc_len, dec_len;
  unsigned char flags, mask;
  printf("- decoding '%s'", filename);
  pak_buffer = Load(filename, &pak_len, 0x00000004, 0x01400000);
  inc_len = *(unsigned int *)(pak_buffer + pak_len - 4);
  if (!inc_len) {
    enc_len = 0;
    dec_len = pak_len - 4;
    pak_len = 0;
    raw_len = dec_len;
  } else {
    if (pak_len < 8) {
      printf("File has a bad header\n");
      exit(-1);
    };
    hdr_len = pak_buffer[pak_len - 5];
    if ((hdr_len < 0x08) || (hdr_len > 0x0B)) {
      printf("Bad header length\n");
      exit(-1);
    };
    if (pak_len <= hdr_len) {
      printf("Bad length\n");
      exit(-1);
    };
    enc_len = *(unsigned int *)(pak_buffer + pak_len - 8) & 0x00FFFFFF;
    dec_len = pak_len - enc_len;
    pak_len = enc_len - hdr_len;
    raw_len = dec_len + enc_len + inc_len;
    if (raw_len > 0x00FFFFFF) {
      printf("Bad decoded length\n");
      exit(-1);
    };
  }
  raw_buffer = (unsigned char *)Memory(raw_len, sizeof(char));
  pak = pak_buffer;
  raw = raw_buffer;
  pak_end = pak_buffer + dec_len + pak_len;
  raw_end = raw_buffer + raw_len;
  for (len = 0; len < dec_len; len++) {
    *raw = *pak;
    raw++;
    pak++;
  }
  BLZ_Invert(pak_buffer + dec_len, pak_len);
  mask = 0;
  while (raw < raw_end) {
    if (!(mask >>= 1)) {
      if (pak == pak_end)
        break;
      flags = *pak;
      pak++;
      mask = 0x80;
    }
    if (!(flags & mask)) {
      if (pak == pak_end)
        break;
      *raw = *pak;
      raw++;
      pak++;
    } else {
      if (pak + 1 >= pak_end)
        break;
      pos = *pak << 8;
      pak++;
      pos |= *pak;
      pak++;
      len = (pos >> 12) + 2 + 1;
      if (raw + len > raw_end) {
        printf(", WARNING: wrong decoded length!");
        len = raw_end - raw;
      }
      pos = (pos & 0xFFF) + 3;
      while (len--) {
        *raw = *(raw - pos);
        raw++;
      }
    }
  }
  BLZ_Invert(raw_buffer + dec_len, raw_len - dec_len);
  raw_len = raw - raw_buffer;
  if (raw != raw_end)
    printf(", WARNING: unexpected end of encoded file!");
  Save(filename, raw_buffer, raw_len);
  free(raw_buffer);
  free(pak_buffer);
  printf("\n");
}


x86 assembly (clang, -O0):
<BLZ_Decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rsi
lea    0xe79(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%rdi
lea    -0x3c(%rbp),%rsi
mov    $0x4,%edx
mov    $0x1400000,%ecx
mov    $0x0,%al
call   1050 <Load@plt>
cltq
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x4(%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    11e7 <BLZ_Decode+0x77>
movl   $0x0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12c7 <BLZ_Decode+0x157>
cmpl   $0x8,-0x3c(%rbp)
jae    1209 <BLZ_Decode+0x99>
lea    0xe18(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x5,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x8,-0x50(%rbp)
jb     1230 <BLZ_Decode+0xc0>
cmpl   $0xb,-0x50(%rbp)
jbe    1248 <BLZ_Decode+0xd8>
lea    0xdf0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
ja     126c <BLZ_Decode+0xfc>
lea    0xddf(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x8(%rax,%rcx,1),%eax
and    $0xffffff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0xffffff,-0x40(%rbp)
jbe    12c2 <BLZ_Decode+0x152>
lea    0xd95(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
jmp    12c7 <BLZ_Decode+0x157>
mov    -0x40(%rbp),%edi
mov    $0x1,%esi
mov    $0x0,%al
call   1090 <Memory@plt>
cltq
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    %rcx,%rax
mov    -0x3c(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x58(%rbp),%eax
jae    1353 <BLZ_Decode+0x1e3>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1315 <BLZ_Decode+0x1a5>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%eax
add    %rax,%rdi
mov    -0x3c(%rbp),%esi
mov    $0x0,%al
call   1040 <BLZ_Invert@plt>
movb   $0x0,-0x5a(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    14e2 <BLZ_Decode+0x372>
movzbl -0x5a(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x5a(%rbp)
cmp    $0x0,%al
jne    13b7 <BLZ_Decode+0x247>
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    139e <BLZ_Decode+0x22e>
jmp    14e2 <BLZ_Decode+0x372>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x59(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movb   $0x80,-0x5a(%rbp)
movzbl -0x59(%rbp),%eax
movzbl -0x5a(%rbp),%ecx
and    %ecx,%eax
cmp    $0x0,%eax
jne    1406 <BLZ_Decode+0x296>
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    13dd <BLZ_Decode+0x26d>
jmp    14e2 <BLZ_Decode+0x372>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    14dd <BLZ_Decode+0x36d>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
cmp    -0x30(%rbp),%rax
jb     141d <BLZ_Decode+0x2ad>
jmp    14e2 <BLZ_Decode+0x372>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
shl    $0x8,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x48(%rbp),%eax
shr    $0xc,%eax
add    $0x2,%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    %rcx,%rax
cmp    -0x38(%rbp),%rax
jbe    148e <BLZ_Decode+0x31e>
lea    0xbe1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
and    $0xfff,%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     14d8 <BLZ_Decode+0x368>
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    149c <BLZ_Decode+0x32c>
jmp    14dd <BLZ_Decode+0x36d>
jmp    136b <BLZ_Decode+0x1fb>
mov    -0x18(%rbp),%rdi
mov    -0x58(%rbp),%eax
add    %rax,%rdi
mov    -0x40(%rbp),%esi
sub    -0x58(%rbp),%esi
mov    $0x0,%al
call   1040 <BLZ_Invert@plt>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x38(%rbp),%rax
je     1523 <BLZ_Decode+0x3b3>
lea    0xb5f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x40(%rbp),%edx
mov    $0x0,%al
call   1080 <Save@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
lea    0xaf6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BLZ_Decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%r14
lea    0xe58(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xc(%rsp),%rsi
mov    %r14,%rdi
mov    $0x4,%edx
mov    $0x1400000,%ecx
xor    %eax,%eax
call   1070 <Load@plt>
movslq %eax,%r13
mov    0xc(%rsp),%ebp
mov    -0x4(%r13,%rbp,1),%ebx
test   %ebx,%ebx
mov    %r14,0x40(%rsp)
je     122a <BLZ_Decode+0x9a>
cmp    $0x7,%ebp
jbe    177f <BLZ_Decode+0x5ef>
lea    -0x5(%rbp),%eax
movzbl 0x0(%r13,%rax,1),%eax
lea    -0xc(%rax),%ecx
cmp    $0xfb,%cl
jbe    1788 <BLZ_Decode+0x5f8>
cmp    %eax,%ebp
jbe    1791 <BLZ_Decode+0x601>
mov    $0xffffff,%ecx
and    -0x8(%r13,%rbp,1),%ecx
mov    %ecx,%edx
sub    %eax,%edx
mov    %edx,0xc(%rsp)
add    %ebp,%ebx
cmp    $0x1000000,%ebx
jae    179a <BLZ_Decode+0x60a>
sub    %ecx,%ebp
jmp    1237 <BLZ_Decode+0xa7>
add    $0xfffffffc,%ebp
movl   $0x0,0xc(%rsp)
mov    %ebp,%ebx
xor    %r15d,%r15d
mov    $0x1,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   10b0 <Memory@plt>
movslq %eax,%r9
mov    %ebp,%r8d
lea    (%r8,%r13,1),%rdi
mov    0xc(%rsp),%r14d
mov    %ebx,0x24(%rsp)
mov    %ebx,%eax
add    %r9,%rax
mov    %rax,0x10(%rsp)
test   %ebp,%ebp
mov    %r13,0x38(%rsp)
mov    %r8,0x30(%rsp)
je     1342 <BLZ_Decode+0x1b2>
lea    -0x1(%r8),%eax
cmp    $0x1f,%eax
jb     12a5 <BLZ_Decode+0x115>
lea    -0x1(%r8),%ecx
lea    (%rcx,%r13,1),%rdx
add    $0x1,%rdx
cmp    %r9,%rdx
jbe    134d <BLZ_Decode+0x1bd>
add    %r9,%rcx
add    $0x1,%rcx
cmp    %r13,%rcx
jbe    134d <BLZ_Decode+0x1bd>
mov    %r9,%rbp
mov    %r8d,%ecx
sub    %r15d,%ecx
mov    %r15d,%eax
not    %eax
add    %r8d,%eax
and    $0x7,%ecx
je     12db <BLZ_Decode+0x14b>
neg    %ecx
xor    %edx,%edx
nop
movzbl 0x0(%r13),%ebx
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0x1,%r13
add    $0xffffffffffffffff,%rdx
cmp    %edx,%ecx
jne    12c0 <BLZ_Decode+0x130>
sub    %edx,%r15d
cmp    $0x7,%eax
jb     143e <BLZ_Decode+0x2ae>
mov    %r8d,%eax
sub    %r15d,%eax
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%r13),%ecx
mov    %cl,0x0(%rbp)
movzbl 0x1(%r13),%ecx
mov    %cl,0x1(%rbp)
movzbl 0x2(%r13),%ecx
mov    %cl,0x2(%rbp)
movzbl 0x3(%r13),%ecx
mov    %cl,0x3(%rbp)
movzbl 0x4(%r13),%ecx
mov    %cl,0x4(%rbp)
movzbl 0x5(%r13),%ecx
mov    %cl,0x5(%rbp)
movzbl 0x6(%r13),%ecx
mov    %cl,0x6(%rbp)
movzbl 0x7(%r13),%ecx
mov    %cl,0x7(%rbp)
add    $0x8,%rbp
add    $0x8,%r13
add    $0xfffffff8,%eax
jne    12f0 <BLZ_Decode+0x160>
jmp    143e <BLZ_Decode+0x2ae>
mov    %r14d,%esi
mov    %r9,%rbp
jmp    1442 <BLZ_Decode+0x2b2>
add    $0x1,%rax
mov    %rax,%r15
and    $0xffffffffffffffe0,%r15
lea    -0x20(%r15),%rsi
mov    %rsi,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdi,%rbx
cmp    $0x60,%rsi
jae    1379 <BLZ_Decode+0x1e9>
xor    %esi,%esi
jmp    13e9 <BLZ_Decode+0x259>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nop
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,(%r9,%rsi,1)
movups %xmm1,0x10(%r9,%rsi,1)
movups 0x20(%r13,%rsi,1),%xmm0
movups 0x30(%r13,%rsi,1),%xmm1
movups %xmm0,0x20(%r9,%rsi,1)
movups %xmm1,0x30(%r9,%rsi,1)
movups 0x40(%r13,%rsi,1),%xmm0
movups 0x50(%r13,%rsi,1),%xmm1
movups %xmm0,0x40(%r9,%rsi,1)
movups %xmm1,0x50(%r9,%rsi,1)
movups 0x60(%r13,%rsi,1),%xmm0
movups 0x70(%r13,%rsi,1),%xmm1
movups %xmm0,0x60(%r9,%rsi,1)
movups %xmm1,0x70(%r9,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1380 <BLZ_Decode+0x1f0>
test   %rcx,%rcx
je     142b <BLZ_Decode+0x29b>
lea    (%r9,%rsi,1),%rdx
add    $0x10,%rdx
add    %r13,%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    1410 <BLZ_Decode+0x280>
add    %r15,%r13
lea    (%r9,%r15,1),%rbp
cmp    %r15,%rax
mov    %rbx,%rdi
jne    12a8 <BLZ_Decode+0x118>
mov    0xc(%rsp),%esi
mov    %r9,0x28(%rsp)
mov    %rdi,%rbx
xor    %eax,%eax
call   1050 <BLZ_Invert@plt>
mov    0x10(%rsp),%r9
cmp    %r9,%rbp
jae    170e <BLZ_Decode+0x57e>
add    %r14,%rbx
xor    %r14d,%r14d
mov    %rbx,%rdi
mov    %rbx,0x18(%rsp)
jmp    1489 <BLZ_Decode+0x2f9>
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rdi
nopl   0x0(%rax)
cmp    %r9,%rbp
jae    170e <BLZ_Decode+0x57e>
cmp    $0x1,%r14b
ja     14d0 <BLZ_Decode+0x340>
cmp    %rdi,%r13
je     170e <BLZ_Decode+0x57e>
mov    0x0(%r13),%r12b
add    $0x1,%r13
mov    $0x80,%r14b
test   %r12b,%r14b
jne    14d8 <BLZ_Decode+0x348>
cmp    %rdi,%r13
je     170e <BLZ_Decode+0x57e>
mov    0x0(%r13),%al
mov    %al,0x0(%rbp)
add    $0x1,%rbp
add    $0x1,%r13
jmp    1480 <BLZ_Decode+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
shr    %r14b
test   %r12b,%r14b
je     14a8 <BLZ_Decode+0x318>
lea    0x1(%r13),%rax
cmp    %rdi,%rax
jae    170e <BLZ_Decode+0x57e>
movzbl 0x0(%r13),%ebx
movzbl 0x1(%r13),%r15d
add    $0x2,%r13
mov    %rbx,%rax
shr    $0x4,%rax
lea    (%rax,%rbp,1),%rcx
add    $0x3,%rcx
cmp    %r9,%rcx
jbe    1530 <BLZ_Decode+0x3a0>
lea    0xb02(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    %r9d,%eax
sub    %ebp,%eax
jne    1534 <BLZ_Decode+0x3a4>
jmp    1480 <BLZ_Decode+0x2f0>
nopl   0x0(%rax,%rax,1)
add    $0x3,%rax
shl    $0x8,%rbx
and    $0xf00,%ebx
lea    0x3(%r15,%rbx,1),%r8
mov    $0xfffffffffffffffd,%r11
sub    %r15,%r11
sub    %rbx,%r11
lea    -0x1(%rax),%r10d
cmp    $0x1f,%r10d
jb     1680 <BLZ_Decode+0x4f0>
mov    %r10,%rcx
sub    %r8,%rcx
add    %rbp,%rcx
add    $0x1,%rcx
cmp    %rcx,%rbp
jae    1585 <BLZ_Decode+0x3f5>
lea    (%r10,%rbp,1),%rcx
add    $0x1,%rcx
lea    (%r11,%rbp,1),%rdx
cmp    %rcx,%rdx
jb     1680 <BLZ_Decode+0x4f0>
add    $0x1,%r10
mov    %r10,%r9
movabs $0x1ffffffe0,%rcx
and    %rcx,%r9
lea    -0x20(%r9),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%ebx
and    $0x3,%ebx
cmp    $0x60,%rdx
jae    15b7 <BLZ_Decode+0x427>
xor    %edi,%edi
jmp    1628 <BLZ_Decode+0x498>
and    $0xfffffffffffffffc,%rcx
lea    0x70(%rbp),%rsi
lea    (%r11,%rbp,1),%rdx
add    $0x70,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x70(%rdx,%rdi,1),%xmm0
movups -0x60(%rdx,%rdi,1),%xmm1
movups %xmm0,-0x70(%rsi,%rdi,1)
movups %xmm1,-0x60(%rsi,%rdi,1)
movups -0x50(%rdx,%rdi,1),%xmm0
movups -0x40(%rdx,%rdi,1),%xmm1
movups %xmm0,-0x50(%rsi,%rdi,1)
movups %xmm1,-0x40(%rsi,%rdi,1)
movups -0x30(%rdx,%rdi,1),%xmm0
movups -0x20(%rdx,%rdi,1),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,1)
movups %xmm1,-0x20(%rsi,%rdi,1)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rcx
jne    15d0 <BLZ_Decode+0x440>
test   %rbx,%rbx
je     165c <BLZ_Decode+0x4cc>
lea    (%rdi,%rbp,1),%rcx
add    $0x10,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%r11,1),%xmm0
movups (%rcx,%r11,1),%xmm1
movups %xmm0,-0x10(%rcx)
movups %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffff,%rbx
jne    1640 <BLZ_Decode+0x4b0>
add    %r9,%rbp
cmp    %r9,%r10
je     146f <BLZ_Decode+0x2df>
sub    %r9d,%eax
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rax),%ecx
test   $0x7,%al
je     16a7 <BLZ_Decode+0x517>
mov    %eax,%edx
and    $0x7,%edx
xor    %esi,%esi
xchg   %ax,%ax
movzbl 0x0(%rbp,%r11,1),%ebx
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0x1,%rsi
cmp    %esi,%edx
jne    1690 <BLZ_Decode+0x500>
sub    %esi,%eax
cmp    $0x7,%ecx
jb     1480 <BLZ_Decode+0x2f0>
mov    $0x7,%ecx
sub    %r8,%rcx
nopl   0x0(%rax,%rax,1)
movzbl -0x7(%rbp,%rcx,1),%edx
mov    %dl,0x0(%rbp)
movzbl -0x6(%rbp,%rcx,1),%edx
mov    %dl,0x1(%rbp)
movzbl -0x5(%rbp,%rcx,1),%edx
mov    %dl,0x2(%rbp)
movzbl -0x4(%rbp,%rcx,1),%edx
mov    %dl,0x3(%rbp)
movzbl -0x3(%rbp,%rcx,1),%edx
mov    %dl,0x4(%rbp)
movzbl -0x2(%rbp,%rcx,1),%edx
mov    %dl,0x5(%rbp)
movzbl -0x1(%rbp,%rcx,1),%edx
mov    %dl,0x6(%rbp)
movzbl 0x0(%rbp,%rcx,1),%edx
mov    %dl,0x7(%rbp)
add    $0x8,%rbp
add    $0xfffffff8,%eax
jne    16c0 <BLZ_Decode+0x530>
jmp    1480 <BLZ_Decode+0x2f0>
mov    0x28(%rsp),%rbx
mov    %rbx,%rdi
mov    0x30(%rsp),%rax
add    %rax,%rdi
mov    0x24(%rsp),%esi
sub    %eax,%esi
xor    %eax,%eax
mov    %r9,%r14
call   1050 <BLZ_Invert@plt>
cmp    %r14,%rbp
je     1741 <BLZ_Decode+0x5b1>
lea    0x8f7(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
sub    %ebx,%ebp
mov    0x40(%rsp),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   10a0 <Save@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x906(%rip),%rdi
jmp    17a1 <BLZ_Decode+0x611>
lea    0x8eb(%rip),%rdi
jmp    17a1 <BLZ_Decode+0x611>
lea    0x8d7(%rip),%rdi
jmp    17a1 <BLZ_Decode+0x611>
lea    0x8bb(%rip),%rdi
call   1060 <puts@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
@.str = [16 x i8] c"- decoding '%s'\00"
@.str.1 = [23 x i8] c"File has a bad header\0A\00"
@.str.2 = [19 x i8] c"Bad header length\0A\00"
@.str.3 = [12 x i8] c"Bad length\0A\00"
@.str.4 = [20 x i8] c"Bad decoded length\0A\00"
@.str.5 = [33 x i8] c", WARNING: wrong decoded length!\00"
@.str.6 = [43 x i8] c", WARNING: unexpected end of encoded file!\00"
@.str.7 = [2 x i8] c"\0A\00"
define void @BLZ_Decode(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8
%18 = alloca i8
store i8* %0, i8** %2
%19 = load i8*, i8** %2
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i8* %19)
%21 = load i8*, i8** %2
%22 = call i32 (i8*, i32*, i32, i32, ...) bitcast (i32 (...)* @Load to i32 (i8*, i32*, i32, i32, ...)*)(i8* %21, i32* %9, i32 4, i32 20971520)
%23 = sext i32 %22 to i64
%24 = inttoptr i64 %23 to i8*
store i8* %24, i8** %3
%25 = load i8*, i8** %3
%26 = load i32, i32* %9
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
%29 = getelementptr inbounds i8, i8* %28, i64 -4
%30 = bitcast i8* %29 to i32*
%31 = load i32, i32* %30
store i32 %31, i32* %13
%32 = load i32, i32* %13
%33 = icmp ne i32 %32, 0
br i1 %33, label %38, label %34
34: ; preds = %1
store i32 0, i32* %15
%35 = load i32, i32* %9
%36 = sub i32 %35, 4
store i32 %36, i32* %16
store i32 0, i32* %9
%37 = load i32, i32* %16
store i32 %37, i32* %10
br label %89
38: ; preds = %1
%39 = load i32, i32* %9
%40 = icmp ult i32 %39, 8
br i1 %40, label %41, label %43
41: ; preds = %38
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.1, i64 0, i64 0))
unreachable
43: ; preds = %38
%44 = load i8*, i8** %3
%45 = load i32, i32* %9
%46 = sub i32 %45, 5
%47 = zext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %44, i64 %47
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
store i32 %50, i32* %14
%51 = load i32, i32* %14
%52 = icmp ult i32 %51, 8
br i1 %52, label %56, label %53
53: ; preds = %43
%54 = load i32, i32* %14
%55 = icmp ugt i32 %54, 11
br i1 %55, label %56, label %58
56: ; preds = %53, %43
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
unreachable
58: ; preds = %53
%59 = load i32, i32* %9
%60 = load i32, i32* %14
%61 = icmp ule i32 %59, %60
br i1 %61, label %62, label %64
62: ; preds = %58
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
unreachable
64: ; preds = %58
%65 = load i8*, i8** %3
%66 = load i32, i32* %9
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
%69 = getelementptr inbounds i8, i8* %68, i64 -8
%70 = bitcast i8* %69 to i32*
%71 = load i32, i32* %70
%72 = and i32 %71, 16777215
store i32 %72, i32* %15
%73 = load i32, i32* %9
%74 = load i32, i32* %15
%75 = sub i32 %73, %74
store i32 %75, i32* %16
%76 = load i32, i32* %15
%77 = load i32, i32* %14
%78 = sub i32 %76, %77
store i32 %78, i32* %9
%79 = load i32, i32* %16
%80 = load i32, i32* %15
%81 = add i32 %79, %80
%82 = load i32, i32* %13
%83 = add i32 %81, %82
store i32 %83, i32* %10
%84 = load i32, i32* %10
%85 = icmp ugt i32 %84, 16777215
br i1 %85, label %86, label %88
86: ; preds = %64
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i64 0, i64 0))
unreachable
88: ; preds = %64
br label %89
89: ; preds = %88, %34
%90 = load i32, i32* %10
%91 = call i32 (i32, i64, ...) bitcast (i32 (...)* @Memory to i32 (i32, i64, ...)*)(i32 %90, i64 1)
%92 = sext i32 %91 to i64
%93 = inttoptr i64 %92 to i8*
store i8* %93, i8** %4
%94 = load i8*, i8** %3
store i8* %94, i8** %5
%95 = load i8*, i8** %4
store i8* %95, i8** %6
%96 = load i8*, i8** %3
%97 = load i32, i32* %16
%98 = zext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %96, i64 %98
%100 = load i32, i32* %9
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %99, i64 %101
store i8* %102, i8** %7
%103 = load i8*, i8** %4
%104 = load i32, i32* %10
%105 = zext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
store i8* %106, i8** %8
store i32 0, i32* %11
br label %107
107: ; preds = %119, %89
%108 = load i32, i32* %11
%109 = load i32, i32* %16
%110 = icmp ult i32 %108, %109
br i1 %110, label %111, label %122
111: ; preds = %107
%112 = load i8*, i8** %5
%113 = load i8, i8* %112
%114 = load i8*, i8** %6
store i8 %113, i8* %114
%115 = load i8*, i8** %6
%116 = getelementptr inbounds i8, i8* %115, i32 1
store i8* %116, i8** %6
%117 = load i8*, i8** %5
%118 = getelementptr inbounds i8, i8* %117, i32 1
store i8* %118, i8** %5
br label %119
119: ; preds = %111
%120 = load i32, i32* %11
%121 = add i32 %120, 1
store i32 %121, i32* %11
br label %107
122: ; preds = %107
%123 = load i8*, i8** %3
%124 = load i32, i32* %16
%125 = zext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = load i32, i32* %9
%128 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @BLZ_Invert to i32 (i8*, i32, ...)*)(i8* %126, i32 %127)
store i8 0, i8* %18
br label %129
129: ; preds = %226, %122
%130 = load i8*, i8** %6
%131 = load i8*, i8** %8
%132 = icmp ult i8* %130, %131
br i1 %132, label %133, label %227
133: ; preds = %129
%134 = load i8, i8* %18
%135 = zext i8 %134 to i32
%136 = ashr i32 %135, 1
%137 = trunc i32 %136 to i8
store i8 %137, i8* %18
%138 = icmp ne i8 %137, 0
br i1 %138, label %149, label %139
139: ; preds = %133
%140 = load i8*, i8** %5
%141 = load i8*, i8** %7
%142 = icmp eq i8* %140, %141
br i1 %142, label %143, label %144
143: ; preds = %139
br label %227
144: ; preds = %139
%145 = load i8*, i8** %5
%146 = load i8, i8* %145
store i8 %146, i8* %17
%147 = load i8*, i8** %5
%148 = getelementptr inbounds i8, i8* %147, i32 1
store i8* %148, i8** %5
store i8 -128, i8* %18
br label %149
149: ; preds = %144, %133
%150 = load i8, i8* %17
%151 = zext i8 %150 to i32
%152 = load i8, i8* %18
%153 = zext i8 %152 to i32
%154 = and i32 %151, %153
%155 = icmp ne i32 %154, 0
br i1 %155, label %169, label %156
156: ; preds = %149
%157 = load i8*, i8** %5
%158 = load i8*, i8** %7
%159 = icmp eq i8* %157, %158
br i1 %159, label %160, label %161
160: ; preds = %156
br label %227
161: ; preds = %156
%162 = load i8*, i8** %5
%163 = load i8, i8* %162
%164 = load i8*, i8** %6
store i8 %163, i8* %164
%165 = load i8*, i8** %6
%166 = getelementptr inbounds i8, i8* %165, i32 1
store i8* %166, i8** %6
%167 = load i8*, i8** %5
%168 = getelementptr inbounds i8, i8* %167, i32 1
store i8* %168, i8** %5
br label %226
169: ; preds = %149
%170 = load i8*, i8** %5
%171 = getelementptr inbounds i8, i8* %170, i64 1
%172 = load i8*, i8** %7
%173 = icmp uge i8* %171, %172
br i1 %173, label %174, label %175
174: ; preds = %169
br label %227
175: ; preds = %169
%176 = load i8*, i8** %5
%177 = load i8, i8* %176
%178 = zext i8 %177 to i32
%179 = shl i32 %178, 8
store i32 %179, i32* %12
%180 = load i8*, i8** %5
%181 = getelementptr inbounds i8, i8* %180, i32 1
store i8* %181, i8** %5
%182 = load i8*, i8** %5
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = load i32, i32* %12
%186 = or i32 %185, %184
store i32 %186, i32* %12
%187 = load i8*, i8** %5
%188 = getelementptr inbounds i8, i8* %187, i32 1
store i8* %188, i8** %5
%189 = load i32, i32* %12
%190 = lshr i32 %189, 12
%191 = add i32 %190, 2
%192 = add i32 %191, 1
store i32 %192, i32* %11
%193 = load i8*, i8** %6
%194 = load i32, i32* %11
%195 = zext i32 %194 to i64
%196 = getelementptr inbounds i8, i8* %193, i64 %195
%197 = load i8*, i8** %8
%198 = icmp ugt i8* %196, %197
br i1 %198, label %199, label %207
199: ; preds = %175
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.5, i64 0, i64 0))
%201 = load i8*, i8** %8
%202 = load i8*, i8** %6
%203 = ptrtoint i8* %201 to i64
%204 = ptrtoint i8* %202 to i64
%205 = sub i64 %203, %204
%206 = trunc i64 %205 to i32
store i32 %206, i32* %11
br label %207
207: ; preds = %199, %175
%208 = load i32, i32* %12
%209 = and i32 %208, 4095
%210 = add i32 %209, 3
store i32 %210, i32* %12
br label %211
211: ; preds = %215, %207
%212 = load i32, i32* %11
%213 = add i32 %212, -1
store i32 %213, i32* %11
%214 = icmp ne i32 %212, 0
br i1 %214, label %215, label %225
215: ; preds = %211
%216 = load i8*, i8** %6
%217 = load i32, i32* %12
%218 = zext i32 %217 to i64
%219 = sub i64 0, %218
%220 = getelementptr inbounds i8, i8* %216, i64 %219
%221 = load i8, i8* %220
%222 = load i8*, i8** %6
store i8 %221, i8* %222
%223 = load i8*, i8** %6
%224 = getelementptr inbounds i8, i8* %223, i32 1
store i8* %224, i8** %6
br label %211
225: ; preds = %211
br label %226
226: ; preds = %225, %161
br label %129
227: ; preds = %174, %160, %143, %129
%228 = load i8*, i8** %4
%229 = load i32, i32* %16
%230 = zext i32 %229 to i64
%231 = getelementptr inbounds i8, i8* %228, i64 %230
%232 = load i32, i32* %10
%233 = load i32, i32* %16
%234 = sub i32 %232, %233
%235 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @BLZ_Invert to i32 (i8*, i32, ...)*)(i8* %231, i32 %234)
%236 = load i8*, i8** %6
%237 = load i8*, i8** %4
%238 = ptrtoint i8* %236 to i64
%239 = ptrtoint i8* %237 to i64
%240 = sub i64 %238, %239
%241 = trunc i64 %240 to i32
store i32 %241, i32* %10
%242 = load i8*, i8** %6
%243 = load i8*, i8** %8
%244 = icmp ne i8* %242, %243
br i1 %244, label %245, label %247
245: ; preds = %227
%246 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.6, i64 0, i64 0))
br label %247
247: ; preds = %245, %227
%248 = load i8*, i8** %2
%249 = load i8*, i8** %4
%250 = load i32, i32* %10
%251 = call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @Save to i32 (i8*, i8*, i32, ...)*)(i8* %248, i8* %249, i32 %250)
%252 = load i8*, i8** %4
%253 = load i8*, i8** %3
%254 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
ret void
}

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