#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
int acor(double *mean, double *sigma, double *tau, double X[], int L,
         int maxlag) {
  int i, s;
  double D;
  double *C;
  int iMax = L - maxlag;
  int Lh = L / 2, j1 = 0, j2 = 1;
  double newMean;
  if (L < 5 * maxlag)
    return 1;
  if (!(C = (double *)malloc((maxlag + 1) * sizeof(double))))
    return -1;
  *mean = 0.;
  for (i = 0; i < L; i++)
    *mean += X[i];
  *mean = *mean / L;
  for (i = 0; i < L; i++)
    X[i] -= *mean;
  for (s = 0; s <= maxlag; s++)
    C[s] = 0.;
  for (i = 0; i < iMax; i++)
    for (s = 0; s <= maxlag; s++)
      C[s] += X[i] * X[i + s];
  for (s = 0; s <= maxlag; s++)
    C[s] = C[s] / iMax;
  D = C[0];
  for (s = 1; s <= maxlag; s++)
    D += 2 * C[s];
  if (D < 0) {
    return 2;
  }
  *sigma = sqrt(D / L);
  *tau = D / C[0];
  if (*tau * 5 < maxlag) {
    free(C);
    return 0;
  }
  for (i = 0; i < Lh; i++) {
    X[i] = X[j1] + X[j2];
    j1 += 2;
    j2 += 2;
  }
  acor(&newMean, sigma, tau, X, Lh, maxlag);
  D = .25 * (*sigma) * (*sigma) * L;
  *tau = D / C[0];
  *sigma = sqrt(D / L);
  free(C);
  return 0;
}


x86 assembly (clang, -O0):
<acor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
imul   $0x5,-0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    11a0 <acor+0x60>
movl   $0x1,-0x4(%rbp)
jmp    1507 <acor+0x3c7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    11cd <acor+0x8d>
movl   $0xffffffff,-0x4(%rbp)
jmp    1507 <acor+0x3c7>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1212 <acor+0xd2>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11df <acor+0x9f>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    126a <acor+0x12a>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1232 <acor+0xf2>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     129b <acor+0x15b>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1271 <acor+0x131>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    131b <acor+0x1db>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1308 <acor+0x1c8>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12b5 <acor+0x175>
jmp    130d <acor+0x1cd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a2 <acor+0x162>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     135f <acor+0x21f>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x4c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1322 <acor+0x1e2>
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     13ac <acor+0x26c>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x40(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1373 <acor+0x233>
xorps  %xmm0,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    13c6 <acor+0x286>
movl   $0x2,-0x4(%rbp)
jmp    1507 <acor+0x3c7>
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x48(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  0xbfe(%rip),%xmm1
mulsd  (%rax),%xmm1
cvtsi2sdl -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    142a <acor+0x2ea>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1507 <acor+0x3c7>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1484 <acor+0x344>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1431 <acor+0x2f1>
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x50(%rbp),%r8d
mov    -0x30(%rbp),%r9d
lea    -0x60(%rbp),%rdi
call   1050 <acor@plt>
mov    -0x18(%rbp),%rax
movsd  0xb5b(%rip),%xmm0
mulsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulsd  (%rax),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x48(%rbp),%rax
divsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
cvtsi2sdl -0x2c(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<acor>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9d,%r12d
mov    %rcx,%r13
lea    (%r12,%r12,4),%ecx
mov    $0x1,%eax
cmp    %r8d,%ecx
jg     18ee <acor+0x79e>
mov    %rdx,%r14
mov    %rsi,%rbp
mov    %rdi,%r15
mov    %r8d,0x8(%rsp)
lea    0x8(,%r12,8),%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     11ce <acor+0x7e>
mov    %rax,%rbx
movq   $0x0,(%r15)
mov    0x8(%rsp),%r8d
test   %r8d,%r8d
mov    %rbp,0x28(%rsp)
mov    %r14,0x20(%rsp)
jle    11d8 <acor+0x88>
mov    %r8d,%eax
lea    -0x1(%rax),%rcx
mov    %eax,%edx
and    $0x3,%edx
cmp    $0x3,%rcx
jae    11f5 <acor+0xa5>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
jmp    1239 <acor+0xe9>
mov    $0xffffffff,%eax
jmp    18ee <acor+0x79e>
cvtsi2sd %r8d,%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm1,0x10(%rsp)
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
jmp    1435 <acor+0x2e5>
mov    %eax,%edi
and    $0xfffffffc,%edi
xorpd  %xmm0,%xmm0
xor    %esi,%esi
addsd  0x0(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%r15)
addsd  0x8(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%r15)
addsd  0x10(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%r15)
addsd  0x18(%r13,%rsi,8),%xmm0
movsd  %xmm0,(%r15)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1200 <acor+0xb0>
test   %rdx,%rdx
je     1263 <acor+0x113>
lea    0x0(,%rsi,8),%rsi
add    %r13,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
addsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%r15)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1250 <acor+0x100>
cvtsi2sd %r8d,%xmm1
movsd  %xmm1,0x10(%rsp)
divsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
test   %r8d,%r8d
jle    1435 <acor+0x2e5>
movsd  0x0(%r13),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13)
cmp    $0x1,%r8d
je     1435 <acor+0x2e5>
mov    $0x1,%edx
cmp    $0x4,%rcx
jb     138e <acor+0x23e>
cmp    %r15,%r13
jae    12c2 <acor+0x172>
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
cmp    %r15,%rsi
ja     138e <acor+0x23e>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1344 <acor+0x1f4>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movsd  (%r15),%xmm0
unpcklpd %xmm0,%xmm0
xor    %esi,%esi
nop
movupd 0x8(%r13,%rsi,8),%xmm1
movupd 0x18(%r13,%rsi,8),%xmm2
movupd 0x28(%r13,%rsi,8),%xmm3
movupd 0x38(%r13,%rsi,8),%xmm4
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
movupd %xmm1,0x8(%r13,%rsi,8)
movupd %xmm2,0x18(%r13,%rsi,8)
subpd  %xmm0,%xmm3
subpd  %xmm0,%xmm4
movupd %xmm3,0x28(%r13,%rsi,8)
movupd %xmm4,0x38(%r13,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12f0 <acor+0x1a0>
jmp    1346 <acor+0x1f6>
xor    %esi,%esi
test   $0x1,%bpl
je     1381 <acor+0x231>
shl    $0x3,%rsi
movsd  (%r15),%xmm0
unpcklpd %xmm0,%xmm0
or     $0x8,%rsi
movupd 0x0(%r13,%rsi,1),%xmm1
movupd 0x10(%r13,%rsi,1),%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm2
movupd %xmm1,0x0(%r13,%rsi,1)
movupd %xmm2,0x10(%r13,%rsi,1)
cmp    %rdx,%rcx
je     1435 <acor+0x2e5>
or     $0x1,%rdx
mov    %eax,%esi
sub    %edx,%esi
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
and    $0x3,%rsi
je     13cd <acor+0x27d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdx,8),%xmm0
subsd  (%r15),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    13b0 <acor+0x260>
cmp    $0x3,%rcx
jb     1435 <acor+0x2e5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%r13,%rdx,8),%xmm0
subsd  (%r15),%xmm0
movsd  0x8(%r13,%rdx,8),%xmm1
movsd  %xmm0,0x0(%r13,%rdx,8)
subsd  (%r15),%xmm1
movsd  %xmm1,0x8(%r13,%rdx,8)
movsd  0x10(%r13,%rdx,8),%xmm0
subsd  (%r15),%xmm0
movsd  %xmm0,0x10(%r13,%rdx,8)
movsd  0x18(%r13,%rdx,8),%xmm0
subsd  (%r15),%xmm0
movsd  %xmm0,0x18(%r13,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    13e0 <acor+0x290>
mov    %r8d,%ebp
sub    %r12d,%ebp
mov    %r12d,%r14d
test   %r12d,%r12d
js     1455 <acor+0x305>
lea    0x8(,%r14,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    %ebp,0xc(%rsp)
test   %ebp,%ebp
jle    15fb <acor+0x4ab>
lea    0x1(%r14),%rax
mov    0xc(%rsp),%r10d
lea    (%rbx,%r14,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,%r9d
and    $0xfffffffc,%r9d
lea    0x10(%r13),%rdi
lea    0x8(,%r14,8),%rcx
not    %r14
movabs $0x7ffffffe0,%r11
and    %rcx,%r11
lea    0x8(%r13),%rsi
xor    %ebp,%ebp
jmp    14c5 <acor+0x375>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x8,%rdi
add    $0x8,%rsi
cmp    %r10,%rbp
je     15fb <acor+0x4ab>
test   %r12d,%r12d
js     14b0 <acor+0x360>
cmp    $0x3,%r12d
jae    1550 <acor+0x400>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%al
je     1500 <acor+0x3b0>
movsd  0x0(%r13,%rbp,8),%xmm0
lea    (%rdx,%rbp,1),%rcx
mulsd  0x0(%r13,%rcx,8),%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    %r14,%rdx
je     14b0 <acor+0x360>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  -0x8(%rsi,%rcx,8),%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x0(%r13,%rbp,8),%xmm0
mulsd  (%rsi,%rcx,8),%xmm0
addsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1510 <acor+0x3c0>
jmp    14b0 <acor+0x360>
nopl   (%rax)
lea    (%rax,%rbp,1),%rcx
lea    0x0(,%rbp,8),%rdx
add    %r13,%rdx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
lea    0x8(,%rbp,8),%r15
add    %r13,%r15
cmp    %rcx,%rbx
setb   %r8b
cmp    0x18(%rsp),%rdx
setb   %cl
cmp    %r15,%rbx
setb   %r15b
test   %cl,%r8b
jne    14d4 <acor+0x384>
mov    $0x0,%edx
and    %cl,%r15b
jne    14d6 <acor+0x386>
movsd  0x0(%r13,%rbp,8),%xmm0
unpcklpd %xmm0,%xmm0
xor    %ecx,%ecx
nop
movupd -0x10(%rdi,%rcx,1),%xmm1
movupd (%rdi,%rcx,1),%xmm2
movupd (%rbx,%rcx,1),%xmm3
movupd 0x10(%rbx,%rcx,1),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rcx,1)
movupd %xmm2,0x10(%rbx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r11
jne    15b0 <acor+0x460>
mov    %r9,%rdx
cmp    %rax,%r9
je     14b0 <acor+0x360>
jmp    14d6 <acor+0x386>
test   %r12d,%r12d
js     16a2 <acor+0x552>
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc(%rsp),%xmm0
lea    0x1(%r12),%eax
test   %r12d,%r12d
mov    0x28(%rsp),%r15
mov    0x20(%rsp),%r14
je     16b9 <acor+0x569>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1808 <acor+0x6b8>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x8(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rbx,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1660 <acor+0x510>
test   $0x1,%dl
je     169b <acor+0x54b>
movupd (%rbx,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rsi,8)
cmp    %rax,%rcx
jne    16c0 <acor+0x570>
jmp    16d7 <acor+0x587>
movsd  (%rbx),%xmm2
mov    0x28(%rsp),%r15
mov    0x20(%rsp),%r14
mov    0x8(%rsp),%ebp
jmp    1776 <acor+0x626>
xor    %ecx,%ecx
mov    0x8(%rsp),%ebp
nop
movsd  (%rbx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    16c0 <acor+0x570>
movsd  (%rbx),%xmm2
test   %r12d,%r12d
jle    1776 <acor+0x626>
lea    -0x1(%rax),%rdx
add    $0xfffffffffffffffe,%rax
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    1703 <acor+0x5b3>
mov    $0x1,%eax
test   %rcx,%rcx
jne    175a <acor+0x60a>
jmp    1776 <acor+0x626>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  0x10(%rbx,%rax,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x18(%rbx,%rax,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x20(%rbx,%rax,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
add    $0x4,%rax
cmp    %rax,%rdx
jne    1710 <acor+0x5c0>
add    $0x1,%rax
test   %rcx,%rcx
je     1776 <acor+0x626>
lea    (%rbx,%rax,8),%rax
xor    %edx,%edx
movsd  (%rax,%rdx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1760 <acor+0x610>
mov    $0x2,%eax
xorpd  %xmm1,%xmm1
ucomisd %xmm2,%xmm1
ja     18ee <acor+0x79e>
movapd %xmm2,%xmm0
divsd  0x10(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jb     179f <acor+0x64f>
sqrtsd %xmm0,%xmm0
jmp    17b4 <acor+0x664>
movsd  %xmm2,0x18(%rsp)
call   1070 <sqrt@plt>
movsd  0x18(%rsp),%xmm2
mov    0x8(%rsp),%ebp
movsd  %xmm0,(%r15)
divsd  (%rbx),%xmm2
movsd  %xmm2,(%r14)
mulsd  0x836(%rip),%xmm2
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
ucomisd %xmm2,%xmm0
ja     18e4 <acor+0x794>
mov    %ebp,%r8d
shr    $0x1f,%r8d
add    %ebp,%r8d
sar    %r8d
cmp    $0x2,%ebp
jl     1884 <acor+0x734>
mov    %r8d,%eax
and    $0xfffffffe,%ebp
cmp    $0x2,%ebp
jne    181c <acor+0x6cc>
mov    $0x1,%ecx
xor    %edx,%edx
xor    %esi,%esi
jmp    186b <acor+0x71b>
xor    %esi,%esi
mov    0x8(%rsp),%ebp
test   $0x1,%dl
jne    168d <acor+0x53d>
jmp    169b <acor+0x54b>
mov    %eax,%esi
and    $0xfffffffe,%esi
mov    $0x1,%ecx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r13,%rcx,8),%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
addsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdx,8)
add    $0x4,%rcx
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1830 <acor+0x6e0>
lea    -0x1(%rcx),%rsi
test   $0x1,%al
je     1884 <acor+0x734>
movsd  0x0(%r13,%rsi,8),%xmm0
addsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
lea    0x30(%rsp),%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %r12d,%r9d
call   1060 <acor@plt>
movsd  (%r15),%xmm1
movsd  0x761(%rip),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x10(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movapd %xmm0,%xmm1
divsd  (%rbx),%xmm1
movsd  %xmm1,(%r14)
divsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     18da <acor+0x78a>
sqrtsd %xmm0,%xmm0
jmp    18df <acor+0x78f>
call   1070 <sqrt@plt>
movsd  %xmm0,(%r15)
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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