#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_vector(float *, int, unsigned long);
int /*<<< orphan*/ myrank(unsigned long, float *);
float sqrt(float);
float *vector(int, unsigned long);
float spearman(float *data1, float *data2, unsigned long n) {
  float *x, *y;
  float mean_x, mean_y, std_x, std_y;
  float sum_x, sum_y, sum_x2, sum_y2;
  float cov, sum_xy;
  unsigned long i;
  float rs;
  x = vector(1, n);
  y = vector(1, n);
  for (i = 1; i <= n; i++) {
    x[i] = data1[i];
    y[i] = data2[i];
  }
  myrank(n, x);
  myrank(n, y);
  sum_x = 0;
  sum_y = 0;
  sum_x2 = 0;
  sum_y2 = 0;
  for (i = 1; i <= n; i++) {
    sum_x += x[i];
    sum_x2 += (x[i] * x[i]);
    sum_y += y[i];
    sum_y2 += (y[i] * y[i]);
  }
  mean_x = sum_x / n;
  mean_y = sum_y / n;
  std_x = sum_x2 / n - mean_x * mean_x;
  std_y = sum_y2 / n - mean_y * mean_y;
  if ((std_x <= 0) | (std_y <= 0)) {
    rs = 0;
  } else {
    std_x = sqrt(std_x * n / (n - 1));
    std_y = sqrt(std_y * n / (n - 1));
    cov = 0;
    sum_xy = 0;
    for (i = 1; i <= n; i++) {
      cov += (x[i] - mean_x) * (y[i] - mean_y);
      sum_xy += (x[i] * y[i]);
    }
    cov = cov / (n - 1);
    rs = cov / (std_x * std_y);
  }
  free_vector(x, 1, n);
  free_vector(y, 1, n);
  return rs;
}


x86 assembly (clang, -O0):
<spearman>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rsi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rsi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x28(%rbp)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     11d6 <spearman+0x96>
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1183 <spearman+0x43>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1050 <myrank@plt>
mov    -0x18(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1050 <myrank@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     12bd <spearman+0x17d>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1218 <spearman+0xd8>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x64(%rbp)
test   %rax,%rax
movss  %xmm0,-0x60(%rbp)
js     1304 <spearman+0x1c4>
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm0
movss  -0x60(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x70(%rbp)
test   %rax,%rax
movss  %xmm0,-0x6c(%rbp)
js     135e <spearman+0x21e>
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x7c(%rbp)
test   %rax,%rax
movss  %xmm0,-0x78(%rbp)
js     13b8 <spearman+0x278>
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x78(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x88(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x84(%rbp)
ff
js     142e <spearman+0x2ee>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x8c(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
ff
divss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x34(%rbp),%xmm0
setae  %al
and    $0x1,%al
movzbl %al,%eax
xorps  %xmm0,%xmm0
ucomiss -0x38(%rbp),%xmm0
setae  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
cmp    $0x0,%eax
je     149d <spearman+0x35d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    178f <spearman+0x64f>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x94(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x90(%rbp)
ff
js     14fa <spearman+0x3ba>
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xa0(%rbp),%rax
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
add    $0xffffffffffffffff,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xac(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xa8(%rbp)
ff
js     1566 <spearman+0x426>
movss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  -0xa8(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x34(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xb8(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xb4(%rbp)
ff
js     15e1 <spearman+0x4a1>
movss  -0xb8(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0xc0(%rbp),%rax
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
add    $0xffffffffffffffff,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xcc(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xc8(%rbp)
ff
js     164d <spearman+0x50d>
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movq   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     1704 <spearman+0x5c4>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
subss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1683 <spearman+0x543>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xd8(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xd4(%rbp)
ff
js     175e <spearman+0x61e>
movss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xd4(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    $0x1,%esi
call   1030 <free_vector@plt>
mov    -0x28(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    $0x1,%esi
call   1030 <free_vector@plt>
movss  -0x5c(%rbp),%xmm0
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spearman>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%r12
mov    $0x1,%edi
mov    %rdx,%rsi
call   1040 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    %r14,%rsi
call   1040 <vector@plt>
mov    %rax,%rbp
test   %r14,%r14
je     122a <spearman+0xea>
mov    $0x1,%eax
cmp    $0x8,%r14
jae    1245 <spearman+0x105>
mov    %rax,%rdi
test   $0x1,%r14b
je     11b5 <spearman+0x75>
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r15,%rax,4)
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
lea    0x1(%rax),%rdi
cmp    %r14,%rax
je     13be <spearman+0x27e>
mov    %r14,%rax
sub    %rdi,%rax
add    $0x1,%rax
lea    0x4(,%rdi,4),%rcx
add    %rbp,%rcx
lea    0x4(,%rdi,4),%rdx
add    %r13,%rdx
lea    (%r15,%rdi,4),%rsi
add    $0x4,%rsi
lea    (%r12,%rdi,4),%rdi
add    $0x4,%rdi
xor    %ebx,%ebx
movss  -0x4(%rdi,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rbx,4)
movss  -0x4(%rdx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rbx,4)
movss  (%rdi,%rbx,4),%xmm0
movss  %xmm0,(%rsi,%rbx,4)
movss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rax
jne    11f0 <spearman+0xb0>
jmp    13be <spearman+0x27e>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <myrank@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
call   1050 <myrank@plt>
jmp    13f5 <spearman+0x2b5>
lea    0x4(%r15),%rdx
lea    (%r15,%r14,4),%rsi
add    $0x4,%rsi
lea    0x4(%rbp),%rdi
lea    0x4(%rbp,%r14,4),%rbx
lea    0x4(%r12),%r9
lea    (%r12,%r14,4),%rcx
add    $0x4,%rcx
lea    0x4(%r13),%r8
lea    0x4(,%r14,4),%r11
add    %r13,%r11
cmp    %rbx,%rdx
setb   0x10(%rsp)
cmp    %rsi,%rdi
setb   0xc(%rsp)
cmp    %rcx,%rdx
setb   %r10b
cmp    %rsi,%r9
setb   0x20(%rsp)
cmp    %r11,%rdx
setb   %dl
cmp    %rsi,%r8
setb   0x30(%rsp)
cmp    %rcx,%rdi
setb   %sil
cmp    %rbx,%r9
setb   %r9b
cmp    %r11,%rdi
setb   %dil
cmp    %rbx,%r8
setb   %cl
mov    0xc(%rsp),%bl
test   %bl,0x10(%rsp)
jne    118f <spearman+0x4f>
and    0x20(%rsp),%r10b
jne    118f <spearman+0x4f>
and    0x30(%rsp),%dl
jne    118f <spearman+0x4f>
and    %r9b,%sil
jne    118f <spearman+0x4f>
and    %cl,%dil
jne    118f <spearman+0x4f>
mov    %r14,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1693 <spearman+0x553>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ecx
xchg   %ax,%ax
movups (%r12,%rcx,4),%xmm0
movups 0x10(%r12,%rcx,4),%xmm1
movups %xmm0,(%r15,%rcx,4)
movups %xmm1,0x10(%r15,%rcx,4)
movups 0x0(%r13,%rcx,4),%xmm0
movups 0x10(%r13,%rcx,4),%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
movups 0x20(%r12,%rcx,4),%xmm0
movups 0x30(%r12,%rcx,4),%xmm1
movups %xmm0,0x20(%r15,%rcx,4)
movups %xmm1,0x30(%r15,%rcx,4)
movups 0x20(%r13,%rcx,4),%xmm0
movups 0x30(%r13,%rcx,4),%xmm1
movups %xmm0,0x20(%rbp,%rcx,4)
movups %xmm1,0x30(%rbp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1320 <spearman+0x1e0>
test   $0x1,%dl
je     13b5 <spearman+0x275>
movups (%r12,%rcx,4),%xmm0
movups 0x10(%r12,%rcx,4),%xmm1
movups %xmm0,(%r15,%rcx,4)
movups %xmm1,0x10(%r15,%rcx,4)
movups 0x0(%r13,%rcx,4),%xmm0
movups 0x10(%r13,%rcx,4),%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
cmp    %r14,%rax
jne    168a <spearman+0x54a>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <myrank@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
call   1050 <myrank@plt>
test   %r14,%r14
je     13f5 <spearman+0x2b5>
cmp    $0x1,%r14
jne    1400 <spearman+0x2c0>
xorps  %xmm0,%xmm0
mov    $0x1,%eax
xorps  %xmm4,%xmm4
test   $0x1,%r14b
jne    146f <spearman+0x32f>
jmp    1487 <spearman+0x347>
xorps  %xmm5,%xmm5
xorps  %xmm4,%xmm4
jmp    1487 <spearman+0x347>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorps  %xmm0,%xmm0
mov    $0x1,%eax
xorps  %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rax,4),%xmm2
movss  0x4(%rbp,%rax,4),%xmm3
movss  (%r15,%rax,4),%xmm1
unpcklps %xmm2,%xmm1
movss  0x4(%r15,%rax,4),%xmm5
unpcklps %xmm3,%xmm5
addps  %xmm1,%xmm4
mulps  %xmm1,%xmm1
addps  %xmm0,%xmm1
addps  %xmm5,%xmm4
mulps  %xmm5,%xmm5
movaps %xmm5,%xmm0
addps  %xmm1,%xmm0
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1420 <spearman+0x2e0>
addps  %xmm1,%xmm5
test   $0x1,%r14b
je     1487 <spearman+0x347>
movss  0x0(%rbp,%rax,4),%xmm1
movss  (%r15,%rax,4),%xmm5
unpcklps %xmm1,%xmm5
addps  %xmm5,%xmm4
mulps  %xmm5,%xmm5
addps  %xmm0,%xmm5
test   %r14,%r14
js     1496 <spearman+0x356>
xorps  %xmm3,%xmm3
cvtsi2ss %r14,%xmm3
jmp    14b1 <spearman+0x371>
mov    %r14,%rax
shr    %rax
mov    %r14d,%ecx
and    $0x1,%ecx
or     %rax,%rcx
xorps  %xmm3,%xmm3
cvtsi2ss %rcx,%xmm3
addss  %xmm3,%xmm3
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
divps  %xmm0,%xmm4
divps  %xmm0,%xmm5
movaps %xmm4,%xmm0
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm5
xorps  %xmm0,%xmm0
movaps %xmm5,%xmm1
cmpleps %xmm0,%xmm1
unpcklps %xmm1,%xmm1
movmskpd %xmm1,%eax
xorps  %xmm2,%xmm2
test   %eax,%eax
jne    164f <spearman+0x50f>
movaps %xmm5,%xmm0
mulss  %xmm3,%xmm0
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
js     14fa <spearman+0x3ba>
cvtsi2ss %rax,%xmm9
jmp    1510 <spearman+0x3d0>
mov    %rax,%rcx
shr    %rcx
and    $0x1,%eax
or     %rcx,%rax
cvtsi2ss %rax,%xmm9
addss  %xmm9,%xmm9
divss  %xmm9,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
movaps %xmm4,0x10(%rsp)
movss  %xmm9,0xc(%rsp)
jb     1530 <spearman+0x3f0>
sqrtss %xmm0,%xmm8
jmp    1557 <spearman+0x417>
movaps %xmm5,0x20(%rsp)
movaps %xmm3,0x30(%rsp)
call   1060 <sqrt@plt>
xorps  %xmm1,%xmm1
movaps 0x30(%rsp),%xmm3
movss  0xc(%rsp),%xmm9
movaps 0x20(%rsp),%xmm5
movaps %xmm0,%xmm8
shufps $0x55,%xmm5,%xmm5
mulss  %xmm3,%xmm5
divss  %xmm9,%xmm5
ucomiss %xmm1,%xmm5
jb     1572 <spearman+0x432>
xorps  %xmm0,%xmm0
sqrtss %xmm5,%xmm0
jmp    158f <spearman+0x44f>
movaps %xmm5,%xmm0
movss  %xmm8,0x20(%rsp)
call   1060 <sqrt@plt>
movss  0x20(%rsp),%xmm8
movss  0xc(%rsp),%xmm9
movaps 0x10(%rsp),%xmm6
test   %r14,%r14
je     15b0 <spearman+0x470>
movaps %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm1
cmp    $0x1,%r14
jne    15b8 <spearman+0x478>
xorps  %xmm2,%xmm2
mov    $0x1,%eax
jmp    161e <spearman+0x4de>
xorps  %xmm2,%xmm2
jmp    1640 <spearman+0x500>
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorps  %xmm7,%xmm7
mov    $0x1,%eax
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm3
movss  0x4(%r15,%rax,4),%xmm4
subss  %xmm6,%xmm3
movss  0x0(%rbp,%rax,4),%xmm5
movss  0x4(%rbp,%rax,4),%xmm2
subss  %xmm1,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm7,%xmm5
subss  %xmm6,%xmm4
subss  %xmm1,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm5,%xmm2
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
movaps %xmm2,%xmm7
cmp    $0x1,%rdx
jne    15d0 <spearman+0x490>
test   $0x1,%r14b
je     1640 <spearman+0x500>
movss  (%r15,%rax,4),%xmm4
subss  %xmm6,%xmm4
movss  0x0(%rbp,%rax,4),%xmm3
subss  %xmm1,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm3,%xmm2
divss  %xmm9,%xmm2
mulss  %xmm0,%xmm8
divss  %xmm8,%xmm2
movss  %xmm2,0x10(%rsp)
mov    %r15,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1030 <free_vector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %r14,%rdx
call   1030 <free_vector@plt>
movss  0x10(%rsp),%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    118f <spearman+0x4f>
mov    $0x1,%ecx
test   $0x1,%dl
jne    1389 <spearman+0x249>
jmp    13b5 <spearman+0x275>

LLVM IR (-O0):
define float @spearman(float* %0, float* %1, i64 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i64
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca i64
%20 = alloca float
store float* %0, float** %4
store float* %1, float** %5
store i64 %2, i64* %6
%21 = load i64, i64* %6
%22 = call float* @vector(i32 1, i64 %21)
store float* %22, float** %7
%23 = load i64, i64* %6
%24 = call float* @vector(i32 1, i64 %23)
store float* %24, float** %8
store i64 1, i64* %19
br label %25
25: ; preds = %44, %3
%26 = load i64, i64* %19
%27 = load i64, i64* %6
%28 = icmp ule i64 %26, %27
br i1 %28, label %29, label %47
29: ; preds = %25
%30 = load float*, float** %4
%31 = load i64, i64* %19
%32 = getelementptr inbounds float, float* %30, i64 %31
%33 = load float, float* %32
%34 = load float*, float** %7
%35 = load i64, i64* %19
%36 = getelementptr inbounds float, float* %34, i64 %35
store float %33, float* %36
%37 = load float*, float** %5
%38 = load i64, i64* %19
%39 = getelementptr inbounds float, float* %37, i64 %38
%40 = load float, float* %39
%41 = load float*, float** %8
%42 = load i64, i64* %19
%43 = getelementptr inbounds float, float* %41, i64 %42
store float %40, float* %43
br label %44
44: ; preds = %29
%45 = load i64, i64* %19
%46 = add i64 %45, 1
store i64 %46, i64* %19
br label %25
47: ; preds = %25
%48 = load i64, i64* %6
%49 = load float*, float** %7
%50 = call i32 @myrank(i64 %48, float* %49)
%51 = load i64, i64* %6
%52 = load float*, float** %8
%53 = call i32 @myrank(i64 %51, float* %52)
store float 0.000000e+00, float* %13
store float 0.000000e+00, float* %14
store float 0.000000e+00, float* %15
store float 0.000000e+00, float* %16
store i64 1, i64* %19
br label %54
54: ; preds = %91, %47
%55 = load i64, i64* %19
%56 = load i64, i64* %6
%57 = icmp ule i64 %55, %56
br i1 %57, label %58, label %94
58: ; preds = %54
%59 = load float*, float** %7
%60 = load i64, i64* %19
%61 = getelementptr inbounds float, float* %59, i64 %60
%62 = load float, float* %61
%63 = load float, float* %13
%64 = fadd float %63, %62
store float %64, float* %13
%65 = load float*, float** %7
%66 = load i64, i64* %19
%67 = getelementptr inbounds float, float* %65, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %7
%70 = load i64, i64* %19
%71 = getelementptr inbounds float, float* %69, i64 %70
%72 = load float, float* %71
%73 = load float, float* %15
%74 = call float @llvm.fmuladd.f32(float %68, float %72, float %73)
store float %74, float* %15
%75 = load float*, float** %8
%76 = load i64, i64* %19
%77 = getelementptr inbounds float, float* %75, i64 %76
%78 = load float, float* %77
%79 = load float, float* %14
%80 = fadd float %79, %78
store float %80, float* %14
%81 = load float*, float** %8
%82 = load i64, i64* %19
%83 = getelementptr inbounds float, float* %81, i64 %82
%84 = load float, float* %83
%85 = load float*, float** %8
%86 = load i64, i64* %19
%87 = getelementptr inbounds float, float* %85, i64 %86
%88 = load float, float* %87
%89 = load float, float* %16
%90 = call float @llvm.fmuladd.f32(float %84, float %88, float %89)
store float %90, float* %16
br label %91
91: ; preds = %58
%92 = load i64, i64* %19
%93 = add i64 %92, 1
store i64 %93, i64* %19
br label %54
94: ; preds = %54
%95 = load float, float* %13
%96 = load i64, i64* %6
%97 = uitofp i64 %96 to float
%98 = fdiv float %95, %97
store float %98, float* %9
%99 = load float, float* %14
%100 = load i64, i64* %6
%101 = uitofp i64 %100 to float
%102 = fdiv float %99, %101
store float %102, float* %10
%103 = load float, float* %15
%104 = load i64, i64* %6
%105 = uitofp i64 %104 to float
%106 = fdiv float %103, %105
%107 = load float, float* %9
%108 = load float, float* %9
%109 = fneg float %107
%110 = call float @llvm.fmuladd.f32(float %109, float %108, float %106)
store float %110, float* %11
%111 = load float, float* %16
%112 = load i64, i64* %6
%113 = uitofp i64 %112 to float
%114 = fdiv float %111, %113
%115 = load float, float* %10
%116 = load float, float* %10
%117 = fneg float %115
%118 = call float @llvm.fmuladd.f32(float %117, float %116, float %114)
store float %118, float* %12
%119 = load float, float* %11
%120 = fcmp ole float %119, 0.000000e+00
%121 = zext i1 %120 to i32
%122 = load float, float* %12
%123 = fcmp ole float %122, 0.000000e+00
%124 = zext i1 %123 to i32
%125 = or i32 %121, %124
%126 = icmp ne i32 %125, 0
br i1 %126, label %127, label %128
127: ; preds = %94
store float 0.000000e+00, float* %20
br label %190
128: ; preds = %94
%129 = load float, float* %11
%130 = load i64, i64* %6
%131 = uitofp i64 %130 to float
%132 = fmul float %129, %131
%133 = load i64, i64* %6
%134 = sub i64 %133, 1
%135 = uitofp i64 %134 to float
%136 = fdiv float %132, %135
%137 = call float @sqrt(float %136)
store float %137, float* %11
%138 = load float, float* %12
%139 = load i64, i64* %6
%140 = uitofp i64 %139 to float
%141 = fmul float %138, %140
%142 = load i64, i64* %6
%143 = sub i64 %142, 1
%144 = uitofp i64 %143 to float
%145 = fdiv float %141, %144
%146 = call float @sqrt(float %145)
store float %146, float* %12
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
store i64 1, i64* %19
br label %147
147: ; preds = %176, %128
%148 = load i64, i64* %19
%149 = load i64, i64* %6
%150 = icmp ule i64 %148, %149
br i1 %150, label %151, label %179
151: ; preds = %147
%152 = load float*, float** %7
%153 = load i64, i64* %19
%154 = getelementptr inbounds float, float* %152, i64 %153
%155 = load float, float* %154
%156 = load float, float* %9
%157 = fsub float %155, %156
%158 = load float*, float** %8
%159 = load i64, i64* %19
%160 = getelementptr inbounds float, float* %158, i64 %159
%161 = load float, float* %160
%162 = load float, float* %10
%163 = fsub float %161, %162
%164 = load float, float* %17
%165 = call float @llvm.fmuladd.f32(float %157, float %163, float %164)
store float %165, float* %17
%166 = load float*, float** %7
%167 = load i64, i64* %19
%168 = getelementptr inbounds float, float* %166, i64 %167
%169 = load float, float* %168
%170 = load float*, float** %8
%171 = load i64, i64* %19
%172 = getelementptr inbounds float, float* %170, i64 %171
%173 = load float, float* %172
%174 = load float, float* %18
%175 = call float @llvm.fmuladd.f32(float %169, float %173, float %174)
store float %175, float* %18
br label %176
176: ; preds = %151
%177 = load i64, i64* %19
%178 = add i64 %177, 1
store i64 %178, i64* %19
br label %147
179: ; preds = %147
%180 = load float, float* %17
%181 = load i64, i64* %6
%182 = sub i64 %181, 1
%183 = uitofp i64 %182 to float
%184 = fdiv float %180, %183
store float %184, float* %17
%185 = load float, float* %17
%186 = load float, float* %11
%187 = load float, float* %12
%188 = fmul float %186, %187
%189 = fdiv float %185, %188
store float %189, float* %20
br label %190
190: ; preds = %179, %127
%191 = load float*, float** %7
%192 = load i64, i64* %6
%193 = call i32 @free_vector(float* %191, i32 1, i64 %192)
%194 = load float*, float** %8
%195 = load i64, i64* %6
%196 = call i32 @free_vector(float* %194, i32 1, i64 %195)
%197 = load float, float* %20
ret float %197
}

LLVM IR (-O2):
define float @spearman(float* nocapture %0, float* nocapture %1, i64 %2) {
%4 = tail call float* @vector(i32 1, i64 %2)
%5 = tail call float* @vector(i32 1, i64 %2)
%6 = icmp eq i64 %2, 0
br i1 %6, label %189, label %7
7: ; preds = %3
%8 = icmp ult i64 %2, 8
br i1 %8, label %124, label %9
9: ; preds = %7
%10 = getelementptr float, float* %4, i64 1
%11 = add i64 %2, 1
%12 = getelementptr float, float* %4, i64 %11
%13 = getelementptr float, float* %5, i64 1
%14 = getelementptr float, float* %5, i64 %11
%15 = getelementptr float, float* %0, i64 1
%16 = getelementptr float, float* %0, i64 %11
%17 = getelementptr float, float* %1, i64 1
%18 = getelementptr float, float* %1, i64 %11
%19 = icmp ult float* %10, %14
%20 = icmp ult float* %13, %12
%21 = and i1 %19, %20
%22 = icmp ult float* %10, %16
%23 = icmp ult float* %15, %12
%24 = and i1 %22, %23
%25 = or i1 %21, %24
%26 = icmp ult float* %10, %18
%27 = icmp ult float* %17, %12
%28 = and i1 %26, %27
%29 = or i1 %25, %28
%30 = icmp ult float* %13, %16
%31 = icmp ult float* %15, %14
%32 = and i1 %30, %31
%33 = or i1 %29, %32
%34 = icmp ult float* %13, %18
%35 = icmp ult float* %17, %14
%36 = and i1 %34, %35
%37 = or i1 %33, %36
br i1 %37, label %124, label %38
38: ; preds = %9
%39 = and i64 %2, -8
%40 = or i64 %39, 1
%41 = add i64 %39, -8
%42 = lshr exact i64 %41, 3
%43 = add nuw nsw i64 %42, 1
%44 = and i64 %43, 1
%45 = icmp eq i64 %41, 0
br i1 %45, label %98, label %46
46: ; preds = %38
%47 = and i64 %43, 4611686018427387902
br label %48
48: ; preds = %48, %46
%49 = phi i64 [ 0, %46 ], [ %93, %48 ]
%50 = phi i64 [ 0, %46 ], [ %94, %48 ]
%51 = or i64 %49, 1
%52 = getelementptr inbounds float, float* %0, i64 %51
%53 = bitcast float* %52 to <4 x float>*
%54 = load <4 x float>, <4 x float>* %53
%55 = getelementptr inbounds float, float* %52, i64 4
%56 = bitcast float* %55 to <4 x float>*
%57 = load <4 x float>, <4 x float>* %56
%58 = getelementptr inbounds float, float* %4, i64 %51
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %54, <4 x float>* %59
%60 = getelementptr inbounds float, float* %58, i64 4
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %57, <4 x float>* %61
%62 = getelementptr inbounds float, float* %1, i64 %51
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = getelementptr inbounds float, float* %62, i64 4
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds float, float* %5, i64 %51
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %64, <4 x float>* %69
%70 = getelementptr inbounds float, float* %68, i64 4
%71 = bitcast float* %70 to <4 x float>*
store <4 x float> %67, <4 x float>* %71
%72 = or i64 %49, 9
%73 = getelementptr inbounds float, float* %0, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = getelementptr inbounds float, float* %73, i64 4
%77 = bitcast float* %76 to <4 x float>*
%78 = load <4 x float>, <4 x float>* %77
%79 = getelementptr inbounds float, float* %4, i64 %72
%80 = bitcast float* %79 to <4 x float>*
store <4 x float> %75, <4 x float>* %80
%81 = getelementptr inbounds float, float* %79, i64 4
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %78, <4 x float>* %82
%83 = getelementptr inbounds float, float* %1, i64 %72
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = getelementptr inbounds float, float* %83, i64 4
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = getelementptr inbounds float, float* %5, i64 %72
%90 = bitcast float* %89 to <4 x float>*
store <4 x float> %85, <4 x float>* %90
%91 = getelementptr inbounds float, float* %89, i64 4
%92 = bitcast float* %91 to <4 x float>*
store <4 x float> %88, <4 x float>* %92
%93 = add nuw i64 %49, 16
%94 = add i64 %50, 2
%95 = icmp eq i64 %94, %47
br i1 %95, label %96, label %48
96: ; preds = %48
%97 = or i64 %93, 1
br label %98
98: ; preds = %96, %38
%99 = phi i64 [ 1, %38 ], [ %97, %96 ]
%100 = icmp eq i64 %44, 0
br i1 %100, label %122, label %101
101: ; preds = %98
%102 = getelementptr inbounds float, float* %0, i64 %99
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %102, i64 4
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = getelementptr inbounds float, float* %4, i64 %99
%109 = bitcast float* %108 to <4 x float>*
store <4 x float> %104, <4 x float>* %109
%110 = getelementptr inbounds float, float* %108, i64 4
%111 = bitcast float* %110 to <4 x float>*
store <4 x float> %107, <4 x float>* %111
%112 = getelementptr inbounds float, float* %1, i64 %99
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = getelementptr inbounds float, float* %112, i64 4
%116 = bitcast float* %115 to <4 x float>*
%117 = load <4 x float>, <4 x float>* %116
%118 = getelementptr inbounds float, float* %5, i64 %99
%119 = bitcast float* %118 to <4 x float>*
store <4 x float> %114, <4 x float>* %119
%120 = getelementptr inbounds float, float* %118, i64 4
%121 = bitcast float* %120 to <4 x float>*
store <4 x float> %117, <4 x float>* %121
br label %122
122: ; preds = %98, %101
%123 = icmp eq i64 %39, %2
br i1 %123, label %156, label %124
124: ; preds = %9, %7, %122
%125 = phi i64 [ 1, %9 ], [ 1, %7 ], [ %40, %122 ]
%126 = and i64 %2, 1
%127 = icmp eq i64 %126, 0
br i1 %127, label %136, label %128
128: ; preds = %124
%129 = getelementptr inbounds float, float* %0, i64 %125
%130 = load float, float* %129
%131 = getelementptr inbounds float, float* %4, i64 %125
store float %130, float* %131
%132 = getelementptr inbounds float, float* %1, i64 %125
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %5, i64 %125
store float %133, float* %134
%135 = add nuw i64 %125, 1
br label %136
136: ; preds = %128, %124
%137 = phi i64 [ %125, %124 ], [ %135, %128 ]
%138 = icmp eq i64 %125, %2
br i1 %138, label %156, label %139
139: ; preds = %136, %139
%140 = phi i64 [ %154, %139 ], [ %137, %136 ]
%141 = getelementptr inbounds float, float* %0, i64 %140
%142 = load float, float* %141
%143 = getelementptr inbounds float, float* %4, i64 %140
store float %142, float* %143
%144 = getelementptr inbounds float, float* %1, i64 %140
%145 = load float, float* %144
%146 = getelementptr inbounds float, float* %5, i64 %140
store float %145, float* %146
%147 = add nuw i64 %140, 1
%148 = getelementptr inbounds float, float* %0, i64 %147
%149 = load float, float* %148
%150 = getelementptr inbounds float, float* %4, i64 %147
store float %149, float* %150
%151 = getelementptr inbounds float, float* %1, i64 %147
%152 = load float, float* %151
%153 = getelementptr inbounds float, float* %5, i64 %147
store float %152, float* %153
%154 = add nuw i64 %140, 2
%155 = icmp eq i64 %147, %2
br i1 %155, label %156, label %139
156: ; preds = %136, %139, %122
%157 = tail call i32 @myrank(i64 %2, float* %4)
%158 = tail call i32 @myrank(i64 %2, float* %5)
br i1 %6, label %210, label %159
159: ; preds = %156
%160 = and i64 %2, 1
%161 = icmp eq i64 %2, 1
br i1 %161, label %194, label %162
162: ; preds = %159
%163 = and i64 %2, -2
br label %164
164: ; preds = %164, %162
%165 = phi i64 [ 1, %162 ], [ %186, %164 ]
%166 = phi <2 x float> [ zeroinitializer, %162 ], [ %185, %164 ]
%167 = phi <2 x float> [ zeroinitializer, %162 ], [ %184, %164 ]
%168 = phi i64 [ 0, %162 ], [ %187, %164 ]
%169 = getelementptr inbounds float, float* %4, i64 %165
%170 = load float, float* %169
%171 = getelementptr inbounds float, float* %5, i64 %165
%172 = load float, float* %171
%173 = insertelement <2 x float> poison, float %170, i64 0
%174 = insertelement <2 x float> %173, float %172, i64 1
%175 = fadd <2 x float> %167, %174
%176 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %174, <2 x float> %174, <2 x float> %166)
%177 = add nuw i64 %165, 1
%178 = getelementptr inbounds float, float* %4, i64 %177
%179 = load float, float* %178
%180 = getelementptr inbounds float, float* %5, i64 %177
%181 = load float, float* %180
%182 = insertelement <2 x float> poison, float %179, i64 0
%183 = insertelement <2 x float> %182, float %181, i64 1
%184 = fadd <2 x float> %175, %183
%185 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %183, <2 x float> %183, <2 x float> %176)
%186 = add nuw i64 %165, 2
%187 = add i64 %168, 2
%188 = icmp eq i64 %187, %163
br i1 %188, label %192, label %164
189: ; preds = %3
%190 = tail call i32 @myrank(i64 %2, float* %4)
%191 = tail call i32 @myrank(i64 %2, float* %5)
br label %210
192: ; preds = %164
%193 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %183, <2 x float> %183, <2 x float> %176)
br label %194
194: ; preds = %192, %159
%195 = phi <2 x float> [ undef, %159 ], [ %184, %192 ]
%196 = phi <2 x float> [ undef, %159 ], [ %193, %192 ]
%197 = phi i64 [ 1, %159 ], [ %186, %192 ]
%198 = phi <2 x float> [ zeroinitializer, %159 ], [ %185, %192 ]
%199 = phi <2 x float> [ zeroinitializer, %159 ], [ %184, %192 ]
%200 = icmp eq i64 %160, 0
br i1 %200, label %210, label %201
201: ; preds = %194
%202 = getelementptr inbounds float, float* %4, i64 %197
%203 = load float, float* %202
%204 = getelementptr inbounds float, float* %5, i64 %197
%205 = load float, float* %204
%206 = insertelement <2 x float> poison, float %203, i64 0
%207 = insertelement <2 x float> %206, float %205, i64 1
%208 = fadd <2 x float> %199, %207
%209 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %207, <2 x float> %207, <2 x float> %198)
br label %210
210: ; preds = %201, %194, %189, %156
%211 = phi <2 x float> [ zeroinitializer, %156 ], [ zeroinitializer, %189 ], [ %196, %194 ], [ %209, %201 ]
%212 = phi <2 x float> [ zeroinitializer, %156 ], [ zeroinitializer, %189 ], [ %195, %194 ], [ %208, %201 ]
%213 = uitofp i64 %2 to float
%214 = insertelement <2 x float> poison, float %213, i64 0
%215 = shufflevector <2 x float> %214, <2 x float> poison, <2 x i32> zeroinitializer
%216 = fdiv <2 x float> %212, %215
%217 = fdiv <2 x float> %211, %215
%218 = fneg <2 x float> %216
%219 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %218, <2 x float> %216, <2 x float> %217)
%220 = fcmp ole <2 x float> %219, zeroinitializer
%221 = shufflevector <2 x i1> %220, <2 x i1> poison, <2 x i32> <i32 1, i32 undef>
%222 = or <2 x i1> %220, %221
%223 = extractelement <2 x i1> %222, i64 0
br i1 %223, label %286, label %224
224: ; preds = %210
%225 = extractelement <2 x float> %219, i64 0
%226 = fmul float %225, %213
%227 = add i64 %2, -1
%228 = uitofp i64 %227 to float
%229 = fdiv float %226, %228
%230 = tail call float @sqrt(float %229)
%231 = extractelement <2 x float> %219, i64 1
%232 = fmul float %231, %213
%233 = fdiv float %232, %228
%234 = tail call float @sqrt(float %233)
br i1 %6, label %281, label %235
235: ; preds = %224
%236 = and i64 %2, 1
%237 = icmp eq i64 %2, 1
br i1 %237, label %266, label %238
238: ; preds = %235
%239 = and i64 %2, -2
%240 = extractelement <2 x float> %216, i64 0
%241 = extractelement <2 x float> %216, i64 1
%242 = extractelement <2 x float> %216, i64 0
%243 = extractelement <2 x float> %216, i64 1
br label %244
244: ; preds = %244, %238
%245 = phi i64 [ 1, %238 ], [ %263, %244 ]
%246 = phi float [ 0.000000e+00, %238 ], [ %262, %244 ]
%247 = phi i64 [ 0, %238 ], [ %264, %244 ]
%248 = getelementptr inbounds float, float* %4, i64 %245
%249 = load float, float* %248
%250 = fsub float %249, %240
%251 = getelementptr inbounds float, float* %5, i64 %245
%252 = load float, float* %251
%253 = fsub float %252, %241
%254 = tail call float @llvm.fmuladd.f32(float %250, float %253, float %246)
%255 = add nuw i64 %245, 1
%256 = getelementptr inbounds float, float* %4, i64 %255
%257 = load float, float* %256
%258 = fsub float %257, %242
%259 = getelementptr inbounds float, float* %5, i64 %255
%260 = load float, float* %259
%261 = fsub float %260, %243
%262 = tail call float @llvm.fmuladd.f32(float %258, float %261, float %254)
%263 = add nuw i64 %245, 2
%264 = add i64 %247, 2
%265 = icmp eq i64 %264, %239
br i1 %265, label %266, label %244
266: ; preds = %244, %235
%267 = phi float [ undef, %235 ], [ %262, %244 ]
%268 = phi i64 [ 1, %235 ], [ %263, %244 ]
%269 = phi float [ 0.000000e+00, %235 ], [ %262, %244 ]
%270 = icmp eq i64 %236, 0
br i1 %270, label %281, label %271
271: ; preds = %266
%272 = getelementptr inbounds float, float* %4, i64 %268
%273 = load float, float* %272
%274 = extractelement <2 x float> %216, i64 0
%275 = fsub float %273, %274
%276 = getelementptr inbounds float, float* %5, i64 %268
%277 = load float, float* %276
%278 = extractelement <2 x float> %216, i64 1
%279 = fsub float %277, %278
%280 = tail call float @llvm.fmuladd.f32(float %275, float %279, float %269)
br label %281
281: ; preds = %271, %266, %224
%282 = phi float [ 0.000000e+00, %224 ], [ %267, %266 ], [ %280, %271 ]
%283 = fdiv float %282, %228
%284 = fmul float %230, %234
%285 = fdiv float %283, %284
br label %286
286: ; preds = %210, %281
%287 = phi float [ %285, %281 ], [ 0.000000e+00, %210 ]
%288 = tail call i32 @free_vector(float* %4, i32 1, i64 %2)
%289 = tail call i32 @free_vector(float* %5, i32 1, i64 %2)
ret float %287
}