#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*/ EINVAL;
int /*<<< orphan*/ errno;
int /*<<< orphan*/ free(char *);
char *malloc(size_t);
int heapsort(void *vbase, size_t nmemb, size_t size,
             int (*compar)(const void *, const void *)) {
  size_t cnt, i, j, l;
  char tmp, *tmp1, *tmp2;
  char *base, *k, *p, *t;
  if (nmemb <= 1)
    return (0);
  if (!size) {
    errno = EINVAL;
    return (-1);
  }
  if ((k = malloc(size)) == NULL)
    return (-1);
  base = (char *)vbase - size;
  for (l = nmemb / 2 + 1; --l;) {
    for (i = l; (j = i * 2) <= nmemb; i = j) {
      p = base + j * size;
      if (j < nmemb && compar(p, p + size) < 0) {
        p += size;
        ++j;
      }
      t = base + i * size;
      if (compar(p, t) <= 0)
        break;
      {
        cnt = size;
        do {
          tmp = *t;
          *t++ = *p;
          *p++ = tmp;
        } while (--cnt);
      };
    }
  };
  while (nmemb > 1) {
    {
      cnt = size;
      tmp1 = k;
      tmp2 = base + nmemb * size;
      do {
        *tmp1++ = *tmp2++;
      } while (--cnt);
    };
    {
      cnt = size;
      tmp1 = base + nmemb * size;
      tmp2 = base + size;
      do {
        *tmp1++ = *tmp2++;
      } while (--cnt);
    };
    --nmemb;
    {
      for (i = 1; (j = i * 2) <= nmemb; i = j) {
        p = base + j * size;
        if (j < nmemb && compar(p, p + size) < 0) {
          p += size;
          ++j;
        }
        t = base + i * size;
        {
          cnt = size;
          tmp1 = t;
          tmp2 = p;
          do {
            *tmp1++ = *tmp2++;
          } while (--cnt);
        };
      }
      for (;;) {
        j = i;
        i = j / 2;
        p = base + j * size;
        t = base + i * size;
        if (j == 1 || compar(k, t) < 0) {
          {
            cnt = size;
            tmp1 = p;
            tmp2 = k;
            do {
              *tmp1++ = *tmp2++;
            } while (--cnt);
          };
          break;
        }
        {
          cnt = size;
          tmp1 = p;
          tmp2 = t;
          do {
            *tmp1++ = *tmp2++;
          } while (--cnt);
        };
      }
    };
  }
  free(k);
  return (0);
}


x86 assembly (clang, -O0):
<heapsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
cmpq   $0x1,-0x18(%rbp)
ja     1152 <heapsort+0x32>
movl   $0x0,-0x4(%rbp)
jmp    15c4 <heapsort+0x4a4>
cmpq   $0x0,-0x20(%rbp)
jne    117b <heapsort+0x5b>
mov    0x2e74(%rip),%rax
mov    (%rax),%ecx
mov    0x2e73(%rip),%rax
mov    %ecx,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    15c4 <heapsort+0x4a4>
mov    -0x20(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    119e <heapsort+0x7e>
movl   $0xffffffff,-0x4(%rbp)
jmp    15c4 <heapsort+0x4a4>
mov    -0x10(%rbp),%rax
xor    %ecx,%ecx
sub    -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     12e1 <heapsort+0x1c1>
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x40(%rbp)
cmp    -0x18(%rbp),%rax
ja     12dc <heapsort+0x1bc>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1248 <heapsort+0x128>
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x78(%rbp),%rsi
add    -0x20(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1248 <heapsort+0x128>
mov    -0x20(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jg     1278 <heapsort+0x158>
jmp    12dc <heapsort+0x1bc>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x49(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%cl
mov    -0x80(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x80(%rbp)
mov    %cl,(%rax)
mov    -0x49(%rbp),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1280 <heapsort+0x160>
jmp    12cf <heapsort+0x1af>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    11dd <heapsort+0xbd>
jmp    11bf <heapsort+0x9f>
jmp    12e6 <heapsort+0x1c6>
cmpq   $0x1,-0x18(%rbp)
jbe    15b4 <heapsort+0x494>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1315 <heapsort+0x1f5>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x68(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1375 <heapsort+0x255>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
movq   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x40(%rbp)
cmp    -0x18(%rbp),%rax
ja     14a2 <heapsort+0x382>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    142c <heapsort+0x30c>
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x78(%rbp),%rsi
add    -0x20(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    142c <heapsort+0x30c>
mov    -0x20(%rbp),%rax
add    -0x78(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1458 <heapsort+0x338>
jmp    1495 <heapsort+0x375>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    13c1 <heapsort+0x2a1>
jmp    14a7 <heapsort+0x387>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x1,-0x40(%rbp)
je     1505 <heapsort+0x3e5>
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    155a <heapsort+0x43a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    151d <heapsort+0x3fd>
jmp    15af <heapsort+0x48f>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
mov    (%rax),%cl
mov    -0x58(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x58(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1572 <heapsort+0x452>
jmp    14a7 <heapsort+0x387>
jmp    12e6 <heapsort+0x1c6>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<heapsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
xor    %eax,%eax
cmp    $0x2,%rsi
jb     202b <heapsort+0xefb>
mov    %rdx,%r12
test   %rdx,%rdx
je     2014 <heapsort+0xee4>
mov    %rcx,%rbx
mov    %rdi,%rbp
mov    %rsi,0x8(%rsp)
mov    %r12,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
je     2026 <heapsort+0xef6>
mov    %rax,0x70(%rsp)
mov    %rbx,0x78(%rsp)
movabs $0xffffffffffffffc,%rax
ff ff 0f
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0x68(%rsp)
mov    %rbp,%rcx
sub    %r12,%rcx
mov    %rcx,0x28(%rsp)
mov    0x8(%rsp),%r9
mov    %r9,%rdx
shr    %rdx
lea    -0x20(%r12),%rcx
mov    %rcx,0x58(%rsp)
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %r12,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rsi,0x10(%rsp)
mov    %rax,0x40(%rsp)
lea    0x2(%rax),%rsi
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
and    %rcx,%rsi
mov    %rsi,0x90(%rsp)
mov    %r12d,%eax
and    $0x1f,%eax
mov    %rax,0x48(%rsp)
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rsp)
mov    %r12d,%eax
and    $0x7,%eax
mov    %rax,0x30(%rsp)
mov    %rbp,0x20(%rsp)
lea    0x30(%rbp),%rax
mov    %rax,0x88(%rsp)
jmp    122f <heapsort+0xff>
nopl   0x0(%rax)
mov    0x38(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
je     14d5 <heapsort+0x3a5>
lea    (%rdx,%rdx,1),%r13
mov    %rdx,0x38(%rsp)
mov    %rdx,%r10
jmp    1244 <heapsort+0x114>
nopl   (%rax)
lea    (%r10,%r10,1),%r13
cmp    %r9,%r13
ja     1220 <heapsort+0xf0>
mov    %r10,%r15
mov    %r13,%rbp
imul   %r12,%rbp
add    0x28(%rsp),%rbp
cmp    %r9,%r13
jae    1290 <heapsort+0x160>
lea    (%r12,%rbp,1),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x78(%rsp),%r14
call   *%r14
mov    %eax,%ecx
shr    $0x1f,%ecx
or     %rcx,%r13
test   %eax,%eax
cmovs  %rbx,%rbp
mov    %r13,(%rsp)
jmp    1299 <heapsort+0x169>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,(%rsp)
mov    0x78(%rsp),%r14
mov    %r15,%rbx
imul   %r12,%rbx
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,1),%r13
mov    %rbp,%rdi
mov    %r13,%rsi
call   *%r14
test   %eax,%eax
mov    0x8(%rsp),%r9
mov    (%rsp),%r10
jle    1220 <heapsort+0xf0>
cmp    $0x8,%r12
jb     12e4 <heapsort+0x1b4>
lea    (%r12,%rbp,1),%rax
cmp    %rax,%r13
jae    1390 <heapsort+0x260>
add    0x20(%rsp),%rbx
cmp    %rbx,%rbp
jae    1390 <heapsort+0x260>
mov    %r12,%r8
mov    %rbp,%rax
mov    %r13,%rcx
lea    -0x1(%r8),%rsi
mov    %r8,%rbp
and    $0x3,%rbp
je     1320 <heapsort+0x1f0>
xor    %edi,%edi
nopl   0x0(%rax)
movzbl (%rcx,%rdi,1),%ebx
movzbl (%rax,%rdi,1),%edx
mov    %dl,(%rcx,%rdi,1)
mov    %bl,(%rax,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1300 <heapsort+0x1d0>
sub    %rdi,%r8
add    %rdi,%rax
add    %rdi,%rcx
cmp    $0x3,%rsi
jb     1240 <heapsort+0x110>
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rcx,%rsi,1),%edx
movzbl (%rax,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
mov    %dl,(%rax,%rsi,1)
movzbl 0x1(%rcx,%rsi,1),%edx
movzbl 0x1(%rax,%rsi,1),%ebx
mov    %bl,0x1(%rcx,%rsi,1)
mov    %dl,0x1(%rax,%rsi,1)
movzbl 0x2(%rcx,%rsi,1),%edx
movzbl 0x2(%rax,%rsi,1),%ebx
mov    %bl,0x2(%rcx,%rsi,1)
mov    %dl,0x2(%rax,%rsi,1)
movzbl 0x3(%rcx,%rsi,1),%edx
movzbl 0x3(%rax,%rsi,1),%ebx
mov    %bl,0x3(%rcx,%rsi,1)
mov    %dl,0x3(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1330 <heapsort+0x200>
jmp    1240 <heapsort+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x20,%r12
jae    139d <heapsort+0x26d>
xor    %edx,%edx
jmp    1479 <heapsort+0x349>
cmpq   $0x20,0x58(%rsp)
jae    13ac <heapsort+0x27c>
xor    %eax,%eax
jmp    1430 <heapsort+0x300>
add    $0xffffffffffffffff,%r15
imul   %r12,%r15
add    0x88(%rsp),%r15
mov    0x90(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r15,%rax,1),%xmm0
movups -0x20(%r15,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,-0x30(%r15,%rax,1)
movups %xmm3,-0x20(%r15,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
movups -0x10(%r15,%rax,1),%xmm0
movups (%r15,%rax,1),%xmm1
movups 0x20(%rbp,%rax,1),%xmm2
movups 0x30(%rbp,%rax,1),%xmm3
movups %xmm2,-0x10(%r15,%rax,1)
movups %xmm3,(%r15,%rax,1)
movups %xmm0,0x20(%rbp,%rax,1)
movups %xmm1,0x30(%rbp,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    13d0 <heapsort+0x2a0>
testb  $0x1,0x50(%rsp)
je     1463 <heapsort+0x333>
movups 0x0(%r13,%rax,1),%xmm0
movups 0x10(%r13,%rax,1),%xmm1
movups 0x0(%rbp,%rax,1),%xmm2
movups 0x10(%rbp,%rax,1),%xmm3
movups %xmm2,0x0(%r13,%rax,1)
movups %xmm3,0x10(%r13,%rax,1)
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
cmp    %r12,0x10(%rsp)
je     1240 <heapsort+0x110>
mov    0x10(%rsp),%rdx
test   $0x18,%r12b
je     14c0 <heapsort+0x390>
mov    0x18(%rsp),%rbx
lea    (%rbx,%rbp,1),%rax
lea    (%rbx,%r13,1),%rcx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rdx,1),%rsi
mov    0x0(%rbp,%rdx,1),%rdi
mov    %rdi,0x0(%r13,%rdx,1)
mov    %rsi,0x0(%rbp,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rbx
jne    1490 <heapsort+0x360>
mov    0x30(%rsp),%r8
cmp    %r12,%rbx
je     1240 <heapsort+0x110>
jmp    12ed <heapsort+0x1bd>
mov    0x10(%rsp),%rax
add    %rax,%r13
add    %rax,%rbp
mov    0x48(%rsp),%r8
jmp    12e7 <heapsort+0x1b7>
cmp    $0x2,%r9
mov    0x20(%rsp),%r15
mov    0x70(%rsp),%rdi
mov    0x68(%rsp),%r10
jb     200b <heapsort+0xedb>
lea    -0x1(%r9),%rax
mov    %rax,0xf0(%rsp)
mov    %rax,%r11
imul   %r12,%r11
lea    (%rdi,%r12,1),%rax
mov    %rax,0xe8(%rsp)
mov    %r12,%rax
imul   %r9,%rax
mov    %rax,0xd8(%rsp)
lea    (%r15,%r12,1),%rax
mov    %rax,0xe0(%rsp)
mov    %r12,%rcx
and    $0xffffffffffffffe0,%rcx
mov    0x50(%rsp),%rax
mov    %eax,%edx
and    $0x3,%edx
and    %rax,0x40(%rsp)
lea    (%r15,%rcx,1),%rax
mov    %rax,0xb0(%rsp)
mov    %r12d,%eax
and    $0x1f,%eax
mov    %rax,0x60(%rsp)
mov    %r12d,%eax
and    $0x7,%eax
mov    %rax,0x38(%rsp)
mov    0x18(%rsp),%rax
lea    (%r15,%rax,1),%rsi
mov    %rsi,0xd0(%rsp)
mov    %rcx,(%rsp)
add    %rdi,%rcx
mov    %rcx,0xa8(%rsp)
lea    (%rdi,%rax,1),%rcx
mov    %rcx,0xc8(%rsp)
neg    %rax
mov    %rax,0xc0(%rsp)
mov    %rdx,0x98(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x10(%rsp)
lea    (%r11,%r15,1),%rbp
add    $0x70,%rbp
lea    0x10(%r15),%rax
mov    %rax,0x48(%rsp)
lea    0x70(%r15),%rax
mov    %rax,0xa0(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0xb8(%rsp)
xor    %r13d,%r13d
mov    %r11,%rcx
mov    %r11,0x80(%rsp)
jmp    161d <heapsort+0x4ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%r13
add    $0x1,%r13
mov    0x90(%rsp),%rbp
add    %r10,%rbp
mov    0x30(%rsp),%rcx
sub    %r12,%rcx
cmp    0xf0(%rsp),%r13
je     200b <heapsort+0xedb>
mov    %rcx,0x30(%rsp)
mov    %r13,%rsi
imul   %r10,%rsi
add    %r11,%rsi
add    %r15,%rsi
mov    %r9,0x8(%rsp)
mov    %r9,%rbx
imul   %r12,%rbx
add    0x28(%rsp),%rbx
mov    %r12,%rdx
mov    %r11,%r14
call   1040 <memcpy@plt>
cmp    $0x8,%r12
mov    %rbp,0x90(%rsp)
mov    %r13,0x88(%rsp)
jb     1696 <heapsort+0x566>
mov    %r13,%rax
imul   %r12,%rax
mov    %r14,%rcx
sub    %rax,%rcx
add    %r15,%rcx
cmp    0xe0(%rsp),%rcx
jae    1c60 <heapsort+0xb30>
mov    0xd8(%rsp),%rcx
sub    %rax,%rcx
add    %r15,%rcx
cmp    %r15,%rcx
jbe    1c60 <heapsort+0xb30>
mov    %r12,%rbp
mov    %r15,%rcx
mov    0x8(%rsp),%r9
lea    -0x1(%rbp),%rax
mov    %rbp,%rdi
and    $0x7,%rdi
je     16c9 <heapsort+0x599>
xor    %esi,%esi
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    16b0 <heapsort+0x580>
sub    %rsi,%rbp
add    %rsi,%rbx
add    %rsi,%rcx
cmp    $0x7,%rax
jb     172f <heapsort+0x5ff>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,1),%eax
mov    %al,(%rbx,%rdx,1)
movzbl 0x1(%rcx,%rdx,1),%eax
mov    %al,0x1(%rbx,%rdx,1)
movzbl 0x2(%rcx,%rdx,1),%eax
mov    %al,0x2(%rbx,%rdx,1)
movzbl 0x3(%rcx,%rdx,1),%eax
mov    %al,0x3(%rbx,%rdx,1)
movzbl 0x4(%rcx,%rdx,1),%eax
mov    %al,0x4(%rbx,%rdx,1)
movzbl 0x5(%rcx,%rdx,1),%eax
mov    %al,0x5(%rbx,%rdx,1)
movzbl 0x6(%rcx,%rdx,1),%eax
mov    %al,0x6(%rbx,%rdx,1)
movzbl 0x7(%rcx,%rdx,1),%eax
mov    %al,0x7(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rbp
jne    16e0 <heapsort+0x5b0>
add    $0xffffffffffffffff,%r9
mov    %r15,%r14
cmp    $0x2,%r9
jb     19d7 <heapsort+0x8a7>
mov    $0x1,%r15d
mov    $0x2,%r14d
mov    %r9,0x8(%rsp)
jmp    176d <heapsort+0x63d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r15,%r15,1),%r14
cmp    %r9,%r14
ja     19c0 <heapsort+0x890>
mov    %r15,%r13
mov    %r14,%rbp
imul   %r12,%rbp
add    0x28(%rsp),%rbp
cmp    %r9,%r14
jae    17a2 <heapsort+0x672>
lea    (%r12,%rbp,1),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *0x78(%rsp)
mov    0x8(%rsp),%r9
mov    %eax,%ecx
shr    $0x1f,%ecx
or     %rcx,%r14
test   %eax,%eax
cmovs  %rbx,%rbp
mov    %r14,%r15
mov    %r13,%rcx
imul   %r12,%rcx
mov    0x28(%rsp),%rax
add    %rcx,%rax
cmp    $0x8,%r12
jb     17d5 <heapsort+0x6a5>
lea    (%r12,%rbp,1),%rdx
cmp    %rdx,%rax
jae    1880 <heapsort+0x750>
add    0x20(%rsp),%rcx
cmp    %rcx,%rbp
jae    1880 <heapsort+0x750>
mov    %r12,%r8
mov    %rax,%rcx
mov    %rbp,%rdx
lea    -0x1(%r8),%rbp
mov    %r8,%rsi
and    $0x7,%rsi
je     1809 <heapsort+0x6d9>
xor    %edi,%edi
nopl   (%rax)
movzbl (%rdx,%rdi,1),%eax
mov    %al,(%rcx,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    17f0 <heapsort+0x6c0>
sub    %rdi,%r8
add    %rdi,%rcx
add    %rdi,%rdx
cmp    $0x7,%rbp
jb     1760 <heapsort+0x630>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdx,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
movzbl 0x1(%rdx,%rax,1),%ebx
mov    %bl,0x1(%rcx,%rax,1)
movzbl 0x2(%rdx,%rax,1),%ebx
mov    %bl,0x2(%rcx,%rax,1)
movzbl 0x3(%rdx,%rax,1),%ebx
mov    %bl,0x3(%rcx,%rax,1)
movzbl 0x4(%rdx,%rax,1),%ebx
mov    %bl,0x4(%rcx,%rax,1)
movzbl 0x5(%rdx,%rax,1),%ebx
mov    %bl,0x5(%rcx,%rax,1)
movzbl 0x6(%rdx,%rax,1),%ebx
mov    %bl,0x6(%rcx,%rax,1)
movzbl 0x7(%rdx,%rax,1),%ebx
mov    %bl,0x7(%rcx,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    1820 <heapsort+0x6f0>
jmp    1760 <heapsort+0x630>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x20,%r12
jae    188d <heapsort+0x75d>
xor    %esi,%esi
jmp    1972 <heapsort+0x842>
cmpq   $0x60,0x58(%rsp)
jae    189e <heapsort+0x76e>
xor    %ecx,%ecx
mov    0x10(%rsp),%rdi
jmp    1919 <heapsort+0x7e9>
lea    -0x1(%r13),%rdx
imul   %r12,%rdx
add    0xa0(%rsp),%rdx
mov    0x40(%rsp),%rsi
xor    %ecx,%ecx
mov    0x10(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rcx,1),%xmm0
movups 0x10(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x70(%rdx,%rcx,1)
movups %xmm1,-0x60(%rdx,%rcx,1)
movups 0x20(%rbp,%rcx,1),%xmm0
movups 0x30(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x50(%rdx,%rcx,1)
movups %xmm1,-0x40(%rdx,%rcx,1)
movups 0x40(%rbp,%rcx,1),%xmm0
movups 0x50(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,1)
movups %xmm1,-0x20(%rdx,%rcx,1)
movups 0x60(%rbp,%rcx,1),%xmm0
movups 0x70(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rcx,1)
movups %xmm1,(%rdx,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rsi
jne    18c0 <heapsort+0x790>
testb  $0x3,0x50(%rsp)
je     195e <heapsort+0x82e>
lea    (%rcx,%rbp,1),%rdx
add    $0x10,%rdx
add    $0xffffffffffffffff,%r13
imul   %r12,%r13
add    %rcx,%r13
add    0x48(%rsp),%r13
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rcx,1),%xmm0
movups (%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%r13,%rcx,1)
movups %xmm1,0x0(%r13,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdi
jne    1940 <heapsort+0x810>
cmp    %r12,(%rsp)
je     1760 <heapsort+0x630>
mov    (%rsp),%rsi
test   $0x18,%r12b
je     19a5 <heapsort+0x875>
mov    0x18(%rsp),%rbx
lea    (%rax,%rbx,1),%rcx
lea    (%rbx,%rbp,1),%rdx
nop
mov    0x0(%rbp,%rsi,1),%rdi
mov    %rdi,(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    1980 <heapsort+0x850>
mov    0x38(%rsp),%r8
cmp    %r12,%rbx
je     1760 <heapsort+0x630>
jmp    17de <heapsort+0x6ae>
mov    (%rsp),%rcx
add    %rcx,%rbp
add    %rcx,%rax
mov    0x60(%rsp),%r8
jmp    17d8 <heapsort+0x6a8>
nopl   0x0(%rax)
mov    %r15,%r14
imul   %r12,%r14
add    0x28(%rsp),%r14
cmp    $0x1,%r15
mov    0x78(%rsp),%r13
jne    1a06 <heapsort+0x8d6>
cmp    $0x8,%r12
jae    1c90 <heapsort+0xb60>
mov    %r12,%rbp
mov    %r14,%rax
mov    0x70(%rsp),%rdi
jmp    1cb6 <heapsort+0xb86>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%r15
je     19d7 <heapsort+0x8a7>
mov    %r14,%rbp
shr    %r15
mov    %r15,%rbx
imul   %r12,%rbx
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,1),%r14
mov    0x70(%rsp),%rdi
mov    %r14,%rsi
call   *%r13
test   %eax,%eax
js     1c7b <heapsort+0xb4b>
cmp    $0x8,%r12
jb     1a50 <heapsort+0x920>
add    0x20(%rsp),%rbx
cmp    %rbx,%rbp
jae    1b00 <heapsort+0x9d0>
lea    (%r12,%rbp,1),%rax
cmp    %rax,%r14
jae    1b00 <heapsort+0x9d0>
mov    %r12,%r8
mov    %rbp,%rcx
mov    %r14,%rax
mov    0x8(%rsp),%r9
lea    -0x1(%r8),%rsi
mov    %r8,%rdx
and    $0x7,%rdx
je     1a89 <heapsort+0x959>
xor    %edi,%edi
nopl   (%rax)
movzbl (%rax,%rdi,1),%ebx
mov    %bl,(%rcx,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1a70 <heapsort+0x940>
sub    %rdi,%r8
add    %rdi,%rcx
add    %rdi,%rax
cmp    $0x7,%rsi
jb     1a00 <heapsort+0x8d0>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
movzbl 0x1(%rax,%rsi,1),%edx
mov    %dl,0x1(%rcx,%rsi,1)
movzbl 0x2(%rax,%rsi,1),%edx
mov    %dl,0x2(%rcx,%rsi,1)
movzbl 0x3(%rax,%rsi,1),%edx
mov    %dl,0x3(%rcx,%rsi,1)
movzbl 0x4(%rax,%rsi,1),%edx
mov    %dl,0x4(%rcx,%rsi,1)
movzbl 0x5(%rax,%rsi,1),%edx
mov    %dl,0x5(%rcx,%rsi,1)
movzbl 0x6(%rax,%rsi,1),%edx
mov    %dl,0x6(%rcx,%rsi,1)
movzbl 0x7(%rax,%rsi,1),%edx
mov    %dl,0x7(%rcx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r8
jne    1aa0 <heapsort+0x970>
jmp    1a00 <heapsort+0x8d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x20,%r12
jae    1b17 <heapsort+0x9e7>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%rdi
jmp    1c0f <heapsort+0xadf>
cmpq   $0x60,0x58(%rsp)
jae    1b35 <heapsort+0xa05>
xor    %eax,%eax
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%rsi
jmp    1bb9 <heapsort+0xa89>
lea    -0x1(%r15),%rcx
imul   %r12,%rcx
add    0xa0(%rsp),%rcx
mov    0x40(%rsp),%rdx
xor    %eax,%eax
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%rdi
mov    0x10(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movups -0x70(%rcx,%rax,1),%xmm0
movups -0x60(%rcx,%rax,1),%xmm1
movups %xmm0,0x0(%rbp,%rax,1)
movups %xmm1,0x10(%rbp,%rax,1)
movups -0x50(%rcx,%rax,1),%xmm0
movups -0x40(%rcx,%rax,1),%xmm1
movups %xmm0,0x20(%rbp,%rax,1)
movups %xmm1,0x30(%rbp,%rax,1)
movups -0x30(%rcx,%rax,1),%xmm0
movups -0x20(%rcx,%rax,1),%xmm1
movups %xmm0,0x40(%rbp,%rax,1)
movups %xmm1,0x50(%rbp,%rax,1)
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,0x60(%rbp,%rax,1)
movups %xmm1,0x70(%rbp,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rdx
jne    1b60 <heapsort+0xa30>
testb  $0x3,0x50(%rsp)
je     1bfb <heapsort+0xacb>
lea    -0x1(%r15),%rcx
imul   %r12,%rcx
add    %rax,%rcx
add    0x48(%rsp),%rcx
add    %rbp,%rax
add    $0x10,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1be0 <heapsort+0xab0>
cmp    %r12,(%rsp)
je     1a00 <heapsort+0x8d0>
mov    (%rsp),%rdx
test   $0x18,%r12b
je     1c45 <heapsort+0xb15>
lea    (%rdi,%rbp,1),%rcx
lea    (%r14,%rdi,1),%rax
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rdx,1),%rsi
mov    %rsi,0x0(%rbp,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    1c20 <heapsort+0xaf0>
mov    0x38(%rsp),%r8
cmp    %r12,%rdi
je     1a00 <heapsort+0x8d0>
jmp    1a5e <heapsort+0x92e>
mov    (%rsp),%rcx
lea    (%r14,%rcx,1),%rax
add    %rcx,%rbp
mov    0x60(%rsp),%r8
mov    %rbp,%rcx
jmp    1a5e <heapsort+0x92e>
nopl   (%rax)
cmp    $0x20,%r12
mov    0x8(%rsp),%r9
jae    1d99 <heapsort+0xc69>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
jmp    1e92 <heapsort+0xd62>
mov    %rbp,%r14
mov    0x8(%rsp),%r9
cmp    $0x8,%r12
jb     19e1 <heapsort+0x8b1>
nopl   (%rax)
cmp    0xe8(%rsp),%r14
mov    0x70(%rsp),%rdi
jae    1d70 <heapsort+0xc40>
lea    (%r14,%r12,1),%rax
cmp    %rax,%rdi
jae    1d70 <heapsort+0xc40>
mov    %r12,%rbp
mov    %r14,%rax
mov    %rdi,%rdx
mov    0x20(%rsp),%r15
mov    0x68(%rsp),%r10
mov    0x80(%rsp),%r11
lea    -0x1(%rbp),%r8
mov    %rbp,%rcx
and    $0x7,%rcx
je     1cf9 <heapsort+0xbc9>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1ce0 <heapsort+0xbb0>
sub    %rsi,%rbp
add    %rsi,%rax
add    %rsi,%rdx
cmp    $0x7,%r8
jb     15f0 <heapsort+0x4c0>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdx,%rsi,1),%ecx
mov    %cl,(%rax,%rsi,1)
movzbl 0x1(%rdx,%rsi,1),%ecx
mov    %cl,0x1(%rax,%rsi,1)
movzbl 0x2(%rdx,%rsi,1),%ecx
mov    %cl,0x2(%rax,%rsi,1)
movzbl 0x3(%rdx,%rsi,1),%ecx
mov    %cl,0x3(%rax,%rsi,1)
movzbl 0x4(%rdx,%rsi,1),%ecx
mov    %cl,0x4(%rax,%rsi,1)
movzbl 0x5(%rdx,%rsi,1),%ecx
mov    %cl,0x5(%rax,%rsi,1)
movzbl 0x6(%rdx,%rsi,1),%ecx
mov    %cl,0x6(%rax,%rsi,1)
movzbl 0x7(%rdx,%rsi,1),%ecx
mov    %cl,0x7(%rax,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbp
jne    1d10 <heapsort+0xbe0>
jmp    15f0 <heapsort+0x4c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x20,%r12
mov    0x68(%rsp),%r10
mov    0x18(%rsp),%rsi
mov    0x80(%rsp),%r11
mov    0x10(%rsp),%rbp
jae    1dad <heapsort+0xc7d>
xor    %ecx,%ecx
mov    0x20(%rsp),%r15
jmp    1f9f <heapsort+0xe6f>
cmpq   $0x60,0x58(%rsp)
jae    1dc5 <heapsort+0xc95>
xor    %eax,%eax
mov    0x30(%rsp),%rsi
jmp    1e41 <heapsort+0xd11>
cmpq   $0x60,0x58(%rsp)
jae    1ede <heapsort+0xdae>
xor    %eax,%eax
mov    0x20(%rsp),%r15
jmp    1f50 <heapsort+0xe20>
mov    0x40(%rsp),%rcx
xor    %eax,%eax
mov    0x30(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r15,%rax,1),%xmm0
movups 0x10(%r15,%rax,1),%xmm1
movups %xmm0,-0x70(%rbp,%rax,1)
movups %xmm1,-0x60(%rbp,%rax,1)
movups 0x20(%r15,%rax,1),%xmm0
movups 0x30(%r15,%rax,1),%xmm1
movups %xmm0,-0x50(%rbp,%rax,1)
movups %xmm1,-0x40(%rbp,%rax,1)
movups 0x40(%r15,%rax,1),%xmm0
movups 0x50(%r15,%rax,1),%xmm1
movups %xmm0,-0x30(%rbp,%rax,1)
movups %xmm1,-0x20(%rbp,%rax,1)
movups 0x60(%r15,%rax,1),%xmm0
movups 0x70(%r15,%rax,1),%xmm1
movups %xmm0,-0x10(%rbp,%rax,1)
movups %xmm1,0x0(%rbp,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    1de0 <heapsort+0xcb0>
cmpq   $0x0,0x98(%rsp)
je     1e7a <heapsort+0xd4a>
add    0x48(%rsp),%rax
mov    0x98(%rsp),%rcx
nopl   0x0(%rax)
movups -0x10(%rax),%xmm0
movups (%rax),%xmm1
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm1,(%rax,%rsi,1)
add    $0x20,%rax
add    $0xffffffffffffffff,%rcx
jne    1e60 <heapsort+0xd30>
cmp    %r12,(%rsp)
je     172f <heapsort+0x5ff>
mov    (%rsp),%rax
test   $0x18,%r12b
je     1fdc <heapsort+0xeac>
add    0x18(%rsp),%rbx
lea    (%r15,%rax,1),%rcx
add    0xc0(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx),%rdx
mov    %rdx,(%rcx,%rsi,1)
add    $0x8,%rcx
add    $0x8,%rax
jne    1eb0 <heapsort+0xd80>
mov    0x38(%rsp),%rbp
mov    0xd0(%rsp),%rcx
cmp    %r12,0x18(%rsp)
jne    16a1 <heapsort+0x571>
jmp    172f <heapsort+0x5ff>
mov    0x40(%rsp),%rcx
xor    %eax,%eax
mov    0x20(%rsp),%r15
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups %xmm0,(%r14,%rax,1)
movups %xmm1,0x10(%r14,%rax,1)
movups 0x20(%rdi,%rax,1),%xmm0
movups 0x30(%rdi,%rax,1),%xmm1
movups %xmm0,0x20(%r14,%rax,1)
movups %xmm1,0x30(%r14,%rax,1)
movups 0x40(%rdi,%rax,1),%xmm0
movups 0x50(%rdi,%rax,1),%xmm1
movups %xmm0,0x40(%r14,%rax,1)
movups %xmm1,0x50(%r14,%rax,1)
movups 0x60(%rdi,%rax,1),%xmm0
movups 0x70(%rdi,%rax,1),%xmm1
movups %xmm0,0x60(%r14,%rax,1)
movups %xmm1,0x70(%r14,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rcx
jne    1ef0 <heapsort+0xdc0>
testb  $0x3,0x50(%rsp)
je     1f8b <heapsort+0xe5b>
mov    0xb8(%rsp),%rcx
add    %rax,%rcx
add    %r14,%rax
add    $0x10,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1f70 <heapsort+0xe40>
cmp    %r12,(%rsp)
je     15f0 <heapsort+0x4c0>
mov    (%rsp),%rcx
test   $0x18,%r12b
je     1ff2 <heapsort+0xec2>
lea    (%r14,%rsi,1),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%rcx,1),%rdx
mov    %rdx,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1fb0 <heapsort+0xe80>
mov    0x38(%rsp),%rbp
mov    0xc8(%rsp),%rdx
cmp    %r12,%rsi
je     15f0 <heapsort+0x4c0>
jmp    1ccb <heapsort+0xb9b>
add    (%rsp),%rbx
mov    0x60(%rsp),%rbp
mov    0xb0(%rsp),%rcx
jmp    16a1 <heapsort+0x571>
add    (%rsp),%r14
mov    0x60(%rsp),%rbp
mov    %r14,%rax
mov    0xa8(%rsp),%rdx
jmp    1ccb <heapsort+0xb9b>
call   1030 <free@plt>
xor    %eax,%eax
jmp    202b <heapsort+0xefb>
mov    0x2fbd(%rip),%rax
mov    (%rax),%eax
mov    0x2fbc(%rip),%rcx
mov    %eax,(%rcx)
mov    $0xffffffff,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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