#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, unsigned long);
int /*<<< orphan*/ free_vector(float *, int, unsigned long);
unsigned long *lvector(int, unsigned long);
float *vector(int, unsigned long);
void sort3(unsigned long n, float ra[], float rb[], float rc[]) {
  void indexx(unsigned long n, float arr[], unsigned long indx[]);
  unsigned long j, *iwksp;
  float *wksp;
  iwksp = lvector(1, n);
  wksp = vector(1, n);
  indexx(n, ra, iwksp);
  for (j = 1; j <= n; j++)
    wksp[j] = ra[j];
  for (j = 1; j <= n; j++)
    ra[j] = wksp[iwksp[j]];
  for (j = 1; j <= n; j++)
    wksp[j] = rb[j];
  for (j = 1; j <= n; j++)
    rb[j] = wksp[iwksp[j]];
  for (j = 1; j <= n; j++)
    wksp[j] = rc[j];
  for (j = 1; j <= n; j++)
    rc[j] = wksp[iwksp[j]];
  free_vector(wksp, 1, n);
  free_lvector(iwksp, 1, n);
}


x86 assembly (clang, -O0):
<sort3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1070 <lvector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rsi
mov    $0x1,%edi
call   1060 <vector@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <indexx@plt>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     11de <sort3+0x8e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11a5 <sort3+0x55>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     1227 <sort3+0xd7>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11e6 <sort3+0x96>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     1268 <sort3+0x118>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    122f <sort3+0xdf>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     12b1 <sort3+0x161>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1270 <sort3+0x120>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     12f2 <sort3+0x1a2>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12b9 <sort3+0x169>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     133b <sort3+0x1eb>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12fa <sort3+0x1aa>
mov    -0x38(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1050 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    $0x1,%esi
call   1040 <free_lvector@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%rbp
mov    %rdi,%r14
mov    $0x1,%edi
mov    %r14,%rsi
call   1070 <lvector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r14,%rsi
call   1060 <vector@plt>
mov    %rax,%rbx
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
call   1030 <indexx@plt>
test   %r14,%r14
je     1897 <sort3+0x747>
mov    $0x1,%eax
cmp    $0x8,%r14
jb     12a6 <sort3+0x156>
lea    0x4(%rbx),%rcx
lea    0x4(,%r14,4),%rdx
add    %rbp,%rdx
cmp    %rdx,%rcx
jae    11d6 <sort3+0x86>
lea    (%rbx,%r14,4),%rcx
add    $0x4,%rcx
lea    0x4(%rbp),%rdx
cmp    %rcx,%rdx
jb     12a6 <sort3+0x156>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdx
jae    11fb <sort3+0xab>
xor    %edx,%edx
jmp    126a <sort3+0x11a>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rbp,%rdx,4),%xmm0
movups 0x14(%rbp,%rdx,4),%xmm1
movups %xmm0,0x4(%rbx,%rdx,4)
movups %xmm1,0x14(%rbx,%rdx,4)
movups 0x24(%rbp,%rdx,4),%xmm0
movups 0x34(%rbp,%rdx,4),%xmm1
movups %xmm0,0x24(%rbx,%rdx,4)
movups %xmm1,0x34(%rbx,%rdx,4)
movups 0x44(%rbp,%rdx,4),%xmm0
movups 0x54(%rbp,%rdx,4),%xmm1
movups %xmm0,0x44(%rbx,%rdx,4)
movups %xmm1,0x54(%rbx,%rdx,4)
movups 0x64(%rbp,%rdx,4),%xmm0
movups 0x74(%rbp,%rdx,4),%xmm1
movups %xmm0,0x64(%rbx,%rdx,4)
movups %xmm1,0x74(%rbx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1210 <sort3+0xc0>
test   %rcx,%rcx
je     1299 <sort3+0x149>
nop
lea    0x0(,%rdx,4),%rsi
or     $0x4,%rsi
movups 0x0(%rbp,%rsi,1),%xmm0
movups 0x10(%rbp,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rdx
add    $0xffffffffffffffff,%rcx
jne    1270 <sort3+0x120>
cmp    %r14,%rax
je     1337 <sort3+0x1e7>
or     $0x1,%rax
mov    %r14d,%edx
sub    %eax,%edx
add    $0x1,%edx
mov    %r14,%rcx
sub    %rax,%rcx
and    $0x3,%rdx
je     12d5 <sort3+0x185>
nopw   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    12c0 <sort3+0x170>
cmp    $0x3,%rcx
jb     1337 <sort3+0x1e7>
mov    %r14,%rcx
sub    %rax,%rcx
lea    (%rbx,%rax,4),%rdx
add    $0xc,%rdx
lea    0xc(,%rax,4),%rax
add    %rbp,%rax
mov    $0xffffffffffffffff,%rsi
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rax,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rsi,4)
movss  -0x4(%rax,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rsi,4)
movss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1300 <sort3+0x1b0>
test   %r14,%r14
je     1897 <sort3+0x747>
lea    -0x1(%r14),%rax
mov    %r14d,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rax
jb     13ad <sort3+0x25d>
mov    %r14,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
xchg   %ax,%ax
mov    0x8(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rbp,%rdx,4)
mov    0x10(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rbp,%rdx,4)
mov    0x18(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0xc(%rbp,%rdx,4)
mov    0x20(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x10(%rbp,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1360 <sort3+0x210>
add    $0x1,%rdx
test   %rcx,%rcx
je     13e7 <sort3+0x297>
lea    0x0(,%rdx,4),%rsi
add    %rbp,%rsi
lea    (%r15,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdx,%rdi,8),%rbp
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    13d0 <sort3+0x280>
test   %r14,%r14
je     1897 <sort3+0x747>
mov    $0x1,%ecx
cmp    $0x8,%r14
jb     1508 <sort3+0x3b8>
lea    0x4(%rbx),%rdx
lea    0x4(,%r14,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rdx
jae    1428 <sort3+0x2d8>
lea    (%rbx,%r14,4),%rdx
add    $0x4,%rdx
lea    0x4(%r13),%rsi
cmp    %rdx,%rsi
jb     1508 <sort3+0x3b8>
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    144d <sort3+0x2fd>
xor    %esi,%esi
jmp    14c2 <sort3+0x372>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r13,%rsi,4),%xmm0
movups 0x14(%r13,%rsi,4),%xmm1
movups %xmm0,0x4(%rbx,%rsi,4)
movups %xmm1,0x14(%rbx,%rsi,4)
movups 0x24(%r13,%rsi,4),%xmm0
movups 0x34(%r13,%rsi,4),%xmm1
movups %xmm0,0x24(%rbx,%rsi,4)
movups %xmm1,0x34(%rbx,%rsi,4)
movups 0x44(%r13,%rsi,4),%xmm0
movups 0x54(%r13,%rsi,4),%xmm1
movups %xmm0,0x44(%rbx,%rsi,4)
movups %xmm1,0x54(%rbx,%rsi,4)
movups 0x64(%r13,%rsi,4),%xmm0
movups 0x74(%r13,%rsi,4),%xmm1
movups %xmm0,0x64(%rbx,%rsi,4)
movups %xmm1,0x74(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1460 <sort3+0x310>
test   %rdx,%rdx
je     14fb <sort3+0x3ab>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
jne    14d0 <sort3+0x380>
cmp    %r14,%rcx
je     1597 <sort3+0x447>
or     $0x1,%rcx
mov    %r14d,%esi
sub    %ecx,%esi
add    $0x1,%esi
mov    %r14,%rdx
sub    %rcx,%rdx
and    $0x3,%rsi
je     1536 <sort3+0x3e6>
nopl   0x0(%rax)
movss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1520 <sort3+0x3d0>
cmp    $0x3,%rdx
jb     1597 <sort3+0x447>
mov    %r14,%rdx
sub    %rcx,%rdx
lea    (%rbx,%rcx,4),%rsi
add    $0xc,%rsi
lea    0xc(,%rcx,4),%rcx
add    %r13,%rcx
mov    $0xffffffffffffffff,%rdi
nopl   0x0(%rax)
movss  -0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdi,4)
movss  -0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdi,4)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rsi,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1560 <sort3+0x410>
test   %r14,%r14
je     1897 <sort3+0x747>
mov    %r14d,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rax
jb     1611 <sort3+0x4c1>
mov    %r14,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x4(%r13,%rdx,4)
mov    0x10(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x8(%r13,%rdx,4)
mov    0x18(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0xc(%r13,%rdx,4)
mov    0x20(%r15,%rdx,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,0x10(%r13,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    15c0 <sort3+0x470>
add    $0x1,%rdx
test   %rcx,%rcx
je     1647 <sort3+0x4f7>
lea    0x0(,%rdx,4),%rsi
add    %r13,%rsi
lea    (%r15,%rdx,8),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rbp
movss  (%rbx,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1630 <sort3+0x4e0>
test   %r14,%r14
je     1897 <sort3+0x747>
mov    $0x1,%ecx
cmp    $0x8,%r14
jb     1767 <sort3+0x617>
lea    0x4(%rbx),%rdx
lea    (%r12,%r14,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    1686 <sort3+0x536>
lea    (%rbx,%r14,4),%rdx
add    $0x4,%rdx
lea    0x4(%r12),%rsi
cmp    %rdx,%rsi
jb     1767 <sort3+0x617>
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    16ab <sort3+0x55b>
xor    %esi,%esi
jmp    1722 <sort3+0x5d2>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%r12,%rsi,4),%xmm0
movups 0x14(%r12,%rsi,4),%xmm1
movups %xmm0,0x4(%rbx,%rsi,4)
movups %xmm1,0x14(%rbx,%rsi,4)
movups 0x24(%r12,%rsi,4),%xmm0
movups 0x34(%r12,%rsi,4),%xmm1
movups %xmm0,0x24(%rbx,%rsi,4)
movups %xmm1,0x34(%rbx,%rsi,4)
movups 0x44(%r12,%rsi,4),%xmm0
movups 0x54(%r12,%rsi,4),%xmm1
movups %xmm0,0x44(%rbx,%rsi,4)
movups %xmm1,0x54(%rbx,%rsi,4)
movups 0x64(%r12,%rsi,4),%xmm0
movups 0x74(%r12,%rsi,4),%xmm1
movups %xmm0,0x64(%rbx,%rsi,4)
movups %xmm1,0x74(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    16c0 <sort3+0x570>
test   %rdx,%rdx
je     175a <sort3+0x60a>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rsi,4),%rdi
or     $0x4,%rdi
movups (%r12,%rdi,1),%xmm0
movups 0x10(%r12,%rdi,1),%xmm1
movups %xmm0,(%rbx,%rdi,1)
movups %xmm1,0x10(%rbx,%rdi,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rdx
jne    1730 <sort3+0x5e0>
cmp    %r14,%rcx
je     17f7 <sort3+0x6a7>
or     $0x1,%rcx
mov    %r14d,%esi
sub    %ecx,%esi
add    $0x1,%esi
mov    %r14,%rdx
sub    %rcx,%rdx
and    $0x3,%rsi
je     1795 <sort3+0x645>
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1780 <sort3+0x630>
cmp    $0x3,%rdx
jb     17f7 <sort3+0x6a7>
mov    %r14,%rdx
sub    %rcx,%rdx
lea    (%rbx,%rcx,4),%rsi
add    $0xc,%rsi
lea    (%r12,%rcx,4),%rcx
add    $0xc,%rcx
mov    $0xffffffffffffffff,%rdi
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdi,4)
movss  -0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdi,4)
movss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movss  0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rsi,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    17c0 <sort3+0x670>
test   %r14,%r14
je     1897 <sort3+0x747>
mov    %r14d,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rax
jb     1871 <sort3+0x721>
mov    %r14,%rax
and    $0xfffffffffffffffc,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r15,%rdx,8),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%r12,%rdx,4)
mov    0x10(%r15,%rdx,8),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x8(%r12,%rdx,4)
mov    0x18(%r15,%rdx,8),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0xc(%r12,%rdx,4)
mov    0x20(%r15,%rdx,8),%rsi
movss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,0x10(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1820 <sort3+0x6d0>
add    $0x1,%rdx
test   %rcx,%rcx
je     1897 <sort3+0x747>
lea    (%r12,%rdx,4),%rax
lea    (%r15,%rdx,8),%rdx
xor    %esi,%esi
mov    (%rdx,%rsi,8),%rdi
movss  (%rbx,%rdi,4),%xmm0
movss  %xmm0,(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1880 <sort3+0x730>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1050 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_lvector@plt>

LLVM IR (-O0):
define void @sort3(i64 %0, float* %1, float* %2, float* %3) {
%5 = alloca i64
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca i64
%10 = alloca i64*
%11 = alloca float*
store i64 %0, i64* %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
%12 = load i64, i64* %5
%13 = call i64* @lvector(i32 1, i64 %12)
store i64* %13, i64** %10
%14 = load i64, i64* %5
%15 = call float* @vector(i32 1, i64 %14)
store float* %15, float** %11
%16 = load i64, i64* %5
%17 = load float*, float** %6
%18 = load i64*, i64** %10
store i64 1, i64* %9
br label %19
19: ; preds = %31, %4
%20 = load i64, i64* %9
%21 = load i64, i64* %5
%22 = icmp ule i64 %20, %21
br i1 %22, label %23, label %34
23: ; preds = %19
%24 = load float*, float** %6
%25 = load i64, i64* %9
%26 = getelementptr inbounds float, float* %24, i64 %25
%27 = load float, float* %26
%28 = load float*, float** %11
%29 = load i64, i64* %9
%30 = getelementptr inbounds float, float* %28, i64 %29
store float %27, float* %30
br label %31
31: ; preds = %23
%32 = load i64, i64* %9
%33 = add i64 %32, 1
store i64 %33, i64* %9
br label %19
34: ; preds = %19
store i64 1, i64* %9
br label %35
35: ; preds = %50, %34
%36 = load i64, i64* %9
%37 = load i64, i64* %5
%38 = icmp ule i64 %36, %37
br i1 %38, label %39, label %53
39: ; preds = %35
%40 = load float*, float** %11
%41 = load i64*, i64** %10
%42 = load i64, i64* %9
%43 = getelementptr inbounds i64, i64* %41, i64 %42
%44 = load i64, i64* %43
%45 = getelementptr inbounds float, float* %40, i64 %44
%46 = load float, float* %45
%47 = load float*, float** %6
%48 = load i64, i64* %9
%49 = getelementptr inbounds float, float* %47, i64 %48
store float %46, float* %49
br label %50
50: ; preds = %39
%51 = load i64, i64* %9
%52 = add i64 %51, 1
store i64 %52, i64* %9
br label %35
53: ; preds = %35
store i64 1, i64* %9
br label %54
54: ; preds = %66, %53
%55 = load i64, i64* %9
%56 = load i64, i64* %5
%57 = icmp ule i64 %55, %56
br i1 %57, label %58, label %69
58: ; preds = %54
%59 = load float*, float** %7
%60 = load i64, i64* %9
%61 = getelementptr inbounds float, float* %59, i64 %60
%62 = load float, float* %61
%63 = load float*, float** %11
%64 = load i64, i64* %9
%65 = getelementptr inbounds float, float* %63, i64 %64
store float %62, float* %65
br label %66
66: ; preds = %58
%67 = load i64, i64* %9
%68 = add i64 %67, 1
store i64 %68, i64* %9
br label %54
69: ; preds = %54
store i64 1, i64* %9
br label %70
70: ; preds = %85, %69
%71 = load i64, i64* %9
%72 = load i64, i64* %5
%73 = icmp ule i64 %71, %72
br i1 %73, label %74, label %88
74: ; preds = %70
%75 = load float*, float** %11
%76 = load i64*, i64** %10
%77 = load i64, i64* %9
%78 = getelementptr inbounds i64, i64* %76, i64 %77
%79 = load i64, i64* %78
%80 = getelementptr inbounds float, float* %75, i64 %79
%81 = load float, float* %80
%82 = load float*, float** %7
%83 = load i64, i64* %9
%84 = getelementptr inbounds float, float* %82, i64 %83
store float %81, 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 %70
88: ; preds = %70
store i64 1, i64* %9
br label %89
89: ; preds = %101, %88
%90 = load i64, i64* %9
%91 = load i64, i64* %5
%92 = icmp ule i64 %90, %91
br i1 %92, label %93, label %104
93: ; preds = %89
%94 = load float*, float** %8
%95 = load i64, i64* %9
%96 = getelementptr inbounds float, float* %94, i64 %95
%97 = load float, float* %96
%98 = load float*, float** %11
%99 = load i64, i64* %9
%100 = getelementptr inbounds float, float* %98, i64 %99
store float %97, float* %100
br label %101
101: ; preds = %93
%102 = load i64, i64* %9
%103 = add i64 %102, 1
store i64 %103, i64* %9
br label %89
104: ; preds = %89
store i64 1, i64* %9
br label %105
105: ; preds = %120, %104
%106 = load i64, i64* %9
%107 = load i64, i64* %5
%108 = icmp ule i64 %106, %107
br i1 %108, label %109, label %123
109: ; preds = %105
%110 = load float*, float** %11
%111 = load i64*, i64** %10
%112 = load i64, i64* %9
%113 = getelementptr inbounds i64, i64* %111, i64 %112
%114 = load i64, i64* %113
%115 = getelementptr inbounds float, float* %110, i64 %114
%116 = load float, float* %115
%117 = load float*, float** %8
%118 = load i64, i64* %9
%119 = getelementptr inbounds float, float* %117, i64 %118
store float %116, float* %119
br label %120
120: ; preds = %109
%121 = load i64, i64* %9
%122 = add i64 %121, 1
store i64 %122, i64* %9
br label %105
123: ; preds = %105
%124 = load float*, float** %11
%125 = load i64, i64* %5
%126 = call i32 @free_vector(float* %124, i32 1, i64 %125)
%127 = load i64*, i64** %10
%128 = load i64, i64* %5
%129 = call i32 @free_lvector(i64* %127, i32 1, i64 %128)
ret void
}

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