#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 qsort(void *aa, size_t n, size_t es,
           int (*cmp)(const void *, const void *)) {
  char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
  int cmp_result, swaptype, swap_cnt;
  size_t d, r;
  char *a = (char *)aa;
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 *)(pl);
          *(long *)(pl) = *(long *)(pl - es);
          *(long *)(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 *)(a);
    *(long *)(a) = *(long *)(pm);
    *(long *)(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 *)(pa);
          *(long *)(pa) = *(long *)(pb);
          *(long *)(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 *)(pc);
          *(long *)(pc) = *(long *)(pd);
          *(long *)(pd) = t;
        } else
          swapfunc(pc, pd, es, swaptype);
        pd -= es;
      }
      pc -= es;
    }
    if (pb > pc)
      break;
    if (swaptype == 0) {
      long t = *(long *)(pb);
      *(long *)(pb) = *(long *)(pc);
      *(long *)(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 *)(pl);
          *(long *)(pl) = *(long *)(pl - es);
          *(long *)(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, r, swaptype);
  r = (pd - pc) < (pn - pd - es) ? pd - pc : pn - pd - es;
  if ((r) > 0)
    swapfunc(pb, pn - r, r, swaptype);
  if ((r = pb - pa) > es)
    qsort(a, r / es, es, cmp);
  if ((r = pd - pc) > es) {
    a = pn - r;
    n = r / es;
    goto loop;
  }
}


x86 assembly (clang, -O0):
<qsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
sub    $0x0,%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    117b <qsort+0x4b>
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
je     118b <qsort+0x5b>
mov    $0x2,%eax
mov    %eax,-0xb4(%rbp)
jmp    11a3 <qsort+0x73>
mov    -0x18(%rbp),%rdx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x8,%rdx
cmove  %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
cmpq   $0x7,-0x10(%rbp)
jae    12d8 <qsort+0x1a8>
mov    -0x80(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x10(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    12d3 <qsort+0x1a3>
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rcx
xor    %eax,%eax
cmp    -0x80(%rbp),%rcx
mov    %al,-0xb5(%rbp)
jbe    1228 <qsort+0xf8>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
setg   %al
mov    %al,-0xb5(%rbp)
mov    -0xb5(%rbp),%al
test   $0x1,%al
jne    123b <qsort+0x10b>
jmp    12bd <qsort+0x18d>
cmpl   $0x0,-0x60(%rbp)
jne    1282 <qsort+0x152>
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x88(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,1)
jmp    129f <qsort+0x16f>
mov    -0x48(%rbp),%rdi
mov    -0x48(%rbp),%rsi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
jmp    12a4 <qsort+0x174>
mov    -0x18(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    11ef <qsort+0xbf>
jmp    12c2 <qsort+0x192>
mov    -0x18(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    11ca <qsort+0x9a>
jmp    191f <qsort+0x7ef>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
shr    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x7,-0x10(%rbp)
jbe    13d0 <qsort+0x2a0>
mov    -0x80(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x28,-0x10(%rbp)
jbe    13b7 <qsort+0x287>
mov    -0x10(%rbp),%rax
shr    $0x3,%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x48(%rbp),%rsi
add    -0x70(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x70(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rcx
call   1040 <med3@plt>
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rdi
xor    %eax,%eax
sub    -0x70(%rbp),%rax
add    %rax,%rdi
mov    -0x50(%rbp),%rsi
mov    -0x50(%rbp),%rdx
add    -0x70(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1040 <med3@plt>
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x70(%rbp),%rcx
shl    $0x1,%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x58(%rbp),%rsi
xor    %eax,%eax
sub    -0x70(%rbp),%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1040 <med3@plt>
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x20(%rbp),%rcx
call   1040 <med3@plt>
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1409 <qsort+0x2d9>
mov    -0x80(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%rcx
mov    -0x80(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x90(%rbp),%rcx
mov    -0x50(%rbp),%rax
mov    %rcx,(%rax)
jmp    141d <qsort+0x2ed>
mov    -0x80(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x80(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    %rax,-0x38(%rbp)
jmp    144e <qsort+0x31e>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0xb6(%rbp)
ja     1481 <qsort+0x351>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   *%rax
mov    %eax,-0x5c(%rbp)
cmp    $0x0,%eax
setle  %al
mov    %al,-0xb6(%rbp)
mov    -0xb6(%rbp),%al
test   $0x1,%al
jne    1494 <qsort+0x364>
jmp    150f <qsort+0x3df>
cmpl   $0x0,-0x5c(%rbp)
jne    14fe <qsort+0x3ce>
movl   $0x1,-0x64(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    14de <qsort+0x3ae>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x98(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
jmp    14f2 <qsort+0x3c2>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x18(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    144e <qsort+0x31e>
jmp    1514 <qsort+0x3e4>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0xb7(%rbp)
ja     1547 <qsort+0x417>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   *%rax
mov    %eax,-0x5c(%rbp)
cmp    $0x0,%eax
setge  %al
mov    %al,-0xb7(%rbp)
mov    -0xb7(%rbp),%al
test   $0x1,%al
jne    155a <qsort+0x42a>
jmp    15e5 <qsort+0x4b5>
cmpl   $0x0,-0x5c(%rbp)
jne    15cc <qsort+0x49c>
movl   $0x1,-0x64(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    15a4 <qsort+0x474>
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    15b8 <qsort+0x488>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x18(%rbp),%rdx
mov    -0x40(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1514 <qsort+0x3e4>
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jbe    15f8 <qsort+0x4c8>
jmp    1671 <qsort+0x541>
cmpl   $0x0,-0x60(%rbp)
jne    1631 <qsort+0x501>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xa8(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
jmp    1645 <qsort+0x515>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
movl   $0x1,-0x64(%rbp)
mov    -0x18(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    1449 <qsort+0x319>
cmpl   $0x0,-0x64(%rbp)
jne    1795 <qsort+0x665>
mov    -0x80(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x10(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1790 <qsort+0x660>
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rcx
xor    %eax,%eax
cmp    -0x80(%rbp),%rcx
mov    %al,-0xb8(%rbp)
jbe    16e5 <qsort+0x5b5>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rdi
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
add    %rcx,%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
cmp    $0x0,%eax
setg   %al
mov    %al,-0xb8(%rbp)
mov    -0xb8(%rbp),%al
test   $0x1,%al
jne    16f8 <qsort+0x5c8>
jmp    177a <qsort+0x64a>
cmpl   $0x0,-0x60(%rbp)
jne    173f <qsort+0x60f>
mov    -0x48(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0xb0(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,1)
jmp    175c <qsort+0x62c>
mov    -0x48(%rbp),%rdi
mov    -0x48(%rbp),%rsi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
jmp    1761 <qsort+0x631>
mov    -0x18(%rbp),%rdx
mov    -0x48(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    16ac <qsort+0x57c>
jmp    177f <qsort+0x64f>
mov    -0x18(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1687 <qsort+0x557>
jmp    191f <qsort+0x7ef>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
sub    %rcx,%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jge    17df <qsort+0x6af>
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xc0(%rbp)
jmp    17f1 <qsort+0x6c1>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
jbe    1824 <qsort+0x6f4>
mov    -0x80(%rbp),%rdi
mov    -0x30(%rbp),%rsi
xor    %eax,%eax
sub    -0x78(%rbp),%rax
add    %rax,%rsi
mov    -0x78(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    -0x58(%rbp),%rcx
mov    -0x40(%rbp),%rdx
sub    %rdx,%rcx
sub    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    185e <qsort+0x72e>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0xc8(%rbp)
jmp    1874 <qsort+0x744>
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
sub    -0x18(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
jbe    18a7 <qsort+0x777>
mov    -0x30(%rbp),%rdi
mov    -0x58(%rbp),%rsi
xor    %eax,%eax
sub    -0x78(%rbp),%rax
add    %rax,%rsi
mov    -0x78(%rbp),%rdx
mov    -0x60(%rbp),%ecx
call   1030 <swapfunc@plt>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x78(%rbp)
cmp    -0x18(%rbp),%rax
jbe    18e0 <qsort+0x7b0>
mov    -0x80(%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
call   1050 <qsort@plt>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x78(%rbp)
cmp    -0x18(%rbp),%rax
jbe    191f <qsort+0x7ef>
mov    -0x58(%rbp),%rax
xor    %ecx,%ecx
sub    -0x78(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x18(%rbp)
mov    %rax,-0x10(%rbp)
jmp    1153 <qsort+0x23>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r12
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
mov    %rdx,%rax
neg    %rax
mov    %rax,0x18(%rsp)
xor    %edx,%edx
cmp    $0x8,%r15
setne  %dl
mov    %ebx,%eax
or     %r15d,%eax
test   $0x7,%al
mov    $0x2,%ecx
cmove  %edx,%ecx
cmp    $0x6,%rsi
mov    %r12,0x20(%rsp)
ja     121a <qsort+0xea>
imul   %r15,%r14
mov    %r14,0x8(%rsp)
cmp    %r15,%r14
jle    15ee <qsort+0x4be>
mov    %ecx,%r12d
add    %rbx,0x8(%rsp)
lea    (%rbx,%r15,1),%r14
mov    %rbx,(%rsp)
jmp    11b5 <qsort+0x85>
add    %r15,%r14
add    %r15,(%rsp)
cmp    0x8(%rsp),%r14
mov    %r13,%rbx
jae    15ee <qsort+0x4be>
mov    %rbx,%r13
cmp    %rbx,%r14
jbe    11a0 <qsort+0x70>
mov    (%rsp),%rbp
jmp    11ef <qsort+0xbf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12d,%ecx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
add    0x18(%rsp),%rbp
lea    (%r15,%rbp,1),%rax
cmp    %r13,%rax
jbe    11a0 <qsort+0x70>
lea    (%r15,%rbp,1),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *0x20(%rsp)
test   %eax,%eax
jle    11a0 <qsort+0x70>
test   %r12d,%r12d
jne    11d0 <qsort+0xa0>
mov    0x0(%rbp,%r15,1),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,0x0(%rbp,%r15,1)
mov    %rax,0x0(%rbp)
jmp    11e1 <qsort+0xb1>
mov    %edx,0x34(%rsp)
jmp    124b <qsort+0x11b>
mov    %r14,%rax
xor    %edx,%edx
div    %r15
mov    %rax,%r14
mov    %ebx,%eax
or     %r15d,%eax
test   $0x7,%al
mov    $0x2,%ecx
cmove  0x34(%rsp),%ecx
cmp    $0x7,%r14
mov    0x20(%rsp),%r12
jb     117c <qsort+0x4c>
mov    %r14,%rbp
shr    %rbp
imul   %r15,%rbp
add    %rbx,%rbp
cmp    $0x7,%r14
mov    %rbx,%r13
mov    %ecx,(%rsp)
mov    %r14,0x8(%rsp)
je     131c <qsort+0x1ec>
mov    %r14,%rax
add    $0xffffffffffffffff,%r14
imul   %r15,%r14
add    %rbx,%r14
cmp    $0x29,%rax
jb     1300 <qsort+0x1d0>
mov    %rax,%rbx
shr    $0x3,%rbx
imul   %r15,%rbx
lea    (%rbx,%r13,1),%rsi
lea    (%rbx,%rbx,1),%rax
mov    %rax,0x10(%rsp)
lea    0x0(,%rbx,2),%rdx
add    %r13,%rdx
mov    %r13,%rdi
mov    %r12,%rcx
call   1040 <med3@plt>
mov    %rax,0x28(%rsp)
mov    %rbp,%rdi
sub    %rbx,%rdi
lea    (%rbx,%rbp,1),%rdx
mov    %rbp,%rsi
mov    %r12,%rcx
call   1040 <med3@plt>
mov    %rax,%rbp
mov    %r14,%rdi
sub    0x10(%rsp),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
mov    %r13,%rbx
mov    %r14,%rdx
mov    %r12,%rcx
call   1040 <med3@plt>
mov    0x28(%rsp),%rdi
mov    %rax,%r14
jmp    1303 <qsort+0x1d3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
call   1040 <med3@plt>
mov    %rax,%rbp
mov    (%rsp),%ecx
mov    0x8(%rsp),%r14
test   %ecx,%ecx
je     1330 <qsort+0x200>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
jmp    133e <qsort+0x20e>
mov    (%rbx),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,(%rbx)
mov    %rax,0x0(%rbp)
lea    (%rbx,%r15,1),%rax
add    $0xffffffffffffffff,%r14
imul   %r15,%r14
add    %rbx,%r14
xor    %ebx,%ebx
mov    %r14,%r12
mov    %rax,%rbp
mov    %rax,0x28(%rsp)
mov    %rax,0x10(%rsp)
cmp    %r12,%rbp
jbe    138e <qsort+0x25e>
jmp    13c8 <qsort+0x298>
mov    0x10(%rsp),%rbx
mov    (%rbx),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,(%rbx)
mov    %rax,0x0(%rbp)
add    %r15,%rbx
mov    %rbx,0x10(%rsp)
mov    $0x1,%ebx
add    %r15,%rbp
cmp    %r12,%rbp
ja     13c8 <qsort+0x298>
mov    %rbp,%rdi
mov    %r13,%rsi
call   *0x20(%rsp)
test   %eax,%eax
jg     13c8 <qsort+0x298>
jne    1386 <qsort+0x256>
mov    (%rsp),%ecx
test   %ecx,%ecx
je     1366 <qsort+0x236>
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
jmp    1379 <qsort+0x249>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
add    %rax,%r12
cmp    %r12,%rbp
ja     1460 <qsort+0x330>
mov    %r12,%rdi
mov    %r13,%rsi
call   *0x20(%rsp)
test   %eax,%eax
js     141d <qsort+0x2ed>
jne    13c0 <qsort+0x290>
mov    (%rsp),%ecx
test   %ecx,%ecx
je     13f8 <qsort+0x2c8>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
jmp    1406 <qsort+0x2d6>
mov    (%r12),%rax
mov    (%r14),%rcx
mov    %rcx,(%r12)
mov    %rax,(%r14)
mov    0x18(%rsp),%rax
add    %rax,%r14
mov    $0x1,%ebx
add    %rax,%r12
cmp    %r12,%rbp
jbe    13d1 <qsort+0x2a1>
jmp    1460 <qsort+0x330>
mov    (%rsp),%ecx
test   %ecx,%ecx
je     1434 <qsort+0x304>
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
jmp    1444 <qsort+0x314>
mov    0x0(%rbp),%rax
mov    (%r12),%rcx
mov    %rcx,0x0(%rbp)
mov    %rax,(%r12)
add    %r15,%rbp
add    0x18(%rsp),%r12
mov    $0x1,%ebx
cmp    %r12,%rbp
jbe    138e <qsort+0x25e>
jmp    13c8 <qsort+0x298>
nop
mov    0x8(%rsp),%rcx
imul   %r15,%rcx
mov    %r13,%rax
lea    (%rcx,%r13,1),%rdx
mov    %rdx,0x8(%rsp)
test   %ebx,%ebx
je     154d <qsort+0x41d>
mov    %rbp,%rcx
mov    0x10(%rsp),%rdx
sub    %rdx,%rcx
sub    %rax,%rdx
cmp    %rcx,%rdx
mov    %rcx,%r13
cmovge %rcx,%rdx
test   %rdx,%rdx
mov    %rax,%rbx
je     14ae <qsort+0x37e>
mov    %rbp,%rsi
sub    %rdx,%rsi
mov    %rbx,%rdi
mov    (%rsp),%ecx
call   1030 <swapfunc@plt>
mov    %rbx,0x10(%rsp)
mov    %r14,%rax
sub    %r12,%rax
add    %r15,%r14
mov    0x8(%rsp),%rbx
mov    %rbx,%rdx
sub    %r14,%rdx
mov    %rax,%r14
cmp    %rdx,%rax
cmovb  %rax,%rdx
test   %rdx,%rdx
mov    (%rsp),%ecx
je     14e7 <qsort+0x3b7>
mov    %rbx,%rsi
sub    %rdx,%rsi
mov    %rbp,%rdi
call   1030 <swapfunc@plt>
cmp    %r15,%r13
jbe    1521 <qsort+0x3f1>
mov    %r13,%rcx
or     %r15,%rcx
shr    $0x20,%rcx
mov    0x20(%rsp),%rcx
je     150a <qsort+0x3da>
mov    %r13,%rax
xor    %edx,%edx
div    %r15
mov    %rax,%rsi
jmp    1514 <qsort+0x3e4>
mov    %r13d,%eax
xor    %edx,%edx
div    %r15d
mov    %eax,%esi
mov    0x10(%rsp),%rdi
mov    %r15,%rdx
call   1050 <qsort@plt>
cmp    %r15,%r14
jbe    15ee <qsort+0x4be>
sub    %r14,%rbx
mov    %r14,%rax
or     %r15,%rax
shr    $0x20,%rax
jne    1220 <qsort+0xf0>
mov    %r14d,%eax
xor    %edx,%edx
div    %r15d
mov    %eax,%r14d
jmp    122b <qsort+0xfb>
cmp    %r15,%rcx
mov    0x28(%rsp),%rcx
jle    15ee <qsort+0x4be>
mov    %rax,%r14
mov    0x20(%rsp),%r12
jmp    1585 <qsort+0x455>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%rcx
add    %r15,%rcx
add    %r15,%r14
cmp    0x8(%rsp),%rcx
mov    %r13,%rax
jae    15ee <qsort+0x4be>
mov    %rcx,0x28(%rsp)
cmp    %rax,%rcx
jbe    1570 <qsort+0x440>
mov    %r14,%rbp
jmp    15c2 <qsort+0x492>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <swapfunc@plt>
mov    0x18(%rsp),%rax
mov    %r13,%rcx
add    %rax,%rbp
lea    (%r15,%rbp,1),%rax
cmp    %r13,%rax
jbe    1570 <qsort+0x440>
lea    (%r15,%rbp,1),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   *%r12
test   %eax,%eax
jle    1570 <qsort+0x440>
mov    (%rsp),%ecx
test   %ecx,%ecx
jne    15a0 <qsort+0x470>
mov    0x0(%rbp,%r15,1),%rax
mov    0x0(%rbp),%rcx
mov    %rcx,0x0(%rbp,%r15,1)
mov    %rax,0x0(%rbp)
jmp    15ae <qsort+0x47e>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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