void array_qsort(void **data, int n, int (*_cmp)(const void *, const void *)) {
  int pivot, i, j;
  if (n == 2) {
    if (_cmp(data[1], data[0]) < 0)
      do {
        void *__temp = (data[0]);
        (data[0]) = (data[1]);
        (data[1]) = __temp;
      } while (0);
  } else {
    int lo = 0, hi = n - 1, mid = (lo + hi) / 2;
    if (_cmp(data[lo], data[mid]) < 0)
      do {
        void *__temp = (data[lo]);
        (data[lo]) = (data[mid]);
        (data[mid]) = __temp;
      } while (0);
    if (_cmp(data[hi], data[lo]) < 0) {
      do {
        void *__temp = (data[hi]);
        (data[hi]) = (data[lo]);
        (data[lo]) = __temp;
      } while (0);
      if (_cmp(data[lo], data[mid]) < 0)
        do {
          void *__temp = (data[lo]);
          (data[lo]) = (data[mid]);
          (data[mid]) = __temp;
        } while (0);
    }
    i = 0;
    j = n;
    pivot = 0;
    do {
      for (i += 1; i < n && _cmp(data[i], data[pivot]) < 0; ++i)
        ;
      for (j -= 1; j > 0 && _cmp(data[pivot], data[j]) < 0; --j)
        ;
      if (i < j)
        do {
          void *__temp = (data[i]);
          (data[i]) = (data[j]);
          (data[j]) = __temp;
        } while (0);
    } while (i < j);
    if (j > 0)
      do {
        void *__temp = (data[j]);
        (data[j]) = (data[pivot]);
        (data[pivot]) = __temp;
      } while (0);
    array_qsort(data, j, _cmp);
    array_qsort(data + j + 1, n - 1 - j, _cmp);
  }
}


x86 assembly (clang, -O0):
<array_qsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
cmpl   $0x2,-0xc(%rbp)
jne    1180 <array_qsort+0x70>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%rdi
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rsi
call   *%rax
cmp    $0x0,%eax
jge    117b <array_qsort+0x6b>
jmp    1150 <array_qsort+0x40>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
jmp    117b <array_qsort+0x6b>
jmp    1496 <array_qsort+0x386>
movl   $0x0,-0x34(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    -0x8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rsi
call   *%rax
cmp    $0x0,%eax
jge    120a <array_qsort+0xfa>
jmp    11cd <array_qsort+0xbd>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    120a <array_qsort+0xfa>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rsi
call   *%rax
cmp    $0x0,%eax
jge    12dc <array_qsort+0x1cc>
jmp    1236 <array_qsort+0x126>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    -0x8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rsi
call   *%rax
cmp    $0x0,%eax
jge    12d7 <array_qsort+0x1c7>
jmp    129a <array_qsort+0x18a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    12d7 <array_qsort+0x1c7>
jmp    12dc <array_qsort+0x1cc>
movl   $0x0,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x69(%rbp)
jge    1331 <array_qsort+0x221>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rsi
call   *%rax
cmp    $0x0,%eax
setl   %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    1341 <array_qsort+0x231>
jmp    1354 <array_qsort+0x244>
jmp    1346 <array_qsort+0x236>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12f9 <array_qsort+0x1e9>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x24(%rbp)
mov    %al,-0x6a(%rbp)
jle    1393 <array_qsort+0x283>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
mov    -0x8(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rsi
call   *%rax
cmp    $0x0,%eax
setl   %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
test   $0x1,%al
jne    13a3 <array_qsort+0x293>
jmp    13b6 <array_qsort+0x2a6>
jmp    13a8 <array_qsort+0x298>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    135d <array_qsort+0x24d>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1404 <array_qsort+0x2f4>
jmp    13c7 <array_qsort+0x2b7>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1404 <array_qsort+0x2f4>
jmp    1409 <array_qsort+0x2f9>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     12f0 <array_qsort+0x1e0>
cmpl   $0x0,-0x24(%rbp)
jle    1461 <array_qsort+0x351>
jmp    1424 <array_qsort+0x314>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1461 <array_qsort+0x351>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x18(%rbp),%rdx
call   1030 <array_qsort@plt>
mov    -0x8(%rbp),%rdi
movslq -0x24(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
add    $0x8,%rdi
mov    -0xc(%rbp),%esi
sub    $0x1,%esi
sub    -0x24(%rbp),%esi
mov    -0x18(%rbp),%rdx
call   1030 <array_qsort@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<array_qsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdx,%r13
mov    %rdi,%r14
cmp    $0x2,%esi
je     1334 <array_qsort+0x224>
mov    %esi,%ebx
mov    %r13,0x8(%rsp)
jmp    119f <array_qsort+0x8f>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
lea    (%r14,%rdi,8),%rax
mov    0x8(%rax,%rcx,8),%rdx
mov    (%r14),%rsi
mov    %rsi,0x8(%rax,%rcx,8)
mov    %rdx,(%r14)
mov    %rdi,%rbp
mov    0x28(%rsp),%rbx
lea    (%rbx,%r15,1),%esi
add    $0xffffffff,%esi
mov    %r14,%rdi
mov    0x8(%rsp),%r13
mov    %r13,%rdx
call   1030 <array_qsort@plt>
movslq %ebp,%rax
lea    (%r14,%rax,8),%rax
mov    %rax,%r14
sub    %r12,%r14
mov    0x18(%rsp),%rdx
sub    %ebx,%edx
mov    %edx,%ecx
sub    %r15d,%ecx
add    $0xfffffffe,%edx
cmp    %r15d,%edx
mov    %ecx,%ebx
je     132e <array_qsort+0x21e>
lea    -0x1(%rbx),%ebp
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebx,%eax
add    $0xffffffff,%eax
sar    %eax
mov    (%r14),%rdi
movslq %eax,%r15
mov    (%r14,%r15,8),%rsi
call   *%r13
test   %eax,%eax
jns    11cd <array_qsort+0xbd>
mov    (%r14),%rax
mov    (%r14,%r15,8),%rcx
mov    %rcx,(%r14)
mov    %rax,(%r14,%r15,8)
movslq %ebp,%rbp
mov    (%r14,%rbp,8),%rdi
mov    (%r14),%rsi
call   *%r13
test   %eax,%eax
jns    1210 <array_qsort+0x100>
mov    (%r14,%rbp,8),%rdi
mov    (%r14),%rax
mov    %rax,(%r14,%rbp,8)
mov    %rdi,(%r14)
mov    (%r14,%r15,8),%rsi
call   *%r13
test   %eax,%eax
jns    1210 <array_qsort+0x100>
mov    (%r14),%rax
mov    (%r14,%r15,8),%rcx
mov    %rcx,(%r14)
mov    %rax,(%r14,%r15,8)
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebx,%rax
mov    %rax,0x30(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x20(%rsp)
xor    %ebp,%ebp
mov    %rbx,0x18(%rsp)
mov    %ebx,%r12d
jmp    124a <array_qsort+0x13a>
nopl   (%rax)
movslq %ebp,%rax
mov    (%r14,%rax,8),%rcx
movslq %edi,%rdx
lea    (%r14,%rdx,8),%rdx
mov    (%rdx,%r15,8),%rsi
mov    %rsi,(%r14,%rax,8)
mov    %rcx,(%rdx,%r15,8)
movslq %ebp,%rbx
lea    0x1(%rbx),%r15d
mov    0x18(%rsp),%rax
cmp    %r15d,%eax
cmovg  %eax,%r15d
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    0x30(%rsp),%rbx
jge    1290 <array_qsort+0x180>
mov    (%r14,%rbx,8),%rdi
mov    (%r14),%rsi
call   *%r13
add    $0x1,%ebp
add    $0x1,%rbx
test   %eax,%eax
js     1270 <array_qsort+0x160>
jmp    1293 <array_qsort+0x183>
xchg   %ax,%ax
mov    %r15d,%ebp
mov    %r12d,%r13d
mov    %r12,0x28(%rsp)
lea    -0x1(%r12),%ecx
mov    0x20(%rsp),%rax
mov    %rcx,0x10(%rsp)
lea    (%rax,%rcx,8),%rbx
mov    $0xfffffffffffffff8,%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %rcx,%r15
mov    %rdx,%r12
lea    (%rcx,%r13,1),%eax
cmp    $0x2,%eax
jl     1310 <array_qsort+0x200>
mov    (%r14),%rdi
mov    -0x8(%rbx,%r15,8),%rsi
call   *0x8(%rsp)
lea    -0x1(%r15),%rcx
lea    0x8(%r12),%rdx
test   %eax,%eax
js     12c0 <array_qsort+0x1b0>
add    %rcx,%r13
cmp    %r13d,%ebp
jge    1140 <array_qsort+0x30>
mov    %r13d,%r12d
mov    0x8(%rsp),%r13
mov    0x10(%rsp),%rdi
jmp    1230 <array_qsort+0x120>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
lea    (%rdi,%r15,1),%rax
cmp    %eax,%ebp
jge    1159 <array_qsort+0x49>
mov    %eax,%r12d
mov    0x8(%rsp),%r13
jmp    1230 <array_qsort+0x120>
sub    %r12,%rax
mov    %rax,%r14
mov    (%r14),%rsi
mov    0x8(%r14),%rdi
call   *%r13
test   %eax,%eax
jns    1351 <array_qsort+0x241>
movdqu (%r14),%xmm0
pshufd $0x4e,%xmm0,%xmm0
movdqu %xmm0,(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @array_qsort(i8** %0, i32 %1, i32 (i8*, i8*)* %2) {
%4 = icmp eq i32 %1, 2
br i1 %4, label %5, label %17
5: ; preds = %101, %3
%6 = phi i8** [ %0, %3 ], [ %106, %101 ]
%7 = getelementptr inbounds i8*, i8** %6, i64 1
%8 = load i8*, i8** %7
%9 = load i8*, i8** %6
%10 = tail call i32 %2(i8* %8, i8* %9)
%11 = icmp slt i32 %10, 0
br i1 %11, label %12, label %109
12: ; preds = %5
%13 = bitcast i8** %6 to <2 x i8*>*
%14 = load <2 x i8*>, <2 x i8*>* %13
%15 = shufflevector <2 x i8*> %14, <2 x i8*> poison, <2 x i32> <i32 1, i32 0>
%16 = bitcast i8** %6 to <2 x i8*>*
store <2 x i8*> %15, <2 x i8*>* %16
br label %109
17: ; preds = %3, %101
%18 = phi i32 [ %107, %101 ], [ %1, %3 ]
%19 = phi i8** [ %106, %101 ], [ %0, %3 ]
%20 = add nsw i32 %18, -1
%21 = sdiv i32 %20, 2
%22 = load i8*, i8** %19
%23 = sext i32 %21 to i64
%24 = getelementptr inbounds i8*, i8** %19, i64 %23
%25 = load i8*, i8** %24
%26 = tail call i32 %2(i8* %22, i8* %25)
%27 = icmp slt i32 %26, 0
br i1 %27, label %28, label %31
28: ; preds = %17
%29 = load i8*, i8** %19
%30 = load i8*, i8** %24
store i8* %30, i8** %19
store i8* %29, i8** %24
br label %31
31: ; preds = %28, %17
%32 = sext i32 %20 to i64
%33 = getelementptr inbounds i8*, i8** %19, i64 %32
%34 = load i8*, i8** %33
%35 = load i8*, i8** %19
%36 = tail call i32 %2(i8* %34, i8* %35)
%37 = icmp slt i32 %36, 0
br i1 %37, label %38, label %47
38: ; preds = %31
%39 = load i8*, i8** %33
%40 = load i8*, i8** %19
store i8* %40, i8** %33
store i8* %39, i8** %19
%41 = load i8*, i8** %24
%42 = tail call i32 %2(i8* %39, i8* %41)
%43 = icmp slt i32 %42, 0
br i1 %43, label %44, label %47
44: ; preds = %38
%45 = load i8*, i8** %19
%46 = load i8*, i8** %24
store i8* %46, i8** %19
store i8* %45, i8** %24
br label %47
47: ; preds = %38, %44, %31
%48 = sext i32 %18 to i64
br label %49
49: ; preds = %88, %47
%50 = phi i32 [ %18, %47 ], [ %89, %88 ]
%51 = phi i32 [ 0, %47 ], [ %68, %88 ]
%52 = sext i32 %51 to i64
%53 = add nsw i32 %51, 1
%54 = call i32 @llvm.smax.i32(i32 %18, i32 %53)
br label %55
55: ; preds = %59, %49
%56 = phi i64 [ %57, %59 ], [ %52, %49 ]
%57 = add nsw i64 %56, 1
%58 = icmp slt i64 %57, %48
br i1 %58, label %59, label %67
59: ; preds = %55
%60 = getelementptr inbounds i8*, i8** %19, i64 %57
%61 = load i8*, i8** %60
%62 = load i8*, i8** %19
%63 = tail call i32 %2(i8* %61, i8* %62)
%64 = icmp slt i32 %63, 0
br i1 %64, label %55, label %65
65: ; preds = %59
%66 = trunc i64 %57 to i32
br label %67
67: ; preds = %55, %65
%68 = phi i32 [ %66, %65 ], [ %54, %55 ]
%69 = zext i32 %50 to i64
br label %70
70: ; preds = %75, %67
%71 = phi i64 [ %72, %75 ], [ %69, %67 ]
%72 = add nsw i64 %71, -1
%73 = trunc i64 %71 to i32
%74 = icmp sgt i32 %73, 1
br i1 %74, label %75, label %85
75: ; preds = %70
%76 = load i8*, i8** %19
%77 = and i64 %72, 4294967295
%78 = getelementptr inbounds i8*, i8** %19, i64 %77
%79 = load i8*, i8** %78
%80 = tail call i32 %2(i8* %76, i8* %79)
%81 = icmp slt i32 %80, 0
br i1 %81, label %70, label %82
82: ; preds = %75
%83 = trunc i64 %72 to i32
%84 = icmp slt i32 %68, %83
br i1 %84, label %88, label %97
85: ; preds = %70
%86 = trunc i64 %72 to i32
%87 = icmp slt i32 %68, %86
br i1 %87, label %88, label %101
88: ; preds = %85, %82
%89 = phi i32 [ %86, %85 ], [ %83, %82 ]
%90 = sext i32 %68 to i64
%91 = getelementptr inbounds i8*, i8** %19, i64 %90
%92 = load i8*, i8** %91
%93 = shl i64 %72, 32
%94 = ashr exact i64 %93, 32
%95 = getelementptr inbounds i8*, i8** %19, i64 %94
%96 = load i8*, i8** %95
store i8* %96, i8** %91
store i8* %92, i8** %95
br label %49
97: ; preds = %82
%98 = getelementptr inbounds i8*, i8** %19, i64 %77
%99 = load i8*, i8** %98
%100 = load i8*, i8** %19
store i8* %100, i8** %98
store i8* %99, i8** %19
br label %101
101: ; preds = %85, %97
%102 = trunc i64 %72 to i32
tail call void @array_qsort(i8** %19, i32 %102, i32 (i8*, i8*)* %2)
%103 = shl i64 %72, 32
%104 = ashr exact i64 %103, 32
%105 = getelementptr inbounds i8*, i8** %19, i64 1
%106 = getelementptr inbounds i8*, i8** %105, i64 %104
%107 = sub nsw i32 %20, %102
%108 = icmp eq i32 %107, 2
br i1 %108, label %5, label %17
109: ; preds = %5, %12
ret void
}