#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 */
char *med3(char *, char *, char *, int (*)(void const *, void const *));
int /*<<< orphan*/ swapfunc(char *, char *, size_t, int);
void _pqsort(void *a, size_t n, size_t es,
             int (*cmp)(const void *, const void *), void *lrange,
             void *rrange) {
  char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
  size_t d, r;
  int swaptype, swap_cnt, cmp_result;
loop:
  swaptype = ((char *)a - (char *)0) % sizeof(long) || es % sizeof(long) ? 2
             : es == sizeof(long)                                        ? 0
                                                                         : 1;
  ;
  swap_cnt = 0;
  if (n < 7) {
    for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
      for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0; pl -= es)
        if (swaptype == 0) {
          long t = *(long *)(void *)(pl);
          *(long *)(void *)(pl) = *(long *)(void *)(pl - es);
          *(long *)(void *)(pl - es) = t;
        } else
          swapfunc(pl, pl - es, es, swaptype);
    return;
  }
  pm = (char *)a + (n / 2) * es;
  if (n > 7) {
    pl = (char *)a;
    pn = (char *)a + (n - 1) * es;
    if (n > 40) {
      d = (n / 8) * es;
      pl = med3(pl, pl + d, pl + 2 * d, cmp);
      pm = med3(pm - d, pm, pm + d, cmp);
      pn = med3(pn - 2 * d, pn - d, pn, cmp);
    }
    pm = med3(pl, pm, pn, cmp);
  }
  if (swaptype == 0) {
    long t = *(long *)(void *)(a);
    *(long *)(void *)(a) = *(long *)(void *)(pm);
    *(long *)(void *)(pm) = t;
  } else
    swapfunc(a, pm, es, swaptype);
  pa = pb = (char *)a + es;
  pc = pd = (char *)a + (n - 1) * es;
  for (;;) {
    while (pb <= pc && (cmp_result = cmp(pb, a)) <= 0) {
      if (cmp_result == 0) {
        swap_cnt = 1;
        if (swaptype == 0) {
          long t = *(long *)(void *)(pa);
          *(long *)(void *)(pa) = *(long *)(void *)(pb);
          *(long *)(void *)(pb) = t;
        } else
          swapfunc(pa, pb, es, swaptype);
        pa += es;
      }
      pb += es;
    }
    while (pb <= pc && (cmp_result = cmp(pc, a)) >= 0) {
      if (cmp_result == 0) {
        swap_cnt = 1;
        if (swaptype == 0) {
          long t = *(long *)(void *)(pc);
          *(long *)(void *)(pc) = *(long *)(void *)(pd);
          *(long *)(void *)(pd) = t;
        } else
          swapfunc(pc, pd, es, swaptype);
        pd -= es;
      }
      pc -= es;
    }
    if (pb > pc)
      break;
    if (swaptype == 0) {
      long t = *(long *)(void *)(pb);
      *(long *)(void *)(pb) = *(long *)(void *)(pc);
      *(long *)(void *)(pc) = t;
    } else
      swapfunc(pb, pc, es, swaptype);
    swap_cnt = 1;
    pb += es;
    pc -= es;
  }
  if (swap_cnt == 0) {
    for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
      for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0; pl -= es)
        if (swaptype == 0) {
          long t = *(long *)(void *)(pl);
          *(long *)(void *)(pl) = *(long *)(void *)(pl - es);
          *(long *)(void *)(pl - es) = t;
        } else
          swapfunc(pl, pl - es, es, swaptype);
    return;
  }
  pn = (char *)a + n * es;
  r = (pa - (char *)a) < (pb - pa) ? pa - (char *)a : pb - pa;
  if ((r) > 0)
    swapfunc((a), (pb - r), (size_t)(r), swaptype);
  r = ((size_t)(pd - pc)) < (pn - pd - es) ? (size_t)(pd - pc) : pn - pd - es;
  if ((r) > 0)
    swapfunc((pb), (pn - r), (size_t)(r), swaptype);
  if ((r = pb - pa) > es) {
    void *_l = a, *_r = ((unsigned char *)a) + r - 1;
    if (!((lrange < _l && rrange < _l) || (lrange > _r && rrange > _r)))
      _pqsort(a, r / es, es, cmp, lrange, rrange);
  }
  if ((r = pd - pc) > es) {
    void *_l, *_r;
    a = pn - r;
    n = r / es;
    _l = a;
    _r = ((unsigned char *)a) + r - 1;
    if (!((lrange < _l && rrange < _l) || (lrange > _r && rrange > _r)))
      goto loop;
  }
}


x86 assembly (clang, -O0):
<_pqsort>:
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    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
sub    $0x0,%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    117b <_pqsort+0x4b>
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
je     118b <_pqsort+0x5b>
mov    $0x2,%eax
mov    %eax,-0xdc(%rbp)
jmp    11a3 <_pqsort+0x73>
mov    -0x18(%rbp),%rdx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x8,%rdx
cmove  %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
cmpq   $0x7,-0x10(%rbp)
jae    12d8 <_pqsort+0x1a8>
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    12d3 <_pqsort+0x1a3>
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0xdd(%rbp)
jbe    1228 <_pqsort+0xf8>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rdi
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rdi
mov    -0x58(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
setg   %al
mov    %al,-0xdd(%rbp)
mov    -0xdd(%rbp),%al
test   $0x1,%al
jne    123b <_pqsort+0x10b>
jmp    12bd <_pqsort+0x18d>
cmpl   $0x0,-0x7c(%rbp)
jne    1282 <_pqsort+0x152>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%rcx
mov    -0x58(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x90(%rbp),%rdx
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,1)
jmp    129f <_pqsort+0x16f>
mov    -0x58(%rbp),%rdi
mov    -0x58(%rbp),%rsi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
jmp    12a4 <_pqsort+0x174>
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    11ef <_pqsort+0xbf>
jmp    12c2 <_pqsort+0x192>
mov    -0x18(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    11ca <_pqsort+0x9a>
jmp    1a01 <_pqsort+0x8d1>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shr    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x7,-0x10(%rbp)
jbe    13d0 <_pqsort+0x2a0>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x28,-0x10(%rbp)
jbe    13b7 <_pqsort+0x287>
mov    -0x10(%rbp),%rax
shr    $0x3,%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x58(%rbp),%rsi
add    -0x70(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x70(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rcx
call   1050 <med3@plt>
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdi
xor    %eax,%eax
sub    -0x70(%rbp),%rax
add    %rax,%rdi
mov    -0x60(%rbp),%rsi
mov    -0x60(%rbp),%rdx
add    -0x70(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1050 <med3@plt>
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x70(%rbp),%rcx
shl    $0x1,%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%rsi
xor    %eax,%eax
sub    -0x70(%rbp),%rax
add    %rax,%rsi
mov    -0x68(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1050 <med3@plt>
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x68(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1050 <med3@plt>
mov    %rax,-0x60(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    1409 <_pqsort+0x2d9>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x98(%rbp),%rcx
mov    -0x60(%rbp),%rax
mov    %rcx,(%rax)
jmp    141d <_pqsort+0x2ed>
mov    -0x8(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x48(%rbp)
jmp    144e <_pqsort+0x31e>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0xde(%rbp)
ja     1484 <_pqsort+0x354>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   *%rax
mov    %eax,-0x84(%rbp)
cmp    $0x0,%eax
setle  %al
mov    %al,-0xde(%rbp)
mov    -0xde(%rbp),%al
test   $0x1,%al
jne    1497 <_pqsort+0x367>
jmp    1515 <_pqsort+0x3e5>
cmpl   $0x0,-0x84(%rbp)
jne    1504 <_pqsort+0x3d4>
movl   $0x1,-0x80(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    14e4 <_pqsort+0x3b4>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xa0(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    %rcx,(%rax)
jmp    14f8 <_pqsort+0x3c8>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x18(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    144e <_pqsort+0x31e>
jmp    151a <_pqsort+0x3ea>
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x48(%rbp),%rcx
mov    %al,-0xdf(%rbp)
ja     1550 <_pqsort+0x420>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   *%rax
mov    %eax,-0x84(%rbp)
cmp    $0x0,%eax
setge  %al
mov    %al,-0xdf(%rbp)
mov    -0xdf(%rbp),%al
test   $0x1,%al
jne    1563 <_pqsort+0x433>
jmp    15f1 <_pqsort+0x4c1>
cmpl   $0x0,-0x84(%rbp)
jne    15d8 <_pqsort+0x4a8>
movl   $0x1,-0x80(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    15b0 <_pqsort+0x480>
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xa8(%rbp),%rcx
mov    -0x50(%rbp),%rax
mov    %rcx,(%rax)
jmp    15c4 <_pqsort+0x494>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x18(%rbp),%rdx
mov    -0x50(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    151a <_pqsort+0x3ea>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jbe    1604 <_pqsort+0x4d4>
jmp    167d <_pqsort+0x54d>
cmpl   $0x0,-0x7c(%rbp)
jne    163d <_pqsort+0x50d>
mov    -0x40(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x40(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xb0(%rbp),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
jmp    1651 <_pqsort+0x521>
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
movl   $0x1,-0x80(%rbp)
mov    -0x18(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1449 <_pqsort+0x319>
cmpl   $0x0,-0x80(%rbp)
jne    17a1 <_pqsort+0x671>
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    179c <_pqsort+0x66c>
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0xe0(%rbp)
jbe    16f1 <_pqsort+0x5c1>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rdi
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rdi
mov    -0x58(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
setg   %al
mov    %al,-0xe0(%rbp)
mov    -0xe0(%rbp),%al
test   $0x1,%al
jne    1704 <_pqsort+0x5d4>
jmp    1786 <_pqsort+0x656>
cmpl   $0x0,-0x7c(%rbp)
jne    174b <_pqsort+0x61b>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%rcx
mov    -0x58(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xb8(%rbp),%rdx
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,1)
jmp    1768 <_pqsort+0x638>
mov    -0x58(%rbp),%rdi
mov    -0x58(%rbp),%rsi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
jmp    176d <_pqsort+0x63d>
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    16b8 <_pqsort+0x588>
jmp    178b <_pqsort+0x65b>
mov    -0x18(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1693 <_pqsort+0x563>
jmp    1a01 <_pqsort+0x8d1>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jge    17eb <_pqsort+0x6bb>
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xe8(%rbp)
jmp    17fd <_pqsort+0x6cd>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
jbe    1830 <_pqsort+0x700>
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rsi
xor    %eax,%eax
sub    -0x78(%rbp),%rax
add    %rax,%rsi
mov    -0x78(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    -0x68(%rbp),%rcx
mov    -0x50(%rbp),%rdx
sub    %rdx,%rcx
sub    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    186a <_pqsort+0x73a>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xf0(%rbp)
jmp    1880 <_pqsort+0x750>
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    %rcx,%rax
sub    -0x18(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
jbe    18b3 <_pqsort+0x783>
mov    -0x40(%rbp),%rdi
mov    -0x68(%rbp),%rsi
xor    %eax,%eax
sub    -0x78(%rbp),%rax
add    %rax,%rsi
mov    -0x78(%rbp),%rdx
mov    -0x7c(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x78(%rbp)
cmp    -0x18(%rbp),%rax
jbe    195b <_pqsort+0x82b>
mov    -0x8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
add    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0xc0(%rbp),%rax
jae    190c <_pqsort+0x7dc>
mov    -0x30(%rbp),%rax
cmp    -0xc0(%rbp),%rax
jb     1956 <_pqsort+0x826>
mov    -0x28(%rbp),%rax
cmp    -0xc8(%rbp),%rax
jbe    192e <_pqsort+0x7fe>
mov    -0x30(%rbp),%rax
cmp    -0xc8(%rbp),%rax
ja     1956 <_pqsort+0x826>
mov    -0x8(%rbp),%rdi
mov    -0x78(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
mov    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
call   1040 <_pqsort@plt>
jmp    195b <_pqsort+0x82b>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x78(%rbp)
cmp    -0x18(%rbp),%rax
jbe    1a01 <_pqsort+0x8d1>
mov    -0x68(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x78(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x8(%rbp),%rax
add    -0x78(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0xd0(%rbp),%rax
jae    19d5 <_pqsort+0x8a5>
mov    -0x30(%rbp),%rax
cmp    -0xd0(%rbp),%rax
jb     19fc <_pqsort+0x8cc>
mov    -0x28(%rbp),%rax
cmp    -0xd8(%rbp),%rax
jbe    19f7 <_pqsort+0x8c7>
mov    -0x30(%rbp),%rax
cmp    -0xd8(%rbp),%rax
ja     19fc <_pqsort+0x8cc>
jmp    1153 <_pqsort+0x23>
jmp    1a01 <_pqsort+0x8d1>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_pqsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x20(%rsp)
mov    %r8,%r14
mov    %rcx,0x18(%rsp)
mov    %rsi,%r13
mov    %rdi,%rbx
mov    %rdx,%rax
neg    %rax
mov    %rax,0x30(%rsp)
xor    %ecx,%ecx
mov    %rdx,%rax
mov    %rdx,(%rsp)
cmp    $0x8,%rdx
setne  %cl
mov    %ecx,0x3c(%rsp)
mov    %r8,0x40(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%eax
mov    (%rsp),%rdx
or     %edx,%eax
test   $0x7,%al
mov    $0x2,%ecx
cmove  0x3c(%rsp),%ecx
cmp    $0x6,%r13
mov    %rbx,%r15
mov    %ecx,0xc(%rsp)
jbe    1545 <_pqsort+0x415>
mov    %r13,%rbp
shr    %rbp
imul   %rdx,%rbp
add    %rbx,%rbp
cmp    $0x7,%r13
mov    %r13,0x10(%rsp)
je     126d <_pqsort+0x13d>
lea    -0x1(%r13),%r14
imul   %rdx,%r14
add    %rbx,%r14
cmp    $0x29,%r13
jb     1250 <_pqsort+0x120>
mov    %r13,%rbx
shr    $0x3,%rbx
imul   %rdx,%rbx
lea    (%r15,%rbx,1),%rsi
lea    (%rbx,%rbx,1),%r13
lea    (%r15,%rbx,2),%rdx
mov    %r15,%rdi
mov    0x18(%rsp),%rcx
call   1050 <med3@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,%rdi
sub    %rbx,%rdi
lea    (%rbx,%rbp,1),%rdx
mov    %rbp,%rsi
mov    0x18(%rsp),%rcx
call   1050 <med3@plt>
mov    %rax,%rbp
mov    %r14,%rdi
sub    %r13,%rdi
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%r12
mov    %r14,%rsi
sub    %rbx,%rsi
mov    %r15,%rbx
mov    %r14,%rdx
mov    %r12,%rcx
call   1050 <med3@plt>
mov    0x28(%rsp),%rdi
mov    %rax,%r14
jmp    1258 <_pqsort+0x128>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rdi
mov    0x18(%rsp),%r12
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
call   1050 <med3@plt>
mov    %rax,%rbp
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
je     1290 <_pqsort+0x160>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    (%rsp),%rbp
mov    %rbp,%rdx
call   1030 <swapfunc@plt>
jmp    12a2 <_pqsort+0x172>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,(%rbx)
mov    %rax,0x0(%rbp)
mov    (%rsp),%rbp
lea    (%rbx,%rbp,1),%rax
lea    -0x1(%r13),%r14
imul   %rbp,%r14
add    %rbx,%r14
xor    %ebx,%ebx
mov    %r14,%r12
mov    %rax,%r13
mov    %rax,0x28(%rsp)
mov    %rax,%rbp
jmp    12d7 <_pqsort+0x1a7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rax
add    %rax,%r13
cmp    %r12,%r13
ja     1318 <_pqsort+0x1e8>
mov    %r13,%rdi
mov    %r15,%rsi
call   *0x18(%rsp)
test   %eax,%eax
jg     1318 <_pqsort+0x1e8>
jne    12d0 <_pqsort+0x1a0>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
je     136f <_pqsort+0x23f>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    (%rsp),%rbx
mov    %rbx,%rdx
call   1030 <swapfunc@plt>
jmp    1383 <_pqsort+0x253>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
add    %rax,%r12
cmp    %r12,%r13
ja     13e0 <_pqsort+0x2b0>
mov    %r12,%rdi
mov    %r15,%rsi
call   *0x18(%rsp)
test   %eax,%eax
js     1396 <_pqsort+0x266>
jne    1310 <_pqsort+0x1e0>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
je     134a <_pqsort+0x21a>
mov    %r12,%rdi
mov    %r14,%rsi
mov    (%rsp),%rdx
call   1030 <swapfunc@plt>
jmp    1358 <_pqsort+0x228>
mov    (%r12),%rax
mov    (%r14),%rcx
mov    %rcx,(%r12)
mov    %rax,(%r14)
mov    0x30(%rsp),%rax
add    %rax,%r14
mov    $0x1,%ebx
add    %rax,%r12
cmp    %r12,%r13
jbe    1321 <_pqsort+0x1f1>
jmp    13e0 <_pqsort+0x2b0>
mov    0x0(%rbp),%rax
mov    0x0(%r13),%rcx
mov    %rcx,0x0(%rbp)
mov    %rax,0x0(%r13)
mov    (%rsp),%rbx
add    %rbx,%rbp
mov    %rbx,%rax
mov    $0x1,%ebx
add    %rax,%r13
jmp    12d7 <_pqsort+0x1a7>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
je     13b2 <_pqsort+0x282>
mov    %r13,%rdi
mov    %r12,%rsi
mov    (%rsp),%rbx
mov    %rbx,%rdx
call   1030 <swapfunc@plt>
jmp    13c6 <_pqsort+0x296>
mov    0x0(%r13),%rax
mov    (%r12),%rcx
mov    %rcx,0x0(%r13)
mov    %rax,(%r12)
mov    (%rsp),%rbx
add    %rbx,%r13
add    0x30(%rsp),%r12
mov    $0x1,%ebx
jmp    12d7 <_pqsort+0x1a7>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
imul   (%rsp),%rcx
mov    %r15,%rax
lea    (%r15,%rcx,1),%rdx
mov    %rdx,0x10(%rsp)
test   %ebx,%ebx
je     15f6 <_pqsort+0x4c6>
mov    %r13,%rbx
sub    %rbp,%rbx
sub    %rax,%rbp
cmp    %rbx,%rbp
cmovge %rbx,%rbp
test   %rbp,%rbp
mov    %rax,%r15
je     142b <_pqsort+0x2fb>
mov    %r13,%rsi
sub    %rbp,%rsi
mov    %r15,%rdi
mov    %rbp,%rdx
mov    0xc(%rsp),%ecx
call   1030 <swapfunc@plt>
mov    %r14,%rbp
sub    %r12,%rbp
add    (%rsp),%r14
mov    0x10(%rsp),%rsi
mov    %rsi,%rdx
sub    %r14,%rdx
cmp    %rdx,%rbp
cmovb  %rbp,%rdx
test   %rdx,%rdx
mov    0x40(%rsp),%r14
mov    0xc(%rsp),%ecx
je     1460 <_pqsort+0x330>
sub    %rdx,%rsi
mov    %r13,%rdi
call   1030 <swapfunc@plt>
mov    %rbx,%rcx
cmp    (%rsp),%rbx
mov    0x18(%rsp),%rbx
jbe    14d0 <_pqsort+0x3a0>
cmp    %r14,%r15
jbe    147a <_pqsort+0x34a>
cmp    0x20(%rsp),%r15
ja     14d0 <_pqsort+0x3a0>
lea    (%r15,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
cmp    %r14,%rax
jae    148e <_pqsort+0x35e>
cmp    0x20(%rsp),%rax
jb     14d0 <_pqsort+0x3a0>
mov    %rcx,%rax
mov    %rcx,%rdx
mov    (%rsp),%rcx
or     %rcx,%rdx
shr    $0x20,%rdx
je     14ab <_pqsort+0x37b>
xor    %edx,%edx
div    %rcx
mov    %rax,%rsi
jmp    14b1 <_pqsort+0x381>
xor    %edx,%edx
div    %ecx
mov    %eax,%esi
mov    %r15,%rdi
mov    %rcx,%rdx
mov    %rbx,%rcx
mov    %r14,%r8
mov    0x20(%rsp),%r9
call   1040 <_pqsort@plt>
nopw   0x0(%rax,%rax,1)
cmp    (%rsp),%rbp
jbe    16a2 <_pqsort+0x572>
mov    0x10(%rsp),%rbx
sub    %rbp,%rbx
cmp    %r14,%rbx
jbe    14f2 <_pqsort+0x3c2>
cmp    0x20(%rsp),%rbx
ja     16a2 <_pqsort+0x572>
mov    0x10(%rsp),%rsi
add    $0xffffffffffffffff,%rsi
mov    %rbp,%rax
mov    (%rsp),%rcx
or     %rcx,%rax
shr    $0x20,%rax
je     1520 <_pqsort+0x3f0>
mov    %rbp,%rax
xor    %edx,%edx
div    %rcx
mov    %rax,%r13
cmp    %r14,%rsi
jb     1532 <_pqsort+0x402>
jmp    1180 <_pqsort+0x50>
mov    %ebp,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%r13d
cmp    %r14,%rsi
jae    1180 <_pqsort+0x50>
mov    %rsi,%rax
cmp    0x20(%rsp),%rsi
jae    1180 <_pqsort+0x50>
jmp    16a2 <_pqsort+0x572>
imul   %rdx,%r13
cmp    %rdx,%r13
jle    16a2 <_pqsort+0x572>
add    %rbx,%r13
mov    (%rsp),%rax
lea    (%rbx,%rax,1),%r14
mov    %rbx,%r12
mov    %r13,0x10(%rsp)
jmp    1587 <_pqsort+0x457>
nopw   0x0(%rax,%rax,1)
add    %r13,%r14
add    %r13,%r12
mov    0x10(%rsp),%r13
cmp    %r13,%r14
mov    %r15,%rbx
jae    16a2 <_pqsort+0x572>
cmp    %rbx,%r14
mov    (%rsp),%r13
jbe    1570 <_pqsort+0x440>
mov    %r12,%rbp
jmp    15c2 <_pqsort+0x492>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    (%rsp),%r13
mov    %r13,%rdx
call   1030 <swapfunc@plt>
add    0x30(%rsp),%rbp
mov    %rbp,%rax
add    %r13,%rax
cmp    %r15,%rax
jbe    1570 <_pqsort+0x440>
mov    %rbp,%rbx
add    %r13,%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *0x18(%rsp)
test   %eax,%eax
jle    1570 <_pqsort+0x440>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    15a0 <_pqsort+0x470>
mov    (%rsp),%r13
mov    0x0(%rbp,%r13,1),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,0x0(%rbp,%r13,1)
mov    %rax,0x0(%rbp)
jmp    15b2 <_pqsort+0x482>
cmp    (%rsp),%rcx
mov    0x18(%rsp),%r12
mov    0x28(%rsp),%rcx
jle    16a2 <_pqsort+0x572>
mov    %rax,0x20(%rsp)
mov    0x30(%rsp),%r13
jmp    1637 <_pqsort+0x507>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    %r14,%rcx
add    %r14,0x20(%rsp)
cmp    0x10(%rsp),%rcx
mov    %r15,%rax
jae    16a2 <_pqsort+0x572>
mov    %rcx,0x28(%rsp)
cmp    %rax,%rcx
mov    (%rsp),%r14
jbe    1620 <_pqsort+0x4f0>
mov    0x20(%rsp),%rbp
jmp    1671 <_pqsort+0x541>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    (%rsp),%r14
mov    %r14,%rdx
call   1030 <swapfunc@plt>
mov    %r15,%rcx
add    %r13,%rbp
lea    (%r14,%rbp,1),%rax
cmp    %r15,%rax
jbe    1620 <_pqsort+0x4f0>
lea    (%r14,%rbp,1),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *%r12
test   %eax,%eax
jle    1620 <_pqsort+0x4f0>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jne    1650 <_pqsort+0x520>
mov    (%rsp),%r14
mov    0x0(%rbp,%r14,1),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,0x0(%rbp,%r14,1)
mov    %rax,0x0(%rbp)
jmp    1662 <_pqsort+0x532>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @_pqsort(i8* %0, i64 %1, i64 %2, i32 (i8*, i8*)* %3, i8* %4, i8* %5) {
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32 (i8*, i8*)*
%11 = alloca i8*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i64
%21 = alloca i64
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i8*
%32 = alloca i8*
%33 = alloca i8*
%34 = alloca i8*
store i8* %0, i8** %7
store i64 %1, i64* %8
store i64 %2, i64* %9
store i32 (i8*, i8*)* %3, i32 (i8*, i8*)** %10
store i8* %4, i8** %11
store i8* %5, i8** %12
br label %35
35: ; preds = %577, %6
%36 = load i8*, i8** %7
%37 = ptrtoint i8* %36 to i64
%38 = sub i64 %37, 0
%39 = urem i64 %38, 8
%40 = icmp ne i64 %39, 0
br i1 %40, label %45, label %41
41: ; preds = %35
%42 = load i64, i64* %9
%43 = urem i64 %42, 8
%44 = icmp ne i64 %43, 0
br i1 %44, label %45, label %46
45: ; preds = %41, %35
br label %51
46: ; preds = %41
%47 = load i64, i64* %9
%48 = icmp eq i64 %47, 8
%49 = zext i1 %48 to i64
%50 = select i1 %48, i32 0, i32 1
br label %51
51: ; preds = %46, %45
%52 = phi i32 [ 2, %45 ], [ %50, %46 ]
store i32 %52, i32* %22
store i32 0, i32* %23
%53 = load i64, i64* %8
%54 = icmp ult i64 %53, 7
br i1 %54, label %55, label %126
55: ; preds = %51
%56 = load i8*, i8** %7
%57 = load i64, i64* %9
%58 = getelementptr inbounds i8, i8* %56, i64 %57
store i8* %58, i8** %18
br label %59
59: ; preds = %121, %55
%60 = load i8*, i8** %18
%61 = load i8*, i8** %7
%62 = load i64, i64* %8
%63 = load i64, i64* %9
%64 = mul i64 %62, %63
%65 = getelementptr inbounds i8, i8* %61, i64 %64
%66 = icmp ult i8* %60, %65
br i1 %66, label %67, label %125
67: ; preds = %59
%68 = load i8*, i8** %18
store i8* %68, i8** %17
br label %69
69: ; preds = %115, %67
%70 = load i8*, i8** %17
%71 = load i8*, i8** %7
%72 = icmp ugt i8* %70, %71
br i1 %72, label %73, label %82
73: ; preds = %69
%74 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%75 = load i8*, i8** %17
%76 = load i64, i64* %9
%77 = sub i64 0, %76
%78 = getelementptr inbounds i8, i8* %75, i64 %77
%79 = load i8*, i8** %17
%80 = call i32 %74(i8* %78, i8* %79)
%81 = icmp sgt i32 %80, 0
br label %82
82: ; preds = %73, %69
%83 = phi i1 [ false, %69 ], [ %81, %73 ]
br i1 %83, label %84, label %120
84: ; preds = %82
%85 = load i32, i32* %22
%86 = icmp eq i32 %85, 0
br i1 %86, label %87, label %105
87: ; preds = %84
%88 = load i8*, i8** %17
%89 = bitcast i8* %88 to i64*
%90 = load i64, i64* %89
store i64 %90, i64* %25
%91 = load i8*, i8** %17
%92 = load i64, i64* %9
%93 = sub i64 0, %92
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = bitcast i8* %94 to i64*
%96 = load i64, i64* %95
%97 = load i8*, i8** %17
%98 = bitcast i8* %97 to i64*
store i64 %96, i64* %98
%99 = load i64, i64* %25
%100 = load i8*, i8** %17
%101 = load i64, i64* %9
%102 = sub i64 0, %101
%103 = getelementptr inbounds i8, i8* %100, i64 %102
%104 = bitcast i8* %103 to i64*
store i64 %99, i64* %104
br label %114
105: ; preds = %84
%106 = load i8*, i8** %17
%107 = load i8*, i8** %17
%108 = load i64, i64* %9
%109 = sub i64 0, %108
%110 = getelementptr inbounds i8, i8* %107, i64 %109
%111 = load i64, i64* %9
%112 = load i32, i32* %22
%113 = call i32 @swapfunc(i8* %106, i8* %110, i64 %111, i32 %112)
br label %114
114: ; preds = %105, %87
br label %115
115: ; preds = %114
%116 = load i64, i64* %9
%117 = load i8*, i8** %17
%118 = sub i64 0, %116
%119 = getelementptr inbounds i8, i8* %117, i64 %118
store i8* %119, i8** %17
br label %69
120: ; preds = %82
br label %121
121: ; preds = %120
%122 = load i64, i64* %9
%123 = load i8*, i8** %18
%124 = getelementptr inbounds i8, i8* %123, i64 %122
store i8* %124, i8** %18
br label %59
125: ; preds = %59
br label %579
126: ; preds = %51
%127 = load i8*, i8** %7
%128 = load i64, i64* %8
%129 = udiv i64 %128, 2
%130 = load i64, i64* %9
%131 = mul i64 %129, %130
%132 = getelementptr inbounds i8, i8* %127, i64 %131
store i8* %132, i8** %18
%133 = load i64, i64* %8
%134 = icmp ugt i64 %133, 7
br i1 %134, label %135, label %188
135: ; preds = %126
%136 = load i8*, i8** %7
store i8* %136, i8** %17
%137 = load i8*, i8** %7
%138 = load i64, i64* %8
%139 = sub i64 %138, 1
%140 = load i64, i64* %9
%141 = mul i64 %139, %140
%142 = getelementptr inbounds i8, i8* %137, i64 %141
store i8* %142, i8** %19
%143 = load i64, i64* %8
%144 = icmp ugt i64 %143, 40
br i1 %144, label %145, label %182
145: ; preds = %135
%146 = load i64, i64* %8
%147 = udiv i64 %146, 8
%148 = load i64, i64* %9
%149 = mul i64 %147, %148
store i64 %149, i64* %20
%150 = load i8*, i8** %17
%151 = load i8*, i8** %17
%152 = load i64, i64* %20
%153 = getelementptr inbounds i8, i8* %151, i64 %152
%154 = load i8*, i8** %17
%155 = load i64, i64* %20
%156 = mul i64 2, %155
%157 = getelementptr inbounds i8, i8* %154, i64 %156
%158 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%159 = call i8* @med3(i8* %150, i8* %153, i8* %157, i32 (i8*, i8*)* %158)
store i8* %159, i8** %17
%160 = load i8*, i8** %18
%161 = load i64, i64* %20
%162 = sub i64 0, %161
%163 = getelementptr inbounds i8, i8* %160, i64 %162
%164 = load i8*, i8** %18
%165 = load i8*, i8** %18
%166 = load i64, i64* %20
%167 = getelementptr inbounds i8, i8* %165, i64 %166
%168 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%169 = call i8* @med3(i8* %163, i8* %164, i8* %167, i32 (i8*, i8*)* %168)
store i8* %169, i8** %18
%170 = load i8*, i8** %19
%171 = load i64, i64* %20
%172 = mul i64 2, %171
%173 = sub i64 0, %172
%174 = getelementptr inbounds i8, i8* %170, i64 %173
%175 = load i8*, i8** %19
%176 = load i64, i64* %20
%177 = sub i64 0, %176
%178 = getelementptr inbounds i8, i8* %175, i64 %177
%179 = load i8*, i8** %19
%180 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%181 = call i8* @med3(i8* %174, i8* %178, i8* %179, i32 (i8*, i8*)* %180)
store i8* %181, i8** %19
br label %182
182: ; preds = %145, %135
%183 = load i8*, i8** %17
%184 = load i8*, i8** %18
%185 = load i8*, i8** %19
%186 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%187 = call i8* @med3(i8* %183, i8* %184, i8* %185, i32 (i8*, i8*)* %186)
store i8* %187, i8** %18
br label %188
188: ; preds = %182, %126
%189 = load i32, i32* %22
%190 = icmp eq i32 %189, 0
br i1 %190, label %191, label %203
191: ; preds = %188
%192 = load i8*, i8** %7
%193 = bitcast i8* %192 to i64*
%194 = load i64, i64* %193
store i64 %194, i64* %26
%195 = load i8*, i8** %18
%196 = bitcast i8* %195 to i64*
%197 = load i64, i64* %196
%198 = load i8*, i8** %7
%199 = bitcast i8* %198 to i64*
store i64 %197, i64* %199
%200 = load i64, i64* %26
%201 = load i8*, i8** %18
%202 = bitcast i8* %201 to i64*
store i64 %200, i64* %202
br label %209
203: ; preds = %188
%204 = load i8*, i8** %7
%205 = load i8*, i8** %18
%206 = load i64, i64* %9
%207 = load i32, i32* %22
%208 = call i32 @swapfunc(i8* %204, i8* %205, i64 %206, i32 %207)
br label %209
209: ; preds = %203, %191
%210 = load i8*, i8** %7
%211 = load i64, i64* %9
%212 = getelementptr inbounds i8, i8* %210, i64 %211
store i8* %212, i8** %14
store i8* %212, i8** %13
%213 = load i8*, i8** %7
%214 = load i64, i64* %8
%215 = sub i64 %214, 1
%216 = load i64, i64* %9
%217 = mul i64 %215, %216
%218 = getelementptr inbounds i8, i8* %213, i64 %217
store i8* %218, i8** %16
store i8* %218, i8** %15
br label %219
219: ; preds = %337, %209
br label %220
220: ; preds = %260, %219
%221 = load i8*, i8** %14
%222 = load i8*, i8** %15
%223 = icmp ule i8* %221, %222
br i1 %223, label %224, label %230
224: ; preds = %220
%225 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%226 = load i8*, i8** %14
%227 = load i8*, i8** %7
%228 = call i32 %225(i8* %226, i8* %227)
store i32 %228, i32* %24
%229 = icmp sle i32 %228, 0
br label %230
230: ; preds = %224, %220
%231 = phi i1 [ false, %220 ], [ %229, %224 ]
br i1 %231, label %232, label %264
232: ; preds = %230
%233 = load i32, i32* %24
%234 = icmp eq i32 %233, 0
br i1 %234, label %235, label %260
235: ; preds = %232
store i32 1, i32* %23
%236 = load i32, i32* %22
%237 = icmp eq i32 %236, 0
br i1 %237, label %238, label %250
238: ; preds = %235
%239 = load i8*, i8** %13
%240 = bitcast i8* %239 to i64*
%241 = load i64, i64* %240
store i64 %241, i64* %27
%242 = load i8*, i8** %14
%243 = bitcast i8* %242 to i64*
%244 = load i64, i64* %243
%245 = load i8*, i8** %13
%246 = bitcast i8* %245 to i64*
store i64 %244, i64* %246
%247 = load i64, i64* %27
%248 = load i8*, i8** %14
%249 = bitcast i8* %248 to i64*
store i64 %247, i64* %249
br label %256
250: ; preds = %235
%251 = load i8*, i8** %13
%252 = load i8*, i8** %14
%253 = load i64, i64* %9
%254 = load i32, i32* %22
%255 = call i32 @swapfunc(i8* %251, i8* %252, i64 %253, i32 %254)
br label %256
256: ; preds = %250, %238
%257 = load i64, i64* %9
%258 = load i8*, i8** %13
%259 = getelementptr inbounds i8, i8* %258, i64 %257
store i8* %259, i8** %13
br label %260
260: ; preds = %256, %232
%261 = load i64, i64* %9
%262 = load i8*, i8** %14
%263 = getelementptr inbounds i8, i8* %262, i64 %261
store i8* %263, i8** %14
br label %220
264: ; preds = %230
br label %265
265: ; preds = %306, %264
%266 = load i8*, i8** %14
%267 = load i8*, i8** %15
%268 = icmp ule i8* %266, %267
br i1 %268, label %269, label %275
269: ; preds = %265
%270 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%271 = load i8*, i8** %15
%272 = load i8*, i8** %7
%273 = call i32 %270(i8* %271, i8* %272)
store i32 %273, i32* %24
%274 = icmp sge i32 %273, 0
br label %275
275: ; preds = %269, %265
%276 = phi i1 [ false, %265 ], [ %274, %269 ]
br i1 %276, label %277, label %311
277: ; preds = %275
%278 = load i32, i32* %24
%279 = icmp eq i32 %278, 0
br i1 %279, label %280, label %306
280: ; preds = %277
store i32 1, i32* %23
%281 = load i32, i32* %22
%282 = icmp eq i32 %281, 0
br i1 %282, label %283, label %295
283: ; preds = %280
%284 = load i8*, i8** %15
%285 = bitcast i8* %284 to i64*
%286 = load i64, i64* %285
store i64 %286, i64* %28
%287 = load i8*, i8** %16
%288 = bitcast i8* %287 to i64*
%289 = load i64, i64* %288
%290 = load i8*, i8** %15
%291 = bitcast i8* %290 to i64*
store i64 %289, i64* %291
%292 = load i64, i64* %28
%293 = load i8*, i8** %16
%294 = bitcast i8* %293 to i64*
store i64 %292, i64* %294
br label %301
295: ; preds = %280
%296 = load i8*, i8** %15
%297 = load i8*, i8** %16
%298 = load i64, i64* %9
%299 = load i32, i32* %22
%300 = call i32 @swapfunc(i8* %296, i8* %297, i64 %298, i32 %299)
br label %301
301: ; preds = %295, %283
%302 = load i64, i64* %9
%303 = load i8*, i8** %16
%304 = sub i64 0, %302
%305 = getelementptr inbounds i8, i8* %303, i64 %304
store i8* %305, i8** %16
br label %306
306: ; preds = %301, %277
%307 = load i64, i64* %9
%308 = load i8*, i8** %15
%309 = sub i64 0, %307
%310 = getelementptr inbounds i8, i8* %308, i64 %309
store i8* %310, i8** %15
br label %265
311: ; preds = %275
%312 = load i8*, i8** %14
%313 = load i8*, i8** %15
%314 = icmp ugt i8* %312, %313
br i1 %314, label %315, label %316
315: ; preds = %311
br label %345
316: ; preds = %311
%317 = load i32, i32* %22
%318 = icmp eq i32 %317, 0
br i1 %318, label %319, label %331
319: ; preds = %316
%320 = load i8*, i8** %14
%321 = bitcast i8* %320 to i64*
%322 = load i64, i64* %321
store i64 %322, i64* %29
%323 = load i8*, i8** %15
%324 = bitcast i8* %323 to i64*
%325 = load i64, i64* %324
%326 = load i8*, i8** %14
%327 = bitcast i8* %326 to i64*
store i64 %325, i64* %327
%328 = load i64, i64* %29
%329 = load i8*, i8** %15
%330 = bitcast i8* %329 to i64*
store i64 %328, i64* %330
br label %337
331: ; preds = %316
%332 = load i8*, i8** %14
%333 = load i8*, i8** %15
%334 = load i64, i64* %9
%335 = load i32, i32* %22
%336 = call i32 @swapfunc(i8* %332, i8* %333, i64 %334, i32 %335)
br label %337
337: ; preds = %331, %319
store i32 1, i32* %23
%338 = load i64, i64* %9
%339 = load i8*, i8** %14
%340 = getelementptr inbounds i8, i8* %339, i64 %338
store i8* %340, i8** %14
%341 = load i64, i64* %9
%342 = load i8*, i8** %15
%343 = sub i64 0, %341
%344 = getelementptr inbounds i8, i8* %342, i64 %343
store i8* %344, i8** %15
br label %219
345: ; preds = %315
%346 = load i32, i32* %23
%347 = icmp eq i32 %346, 0
br i1 %347, label %348, label %419
348: ; preds = %345
%349 = load i8*, i8** %7
%350 = load i64, i64* %9
%351 = getelementptr inbounds i8, i8* %349, i64 %350
store i8* %351, i8** %18
br label %352
352: ; preds = %414, %348
%353 = load i8*, i8** %18
%354 = load i8*, i8** %7
%355 = load i64, i64* %8
%356 = load i64, i64* %9
%357 = mul i64 %355, %356
%358 = getelementptr inbounds i8, i8* %354, i64 %357
%359 = icmp ult i8* %353, %358
br i1 %359, label %360, label %418
360: ; preds = %352
%361 = load i8*, i8** %18
store i8* %361, i8** %17
br label %362
362: ; preds = %408, %360
%363 = load i8*, i8** %17
%364 = load i8*, i8** %7
%365 = icmp ugt i8* %363, %364
br i1 %365, label %366, label %375
366: ; preds = %362
%367 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%368 = load i8*, i8** %17
%369 = load i64, i64* %9
%370 = sub i64 0, %369
%371 = getelementptr inbounds i8, i8* %368, i64 %370
%372 = load i8*, i8** %17
%373 = call i32 %367(i8* %371, i8* %372)
%374 = icmp sgt i32 %373, 0
br label %375
375: ; preds = %366, %362
%376 = phi i1 [ false, %362 ], [ %374, %366 ]
br i1 %376, label %377, label %413
377: ; preds = %375
%378 = load i32, i32* %22
%379 = icmp eq i32 %378, 0
br i1 %379, label %380, label %398
380: ; preds = %377
%381 = load i8*, i8** %17
%382 = bitcast i8* %381 to i64*
%383 = load i64, i64* %382
store i64 %383, i64* %30
%384 = load i8*, i8** %17
%385 = load i64, i64* %9
%386 = sub i64 0, %385
%387 = getelementptr inbounds i8, i8* %384, i64 %386
%388 = bitcast i8* %387 to i64*
%389 = load i64, i64* %388
%390 = load i8*, i8** %17
%391 = bitcast i8* %390 to i64*
store i64 %389, i64* %391
%392 = load i64, i64* %30
%393 = load i8*, i8** %17
%394 = load i64, i64* %9
%395 = sub i64 0, %394
%396 = getelementptr inbounds i8, i8* %393, i64 %395
%397 = bitcast i8* %396 to i64*
store i64 %392, i64* %397
br label %407
398: ; preds = %377
%399 = load i8*, i8** %17
%400 = load i8*, i8** %17
%401 = load i64, i64* %9
%402 = sub i64 0, %401
%403 = getelementptr inbounds i8, i8* %400, i64 %402
%404 = load i64, i64* %9
%405 = load i32, i32* %22
%406 = call i32 @swapfunc(i8* %399, i8* %403, i64 %404, i32 %405)
br label %407
407: ; preds = %398, %380
br label %408
408: ; preds = %407
%409 = load i64, i64* %9
%410 = load i8*, i8** %17
%411 = sub i64 0, %409
%412 = getelementptr inbounds i8, i8* %410, i64 %411
store i8* %412, i8** %17
br label %362
413: ; preds = %375
br label %414
414: ; preds = %413
%415 = load i64, i64* %9
%416 = load i8*, i8** %18
%417 = getelementptr inbounds i8, i8* %416, i64 %415
store i8* %417, i8** %18
br label %352
418: ; preds = %352
br label %579
419: ; preds = %345
%420 = load i8*, i8** %7
%421 = load i64, i64* %8
%422 = load i64, i64* %9
%423 = mul i64 %421, %422
%424 = getelementptr inbounds i8, i8* %420, i64 %423
store i8* %424, i8** %19
%425 = load i8*, i8** %13
%426 = load i8*, i8** %7
%427 = ptrtoint i8* %425 to i64
%428 = ptrtoint i8* %426 to i64
%429 = sub i64 %427, %428
%430 = load i8*, i8** %14
%431 = load i8*, i8** %13
%432 = ptrtoint i8* %430 to i64
%433 = ptrtoint i8* %431 to i64
%434 = sub i64 %432, %433
%435 = icmp slt i64 %429, %434
br i1 %435, label %436, label %442
436: ; preds = %419
%437 = load i8*, i8** %13
%438 = load i8*, i8** %7
%439 = ptrtoint i8* %437 to i64
%440 = ptrtoint i8* %438 to i64
%441 = sub i64 %439, %440
br label %448
442: ; preds = %419
%443 = load i8*, i8** %14
%444 = load i8*, i8** %13
%445 = ptrtoint i8* %443 to i64
%446 = ptrtoint i8* %444 to i64
%447 = sub i64 %445, %446
br label %448
448: ; preds = %442, %436
%449 = phi i64 [ %441, %436 ], [ %447, %442 ]
store i64 %449, i64* %21
%450 = load i64, i64* %21
%451 = icmp ugt i64 %450, 0
br i1 %451, label %452, label %461
452: ; preds = %448
%453 = load i8*, i8** %7
%454 = load i8*, i8** %14
%455 = load i64, i64* %21
%456 = sub i64 0, %455
%457 = getelementptr inbounds i8, i8* %454, i64 %456
%458 = load i64, i64* %21
%459 = load i32, i32* %22
%460 = call i32 @swapfunc(i8* %453, i8* %457, i64 %458, i32 %459)
br label %461
461: ; preds = %452, %448
%462 = load i8*, i8** %16
%463 = load i8*, i8** %15
%464 = ptrtoint i8* %462 to i64
%465 = ptrtoint i8* %463 to i64
%466 = sub i64 %464, %465
%467 = load i8*, i8** %19
%468 = load i8*, i8** %16
%469 = ptrtoint i8* %467 to i64
%470 = ptrtoint i8* %468 to i64
%471 = sub i64 %469, %470
%472 = load i64, i64* %9
%473 = sub i64 %471, %472
%474 = icmp ult i64 %466, %473
br i1 %474, label %475, label %481
475: ; preds = %461
%476 = load i8*, i8** %16
%477 = load i8*, i8** %15
%478 = ptrtoint i8* %476 to i64
%479 = ptrtoint i8* %477 to i64
%480 = sub i64 %478, %479
br label %489
481: ; preds = %461
%482 = load i8*, i8** %19
%483 = load i8*, i8** %16
%484 = ptrtoint i8* %482 to i64
%485 = ptrtoint i8* %483 to i64
%486 = sub i64 %484, %485
%487 = load i64, i64* %9
%488 = sub i64 %486, %487
br label %489
489: ; preds = %481, %475
%490 = phi i64 [ %480, %475 ], [ %488, %481 ]
store i64 %490, i64* %21
%491 = load i64, i64* %21
%492 = icmp ugt i64 %491, 0
br i1 %492, label %493, label %502
493: ; preds = %489
%494 = load i8*, i8** %14
%495 = load i8*, i8** %19
%496 = load i64, i64* %21
%497 = sub i64 0, %496
%498 = getelementptr inbounds i8, i8* %495, i64 %497
%499 = load i64, i64* %21
%500 = load i32, i32* %22
%501 = call i32 @swapfunc(i8* %494, i8* %498, i64 %499, i32 %500)
br label %502
502: ; preds = %493, %489
%503 = load i8*, i8** %14
%504 = load i8*, i8** %13
%505 = ptrtoint i8* %503 to i64
%506 = ptrtoint i8* %504 to i64
%507 = sub i64 %505, %506
store i64 %507, i64* %21
%508 = load i64, i64* %9
%509 = icmp ugt i64 %507, %508
br i1 %509, label %510, label %541
510: ; preds = %502
%511 = load i8*, i8** %7
store i8* %511, i8** %31
%512 = load i8*, i8** %7
%513 = load i64, i64* %21
%514 = getelementptr inbounds i8, i8* %512, i64 %513
%515 = getelementptr inbounds i8, i8* %514, i64 -1
store i8* %515, i8** %32
%516 = load i8*, i8** %11
%517 = load i8*, i8** %31
%518 = icmp ult i8* %516, %517
br i1 %518, label %519, label %523
519: ; preds = %510
%520 = load i8*, i8** %12
%521 = load i8*, i8** %31
%522 = icmp ult i8* %520, %521
br i1 %522, label %540, label %523
523: ; preds = %519, %510
%524 = load i8*, i8** %11
%525 = load i8*, i8** %32
%526 = icmp ugt i8* %524, %525
br i1 %526, label %527, label %531
527: ; preds = %523
%528 = load i8*, i8** %12
%529 = load i8*, i8** %32
%530 = icmp ugt i8* %528, %529
br i1 %530, label %540, label %531
531: ; preds = %527, %523
%532 = load i8*, i8** %7
%533 = load i64, i64* %21
%534 = load i64, i64* %9
%535 = udiv i64 %533, %534
%536 = load i64, i64* %9
%537 = load i32 (i8*, i8*)*, i32 (i8*, i8*)** %10
%538 = load i8*, i8** %11
%539 = load i8*, i8** %12
br label %540
540: ; preds = %531, %527, %519
br label %541
541: ; preds = %540, %502
%542 = load i8*, i8** %16
%543 = load i8*, i8** %15
%544 = ptrtoint i8* %542 to i64
%545 = ptrtoint i8* %543 to i64
%546 = sub i64 %544, %545
store i64 %546, i64* %21
%547 = load i64, i64* %9
%548 = icmp ugt i64 %546, %547
br i1 %548, label %549, label %579
549: ; preds = %541
%550 = load i8*, i8** %19
%551 = load i64, i64* %21
%552 = sub i64 0, %551
%553 = getelementptr inbounds i8, i8* %550, i64 %552
store i8* %553, i8** %7
%554 = load i64, i64* %21
%555 = load i64, i64* %9
%556 = udiv i64 %554, %555
store i64 %556, i64* %8
%557 = load i8*, i8** %7
store i8* %557, i8** %33
%558 = load i8*, i8** %7
%559 = load i64, i64* %21
%560 = getelementptr inbounds i8, i8* %558, i64 %559
%561 = getelementptr inbounds i8, i8* %560, i64 -1
store i8* %561, i8** %34
%562 = load i8*, i8** %11
%563 = load i8*, i8** %33
%564 = icmp ult i8* %562, %563
br i1 %564, label %565, label %569
565: ; preds = %549
%566 = load i8*, i8** %12
%567 = load i8*, i8** %33
%568 = icmp ult i8* %566, %567
br i1 %568, label %578, label %569
569: ; preds = %565, %549
%570 = load i8*, i8** %11
%571 = load i8*, i8** %34
%572 = icmp ugt i8* %570, %571
br i1 %572, label %573, label %577
573: ; preds = %569
%574 = load i8*, i8** %12
%575 = load i8*, i8** %34
%576 = icmp ugt i8* %574, %575
br i1 %576, label %578, label %577
577: ; preds = %573, %569
br label %35
578: ; preds = %573, %565
br label %579
579: ; preds = %125, %418, %578, %541
ret void
}

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