void sglib_int_array_quick_sort(int *a, int max) {
  {
    {
      int _i_, _j_, _p_, _stacki_, _start_, _end_;
      int _startStack_[64];
      int _endStack_[64];
      int _tmp_;
      _startStack_[0] = 0;
      _endStack_[0] = (max);
      _stacki_ = 1;
      while (_stacki_ > 0) {
        _stacki_--;
        _start_ = _startStack_[_stacki_];
        _end_ = _endStack_[_stacki_];
        while (_end_ - _start_ > 2) {
          _p_ = _start_;
          _i_ = _start_ + 1;
          _j_ = _end_ - 1;
          while (_i_ < _j_) {
            for (; _i_ <= _j_ &&
                   (((((a)[_i_])) > (((a)[_p_]))
                         ? 1
                         : ((((a)[_i_])) < (((a)[_p_])) ? -1 : 0))) <= 0;
                 _i_++)
              ;
            if (_i_ > _j_) {
              {
                int _sgl_aee_tmp_;
                _sgl_aee_tmp_ = (a)[(_j_)];
                (a)[(_j_)] = (a)[(_p_)];
                (a)[(_p_)] = _sgl_aee_tmp_;
              };
              _i_ = _j_;
            } else {
              for (; _i_ <= _j_ &&
                     (((((a)[_j_])) > (((a)[_p_]))
                           ? 1
                           : ((((a)[_j_])) < (((a)[_p_])) ? -1 : 0))) >= 0;
                   _j_--)
                ;
              if (_i_ > _j_) {
                {
                  int _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (a)[(_j_)];
                  (a)[(_j_)] = (a)[(_p_)];
                  (a)[(_p_)] = _sgl_aee_tmp_;
                };
                _i_ = _j_;
              } else if (_i_ < _j_) {
                {
                  int _sgl_aee_tmp_;
                  _sgl_aee_tmp_ = (a)[(_i_)];
                  (a)[(_i_)] = (a)[(_j_)];
                  (a)[(_j_)] = _sgl_aee_tmp_;
                };
                if (_i_ + 2 < _j_) {
                  _i_++;
                  _j_--;
                } else if (_i_ + 1 < _j_)
                  _i_++;
              }
            }
          }
          if (_i_ - _start_ > 1 && _end_ - _j_ > 1) {
            if (_i_ - _start_ < _end_ - _j_ - 1) {
              _startStack_[_stacki_] = _j_ + 1;
              _endStack_[_stacki_] = _end_;
              _stacki_++;
              _end_ = _i_;
            } else {
              _startStack_[_stacki_] = _start_;
              _endStack_[_stacki_] = _i_;
              _stacki_++;
              _start_ = _j_ + 1;
            }
          } else {
            if (_i_ - _start_ > 1) {
              _end_ = _i_;
            } else {
              _start_ = _j_ + 1;
            }
          }
        }
        if (_end_ - _start_ == 2) {
          if ((((((a)[_start_])) > (((a)[_end_ - 1]))
                    ? 1
                    : ((((a)[_start_])) < (((a)[_end_ - 1])) ? -1 : 0))) > 0) {
            {
              int _sgl_aee_tmp_;
              _sgl_aee_tmp_ = (a)[(_start_)];
              (a)[(_start_)] = (a)[(_end_ - 1)];
              (a)[(_end_ - 1)] = _sgl_aee_tmp_;
            };
          }
        }
      }
    };
  };
}


x86 assembly (clang, -O0):
<sglib_int_array_quick_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x130(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x230(%rbp)
movl   $0x1,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    15a1 <sglib_int_array_quick_sort+0x4a1>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x20(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    $0x2,%eax
jle    14d9 <sglib_int_array_quick_sort+0x3d9>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1411 <sglib_int_array_quick_sort+0x311>
jmp    1193 <sglib_int_array_quick_sort+0x93>
mov    -0x10(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x245(%rbp)
jg     120d <sglib_int_array_quick_sort+0x10d>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11d3 <sglib_int_array_quick_sort+0xd3>
mov    $0x1,%eax
mov    %eax,-0x24c(%rbp)
jmp    11fb <sglib_int_array_quick_sort+0xfb>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x24c(%rbp)
mov    -0x24c(%rbp),%eax
cmp    $0x0,%eax
setle  %al
mov    %al,-0x245(%rbp)
mov    -0x245(%rbp),%al
test   $0x1,%al
jne    1220 <sglib_int_array_quick_sort+0x120>
jmp    1233 <sglib_int_array_quick_sort+0x133>
jmp    1225 <sglib_int_array_quick_sort+0x125>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1193 <sglib_int_array_quick_sort+0x93>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1282 <sglib_int_array_quick_sort+0x182>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x238(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x238(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    140c <sglib_int_array_quick_sort+0x30c>
jmp    1287 <sglib_int_array_quick_sort+0x187>
mov    -0x10(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x24d(%rbp)
jg     1301 <sglib_int_array_quick_sort+0x201>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    12c7 <sglib_int_array_quick_sort+0x1c7>
mov    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    12ef <sglib_int_array_quick_sort+0x1ef>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x254(%rbp)
mov    -0x254(%rbp),%eax
cmp    $0x0,%eax
setge  %al
mov    %al,-0x24d(%rbp)
mov    -0x24d(%rbp),%al
test   $0x1,%al
jne    1314 <sglib_int_array_quick_sort+0x214>
jmp    1327 <sglib_int_array_quick_sort+0x227>
jmp    1319 <sglib_int_array_quick_sort+0x219>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1287 <sglib_int_array_quick_sort+0x187>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1376 <sglib_int_array_quick_sort+0x276>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x23c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x23c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1407 <sglib_int_array_quick_sort+0x307>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1402 <sglib_int_array_quick_sort+0x302>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x240(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x240(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x2,%eax
cmp    -0x14(%rbp),%eax
jge    13e0 <sglib_int_array_quick_sort+0x2e0>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    13fd <sglib_int_array_quick_sort+0x2fd>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jge    13f8 <sglib_int_array_quick_sort+0x2f8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13fd <sglib_int_array_quick_sort+0x2fd>
jmp    1402 <sglib_int_array_quick_sort+0x302>
jmp    1407 <sglib_int_array_quick_sort+0x307>
jmp    140c <sglib_int_array_quick_sort+0x30c>
jmp    1182 <sglib_int_array_quick_sort+0x82>
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    $0x1,%eax
jle    14ac <sglib_int_array_quick_sort+0x3ac>
mov    -0x24(%rbp),%eax
sub    -0x14(%rbp),%eax
cmp    $0x1,%eax
jle    14ac <sglib_int_array_quick_sort+0x3ac>
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1479 <sglib_int_array_quick_sort+0x379>
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x24(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    14a7 <sglib_int_array_quick_sort+0x3a7>
mov    -0x20(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x10(%rbp),%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14d4 <sglib_int_array_quick_sort+0x3d4>
mov    -0x10(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    $0x1,%eax
jle    14c6 <sglib_int_array_quick_sort+0x3c6>
mov    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    14cf <sglib_int_array_quick_sort+0x3cf>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14d4 <sglib_int_array_quick_sort+0x3d4>
jmp    115b <sglib_int_array_quick_sort+0x5b>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
cmp    $0x2,%eax
jne    159c <sglib_int_array_quick_sort+0x49c>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1519 <sglib_int_array_quick_sort+0x419>
mov    $0x1,%eax
mov    %eax,-0x258(%rbp)
jmp    1546 <sglib_int_array_quick_sort+0x446>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
xor    %eax,%eax
mov    $0xffffffff,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x258(%rbp)
mov    -0x258(%rbp),%eax
cmp    $0x0,%eax
jle    1597 <sglib_int_array_quick_sort+0x497>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x244(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x244(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    159c <sglib_int_array_quick_sort+0x49c>
jmp    112c <sglib_int_array_quick_sort+0x2c>
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sglib_int_array_quick_sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
movl   $0x0,0x90(%rsp)
mov    %esi,-0x70(%rsp)
mov    $0x1,%ecx
movabs $0xffffffff00000000,%r9
ff ff ff
movabs $0x100000000,%r14
jmp    114d <sglib_int_array_quick_sort+0x4d>
nopl   0x0(%rax,%rax,1)
mov    -0x78(%rsp),%rcx
test   %ecx,%ecx
jle    130d <sglib_int_array_quick_sort+0x20d>
add    $0xffffffff,%ecx
mov    0x90(%rsp,%rcx,4),%r10d
mov    -0x70(%rsp,%rcx,4),%r12d
mov    %r12d,%eax
sub    %r10d,%eax
cmp    $0x3,%eax
mov    %rcx,-0x78(%rsp)
jge    11c7 <sglib_int_array_quick_sort+0xc7>
mov    %r12d,%r13d
cmp    $0x2,%eax
jne    1140 <sglib_int_array_quick_sort+0x40>
movslq %r10d,%rax
mov    (%rdi,%rax,4),%ecx
movslq %r13d,%rdx
mov    -0x4(%rdi,%rdx,4),%esi
cmp    %esi,%ecx
jle    1140 <sglib_int_array_quick_sort+0x40>
add    $0xffffffffffffffff,%rdx
mov    %esi,(%rdi,%rax,4)
mov    %ecx,(%rdi,%rdx,4)
jmp    1140 <sglib_int_array_quick_sort+0x40>
mov    -0x78(%rsp),%rax
cltq
mov    %r10d,0x90(%rsp,%rax,4)
mov    %r13d,-0x70(%rsp,%rax,4)
add    $0x1,%eax
mov    %rax,-0x78(%rsp)
xchg   %ax,%ax
add    $0x1,%ecx
mov    %r12d,%r13d
mov    %ecx,%r10d
mov    %r13d,%eax
sub    %r10d,%eax
mov    %r13d,%r12d
cmp    $0x2,%eax
jle    1170 <sglib_int_array_quick_sort+0x70>
lea    0x1(%r10),%r13d
lea    -0x1(%r12),%ecx
cmp    %ecx,%r13d
jge    12c1 <sglib_int_array_quick_sort+0x1c1>
movslq %r10d,%r11
mov    (%rdi,%r11,4),%r8d
cmp    %ecx,%r13d
jg     12b0 <sglib_int_array_quick_sort+0x1b0>
movslq %r13d,%rdx
lea    (%rdi,%rdx,4),%rax
shl    $0x20,%rdx
mov    %r13d,%r15d
mov    %ecx,%ebp
not    %ebp
add    %r15,%rbp
xor    %esi,%esi
cmp    %r8d,(%rax,%rsi,4)
jg     1220 <sglib_int_array_quick_sort+0x120>
add    %r14,%rdx
add    $0x1,%rsi
mov    %esi,%ebx
add    %ebp,%ebx
jne    1200 <sglib_int_array_quick_sort+0x100>
jmp    12b0 <sglib_int_array_quick_sort+0x1b0>
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rsi,1),%r13
cmp    %r13d,%ecx
jl     12b0 <sglib_int_array_quick_sort+0x1b0>
movslq %ecx,%rbp
sar    $0x20,%rdx
mov    %rbp,%rax
shl    $0x20,%rax
add    $0x1,%rbp
nop
cmp    %r8d,-0x4(%rdi,%rbp,4)
jl     1260 <sglib_int_array_quick_sort+0x160>
add    %r9,%rax
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%rdx
jl     1240 <sglib_int_array_quick_sort+0x140>
jmp    12b0 <sglib_int_array_quick_sort+0x1b0>
nopl   0x0(%rax,%rax,1)
cmp    %ecx,%r13d
jge    128e <sglib_int_array_quick_sort+0x18e>
mov    (%rdi,%rdx,4),%ebp
sar    $0x1e,%rax
mov    (%rdi,%rax,1),%ebx
mov    %ebx,(%rdi,%rdx,4)
mov    %ebp,(%rdi,%rax,1)
lea    (%r15,%rsi,1),%rdx
add    $0x2,%edx
lea    (%r15,%rsi,1),%rax
add    $0x1,%rax
cmp    %ecx,%edx
jge    1299 <sglib_int_array_quick_sort+0x199>
add    $0xffffffff,%ecx
mov    %eax,%r13d
cmp    %ecx,%r13d
jl     11dc <sglib_int_array_quick_sort+0xdc>
jmp    12c1 <sglib_int_array_quick_sort+0x1c1>
cmp    %ecx,%eax
cmovl  %eax,%r13d
cmp    %ecx,%r13d
jl     11dc <sglib_int_array_quick_sort+0xdc>
jmp    12c1 <sglib_int_array_quick_sort+0x1c1>
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rdx
mov    (%rdi,%rdx,4),%eax
mov    %r8d,(%rdi,%rdx,4)
mov    %eax,(%rdi,%r11,4)
mov    %ecx,%r13d
mov    %r13d,%eax
sub    %r10d,%eax
cmp    $0x2,%eax
jl     11b0 <sglib_int_array_quick_sort+0xb0>
mov    %r12d,%edx
sub    %ecx,%edx
cmp    $0x2,%edx
jl     11b9 <sglib_int_array_quick_sort+0xb9>
add    $0xffffffff,%edx
cmp    %edx,%eax
jae    1192 <sglib_int_array_quick_sort+0x92>
add    $0x1,%ecx
mov    -0x78(%rsp),%rdx
movslq %edx,%rax
mov    %ecx,0x90(%rsp,%rax,4)
mov    %r12d,-0x70(%rsp,%rax,4)
add    $0x1,%edx
mov    %rdx,-0x78(%rsp)
jmp    11b9 <sglib_int_array_quick_sort+0xb9>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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