#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*/ assert(int /*<<< orphan*/);
int /*<<< orphan*/ heap_isheap(void *, size_t, size_t,
                               int (*)(void const *, void const *));
int /*<<< orphan*/ siftup(unsigned char *, void *, size_t,
                          int (*)(void const *, void const *), int);
void heap_heapify(void *base, size_t nmemb, size_t size,
                  int (*cmp)(const void *, const void *)) {
  unsigned int ipos;
  unsigned char *cbase = (unsigned char *)base, *end = cbase + nmemb * size,
                *pos, *lchild, *rchild;
  if (nmemb < 2) {
    return;
  }
  ipos = ((nmemb) >> (1)) - 1;
  pos = cbase + (nmemb - (ipos + 1)) * size;
  lchild = cbase + (nmemb - (1 + (1 + ((ipos) << (1))))) * size;
  rchild = lchild - size;
  if (rchild >= cbase) {
    if (cmp(lchild, rchild) < 0) {
      if (cmp(lchild, pos) < 0) {
        do {
          unsigned char SWAP_tmp, *SWAP_tone = (unsigned char *)lchild,
                                  *SWAP_ttwo = (unsigned char *)pos;
          size_t SWAP_size = size;
          do {
            SWAP_tmp = *SWAP_tone;
            *SWAP_tone = *SWAP_ttwo;
            *SWAP_ttwo = SWAP_tmp;
            ++SWAP_tone;
            ++SWAP_ttwo;
          } while (--SWAP_size);
        } while (0);
      }
    } else {
      if (cmp(rchild, pos) < 0) {
        do {
          unsigned char SWAP_tmp, *SWAP_tone = (unsigned char *)rchild,
                                  *SWAP_ttwo = (unsigned char *)pos;
          size_t SWAP_size = size;
          do {
            SWAP_tmp = *SWAP_tone;
            *SWAP_tone = *SWAP_ttwo;
            *SWAP_ttwo = SWAP_tmp;
            ++SWAP_tone;
            ++SWAP_ttwo;
          } while (--SWAP_size);
        } while (0);
      }
    }
  } else {
    if (cmp(lchild, pos) < 0) {
      do {
        unsigned char SWAP_tmp, *SWAP_tone = (unsigned char *)lchild,
                                *SWAP_ttwo = (unsigned char *)pos;
        size_t SWAP_size = size;
        do {
          SWAP_tmp = *SWAP_tone;
          *SWAP_tone = *SWAP_ttwo;
          *SWAP_ttwo = SWAP_tmp;
          ++SWAP_tone;
          ++SWAP_ttwo;
        } while (--SWAP_size);
      } while (0);
    }
  }
  pos += size;
  lchild += size + size;
  rchild += size + size;
  while (pos < end) {
    if (cmp(lchild, rchild) < 0) {
      if (cmp(lchild, pos) < 0) {
        do {
          unsigned char SWAP_tmp, *SWAP_tone = (unsigned char *)lchild,
                                  *SWAP_ttwo = (unsigned char *)pos;
          size_t SWAP_size = size;
          do {
            SWAP_tmp = *SWAP_tone;
            *SWAP_tone = *SWAP_ttwo;
            *SWAP_ttwo = SWAP_tmp;
            ++SWAP_tone;
            ++SWAP_ttwo;
          } while (--SWAP_size);
        } while (0);
        siftup(lchild, base, size, cmp, ((pos - lchild) << (1)));
      }
    } else {
      if (cmp(rchild, pos) < 0) {
        do {
          unsigned char SWAP_tmp, *SWAP_tone = (unsigned char *)rchild,
                                  *SWAP_ttwo = (unsigned char *)pos;
          size_t SWAP_size = size;
          do {
            SWAP_tmp = *SWAP_tone;
            *SWAP_tone = *SWAP_ttwo;
            *SWAP_ttwo = SWAP_tmp;
            ++SWAP_tone;
            ++SWAP_ttwo;
          } while (--SWAP_size);
        } while (0);
        siftup(rchild, base, size, cmp, ((pos - lchild) << (1)) + size);
      }
    }
    pos += size;
    lchild += size + size;
    rchild += size + size;
  }
  assert(heap_isheap(base, nmemb, size, cmp));
  return;
}


x86 assembly (clang, -O0):
<heap_heapify>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x2,-0x10(%rbp)
jae    1177 <heap_heapify+0x47>
jmp    1655 <heap_heapify+0x525>
mov    -0x10(%rbp),%rax
shr    $0x1,%rax
sub    $0x1,%rax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
sub    %rdx,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
add    $0x1,%edx
mov    %edx,%edx
sub    %rdx,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x30(%rbp),%rax
jb     133b <heap_heapify+0x20b>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    128f <heap_heapify+0x15f>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    128a <heap_heapify+0x15a>
jmp    121c <heap_heapify+0xec>
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x51(%rbp)
mov    -0x68(%rbp),%rax
mov    (%rax),%cl
mov    -0x60(%rbp),%rax
mov    %cl,(%rax)
mov    -0x51(%rbp),%cl
mov    -0x68(%rbp),%rax
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    1234 <heap_heapify+0x104>
jmp    1285 <heap_heapify+0x155>
jmp    128a <heap_heapify+0x15a>
jmp    1336 <heap_heapify+0x206>
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1331 <heap_heapify+0x201>
jmp    12ab <heap_heapify+0x17b>
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x71(%rbp)
mov    -0x88(%rbp),%rax
mov    (%rax),%cl
mov    -0x80(%rbp),%rax
mov    %cl,(%rax)
mov    -0x71(%rbp),%cl
mov    -0x88(%rbp),%rax
mov    %cl,(%rax)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
mov    -0x90(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x90(%rbp)
cmp    $0x0,%rax
jne    12c9 <heap_heapify+0x199>
jmp    132c <heap_heapify+0x1fc>
jmp    1331 <heap_heapify+0x201>
jmp    1336 <heap_heapify+0x206>
jmp    13f7 <heap_heapify+0x2c7>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    13f2 <heap_heapify+0x2c2>
jmp    1357 <heap_heapify+0x227>
mov    -0x48(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa0(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x91(%rbp)
mov    -0xa8(%rbp),%rax
mov    (%rax),%cl
mov    -0xa0(%rbp),%rax
mov    %cl,(%rax)
mov    -0x91(%rbp),%cl
mov    -0xa8(%rbp),%rax
mov    %cl,(%rax)
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb0(%rbp)
cmp    $0x0,%rax
jne    1378 <heap_heapify+0x248>
jmp    13ed <heap_heapify+0x2bd>
jmp    13f2 <heap_heapify+0x2c2>
jmp    13f7 <heap_heapify+0x2c7>
mov    -0x18(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    1639 <heap_heapify+0x509>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1526 <heap_heapify+0x3f6>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1521 <heap_heapify+0x3f1>
jmp    1464 <heap_heapify+0x334>
mov    -0x48(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    (%rax),%al
mov    %al,-0xb1(%rbp)
mov    -0xc8(%rbp),%rax
mov    (%rax),%cl
mov    -0xc0(%rbp),%rax
mov    %cl,(%rax)
mov    -0xb1(%rbp),%cl
mov    -0xc8(%rbp),%rax
mov    %cl,(%rax)
mov    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xd0(%rbp)
cmp    $0x0,%rax
jne    1485 <heap_heapify+0x355>
jmp    14fa <heap_heapify+0x3ca>
mov    -0x48(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%r8
sub    %r8,%rax
shl    $0x1,%rax
mov    %eax,%r8d
call   1050 <siftup@plt>
jmp    1608 <heap_heapify+0x4d8>
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
jge    1603 <heap_heapify+0x4d3>
jmp    1542 <heap_heapify+0x412>
mov    -0x50(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xe0(%rbp),%rax
mov    (%rax),%al
mov    %al,-0xd1(%rbp)
mov    -0xe8(%rbp),%rax
mov    (%rax),%cl
mov    -0xe0(%rbp),%rax
mov    %cl,(%rax)
mov    -0xd1(%rbp),%cl
mov    -0xe8(%rbp),%rax
mov    %cl,(%rax)
mov    -0xe0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xf0(%rbp)
cmp    $0x0,%rax
jne    1563 <heap_heapify+0x433>
jmp    15d8 <heap_heapify+0x4a8>
mov    -0x50(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%r8
sub    %r8,%rax
shl    $0x1,%rax
add    -0x18(%rbp),%rax
mov    %eax,%r8d
call   1050 <siftup@plt>
jmp    1608 <heap_heapify+0x4d8>
mov    -0x18(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
add    -0x18(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1423 <heap_heapify+0x2f3>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1030 <heap_isheap@plt>
mov    %eax,%edi
call   1040 <assert@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<heap_heapify>:
cmp    $0x2,%rsi
jae    1137 <heap_heapify+0x7>
ret
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rcx,0x18(%rsp)
mov    %rdx,%rax
imul   %rsi,%rax
add    %rdi,%rax
mov    %rax,0x78(%rsp)
mov    %rsi,%rax
shr    %rax
mov    %eax,%eax
mov    %rsi,%r14
sub    %rax,%r14
mov    %r14,0x38(%rsp)
imul   %rdx,%r14
mov    %r14,0x30(%rsp)
lea    (%rdi,%r14,1),%r13
movabs $0xffffffff00000001,%r12
ff ff ff
mov    %rsi,0xa0(%rsp)
and    %rsi,%r12
mov    %r12,%r15
imul   %rdx,%r15
lea    (%rdi,%r15,1),%r14
mov    %r14,%rbp
mov    %rdx,0x28(%rsp)
sub    %rdx,%rbp
mov    %rdi,0x8(%rsp)
cmp    %rdi,%rbp
mov    %rbp,0x10(%rsp)
mov    %r14,%rdi
jae    122b <heap_heapify+0xfb>
mov    %r13,%rsi
call   *0x18(%rsp)
mov    %r14,%rdi
test   %eax,%eax
mov    0x28(%rsp),%r9
jns    189d <heap_heapify+0x76d>
mov    %rdi,%rax
mov    %r13,%rcx
mov    %r9,%r8
cmp    $0x8,%r9
jb     162c <heap_heapify+0x4fc>
mov    0x38(%rsp),%rax
add    $0x1,%rax
imul   %r9,%rax
add    0x8(%rsp),%rax
cmp    %rax,%rdi
jae    121a <heap_heapify+0xea>
lea    0x1(%r12),%rdx
imul   %r9,%rdx
add    0x8(%rsp),%rdx
mov    %rdi,%rax
mov    %r13,%rcx
mov    %r9,%r8
cmp    %rdx,%r13
jb     162c <heap_heapify+0x4fc>
cmp    $0x20,%r9
jae    1317 <heap_heapify+0x1e7>
xor    %esi,%esi
jmp    1545 <heap_heapify+0x415>
mov    %rbp,%rsi
mov    0x18(%rsp),%rbx
call   *%rbx
test   %eax,%eax
js     12a4 <heap_heapify+0x174>
mov    %rbp,%rdi
mov    %r13,%rsi
call   *%rbx
test   %eax,%eax
mov    0x28(%rsp),%r9
mov    %r14,%rdi
jns    189d <heap_heapify+0x76d>
mov    0x10(%rsp),%rcx
mov    %r13,%rdx
mov    %r9,%r10
cmp    $0x8,%r9
jb     1757 <heap_heapify+0x627>
mov    0x38(%rsp),%rax
add    $0x1,%rax
imul   %r9,%rax
add    0x8(%rsp),%rax
cmp    %rax,0x10(%rsp)
jae    1293 <heap_heapify+0x163>
mov    0x10(%rsp),%rcx
mov    %r13,%rdx
mov    %r9,%r10
cmp    %rdi,%r13
jb     1757 <heap_heapify+0x627>
cmp    $0x20,%r9
jae    13bd <heap_heapify+0x28d>
xor    %eax,%eax
jmp    15d2 <heap_heapify+0x4a2>
mov    %r14,%rdi
mov    %r13,%rsi
call   *%rbx
test   %eax,%eax
mov    0x28(%rsp),%r9
mov    %r14,%rdi
jns    189d <heap_heapify+0x76d>
mov    %rdi,%rax
mov    %r13,%rcx
mov    %r9,%r8
cmp    $0x8,%r9
jb     1807 <heap_heapify+0x6d7>
mov    0x38(%rsp),%rax
add    $0x1,%rax
imul   %r9,%rax
add    0x8(%rsp),%rax
cmp    %rax,%rdi
jae    1306 <heap_heapify+0x1d6>
lea    0x1(%r12),%rdx
imul   %r9,%rdx
add    0x8(%rsp),%rdx
mov    %rdi,%rax
mov    %r13,%rcx
mov    %r9,%r8
cmp    %rdx,%r13
jb     1807 <heap_heapify+0x6d7>
cmp    $0x20,%r9
jae    1464 <heap_heapify+0x334>
xor    %esi,%esi
jmp    1705 <heap_heapify+0x5d5>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rax
shr    $0x5,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     1502 <heap_heapify+0x3d2>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x8(%rsp),%rcx
lea    (%r15,%rcx,1),%rbx
add    $0x30,%rbx
mov    0x30(%rsp),%rbp
add    %rcx,%rbp
add    $0x30,%rbp
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rbx,%rcx,1),%xmm0
movups -0x20(%rbx,%rcx,1),%xmm1
movups -0x30(%rbp,%rcx,1),%xmm2
movups -0x20(%rbp,%rcx,1),%xmm3
movups %xmm2,-0x30(%rbx,%rcx,1)
movups %xmm3,-0x20(%rbx,%rcx,1)
movups %xmm0,-0x30(%rbp,%rcx,1)
movups %xmm1,-0x20(%rbp,%rcx,1)
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups -0x10(%rbp,%rcx,1),%xmm2
movups 0x0(%rbp,%rcx,1),%xmm3
movups %xmm2,-0x10(%rbx,%rcx,1)
movups %xmm3,(%rbx,%rcx,1)
movups %xmm0,-0x10(%rbp,%rcx,1)
movups %xmm1,0x0(%rbp,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1360 <heap_heapify+0x230>
jmp    1504 <heap_heapify+0x3d4>
mov    %r9,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
mov    0x8(%rsp),%rbp
je     1589 <heap_heapify+0x459>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    -0x1(%r12),%rdx
imul   %r9,%rdx
lea    (%rdx,%rbp,1),%rbx
add    $0x30,%rbx
mov    0x30(%rsp),%rdx
add    %rdx,%rbp
add    $0x30,%rbp
xor    %edx,%edx
movups -0x30(%rbx,%rdx,1),%xmm0
movups -0x20(%rbx,%rdx,1),%xmm1
movups -0x30(%rbp,%rdx,1),%xmm2
movups -0x20(%rbp,%rdx,1),%xmm3
movups %xmm2,-0x30(%rbx,%rdx,1)
movups %xmm3,-0x20(%rbx,%rdx,1)
movups %xmm0,-0x30(%rbp,%rdx,1)
movups %xmm1,-0x20(%rbp,%rdx,1)
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups -0x10(%rbp,%rdx,1),%xmm2
movups 0x0(%rbp,%rdx,1),%xmm3
movups %xmm2,-0x10(%rbx,%rdx,1)
movups %xmm3,(%rbx,%rdx,1)
movups %xmm0,-0x10(%rbp,%rdx,1)
movups %xmm1,0x0(%rbp,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1407 <heap_heapify+0x2d7>
jmp    158b <heap_heapify+0x45b>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rax
shr    $0x5,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     16c2 <heap_heapify+0x592>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x8(%rsp),%rcx
lea    (%r15,%rcx,1),%rbx
add    $0x30,%rbx
mov    0x30(%rsp),%rbp
add    %rcx,%rbp
add    $0x30,%rbp
xor    %ecx,%ecx
movups -0x30(%rbx,%rcx,1),%xmm0
movups -0x20(%rbx,%rcx,1),%xmm1
movups -0x30(%rbp,%rcx,1),%xmm2
movups -0x20(%rbp,%rcx,1),%xmm3
movups %xmm2,-0x30(%rbx,%rcx,1)
movups %xmm3,-0x20(%rbx,%rcx,1)
movups %xmm0,-0x30(%rbp,%rcx,1)
movups %xmm1,-0x20(%rbp,%rcx,1)
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups -0x10(%rbp,%rcx,1),%xmm2
movups 0x0(%rbp,%rcx,1),%xmm3
movups %xmm2,-0x10(%rbx,%rcx,1)
movups %xmm3,(%rbx,%rcx,1)
movups %xmm0,-0x10(%rbp,%rcx,1)
movups %xmm1,0x0(%rbp,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    14a5 <heap_heapify+0x375>
jmp    16c4 <heap_heapify+0x594>
xor    %ecx,%ecx
test   $0x1,%al
je     1532 <heap_heapify+0x402>
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups 0x0(%r13,%rcx,1),%xmm2
movups 0x10(%r13,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm3,0x10(%rdi,%rcx,1)
movups %xmm0,0x0(%r13,%rcx,1)
movups %xmm1,0x10(%r13,%rcx,1)
cmp    %r9,%rsi
je     189d <heap_heapify+0x76d>
test   $0x18,%r9b
je     161b <heap_heapify+0x4eb>
mov    %r9,%rbx
and    $0xfffffffffffffff8,%rbx
lea    (%rdi,%rbx,1),%rax
lea    (%rbx,%r13,1),%rcx
mov    %r9d,%r8d
and    $0x7,%r8d
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rsi,1),%rdx
mov    0x0(%r13,%rsi,1),%rbp
mov    %rbp,(%rdi,%rsi,1)
mov    %rdx,0x0(%r13,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    1560 <heap_heapify+0x430>
cmp    %r9,%rbx
jne    162c <heap_heapify+0x4fc>
jmp    189d <heap_heapify+0x76d>
xor    %edx,%edx
test   $0x1,%cl
je     15bf <heap_heapify+0x48f>
mov    0x10(%rsp),%rcx
movups (%rcx,%rdx,1),%xmm0
movups 0x10(%rcx,%rdx,1),%xmm1
movups 0x0(%r13,%rdx,1),%xmm2
movups 0x10(%r13,%rdx,1),%xmm3
movups %xmm2,(%rcx,%rdx,1)
movups %xmm3,0x10(%rcx,%rdx,1)
movups %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
cmp    %r9,%rax
je     189d <heap_heapify+0x76d>
test   $0x18,%r9b
je     1744 <heap_heapify+0x614>
mov    0x10(%rsp),%rbp
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%rbp,1),%rcx
lea    (%r8,%r13,1),%rdx
mov    %r9d,%r10d
and    $0x7,%r10d
nopl   (%rax)
mov    0x0(%rbp,%rax,1),%rsi
mov    0x0(%r13,%rax,1),%rbx
mov    %rbx,0x0(%rbp,%rax,1)
mov    %rsi,0x0(%r13,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    15f0 <heap_heapify+0x4c0>
cmp    %r9,%r8
jne    1757 <heap_heapify+0x627>
jmp    189d <heap_heapify+0x76d>
mov    %r9d,%r8d
and    $0x1f,%r8d
lea    (%rsi,%r13,1),%rcx
add    %rdi,%rsi
mov    %rsi,%rax
lea    -0x1(%r8),%r10
mov    %r8,%rbp
and    $0x3,%rbp
je     1660 <heap_heapify+0x530>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%ebx
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rax,%rsi,1)
mov    %bl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1640 <heap_heapify+0x510>
add    %rsi,%rax
add    %rsi,%rcx
sub    %rsi,%r8
cmp    $0x3,%r10
jb     189d <heap_heapify+0x76d>
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rax,%rsi,1),%edx
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
mov    %dl,(%rcx,%rsi,1)
movzbl 0x1(%rax,%rsi,1),%edx
movzbl 0x1(%rcx,%rsi,1),%ebx
mov    %bl,0x1(%rax,%rsi,1)
mov    %dl,0x1(%rcx,%rsi,1)
movzbl 0x2(%rax,%rsi,1),%edx
movzbl 0x2(%rcx,%rsi,1),%ebx
mov    %bl,0x2(%rax,%rsi,1)
mov    %dl,0x2(%rcx,%rsi,1)
movzbl 0x3(%rax,%rsi,1),%edx
movzbl 0x3(%rcx,%rsi,1),%ebx
mov    %bl,0x3(%rax,%rsi,1)
mov    %dl,0x3(%rcx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1670 <heap_heapify+0x540>
jmp    189d <heap_heapify+0x76d>
xor    %ecx,%ecx
test   $0x1,%al
je     16f2 <heap_heapify+0x5c2>
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups 0x0(%r13,%rcx,1),%xmm2
movups 0x10(%r13,%rcx,1),%xmm3
movups %xmm2,(%rdi,%rcx,1)
movups %xmm3,0x10(%rdi,%rcx,1)
movups %xmm0,0x0(%r13,%rcx,1)
movups %xmm1,0x10(%r13,%rcx,1)
cmp    %r9,%rsi
je     189d <heap_heapify+0x76d>
test   $0x18,%r9b
je     17f6 <heap_heapify+0x6c6>
mov    %r9,%rbx
and    $0xfffffffffffffff8,%rbx
lea    (%rdi,%rbx,1),%rax
lea    (%rbx,%r13,1),%rcx
mov    %r9d,%r8d
and    $0x7,%r8d
mov    (%rdi,%rsi,1),%rdx
mov    0x0(%r13,%rsi,1),%rbp
mov    %rbp,(%rdi,%rsi,1)
mov    %rdx,0x0(%r13,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    171b <heap_heapify+0x5eb>
cmp    %r9,%rbx
jne    1807 <heap_heapify+0x6d7>
jmp    189d <heap_heapify+0x76d>
mov    %r9d,%r10d
and    $0x1f,%r10d
lea    (%rax,%r13,1),%rdx
add    0x10(%rsp),%rax
mov    %rax,%rcx
lea    -0x1(%r10),%r8
mov    %r10,%rsi
and    $0x3,%rsi
je     1790 <heap_heapify+0x660>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%rcx,%rbp,1),%ebx
movzbl (%rdx,%rbp,1),%eax
mov    %al,(%rcx,%rbp,1)
mov    %bl,(%rdx,%rbp,1)
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1770 <heap_heapify+0x640>
add    %rbp,%rcx
add    %rbp,%rdx
sub    %rbp,%r10
cmp    $0x3,%r8
jb     189d <heap_heapify+0x76d>
xor    %eax,%eax
nopl   0x0(%rax)
movzbl (%rcx,%rax,1),%esi
movzbl (%rdx,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
mov    %sil,(%rdx,%rax,1)
movzbl 0x1(%rcx,%rax,1),%esi
movzbl 0x1(%rdx,%rax,1),%ebx
mov    %bl,0x1(%rcx,%rax,1)
mov    %sil,0x1(%rdx,%rax,1)
movzbl 0x2(%rcx,%rax,1),%esi
movzbl 0x2(%rdx,%rax,1),%ebx
mov    %bl,0x2(%rcx,%rax,1)
mov    %sil,0x2(%rdx,%rax,1)
movzbl 0x3(%rcx,%rax,1),%esi
movzbl 0x3(%rdx,%rax,1),%ebx
mov    %bl,0x3(%rcx,%rax,1)
mov    %sil,0x3(%rdx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r10
jne    17a0 <heap_heapify+0x670>
jmp    189d <heap_heapify+0x76d>
mov    %r9d,%r8d
and    $0x1f,%r8d
lea    (%rsi,%r13,1),%rcx
add    %rdi,%rsi
mov    %rsi,%rax
lea    -0x1(%r8),%r10
mov    %r8,%rbp
and    $0x3,%rbp
je     1840 <heap_heapify+0x710>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%ebx
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rax,%rsi,1)
mov    %bl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1820 <heap_heapify+0x6f0>
add    %rsi,%rax
add    %rsi,%rcx
sub    %rsi,%r8
cmp    $0x3,%r10
jb     189d <heap_heapify+0x76d>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%edx
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
mov    %dl,(%rcx,%rsi,1)
movzbl 0x1(%rax,%rsi,1),%edx
movzbl 0x1(%rcx,%rsi,1),%ebx
mov    %bl,0x1(%rax,%rsi,1)
mov    %dl,0x1(%rcx,%rsi,1)
movzbl 0x2(%rax,%rsi,1),%edx
movzbl 0x2(%rcx,%rsi,1),%ebx
mov    %bl,0x2(%rax,%rsi,1)
mov    %dl,0x2(%rcx,%rsi,1)
movzbl 0x3(%rax,%rsi,1),%edx
movzbl 0x3(%rcx,%rsi,1),%ebx
mov    %bl,0x3(%rax,%rsi,1)
mov    %dl,0x3(%rcx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1850 <heap_heapify+0x720>
add    %r9,%r13
cmp    0x78(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r15
jae    1eea <heap_heapify+0xdba>
lea    (%r9,%r9,1),%rbp
mov    %r12,%rax
or     $0x2,%rax
imul   %r9,%rax
mov    %rax,0xb0(%rsp)
lea    0x3(%r12),%rax
imul   %r9,%rax
mov    %rax,0x98(%rsp)
addq   $0x2,0x38(%rsp)
lea    0x1(%r12),%rax
imul   %r9,%rax
lea    -0x20(%r9),%rdx
mov    %rdx,0x60(%rsp)
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %r9,%rdx
and    $0xffffffffffffffe0,%rdx
mov    %rdx,0x20(%rsp)
mov    %rsi,%rdx
mov    %rsi,0x58(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x50(%rsp)
mov    %r9d,%edx
and    $0x1f,%edx
mov    %rdx,0x48(%rsp)
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rdx,0x70(%rsp)
mov    %r9d,%edx
and    $0x7,%edx
mov    %rdx,0x68(%rsp)
mov    0x8(%rsp),%rbx
lea    (%rbx,%rax,1),%rdx
add    $0x30,%rdx
mov    %rax,0xa8(%rsp)
add    %rbx,%rax
add    $0x2,%r12
imul   %r9,%r12
lea    (%rbx,%r12,1),%rsi
add    $0x30,%rsi
add    %rbx,%r12
xor    %ebx,%ebx
mov    %rbp,0xb8(%rsp)
jmp    19f6 <heap_heapify+0x8c6>
nopl   0x0(%rax)
mov    %r13d,%eax
sub    %r10d,%eax
lea    (%rdx,%rax,2),%r8d
mov    %r11,%r15
mov    %r11,%rdi
mov    0x8(%rsp),%rsi
mov    0x18(%rsp),%rcx
call   1050 <siftup@plt>
mov    0x28(%rsp),%r9
add    %r9,%r13
mov    0xc0(%rsp),%rbx
add    $0x1,%rbx
mov    0xb8(%rsp),%rbp
mov    0x90(%rsp),%rdx
add    %rbp,%rdx
mov    0x30(%rsp),%rax
add    %rbp,%rax
mov    0x88(%rsp),%rsi
add    %rbp,%rsi
mov    0x40(%rsp),%r12
add    %rbp,%r12
cmp    0x78(%rsp),%r13
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%r14
jae    1eea <heap_heapify+0xdba>
mov    %rsi,0x88(%rsp)
mov    %rax,0x30(%rsp)
mov    %rdx,0x90(%rsp)
mov    %r12,0x40(%rsp)
mov    %rbp,%r12
imul   %rbx,%r12
mov    0xb0(%rsp),%rax
add    %r12,%rax
mov    0x8(%rsp),%rdx
add    %rdx,%rax
mov    %rax,0x80(%rsp)
mov    0x38(%rsp),%rax
mov    %rbx,0xc0(%rsp)
add    %rax,%rbx
imul   %r9,%rbx
add    %rdx,%rbx
add    %rbp,%rdi
add    %rbp,%r15
mov    %r15,%rsi
mov    %rdi,%rbp
call   *%r14
test   %eax,%eax
mov    %rbp,0x10(%rsp)
js     1ad0 <heap_heapify+0x9a0>
mov    %r15,%rdi
mov    %r13,%rsi
call   *%r14
test   %eax,%eax
jns    199f <heap_heapify+0x86f>
mov    %r15,%r11
mov    %r13,%rcx
mov    0x28(%rsp),%rdx
mov    %rdx,%r8
cmp    $0x8,%rdx
mov    0x10(%rsp),%r10
jb     1d80 <heap_heapify+0xc50>
add    0xa8(%rsp),%r12
add    0x8(%rsp),%r12
cmp    %rbx,%r12
jae    1ab8 <heap_heapify+0x988>
mov    %r11,%r15
mov    %r13,%rcx
mov    %rdx,%r8
cmp    0x80(%rsp),%r13
jb     1d80 <heap_heapify+0xc50>
cmp    $0x20,%rdx
jae    1b3e <heap_heapify+0xa0e>
xor    %ebx,%ebx
jmp    1c2a <heap_heapify+0xafa>
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    %r13,%rsi
call   *%r14
test   %eax,%eax
jns    199f <heap_heapify+0x86f>
mov    0x10(%rsp),%rdi
mov    %rdi,%r11
mov    %r13,%rbp
mov    0x28(%rsp),%rdx
mov    %rdx,%r8
cmp    $0x8,%rdx
mov    0x18(%rsp),%rcx
jb     1e2c <heap_heapify+0xcfc>
cmp    %rbx,0x80(%rsp)
jae    1b2c <heap_heapify+0x9fc>
add    0x98(%rsp),%r12
add    0x8(%rsp),%r12
mov    %rdi,%r11
mov    %r13,%rbp
mov    %rdx,%r8
cmp    %r12,%r13
jb     1e2c <heap_heapify+0xcfc>
cmp    $0x20,%rdx
jae    1b50 <heap_heapify+0xa20>
xor    %ebx,%ebx
mov    0x40(%rsp),%r8
jmp    1d2f <heap_heapify+0xbff>
cmpq   $0x20,0x60(%rsp)
jae    1b63 <heap_heapify+0xa33>
xor    %eax,%eax
mov    %r11,%rsi
jmp    1be0 <heap_heapify+0xab0>
cmpq   $0x20,0x60(%rsp)
jae    1c6e <heap_heapify+0xb3e>
xor    %eax,%eax
jmp    1ce0 <heap_heapify+0xbb0>
mov    0x50(%rsp),%rcx
xor    %eax,%eax
mov    %r11,%rsi
mov    0x90(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rdi,%rax,1),%xmm0
movups -0x20(%rdi,%rax,1),%xmm1
movups 0x0(%r13,%rax,1),%xmm2
movups 0x10(%r13,%rax,1),%xmm3
movups %xmm2,-0x30(%rdi,%rax,1)
movups %xmm3,-0x20(%rdi,%rax,1)
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
movups -0x10(%rdi,%rax,1),%xmm0
movups (%rdi,%rax,1),%xmm1
movups 0x20(%r13,%rax,1),%xmm2
movups 0x30(%r13,%rax,1),%xmm3
movups %xmm2,-0x10(%rdi,%rax,1)
movups %xmm3,(%rdi,%rax,1)
movups %xmm0,0x20(%r13,%rax,1)
movups %xmm1,0x30(%r13,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b80 <heap_heapify+0xa50>
testb  $0x1,0x58(%rsp)
je     1c11 <heap_heapify+0xae1>
movups (%rsi,%rax,1),%xmm0
movups 0x10(%rsi,%rax,1),%xmm1
movups 0x0(%r13,%rax,1),%xmm2
movups 0x10(%r13,%rax,1),%xmm3
movups %xmm2,(%rsi,%rax,1)
movups %xmm3,0x10(%rsi,%rax,1)
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
cmp    %rdx,0x20(%rsp)
je     1980 <heap_heapify+0x850>
mov    0x20(%rsp),%rbx
test   $0x18,%dl
je     1d6e <heap_heapify+0xc3e>
mov    0x70(%rsp),%r9
lea    (%r11,%r9,1),%r15
lea    (%r9,%r13,1),%rcx
mov    0x30(%rsp),%rax
nopl   0x0(%rax)
mov    (%rax,%rbx,1),%rsi
mov    0x0(%r13,%rbx,1),%rdi
mov    %rdi,(%rax,%rbx,1)
mov    %rsi,0x0(%r13,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r9
jne    1c40 <heap_heapify+0xb10>
mov    0x68(%rsp),%r8
cmp    %rdx,%r9
je     1980 <heap_heapify+0x850>
jmp    1d80 <heap_heapify+0xc50>
mov    0x50(%rsp),%rbp
xor    %eax,%eax
mov    0x88(%rsp),%rsi
nopl   (%rax)
movups -0x30(%rsi,%rax,1),%xmm0
movups -0x20(%rsi,%rax,1),%xmm1
movups 0x0(%r13,%rax,1),%xmm2
movups 0x10(%r13,%rax,1),%xmm3
movups %xmm2,-0x30(%rsi,%rax,1)
movups %xmm3,-0x20(%rsi,%rax,1)
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
movups -0x10(%rsi,%rax,1),%xmm0
movups (%rsi,%rax,1),%xmm1
movups 0x20(%r13,%rax,1),%xmm2
movups 0x30(%r13,%rax,1),%xmm3
movups %xmm2,-0x10(%rsi,%rax,1)
movups %xmm3,(%rsi,%rax,1)
movups %xmm0,0x20(%r13,%rax,1)
movups %xmm1,0x30(%r13,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbp
jne    1c80 <heap_heapify+0xb50>
testb  $0x1,0x58(%rsp)
je     1d11 <heap_heapify+0xbe1>
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups 0x0(%r13,%rax,1),%xmm2
movups 0x10(%r13,%rax,1),%xmm3
movups %xmm2,(%rdi,%rax,1)
movups %xmm3,0x10(%rdi,%rax,1)
movups %xmm0,0x0(%r13,%rax,1)
movups %xmm1,0x10(%r13,%rax,1)
cmp    %rdx,0x20(%rsp)
je     1ed7 <heap_heapify+0xda7>
mov    0x20(%rsp),%rbx
test   $0x18,%dl
mov    0x40(%rsp),%r8
je     1e1a <heap_heapify+0xcea>
mov    0x70(%rsp),%r9
lea    (%rdi,%r9,1),%r11
lea    (%r9,%r13,1),%rbp
nopl   0x0(%rax)
mov    (%r8,%rbx,1),%rsi
mov    0x0(%r13,%rbx,1),%rax
mov    %rax,(%r8,%rbx,1)
mov    %rsi,0x0(%r13,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r9
jne    1d40 <heap_heapify+0xc10>
mov    0x68(%rsp),%r8
cmp    %rdx,%r9
jne    1e2c <heap_heapify+0xcfc>
jmp    1ed7 <heap_heapify+0xda7>
mov    0x20(%rsp),%rax
lea    (%rax,%r13,1),%rcx
lea    (%r11,%rax,1),%r15
mov    0x48(%rsp),%r8
lea    -0x1(%r8),%r9
mov    %r8,%rsi
and    $0x3,%rsi
je     1db2 <heap_heapify+0xc82>
xor    %edi,%edi
nop
movzbl (%r15,%rdi,1),%ebx
movzbl (%rcx,%rdi,1),%eax
mov    %al,(%r15,%rdi,1)
mov    %bl,(%rcx,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1d90 <heap_heapify+0xc60>
add    %rdi,%r15
add    %rdi,%rcx
sub    %rdi,%r8
cmp    $0x3,%r9
jb     1980 <heap_heapify+0x850>
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%r15,%rsi,1),%eax
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%r15,%rsi,1)
mov    %al,(%rcx,%rsi,1)
movzbl 0x1(%r15,%rsi,1),%eax
movzbl 0x1(%rcx,%rsi,1),%ebx
mov    %bl,0x1(%r15,%rsi,1)
mov    %al,0x1(%rcx,%rsi,1)
movzbl 0x2(%r15,%rsi,1),%eax
movzbl 0x2(%rcx,%rsi,1),%ebx
mov    %bl,0x2(%r15,%rsi,1)
mov    %al,0x2(%rcx,%rsi,1)
movzbl 0x3(%r15,%rsi,1),%eax
movzbl 0x3(%rcx,%rsi,1),%ebx
mov    %bl,0x3(%r15,%rsi,1)
mov    %al,0x3(%rcx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1dc0 <heap_heapify+0xc90>
jmp    1980 <heap_heapify+0x850>
mov    0x20(%rsp),%rax
lea    (%rax,%r13,1),%rbp
lea    (%rdi,%rax,1),%r11
mov    0x48(%rsp),%r8
lea    -0x1(%r8),%r9
mov    %r8,%r10
and    $0x3,%r10
je     1e64 <heap_heapify+0xd34>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%r11,%rsi,1),%ebx
movzbl 0x0(%rbp,%rsi,1),%eax
mov    %al,(%r11,%rsi,1)
mov    %bl,0x0(%rbp,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1e40 <heap_heapify+0xd10>
add    %rsi,%r11
add    %rsi,%rbp
sub    %rsi,%r8
mov    0x18(%rsp),%rcx
cmp    $0x3,%r9
jb     1ed7 <heap_heapify+0xda7>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r11,%rsi,1),%eax
movzbl 0x0(%rbp,%rsi,1),%ebx
mov    %bl,(%r11,%rsi,1)
mov    %al,0x0(%rbp,%rsi,1)
movzbl 0x1(%r11,%rsi,1),%eax
movzbl 0x1(%rbp,%rsi,1),%ebx
mov    %bl,0x1(%r11,%rsi,1)
mov    %al,0x1(%rbp,%rsi,1)
movzbl 0x2(%r11,%rsi,1),%eax
movzbl 0x2(%rbp,%rsi,1),%ebx
mov    %bl,0x2(%r11,%rsi,1)
mov    %al,0x2(%rbp,%rsi,1)
movzbl 0x3(%r11,%rsi,1),%eax
movzbl 0x3(%rbp,%rsi,1),%ebx
mov    %bl,0x3(%r11,%rsi,1)
mov    %al,0x3(%rbp,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    1e80 <heap_heapify+0xd50>
mov    %r13d,%r8d
sub    %edi,%r8d
add    %r8d,%r8d
mov    0x8(%rsp),%rsi
jmp    199a <heap_heapify+0x86a>
mov    0x8(%rsp),%rdi
mov    0xa0(%rsp),%rsi
mov    %r9,%rdx
mov    %r14,%rcx
call   1030 <heap_isheap@plt>
mov    %eax,%edi
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <assert@plt>

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

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