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


x86 assembly (clang, -O0):
<crossf>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
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    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x84(%rbp)
cmp    0x2ecb(%rip),%eax
jle    1210 <crossf+0xc0>
cmpq   $0x0,0x2eb5(%rip)
je     11ad <crossf+0x5d>
mov    0x2ea8(%rip),%rdi
call   1030 <free@plt>
movq   $0x0,0x2e98(%rip)
movl   $0x0,0x2e96(%rip)
movslq -0x84(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2e75(%rip)
cmp    $0x0,%rax
jne    1204 <crossf+0xb4>
mov    0x2df4(%rip),%rax
mov    (%rax),%edi
lea    0xe13(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x84(%rbp),%eax
mov    %eax,0x2e48(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     125c <crossf+0x10c>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1226 <crossf+0xd6>
cvtsi2ssl -0xc(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x2dce(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     12d2 <crossf+0x182>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  %xmm0,(%rax)
jmp    128e <crossf+0x13e>
mov    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x2d47(%rip),%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     1362 <crossf+0x212>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1315 <crossf+0x1c5>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15bc <crossf+0x46c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    0x2cb9(%rip),%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     13fb <crossf+0x2ab>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    13ae <crossf+0x25e>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0xffffffff,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a1 <crossf+0x451>
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    0x2c08(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0x2bfd(%rip),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
cmp    $0x0,%eax
je     14c2 <crossf+0x372>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1471 <crossf+0x321>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
addsd  -0x78(%rbp),%xmm1
movsd  %xmm1,-0x78(%rbp)
movsd  0xaab(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    156c <crossf+0x41c>
movsd  0xa99(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jbe    158e <crossf+0x43e>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x7c(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x80(%rbp)
jmp    1593 <crossf+0x443>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1427 <crossf+0x2d7>
mov    -0x80(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    161c <crossf+0x4cc>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x18(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x7c(%rbp)
cmp    $0x0,%eax
jle    1617 <crossf+0x4c7>
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x98(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    15e2 <crossf+0x492>
jmp    161c <crossf+0x4cc>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crossf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r13
mov    %r8,%r15
mov    %ecx,%r12d
mov    %esi,%r8d
mov    %rdi,%rbp
mov    %rdx,%rax
mov    %rdx,0x10(%rsp)
lea    (%rdx,%r8,1),%r14d
add    %ecx,%r14d
cmp    0x2ecd(%rip),%r14d
mov    %r8,0x20(%rsp)
jle    11e9 <crossf+0x89>
mov    0x2eb7(%rip),%rdi
test   %rdi,%rdi
je     11ab <crossf+0x4b>
call   1030 <free@plt>
movq   $0x0,0x2ea2(%rip)
movl   $0x0,0x2ea0(%rip)
lea    0x0(,%r14,4),%edi
call   1060 <malloc@plt>
mov    %rax,0x2e84(%rip)
test   %rax,%rax
je     17ff <crossf+0x69f>
mov    %r14d,0x2e7c(%rip)
mov    0x20(%rsp),%r8
test   %r8d,%r8d
je     122c <crossf+0xcc>
lea    -0x1(%r8),%ecx
test   $0x7,%r8b
je     1231 <crossf+0xd1>
mov    %r8d,%edx
and    $0x7,%edx
xorps  %xmm0,%xmm0
xor    %esi,%esi
mov    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
addss  (%rax),%xmm0
add    $0x4,%rax
add    $0x1,%rsi
cmp    %esi,%edx
jne    1210 <crossf+0xb0>
mov    %r8d,%edx
sub    %esi,%edx
cmp    $0x7,%ecx
jae    123f <crossf+0xdf>
jmp    1287 <crossf+0x127>
xorps  %xmm0,%xmm0
jmp    1287 <crossf+0x127>
xorps  %xmm0,%xmm0
mov    %rbp,%rax
mov    %r8d,%edx
cmp    $0x7,%ecx
jb     1287 <crossf+0x127>
mov    %edx,%ecx
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,%ecx
jne    1250 <crossf+0xf0>
mov    0x2dca(%rip),%rax
test   %r14d,%r14d
je     1414 <crossf+0x2b4>
cvtsi2ss %r8d,%xmm1
divss  %xmm1,%xmm0
mov    0x10(%rsp),%rcx
lea    (%r12,%rcx,1),%edx
lea    (%r8,%rdx,1),%ecx
add    $0xffffffff,%ecx
cmp    $0x7,%ecx
jb     12e0 <crossf+0x180>
add    %r8d,%edx
add    $0xffffffff,%edx
lea    0x4(,%rdx,4),%rsi
add    %rbp,%rsi
cmp    %rsi,%rax
jae    137c <crossf+0x21c>
lea    (%rax,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rbp,%rdx
jbe    137c <crossf+0x21c>
mov    %rax,%rcx
lea    -0x1(%r14),%edx
mov    %r14d,%esi
and    $0x3,%esi
je     131f <crossf+0x1bf>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp),%xmm1
add    $0x4,%rbp
subss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
add    $0x4,%rcx
add    $0x1,%edi
cmp    %edi,%esi
jne    1300 <crossf+0x1a0>
sub    %edi,%r14d
cmp    $0x3,%edx
jb     1414 <crossf+0x2b4>
mov    %r14d,%edx
xor    %esi,%esi
nopl   (%rax)
movss  0x0(%rbp,%rsi,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rbp,%rsi,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
movss  0x8(%rbp,%rsi,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx,%rsi,4)
movss  0xc(%rbp,%rsi,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%edx
jne    1330 <crossf+0x1d0>
jmp    1414 <crossf+0x2b4>
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     17ef <crossf+0x68f>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nop
movups 0x0(%rbp,%rsi,4),%xmm2
movups 0x10(%rbp,%rsi,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
movups 0x20(%rbp,%rsi,4),%xmm2
movups 0x30(%rbp,%rsi,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x20(%rax,%rsi,4)
movups %xmm3,0x30(%rax,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    13b0 <crossf+0x250>
test   $0x1,%bl
je     140b <crossf+0x2ab>
movups 0x0(%rbp,%rsi,4),%xmm2
movups 0x10(%rbp,%rsi,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%rax,%rsi,4)
movups %xmm3,0x10(%rax,%rsi,4)
cmp    %rdx,%rcx
jne    15a3 <crossf+0x443>
mov    0x98(%rsp),%rdi
mov    0x90(%rsp),%rbp
test   %r8d,%r8d
je     1476 <crossf+0x316>
lea    -0x1(%r8),%ecx
mov    %ecx,0x4(%rsp)
test   $0x3,%r8b
je     1482 <crossf+0x322>
mov    %r8d,%edx
and    $0x3,%edx
xorps  %xmm0,%xmm0
xor    %esi,%esi
mov    %rax,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx),%xmm1
add    $0x4,%rcx
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %esi,%edx
jne    1450 <crossf+0x2f0>
mov    %r8d,%edx
sub    %esi,%edx
cmpl   $0x3,0x4(%rsp)
jae    1492 <crossf+0x332>
jmp    14df <crossf+0x37f>
movl   $0x0,(%r15)
jmp    1549 <crossf+0x3e9>
xorps  %xmm0,%xmm0
mov    %rax,%rcx
mov    %r8d,%edx
cmpl   $0x3,0x4(%rsp)
jb     14df <crossf+0x37f>
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm1
movss  0x4(%rcx,%rsi,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0x8(%rcx,%rsi,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rcx,%rsi,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rsi
cmp    %esi,%edx
jne    14a0 <crossf+0x340>
movss  %xmm0,(%r15)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1549 <crossf+0x3e9>
movslq 0x10(%rsp),%rbp
test   %r8d,%r8d
mov    %r13,0x30(%rsp)
je     156d <crossf+0x40d>
lea    (%rax,%rbp,4),%rcx
test   $0x3,%r8b
je     15b4 <crossf+0x454>
mov    %r8d,%edx
and    $0x3,%edx
xorps  %xmm1,%xmm1
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx),%xmm2
add    $0x4,%rcx
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %esi,%edx
jne    1520 <crossf+0x3c0>
mov    %r8d,%edx
sub    %esi,%edx
cmpl   $0x3,0x4(%rsp)
jae    15c1 <crossf+0x461>
jmp    160f <crossf+0x4af>
movl   $0x0,0x0(%r13)
movl   $0x0,0x0(%rbp)
test   %r12d,%r12d
jle    1594 <crossf+0x434>
mov    %r12d,%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1040 <memset@plt>
jmp    1594 <crossf+0x434>
xorps  %xmm2,%xmm2
test   %r12d,%r12d
jg     161f <crossf+0x4bf>
mov    $0xffffffff,%ecx
xorps  %xmm1,%xmm1
mov    0x30(%rsp),%rax
mov    %ecx,(%rax)
mov    0x90(%rsp),%rax
movss  %xmm1,(%rax)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(%rbp,%rdx,4),%rbp
sub    %edx,%r14d
lea    (%rax,%rdx,4),%rcx
jmp    12e3 <crossf+0x183>
xorps  %xmm1,%xmm1
mov    %r8d,%edx
cmpl   $0x3,0x4(%rsp)
jb     160f <crossf+0x4af>
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rcx,%rsi,4),%xmm2
movss  0x4(%rcx,%rsi,4),%xmm3
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  0x8(%rcx,%rsi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  0xc(%rcx,%rsi,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %esi,%edx
jne    15d0 <crossf+0x470>
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
test   %r12d,%r12d
jle    1579 <crossf+0x419>
mov    %rdi,0x28(%rsp)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x48(%rsp)
mov    %r12d,%ecx
mov    %rcx,0x40(%rsp)
lea    0x0(,%rbp,4),%r14
mov    %r8d,%ecx
mov    %rcx,0x38(%rsp)
mov    %r8d,%r12d
and    $0x3,%r12d
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
movl   $0xffffffff,0x8(%rsp)
ff
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rbp,4),%rcx
lea    (%rcx,%r13,4),%rbx
xorps  %xmm3,%xmm3
mov    %rbx,%r15
test   %r8d,%r8d
je     173a <crossf+0x5da>
xorps  %xmm3,%xmm3
test   $0x3,%r8b
je     16d0 <crossf+0x570>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax),%xmm0
mulss  (%rax,%r14,1),%xmm0
add    $0x4,%rax
addss  %xmm0,%xmm3
add    $0x1,%rcx
cmp    %ecx,%r12d
jne    16a0 <crossf+0x540>
lea    (%rax,%r14,1),%r15
mov    0x38(%rsp),%rdx
sub    %ecx,%edx
cmpl   $0x3,0x4(%rsp)
jae    16dd <crossf+0x57d>
jmp    173a <crossf+0x5da>
nop
mov    %rbx,%r15
mov    %r8d,%edx
cmpl   $0x3,0x4(%rsp)
jb     173a <crossf+0x5da>
mov    %edx,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mulss  (%r15),%xmm0
movss  0x4(%rax,%rdx,4),%xmm1
addss  %xmm3,%xmm0
mulss  0x4(%r15),%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rax,%rdx,4),%xmm0
mulss  0x8(%r15),%xmm0
addss  %xmm1,%xmm0
movss  0xc(%rax,%rdx,4),%xmm3
mulss  0xc(%r15),%xmm3
add    $0x10,%r15
addss  %xmm0,%xmm3
add    $0x4,%rdx
cmp    %edx,%ecx
jne    16f0 <crossf+0x590>
movss  %xmm3,0x1c(%rsp)
movaps %xmm2,%xmm0
mulsd  0x48(%rsp),%xmm0
movsd  %xmm2,0x50(%rsp)
call   1070 <sqrt@plt>
movss  0x1c(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
ucomiss %xmm0,%xmm1
mov    0x10(%rsp),%rax
lea    0x0(%r13,%rax,1),%eax
mov    0x8(%rsp),%ecx
cmova  %eax,%ecx
mov    0x28(%rsp),%rax
movss  %xmm1,(%rax)
maxss  %xmm0,%xmm1
add    $0x1,%r13
cmp    0x40(%rsp),%r13
je     1581 <crossf+0x421>
mov    %ecx,0x8(%rsp)
movss  (%rbx),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x50(%rsp),%xmm2
subsd  %xmm0,%xmm2
movss  (%r15),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  0x839(%rip),%xmm2
maxsd  %xmm0,%xmm2
add    $0x4,%rax
mov    %rax,0x28(%rsp)
mov    0x287d(%rip),%rax
add    $0x4,%r14
movss  %xmm1,0xc(%rsp)
mov    0x20(%rsp),%r8
jmp    1670 <crossf+0x510>
xor    %esi,%esi
test   $0x1,%bl
jne    13f2 <crossf+0x292>
jmp    140b <crossf+0x2ab>
mov    0x27da(%rip),%rax
mov    (%rax),%edi
lea    0x7f9(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>

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

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