#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ RAND_MAX;
int atoi(char *);
int /*<<< orphan*/ iquicksort_I(int *, int *, int);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ putchar(char);
double rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int *vrandi(int, int, int);
int main(int argc, char *argv[]) {
  srand(time(NULL));
  for (int i = 0; i < argc; ++i)
    printf("argv[%d]: %s   ", i, argv[i]);
  putchar('\n');
  printf("breaking ties with random ranks\n");
  int max = atoi(argv[1]);
  int n = atoi(argv[2]);
  printf("random vector:  max: %d   n: %d\n", max, n);
  int *x = vrandi(10, max, n);
  for (int i = 0; i < n; ++i)
    printf("%d    ", x[i]);
  putchar('\n');
  int *indx = (int *)malloc(n * sizeof(int));
  for (int i = 0; i < n; ++i)
    indx[i] = i;
  iquicksort_I(x, indx, n);
  double *result = (double *)malloc(n * sizeof(double));
  double *ranks = (double *)malloc(n * sizeof(double));
  int b = x[0];
  int ib = 0;
  int i;
  for (i = 1; i < n; ++i) {
    if (x[i] != b) {
      if (ib < i - 1) {
        int tn = i - ib;
        int *t = (int *)malloc(tn * sizeof(int));
        int j;
        for (j = 0; j < tn; ++j)
          t[j] = j;
        for (j = ib; j < i - 1; ++j) {
          int k = (int)(tn * (rand() / (double)RAND_MAX));
          printf("j: %d, k rnd index: %d  "
                 "MIDDLE"
                 "\n",
                 j, k);
          ranks[j] = (double)(t[k] + ib + 1);
          t[k] = t[--tn];
        }
        int k = t[0] + ib + 1;
        printf("j: %d, last tie index: %d  "
               "MIDDLE"
               "\n",
               j, k);
        ranks[j] = k;
      } else {
        ranks[ib] = ib + 1;
      }
      b = x[i];
      ib = i;
    }
  }
  if (ib == i - 1)
    ranks[ib] = i;
  else {
    int tn = i - ib;
    int *t = (int *)malloc(tn * sizeof(int));
    int j;
    for (j = 0; j < tn; ++j)
      t[j] = j;
    for (j = ib; j < i - 1; ++j) {
      int k = (int)(tn * (rand() / (double)RAND_MAX));
      printf("j: %d, k rnd index: %d  "
             "FINAL"
             "\n",
             j, k);
      ranks[j] = (double)(t[k] + ib + 1);
      t[k] = t[--tn];
    }
    int k = t[0] + ib + 1;
    printf("j: %d, last tie index: %d  "
           "FINAL"
           "\n",
           j, k);
    ranks[j] = k;
  }
  for (int i = 0; i < n; ++i)
    result[indx[i]] = ranks[i];
  printf("reorder ranks into original order of vector:\n");
  for (int i = 0; i < n; ++i)
    printf("%.1f   ", result[i]);
  putchar('\n');
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xor    %eax,%eax
mov    %eax,%edi
call   1080 <time@plt>
mov    %eax,%edi
call   1070 <srand@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11f7 <main+0x67>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xe1e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c0 <main+0x30>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xe08(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   10a0 <atoi@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xdf5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    $0xa,%edi
call   1060 <vrandi@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1291 <main+0x101>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xdd6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    125e <main+0xce>
mov    $0xa,%edi
call   1030 <putchar@plt>
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12dd <main+0x14d>
mov    -0x3c(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12b5 <main+0x125>
mov    -0x28(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <iquicksort_I@plt>
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14d1 <main+0x341>
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x54(%rbp),%eax
je     14be <main+0x32e>
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1493 <main+0x303>
mov    -0x5c(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x60(%rbp)
movslq -0x60(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    13a6 <main+0x216>
mov    -0x6c(%rbp),%edx
mov    -0x68(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    137e <main+0x1ee>
mov    -0x58(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1459 <main+0x2c9>
cvtsi2sdl -0x60(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    $0x0,%al
call   10b0 <rand@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x2c05(%rip),%rax
cvtsi2sdq (%rax),%xmm2
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%esi
mov    -0x70(%rbp),%edx
lea    0xc55(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13ac <main+0x21c>
mov    -0x68(%rbp),%rax
mov    (%rax),%eax
add    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x6c(%rbp),%esi
mov    -0x74(%rbp),%edx
lea    0xc04(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cvtsi2sdl -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14aa <main+0x31a>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    14c3 <main+0x333>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    132a <main+0x19a>
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14f9 <main+0x369>
cvtsi2sdl -0x5c(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    166b <main+0x4db>
mov    -0x5c(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x78(%rbp)
movslq -0x78(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1556 <main+0x3c6>
mov    -0x84(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    151f <main+0x38f>
mov    -0x58(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1627 <main+0x497>
cvtsi2sdl -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    $0x0,%al
call   10b0 <rand@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x2a4f(%rip),%rax
cvtsi2sdq (%rax),%xmm2
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%esi
mov    -0x88(%rbp),%edx
lea    0xad9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x80(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x58(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x50(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x78(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x80(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    155f <main+0x3cf>
mov    -0x80(%rbp),%rax
mov    (%rax),%eax
add    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x84(%rbp),%esi
mov    -0x8c(%rbp),%edx
lea    0xa6f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cvtsi2sdl -0x8c(%rbp),%xmm0
ff
mov    -0x50(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16c0 <main+0x530>
mov    -0x50(%rbp),%rax
movslq -0x90(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0x90(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1675 <main+0x4e5>
lea    0xa16(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1719 <main+0x589>
mov    -0x48(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xa0d(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    16d8 <main+0x548>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rsi,%r15
mov    %edi,%ebp
xor    %edi,%edi
call   1090 <time@plt>
mov    %eax,%edi
call   1080 <srand@plt>
test   %ebp,%ebp
jle    11e9 <main+0x49>
mov    %ebp,%ebx
lea    0xec2(%rip),%r14
xor    %ebp,%ebp
mov    (%r15,%rbp,8),%rdx
mov    %r14,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    11d0 <main+0x30>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xf5a(%rip),%rdi
call   1050 <puts@plt>
mov    0x8(%r15),%rdi
call   10b0 <atoi@plt>
mov    %eax,%ebp
mov    0x10(%r15),%rdi
call   10b0 <atoi@plt>
mov    %eax,%ebx
lea    0xe84(%rip),%rdi
mov    %ebp,%esi
mov    %eax,%edx
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
mov    %ebp,%esi
mov    %ebx,%edx
call   1070 <vrandi@plt>
mov    %rax,%r12
mov    %ebx,%r13d
mov    %rbx,%rax
mov    %rbx,0x10(%rsp)
test   %ebx,%ebx
jle    1267 <main+0xc7>
lea    0xe73(%rip),%rbx
xor    %ebp,%ebp
mov    (%r12,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1250 <main+0xb0>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rsp),%rbx
lea    0x0(,%rbx,4),%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
test   %ebx,%ebx
jle    140d <main+0x26d>
cmp    $0x8,%ebx
jae    1299 <main+0xf9>
xor    %eax,%eax
jmp    1400 <main+0x260>
mov    %r13d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    12c8 <main+0x128>
movdqa 0xd3f(%rip),%xmm0
xor    %esi,%esi
jmp    13a0 <main+0x200>
and    $0xfffffffffffffffc,%rdx
movdqa 0xd2c(%rip),%xmm0
xor    %esi,%esi
movdqa 0xd31(%rip),%xmm8
movdqa 0xd38(%rip),%xmm9
movdqa 0xd3f(%rip),%xmm10
movdqa 0xd47(%rip),%xmm4
movdqa 0xd4f(%rip),%xmm5
movdqa 0xd57(%rip),%xmm6
movdqa 0xd5f(%rip),%xmm7
movdqa 0xd67(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r14,%rsi,4)
movdqu %xmm2,0x10(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r14,%rsi,4)
movdqu %xmm3,0x30(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r14,%rsi,4)
movdqu %xmm3,0x50(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r14,%rsi,4)
movdqu %xmm3,0x70(%r14,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1320 <main+0x180>
test   %rcx,%rcx
je     13f0 <main+0x250>
lea    (%r14,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xc55(%rip),%xmm1
movdqa 0xc5d(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    13d0 <main+0x230>
cmp    %r13,%rax
je     140d <main+0x26d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    1400 <main+0x260>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <iquicksort_I@plt>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,8),%ebx
mov    %ebx,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
mov    0x10(%rsp),%rbx
call   10a0 <malloc@plt>
cmp    $0x2,%ebx
mov    %r13,0x40(%rsp)
mov    %r15,0x28(%rsp)
mov    %rax,0x18(%rsp)
jl     1783 <main+0x5e3>
mov    (%r12),%edx
lea    -0x1(%rbx),%r8d
mov    $0x1,%esi
xor    %ebp,%ebp
xor    %ebx,%ebx
mov    %r14,0x20(%rsp)
mov    %r12,0x50(%rsp)
mov    %r8d,0x3c(%rsp)
jmp    1494 <main+0x2f4>
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%ecx
add    $0x1,%rsi
add    $0x1,%ebp
mov    %ecx,%edx
cmp    %r8d,%ebp
je     178a <main+0x5ea>
mov    (%r12,%rsi,4),%ecx
cmp    %edx,%ecx
je     1480 <main+0x2e0>
mov    %r13,%rdi
lea    -0x1(%rsi),%rdx
movslq %ebx,%r13
cmp    %r13,%rdx
jle    1530 <main+0x390>
mov    %ebp,0xc(%rsp)
mov    %esi,%ebp
sub    %ebx,%ebp
lea    0x0(,%rbp,4),%edi
mov    %rsi,0x48(%rsp)
call   10a0 <malloc@plt>
movdqa 0xbaf(%rip),%xmm10
movdqa 0xb96(%rip),%xmm9
movdqa 0xb7d(%rip),%xmm8
movdqa 0xb65(%rip),%xmm7
movdqa 0xb4d(%rip),%xmm6
movdqa 0xb35(%rip),%xmm5
movdqa 0xb1d(%rip),%xmm4
movdqa 0xb05(%rip),%xmm3
mov    0x48(%rsp),%r8
mov    %rax,%r12
test   %ebp,%ebp
jle    168d <main+0x4ed>
cmp    $0x8,%ebp
jae    154b <main+0x3ab>
xor    %eax,%eax
jmp    1675 <main+0x4d5>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r13),%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,(%rax,%r13,8)
mov    %esi,%ebx
mov    %rdi,%r13
jmp    1482 <main+0x2e2>
mov    %ebp,%ecx
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
cmp    $0x18,%rsi
jae    1576 <main+0x3d6>
xor    %edi,%edi
movdqa 0xa8f(%rip),%xmm0
jmp    1620 <main+0x480>
mov    %r8d,%esi
sub    %ebx,%esi
and    $0xfffffff8,%esi
add    $0xfffffffffffffff8,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
movdqa 0xa68(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,(%r12,%rdi,4)
movdqu %xmm1,0x10(%r12,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
movdqu %xmm1,0x20(%r12,%rdi,4)
movdqu %xmm2,0x30(%r12,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
movdqu %xmm1,0x40(%r12,%rdi,4)
movdqu %xmm2,0x50(%r12,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm8,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqu %xmm1,0x60(%r12,%rdi,4)
movdqu %xmm2,0x70(%r12,%rdi,4)
add    $0x20,%rdi
paddd  %xmm10,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    15a0 <main+0x400>
test   $0x3,%dl
je     1670 <main+0x4d0>
lea    (%r12,%rdi,4),%rdx
add    $0x10,%rdx
mov    %r8d,%esi
sub    %ebx,%esi
and    $0x18,%sil
add    $0xf8,%sil
shr    $0x3,%sil
add    $0x1,%sil
movzbl %sil,%esi
and    $0x3,%esi
shl    $0x5,%rsi
xor    %edi,%edi
nop
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm1,(%rdx,%rdi,1)
paddd  %xmm4,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1650 <main+0x4b0>
cmp    %rcx,%rax
je     168d <main+0x4ed>
mov    %r8d,%ecx
sub    %ebx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %eax,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1680 <main+0x4e0>
lea    0x1(%rbx),%eax
mov    %eax,0x8(%rsp)
mov    %r8d,%r14d
sub    %ebx,%r14d
movslq %r14d,%rax
lea    (%r12,%rax,4),%rbp
add    $0xfffffffffffffffc,%rbp
mov    0x18(%rsp),%rax
lea    (%rax,%r13,8),%r15
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
call   10c0 <rand@plt>
mov    0x291c(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2sdq (%rax),%xmm1
divsd  %xmm1,%xmm0
mulsd  0x30(%rsp),%xmm0
cvttsd2si %xmm0,%r13d
lea    0x9de(%rip),%rdi
mov    %ebx,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1060 <printf@plt>
movslq %r13d,%rax
mov    (%r12,%rax,4),%ecx
add    0x8(%rsp),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,(%r15)
mov    0x0(%rbp),%ecx
mov    %ecx,(%r12,%rax,4)
add    $0xffffffff,%r14d
add    $0xfffffffffffffffc,%rbp
add    $0x8,%r15
add    $0x1,%ebx
cmp    %ebx,0xc(%rsp)
jne    16b0 <main+0x510>
mov    0x8(%rsp),%ebx
add    (%r12),%ebx
lea    0x9b0(%rip),%rdi
mov    0xc(%rsp),%ebp
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <printf@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mov    %ebp,%ecx
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rsp),%r12
mov    0x48(%rsp),%rsi
mov    (%r12,%rsi,4),%ecx
mov    %esi,%ebx
mov    0x40(%rsp),%r13
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%r15
mov    0x3c(%rsp),%r8d
jmp    1482 <main+0x2e2>
xor    %ebx,%ebx
mov    $0x1,%esi
lea    -0x1(%rsi),%ecx
cmp    %ecx,%ebx
je     1a22 <main+0x882>
mov    %ecx,0x8(%rsp)
mov    %r13,%r12
mov    %rsi,%r13
mov    %esi,%r15d
sub    %ebx,%r15d
lea    0x0(,%r15,4),%edi
call   10a0 <malloc@plt>
mov    %rax,%rsi
test   %r15d,%r15d
jle    192c <main+0x78c>
mov    %r15d,%eax
cmp    $0x8,%r15d
jae    17ce <main+0x62e>
xor    %ecx,%ecx
jmp    1920 <main+0x780>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    17fc <main+0x65c>
movdqa 0x80b(%rip),%xmm0
xor    %edi,%edi
jmp    18c8 <main+0x728>
and    $0xfffffffffffffffc,%rdx
movdqa 0x7f8(%rip),%xmm0
xor    %edi,%edi
movdqa 0x7fd(%rip),%xmm8
movdqa 0x804(%rip),%xmm9
movdqa 0x80b(%rip),%xmm10
movdqa 0x813(%rip),%xmm4
movdqa 0x81b(%rip),%xmm5
movdqa 0x823(%rip),%xmm6
movdqa 0x82b(%rip),%xmm7
movdqa 0x833(%rip),%xmm1
nopl   (%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rsi,%rdi,4)
movdqu %xmm2,0x10(%rsi,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rsi,%rdi,4)
movdqu %xmm3,0x30(%rsi,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rsi,%rdi,4)
movdqu %xmm3,0x50(%rsi,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rsi,%rdi,4)
movdqu %xmm3,0x70(%rsi,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    1850 <main+0x6b0>
test   %rbp,%rbp
je     1910 <main+0x770>
lea    (%rsi,%rdi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbp
xor    %edi,%edi
movdqa 0x72d(%rip),%xmm1
movdqa 0x735(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm3,(%rdx,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    18f0 <main+0x750>
cmp    %rax,%rcx
je     192c <main+0x78c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1920 <main+0x780>
lea    0x1(%rbx),%edx
cmp    0x8(%rsp),%ebx
jge    19ff <main+0x85f>
mov    %r14,0x20(%rsp)
movslq %ebx,%rax
mov    %r13d,%ecx
sub    %rax,%rcx
lea    (%rsi,%rcx,4),%r14
add    $0xfffffffffffffffc,%r14
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r13
mov    %edx,0xc(%rsp)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
mov    %r15,%r12
mov    %rsi,%r15
call   10c0 <rand@plt>
mov    0x2666(%rip),%rax
xorps  %xmm1,%xmm1
cvtsi2sdq (%rax),%xmm1
divsd  %xmm1,%xmm0
mulsd  0x30(%rsp),%xmm0
cvttsd2si %xmm0,%ebp
lea    0x76c(%rip),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r15,%rsi
mov    %r12,%r15
mov    0xc(%rsp),%edx
movslq %ebp,%rax
mov    (%rsi,%rax,4),%ecx
add    %edx,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x0(%r13)
mov    (%r14),%ecx
mov    %ecx,(%rsi,%rax,4)
add    $0xffffffff,%r15d
add    $0xfffffffffffffffc,%r14
add    $0x8,%r13
add    $0x1,%ebx
cmp    $0x1,%r15d
jne    1960 <main+0x7c0>
mov    0x8(%rsp),%eax
mov    %eax,%ebx
mov    0x40(%rsp),%r13
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%r15
jmp    1a07 <main+0x867>
mov    0x28(%rsp),%r15
mov    %r12,%r13
add    (%rsi),%edx
lea    0x71a(%rip),%rdi
mov    %ebx,%esi
mov    %edx,%ebp
xor    %eax,%eax
call   1060 <printf@plt>
mov    %ebp,%esi
mov    0x18(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
movslq %ebx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rsp),%r12
test   %r12d,%r12d
jle    1a4f <main+0x8af>
lea    -0x1(%r13),%rcx
mov    %r13d,%ebx
and    $0x3,%ebx
cmp    $0x3,%rcx
jae    1a60 <main+0x8c0>
xor    %ecx,%ecx
jmp    1abb <main+0x91b>
lea    0x71e(%rip),%rdi
call   1050 <puts@plt>
jmp    1b29 <main+0x989>
mov    %r13d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm0
movslq (%r14,%rcx,4),%rsi
movsd  %xmm0,(%r15,%rsi,8)
movsd  0x8(%rax,%rcx,8),%xmm0
movslq 0x4(%r14,%rcx,4),%rsi
movsd  %xmm0,(%r15,%rsi,8)
movsd  0x10(%rax,%rcx,8),%xmm0
movslq 0x8(%r14,%rcx,4),%rsi
movsd  %xmm0,(%r15,%rsi,8)
movsd  0x18(%rax,%rcx,8),%xmm0
movslq 0xc(%r14,%rcx,4),%rsi
movsd  %xmm0,(%r15,%rsi,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1a70 <main+0x8d0>
test   %rbx,%rbx
je     1ae8 <main+0x948>
lea    (%r14,%rcx,4),%rdx
lea    (%rax,%rcx,8),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,8),%xmm0
movslq (%rdx,%rsi,4),%rdi
movsd  %xmm0,(%r15,%rdi,8)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1ad0 <main+0x930>
lea    0x685(%rip),%rdi
call   1050 <puts@plt>
test   %r12d,%r12d
jle    1b29 <main+0x989>
xor    %ebp,%ebp
lea    0x64a(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rbp,8),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1b10 <main+0x970>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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