#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
float sqrt(double);
int /*<<< orphan*/ stderr;
void crossfi(const float *data, int size, int start0, int nlags0, int nlags,
             float *engref, int *maxloc, float *maxval, float *correl,
             int *locs, int nlocs) {
  static float *dbdata = NULL;
  static int dbsize = 0;
  register float *dp, *ds, sum, st;
  register int j;
  register float *dq, t, engr, *dds, amax;
  const float *p;
  register double engc;
  int i, iloc, start, total;
  if ((total = size + start0 + nlags0) > dbsize) {
    if (dbdata)
      free(dbdata);
    dbdata = NULL;
    dbsize = 0;
    if (!(dbdata = (float *)malloc(sizeof(float) * total))) {
      (void)fprintf(stderr, "Allocation failure in crossfi()\n");
      exit(-1);
    }
    dbsize = total;
  }
  for (engr = 0.0, j = size, p = data; j--;)
    engr += *p++;
  engr /= size;
  for (j = size + nlags0 + start0, dq = dbdata, p = data; j--;) {
    *dq++ = *p++ - engr;
  }
  {
    float *pp;
    for (pp = correl, i = nlags0; i-- > 0;)
      *pp++ = 0.0;
  }
  for (j = size, dp = dbdata, sum = 0.0; j--;) {
    st = *dp++;
    sum += st * st;
  }
  *engref = engr = sum;
  amax = 0.0;
  iloc = -1;
  if (engr > 0.0) {
    for (; nlocs > 0; nlocs--, locs++) {
      start = *locs - (nlags >> 1);
      if (start < start0)
        start = start0;
      dq = correl + start - start0;
      for (j = size, dp = dbdata + start, sum = 0.0; j--;) {
        st = *dp++;
        sum += st * st;
      }
      engc = sum;
      for (i = 0; i < nlags; i++) {
        for (j = size, sum = 0.0, dp = dbdata, dds = ds = dbdata + i + start;
             j--;)
          sum += *dp++ * *ds++;
        if (engc < 1.0)
          engc = 1.0;
        *dq++ = t = (sum / sqrt((double)(10000.0 + (engc * engr))));
        engc -= (double)(*dds * *dds);
        engc += (double)(*ds * *ds);
        if (t > amax) {
          amax = t;
          iloc = i + start;
        }
      }
    }
    *maxloc = iloc;
    *maxval = amax;
  } else {
    *maxloc = 0;
    *maxval = 0.0;
  }
}


x86 assembly (clang, -O0):
<crossfi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmp    0x2ec3(%rip),%eax
jle    1212 <crossfi+0xc2>
cmpq   $0x0,0x2ead(%rip)
je     11b5 <crossfi+0x65>
mov    0x2ea0(%rip),%rdi
call   1030 <free@plt>
movq   $0x0,0x2e90(%rip)
movl   $0x0,0x2e8e(%rip)
movslq -0x80(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2e70(%rip)
cmp    $0x0,%rax
jne    1209 <crossfi+0xb9>
mov    0x2def(%rip),%rax
mov    (%rax),%edi
lea    0xe16(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x80(%rbp),%eax
mov    %eax,0x2e46(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
cmp    $0x0,%eax
je     125e <crossfi+0x10e>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    1228 <crossfi+0xd8>
cvtsi2ssl -0xc(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x2dcc(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
cmp    $0x0,%eax
je     12d4 <crossfi+0x184>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x68(%rbp)
movss  (%rax),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  %xmm0,(%rax)
jmp    1290 <crossfi+0x140>
mov    0x20(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x74(%rbp)
cmp    $0x0,%eax
jle    131a <crossfi+0x1ca>
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x88(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    12e5 <crossfi+0x195>
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x2d29(%rip),%rax
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
cmp    $0x0,%eax
je     1380 <crossfi+0x230>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1333 <crossfi+0x1e3>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0xffffffff,-0x78(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1653 <crossfi+0x503>
jmp    13bc <crossfi+0x26c>
cmpl   $0x0,0x30(%rbp)
jle    1638 <crossfi+0x4e8>
mov    0x28(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%ecx
sar    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13e9 <crossfi+0x299>
mov    -0x10(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    0x20(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x2c37(%rip),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
cmp    $0x0,%eax
je     147d <crossfi+0x32d>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    1430 <crossfi+0x2e0>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1619 <crossfi+0x4c9>
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    0x2b9d(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0x2b92(%rip),%rax
movslq -0x74(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    %rax,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x3c(%rbp)
cmp    $0x0,%eax
je     152d <crossfi+0x3dd>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  (%rax),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    14dc <crossfi+0x38c>
movsd  0xacb(%rip),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    154d <crossfi+0x3fd>
movsd  0xab8(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  0xa94(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x8c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0x4c(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
jbe    1606 <crossfi+0x4b6>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x74(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
jmp    160b <crossfi+0x4bb>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1492 <crossfi+0x342>
jmp    161e <crossfi+0x4ce>
mov    0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,0x30(%rbp)
mov    0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,0x28(%rbp)
jmp    13bc <crossfi+0x26c>
mov    -0x78(%rbp),%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1668 <crossfi+0x518>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crossfi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%r14
mov    %r8d,0xc(%rsp)
mov    %edx,%r12d
mov    %rdi,%rbx
lea    (%r12,%rsi,1),%r15d
add    %ecx,%r15d
cmp    0x2ed3(%rip),%r15d
mov    %rsi,0x10(%rsp)
jle    11e9 <crossfi+0x89>
mov    %rcx,%rbp
mov    0x2eba(%rip),%rdi
test   %rdi,%rdi
je     11a8 <crossfi+0x48>
call   1030 <free@plt>
movq   $0x0,0x2ea5(%rip)
movl   $0x0,0x2ea3(%rip)
lea    0x0(,%r15,4),%edi
call   1060 <malloc@plt>
mov    %rax,0x2e87(%rip)
test   %rax,%rax
je     1893 <crossfi+0x733>
mov    %r15d,0x2e7f(%rip)
mov    0x10(%rsp),%rsi
mov    %rbp,%rcx
test   %esi,%esi
mov    %r14,(%rsp)
je     122c <crossfi+0xcc>
lea    -0x1(%rsi),%r8d
test   $0x7,%sil
je     1231 <crossfi+0xd1>
mov    %esi,%edx
and    $0x7,%edx
xorps  %xmm0,%xmm0
xor    %edi,%edi
mov    %rbx,%rax
nopl   0x0(%rax,%rax,1)
addss  (%rax),%xmm0
add    $0x4,%rax
add    $0x1,%rdi
cmp    %edi,%edx
jne    1210 <crossfi+0xb0>
mov    %esi,%edx
sub    %edi,%edx
cmp    $0x7,%r8d
jae    123f <crossfi+0xdf>
jmp    1287 <crossfi+0x127>
xorps  %xmm0,%xmm0
jmp    1287 <crossfi+0x127>
xorps  %xmm0,%xmm0
mov    %rbx,%rax
mov    %esi,%edx
cmp    $0x7,%r8d
jb     1287 <crossfi+0x127>
mov    %edx,%edi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rax,%rdx,4),%xmm0
addss  0x4(%rax,%rdx,4),%xmm0
addss  0x8(%rax,%rdx,4),%xmm0
addss  0xc(%rax,%rdx,4),%xmm0
addss  0x10(%rax,%rdx,4),%xmm0
addss  0x14(%rax,%rdx,4),%xmm0
addss  0x18(%rax,%rdx,4),%xmm0
addss  0x1c(%rax,%rdx,4),%xmm0
add    $0x8,%rdx
cmp    %edx,%edi
jne    1250 <crossfi+0xf0>
mov    0x2dca(%rip),%r14
test   %r15d,%r15d
je     1409 <crossfi+0x2a9>
cvtsi2ss %esi,%xmm1
divss  %xmm1,%xmm0
lea    (%rcx,%r12,1),%edx
lea    (%rsi,%rdx,1),%eax
add    $0xffffffff,%eax
cmp    $0x7,%eax
jb     12d6 <crossfi+0x176>
lea    (%rsi,%rdx,1),%edi
add    $0xffffffff,%edi
lea    (%rbx,%rdi,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%r14
jae    136b <crossfi+0x20b>
lea    (%r14,%rdi,4),%rdx
add    $0x4,%rdx
cmp    %rbx,%rdx
jbe    136b <crossfi+0x20b>
mov    %r14,%rax
lea    -0x1(%r15),%ebp
test   $0x3,%r15b
je     130f <crossfi+0x1af>
mov    %r15d,%edi
and    $0x3,%edi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movss  (%rbx),%xmm1
add    $0x4,%rbx
subss  %xmm0,%xmm1
movss  %xmm1,(%rax)
add    $0x4,%rax
add    $0x1,%rdx
cmp    %edx,%edi
jne    12f0 <crossfi+0x190>
sub    %edx,%r15d
cmp    $0x3,%ebp
jb     1409 <crossfi+0x2a9>
mov    %r15d,%edi
xor    %edx,%edx
nopl   (%rax)
movss  (%rbx,%rdx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
movss  0x4(%rbx,%rdx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x4(%rax,%rdx,4)
movss  0x8(%rbx,%rdx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x8(%rax,%rdx,4)
movss  0xc(%rbx,%rdx,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%edi
jne    1320 <crossfi+0x1c0>
jmp    1409 <crossfi+0x2a9>
add    $0x1,%rax
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r8),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     1882 <crossfi+0x722>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movups (%rbx,%rdx,4),%xmm2
movups 0x10(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%r14,%rdx,4)
movups %xmm3,0x10(%r14,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm2
movups 0x30(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x20(%r14,%rdx,4)
movups %xmm3,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    13a0 <crossfi+0x240>
test   $0x1,%bpl
je     1400 <crossfi+0x2a0>
movups (%rbx,%rdx,4),%xmm2
movups 0x10(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%r14,%rdx,4)
movups %xmm3,0x10(%r14,%rdx,4)
cmp    %r8,%rax
jne    1872 <crossfi+0x712>
mov    0xd0(%rsp),%r13
test   %ecx,%ecx
jle    142a <crossfi+0x2ca>
mov    %ecx,%edx
shl    $0x2,%rdx
mov    %r13,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x10(%rsp),%rsi
mov    0xc8(%rsp),%r8
mov    0xc0(%rsp),%rbx
test   %esi,%esi
je     1485 <crossfi+0x325>
lea    -0x1(%rsi),%eax
mov    %eax,0x8(%rsp)
test   $0x3,%sil
je     149a <crossfi+0x33a>
mov    %esi,%ecx
and    $0x3,%ecx
xorps  %xmm0,%xmm0
xor    %edx,%edx
mov    %r14,%rax
nopl   0x0(%rax,%rax,1)
movss  (%rax),%xmm1
add    $0x4,%rax
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %edx,%ecx
jne    1460 <crossfi+0x300>
mov    %esi,%ecx
sub    %edx,%ecx
cmpl   $0x3,0x8(%rsp)
jae    14a9 <crossfi+0x349>
jmp    14ef <crossfi+0x38f>
mov    (%rsp),%rax
movl   $0x0,(%rax)
xorps  %xmm3,%xmm3
xor    %r15d,%r15d
jmp    1858 <crossfi+0x6f8>
xorps  %xmm0,%xmm0
mov    %r14,%rax
mov    %esi,%ecx
cmpl   $0x3,0x8(%rsp)
jb     14ef <crossfi+0x38f>
mov    %ecx,%ecx
xor    %edx,%edx
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm1
movss  0x4(%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rax,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rax,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %edx,%ecx
jne    14b0 <crossfi+0x350>
mov    (%rsp),%rax
movss  %xmm0,(%rax)
xorps  %xmm3,%xmm3
xor    %r15d,%r15d
ucomiss %xmm3,%xmm0
jbe    1858 <crossfi+0x6f8>
mov    0xe0(%rsp),%edi
test   %edi,%edi
jle    1852 <crossfi+0x6f2>
mov    0xd8(%rsp),%rbp
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x60(%rsp)
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
sar    %eax
mov    %eax,0x24(%rsp)
movslq %r12d,%rax
shl    $0x2,%rax
sub    %rax,%r13
mov    %ecx,%eax
mov    %rax,0x58(%rsp)
mov    %esi,%ebx
and    $0x3,%ebx
mov    %esi,%eax
mov    %rax,0x38(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,0x30(%rsp)
xorps  %xmm3,%xmm3
mov    $0xffffffff,%r15d
mov    %r12,0x48(%rsp)
mov    %r13,0x40(%rsp)
nopl   (%rax)
mov    0x0(%rbp),%eax
sub    0x24(%rsp),%eax
cmp    %r12d,%eax
cmovl  %r12d,%eax
mov    %rax,0x68(%rsp)
cltq
mov    %rax,0x18(%rsp)
xorps  %xmm0,%xmm0
test   %esi,%esi
je     162f <crossfi+0x4cf>
mov    0x18(%rsp),%rax
lea    (%r14,%rax,4),%rax
xorps  %xmm0,%xmm0
test   %ebx,%ebx
je     15e0 <crossfi+0x480>
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
nopl   0x0(%rax)
movss  (%rax),%xmm1
add    $0x4,%rax
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %ecx,%edx
jne    15b0 <crossfi+0x450>
mov    0x38(%rsp),%rdx
sub    %ecx,%edx
cmpl   $0x3,0x8(%rsp)
jae    15e9 <crossfi+0x489>
jmp    162f <crossfi+0x4cf>
nopl   0x0(%rax,%rax,1)
mov    %esi,%edx
cmpl   $0x3,0x8(%rsp)
jb     162f <crossfi+0x4cf>
mov    %edx,%ecx
xor    %edx,%edx
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm1
movss  0x4(%rax,%rdx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rax,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rax,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %edx,%ecx
jne    15f0 <crossfi+0x490>
cmpl   $0x0,0xc(%rsp)
jle    1828 <crossfi+0x6c8>
mov    %rbp,0x50(%rsp)
mov    %edi,0x28(%rsp)
mov    0x18(%rsp),%rax
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cvtss2sd %xmm0,%xmm0
lea    0x0(,%rax,4),%r12
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
lea    (%r14,%rax,4),%rax
lea    (%rax,%r13,4),%rbp
test   %esi,%esi
movss  %xmm3,0x2c(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rbp,0x78(%rsp)
je     16e0 <crossfi+0x580>
test   $0x3,%sil
je     16f0 <crossfi+0x590>
xor    %ecx,%ecx
xorps  %xmm2,%xmm2
nop
movss  (%r14),%xmm1
mulss  (%r14,%r12,1),%xmm1
add    $0x4,%r14
addss  %xmm1,%xmm2
add    $0x1,%ecx
cmp    %ecx,%ebx
jne    16a0 <crossfi+0x540>
movss  %xmm2,(%rsp)
mov    %esi,%eax
sub    %ecx,%eax
lea    (%r14,%r12,1),%rbp
cmpl   $0x3,0x8(%rsp)
jae    1701 <crossfi+0x5a1>
jmp    1760 <crossfi+0x600>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm1,%xmm1
movss  %xmm1,(%rsp)
jmp    1760 <crossfi+0x600>
nopw   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
movss  %xmm1,(%rsp)
mov    %esi,%eax
cmpl   $0x3,0x8(%rsp)
jb     1760 <crossfi+0x600>
mov    %eax,%eax
xor    %ecx,%ecx
movss  (%rsp),%xmm3
nopw   0x0(%rax,%rax,1)
movss  (%r14,%rcx,4),%xmm1
mulss  0x0(%rbp),%xmm1
movss  0x4(%r14,%rcx,4),%xmm2
addss  %xmm3,%xmm1
mulss  0x4(%rbp),%xmm2
addss  %xmm1,%xmm2
movss  0x8(%r14,%rcx,4),%xmm1
mulss  0x8(%rbp),%xmm1
addss  %xmm2,%xmm1
movss  0xc(%r14,%rcx,4),%xmm3
mulss  0xc(%rbp),%xmm3
add    $0x10,%rbp
addss  %xmm1,%xmm3
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1710 <crossfi+0x5b0>
movss  %xmm3,(%rsp)
movsd  0x898(%rip),%xmm1
maxsd  %xmm0,%xmm1
movsd  %xmm1,0x70(%rsp)
movapd %xmm1,%xmm0
mulsd  0x60(%rsp),%xmm0
addsd  0x884(%rip),%xmm0
call   1070 <sqrt@plt>
movss  (%rsp),%xmm3
divss  %xmm0,%xmm3
movss  0x2c(%rsp),%xmm0
ucomiss %xmm0,%xmm3
mov    0x68(%rsp),%rax
lea    (%rax,%r13,1),%eax
cmova  %eax,%r15d
mov    0x80(%rsp),%rcx
movss  %xmm3,(%rcx)
maxss  %xmm0,%xmm3
add    $0x1,%r13
cmp    0x58(%rsp),%r13
je     1810 <crossfi+0x6b0>
mov    0x78(%rsp),%rax
movss  (%rax),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x70(%rsp),%xmm1
subsd  %xmm0,%xmm1
movss  0x0(%rbp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rcx
mov    0x285e(%rip),%r14
add    $0x4,%r12
mov    0x10(%rsp),%rsi
jmp    1670 <crossfi+0x510>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%r12
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%r13
mov    0x28(%rsp),%edi
mov    0x50(%rsp),%rbp
cmp    $0x2,%edi
jl     1840 <crossfi+0x6e0>
add    $0x4,%rbp
add    $0xffffffff,%edi
mov    0x281d(%rip),%r14
jmp    1570 <crossfi+0x410>
mov    0xc8(%rsp),%r8
mov    0xc0(%rsp),%rbx
jmp    1858 <crossfi+0x6f8>
mov    $0xffffffff,%r15d
mov    %r15d,(%rbx)
movss  %xmm3,(%r8)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rbx,%r8,4),%rbx
lea    (%r14,%r8,4),%rax
sub    %r8d,%r15d
jmp    12d9 <crossfi+0x179>
xor    %edx,%edx
test   $0x1,%bpl
jne    13e6 <crossfi+0x286>
jmp    1400 <crossfi+0x2a0>
mov    0x2746(%rip),%rax
mov    (%rax),%edi
lea    0x76d(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>

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

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