#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*/ free_lvector(unsigned long *, int, int);
unsigned long *lvector(int, int);
int /*<<< orphan*/ nrerror(char *);
void sort2(unsigned long n, float arr[], float brr[]) {
  unsigned long i, ir = n, j, k, l = 1, *istack;
  int jstack = 0;
  float a, b, temp;
  istack = lvector(1, 50);
  for (;;) {
    if (ir - l < 7) {
      for (j = l + 1; j <= ir; j++) {
        a = arr[j];
        b = brr[j];
        for (i = j - 1; i >= l; i--) {
          if (arr[i] <= a)
            break;
          arr[i + 1] = arr[i];
          brr[i + 1] = brr[i];
        }
        arr[i + 1] = a;
        brr[i + 1] = b;
      }
      if (!jstack) {
        free_lvector(istack, 1, 50);
        return;
      }
      ir = istack[jstack];
      l = istack[jstack - 1];
      jstack -= 2;
    } 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;
      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;
      }
      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;
      }
      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;
      }
      i = l + 1;
      j = ir;
      a = arr[l + 1];
      b = brr[l + 1];
      for (;;) {
        do
          i++;
        while (arr[i] < 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;
      }
      arr[l + 1] = arr[j];
      arr[j] = a;
      brr[l + 1] = brr[j];
      brr[j] = b;
      jstack += 2;
      if (jstack > 50)
        nrerror("NSTACK too small in sort2.");
      if (ir - i + 1 >= j - l) {
        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):
<sort2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
movq   $0x1,-0x40(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <lvector@plt>
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x7,%rax
jae    12cc <sort2+0x19c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     1276 <sort2+0x146>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x40(%rbp),%rax
jb     123f <sort2+0x10f>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     11f8 <sort2+0xc8>
jmp    123f <sort2+0x10f>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    11ca <sort2+0x9a>
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    118c <sort2+0x5c>
cmpl   $0x0,-0x4c(%rbp)
jne    1299 <sort2+0x169>
mov    -0x48(%rbp),%rdi
mov    $0x1,%esi
mov    $0x32,%edx
call   1040 <free_lvector@plt>
add    $0x60,%rsp
pop    %rbp
ret
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    175b <sort2+0x62b>
mov    -0x40(%rbp),%rax
add    -0x28(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    13f7 <sort2+0x2c7>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1497 <sort2+0x367>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
ucomiss 0x4(%rax,%rcx,4),%xmm0
jbe    1537 <sort2+0x407>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1576 <sort2+0x446>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1576 <sort2+0x446>
jmp    15a2 <sort2+0x472>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x50(%rbp),%xmm0
ja     15a2 <sort2+0x472>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    15d8 <sort2+0x4a8>
jmp    1659 <sort2+0x529>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1571 <sort2+0x441>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x32,-0x4c(%rbp)
jle    16d2 <sort2+0x5a2>
lea    0x933(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
add    $0x1,%rax
mov    -0x30(%rbp),%rcx
sub    -0x40(%rbp),%rcx
cmp    %rcx,%rax
jb     1725 <sort2+0x5f5>
mov    -0x28(%rbp),%rdx
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1756 <sort2+0x626>
mov    -0x30(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    175b <sort2+0x62b>
jmp    116e <sort2+0x3e>

x86 assembly (clang, -O2):
<sort2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <lvector@plt>
mov    %rbp,%r8
mov    %rax,%rdi
xor    %r13d,%r13d
mov    $0x1,%r15d
mov    %rax,(%rsp)
jmp    1180 <sort2+0x50>
nopl   0x0(%rax,%rax,1)
mov    %r8,(%rdi,%rcx,8)
mov    %rbp,0x8(%rdi,%rax,8)
add    $0xffffffffffffffff,%r12
mov    %r12,%r8
mov    %r13d,%r9d
mov    %r8,0x8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r8,%rax
sub    %r15,%rax
cmp    $0x6,%rax
jbe    1370 <sort2+0x240>
lea    (%r15,%r8,1),%rax
add    %rax,%rax
and    $0xfffffffffffffffc,%rax
movss  (%rbx,%rax,1),%xmm0
movss  0x4(%rbx,%r15,4),%xmm1
movss  %xmm1,(%rbx,%rax,1)
movss  %xmm0,0x4(%rbx,%r15,4)
movss  (%r14,%rax,1),%xmm0
movss  0x4(%r14,%r15,4),%xmm1
movss  %xmm1,(%r14,%rax,1)
movss  %xmm0,0x4(%r14,%r15,4)
movss  (%rbx,%r15,4),%xmm0
movss  (%rbx,%r8,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    1218 <sort2+0xe8>
movss  %xmm1,(%rbx,%r15,4)
movss  %xmm0,(%rbx,%r8,4)
movss  (%r14,%r15,4),%xmm0
movss  (%r14,%r8,4),%xmm1
movss  %xmm1,(%r14,%r15,4)
movss  %xmm0,(%r14,%r8,4)
movss  (%rbx,%r8,4),%xmm1
movss  0x4(%rbx,%r15,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1252 <sort2+0x122>
movss  %xmm1,0x4(%rbx,%r15,4)
movss  %xmm0,(%rbx,%r8,4)
movss  0x4(%r14,%r15,4),%xmm0
movss  (%r14,%r8,4),%xmm1
movss  %xmm1,0x4(%r14,%r15,4)
movss  %xmm0,(%r14,%r8,4)
movss  0x4(%rbx,%r15,4),%xmm0
movss  (%rbx,%r15,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    1290 <sort2+0x160>
movss  %xmm0,(%rbx,%r15,4)
movss  %xmm1,0x4(%rbx,%r15,4)
movss  (%r14,%r15,4),%xmm1
movss  0x4(%r14,%r15,4),%xmm0
movss  %xmm0,(%r14,%r15,4)
movss  %xmm1,0x4(%r14,%r15,4)
movss  0x4(%rbx,%r15,4),%xmm0
jmp    1297 <sort2+0x167>
nopl   (%rax)
movss  0x4(%r14,%r15,4),%xmm1
lea    0x1(%r15),%rbp
mov    %r8,%r12
xchg   %ax,%ax
movss  0x4(%rbx,%rbp,4),%xmm2
add    $0x1,%rbp
ucomiss %xmm2,%xmm0
ja     12a0 <sort2+0x170>
nop
movss  -0x4(%rbx,%r12,4),%xmm3
add    $0xffffffffffffffff,%r12
ucomiss %xmm0,%xmm3
ja     12b0 <sort2+0x180>
cmp    %rbp,%r12
jb     12f0 <sort2+0x1c0>
movss  %xmm3,(%rbx,%rbp,4)
movss  %xmm2,(%rbx,%r12,4)
movss  (%r14,%rbp,4),%xmm2
movss  (%r14,%r12,4),%xmm3
movss  %xmm3,(%r14,%rbp,4)
movss  %xmm2,(%r14,%r12,4)
jmp    12a0 <sort2+0x170>
nopw   0x0(%rax,%rax,1)
movss  %xmm3,0x4(%rbx,%r15,4)
movss  %xmm0,(%rbx,%r12,4)
movss  (%r14,%r12,4),%xmm0
movss  %xmm0,0x4(%r14,%r15,4)
movss  %xmm1,(%r14,%r12,4)
lea    0x2(%r9),%r13d
cmp    $0x31,%r9d
jl     1339 <sort2+0x209>
lea    0xcdf(%rip),%rdi
mov    %r9,0x10(%rsp)
call   1030 <nrerror@plt>
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r8
mov    (%rsp),%rdi
mov    %r8,%rdx
sub    %rbp,%rdx
add    $0x1,%rdx
mov    %r12,%rsi
sub    %r15,%rsi
movslq %r13d,%rcx
movslq %r9d,%rax
cmp    %rsi,%rdx
jae    1170 <sort2+0x40>
add    $0xffffffffffffffff,%r12
mov    %r12,(%rdi,%rcx,8)
mov    %r15,0x8(%rdi,%rax,8)
mov    %rbp,%r15
mov    %r13d,%r9d
jmp    1190 <sort2+0x60>
lea    0x1(%r15),%rdx
cmp    %r8,%rdx
jbe    13a0 <sort2+0x270>
test   %r9d,%r9d
je     1408 <sort2+0x2d8>
movslq %r9d,%rax
mov    -0x8(%rdi,%rax,8),%r15
mov    (%rdi,%rax,8),%r8
add    $0xfffffffe,%r9d
mov    %r9d,%r13d
jmp    1180 <sort2+0x50>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
jmp    13c6 <sort2+0x296>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,0x4(%rbx,%rcx,4)
movss  %xmm1,0x4(%r14,%rcx,4)
lea    0x1(%rax),%rdx
cmp    %r8,%rdx
ja     1379 <sort2+0x249>
mov    %rax,%rcx
mov    %rdx,%rax
movss  (%rbx,%rdx,4),%xmm0
movss  (%r14,%rdx,4),%xmm1
cmp    %r15,%rcx
jb     13b0 <sort2+0x280>
nopl   0x0(%rax)
movss  (%rbx,%rcx,4),%xmm2
ucomiss %xmm2,%xmm0
jae    13b0 <sort2+0x280>
movss  %xmm2,0x4(%rbx,%rcx,4)
movss  (%r14,%rcx,4),%xmm2
movss  %xmm2,0x4(%r14,%rcx,4)
add    $0xffffffffffffffff,%rcx
cmp    %r15,%rcx
jae    13e0 <sort2+0x2b0>
jmp    13b0 <sort2+0x280>
mov    $0x1,%esi
mov    $0x32,%edx
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_lvector@plt>

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

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