#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(long *, int, int);
long *lvector(int, int);
int /*<<< orphan*/ nrerror(char *);
void quicksorti(unsigned long n, int *arr, float *brr) {
  unsigned long i, ir = n, j, k, l = 1;
  float b;
  long *istack;
  int jstack = 0;
  float a, temp;
  istack = lvector(1, 200);
  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 == 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;
      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];
      brr[l + 1] = brr[j];
      arr[j] = a;
      brr[j] = b;
      jstack += 2;
      if (jstack > 200)
        nrerror("NSTACK too small in sort.");
      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;
      }
    }
  }
  free_lvector(istack, 1, 200);
}


x86 assembly (clang, -O0):
<quicksorti>:
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,-0x54(%rbp)
mov    $0x1,%edi
mov    $0xc8,%esi
call   1050 <lvector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x40(%rbp),%rax
cmp    $0x7,%rax
jae    12b8 <quicksorti+0x188>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     1270 <quicksorti+0x140>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x40(%rbp),%rax
jb     123b <quicksorti+0x10b>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     11f8 <quicksorti+0xc8>
jmp    123b <quicksorti+0x10b>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %edx,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 <quicksorti+0x9a>
cvttss2si -0x58(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,4)
movss  -0x44(%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 <quicksorti+0x5c>
cmpl   $0x0,-0x54(%rbp)
jne    127f <quicksorti+0x14f>
jmp    1722 <quicksorti+0x5f2>
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x54(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
jmp    171d <quicksorti+0x5ed>
mov    -0x40(%rbp),%rax
add    -0x28(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cvttss2si -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%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  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    13d4 <quicksorti+0x2a4>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cvttss2si -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%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  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    146b <quicksorti+0x33b>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
cvtsi2ssl 0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,4)
cvttss2si -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%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  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
cmp    0x4(%rcx,%rdx,4),%eax
jle    1502 <quicksorti+0x3d2>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x4(%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cvttss2si -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%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  -0x5c(%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
cvtsi2ssl 0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    1541 <quicksorti+0x411>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1541 <quicksorti+0x411>
jmp    156d <quicksorti+0x43d>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
ucomiss -0x58(%rbp),%xmm0
ja     156d <quicksorti+0x43d>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    15a3 <quicksorti+0x473>
jmp    161e <quicksorti+0x4ee>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cvttss2si -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%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  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    153c <quicksorti+0x40c>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,0x4(%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)
cvttss2si -0x58(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0xc8,-0x54(%rbp)
jle    1694 <quicksorti+0x564>
lea    0x971(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
add    $0x1,%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jb     16e7 <quicksorti+0x5b7>
mov    -0x28(%rbp),%rdx
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x54(%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    1718 <quicksorti+0x5e8>
mov    -0x30(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x50(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    171d <quicksorti+0x5ed>
jmp    116e <quicksorti+0x3e>
mov    -0x50(%rbp),%rdi
mov    $0x1,%esi
mov    $0xc8,%edx
call   1040 <free_lvector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quicksorti>:
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    $0xc8,%esi
call   1050 <lvector@plt>
mov    %rbp,%rsi
mov    %rax,%rdi
xor    %r13d,%r13d
mov    $0x1,%r15d
mov    %rax,(%rsp)
jmp    117c <quicksorti+0x4c>
nopl   0x0(%rax,%rax,1)
mov    %rsi,(%rdi,%rcx,8)
mov    %rbp,0x8(%rdi,%rax,8)
mov    %r12,%rsi
mov    %r13d,%r8d
mov    %rsi,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rsi,%rax
sub    %r15,%rax
cmp    $0x6,%rax
jbe    1390 <quicksorti+0x260>
lea    (%r15,%rsi,1),%rcx
add    %rcx,%rcx
and    $0xfffffffffffffffc,%rcx
xorps  %xmm0,%xmm0
cvtsi2ssl (%rbx,%rcx,1),%xmm0
mov    0x4(%rbx,%r15,4),%eax
mov    %eax,(%rbx,%rcx,1)
cvttss2si %xmm0,%eax
mov    %eax,0x4(%rbx,%r15,4)
movss  (%r14,%rcx,1),%xmm0
movss  0x4(%r14,%r15,4),%xmm1
movss  %xmm1,(%r14,%rcx,1)
movss  %xmm0,0x4(%r14,%r15,4)
mov    (%rbx,%r15,4),%edx
mov    (%rbx,%rsi,4),%ecx
cmp    %ecx,%edx
jle    1218 <quicksorti+0xe8>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mov    %ecx,(%rbx,%r15,4)
cvttss2si %xmm0,%ecx
mov    %ecx,(%rbx,%rsi,4)
movss  (%r14,%r15,4),%xmm0
movss  (%r14,%rsi,4),%xmm1
movss  %xmm1,(%r14,%r15,4)
movss  %xmm0,(%r14,%rsi,4)
mov    0x4(%rbx,%r15,4),%eax
cmp    %ecx,%eax
jle    124e <quicksorti+0x11e>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    %ecx,0x4(%rbx,%r15,4)
cvttss2si %xmm0,%eax
mov    %eax,(%rbx,%rsi,4)
movss  0x4(%r14,%r15,4),%xmm0
movss  (%r14,%rsi,4),%xmm1
movss  %xmm1,0x4(%r14,%r15,4)
movss  %xmm0,(%r14,%rsi,4)
mov    0x4(%rbx,%r15,4),%eax
mov    (%rbx,%r15,4),%ecx
cmp    %eax,%ecx
jle    1290 <quicksorti+0x160>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
mov    %eax,(%rbx,%r15,4)
cvttss2si %xmm0,%eax
mov    %eax,0x4(%rbx,%r15,4)
movss  (%r14,%r15,4),%xmm0
movss  0x4(%r14,%r15,4),%xmm1
movss  %xmm1,(%r14,%r15,4)
movss  %xmm0,0x4(%r14,%r15,4)
jmp    1297 <quicksorti+0x167>
cs nopw 0x0(%rax,%rax,1)
movss  0x4(%r14,%r15,4),%xmm0
lea    0x1(%r15),%rbp
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mov    %rsi,%r12
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm2,%xmm2
cvtsi2ssl 0x4(%rbx,%rbp,4),%xmm2
add    $0x1,%rbp
ucomiss %xmm2,%xmm1
ja     12b0 <quicksorti+0x180>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%rbx,%r12,4),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
add    $0xffffffffffffffff,%r12
ucomiss %xmm1,%xmm3
ja     12d0 <quicksorti+0x1a0>
cmp    %rbp,%r12
jb     1310 <quicksorti+0x1e0>
mov    %eax,(%rbx,%rbp,4)
cvttss2si %xmm2,%eax
mov    %eax,(%rbx,%r12,4)
movss  (%r14,%rbp,4),%xmm2
movss  (%r14,%r12,4),%xmm3
movss  %xmm3,(%r14,%rbp,4)
movss  %xmm2,(%r14,%r12,4)
jmp    12b0 <quicksorti+0x180>
nop
mov    %eax,0x4(%rbx,%r15,4)
movss  (%r14,%r12,4),%xmm2
movss  %xmm2,0x4(%r14,%r15,4)
cvttss2si %xmm1,%eax
mov    %eax,(%rbx,%r12,4)
movss  %xmm0,(%r14,%r12,4)
lea    0x2(%r8),%r13d
cmp    $0xc7,%r8d
jl     135c <quicksorti+0x22c>
lea    0xcbc(%rip),%rdi
mov    %r8,0x10(%rsp)
call   1030 <nrerror@plt>
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdi
mov    %rsi,%rdx
sub    %rbp,%rdx
add    $0x1,%rdx
add    $0xffffffffffffffff,%r12
movslq %r13d,%rcx
movslq %r8d,%rax
cmp    %r12,%rdx
jae    1170 <quicksorti+0x40>
mov    %r12,(%rdi,%rcx,8)
mov    %r15,0x8(%rdi,%rax,8)
mov    %rbp,%r15
mov    %r13d,%r8d
jmp    1190 <quicksorti+0x60>
nopl   (%rax)
lea    0x1(%r15),%rdx
cmp    %rsi,%rdx
jbe    13c0 <quicksorti+0x290>
test   %r8d,%r8d
je     143b <quicksorti+0x30b>
movslq %r8d,%rax
mov    -0x8(%rdi,%rax,8),%r15
mov    (%rdi,%rax,8),%rsi
add    $0xfffffffe,%r8d
mov    %r8d,%r13d
jmp    117c <quicksorti+0x4c>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
jmp    13e8 <quicksorti+0x2b8>
cs nopw 0x0(%rax,%rax,1)
nop
cvttss2si %xmm1,%edx
mov    %edx,0x4(%rbx,%rcx,4)
movss  %xmm0,0x4(%r14,%rcx,4)
lea    0x1(%rax),%rdx
cmp    %rsi,%rdx
ja     1399 <quicksorti+0x269>
mov    %rax,%rcx
mov    %rdx,%rax
xorps  %xmm1,%xmm1
cvtsi2ssl (%rbx,%rdx,4),%xmm1
movss  (%r14,%rdx,4),%xmm0
cmp    %r15,%rcx
jb     13d0 <quicksorti+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
ucomiss %xmm2,%xmm1
jae    13d0 <quicksorti+0x2a0>
mov    %edx,0x4(%rbx,%rcx,4)
movss  (%r14,%rcx,4),%xmm2
movss  %xmm2,0x4(%r14,%rcx,4)
add    $0xffffffffffffffff,%rcx
cmp    %r15,%rcx
jae    1410 <quicksorti+0x2e0>
jmp    13d0 <quicksorti+0x2a0>
mov    $0x1,%esi
mov    $0xc8,%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 = [26 x i8] c"NSTACK too small in sort.\00"
define void @quicksorti(i64 %0, i32* %1, float* %2) {
%4 = alloca i64
%5 = alloca i32*
%6 = alloca float*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca float
%13 = alloca i64*
%14 = alloca i32
%15 = alloca float
%16 = alloca float
store i64 %0, i64* %4
store i32* %1, i32** %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* %14
%18 = call i64* @lvector(i32 1, i32 200)
store i64* %18, i64** %13
br label %19
19: ; preds = %433, %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 = %88, %24
%28 = load i64, i64* %9
%29 = load i64, i64* %8
%30 = icmp ule i64 %28, %29
br i1 %30, label %31, label %91
31: ; preds = %27
%32 = load i32*, i32** %5
%33 = load i64, i64* %9
%34 = getelementptr inbounds i32, i32* %32, i64 %33
%35 = load i32, i32* %34
%36 = sitofp i32 %35 to float
store float %36, float* %15
%37 = load float*, float** %6
%38 = load i64, i64* %9
%39 = getelementptr inbounds float, float* %37, i64 %38
%40 = load float, float* %39
store float %40, float* %12
%41 = load i64, i64* %9
%42 = sub i64 %41, 1
store i64 %42, i64* %7
br label %43
43: ; preds = %73, %31
%44 = load i64, i64* %7
%45 = load i64, i64* %11
%46 = icmp uge i64 %44, %45
br i1 %46, label %47, label %76
47: ; preds = %43
%48 = load i32*, i32** %5
%49 = load i64, i64* %7
%50 = getelementptr inbounds i32, i32* %48, i64 %49
%51 = load i32, i32* %50
%52 = sitofp i32 %51 to float
%53 = load float, float* %15
%54 = fcmp ole float %52, %53
br i1 %54, label %55, label %56
55: ; preds = %47
br label %76
56: ; preds = %47
%57 = load i32*, i32** %5
%58 = load i64, i64* %7
%59 = getelementptr inbounds i32, i32* %57, i64 %58
%60 = load i32, i32* %59
%61 = load i32*, i32** %5
%62 = load i64, i64* %7
%63 = add i64 %62, 1
%64 = getelementptr inbounds i32, i32* %61, i64 %63
store i32 %60, i32* %64
%65 = load float*, float** %6
%66 = load i64, i64* %7
%67 = getelementptr inbounds float, float* %65, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %6
%70 = load i64, i64* %7
%71 = add i64 %70, 1
%72 = getelementptr inbounds float, float* %69, i64 %71
store float %68, float* %72
br label %73
73: ; preds = %56
%74 = load i64, i64* %7
%75 = add i64 %74, -1
store i64 %75, i64* %7
br label %43
76: ; preds = %55, %43
%77 = load float, float* %15
%78 = fptosi float %77 to i32
%79 = load i32*, i32** %5
%80 = load i64, i64* %7
%81 = add i64 %80, 1
%82 = getelementptr inbounds i32, i32* %79, i64 %81
store i32 %78, i32* %82
%83 = load float, float* %12
%84 = load float*, float** %6
%85 = load i64, i64* %7
%86 = add i64 %85, 1
%87 = getelementptr inbounds float, float* %84, i64 %86
store float %83, float* %87
br label %88
88: ; preds = %76
%89 = load i64, i64* %9
%90 = add i64 %89, 1
store i64 %90, i64* %9
br label %27
91: ; preds = %27
%92 = load i32, i32* %14
%93 = icmp eq i32 %92, 0
br i1 %93, label %94, label %95
94: ; preds = %91
br label %434
95: ; preds = %91
%96 = load i64*, i64** %13
%97 = load i32, i32* %14
%98 = add nsw i32 %97, -1
store i32 %98, i32* %14
%99 = sext i32 %97 to i64
%100 = getelementptr inbounds i64, i64* %96, i64 %99
%101 = load i64, i64* %100
store i64 %101, i64* %8
%102 = load i64*, i64** %13
%103 = load i32, i32* %14
%104 = add nsw i32 %103, -1
store i32 %104, i32* %14
%105 = sext i32 %103 to i64
%106 = getelementptr inbounds i64, i64* %102, i64 %105
%107 = load i64, i64* %106
store i64 %107, i64* %11
br label %433
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 i32*, i32** %5
%114 = load i64, i64* %10
%115 = getelementptr inbounds i32, i32* %113, i64 %114
%116 = load i32, i32* %115
%117 = sitofp i32 %116 to float
store float %117, float* %16
%118 = load i32*, i32** %5
%119 = load i64, i64* %11
%120 = add i64 %119, 1
%121 = getelementptr inbounds i32, i32* %118, i64 %120
%122 = load i32, i32* %121
%123 = load i32*, i32** %5
%124 = load i64, i64* %10
%125 = getelementptr inbounds i32, i32* %123, i64 %124
store i32 %122, i32* %125
%126 = load float, float* %16
%127 = fptosi float %126 to i32
%128 = load i32*, i32** %5
%129 = load i64, i64* %11
%130 = add i64 %129, 1
%131 = getelementptr inbounds i32, i32* %128, i64 %130
store i32 %127, i32* %131
%132 = load float*, float** %6
%133 = load i64, i64* %10
%134 = getelementptr inbounds float, float* %132, i64 %133
%135 = load float, float* %134
store float %135, float* %16
%136 = load float*, float** %6
%137 = load i64, i64* %11
%138 = add i64 %137, 1
%139 = getelementptr inbounds float, float* %136, i64 %138
%140 = load float, float* %139
%141 = load float*, float** %6
%142 = load i64, i64* %10
%143 = getelementptr inbounds float, float* %141, i64 %142
store float %140, float* %143
%144 = load float, float* %16
%145 = load float*, float** %6
%146 = load i64, i64* %11
%147 = add i64 %146, 1
%148 = getelementptr inbounds float, float* %145, i64 %147
store float %144, float* %148
%149 = load i32*, i32** %5
%150 = load i64, i64* %11
%151 = getelementptr inbounds i32, i32* %149, i64 %150
%152 = load i32, i32* %151
%153 = load i32*, i32** %5
%154 = load i64, i64* %8
%155 = getelementptr inbounds i32, i32* %153, i64 %154
%156 = load i32, i32* %155
%157 = icmp sgt i32 %152, %156
br i1 %157, label %158, label %191
158: ; preds = %108
%159 = load i32*, i32** %5
%160 = load i64, i64* %11
%161 = getelementptr inbounds i32, i32* %159, i64 %160
%162 = load i32, i32* %161
%163 = sitofp i32 %162 to float
store float %163, float* %16
%164 = load i32*, i32** %5
%165 = load i64, i64* %8
%166 = getelementptr inbounds i32, i32* %164, i64 %165
%167 = load i32, i32* %166
%168 = load i32*, i32** %5
%169 = load i64, i64* %11
%170 = getelementptr inbounds i32, i32* %168, i64 %169
store i32 %167, i32* %170
%171 = load float, float* %16
%172 = fptosi float %171 to i32
%173 = load i32*, i32** %5
%174 = load i64, i64* %8
%175 = getelementptr inbounds i32, i32* %173, i64 %174
store i32 %172, i32* %175
%176 = load float*, float** %6
%177 = load i64, i64* %11
%178 = getelementptr inbounds float, float* %176, i64 %177
%179 = load float, float* %178
store float %179, float* %16
%180 = load float*, float** %6
%181 = load i64, i64* %8
%182 = getelementptr inbounds float, float* %180, i64 %181
%183 = load float, float* %182
%184 = load float*, float** %6
%185 = load i64, i64* %11
%186 = getelementptr inbounds float, float* %184, i64 %185
store float %183, float* %186
%187 = load float, float* %16
%188 = load float*, float** %6
%189 = load i64, i64* %8
%190 = getelementptr inbounds float, float* %188, i64 %189
store float %187, float* %190
br label %191
191: ; preds = %158, %108
%192 = load i32*, i32** %5
%193 = load i64, i64* %11
%194 = add i64 %193, 1
%195 = getelementptr inbounds i32, i32* %192, i64 %194
%196 = load i32, i32* %195
%197 = load i32*, i32** %5
%198 = load i64, i64* %8
%199 = getelementptr inbounds i32, i32* %197, i64 %198
%200 = load i32, i32* %199
%201 = icmp sgt i32 %196, %200
br i1 %201, label %202, label %239
202: ; preds = %191
%203 = load i32*, i32** %5
%204 = load i64, i64* %11
%205 = add i64 %204, 1
%206 = getelementptr inbounds i32, i32* %203, i64 %205
%207 = load i32, i32* %206
%208 = sitofp i32 %207 to float
store float %208, float* %16
%209 = load i32*, i32** %5
%210 = load i64, i64* %8
%211 = getelementptr inbounds i32, i32* %209, i64 %210
%212 = load i32, i32* %211
%213 = load i32*, i32** %5
%214 = load i64, i64* %11
%215 = add i64 %214, 1
%216 = getelementptr inbounds i32, i32* %213, i64 %215
store i32 %212, i32* %216
%217 = load float, float* %16
%218 = fptosi float %217 to i32
%219 = load i32*, i32** %5
%220 = load i64, i64* %8
%221 = getelementptr inbounds i32, i32* %219, i64 %220
store i32 %218, i32* %221
%222 = load float*, float** %6
%223 = load i64, i64* %11
%224 = add i64 %223, 1
%225 = getelementptr inbounds float, float* %222, i64 %224
%226 = load float, float* %225
store float %226, float* %16
%227 = load float*, float** %6
%228 = load i64, i64* %8
%229 = getelementptr inbounds float, float* %227, i64 %228
%230 = load float, float* %229
%231 = load float*, float** %6
%232 = load i64, i64* %11
%233 = add i64 %232, 1
%234 = getelementptr inbounds float, float* %231, i64 %233
store float %230, float* %234
%235 = load float, float* %16
%236 = load float*, float** %6
%237 = load i64, i64* %8
%238 = getelementptr inbounds float, float* %236, i64 %237
store float %235, float* %238
br label %239
239: ; preds = %202, %191
%240 = load i32*, i32** %5
%241 = load i64, i64* %11
%242 = getelementptr inbounds i32, i32* %240, i64 %241
%243 = load i32, i32* %242
%244 = load i32*, i32** %5
%245 = load i64, i64* %11
%246 = add i64 %245, 1
%247 = getelementptr inbounds i32, i32* %244, i64 %246
%248 = load i32, i32* %247
%249 = icmp sgt i32 %243, %248
br i1 %249, label %250, label %287
250: ; preds = %239
%251 = load i32*, i32** %5
%252 = load i64, i64* %11
%253 = getelementptr inbounds i32, i32* %251, i64 %252
%254 = load i32, i32* %253
%255 = sitofp i32 %254 to float
store float %255, float* %16
%256 = load i32*, i32** %5
%257 = load i64, i64* %11
%258 = add i64 %257, 1
%259 = getelementptr inbounds i32, i32* %256, i64 %258
%260 = load i32, i32* %259
%261 = load i32*, i32** %5
%262 = load i64, i64* %11
%263 = getelementptr inbounds i32, i32* %261, i64 %262
store i32 %260, i32* %263
%264 = load float, float* %16
%265 = fptosi float %264 to i32
%266 = load i32*, i32** %5
%267 = load i64, i64* %11
%268 = add i64 %267, 1
%269 = getelementptr inbounds i32, i32* %266, i64 %268
store i32 %265, i32* %269
%270 = load float*, float** %6
%271 = load i64, i64* %11
%272 = getelementptr inbounds float, float* %270, i64 %271
%273 = load float, float* %272
store float %273, float* %16
%274 = load float*, float** %6
%275 = load i64, i64* %11
%276 = add i64 %275, 1
%277 = getelementptr inbounds float, float* %274, i64 %276
%278 = load float, float* %277
%279 = load float*, float** %6
%280 = load i64, i64* %11
%281 = getelementptr inbounds float, float* %279, i64 %280
store float %278, float* %281
%282 = load float, float* %16
%283 = load float*, float** %6
%284 = load i64, i64* %11
%285 = add i64 %284, 1
%286 = getelementptr inbounds float, float* %283, i64 %285
store float %282, float* %286
br label %287
287: ; preds = %250, %239
%288 = load i64, i64* %11
%289 = add i64 %288, 1
store i64 %289, i64* %7
%290 = load i64, i64* %8
store i64 %290, i64* %9
%291 = load i32*, i32** %5
%292 = load i64, i64* %11
%293 = add i64 %292, 1
%294 = getelementptr inbounds i32, i32* %291, i64 %293
%295 = load i32, i32* %294
%296 = sitofp i32 %295 to float
store float %296, float* %15
%297 = load float*, float** %6
%298 = load i64, i64* %11
%299 = add i64 %298, 1
%300 = getelementptr inbounds float, float* %297, i64 %299
%301 = load float, float* %300
store float %301, float* %12
br label %302
302: ; preds = %331, %287
br label %303
303: ; preds = %306, %302
%304 = load i64, i64* %7
%305 = add i64 %304, 1
store i64 %305, i64* %7
br label %306
306: ; preds = %303
%307 = load i32*, i32** %5
%308 = load i64, i64* %7
%309 = getelementptr inbounds i32, i32* %307, i64 %308
%310 = load i32, i32* %309
%311 = sitofp i32 %310 to float
%312 = load float, float* %15
%313 = fcmp olt float %311, %312
br i1 %313, label %303, label %314
314: ; preds = %306
br label %315
315: ; preds = %318, %314
%316 = load i64, i64* %9
%317 = add i64 %316, -1
store i64 %317, i64* %9
br label %318
318: ; preds = %315
%319 = load i32*, i32** %5
%320 = load i64, i64* %9
%321 = getelementptr inbounds i32, i32* %319, i64 %320
%322 = load i32, i32* %321
%323 = sitofp i32 %322 to float
%324 = load float, float* %15
%325 = fcmp ogt float %323, %324
br i1 %325, label %315, label %326
326: ; preds = %318
%327 = load i64, i64* %9
%328 = load i64, i64* %7
%329 = icmp ult i64 %327, %328
br i1 %329, label %330, label %331
330: ; preds = %326
br label %364
331: ; preds = %326
%332 = load i32*, i32** %5
%333 = load i64, i64* %7
%334 = getelementptr inbounds i32, i32* %332, i64 %333
%335 = load i32, i32* %334
%336 = sitofp i32 %335 to float
store float %336, float* %16
%337 = load i32*, i32** %5
%338 = load i64, i64* %9
%339 = getelementptr inbounds i32, i32* %337, i64 %338
%340 = load i32, i32* %339
%341 = load i32*, i32** %5
%342 = load i64, i64* %7
%343 = getelementptr inbounds i32, i32* %341, i64 %342
store i32 %340, i32* %343
%344 = load float, float* %16
%345 = fptosi float %344 to i32
%346 = load i32*, i32** %5
%347 = load i64, i64* %9
%348 = getelementptr inbounds i32, i32* %346, i64 %347
store i32 %345, i32* %348
%349 = load float*, float** %6
%350 = load i64, i64* %7
%351 = getelementptr inbounds float, float* %349, i64 %350
%352 = load float, float* %351
store float %352, float* %16
%353 = load float*, float** %6
%354 = load i64, i64* %9
%355 = getelementptr inbounds float, float* %353, i64 %354
%356 = load float, float* %355
%357 = load float*, float** %6
%358 = load i64, i64* %7
%359 = getelementptr inbounds float, float* %357, i64 %358
store float %356, float* %359
%360 = load float, float* %16
%361 = load float*, float** %6
%362 = load i64, i64* %9
%363 = getelementptr inbounds float, float* %361, i64 %362
store float %360, float* %363
br label %302
364: ; preds = %330
%365 = load i32*, i32** %5
%366 = load i64, i64* %9
%367 = getelementptr inbounds i32, i32* %365, i64 %366
%368 = load i32, i32* %367
%369 = load i32*, i32** %5
%370 = load i64, i64* %11
%371 = add i64 %370, 1
%372 = getelementptr inbounds i32, i32* %369, i64 %371
store i32 %368, i32* %372
%373 = load float*, float** %6
%374 = load i64, i64* %9
%375 = getelementptr inbounds float, float* %373, i64 %374
%376 = load float, float* %375
%377 = load float*, float** %6
%378 = load i64, i64* %11
%379 = add i64 %378, 1
%380 = getelementptr inbounds float, float* %377, i64 %379
store float %376, float* %380
%381 = load float, float* %15
%382 = fptosi float %381 to i32
%383 = load i32*, i32** %5
%384 = load i64, i64* %9
%385 = getelementptr inbounds i32, i32* %383, i64 %384
store i32 %382, i32* %385
%386 = load float, float* %12
%387 = load float*, float** %6
%388 = load i64, i64* %9
%389 = getelementptr inbounds float, float* %387, i64 %388
store float %386, float* %389
%390 = load i32, i32* %14
%391 = add nsw i32 %390, 2
store i32 %391, i32* %14
%392 = load i32, i32* %14
%393 = icmp sgt i32 %392, 200
br i1 %393, label %394, label %396
394: ; preds = %364
%395 = call i32 @nrerror(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
br label %396
396: ; preds = %394, %364
%397 = load i64, i64* %8
%398 = load i64, i64* %7
%399 = sub i64 %397, %398
%400 = add i64 %399, 1
%401 = load i64, i64* %9
%402 = sub i64 %401, 1
%403 = icmp uge i64 %400, %402
br i1 %403, label %404, label %418
404: ; preds = %396
%405 = load i64, i64* %8
%406 = load i64*, i64** %13
%407 = load i32, i32* %14
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i64, i64* %406, i64 %408
store i64 %405, i64* %409
%410 = load i64, i64* %7
%411 = load i64*, i64** %13
%412 = load i32, i32* %14
%413 = sub nsw i32 %412, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i64, i64* %411, i64 %414
store i64 %410, i64* %415
%416 = load i64, i64* %9
%417 = sub i64 %416, 1
store i64 %417, i64* %8
br label %432
418: ; preds = %396
%419 = load i64, i64* %9
%420 = sub i64 %419, 1
%421 = load i64*, i64** %13
%422 = load i32, i32* %14
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds i64, i64* %421, i64 %423
store i64 %420, i64* %424
%425 = load i64, i64* %11
%426 = load i64*, i64** %13
%427 = load i32, i32* %14
%428 = sub nsw i32 %427, 1
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i64, i64* %426, i64 %429
store i64 %425, i64* %430
%431 = load i64, i64* %7
store i64 %431, i64* %11
br label %432
432: ; preds = %418, %404
br label %433
433: ; preds = %432, %95
br label %19
434: ; preds = %94
%435 = load i64*, i64** %13
%436 = call i32 @free_lvector(i64* %435, i32 1, i32 200)
ret void
}

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