void quicksort3way(int a[], int n) {
  unsigned int i, j, p, q, k;
  if (n <= 1)
    return;
  int pvt = a[n - 1];
  for (i = 0; a[i] < pvt; ++i)
    ;
  for (j = n - 2; pvt < a[j] && j > 0; --j)
    ;
  p = 0;
  q = n - 1;
  if (i < j) {
    {
      int t = a[i];
      a[i] = a[j];
      a[j] = t;
    };
    if (a[i] == pvt) {
      {
        int t = a[p];
        a[p] = a[i];
        a[i] = t;
      };
    }
    if (a[j] == pvt) {
      q--;
      {
        int t = a[q];
        a[q] = a[j];
        a[j] = t;
      };
    }
    for (;;) {
      while (++i, a[i] < pvt)
        ;
      while (--j, pvt < a[j]) {
        if (j == 0)
          break;
      }
      if (i >= j)
        break;
      {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
      };
      if (a[i] == pvt) {
        if (p)
          p++;
        {
          int t = a[p];
          a[p] = a[i];
          a[i] = t;
        };
      }
      if (a[j] == pvt) {
        q--;
        {
          int t = a[q];
          a[q] = a[j];
          a[j] = t;
        };
      }
    }
  }
  {
    int t = a[i];
    a[i] = a[n - 1];
    a[n - 1] = t;
  };
  j = i - 1;
  i++;
  for (k = 0; k < p; k++, j--) {
    {
      int t = a[k];
      a[k] = a[j];
      a[j] = t;
    };
  }
  for (k = n - 2; k > q; k--, i++) {
    {
      int t = a[i];
      a[i] = a[k];
      a[k] = t;
    };
  }
  quicksort3way(a, j + 1);
  quicksort3way(a + i, n - i);
}


x86 assembly (clang, -O0):
<quicksort3way>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     112e <quicksort3way+0x1e>
jmp    1500 <quicksort3way+0x3f0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jge    116e <quicksort3way+0x5e>
jmp    1160 <quicksort3way+0x50>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1148 <quicksort3way+0x38>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    %eax,%esi
xor    %eax,%eax
cmp    (%rdx,%rsi,4),%ecx
mov    %al,-0x49(%rbp)
jge    119b <quicksort3way+0x8b>
cmpl   $0x0,-0x14(%rbp)
seta   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    11ab <quicksort3way+0x9b>
jmp    11be <quicksort3way+0xae>
jmp    11b0 <quicksort3way+0xa0>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1177 <quicksort3way+0x67>
movl   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    13da <quicksort3way+0x2ca>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    1249 <quicksort3way+0x139>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    1293 <quicksort3way+0x183>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
jmp    1298 <quicksort3way+0x188>
jmp    129d <quicksort3way+0x18d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jge    12be <quicksort3way+0x1ae>
jmp    129d <quicksort3way+0x18d>
jmp    12c3 <quicksort3way+0x1b3>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
cmp    (%rcx,%rdx,4),%eax
jge    12f3 <quicksort3way+0x1e3>
cmpl   $0x0,-0x14(%rbp)
jne    12ee <quicksort3way+0x1de>
jmp    12f3 <quicksort3way+0x1e3>
jmp    12c3 <quicksort3way+0x1b3>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jb     1304 <quicksort3way+0x1f4>
jmp    13d5 <quicksort3way+0x2c5>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    1386 <quicksort3way+0x276>
cmpl   $0x0,-0x18(%rbp)
je     1358 <quicksort3way+0x248>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x24(%rbp),%eax
jne    13d0 <quicksort3way+0x2c0>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
jmp    1298 <quicksort3way+0x188>
jmp    13da <quicksort3way+0x2ca>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    147e <quicksort3way+0x36e>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    142d <quicksort3way+0x31d>
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jbe    14d8 <quicksort3way+0x3c8>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1487 <quicksort3way+0x377>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
add    $0x1,%esi
call   1030 <quicksort3way@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%eax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0xc(%rbp),%esi
sub    -0x10(%rbp),%esi
call   1030 <quicksort3way@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quicksort3way>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    $0x2,%esi
jge    112f <quicksort3way+0x1f>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%ebx
mov    %rdi,%r14
jmp    1157 <quicksort3way+0x47>
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
call   1030 <quicksort3way@plt>
mov    %r15d,%eax
lea    (%r14,%rax,4),%r14
sub    %r15d,%ebx
cmp    $0x1,%ebx
jle    1120 <quicksort3way+0x10>
lea    -0x1(%rbx),%r8d
mov    (%r14,%r8,4),%edx
mov    $0xffffffff,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%esi
mov    (%r14,%rsi,4),%ecx
cmp    %edx,%ecx
jl     1170 <quicksort3way+0x60>
mov    %esi,%r12d
mov    %rbx,(%rsp)
lea    -0x2(%rbx),%r10d
lea    0x1(%rsi),%r15d
xor    %edi,%edi
xor    %eax,%eax
xchg   %ax,%ax
lea    (%r10,%rax,1),%rbp
mov    %ebp,%ebx
mov    (%r14,%rbx,4),%r9d
add    $0xffffffffffffffff,%rax
add    $0x4,%rdi
cmp    %r9d,%edx
jge    11ab <quicksort3way+0x9b>
test   %ebp,%ebp
jne    1190 <quicksort3way+0x80>
mov    %r10d,%r11d
lea    (%r14,%r11,4),%rbp
add    $0x4,%rbp
mov    %rbp,%r13
sub    %rdi,%r13
movslq (%rsp),%rdi
add    %rax,%rdi
add    $0xffffffffffffffff,%rdi
cmp    %edi,%esi
jae    11f0 <quicksort3way+0xe0>
mov    %r9d,(%r14,%r12,4)
mov    %ecx,0x0(%rbp,%rax,4)
cmp    %edx,(%r14,%r12,4)
jne    11e7 <quicksort3way+0xd7>
mov    (%r14),%ecx
mov    %edx,(%r14)
mov    %ecx,(%r14,%r12,4)
mov    0x0(%rbp,%rax,4),%ecx
cmp    %edx,%ecx
jne    1200 <quicksort3way+0xf0>
mov    %r10d,%r9d
jmp    1210 <quicksort3way+0x100>
mov    %r8d,%r9d
jmp    1298 <quicksort3way+0x188>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%r9d
jmp    1230 <quicksort3way+0x120>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%eax
mov    (%r14,%rax,4),%ecx
mov    %edx,(%r14,%rax,4)
mov    %ecx,0x0(%r13)
jmp    1230 <quicksort3way+0x120>
cmp    %edx,%ecx
je     1320 <quicksort3way+0x210>
nopl   0x0(%rax)
add    $0x1,%esi
mov    (%r14,%rsi,4),%ecx
cmp    %edx,%ecx
jl     1230 <quicksort3way+0x120>
mov    %esi,%r12d
add    $0xffffffff,%edi
mov    %edi,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %eax,%edi
mov    (%r14,%rdi,4),%ebp
sub    $0x1,%eax
setb   %bl
cmp    %ebp,%edx
jge    1264 <quicksort3way+0x154>
test   %bl,%bl
je     1250 <quicksort3way+0x140>
lea    0x1(%rax),%edi
lea    (%r14,%rdi,4),%r13
cmp    %edi,%esi
jae    1290 <quicksort3way+0x180>
mov    %ebp,(%r14,%r12,4)
mov    %ecx,0x0(%r13)
cmp    %edx,(%r14,%r12,4)
jne    1221 <quicksort3way+0x111>
mov    (%r14),%ecx
mov    %edx,(%r14)
mov    %ecx,(%r14,%r12,4)
mov    0x0(%r13),%ecx
jmp    1221 <quicksort3way+0x111>
nopl   (%rax)
mov    (%r14,%r8,4),%edx
lea    0x1(%rsi),%r15d
mov    (%rsp),%rbx
mov    %edx,(%r14,%r12,4)
mov    %ecx,(%r14,%r8,4)
cmp    %r9d,%r10d
jbe    1140 <quicksort3way+0x30>
mov    %ebx,%ecx
sub    %r9d,%ecx
lea    -0x3(%rbx),%eax
test   $0x1,%cl
je     12d5 <quicksort3way+0x1c5>
mov    %r15d,%ecx
mov    (%r14,%rcx,4),%edx
mov    (%r14,%r11,4),%edi
mov    %edi,(%r14,%rcx,4)
mov    %edx,(%r14,%r11,4)
add    $0xffffffffffffffff,%r11
add    $0x1,%r15d
cmp    %r9d,%eax
je     1140 <quicksort3way+0x30>
xchg   %ax,%ax
mov    %r15d,%eax
mov    (%r14,%rax,4),%ecx
mov    (%r14,%r11,4),%edx
mov    %edx,(%r14,%rax,4)
mov    %ecx,(%r14,%r11,4)
lea    0x1(%r15),%eax
mov    (%r14,%rax,4),%ecx
mov    -0x4(%r14,%r11,4),%edx
mov    %edx,(%r14,%rax,4)
mov    %ecx,-0x4(%r14,%r11,4)
add    $0xfffffffffffffffe,%r11
add    $0x2,%r15d
cmp    %r11d,%r9d
jb     12e0 <quicksort3way+0x1d0>
jmp    1140 <quicksort3way+0x30>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%r9d
add    $0x1,%eax
mov    %eax,%edi
jmp    1210 <quicksort3way+0x100>

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

LLVM IR (-O2):
define void @quicksort3way(i32* %0, i32 %1) {
%3 = icmp slt i32 %1, 2
br i1 %3, label %150, label %4
4: ; preds = %2, %144
%5 = phi i32 [ %148, %144 ], [ %1, %2 ]
%6 = phi i32* [ %147, %144 ], [ %0, %2 ]
%7 = add nsw i32 %5, -1
%8 = zext i32 %7 to i64
%9 = getelementptr inbounds i32, i32* %6, i64 %8
%10 = load i32, i32* %9
br label %11
11: ; preds = %11, %4
%12 = phi i32 [ 0, %4 ], [ %17, %11 ]
%13 = zext i32 %12 to i64
%14 = getelementptr inbounds i32, i32* %6, i64 %13
%15 = load i32, i32* %14
%16 = icmp slt i32 %15, %10
%17 = add i32 %12, 1
br i1 %16, label %11, label %18
18: ; preds = %11
%19 = zext i32 %12 to i64
%20 = getelementptr inbounds i32, i32* %6, i64 %19
%21 = add i32 %5, -2
br label %22
22: ; preds = %22, %18
%23 = phi i32 [ %21, %18 ], [ %30, %22 ]
%24 = zext i32 %23 to i64
%25 = getelementptr inbounds i32, i32* %6, i64 %24
%26 = load i32, i32* %25
%27 = icmp slt i32 %10, %26
%28 = icmp ne i32 %23, 0
%29 = select i1 %27, i1 %28, i1 false
%30 = add i32 %23, -1
br i1 %29, label %22, label %31
31: ; preds = %22
%32 = zext i32 %23 to i64
%33 = getelementptr inbounds i32, i32* %6, i64 %32
%34 = icmp ult i32 %12, %23
br i1 %34, label %35, label %97
35: ; preds = %31
store i32 %26, i32* %20
store i32 %15, i32* %33
%36 = load i32, i32* %20
%37 = icmp eq i32 %36, %10
br i1 %37, label %38, label %41
38: ; preds = %35
%39 = load i32, i32* %6
store i32 %10, i32* %6
store i32 %39, i32* %20
%40 = load i32, i32* %33
br label %41
41: ; preds = %38, %35
%42 = phi i32 [ %40, %38 ], [ %15, %35 ]
%43 = icmp eq i32 %42, %10
br i1 %43, label %44, label %52
44: ; preds = %41, %91
%45 = phi i32 [ %92, %91 ], [ %21, %41 ]
%46 = phi i32* [ %80, %91 ], [ %33, %41 ]
%47 = phi i32 [ %71, %91 ], [ %23, %41 ]
%48 = phi i32 [ %61, %91 ], [ %12, %41 ]
%49 = zext i32 %45 to i64
%50 = getelementptr inbounds i32, i32* %6, i64 %49
%51 = load i32, i32* %50
store i32 %10, i32* %50
store i32 %51, i32* %46
br label %52
52: ; preds = %41, %44
%53 = phi i32 [ %45, %44 ], [ %7, %41 ]
%54 = phi i32 [ %47, %44 ], [ %23, %41 ]
%55 = phi i32 [ %48, %44 ], [ %12, %41 ]
br label %56
56: ; preds = %52, %88
%57 = phi i32 [ %71, %88 ], [ %54, %52 ]
%58 = phi i32 [ %61, %88 ], [ %55, %52 ]
br label %59
59: ; preds = %59, %56
%60 = phi i32 [ %58, %56 ], [ %61, %59 ]
%61 = add i32 %60, 1
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %6, i64 %62
%64 = load i32, i32* %63
%65 = icmp slt i32 %64, %10
br i1 %65, label %59, label %66
66: ; preds = %59
%67 = zext i32 %61 to i64
%68 = getelementptr inbounds i32, i32* %6, i64 %67
br label %69
69: ; preds = %66, %69
%70 = phi i32 [ %71, %69 ], [ %57, %66 ]
%71 = add i32 %70, -1
%72 = zext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %6, i64 %72
%74 = load i32, i32* %73
%75 = icmp sge i32 %10, %74
%76 = icmp eq i32 %71, 0
%77 = select i1 %75, i1 true, i1 %76
br i1 %77, label %78, label %69
78: ; preds = %69
%79 = zext i32 %71 to i64
%80 = getelementptr inbounds i32, i32* %6, i64 %79
%81 = icmp ult i32 %61, %71
br i1 %81, label %82, label %93
82: ; preds = %78
store i32 %74, i32* %68
store i32 %64, i32* %80
%83 = load i32, i32* %68
%84 = icmp eq i32 %83, %10
br i1 %84, label %85, label %88
85: ; preds = %82
%86 = load i32, i32* %6
store i32 %10, i32* %6
store i32 %86, i32* %68
%87 = load i32, i32* %80
br label %88
88: ; preds = %85, %82
%89 = phi i32 [ %87, %85 ], [ %64, %82 ]
%90 = icmp eq i32 %89, %10
br i1 %90, label %91, label %56
91: ; preds = %88
%92 = add i32 %53, -1
br label %44
93: ; preds = %78
%94 = zext i32 %61 to i64
%95 = load i32, i32* %9
%96 = add i32 %60, 2
br label %97
97: ; preds = %93, %31
%98 = phi i32 [ %96, %93 ], [ %17, %31 ]
%99 = phi i32 [ %95, %93 ], [ %10, %31 ]
%100 = phi i32 [ %64, %93 ], [ %15, %31 ]
%101 = phi i64 [ %94, %93 ], [ %19, %31 ]
%102 = phi i32 [ %53, %93 ], [ %7, %31 ]
%103 = phi i32 [ %61, %93 ], [ %12, %31 ]
%104 = getelementptr inbounds i32, i32* %6, i64 %101
store i32 %99, i32* %104
store i32 %100, i32* %9
%105 = icmp ugt i32 %21, %102
br i1 %105, label %106, label %144
106: ; preds = %97
%107 = zext i32 %21 to i64
%108 = sub i32 %5, %102
%109 = add i32 %5, -3
%110 = and i32 %108, 1
%111 = icmp eq i32 %110, 0
br i1 %111, label %120, label %112
112: ; preds = %106
%113 = zext i32 %98 to i64
%114 = getelementptr inbounds i32, i32* %6, i64 %113
%115 = load i32, i32* %114
%116 = getelementptr inbounds i32, i32* %6, i64 %107
%117 = load i32, i32* %116
store i32 %117, i32* %114
store i32 %115, i32* %116
%118 = add nsw i64 %107, -1
%119 = add i32 %98, 1
br label %120
120: ; preds = %112, %106
%121 = phi i64 [ %107, %106 ], [ %118, %112 ]
%122 = phi i32 [ %98, %106 ], [ %119, %112 ]
%123 = phi i32 [ undef, %106 ], [ %119, %112 ]
%124 = icmp eq i32 %109, %102
br i1 %124, label %144, label %125
125: ; preds = %120, %125
%126 = phi i64 [ %140, %125 ], [ %121, %120 ]
%127 = phi i32 [ %142, %125 ], [ %122, %120 ]
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %6, i64 %128
%130 = load i32, i32* %129
%131 = getelementptr inbounds i32, i32* %6, i64 %126
%132 = load i32, i32* %131
store i32 %132, i32* %129
store i32 %130, i32* %131
%133 = add nsw i64 %126, -1
%134 = add i32 %127, 1
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %6, i64 %135
%137 = load i32, i32* %136
%138 = getelementptr inbounds i32, i32* %6, i64 %133
%139 = load i32, i32* %138
store i32 %139, i32* %136
store i32 %137, i32* %138
%140 = add nsw i64 %126, -2
%141 = trunc i64 %140 to i32
%142 = add i32 %127, 2
%143 = icmp ult i32 %102, %141
br i1 %143, label %125, label %144
144: ; preds = %120, %125, %97
%145 = phi i32 [ %98, %97 ], [ %123, %120 ], [ %142, %125 ]
tail call void @quicksort3way(i32* %6, i32 %103)
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %6, i64 %146
%148 = sub i32 %5, %145
%149 = icmp slt i32 %148, 2
br i1 %149, label %150, label %4
150: ; preds = %144, %2
ret void
}