void quickSort(double *arr, int elements, int *pos) {
  int beg[300], end[300], i, L, R, swap;
  double piv;
  for (i = 0; i < elements; i++)
    pos[i] = i;
  int ptmp;
  beg[0] = 0;
  end[0] = elements;
  i = 0;
  while (i >= 0) {
    L = beg[i];
    R = end[i] - 1;
    if (L < R) {
      piv = arr[L];
      ptmp = pos[L];
      while (L < R) {
        while (arr[R] >= piv && L < R)
          R--;
        if (L < R) {
          arr[L] = arr[R];
          pos[L] = pos[R];
          L++;
        }
        while (arr[L] <= piv && L < R)
          L++;
        if (L < R) {
          arr[R] = arr[L];
          pos[R] = pos[L];
          R--;
        }
      }
      arr[L] = piv;
      pos[L] = ptmp;
      beg[i + 1] = L + 1;
      end[i + 1] = end[i];
      end[i++] = L;
      if (end[i] - beg[i] > end[i - 1] - beg[i - 1]) {
        swap = beg[i];
        beg[i] = beg[i - 1];
        beg[i - 1] = swap;
        swap = end[i];
        end[i] = end[i - 1];
        end[i - 1] = swap;
      }
    } else {
      i--;
    }
  }
}


x86 assembly (clang, -O0):
<quickSort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x920,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x984(%rbp)
mov    -0x984(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1157 <quickSort+0x57>
mov    -0x984(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x984(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x984(%rbp)
jmp    1120 <quickSort+0x20>
movl   $0x0,-0x4d0(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x980(%rbp)
movl   $0x0,-0x984(%rbp)
cmpl   $0x0,-0x984(%rbp)
jl     150f <quickSort+0x40f>
movslq -0x984(%rbp),%rax
mov    -0x4d0(%rbp,%rax,4),%eax
mov    %eax,-0x988(%rbp)
movslq -0x984(%rbp),%rax
mov    -0x980(%rbp,%rax,4),%eax
sub    $0x1,%eax
mov    %eax,-0x98c(%rbp)
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
jge    14fb <quickSort+0x3fb>
mov    -0x8(%rbp),%rax
movslq -0x988(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x998(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x988(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x99c(%rbp)
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
jge    138d <quickSort+0x28d>
jmp    1201 <quickSort+0x101>
mov    -0x8(%rbp),%rax
movslq -0x98c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xor    %eax,%eax
ucomisd -0x998(%rbp),%xmm0
ff
mov    %al,-0x99d(%rbp)
jb     123c <quickSort+0x13c>
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
setl   %al
mov    %al,-0x99d(%rbp)
mov    -0x99d(%rbp),%al
test   $0x1,%al
jne    124f <quickSort+0x14f>
jmp    1263 <quickSort+0x163>
mov    -0x98c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98c(%rbp)
jmp    1201 <quickSort+0x101>
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
jge    12c0 <quickSort+0x1c0>
mov    -0x8(%rbp),%rax
movslq -0x98c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x988(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x98c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x988(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x988(%rbp)
jmp    12c5 <quickSort+0x1c5>
mov    -0x8(%rbp),%rax
movslq -0x988(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x998(%rbp),%xmm0
ff
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0x99e(%rbp)
jb     1304 <quickSort+0x204>
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
setl   %al
mov    %al,-0x99e(%rbp)
mov    -0x99e(%rbp),%al
test   $0x1,%al
jne    1317 <quickSort+0x217>
jmp    132b <quickSort+0x22b>
mov    -0x988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x988(%rbp)
jmp    12c5 <quickSort+0x1c5>
mov    -0x988(%rbp),%eax
cmp    -0x98c(%rbp),%eax
jge    1388 <quickSort+0x288>
mov    -0x8(%rbp),%rax
movslq -0x988(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x98c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x988(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x98c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98c(%rbp)
jmp    11ea <quickSort+0xea>
movsd  -0x998(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x988(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x99c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x988(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x988(%rbp),%ecx
add    $0x1,%ecx
mov    -0x984(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x4d0(%rbp,%rax,4)
movslq -0x984(%rbp),%rax
mov    -0x980(%rbp,%rax,4),%ecx
mov    -0x984(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x980(%rbp,%rax,4)
mov    -0x988(%rbp),%ecx
mov    -0x984(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x984(%rbp)
cltq
mov    %ecx,-0x980(%rbp,%rax,4)
movslq -0x984(%rbp),%rax
mov    -0x980(%rbp,%rax,4),%eax
movslq -0x984(%rbp),%rcx
sub    -0x4d0(%rbp,%rcx,4),%eax
mov    -0x984(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x980(%rbp,%rcx,4),%ecx
mov    -0x984(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
sub    -0x4d0(%rbp,%rdx,4),%ecx
cmp    %ecx,%eax
jle    14f6 <quickSort+0x3f6>
movslq -0x984(%rbp),%rax
mov    -0x4d0(%rbp,%rax,4),%eax
mov    %eax,-0x990(%rbp)
mov    -0x984(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x4d0(%rbp,%rax,4),%ecx
movslq -0x984(%rbp),%rax
mov    %ecx,-0x4d0(%rbp,%rax,4)
mov    -0x990(%rbp),%ecx
mov    -0x984(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x4d0(%rbp,%rax,4)
movslq -0x984(%rbp),%rax
mov    -0x980(%rbp,%rax,4),%eax
mov    %eax,-0x990(%rbp)
mov    -0x984(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x980(%rbp,%rax,4),%ecx
movslq -0x984(%rbp),%rax
mov    %ecx,-0x980(%rbp,%rax,4)
mov    -0x990(%rbp),%ecx
mov    -0x984(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x980(%rbp,%rax,4)
jmp    150a <quickSort+0x40a>
mov    -0x984(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x984(%rbp)
jmp    1174 <quickSort+0x74>
add    $0x920,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quickSort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8f8,%rsp
test   %esi,%esi
jle    128c <quickSort+0x18c>
mov    %esi,%eax
cmp    $0x8,%esi
jae    1127 <quickSort+0x27>
xor    %ecx,%ecx
jmp    1280 <quickSort+0x180>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    1157 <quickSort+0x57>
movdqa 0xeb0(%rip),%xmm0
xor    %ebp,%ebp
jmp    1228 <quickSort+0x128>
and    $0xfffffffffffffffc,%rbx
movdqa 0xe9d(%rip),%xmm0
xor    %ebp,%ebp
movdqa 0xea2(%rip),%xmm8
movdqa 0xea9(%rip),%xmm9
movdqa 0xeb0(%rip),%xmm10
movdqa 0xeb8(%rip),%xmm4
movdqa 0xec0(%rip),%xmm5
movdqa 0xec8(%rip),%xmm6
movdqa 0xed0(%rip),%xmm7
movdqa 0xed8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rdx,%rbp,4)
movdqu %xmm2,0x10(%rdx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rdx,%rbp,4)
movdqu %xmm3,0x30(%rdx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rdx,%rbp,4)
movdqu %xmm3,0x50(%rdx,%rbp,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rdx,%rbp,4)
movdqu %xmm3,0x70(%rdx,%rbp,4)
add    $0x20,%rbp
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rbx
jne    11b0 <quickSort+0xb0>
test   %r8,%r8
je     1271 <quickSort+0x171>
lea    (%rdx,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %ebx,%ebx
movdqa 0xdcd(%rip),%xmm1
movdqa 0xdd5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rbp,%rbx,1)
movdqu %xmm3,0x0(%rbp,%rbx,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1250 <quickSort+0x150>
cmp    %rax,%rcx
je     128c <quickSort+0x18c>
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1280 <quickSort+0x180>
movabs $0xffffffff00000000,%r10
ff ff ff
movabs $0x100000000,%r13
movl   $0x0,0x440(%rsp)
mov    %esi,-0x70(%rsp)
xor    %r8d,%r8d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%r9d
lea    -0x1(%rsi),%r12d
cmp    %r12d,%r8d
jge    13a0 <quickSort+0x2a0>
mov    %esi,%eax
mov    %rax,-0x78(%rsp)
movslq %r8d,%rax
movsd  (%rdi,%rax,8),%xmm0
mov    (%rdx,%rax,4),%r14d
mov    %r8d,%r15d
jmp    12f9 <quickSort+0x1f9>
nopl   0x0(%rax,%rax,1)
cmp    %r15d,%r12d
jle    13b0 <quickSort+0x2b0>
movslq %r12d,%rbp
movslq %r15d,%r11
mov    %rbp,%rbx
shl    $0x20,%rbx
add    %r13,%rbx
nopl   0x0(%rax)
mov    %rbp,%rax
movsd  (%rdi,%rbp,8),%xmm1
add    $0xffffffffffffffff,%rbp
add    %r10,%rbx
ucomisd %xmm0,%xmm1
jb     132a <quickSort+0x22a>
cmp    %r11,%rax
jg     1310 <quickSort+0x210>
cmp    %r11,%rax
jle    1344 <quickSort+0x244>
movsd  %xmm1,(%rdi,%r11,8)
mov    0x4(%rdx,%rbp,4),%eax
mov    %eax,(%rdx,%r11,4)
add    $0x1,%r11d
movslq %r11d,%r11
lea    0x1(%rbp),%r12d
sar    $0x20,%rbx
mov    %r11,%rax
shl    $0x20,%rax
add    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
mov    %r11,%rcx
movsd  (%rdi,%r11,8),%xmm1
add    $0x1,%r11
add    %r13,%rax
ucomisd %xmm1,%xmm0
jb     137b <quickSort+0x27b>
cmp    %rbx,%rcx
jl     1360 <quickSort+0x260>
lea    -0x1(%r11),%r15
cmp    %rbx,%rcx
jge    12f0 <quickSort+0x1f0>
movsd  %xmm1,0x8(%rdi,%rbp,8)
mov    -0x4(%rdx,%r11,4),%ecx
mov    %ecx,0x4(%rdx,%rbp,4)
mov    %ebp,%r12d
jmp    12f0 <quickSort+0x1f0>
nop
add    $0xffffffff,%r9d
mov    %r9d,%eax
jmp    1410 <quickSort+0x310>
nopl   0x0(%rax)
mov    %rax,%rcx
sar    $0x1d,%rcx
movsd  %xmm0,(%rdi,%rcx,1)
sar    $0x1e,%rax
mov    %r14d,(%rdx,%rax,1)
movslq %r9d,%rbx
lea    0x1(%r9),%eax
mov    %r11d,0x444(%rsp,%rbx,4)
mov    -0x78(%rsp),%rcx
mov    %ecx,-0x6c(%rsp,%rbx,4)
mov    %r15d,-0x70(%rsp,%r9,4)
mov    %esi,%ecx
sub    %r11d,%ecx
mov    %r8d,%ebp
not    %ebp
add    %r11d,%ebp
cmp    %ebp,%ecx
jle    1410 <quickSort+0x310>
add    $0x1,%rbx
mov    %r8d,0x440(%rsp,%rbx,4)
mov    %r11d,0x440(%rsp,%r9,4)
mov    %r15d,-0x70(%rsp,%rbx,4)
mov    %esi,-0x70(%rsp,%r9,4)
test   %eax,%eax
js     1427 <quickSort+0x327>
mov    %eax,%ecx
mov    0x440(%rsp,%rcx,4),%r8d
mov    -0x70(%rsp,%rcx,4),%esi
jmp    12c0 <quickSort+0x1c0>
add    $0x8f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @quickSort(double* nocapture %0, i32 %1, i32* nocapture %2) {
%4 = alloca [300 x i32]
%5 = alloca [300 x i32]
%6 = bitcast [300 x i32]* %4 to i8*
%7 = bitcast [300 x i32]* %5 to i8*
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %82
9: ; preds = %3
%10 = zext i32 %1 to i64
%11 = icmp ult i32 %1, 8
br i1 %11, label %74, label %12
12: ; preds = %9
%13 = and i64 %10, 4294967288
%14 = add nsw i64 %13, -8
%15 = lshr exact i64 %14, 3
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 3
%18 = icmp ult i64 %14, 24
br i1 %18, label %55, label %19
19: ; preds = %12
%20 = and i64 %16, 4611686018427387900
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %51, %21 ]
%23 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %19 ], [ %52, %21 ]
%24 = phi i64 [ 0, %19 ], [ %53, %21 ]
%25 = add <4 x i32> %23, <i32 4, i32 4, i32 4, i32 4>
%26 = getelementptr inbounds i32, i32* %2, i64 %22
%27 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %27
%28 = getelementptr inbounds i32, i32* %26, i64 4
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %25, <4 x i32>* %29
%30 = or i64 %22, 8
%31 = add <4 x i32> %23, <i32 8, i32 8, i32 8, i32 8>
%32 = add <4 x i32> %23, <i32 12, i32 12, i32 12, i32 12>
%33 = getelementptr inbounds i32, i32* %2, i64 %30
%34 = bitcast i32* %33 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %34
%35 = getelementptr inbounds i32, i32* %33, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %32, <4 x i32>* %36
%37 = or i64 %22, 16
%38 = add <4 x i32> %23, <i32 16, i32 16, i32 16, i32 16>
%39 = add <4 x i32> %23, <i32 20, i32 20, i32 20, i32 20>
%40 = getelementptr inbounds i32, i32* %2, i64 %37
%41 = bitcast i32* %40 to <4 x i32>*
store <4 x i32> %38, <4 x i32>* %41
%42 = getelementptr inbounds i32, i32* %40, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %43
%44 = or i64 %22, 24
%45 = add <4 x i32> %23, <i32 24, i32 24, i32 24, i32 24>
%46 = add <4 x i32> %23, <i32 28, i32 28, i32 28, i32 28>
%47 = getelementptr inbounds i32, i32* %2, i64 %44
%48 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %48
%49 = getelementptr inbounds i32, i32* %47, i64 4
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %46, <4 x i32>* %50
%51 = add nuw i64 %22, 32
%52 = add <4 x i32> %23, <i32 32, i32 32, i32 32, i32 32>
%53 = add i64 %24, 4
%54 = icmp eq i64 %53, %20
br i1 %54, label %55, label %21
55: ; preds = %21, %12
%56 = phi i64 [ 0, %12 ], [ %51, %21 ]
%57 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %12 ], [ %52, %21 ]
%58 = icmp eq i64 %17, 0
br i1 %58, label %72, label %59
59: ; preds = %55, %59
%60 = phi i64 [ %68, %59 ], [ %56, %55 ]
%61 = phi <4 x i32> [ %69, %59 ], [ %57, %55 ]
%62 = phi i64 [ %70, %59 ], [ 0, %55 ]
%63 = add <4 x i32> %61, <i32 4, i32 4, i32 4, i32 4>
%64 = getelementptr inbounds i32, i32* %2, i64 %60
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> %61, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %67
%68 = add nuw i64 %60, 8
%69 = add <4 x i32> %61, <i32 8, i32 8, i32 8, i32 8>
%70 = add i64 %62, 1
%71 = icmp eq i64 %70, %17
br i1 %71, label %72, label %59
72: ; preds = %59, %55
%73 = icmp eq i64 %13, %10
br i1 %73, label %82, label %74
74: ; preds = %9, %72
%75 = phi i64 [ 0, %9 ], [ %13, %72 ]
br label %76
76: ; preds = %74, %76
%77 = phi i64 [ %80, %76 ], [ %75, %74 ]
%78 = getelementptr inbounds i32, i32* %2, i64 %77
%79 = trunc i64 %77 to i32
store i32 %79, i32* %78
%80 = add nuw nsw i64 %77, 1
%81 = icmp eq i64 %80, %10
br i1 %81, label %82, label %76
82: ; preds = %76, %72, %3
%83 = getelementptr inbounds [300 x i32], [300 x i32]* %4, i64 0, i64 0
store i32 0, i32* %83
%84 = getelementptr inbounds [300 x i32], [300 x i32]* %5, i64 0, i64 0
store i32 %1, i32* %84
br label %85
85: ; preds = %165, %82
%86 = phi i32 [ %1, %82 ], [ %170, %165 ]
%87 = phi i32 [ 0, %82 ], [ %168, %165 ]
%88 = phi i32 [ 0, %82 ], [ %163, %165 ]
%89 = zext i32 %88 to i64
%90 = getelementptr inbounds [300 x i32], [300 x i32]* %4, i64 0, i64 %89
%91 = getelementptr inbounds [300 x i32], [300 x i32]* %5, i64 0, i64 %89
%92 = add nsw i32 %86, -1
%93 = icmp slt i32 %87, %92
br i1 %93, label %94, label %160
94: ; preds = %85
%95 = sext i32 %87 to i64
%96 = getelementptr inbounds double, double* %0, i64 %95
%97 = load double, double* %96
%98 = getelementptr inbounds i32, i32* %2, i64 %95
%99 = load i32, i32* %98
br label %100
100: ; preds = %94, %142
%101 = phi i32 [ %87, %94 ], [ %136, %142 ]
%102 = phi i32 [ %92, %94 ], [ %143, %142 ]
%103 = sext i32 %102 to i64
%104 = sext i32 %101 to i64
br label %105
105: ; preds = %105, %100
%106 = phi i64 [ %112, %105 ], [ %103, %100 ]
%107 = getelementptr inbounds double, double* %0, i64 %106
%108 = load double, double* %107
%109 = fcmp oge double %108, %97
%110 = icmp sgt i64 %106, %104
%111 = select i1 %109, i1 %110, i1 false
%112 = add nsw i64 %106, -1
br i1 %111, label %105, label %113
113: ; preds = %105
%114 = getelementptr inbounds double, double* %0, i64 %106
%115 = trunc i64 %106 to i32
br i1 %110, label %116, label %123
116: ; preds = %113
%117 = getelementptr inbounds double, double* %0, i64 %104
store double %108, double* %117
%118 = getelementptr inbounds i32, i32* %2, i64 %106
%119 = load i32, i32* %118
%120 = getelementptr inbounds i32, i32* %2, i64 %104
store i32 %119, i32* %120
%121 = add nsw i32 %101, 1
%122 = sext i32 %121 to i64
br label %123
123: ; preds = %116, %113
%124 = phi i64 [ %122, %116 ], [ %104, %113 ]
%125 = shl i64 %106, 32
%126 = ashr exact i64 %125, 32
br label %127
127: ; preds = %127, %123
%128 = phi i64 [ %134, %127 ], [ %124, %123 ]
%129 = getelementptr inbounds double, double* %0, i64 %128
%130 = load double, double* %129
%131 = fcmp ole double %130, %97
%132 = icmp slt i64 %128, %126
%133 = select i1 %131, i1 %132, i1 false
%134 = add nsw i64 %128, 1
br i1 %133, label %127, label %135
135: ; preds = %127
%136 = trunc i64 %128 to i32
br i1 %132, label %137, label %142
137: ; preds = %135
store double %130, double* %114
%138 = getelementptr inbounds i32, i32* %2, i64 %128
%139 = load i32, i32* %138
%140 = getelementptr inbounds i32, i32* %2, i64 %106
store i32 %139, i32* %140
%141 = add nsw i32 %115, -1
br label %142
142: ; preds = %137, %135
%143 = phi i32 [ %141, %137 ], [ %115, %135 ]
%144 = icmp sgt i32 %143, %136
br i1 %144, label %100, label %145
145: ; preds = %142
%146 = trunc i64 %128 to i32
%147 = shl i64 %128, 32
%148 = ashr exact i64 %147, 32
%149 = getelementptr inbounds double, double* %0, i64 %148
store double %97, double* %149
%150 = getelementptr inbounds i32, i32* %2, i64 %148
store i32 %99, i32* %150
%151 = add nsw i32 %146, 1
%152 = add nsw i32 %88, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [300 x i32], [300 x i32]* %4, i64 0, i64 %153
store i32 %151, i32* %154
%155 = getelementptr inbounds [300 x i32], [300 x i32]* %5, i64 0, i64 %153
store i32 %86, i32* %155
store i32 %146, i32* %91
%156 = sub nsw i32 %86, %151
%157 = sub nsw i32 %146, %87
%158 = icmp sgt i32 %156, %157
br i1 %158, label %159, label %162
159: ; preds = %145
store i32 %87, i32* %154
store i32 %151, i32* %90
store i32 %146, i32* %155
store i32 %86, i32* %91
br label %162
160: ; preds = %85
%161 = add nsw i32 %88, -1
br label %162
162: ; preds = %145, %159, %160
%163 = phi i32 [ %152, %159 ], [ %152, %145 ], [ %161, %160 ]
%164 = icmp sgt i32 %163, -1
br i1 %164, label %165, label %171
165: ; preds = %162
%166 = zext i32 %163 to i64
%167 = getelementptr inbounds [300 x i32], [300 x i32]* %4, i64 0, i64 %166
%168 = load i32, i32* %167
%169 = getelementptr inbounds [300 x i32], [300 x i32]* %5, i64 0, i64 %166
%170 = load i32, i32* %169
br label %85
171: ; preds = %162
ret void
}