#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*/ free(char *);
char *malloc(size_t);
int heapsort(void *vbase, size_t nmemb, size_t size,
             int (*compar)(void const *, void const *)) {
  size_t cnt;
  size_t i;
  size_t j;
  size_t l;
  char tmp;
  char *tmp1;
  char *tmp2;
  char *base;
  char *k;
  char *p;
  char *t;
  if (nmemb <= 1) {
    return (0);
  }
  if (!size) {
    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    15b2 <heapsort+0x492>
cmpq   $0x0,-0x20(%rbp)
jne    1169 <heapsort+0x49>
movl   $0xffffffff,-0x4(%rbp)
jmp    15b2 <heapsort+0x492>
mov    -0x20(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    118c <heapsort+0x6c>
movl   $0xffffffff,-0x4(%rbp)
jmp    15b2 <heapsort+0x492>
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     12cf <heapsort+0x1af>
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x40(%rbp)
cmp    -0x18(%rbp),%rax
ja     12ca <heapsort+0x1aa>
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    1236 <heapsort+0x116>
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x78(%rbp),%rsi
add    -0x20(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1236 <heapsort+0x116>
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     1266 <heapsort+0x146>
jmp    12ca <heapsort+0x1aa>
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    126e <heapsort+0x14e>
jmp    12bd <heapsort+0x19d>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    11cb <heapsort+0xab>
jmp    11ad <heapsort+0x8d>
jmp    12d4 <heapsort+0x1b4>
cmpq   $0x1,-0x18(%rbp)
jbe    15a2 <heapsort+0x482>
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    1303 <heapsort+0x1e3>
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    1363 <heapsort+0x243>
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     1490 <heapsort+0x370>
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    141a <heapsort+0x2fa>
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rdi
mov    -0x78(%rbp),%rsi
add    -0x20(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    141a <heapsort+0x2fa>
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    1446 <heapsort+0x326>
jmp    1483 <heapsort+0x363>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    13af <heapsort+0x28f>
jmp    1495 <heapsort+0x375>
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     14f3 <heapsort+0x3d3>
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1548 <heapsort+0x428>
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    150b <heapsort+0x3eb>
jmp    159d <heapsort+0x47d>
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    1560 <heapsort+0x440>
jmp    1495 <heapsort+0x375>
jmp    12d4 <heapsort+0x1b4>
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    %ebp,%ebp
cmp    $0x2,%rsi
jb     2012 <heapsort+0xee2>
mov    %rdx,%r12
mov    $0xffffffff,%ebp
test   %rdx,%rdx
je     2012 <heapsort+0xee2>
mov    %rcx,%rbx
mov    %rdi,%r14
mov    %r12,%rdi
mov    %rsi,0x8(%rsp)
call   1050 <malloc@plt>
mov    0x8(%rsp),%r9
test   %rax,%rax
je     2012 <heapsort+0xee2>
mov    %rax,0x70(%rsp)
mov    %rbx,0x78(%rsp)
movabs $0xffffffffffffffc,%rax
ff ff 0f
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0x68(%rsp)
mov    %r14,%rcx
sub    %r12,%rcx
mov    %rcx,0x28(%rsp)
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    %r14,0x20(%rsp)
lea    0x30(%r14),%rax
mov    %rax,0x88(%rsp)
jmp    122f <heapsort+0xff>
xchg   %ax,%ax
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    %ebp,%ebp
mov    %ebp,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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