#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_ivector(int *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ nrerror(char *);
void indexx(int n, float arr[], int indx[]) {
  int i, indxt, ir = n, itemp, j, k, l = 1;
  int jstack = 0, *istack;
  float a;
  istack = ivector(1, 50);
  for (j = 1; j <= n; j++)
    indx[j] = j;
  for (;;) {
    if (ir - l < 7) {
      for (j = l + 1; j <= ir; j++) {
        indxt = indx[j];
        a = arr[indxt];
        for (i = j - 1; i >= 1; i--) {
          if (arr[indx[i]] <= a)
            break;
          indx[i + 1] = indx[i];
        }
        indx[i + 1] = indxt;
      }
      if (jstack == 0)
        break;
      ir = istack[jstack--];
      l = istack[jstack--];
    } else {
      k = (l + ir) >> 1;
      itemp = (indx[k]);
      (indx[k]) = (indx[l + 1]);
      (indx[l + 1]) = itemp;
      ;
      if (arr[indx[l + 1]] > arr[indx[ir]]) {
        itemp = (indx[l + 1]);
        (indx[l + 1]) = (indx[ir]);
        (indx[ir]) = itemp;
      }
      if (arr[indx[l]] > arr[indx[ir]]) {
        itemp = (indx[l]);
        (indx[l]) = (indx[ir]);
        (indx[ir]) = itemp;
      }
      if (arr[indx[l + 1]] > arr[indx[l]]) {
        itemp = (indx[l + 1]);
        (indx[l + 1]) = (indx[l]);
        (indx[l]) = itemp;
      }
      i = l + 1;
      j = ir;
      indxt = indx[l];
      a = arr[indxt];
      for (;;) {
        do
          i++;
        while (arr[indx[i]] < a);
        do
          j--;
        while (arr[indx[j]] > a);
        if (j < i)
          break;
        itemp = (indx[i]);
        (indx[i]) = (indx[j]);
        (indx[j]) = itemp;
      }
      indx[l] = indx[j];
      indx[j] = indxt;
      jstack += 2;
      if (jstack > 50)
        nrerror("NSTACK too small in indexx.");
      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;
      }
    }
  }
  free_ivector(istack, 1, 50);
}


x86 assembly (clang, -O0):
<indexx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <ivector@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1199 <indexx+0x69>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1171 <indexx+0x41>
jmp    119e <indexx+0x6e>
mov    -0x24(%rbp),%eax
sub    -0x34(%rbp),%eax
cmp    $0x7,%eax
jge    12ab <indexx+0x17b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1267 <indexx+0x137>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jl     1246 <indexx+0x116>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     121d <indexx+0xed>
jmp    1246 <indexx+0x116>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11eb <indexx+0xbb>
mov    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b6 <indexx+0x86>
cmpl   $0x0,-0x38(%rbp)
jne    1276 <indexx+0x146>
jmp    15c6 <indexx+0x496>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    15c1 <indexx+0x491>
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1363 <indexx+0x233>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    13c4 <indexx+0x294>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1434 <indexx+0x304>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    1468 <indexx+0x338>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x44(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1468 <indexx+0x338>
jmp    1499 <indexx+0x369>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x44(%rbp),%xmm0
ja     1499 <indexx+0x369>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14d2 <indexx+0x3a2>
jmp    1509 <indexx+0x3d9>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1463 <indexx+0x333>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x32,-0x38(%rbp)
jle    154c <indexx+0x41c>
lea    0xab9(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x24(%rbp),%eax
sub    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    -0x2c(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jl     1592 <indexx+0x462>
mov    -0x24(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%edx
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15bc <indexx+0x48c>
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    15c1 <indexx+0x491>
jmp    119e <indexx+0x6e>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x32,%edx
call   1040 <free_ivector@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<indexx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %edi,%r15d
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <ivector@plt>
mov    %rax,%r11
test   %r15d,%r15d
jle    12ed <indexx+0x1bd>
mov    %r15d,%eax
mov    $0x1,%ecx
cmp    $0x8,%r15d
jb     12d8 <indexx+0x1a8>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    11a2 <indexx+0x72>
movdqa 0xe65(%rip),%xmm0
xor    %esi,%esi
jmp    1285 <indexx+0x155>
and    $0xfffffffffffffffc,%rdi
movdqa 0xe52(%rip),%xmm0
xor    %esi,%esi
movdqa 0xe57(%rip),%xmm8
movdqa 0xe5e(%rip),%xmm9
movdqa 0xe65(%rip),%xmm10
movdqa 0xe6d(%rip),%xmm4
movdqa 0xe75(%rip),%xmm5
movdqa 0xe7d(%rip),%xmm6
movdqa 0xe85(%rip),%xmm7
movdqa 0xe8d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,0x4(%r14,%rsi,4)
movdqu %xmm2,0x14(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x24(%r14,%rsi,4)
movdqu %xmm3,0x34(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x44(%r14,%rsi,4)
movdqu %xmm3,0x54(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x64(%r14,%rsi,4)
movdqu %xmm3,0x74(%r14,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    1200 <indexx+0xd0>
test   %rdx,%rdx
je     12cf <indexx+0x19f>
movdqa 0xd7e(%rip),%xmm1
movdqa 0xd86(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
or     $0x4,%rdi
movdqu %xmm0,(%r14,%rdi,1)
movdqu %xmm3,0x10(%r14,%rdi,1)
add    $0x8,%rsi
paddd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rdx
jne    12a0 <indexx+0x170>
cmp    %rcx,%rax
je     12ed <indexx+0x1bd>
or     $0x1,%rcx
add    $0x1,%rax
nopl   0x0(%rax)
mov    %ecx,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12e0 <indexx+0x1b0>
lea    0x4(%r14),%rax
mov    %rax,0x40(%rsp)
xor    %r8d,%r8d
mov    $0x1,%edi
mov    %r11,0x20(%rsp)
jmp    1325 <indexx+0x1f5>
cs nopw 0x0(%rax,%rax,1)
nop
add    %ebp,%r12d
mov    0x10(%rsp),%rdx
mov    %edx,(%r11,%rcx,4)
mov    %r12d,0x4(%r11,%rax,4)
add    $0xffffffff,%r15d
movslq %r15d,%r10
lea    0x1(%r10),%eax
mov    %eax,0xc(%rsp)
mov    %r10,0x30(%rsp)
mov    %r15,0x10(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %r15d,%eax
sub    %edi,%eax
cmp    $0x6,%eax
jle    14e0 <indexx+0x3b0>
lea    (%rdi,%r15,1),%eax
sar    %eax
cltq
movslq (%r14,%rax,4),%rcx
movslq %edi,%r9
lea    0x1(%r9),%rdx
mov    0x4(%r14,%r9,4),%esi
mov    %esi,(%r14,%rax,4)
mov    %ecx,0x4(%r14,%r9,4)
movss  (%rbx,%rcx,4),%xmm0
movslq (%r14,%r10,4),%rax
movss  (%rbx,%rax,4),%xmm1
ucomiss %xmm1,%xmm0
mov    %r8,0x18(%rsp)
jbe    13a0 <indexx+0x270>
mov    %eax,(%r14,%rdx,4)
mov    %ecx,(%r14,%r10,4)
jmp    13a5 <indexx+0x275>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm1,%xmm0
mov    %eax,%ecx
movslq (%r14,%r9,4),%r8
movss  (%rbx,%r8,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    13c6 <indexx+0x296>
mov    %ecx,(%r14,%r9,4)
mov    %r8d,(%r14,%r10,4)
movslq (%r14,%r9,4),%r8
movss  (%rbx,%r8,4),%xmm1
movslq (%r14,%rdx,4),%rax
movss  (%rbx,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    13f0 <indexx+0x2c0>
mov    %r8d,(%r14,%rdx,4)
mov    %eax,(%r14,%r9,4)
mov    %eax,%r8d
jmp    13f3 <indexx+0x2c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm1,%xmm0
mov    %rdi,0x38(%rsp)
lea    0x1(%rdi),%r12d
nopl   0x0(%rax)
movslq %r12d,%rax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rdx
xor    %ebp,%ebp
xchg   %ax,%ax
movslq (%rdx,%rbp,4),%rsi
add    $0x1,%rbp
ucomiss (%rbx,%rsi,4),%xmm0
ja     1410 <indexx+0x2e0>
mov    %r12d,%r13d
mov    %r13,%r10
add    %rbp,%r10
movslq %r15d,%rax
lea    (%r14,%rax,4),%rcx
xchg   %ax,%ax
movslq -0x4(%rcx),%rax
add    $0xfffffffffffffffc,%rcx
movss  (%rbx,%rax,4),%xmm1
add    $0xffffffff,%r15d
ucomiss %xmm0,%xmm1
ja     1430 <indexx+0x300>
lea    0x1(%r15),%edi
cmp    %r10d,%edi
jle    1460 <indexx+0x330>
mov    %eax,-0x4(%rdx,%rbp,4)
mov    %esi,(%rcx)
mov    %r10d,%r12d
jmp    1400 <indexx+0x2d0>
nopw   0x0(%rax,%rax,1)
mov    %eax,(%r14,%r9,4)
mov    %r8d,(%rcx)
mov    0x18(%rsp),%rax
lea    0x2(%rax),%r8d
cmp    $0x31,%eax
jl     1495 <indexx+0x365>
lea    0xc14(%rip),%rdi
mov    %r8,0x28(%rsp)
call   1030 <nrerror@plt>
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%rax
mov    0x20(%rsp),%r11
mov    0xc(%rsp),%edx
sub    %r12d,%edx
sub    %ebp,%edx
mov    %r15d,%esi
mov    0x38(%rsp),%rdi
sub    %edi,%esi
movslq %r8d,%rcx
cltq
cmp    %esi,%edx
jge    1310 <indexx+0x1e0>
add    %rbp,%r13
add    $0xffffffff,%r15d
mov    %r15d,(%r11,%rcx,4)
mov    %edi,0x4(%r11,%rax,4)
mov    %r13d,%edi
mov    0x10(%rsp),%r15
mov    0x30(%rsp),%r10
jmp    1340 <indexx+0x210>
nopw   0x0(%rax,%rax,1)
cmp    %edi,%r15d
movabs $0x100000000,%rbp
jle    1550 <indexx+0x420>
movslq %edi,%rax
jmp    1514 <indexx+0x3e4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
shl    $0x20,%rdx
add    %rbp,%rdx
sar    $0x1e,%rdx
mov    %ecx,(%r14,%rdx,1)
cmp    %r10,%rax
je     1550 <indexx+0x420>
mov    %rax,%rdx
add    $0x1,%rax
movslq 0x4(%r14,%rdx,4),%rcx
test   %rdx,%rdx
jle    1500 <indexx+0x3d0>
movss  (%rbx,%rcx,4),%xmm0
mov    %edx,%edx
nopl   0x0(%rax)
movslq (%r14,%rdx,4),%rsi
ucomiss (%rbx,%rsi,4),%xmm0
jae    1500 <indexx+0x3d0>
mov    %esi,0x4(%r14,%rdx,4)
add    $0xffffffffffffffff,%rdx
lea    0x1(%rdx),%esi
cmp    $0x1,%esi
jg     1530 <indexx+0x400>
xor    %edx,%edx
jmp    1500 <indexx+0x3d0>
nop
test   %r8d,%r8d
je     156a <indexx+0x43a>
movslq %r8d,%rax
mov    -0x4(%r11,%rax,4),%edi
mov    (%r11,%rax,4),%r15d
add    $0xfffffffe,%r8d
jmp    1325 <indexx+0x1f5>
mov    %r11,%rdi
mov    $0x1,%esi
mov    $0x32,%edx
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_ivector@plt>

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

LLVM IR (-O2):
@.str = [28 x i8] c"NSTACK too small in indexx.\00"
define void @indexx(i32 %0, float* nocapture %1, i32* nocapture %2) {
%4 = tail call i32* @ivector(i32 1, i32 50)
%5 = icmp slt i32 %0, 1
br i1 %5, label %84, label %6
6: ; preds = %3
%7 = add nuw i32 %0, 1
%8 = zext i32 %7 to i64
%9 = add nsw i64 %8, -1
%10 = icmp ult i64 %9, 8
br i1 %10, label %76, label %11
11: ; preds = %6
%12 = and i64 %9, -8
%13 = or i64 %12, 1
%14 = add nsw i64 %12, -8
%15 = lshr exact i64 %14, 3
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 3
%18 = icmp ult i64 %14, 24
br i1 %18, label %56, label %19
19: ; preds = %11
%20 = and i64 %16, 4611686018427387900
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %52, %21 ]
%23 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %19 ], [ %53, %21 ]
%24 = phi i64 [ 0, %19 ], [ %54, %21 ]
%25 = or i64 %22, 1
%26 = add <4 x i32> %23, <i32 4, i32 4, i32 4, i32 4>
%27 = getelementptr inbounds i32, i32* %2, i64 %25
%28 = bitcast i32* %27 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %28
%29 = getelementptr inbounds i32, i32* %27, i64 4
%30 = bitcast i32* %29 to <4 x i32>*
store <4 x i32> %26, <4 x i32>* %30
%31 = add <4 x i32> %23, <i32 8, i32 8, i32 8, i32 8>
%32 = or i64 %22, 9
%33 = add <4 x i32> %23, <i32 12, i32 12, i32 12, i32 12>
%34 = getelementptr inbounds i32, i32* %2, i64 %32
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %35
%36 = getelementptr inbounds i32, i32* %34, i64 4
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %37
%38 = add <4 x i32> %23, <i32 16, i32 16, i32 16, i32 16>
%39 = or i64 %22, 17
%40 = add <4 x i32> %23, <i32 20, i32 20, i32 20, i32 20>
%41 = getelementptr inbounds i32, i32* %2, i64 %39
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %38, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %44
%45 = add <4 x i32> %23, <i32 24, i32 24, i32 24, i32 24>
%46 = or i64 %22, 25
%47 = add <4 x i32> %23, <i32 28, i32 28, i32 28, i32 28>
%48 = getelementptr inbounds i32, i32* %2, i64 %46
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %49
%50 = getelementptr inbounds i32, i32* %48, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %51
%52 = add nuw i64 %22, 32
%53 = add <4 x i32> %23, <i32 32, i32 32, i32 32, i32 32>
%54 = add i64 %24, 4
%55 = icmp eq i64 %54, %20
br i1 %55, label %56, label %21
56: ; preds = %21, %11
%57 = phi i64 [ 0, %11 ], [ %52, %21 ]
%58 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %11 ], [ %53, %21 ]
%59 = icmp eq i64 %17, 0
br i1 %59, label %74, label %60
60: ; preds = %56, %60
%61 = phi i64 [ %70, %60 ], [ %57, %56 ]
%62 = phi <4 x i32> [ %71, %60 ], [ %58, %56 ]
%63 = phi i64 [ %72, %60 ], [ 0, %56 ]
%64 = or i64 %61, 1
%65 = add <4 x i32> %62, <i32 4, i32 4, i32 4, i32 4>
%66 = getelementptr inbounds i32, i32* %2, i64 %64
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %66, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %69
%70 = add nuw i64 %61, 8
%71 = add <4 x i32> %62, <i32 8, i32 8, i32 8, i32 8>
%72 = add i64 %63, 1
%73 = icmp eq i64 %72, %17
br i1 %73, label %74, label %60
74: ; preds = %60, %56
%75 = icmp eq i64 %9, %12
br i1 %75, label %84, label %76
76: ; preds = %6, %74
%77 = phi i64 [ 1, %6 ], [ %13, %74 ]
br label %78
78: ; preds = %76, %78
%79 = phi i64 [ %82, %78 ], [ %77, %76 ]
%80 = getelementptr inbounds i32, i32* %2, i64 %79
%81 = trunc i64 %79 to i32
store i32 %81, i32* %80
%82 = add nuw nsw i64 %79, 1
%83 = icmp eq i64 %82, %8
br i1 %83, label %84, label %78
84: ; preds = %78, %74, %3
br label %85
85: ; preds = %144, %84
%86 = phi i32 [ %0, %84 ], [ %145, %144 ]
%87 = phi i32 [ 1, %84 ], [ %146, %144 ]
%88 = phi i32 [ 0, %84 ], [ %147, %144 ]
%89 = sext i32 %86 to i64
%90 = getelementptr inbounds i32, i32* %2, i64 %89
br label %91
91: ; preds = %85, %248
%92 = phi i32 [ %227, %248 ], [ %87, %85 ]
%93 = phi i32 [ %231, %248 ], [ %88, %85 ]
%94 = sub nsw i32 %86, %92
%95 = icmp slt i32 %94, 7
br i1 %95, label %96, label %148
96: ; preds = %91
%97 = icmp sgt i32 %86, %92
br i1 %97, label %98, label %133
98: ; preds = %96
%99 = sext i32 %92 to i64
%100 = sext i32 %86 to i64
br label %101
101: ; preds = %98, %126
%102 = phi i64 [ %99, %98 ], [ %103, %126 ]
%103 = add nsw i64 %102, 1
%104 = getelementptr inbounds i32, i32* %2, i64 %103
%105 = load i32, i32* %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %1, i64 %106
%108 = load float, float* %107
%109 = icmp sgt i64 %102, 0
br i1 %109, label %110, label %126
110: ; preds = %101
%111 = and i64 %102, 4294967295
br label %112
112: ; preds = %110, %120
%113 = phi i64 [ %111, %110 ], [ %124, %120 ]
%114 = getelementptr inbounds i32, i32* %2, i64 %113
%115 = load i32, i32* %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %1, i64 %116
%118 = load float, float* %117
%119 = fcmp ugt float %118, %108
br i1 %119, label %120, label %126
120: ; preds = %112
%121 = trunc i64 %113 to i32
%122 = add nuw nsw i64 %113, 1
%123 = getelementptr inbounds i32, i32* %2, i64 %122
store i32 %115, i32* %123
%124 = add nsw i64 %113, -1
%125 = icmp sgt i32 %121, 1
br i1 %125, label %112, label %126
126: ; preds = %120, %112, %101
%127 = phi i64 [ %102, %101 ], [ %113, %112 ], [ 0, %120 ]
%128 = shl i64 %127, 32
%129 = add i64 %128, 4294967296
%130 = ashr exact i64 %129, 32
%131 = getelementptr inbounds i32, i32* %2, i64 %130
store i32 %105, i32* %131
%132 = icmp eq i64 %103, %100
br i1 %132, label %133, label %101
133: ; preds = %126, %96
%134 = icmp eq i32 %93, 0
br i1 %134, label %255, label %135
135: ; preds = %133
%136 = add nsw i32 %93, -1
%137 = sext i32 %93 to i64
%138 = getelementptr inbounds i32, i32* %4, i64 %137
%139 = load i32, i32* %138
%140 = add nsw i32 %93, -2
%141 = sext i32 %136 to i64
%142 = getelementptr inbounds i32, i32* %4, i64 %141
%143 = load i32, i32* %142
br label %144
144: ; preds = %135, %239
%145 = phi i32 [ %247, %239 ], [ %139, %135 ]
%146 = phi i32 [ %92, %239 ], [ %143, %135 ]
%147 = phi i32 [ %231, %239 ], [ %140, %135 ]
br label %85
148: ; preds = %91
%149 = add nsw i32 %92, %86
%150 = ashr i32 %149, 1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %2, i64 %151
%153 = load i32, i32* %152
%154 = add nsw i32 %92, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %2, i64 %155
%157 = load i32, i32* %156
store i32 %157, i32* %152
store i32 %153, i32* %156
%158 = sext i32 %153 to i64
%159 = getelementptr inbounds float, float* %1, i64 %158
%160 = load float, float* %159
%161 = load i32, i32* %90
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %1, i64 %162
%164 = load float, float* %163
%165 = fcmp ogt float %160, %164
br i1 %165, label %166, label %167
166: ; preds = %148
store i32 %161, i32* %156
store i32 %153, i32* %90
br label %167
167: ; preds = %166, %148
%168 = phi float [ %160, %166 ], [ %164, %148 ]
%169 = phi i32 [ %153, %166 ], [ %161, %148 ]
%170 = sext i32 %92 to i64
%171 = getelementptr inbounds i32, i32* %2, i64 %170
%172 = load i32, i32* %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %1, i64 %173
%175 = load float, float* %174
%176 = fcmp ogt float %175, %168
br i1 %176, label %177, label %182
177: ; preds = %167
store i32 %169, i32* %171
store i32 %172, i32* %90
%178 = load i32, i32* %171
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %1, i64 %179
%181 = load float, float* %180
br label %182
182: ; preds = %177, %167
%183 = phi float [ %181, %177 ], [ %175, %167 ]
%184 = phi i32 [ %178, %177 ], [ %172, %167 ]
%185 = load i32, i32* %156
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float, float* %1, i64 %186
%188 = load float, float* %187
%189 = fcmp ogt float %188, %183
br i1 %189, label %190, label %191
190: ; preds = %182
store i32 %184, i32* %156
store i32 %185, i32* %171
br label %191
191: ; preds = %190, %182
%192 = phi float [ %188, %190 ], [ %183, %182 ]
%193 = phi i32 [ %185, %190 ], [ %184, %182 ]
br label %194
194: ; preds = %224, %191
%195 = phi i32 [ %86, %191 ], [ %225, %224 ]
%196 = phi i32 [ %154, %191 ], [ %209, %224 ]
%197 = sext i32 %196 to i64
br label %198
198: ; preds = %198, %194
%199 = phi i64 [ %200, %198 ], [ %197, %194 ]
%200 = add nsw i64 %199, 1
%201 = getelementptr inbounds i32, i32* %2, i64 %200
%202 = load i32, i32* %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %1, i64 %203
%205 = load float, float* %204
%206 = fcmp olt float %205, %192
br i1 %206, label %198, label %207
207: ; preds = %198
%208 = getelementptr inbounds i32, i32* %2, i64 %200
%209 = trunc i64 %200 to i32
%210 = sext i32 %195 to i64
br label %211
211: ; preds = %207, %211
%212 = phi i64 [ %210, %207 ], [ %213, %211 ]
%213 = add i64 %212, -1
%214 = getelementptr inbounds i32, i32* %2, i64 %213
%215 = load i32, i32* %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %1, i64 %216
%218 = load float, float* %217
%219 = fcmp ogt float %218, %192
br i1 %219, label %211, label %220
220: ; preds = %211
%221 = getelementptr inbounds i32, i32* %2, i64 %213
%222 = trunc i64 %212 to i32
%223 = icmp sgt i32 %222, %209
br i1 %223, label %224, label %226
224: ; preds = %220
%225 = trunc i64 %213 to i32
store i32 %215, i32* %208
store i32 %202, i32* %221
br label %194
226: ; preds = %220
%227 = trunc i64 %200 to i32
%228 = trunc i64 %199 to i32
%229 = trunc i64 %212 to i32
%230 = trunc i64 %213 to i32
store i32 %215, i32* %171
store i32 %193, i32* %221
%231 = add nsw i32 %93, 2
%232 = icmp sgt i32 %93, 48
br i1 %232, label %233, label %235
233: ; preds = %226
%234 = tail call i32 @nrerror(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
br label %235
235: ; preds = %233, %226
%236 = sub i32 %86, %228
%237 = sub nsw i32 %230, %92
%238 = icmp slt i32 %236, %237
br i1 %238, label %248, label %239
239: ; preds = %235
%240 = trunc i64 %200 to i32
%241 = trunc i64 %212 to i32
%242 = sext i32 %231 to i64
%243 = getelementptr inbounds i32, i32* %4, i64 %242
store i32 %86, i32* %243
%244 = add nsw i32 %93, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i32, i32* %4, i64 %245
store i32 %240, i32* %246
%247 = add nsw i32 %241, -2
br label %144
248: ; preds = %235
%249 = add nsw i32 %229, -2
%250 = sext i32 %231 to i64
%251 = getelementptr inbounds i32, i32* %4, i64 %250
store i32 %249, i32* %251
%252 = add nsw i32 %93, 1
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i32, i32* %4, i64 %253
store i32 %92, i32* %254
br label %91
255: ; preds = %133
%256 = tail call i32 @free_ivector(i32* %4, i32 1, i32 50)
ret void
}