#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 */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ printf(char *);
void sort3(int n, float *arr, float *brr, float *crr) {
  int i, ir, j, jstack, k, l, istack[50];
  float a, b, c, temp;
  jstack = -1;
  l = 0;
  ir = n - 1;
  for (;;) {
    if ((ir - l) < 7) {
      for (j = l + 1; j <= ir; j++) {
        a = arr[j];
        b = brr[j];
        c = crr[j];
        for (i = j - 1; i >= l; i--) {
          if (arr[i] <= a)
            break;
          arr[i + 1] = arr[i];
          brr[i + 1] = brr[i];
          crr[i + 1] = crr[i];
        }
        i = 0;
        arr[i + 1] = a;
        brr[i + 1] = b;
        crr[i + 1] = c;
      }
      if (jstack < 0)
        break;
      ir = istack[jstack--];
      l = istack[jstack--];
    } else {
      k = (l + ir) >> 1;
      temp = (arr[k]);
      (arr[k]) = (arr[l + 1]);
      (arr[l + 1]) = temp;
      ;
      temp = (brr[k]);
      (brr[k]) = (brr[l + 1]);
      (brr[l + 1]) = temp;
      ;
      temp = (crr[k]);
      (crr[k]) = (crr[l + 1]);
      (crr[l + 1]) = temp;
      ;
      if (arr[l] > arr[ir]) {
        temp = (arr[l]);
        (arr[l]) = (arr[ir]);
        (arr[ir]) = temp;
        ;
        temp = (brr[l]);
        (brr[l]) = (brr[ir]);
        (brr[ir]) = temp;
        ;
        temp = (crr[l]);
        (crr[l]) = (crr[ir]);
        (crr[ir]) = temp;
        ;
      }
      if (arr[l + 1] > arr[ir]) {
        temp = (arr[l + 1]);
        (arr[l + 1]) = (arr[ir]);
        (arr[ir]) = temp;
        ;
        temp = (brr[l + 1]);
        (brr[l + 1]) = (brr[ir]);
        (brr[ir]) = temp;
        ;
        temp = (crr[l + 1]);
        (crr[l + 1]) = (crr[ir]);
        (crr[ir]) = temp;
        ;
      }
      if (arr[l] > arr[l + 1]) {
        temp = (arr[l]);
        (arr[l]) = (arr[l + 1]);
        (arr[l + 1]) = temp;
        ;
        temp = (brr[l]);
        (brr[l]) = (brr[l + 1]);
        (brr[l + 1]) = temp;
        ;
        temp = (crr[l]);
        (crr[l]) = (crr[l + 1]);
        (crr[l + 1]) = temp;
        ;
      }
      i = l + 1;
      j = ir;
      a = arr[l + 1];
      b = brr[l + 1];
      c = crr[l + 1];
      for (;;) {
        do
          i++;
        while (arr[j] < a);
        do
          j--;
        while (arr[j] > a);
        if (j < i)
          break;
        temp = (arr[i]);
        (arr[i]) = (arr[j]);
        (arr[j]) = temp;
        ;
        temp = (brr[i]);
        (brr[i]) = (brr[j]);
        (brr[j]) = temp;
        ;
        temp = (crr[i]);
        (crr[i]) = (crr[j]);
        (crr[j]) = temp;
        ;
      }
      arr[l + 1] = arr[j];
      arr[j] = a;
      brr[l + 1] = brr[j];
      brr[j] = b;
      crr[l + 1] = crr[j];
      crr[j] = c;
      if (jstack >= 50) {
        printf("NSTACK too small in sort3.");
        exit(1);
      }
      if (ir - i + 1 >= j - 1) {
        istack[jstack] = ir;
        istack[jstack - 1] = i;
        ir = j - 1;
      } else {
        istack[jstack] = j - 1;
        istack[jstack - 1] = l;
        l = i;
      }
    }
  }
}


x86 assembly (clang, -O0):
<sort3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0xffffffff,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x38(%rbp),%eax
cmp    $0x7,%eax
jge    12fc <sort3+0x1dc>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     12ba <sort3+0x19a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jl     1257 <sort3+0x137>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x104(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     11ec <sort3+0xcc>
jmp    1257 <sort3+0x137>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11bd <sort3+0x9d>
movl   $0x0,-0x24(%rbp)
movss  -0x104(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x108(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1169 <sort3+0x49>
cmpl   $0x0,-0x30(%rbp)
jge    12c9 <sort3+0x1a9>
jmp    19c0 <sort3+0x8a0>
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cltq
mov    -0x100(%rbp,%rax,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cltq
mov    -0x100(%rbp,%rax,4),%eax
mov    %eax,-0x38(%rbp)
jmp    19bb <sort3+0x89b>
mov    -0x38(%rbp),%eax
add    -0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    14dd <sort3+0x3bd>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    15eb <sort3+0x4cb>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    16f9 <sort3+0x5d9>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
jmp    175b <sort3+0x63b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x104(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     175b <sort3+0x63b>
jmp    1787 <sort3+0x667>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x104(%rbp),%xmm0
ja     1787 <sort3+0x667>
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17bb <sort3+0x69b>
jmp    188c <sort3+0x76c>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x110(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1756 <sort3+0x636>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x104(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x108(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x10c(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x32,-0x30(%rbp)
jl     1948 <sort3+0x828>
lea    0x6c7(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x1,%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     198d <sort3+0x86d>
mov    -0x28(%rbp),%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x100(%rbp,%rax,4)
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x100(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    19b6 <sort3+0x896>
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x100(%rbp,%rax,4)
mov    -0x38(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x100(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    19bb <sort3+0x89b>
jmp    1151 <sort3+0x31>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort3>:
push   %rbp
push   %r15
push   %r14
push   %rbx
lea    -0x1(%rdi),%r8d
xor    %r9d,%r9d
cmp    $0x8,%edi
jge    11b8 <sort3+0xb8>
mov    %r8d,%edi
cmp    %edi,%r9d
jge    11b1 <sort3+0xb1>
movslq %r9d,%rax
movslq %edi,%r8
lea    0x1(%rax),%rdi
mov    %rax,%r9
jmp    1158 <sort3+0x58>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  %xmm0,0x4(%rsi)
movss  %xmm1,0x4(%rdx)
movss  %xmm2,0x4(%rcx)
add    $0x1,%rdi
cmp    %r8,%r9
je     11b1 <sort3+0xb1>
mov    %r9,%rbx
movss  0x4(%rsi,%r9,4),%xmm0
movss  0x4(%rdx,%r9,4),%xmm1
movss  0x4(%rcx,%r9,4),%xmm2
add    $0x1,%r9
cmp    %rax,%rbx
jl     1140 <sort3+0x40>
mov    %rdi,%rbp
nopl   0x0(%rax)
movss  -0x4(%rsi,%rbp,4),%xmm3
ucomiss %xmm3,%xmm0
jae    1140 <sort3+0x40>
movss  %xmm3,(%rsi,%rbp,4)
movss  -0x4(%rdx,%rbp,4),%xmm3
movss  %xmm3,(%rdx,%rbp,4)
movss  -0x4(%rcx,%rbp,4),%xmm3
movss  %xmm3,(%rcx,%rbp,4)
add    $0xffffffffffffffff,%rbp
cmp    %rax,%rbp
jg     1180 <sort3+0x80>
jmp    1140 <sort3+0x40>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r9d,%r9d
jmp    121c <sort3+0x11c>
nopl   (%rax)
movss  %xmm3,(%rsi,%r10,4)
movss  %xmm0,0x0(%rbp,%rbx,4)
lea    (%rdx,%r15,4),%rdi
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rdx,%r10,4)
movss  %xmm2,(%rdi,%rbx,4)
lea    (%rcx,%r15,4),%rdi
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%r10,4)
movss  %xmm1,(%rdi,%rbx,4)
mov    %r8d,%ebp
sub    %r14d,%ebp
lea    (%r11,%rbx,1),%edi
add    $0xffffffff,%edi
cmp    %edi,%ebp
cmovl  %r8d,%edi
cmovl  %eax,%r9d
mov    %edi,%eax
sub    %r9d,%eax
mov    %edi,%r8d
cmp    $0x7,%eax
jl     1119 <sort3+0x19>
lea    (%r9,%r8,1),%eax
sar    %eax
movslq %eax,%rdi
movss  (%rsi,%rdi,4),%xmm0
movslq %r9d,%rax
lea    0x1(%rax),%r10
movss  0x4(%rsi,%rax,4),%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  %xmm0,0x4(%rsi,%rax,4)
movss  (%rdx,%rdi,4),%xmm0
movss  0x4(%rdx,%rax,4),%xmm1
movss  %xmm1,(%rdx,%rdi,4)
movss  %xmm0,0x4(%rdx,%rax,4)
movss  (%rcx,%rdi,4),%xmm0
movss  0x4(%rcx,%rax,4),%xmm1
movss  %xmm1,(%rcx,%rdi,4)
movss  %xmm0,0x4(%rcx,%rax,4)
movss  (%rsi,%rax,4),%xmm0
movslq %r8d,%rdi
movss  (%rsi,%rdi,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    12b7 <sort3+0x1b7>
movss  %xmm1,(%rsi,%rax,4)
movss  %xmm0,(%rsi,%rdi,4)
movss  (%rdx,%rax,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  (%rcx,%rax,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%rax,4)
movss  %xmm0,(%rcx,%rdi,4)
movss  (%rsi,%rdi,4),%xmm1
movss  (%rsi,%r10,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    12ff <sort3+0x1ff>
movss  %xmm1,(%rsi,%r10,4)
movss  %xmm0,(%rsi,%rdi,4)
movss  (%rdx,%r10,4),%xmm0
movss  (%rdx,%rdi,4),%xmm1
movss  %xmm1,(%rdx,%r10,4)
movss  %xmm0,(%rdx,%rdi,4)
movss  (%rcx,%r10,4),%xmm0
movss  (%rcx,%rdi,4),%xmm1
movss  %xmm1,(%rcx,%r10,4)
movss  %xmm0,(%rcx,%rdi,4)
movss  (%rsi,%r10,4),%xmm0
movss  (%rsi,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    1350 <sort3+0x250>
movss  %xmm0,(%rsi,%rax,4)
movss  %xmm1,(%rsi,%r10,4)
movss  (%rdx,%rax,4),%xmm0
movss  (%rdx,%r10,4),%xmm1
movss  %xmm1,(%rdx,%rax,4)
movss  %xmm0,(%rdx,%r10,4)
movss  (%rcx,%rax,4),%xmm1
movss  (%rcx,%r10,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  %xmm1,(%rcx,%r10,4)
movss  (%rsi,%r10,4),%xmm0
jmp    1356 <sort3+0x256>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%r10,4),%xmm1
lea    0x1(%r9),%r14d
movss  (%rdx,%r10,4),%xmm2
mov    %r8d,%r11d
mov    %r14d,%eax
cs nopw 0x0(%rax,%rax,1)
movslq %r11d,%r15
movss  (%rsi,%r15,4),%xmm3
nopl   0x0(%rax)
add    $0x1,%eax
ucomiss %xmm3,%xmm0
ja     1380 <sort3+0x280>
lea    (%rsi,%r15,4),%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
movss  -0x4(%rbp,%rbx,4),%xmm3
add    $0xffffffffffffffff,%rbx
ucomiss %xmm0,%xmm3
ja     1390 <sort3+0x290>
lea    (%r11,%rbx,1),%edi
add    $0x1,%edi
cmp    %edi,%eax
jge    11c0 <sort3+0xc0>
add    %ebx,%r11d
movslq %eax,%rdi
movss  (%rsi,%rdi,4),%xmm4
movss  %xmm3,(%rsi,%rdi,4)
movss  %xmm4,0x0(%rbp,%rbx,4)
movss  (%rdx,%rdi,4),%xmm3
lea    (%rdx,%r15,4),%rbp
movss  0x0(%rbp,%rbx,4),%xmm4
movss  %xmm4,(%rdx,%rdi,4)
movss  %xmm3,0x0(%rbp,%rbx,4)
movss  (%rcx,%rdi,4),%xmm3
lea    (%rcx,%r15,4),%rbp
movss  0x0(%rbp,%rbx,4),%xmm4
movss  %xmm4,(%rcx,%rdi,4)
movss  %xmm3,0x0(%rbp,%rbx,4)
mov    %eax,%r14d
jmp    1370 <sort3+0x270>

LLVM IR (-O0):
@.str = [27 x i8] c"NSTACK too small in sort3.\00"
define void @sort3(i32 %0, float* %1, float* %2, float* %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca [50 x i32]
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
store i32 %0, i32* %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
store i32 -1, i32* %12
store i32 0, i32* %14
%20 = load i32, i32* %5
%21 = sub nsw i32 %20, 1
store i32 %21, i32* %10
br label %22
22: ; preds = %620, %4
%23 = load i32, i32* %10
%24 = load i32, i32* %14
%25 = sub nsw i32 %23, %24
%26 = icmp slt i32 %25, 7
br i1 %26, label %27, label %136
27: ; preds = %22
%28 = load i32, i32* %14
%29 = add nsw i32 %28, 1
store i32 %29, i32* %11
br label %30
30: ; preds = %118, %27
%31 = load i32, i32* %11
%32 = load i32, i32* %10
%33 = icmp sle i32 %31, %32
br i1 %33, label %34, label %121
34: ; preds = %30
%35 = load float*, float** %6
%36 = load i32, i32* %11
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
store float %39, float* %16
%40 = load float*, float** %7
%41 = load i32, i32* %11
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
%44 = load float, float* %43
store float %44, float* %17
%45 = load float*, float** %8
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
%49 = load float, float* %48
store float %49, float* %18
%50 = load i32, i32* %11
%51 = sub nsw i32 %50, 1
store i32 %51, i32* %9
br label %52
52: ; preds = %96, %34
%53 = load i32, i32* %9
%54 = load i32, i32* %14
%55 = icmp sge i32 %53, %54
br i1 %55, label %56, label %99
56: ; preds = %52
%57 = load float*, float** %6
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
%62 = load float, float* %16
%63 = fcmp ole float %61, %62
br i1 %63, label %64, label %65
64: ; preds = %56
br label %99
65: ; preds = %56
%66 = load float*, float** %6
%67 = load i32, i32* %9
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %66, i64 %68
%70 = load float, float* %69
%71 = load float*, float** %6
%72 = load i32, i32* %9
%73 = add nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %71, i64 %74
store float %70, float* %75
%76 = load float*, float** %7
%77 = load i32, i32* %9
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float, float* %76, i64 %78
%80 = load float, float* %79
%81 = load float*, float** %7
%82 = load i32, i32* %9
%83 = add nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %81, i64 %84
store float %80, float* %85
%86 = load float*, float** %8
%87 = load i32, i32* %9
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = load float*, float** %8
%92 = load i32, i32* %9
%93 = add nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %91, i64 %94
store float %90, float* %95
br label %96
96: ; preds = %65
%97 = load i32, i32* %9
%98 = add nsw i32 %97, -1
store i32 %98, i32* %9
br label %52
99: ; preds = %64, %52
store i32 0, i32* %9
%100 = load float, float* %16
%101 = load float*, float** %6
%102 = load i32, i32* %9
%103 = add nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %101, i64 %104
store float %100, float* %105
%106 = load float, float* %17
%107 = load float*, float** %7
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %107, i64 %110
store float %106, float* %111
%112 = load float, float* %18
%113 = load float*, float** %8
%114 = load i32, i32* %9
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %113, i64 %116
store float %112, float* %117
br label %118
118: ; preds = %99
%119 = load i32, i32* %11
%120 = add nsw i32 %119, 1
store i32 %120, i32* %11
br label %30
121: ; preds = %30
%122 = load i32, i32* %12
%123 = icmp slt i32 %122, 0
br i1 %123, label %124, label %125
124: ; preds = %121
br label %621
125: ; preds = %121
%126 = load i32, i32* %12
%127 = add nsw i32 %126, -1
store i32 %127, i32* %12
%128 = sext i32 %126 to i64
%129 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %128
%130 = load i32, i32* %129
store i32 %130, i32* %10
%131 = load i32, i32* %12
%132 = add nsw i32 %131, -1
store i32 %132, i32* %12
%133 = sext i32 %131 to i64
%134 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %133
%135 = load i32, i32* %134
store i32 %135, i32* %14
br label %620
136: ; preds = %22
%137 = load i32, i32* %14
%138 = load i32, i32* %10
%139 = add nsw i32 %137, %138
%140 = ashr i32 %139, 1
store i32 %140, i32* %13
%141 = load float*, float** %6
%142 = load i32, i32* %13
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds float, float* %141, i64 %143
%145 = load float, float* %144
store float %145, float* %19
%146 = load float*, float** %6
%147 = load i32, i32* %14
%148 = add nsw i32 %147, 1
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %146, i64 %149
%151 = load float, float* %150
%152 = load float*, float** %6
%153 = load i32, i32* %13
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
store float %151, float* %155
%156 = load float, float* %19
%157 = load float*, float** %6
%158 = load i32, i32* %14
%159 = add nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %157, i64 %160
store float %156, float* %161
%162 = load float*, float** %7
%163 = load i32, i32* %13
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
%166 = load float, float* %165
store float %166, float* %19
%167 = load float*, float** %7
%168 = load i32, i32* %14
%169 = add nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %167, i64 %170
%172 = load float, float* %171
%173 = load float*, float** %7
%174 = load i32, i32* %13
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
store float %172, float* %176
%177 = load float, float* %19
%178 = load float*, float** %7
%179 = load i32, i32* %14
%180 = add nsw i32 %179, 1
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %178, i64 %181
store float %177, float* %182
%183 = load float*, float** %8
%184 = load i32, i32* %13
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
%187 = load float, float* %186
store float %187, float* %19
%188 = load float*, float** %8
%189 = load i32, i32* %14
%190 = add nsw i32 %189, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %188, i64 %191
%193 = load float, float* %192
%194 = load float*, float** %8
%195 = load i32, i32* %13
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %194, i64 %196
store float %193, float* %197
%198 = load float, float* %19
%199 = load float*, float** %8
%200 = load i32, i32* %14
%201 = add nsw i32 %200, 1
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %199, i64 %202
store float %198, float* %203
%204 = load float*, float** %6
%205 = load i32, i32* %14
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
%208 = load float, float* %207
%209 = load float*, float** %6
%210 = load i32, i32* %10
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %209, i64 %211
%213 = load float, float* %212
%214 = fcmp ogt float %208, %213
br i1 %214, label %215, label %273
215: ; preds = %136
%216 = load float*, float** %6
%217 = load i32, i32* %14
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %216, i64 %218
%220 = load float, float* %219
store float %220, float* %19
%221 = load float*, float** %6
%222 = load i32, i32* %10
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
%225 = load float, float* %224
%226 = load float*, float** %6
%227 = load i32, i32* %14
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
store float %225, float* %229
%230 = load float, float* %19
%231 = load float*, float** %6
%232 = load i32, i32* %10
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %231, i64 %233
store float %230, float* %234
%235 = load float*, float** %7
%236 = load i32, i32* %14
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds float, float* %235, i64 %237
%239 = load float, float* %238
store float %239, float* %19
%240 = load float*, float** %7
%241 = load i32, i32* %10
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float, float* %240, i64 %242
%244 = load float, float* %243
%245 = load float*, float** %7
%246 = load i32, i32* %14
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
store float %244, float* %248
%249 = load float, float* %19
%250 = load float*, float** %7
%251 = load i32, i32* %10
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
store float %249, float* %253
%254 = load float*, float** %8
%255 = load i32, i32* %14
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds float, float* %254, i64 %256
%258 = load float, float* %257
store float %258, float* %19
%259 = load float*, float** %8
%260 = load i32, i32* %10
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
%263 = load float, float* %262
%264 = load float*, float** %8
%265 = load i32, i32* %14
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds float, float* %264, i64 %266
store float %263, float* %267
%268 = load float, float* %19
%269 = load float*, float** %8
%270 = load i32, i32* %10
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* %269, i64 %271
store float %268, float* %272
br label %273
273: ; preds = %215, %136
%274 = load float*, float** %6
%275 = load i32, i32* %14
%276 = add nsw i32 %275, 1
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds float, float* %274, i64 %277
%279 = load float, float* %278
%280 = load float*, float** %6
%281 = load i32, i32* %10
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
%284 = load float, float* %283
%285 = fcmp ogt float %279, %284
br i1 %285, label %286, label %350
286: ; preds = %273
%287 = load float*, float** %6
%288 = load i32, i32* %14
%289 = add nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float, float* %287, i64 %290
%292 = load float, float* %291
store float %292, float* %19
%293 = load float*, float** %6
%294 = load i32, i32* %10
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds float, float* %293, i64 %295
%297 = load float, float* %296
%298 = load float*, float** %6
%299 = load i32, i32* %14
%300 = add nsw i32 %299, 1
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %298, i64 %301
store float %297, float* %302
%303 = load float, float* %19
%304 = load float*, float** %6
%305 = load i32, i32* %10
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds float, float* %304, i64 %306
store float %303, float* %307
%308 = load float*, float** %7
%309 = load i32, i32* %14
%310 = add nsw i32 %309, 1
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds float, float* %308, i64 %311
%313 = load float, float* %312
store float %313, float* %19
%314 = load float*, float** %7
%315 = load i32, i32* %10
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
%318 = load float, float* %317
%319 = load float*, float** %7
%320 = load i32, i32* %14
%321 = add nsw i32 %320, 1
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %319, i64 %322
store float %318, float* %323
%324 = load float, float* %19
%325 = load float*, float** %7
%326 = load i32, i32* %10
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
store float %324, float* %328
%329 = load float*, float** %8
%330 = load i32, i32* %14
%331 = add nsw i32 %330, 1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %329, i64 %332
%334 = load float, float* %333
store float %334, float* %19
%335 = load float*, float** %8
%336 = load i32, i32* %10
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
%339 = load float, float* %338
%340 = load float*, float** %8
%341 = load i32, i32* %14
%342 = add nsw i32 %341, 1
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds float, float* %340, i64 %343
store float %339, float* %344
%345 = load float, float* %19
%346 = load float*, float** %8
%347 = load i32, i32* %10
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds float, float* %346, i64 %348
store float %345, float* %349
br label %350
350: ; preds = %286, %273
%351 = load float*, float** %6
%352 = load i32, i32* %14
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %351, i64 %353
%355 = load float, float* %354
%356 = load float*, float** %6
%357 = load i32, i32* %14
%358 = add nsw i32 %357, 1
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds float, float* %356, i64 %359
%361 = load float, float* %360
%362 = fcmp ogt float %355, %361
br i1 %362, label %363, label %427
363: ; preds = %350
%364 = load float*, float** %6
%365 = load i32, i32* %14
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds float, float* %364, i64 %366
%368 = load float, float* %367
store float %368, float* %19
%369 = load float*, float** %6
%370 = load i32, i32* %14
%371 = add nsw i32 %370, 1
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %369, i64 %372
%374 = load float, float* %373
%375 = load float*, float** %6
%376 = load i32, i32* %14
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds float, float* %375, i64 %377
store float %374, float* %378
%379 = load float, float* %19
%380 = load float*, float** %6
%381 = load i32, i32* %14
%382 = add nsw i32 %381, 1
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds float, float* %380, i64 %383
store float %379, float* %384
%385 = load float*, float** %7
%386 = load i32, i32* %14
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds float, float* %385, i64 %387
%389 = load float, float* %388
store float %389, float* %19
%390 = load float*, float** %7
%391 = load i32, i32* %14
%392 = add nsw i32 %391, 1
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float, float* %390, i64 %393
%395 = load float, float* %394
%396 = load float*, float** %7
%397 = load i32, i32* %14
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds float, float* %396, i64 %398
store float %395, float* %399
%400 = load float, float* %19
%401 = load float*, float** %7
%402 = load i32, i32* %14
%403 = add nsw i32 %402, 1
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds float, float* %401, i64 %404
store float %400, float* %405
%406 = load float*, float** %8
%407 = load i32, i32* %14
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds float, float* %406, i64 %408
%410 = load float, float* %409
store float %410, float* %19
%411 = load float*, float** %8
%412 = load i32, i32* %14
%413 = add nsw i32 %412, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds float, float* %411, i64 %414
%416 = load float, float* %415
%417 = load float*, float** %8
%418 = load i32, i32* %14
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds float, float* %417, i64 %419
store float %416, float* %420
%421 = load float, float* %19
%422 = load float*, float** %8
%423 = load i32, i32* %14
%424 = add nsw i32 %423, 1
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds float, float* %422, i64 %425
store float %421, float* %426
br label %427
427: ; preds = %363, %350
%428 = load i32, i32* %14
%429 = add nsw i32 %428, 1
store i32 %429, i32* %9
%430 = load i32, i32* %10
store i32 %430, i32* %11
%431 = load float*, float** %6
%432 = load i32, i32* %14
%433 = add nsw i32 %432, 1
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds float, float* %431, i64 %434
%436 = load float, float* %435
store float %436, float* %16
%437 = load float*, float** %7
%438 = load i32, i32* %14
%439 = add nsw i32 %438, 1
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %437, i64 %440
%442 = load float, float* %441
store float %442, float* %17
%443 = load float*, float** %8
%444 = load i32, i32* %14
%445 = add nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %443, i64 %446
%448 = load float, float* %447
store float %448, float* %18
br label %449
449: ; preds = %478, %427
br label %450
450: ; preds = %453, %449
%451 = load i32, i32* %9
%452 = add nsw i32 %451, 1
store i32 %452, i32* %9
br label %453
453: ; preds = %450
%454 = load float*, float** %6
%455 = load i32, i32* %11
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds float, float* %454, i64 %456
%458 = load float, float* %457
%459 = load float, float* %16
%460 = fcmp olt float %458, %459
br i1 %460, label %450, label %461
461: ; preds = %453
br label %462
462: ; preds = %465, %461
%463 = load i32, i32* %11
%464 = add nsw i32 %463, -1
store i32 %464, i32* %11
br label %465
465: ; preds = %462
%466 = load float*, float** %6
%467 = load i32, i32* %11
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds float, float* %466, i64 %468
%470 = load float, float* %469
%471 = load float, float* %16
%472 = fcmp ogt float %470, %471
br i1 %472, label %462, label %473
473: ; preds = %465
%474 = load i32, i32* %11
%475 = load i32, i32* %9
%476 = icmp slt i32 %474, %475
br i1 %476, label %477, label %478
477: ; preds = %473
br label %536
478: ; preds = %473
%479 = load float*, float** %6
%480 = load i32, i32* %9
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds float, float* %479, i64 %481
%483 = load float, float* %482
store float %483, float* %19
%484 = load float*, float** %6
%485 = load i32, i32* %11
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
%488 = load float, float* %487
%489 = load float*, float** %6
%490 = load i32, i32* %9
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds float, float* %489, i64 %491
store float %488, float* %492
%493 = load float, float* %19
%494 = load float*, float** %6
%495 = load i32, i32* %11
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds float, float* %494, i64 %496
store float %493, float* %497
%498 = load float*, float** %7
%499 = load i32, i32* %9
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float, float* %498, i64 %500
%502 = load float, float* %501
store float %502, float* %19
%503 = load float*, float** %7
%504 = load i32, i32* %11
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds float, float* %503, i64 %505
%507 = load float, float* %506
%508 = load float*, float** %7
%509 = load i32, i32* %9
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds float, float* %508, i64 %510
store float %507, float* %511
%512 = load float, float* %19
%513 = load float*, float** %7
%514 = load i32, i32* %11
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float, float* %513, i64 %515
store float %512, float* %516
%517 = load float*, float** %8
%518 = load i32, i32* %9
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds float, float* %517, i64 %519
%521 = load float, float* %520
store float %521, float* %19
%522 = load float*, float** %8
%523 = load i32, i32* %11
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %522, i64 %524
%526 = load float, float* %525
%527 = load float*, float** %8
%528 = load i32, i32* %9
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds float, float* %527, i64 %529
store float %526, float* %530
%531 = load float, float* %19
%532 = load float*, float** %8
%533 = load i32, i32* %11
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds float, float* %532, i64 %534
store float %531, float* %535
br label %449
536: ; preds = %477
%537 = load float*, float** %6
%538 = load i32, i32* %11
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds float, float* %537, i64 %539
%541 = load float, float* %540
%542 = load float*, float** %6
%543 = load i32, i32* %14
%544 = add nsw i32 %543, 1
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds float, float* %542, i64 %545
store float %541, float* %546
%547 = load float, float* %16
%548 = load float*, float** %6
%549 = load i32, i32* %11
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %548, i64 %550
store float %547, float* %551
%552 = load float*, float** %7
%553 = load i32, i32* %11
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds float, float* %552, i64 %554
%556 = load float, float* %555
%557 = load float*, float** %7
%558 = load i32, i32* %14
%559 = add nsw i32 %558, 1
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds float, float* %557, i64 %560
store float %556, float* %561
%562 = load float, float* %17
%563 = load float*, float** %7
%564 = load i32, i32* %11
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %563, i64 %565
store float %562, float* %566
%567 = load float*, float** %8
%568 = load i32, i32* %11
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds float, float* %567, i64 %569
%571 = load float, float* %570
%572 = load float*, float** %8
%573 = load i32, i32* %14
%574 = add nsw i32 %573, 1
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float, float* %572, i64 %575
store float %571, float* %576
%577 = load float, float* %18
%578 = load float*, float** %8
%579 = load i32, i32* %11
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds float, float* %578, i64 %580
store float %577, float* %581
%582 = load i32, i32* %12
%583 = icmp sge i32 %582, 50
br i1 %583, label %584, label %587
584: ; preds = %536
%585 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
%586 = call i32 @exit(i32 1)
unreachable
587: ; preds = %536
%588 = load i32, i32* %10
%589 = load i32, i32* %9
%590 = sub nsw i32 %588, %589
%591 = add nsw i32 %590, 1
%592 = load i32, i32* %11
%593 = sub nsw i32 %592, 1
%594 = icmp sge i32 %591, %593
br i1 %594, label %595, label %607
595: ; preds = %587
%596 = load i32, i32* %10
%597 = load i32, i32* %12
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %598
store i32 %596, i32* %599
%600 = load i32, i32* %9
%601 = load i32, i32* %12
%602 = sub nsw i32 %601, 1
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %603
store i32 %600, i32* %604
%605 = load i32, i32* %11
%606 = sub nsw i32 %605, 1
store i32 %606, i32* %10
br label %619
607: ; preds = %587
%608 = load i32, i32* %11
%609 = sub nsw i32 %608, 1
%610 = load i32, i32* %12
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %611
store i32 %609, i32* %612
%613 = load i32, i32* %14
%614 = load i32, i32* %12
%615 = sub nsw i32 %614, 1
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds [50 x i32], [50 x i32]* %15, i64 0, i64 %616
store i32 %613, i32* %617
%618 = load i32, i32* %9
store i32 %618, i32* %14
br label %619
619: ; preds = %607, %595
br label %620
620: ; preds = %619, %125
br label %22
621: ; preds = %124
ret void
}

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