void psrs_sort(long long *a, int n) {
  if (n > 1) {
    if (n <= 55) {
      insertion_sort(a, n);
    } else if (n <= 10000) {
      merge_sort(a, n);
    } else {
      int p, size, rsize, sample_size;
      long long *sample, *pivots;
      int *partition_borders, *bucket_sizes, *result_positions;
      long long **loc_a_ptrs;
      p = omp_get_max_threads();
      p = p * p * p;
      if (p > n) {
        p = floor(pow(n, 0.33));
        p -= p % 2;
      } else {
        p = omp_get_max_threads();
        p -= p % 2;
      }
      omp_set_num_threads(p);
      size = (n + p - 1) / p;
      rsize = (size + p - 1) / p;
      sample_size = p * (p - 1);
      loc_a_ptrs = malloc(p * sizeof(long long *));
      sample = malloc(sample_size * sizeof(long long));
      partition_borders = malloc(p * (p + 1) * sizeof(int));
      bucket_sizes = malloc(p * sizeof(int));
      result_positions = malloc(p * sizeof(int));
      pivots = malloc((p - 1) * sizeof(long long));
#pragma omp parallel
      {
        int i, j, max, thread_num, start, end, loc_size, offset,
            this_result_size;
        long long *loc_a, *this_result, *current_a;
        thread_num = omp_get_thread_num();
        start = thread_num * size;
        end = start + size - 1;
        if (end >= n)
          end = n - 1;
        loc_size = (end - start + 1);
        end = end % size;
        loc_a = malloc(loc_size * sizeof(long long));
        memcpy(loc_a, a + start, loc_size * sizeof(long long));
        loc_a_ptrs[thread_num] = loc_a;
        sortll(loc_a, loc_size);
        offset = thread_num * (p - 1) - 1;
        for (i = 1; i < p; i++) {
          if (i * rsize <= end) {
            sample[offset + i] = loc_a[i * rsize - 1];
          } else {
            sample[offset + i] = loc_a[end];
          }
        }
#pragma omp barrier
#pragma omp single
        {
          merge_sort(sample, sample_size);
          for (i = 0; i < p - 1; i++) {
            pivots[i] = sample[i * p + p / 2];
          }
        }
#pragma omp barrier
        offset = thread_num * (p + 1);
        partition_borders[offset] = 0;
        partition_borders[offset + p] = end + 1;
        calc_partition_borders(loc_a, 0, loc_size - 1, partition_borders,
                               offset, pivots, 1, p - 1);
#pragma omp barrier
        max = p * (p + 1);
        bucket_sizes[thread_num] = 0;
        for (i = thread_num; i < max; i += p + 1) {
          bucket_sizes[thread_num] +=
              partition_borders[i + 1] - partition_borders[i];
        }
#pragma omp barrier
#pragma omp single
        {
          result_positions[0] = 0;
          for (i = 1; i < p; i++) {
            result_positions[i] = bucket_sizes[i - 1] + result_positions[i - 1];
          }
        }
#pragma omp barrier
        this_result = a + result_positions[thread_num];
        if (thread_num == p - 1) {
          this_result_size = n - result_positions[thread_num];
        } else {
          this_result_size =
              result_positions[thread_num + 1] - result_positions[thread_num];
        }
        this_result = a + result_positions[thread_num];
        for (i = 0, j = 0; i < p; i++) {
          int low, high, partition_size;
          offset = i * (p + 1) + thread_num;
          low = partition_borders[offset];
          high = partition_borders[offset + 1];
          partition_size = (high - low);
          if (partition_size > 0) {
            memcpy(this_result + j, &(loc_a_ptrs[i][low]),
                   partition_size * sizeof(long long));
            j += partition_size;
          }
        }
        sortll(this_result, this_result_size);
#pragma omp barrier
        free(loc_a);
      }
      free(loc_a_ptrs);
      free(sample);
      free(partition_borders);
      free(bucket_sizes);
      free(result_positions);
      free(pivots);
    }
  }
}


x86 assembly (clang, -O0):
<psrs_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jle    17a4 <psrs_sort+0x5e4>
cmpl   $0x37,-0xc(%rbp)
jg     11f9 <psrs_sort+0x39>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   10d0 <insertion_sort@plt>
jmp    179f <psrs_sort+0x5df>
cmpl   $0x2710,-0xc(%rbp)
jg     1219 <psrs_sort+0x59>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1080 <merge_sort@plt>
jmp    179a <psrs_sort+0x5da>
mov    $0x0,%al
call   1090 <omp_get_max_threads@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1273 <psrs_sort+0xb3>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xdb6(%rip),%xmm1
call   10b0 <pow@plt>
call   10e0 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x10(%rbp)
jmp    1290 <psrs_sort+0xd0>
mov    $0x0,%al
call   1090 <omp_get_max_threads@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%edi
mov    $0x0,%al
call   1070 <omp_set_num_threads@plt>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x10(%rbp)
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x10(%rbp)
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
add    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1374 <psrs_sort+0x1b4>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
sub    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x68(%rbp)
movslq -0x6c(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x64(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x6c(%rbp),%rdx
shl    $0x3,%rdx
call   1050 <memcpy@plt>
mov    -0x80(%rbp),%rdx
mov    -0x50(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x80(%rbp),%rdi
mov    -0x6c(%rbp),%esi
mov    $0x0,%al
call   10c0 <sortll@plt>
mov    -0x60(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1469 <psrs_sort+0x2a9>
mov    -0x54(%rbp),%eax
imul   -0x18(%rbp),%eax
cmp    -0x68(%rbp),%eax
jg     1439 <psrs_sort+0x279>
mov    -0x80(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1456 <psrs_sort+0x296>
mov    -0x80(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    145b <psrs_sort+0x29b>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13f2 <psrs_sort+0x232>
mov    -0x28(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    $0x0,%al
call   1080 <merge_sort@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14d8 <psrs_sort+0x318>
mov    -0x28(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x54(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x10(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0xa8(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    147e <psrs_sort+0x2be>
mov    -0x60(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
add    $0x1,%edx
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rdi
mov    -0x6c(%rbp),%edx
sub    $0x1,%edx
mov    -0x38(%rbp),%rcx
mov    -0x70(%rbp),%r8d
mov    -0x30(%rbp),%r9
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
xor    %esi,%esi
movl   $0x1,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   10a0 <calc_partition_borders@plt>
mov    -0x10(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x60(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x60(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    15a6 <psrs_sort+0x3e6>
mov    -0x38(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x60(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1560 <psrs_sort+0x3a0>
mov    -0x48(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15fc <psrs_sort+0x43c>
mov    -0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    15b7 <psrs_sort+0x3f7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x60(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1641 <psrs_sort+0x481>
mov    -0xc(%rbp),%eax
mov    -0x48(%rbp),%rcx
movslq -0x60(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    165f <psrs_sort+0x49f>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
movslq -0x60(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x74(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x60(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    174a <psrs_sort+0x58a>
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
sub    -0x94(%rbp),%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jle    1737 <psrs_sort+0x577>
mov    -0x88(%rbp),%rdi
movslq -0x58(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x94(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x9c(%rbp),%rdx
shl    $0x3,%rdx
call   1050 <memcpy@plt>
mov    -0x9c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    173c <psrs_sort+0x57c>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    168b <psrs_sort+0x4cb>
mov    -0x88(%rbp),%rdi
mov    -0x74(%rbp),%esi
mov    $0x0,%al
call   10c0 <sortll@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
jmp    179f <psrs_sort+0x5df>
jmp    17a4 <psrs_sort+0x5e4>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<psrs_sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
cmp    $0x2,%esi
jl     11ff <psrs_sort+0x3f>
mov    %esi,%r12d
mov    %rdi,%rbx
cmp    $0x37,%esi
ja     1211 <psrs_sort+0x51>
mov    %rbx,%rdi
mov    %r12d,%esi
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10d0 <insertion_sort@plt>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x2710,%r12d
ja     1238 <psrs_sort+0x78>
mov    %rbx,%rdi
mov    %r12d,%esi
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <merge_sort@plt>
xor    %eax,%eax
call   1090 <omp_get_max_threads@plt>
mov    %eax,%ecx
imul   %eax,%ecx
imul   %eax,%ecx
cmp    %r12d,%ecx
mov    %rbx,0x68(%rsp)
jle    126e <psrs_sort+0xae>
cvtsi2sd %r12d,%xmm0
movsd  0xda2(%rip),%xmm1
call   10b0 <pow@plt>
call   10e0 <floor@plt>
cvttsd2si %xmm0,%eax
jmp    1275 <psrs_sort+0xb5>
xor    %eax,%eax
call   1090 <omp_get_max_threads@plt>
mov    %eax,0x5c(%rsp)
mov    %eax,%r13d
shr    $0x1f,%r13d
add    %eax,%r13d
and    $0xfffffffe,%r13d
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <omp_set_num_threads@plt>
lea    -0x1(%r13),%r15d
lea    (%r12,%r13,1),%eax
add    $0xffffffff,%eax
cltd
idiv   %r13d
mov    %eax,%r14d
mov    %r15d,%ebp
imul   %r13d,%ebp
movslq %r13d,%rbx
lea    0x0(,%rbx,8),%rdi
call   1060 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %ebp,0x34(%rsp)
movslq %ebp,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,0x18(%rsp)
lea    0x1(%r13),%eax
mov    %eax,0x64(%rsp)
imul   %r13d,%eax
mov    %eax,0x60(%rsp)
cltq
mov    %rax,0x90(%rsp)
lea    0x0(,%rax,4),%rdi
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbx,0x80(%rsp)
lea    0x0(,%rbx,4),%rbp
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %r15,0x8(%rsp)
movslq %r15d,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
mov    %eax,%r15d
mov    %eax,%ebx
imul   %r14d,%ebx
lea    (%rbx,%r14,1),%eax
cmp    %r12d,%eax
cmovg  %r12d,%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
sub    %ebx,%ecx
lea    0x1(%rcx),%edx
mov    %edx,0x38(%rsp)
cltd
mov    %r14,0x88(%rsp)
idiv   %r14d
mov    %edx,0x10(%rsp)
mov    %rcx,0x98(%rsp)
movslq %ecx,%rax
lea    0x8(,%rax,8),%rbp
mov    %rbp,%rdi
call   1060 <malloc@plt>
mov    %rax,%r14
movslq %ebx,%rax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %r14,%rdi
mov    %rbp,%rdx
call   1050 <memcpy@plt>
movslq %r15d,%rax
mov    %rax,0xa0(%rsp)
mov    0x50(%rsp),%rcx
mov    %r14,(%rcx,%rax,8)
mov    %r14,0x48(%rsp)
mov    %r14,%rdi
mov    0x38(%rsp),%esi
xor    %eax,%eax
call   10c0 <sortll@plt>
cmp    $0x1,%r13d
mov    %r13,0x40(%rsp)
jle    1520 <psrs_sort+0x360>
mov    0x34(%rsp),%esi
mov    0x8(%rsp),%rcx
imul   %ecx,%r15d
add    $0xffffffff,%r15d
mov    0x88(%rsp),%rax
add    %ecx,%eax
cltd
idiv   %r13d
movslq 0x10(%rsp),%rcx
movslq %eax,%r9
movslq %r15d,%rax
mov    %rax,0x38(%rsp)
mov    %r13d,%r10d
add    $0xffffffffffffffff,%r10
mov    $0x1,%r8d
cmp    $0x2,%r13d
mov    0x48(%rsp),%r15
je     149f <psrs_sort+0x2df>
mov    0x18(%rsp),%rax
mov    0x38(%rsp),%rdx
lea    (%rax,%rdx,8),%r14
add    $0x8,%r14
lea    (%r9,%r9,1),%rdx
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
neg    %r11
mov    $0x1,%r8d
mov    %rdx,%rbx
mov    %r9,%rax
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%rdi
cmp    %rcx,%rax
cmovg  %rcx,%rdi
mov    (%r15,%rdi,8),%rdi
lea    -0x1(%rbx),%rbp
cmp    %rcx,%rbx
cmovg  %rcx,%rbp
mov    %rdi,-0x8(%r14,%r8,8)
mov    (%r15,%rbp,8),%rdi
mov    %rdi,(%r14,%r8,8)
add    %rdx,%rax
add    %rdx,%rbx
lea    (%r11,%r8,1),%rdi
add    $0x2,%rdi
add    $0x2,%r8
cmp    $0x1,%rdi
jne    1460 <psrs_sort+0x2a0>
test   $0x1,%r10b
mov    0x18(%rsp),%rdi
je     14c9 <psrs_sort+0x309>
imul   %r8,%r9
lea    -0x1(%r9),%rax
cmp    %rcx,%r9
cmovg  %rcx,%rax
mov    (%r15,%rax,8),%rax
mov    0x38(%rsp),%rcx
add    %r8,%rcx
mov    %rax,(%rdi,%rcx,8)
xor    %eax,%eax
call   1080 <merge_sort@plt>
cmpl   $0x2,0x40(%rsp)
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%r9
mov    0x10(%rsp),%edi
jl     1613 <psrs_sort+0x453>
mov    0x5c(%rsp),%ecx
movslq %ecx,%r15
mov    0x40(%rsp),%r11
sub    %r11d,%ecx
shr    %r11d
mov    0x8(%rsp),%r14d
lea    -0x1(%r14),%rax
mov    %r14d,%r10d
and    $0x3,%r10d
movslq %ecx,%r8
cmp    $0x3,%rax
jae    1543 <psrs_sort+0x383>
xor    %esi,%esi
mov    0x20(%rsp),%r9
jmp    15bf <psrs_sort+0x3ff>
mov    0x18(%rsp),%rdi
mov    0x34(%rsp),%esi
xor    %eax,%eax
call   1080 <merge_sort@plt>
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%r9
mov    0x10(%rsp),%edi
jmp    1613 <psrs_sort+0x453>
and    $0xfffffffc,%r14d
lea    (%r11,%r15,2),%rbp
sub    %r8,%rbp
sub    %r8,%rbp
mov    %r15,%rax
shl    $0x5,%rax
mov    %r8,%rcx
shl    $0x5,%rcx
sub    %rcx,%rax
lea    (%r11,%r15,1),%rbx
sub    %r8,%rbx
lea    (%r15,%r15,2),%rcx
add    %r11,%rcx
lea    (%r8,%r8,2),%rdx
sub    %rdx,%rcx
xor    %esi,%esi
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdx,%r11,8),%rdi
mov    %rdi,(%r9,%rsi,8)
mov    (%rdx,%rbx,8),%rdi
mov    %rdi,0x8(%r9,%rsi,8)
mov    (%rdx,%rbp,8),%rdi
mov    %rdi,0x10(%r9,%rsi,8)
mov    (%rdx,%rcx,8),%rdi
mov    %rdi,0x18(%r9,%rsi,8)
add    $0x4,%rsi
add    %rax,%rdx
cmp    %rsi,%r14
jne    1590 <psrs_sort+0x3d0>
test   %r10,%r10
mov    0x28(%rsp),%r13
mov    0x10(%rsp),%edi
je     1613 <psrs_sort+0x453>
lea    (%r9,%rsi,8),%rax
mov    0x80(%rsp),%rcx
imul   %rsi,%rcx
shl    $0x3,%r11
lea    (%r11,%rcx,8),%rdx
mov    0x18(%rsp),%rcx
add    %rdx,%rcx
shl    $0x3,%r15
shl    $0x3,%r8
sub    %r8,%r15
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rcx),%rsi
mov    %rsi,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r15,%rcx
cmp    %rdx,%r10
jne    1600 <psrs_sort+0x440>
mov    0xa0(%rsp),%rbp
mov    %ebp,%eax
mov    0x64(%rsp),%r14d
imul   %r14d,%eax
movslq %eax,%r8
movl   $0x0,0x0(%r13,%r8,4)
add    $0x1,%edi
mov    0x40(%rsp),%r15
lea    (%r8,%r15,1),%eax
cltq
mov    %edi,0x0(%r13,%rax,4)
xor    %ebx,%ebx
mov    0x48(%rsp),%rdi
xor    %esi,%esi
mov    0x98(%rsp),%rdx
mov    %r13,%rcx
xor    %eax,%eax
push   0x8(%rsp)
push   $0x1
call   10a0 <calc_partition_borders@plt>
mov    %rbp,%r9
add    $0x10,%rsp
mov    0x78(%rsp),%rdi
movl   $0x0,(%rdi,%rbp,4)
movslq %r14d,%rbp
cmp    0x60(%rsp),%r9d
jge    16ad <psrs_sort+0x4ed>
mov    %r9,%rax
mov    0x90(%rsp),%rdx
xchg   %ax,%ax
mov    0x4(%r13,%rax,4),%ecx
sub    0x0(%r13,%rax,4),%ecx
add    %ecx,%ebx
add    %rbp,%rax
cmp    %rdx,%rax
jl     1690 <psrs_sort+0x4d0>
mov    %ebx,(%rdi,%r9,4)
mov    0x40(%rsp),%r15
mov    0x70(%rsp),%rbx
movl   $0x0,(%rbx)
cmp    $0x2,%r15d
mov    0x68(%rsp),%r8
jl     173f <psrs_sort+0x57f>
mov    %r15d,%ecx
lea    -0x1(%rcx),%rsi
add    $0xfffffffffffffffe,%rcx
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    16e2 <psrs_sort+0x522>
mov    $0x1,%edx
xor    %ecx,%ecx
jmp    171c <psrs_sort+0x55c>
and    $0xfffffffffffffffc,%rsi
xor    %ecx,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
add    (%rdi,%rdx,4),%ecx
mov    %ecx,0x4(%rbx,%rdx,4)
add    0x4(%rdi,%rdx,4),%ecx
mov    %ecx,0x8(%rbx,%rdx,4)
add    0x8(%rdi,%rdx,4),%ecx
mov    %ecx,0xc(%rbx,%rdx,4)
add    0xc(%rdi,%rdx,4),%ecx
mov    %ecx,0x10(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    16f0 <psrs_sort+0x530>
add    $0x1,%rdx
test   %rax,%rax
je     173f <psrs_sort+0x57f>
lea    (%rbx,%rdx,4),%rsi
lea    (%rdi,%rdx,4),%rdx
add    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
nop
add    (%rdx,%rdi,4),%ecx
mov    %ecx,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1730 <psrs_sort+0x570>
movslq (%rbx,%r9,4),%rax
cmp    0x8(%rsp),%r9d
je     174f <psrs_sort+0x58f>
mov    0x4(%rbx,%r9,4),%r12d
sub    %eax,%r12d
mov    %r12,0x10(%rsp)
lea    (%r8,%rax,8),%rax
mov    %rax,0x8(%rsp)
test   %r15d,%r15d
jle    17c2 <psrs_sort+0x602>
mov    %r15d,%r13d
mov    0x28(%rsp),%rax
lea    (%rax,%r9,4),%r14
add    $0x4,%r14
shl    $0x2,%rbp
xor    %r12d,%r12d
xor    %ebx,%ebx
jmp    178c <psrs_sort+0x5cc>
add    $0x1,%r12
add    %rbp,%r14
cmp    %r12,%r13
je     17c2 <psrs_sort+0x602>
movslq -0x4(%r14),%rsi
mov    (%r14),%r15d
sub    %esi,%r15d
jle    1780 <psrs_sort+0x5c0>
movslq %ebx,%rbx
mov    0x8(%rsp),%rax
lea    (%rax,%rbx,8),%rdi
shl    $0x3,%rsi
mov    0x50(%rsp),%rax
add    (%rax,%r12,8),%rsi
mov    %r15d,%edx
shl    $0x3,%rdx
call   1050 <memcpy@plt>
add    %r15d,%ebx
jmp    1780 <psrs_sort+0x5c0>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rsi
xor    %eax,%eax
call   10c0 <sortll@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @psrs_sort(i64* %0, i32 %1) {
%3 = alloca i64*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64*
%10 = alloca i64*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32*
%14 = alloca i64**
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i64*
%25 = alloca i64*
%26 = alloca i64*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
store i64* %0, i64** %3
store i32 %1, i32* %4
%30 = load i32, i32* %4
%31 = icmp sgt i32 %30, 1
br i1 %31, label %32, label %449
32: ; preds = %2
%33 = load i32, i32* %4
%34 = icmp sle i32 %33, 55
br i1 %34, label %35, label %39
35: ; preds = %32
%36 = load i64*, i64** %3
%37 = load i32, i32* %4
%38 = call i32 (i64*, i32, ...) bitcast (i32 (...)* @insertion_sort to i32 (i64*, i32, ...)*)(i64* %36, i32 %37)
br label %448
39: ; preds = %32
%40 = load i32, i32* %4
%41 = icmp sle i32 %40, 10000
br i1 %41, label %42, label %46
42: ; preds = %39
%43 = load i64*, i64** %3
%44 = load i32, i32* %4
%45 = call i32 (i64*, i32, ...) bitcast (i32 (...)* @merge_sort to i32 (i64*, i32, ...)*)(i64* %43, i32 %44)
br label %447
46: ; preds = %39
%47 = call i32 (...) @omp_get_max_threads()
store i32 %47, i32* %5
%48 = load i32, i32* %5
%49 = load i32, i32* %5
%50 = mul nsw i32 %48, %49
%51 = load i32, i32* %5
%52 = mul nsw i32 %50, %51
store i32 %52, i32* %5
%53 = load i32, i32* %5
%54 = load i32, i32* %4
%55 = icmp sgt i32 %53, %54
br i1 %55, label %56, label %66
56: ; preds = %46
%57 = load i32, i32* %4
%58 = sitofp i32 %57 to double
%59 = call double @pow(double %58, double 3.300000e-01)
%60 = call double @llvm.floor.f64(double %59)
%61 = fptosi double %60 to i32
store i32 %61, i32* %5
%62 = load i32, i32* %5
%63 = srem i32 %62, 2
%64 = load i32, i32* %5
%65 = sub nsw i32 %64, %63
store i32 %65, i32* %5
br label %72
66: ; preds = %46
%67 = call i32 (...) @omp_get_max_threads()
store i32 %67, i32* %5
%68 = load i32, i32* %5
%69 = srem i32 %68, 2
%70 = load i32, i32* %5
%71 = sub nsw i32 %70, %69
store i32 %71, i32* %5
br label %72
72: ; preds = %66, %56
%73 = load i32, i32* %5
%74 = call i32 (i32, ...) bitcast (i32 (...)* @omp_set_num_threads to i32 (i32, ...)*)(i32 %73)
%75 = load i32, i32* %4
%76 = load i32, i32* %5
%77 = add nsw i32 %75, %76
%78 = sub nsw i32 %77, 1
%79 = load i32, i32* %5
%80 = sdiv i32 %78, %79
store i32 %80, i32* %6
%81 = load i32, i32* %6
%82 = load i32, i32* %5
%83 = add nsw i32 %81, %82
%84 = sub nsw i32 %83, 1
%85 = load i32, i32* %5
%86 = sdiv i32 %84, %85
store i32 %86, i32* %7
%87 = load i32, i32* %5
%88 = load i32, i32* %5
%89 = sub nsw i32 %88, 1
%90 = mul nsw i32 %87, %89
store i32 %90, i32* %8
%91 = load i32, i32* %5
%92 = sext i32 %91 to i64
%93 = mul i64 %92, 8
%94 = call i8* @malloc(i64 %93)
%95 = bitcast i8* %94 to i64**
store i64** %95, i64*** %14
%96 = load i32, i32* %8
%97 = sext i32 %96 to i64
%98 = mul i64 %97, 8
%99 = call i8* @malloc(i64 %98)
%100 = bitcast i8* %99 to i64*
store i64* %100, i64** %9
%101 = load i32, i32* %5
%102 = load i32, i32* %5
%103 = add nsw i32 %102, 1
%104 = mul nsw i32 %101, %103
%105 = sext i32 %104 to i64
%106 = mul i64 %105, 4
%107 = call i8* @malloc(i64 %106)
%108 = bitcast i8* %107 to i32*
store i32* %108, i32** %11
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = mul i64 %110, 4
%112 = call i8* @malloc(i64 %111)
%113 = bitcast i8* %112 to i32*
store i32* %113, i32** %12
%114 = load i32, i32* %5
%115 = sext i32 %114 to i64
%116 = mul i64 %115, 4
%117 = call i8* @malloc(i64 %116)
%118 = bitcast i8* %117 to i32*
store i32* %118, i32** %13
%119 = load i32, i32* %5
%120 = sub nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = mul i64 %121, 8
%123 = call i8* @malloc(i64 %122)
%124 = bitcast i8* %123 to i64*
store i64* %124, i64** %10
%125 = call i32 (...) @omp_get_thread_num()
store i32 %125, i32* %18
%126 = load i32, i32* %18
%127 = load i32, i32* %6
%128 = mul nsw i32 %126, %127
store i32 %128, i32* %19
%129 = load i32, i32* %19
%130 = load i32, i32* %6
%131 = add nsw i32 %129, %130
%132 = sub nsw i32 %131, 1
store i32 %132, i32* %20
%133 = load i32, i32* %20
%134 = load i32, i32* %4
%135 = icmp sge i32 %133, %134
br i1 %135, label %136, label %139
136: ; preds = %72
%137 = load i32, i32* %4
%138 = sub nsw i32 %137, 1
store i32 %138, i32* %20
br label %139
139: ; preds = %136, %72
%140 = load i32, i32* %20
%141 = load i32, i32* %19
%142 = sub nsw i32 %140, %141
%143 = add nsw i32 %142, 1
store i32 %143, i32* %21
%144 = load i32, i32* %20
%145 = load i32, i32* %6
%146 = srem i32 %144, %145
store i32 %146, i32* %20
%147 = load i32, i32* %21
%148 = sext i32 %147 to i64
%149 = mul i64 %148, 8
%150 = call i8* @malloc(i64 %149)
%151 = bitcast i8* %150 to i64*
store i64* %151, i64** %24
%152 = load i64*, i64** %24
%153 = bitcast i64* %152 to i8*
%154 = load i64*, i64** %3
%155 = load i32, i32* %19
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i64, i64* %154, i64 %156
%158 = bitcast i64* %157 to i8*
%159 = load i32, i32* %21
%160 = sext i32 %159 to i64
%161 = mul i64 %160, 8
%162 = load i64*, i64** %24
%163 = load i64**, i64*** %14
%164 = load i32, i32* %18
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i64*, i64** %163, i64 %165
store i64* %162, i64** %166
%167 = load i64*, i64** %24
%168 = load i32, i32* %21
%169 = call i32 (i64*, i32, ...) bitcast (i32 (...)* @sortll to i32 (i64*, i32, ...)*)(i64* %167, i32 %168)
%170 = load i32, i32* %18
%171 = load i32, i32* %5
%172 = sub nsw i32 %171, 1
%173 = mul nsw i32 %170, %172
%174 = sub nsw i32 %173, 1
store i32 %174, i32* %22
store i32 1, i32* %15
br label %175
175: ; preds = %213, %139
%176 = load i32, i32* %15
%177 = load i32, i32* %5
%178 = icmp slt i32 %176, %177
br i1 %178, label %179, label %216
179: ; preds = %175
%180 = load i32, i32* %15
%181 = load i32, i32* %7
%182 = mul nsw i32 %180, %181
%183 = load i32, i32* %20
%184 = icmp sle i32 %182, %183
br i1 %184, label %185, label %200
185: ; preds = %179
%186 = load i64*, i64** %24
%187 = load i32, i32* %15
%188 = load i32, i32* %7
%189 = mul nsw i32 %187, %188
%190 = sub nsw i32 %189, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i64, i64* %186, i64 %191
%193 = load i64, i64* %192
%194 = load i64*, i64** %9
%195 = load i32, i32* %22
%196 = load i32, i32* %15
%197 = add nsw i32 %195, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i64, i64* %194, i64 %198
store i64 %193, i64* %199
br label %212
200: ; preds = %179
%201 = load i64*, i64** %24
%202 = load i32, i32* %20
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i64, i64* %201, i64 %203
%205 = load i64, i64* %204
%206 = load i64*, i64** %9
%207 = load i32, i32* %22
%208 = load i32, i32* %15
%209 = add nsw i32 %207, %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i64, i64* %206, i64 %210
store i64 %205, i64* %211
br label %212
212: ; preds = %200, %185
br label %213
213: ; preds = %212
%214 = load i32, i32* %15
%215 = add nsw i32 %214, 1
store i32 %215, i32* %15
br label %175
216: ; preds = %175
%217 = load i64*, i64** %9
%218 = load i32, i32* %8
%219 = call i32 (i64*, i32, ...) bitcast (i32 (...)* @merge_sort to i32 (i64*, i32, ...)*)(i64* %217, i32 %218)
store i32 0, i32* %15
br label %220
220: ; preds = %240, %216
%221 = load i32, i32* %15
%222 = load i32, i32* %5
%223 = sub nsw i32 %222, 1
%224 = icmp slt i32 %221, %223
br i1 %224, label %225, label %243
225: ; preds = %220
%226 = load i64*, i64** %9
%227 = load i32, i32* %15
%228 = load i32, i32* %5
%229 = mul nsw i32 %227, %228
%230 = load i32, i32* %5
%231 = sdiv i32 %230, 2
%232 = add nsw i32 %229, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i64, i64* %226, i64 %233
%235 = load i64, i64* %234
%236 = load i64*, i64** %10
%237 = load i32, i32* %15
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i64, i64* %236, i64 %238
store i64 %235, i64* %239
br label %240
240: ; preds = %225
%241 = load i32, i32* %15
%242 = add nsw i32 %241, 1
store i32 %242, i32* %15
br label %220
243: ; preds = %220
%244 = load i32, i32* %18
%245 = load i32, i32* %5
%246 = add nsw i32 %245, 1
%247 = mul nsw i32 %244, %246
store i32 %247, i32* %22
%248 = load i32*, i32** %11
%249 = load i32, i32* %22
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %248, i64 %250
store i32 0, i32* %251
%252 = load i32, i32* %20
%253 = add nsw i32 %252, 1
%254 = load i32*, i32** %11
%255 = load i32, i32* %22
%256 = load i32, i32* %5
%257 = add nsw i32 %255, %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %254, i64 %258
store i32 %253, i32* %259
%260 = load i64*, i64** %24
%261 = load i32, i32* %21
%262 = sub nsw i32 %261, 1
%263 = load i32*, i32** %11
%264 = load i32, i32* %22
%265 = load i64*, i64** %10
%266 = load i32, i32* %5
%267 = sub nsw i32 %266, 1
%268 = call i32 (i64*, i32, i32, i32*, i32, i64*, i32, i32, ...) bitcast (i32 (...)* @calc_partition_borders to i32 (i64*, i32, i32, i32*, i32, i64*, i32, i32, ...)*)(i64* %260, i32 0, i32 %262, i32* %263, i32 %264, i64* %265, i32 1, i32 %267)
%269 = load i32, i32* %5
%270 = load i32, i32* %5
%271 = add nsw i32 %270, 1
%272 = mul nsw i32 %269, %271
store i32 %272, i32* %17
%273 = load i32*, i32** %12
%274 = load i32, i32* %18
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32, i32* %273, i64 %275
store i32 0, i32* %276
%277 = load i32, i32* %18
store i32 %277, i32* %15
br label %278
278: ; preds = %301, %243
%279 = load i32, i32* %15
%280 = load i32, i32* %17
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %306
282: ; preds = %278
%283 = load i32*, i32** %11
%284 = load i32, i32* %15
%285 = add nsw i32 %284, 1
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i32, i32* %283, i64 %286
%288 = load i32, i32* %287
%289 = load i32*, i32** %11
%290 = load i32, i32* %15
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds i32, i32* %289, i64 %291
%293 = load i32, i32* %292
%294 = sub nsw i32 %288, %293
%295 = load i32*, i32** %12
%296 = load i32, i32* %18
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %295, i64 %297
%299 = load i32, i32* %298
%300 = add nsw i32 %299, %294
store i32 %300, i32* %298
br label %301
301: ; preds = %282
%302 = load i32, i32* %5
%303 = add nsw i32 %302, 1
%304 = load i32, i32* %15
%305 = add nsw i32 %304, %303
store i32 %305, i32* %15
br label %278
306: ; preds = %278
%307 = load i32*, i32** %13
%308 = getelementptr inbounds i32, i32* %307, i64 0
store i32 0, i32* %308
store i32 1, i32* %15
br label %309
309: ; preds = %331, %306
%310 = load i32, i32* %15
%311 = load i32, i32* %5
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %334
313: ; preds = %309
%314 = load i32*, i32** %12
%315 = load i32, i32* %15
%316 = sub nsw i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %314, i64 %317
%319 = load i32, i32* %318
%320 = load i32*, i32** %13
%321 = load i32, i32* %15
%322 = sub nsw i32 %321, 1
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds i32, i32* %320, i64 %323
%325 = load i32, i32* %324
%326 = add nsw i32 %319, %325
%327 = load i32*, i32** %13
%328 = load i32, i32* %15
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i32, i32* %327, i64 %329
store i32 %326, i32* %330
br label %331
331: ; preds = %313
%332 = load i32, i32* %15
%333 = add nsw i32 %332, 1
store i32 %333, i32* %15
br label %309
334: ; preds = %309
%335 = load i64*, i64** %3
%336 = load i32*, i32** %13
%337 = load i32, i32* %18
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %336, i64 %338
%340 = load i32, i32* %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i64, i64* %335, i64 %341
store i64* %342, i64** %25
%343 = load i32, i32* %18
%344 = load i32, i32* %5
%345 = sub nsw i32 %344, 1
%346 = icmp eq i32 %343, %345
br i1 %346, label %347, label %355
347: ; preds = %334
%348 = load i32, i32* %4
%349 = load i32*, i32** %13
%350 = load i32, i32* %18
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %349, i64 %351
%353 = load i32, i32* %352
%354 = sub nsw i32 %348, %353
store i32 %354, i32* %23
br label %368
355: ; preds = %334
%356 = load i32*, i32** %13
%357 = load i32, i32* %18
%358 = add nsw i32 %357, 1
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i32, i32* %356, i64 %359
%361 = load i32, i32* %360
%362 = load i32*, i32** %13
%363 = load i32, i32* %18
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i32, i32* %362, i64 %364
%366 = load i32, i32* %365
%367 = sub nsw i32 %361, %366
store i32 %367, i32* %23
br label %368
368: ; preds = %355, %347
%369 = load i64*, i64** %3
%370 = load i32*, i32** %13
%371 = load i32, i32* %18
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds i32, i32* %370, i64 %372
%374 = load i32, i32* %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i64, i64* %369, i64 %375
store i64* %376, i64** %25
store i32 0, i32* %15
store i32 0, i32* %16
br label %377
377: ; preds = %426, %368
%378 = load i32, i32* %15
%379 = load i32, i32* %5
%380 = icmp slt i32 %378, %379
br i1 %380, label %381, label %429
381: ; preds = %377
%382 = load i32, i32* %15
%383 = load i32, i32* %5
%384 = add nsw i32 %383, 1
%385 = mul nsw i32 %382, %384
%386 = load i32, i32* %18
%387 = add nsw i32 %385, %386
store i32 %387, i32* %22
%388 = load i32*, i32** %11
%389 = load i32, i32* %22
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds i32, i32* %388, i64 %390
%392 = load i32, i32* %391
store i32 %392, i32* %27
%393 = load i32*, i32** %11
%394 = load i32, i32* %22
%395 = add nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i32, i32* %393, i64 %396
%398 = load i32, i32* %397
store i32 %398, i32* %28
%399 = load i32, i32* %28
%400 = load i32, i32* %27
%401 = sub nsw i32 %399, %400
store i32 %401, i32* %29
%402 = load i32, i32* %29
%403 = icmp sgt i32 %402, 0
br i1 %403, label %404, label %425
404: ; preds = %381
%405 = load i64*, i64** %25
%406 = load i32, i32* %16
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i64, i64* %405, i64 %407
%409 = bitcast i64* %408 to i8*
%410 = load i64**, i64*** %14
%411 = load i32, i32* %15
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i64*, i64** %410, i64 %412
%414 = load i64*, i64** %413
%415 = load i32, i32* %27
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds i64, i64* %414, i64 %416
%418 = bitcast i64* %417 to i8*
%419 = load i32, i32* %29
%420 = sext i32 %419 to i64
%421 = mul i64 %420, 8
%422 = load i32, i32* %29
%423 = load i32, i32* %16
%424 = add nsw i32 %423, %422
store i32 %424, i32* %16
br label %425
425: ; preds = %404, %381
br label %426
426: ; preds = %425
%427 = load i32, i32* %15
%428 = add nsw i32 %427, 1
store i32 %428, i32* %15
br label %377
429: ; preds = %377
%430 = load i64*, i64** %25
%431 = load i32, i32* %23
%432 = call i32 (i64*, i32, ...) bitcast (i32 (...)* @sortll to i32 (i64*, i32, ...)*)(i64* %430, i32 %431)
%433 = load i64*, i64** %24
%434 = bitcast i64* %433 to i8*
%435 = load i64**, i64*** %14
%436 = bitcast i64** %435 to i8*
%437 = load i64*, i64** %9
%438 = bitcast i64* %437 to i8*
%439 = load i32*, i32** %11
%440 = bitcast i32* %439 to i8*
%441 = load i32*, i32** %12
%442 = bitcast i32* %441 to i8*
%443 = load i32*, i32** %13
%444 = bitcast i32* %443 to i8*
%445 = load i64*, i64** %10
%446 = bitcast i64* %445 to i8*
br label %447
447: ; preds = %429, %42
br label %448
448: ; preds = %447, %35
br label %449
449: ; preds = %448, %2
ret void
}

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