#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*/ memset(double *, int /*<<< orphan*/, int);
void llz_levinson1(double *r, int p, double *acof, double *kcof, double *err) {
  int i;
  int k, s, m;
  double am1[64 + 1];
  double km, em1, em;
  double errtmp;
  memset(am1, 0, sizeof(double) * (64 + 1));
  if (r[0] == 0.0) {
    for (i = 1; i <= p; i++) {
      kcof[i] = 0.0;
      acof[i] = 0.0;
    }
  } else {
    for (k = 0; k <= p; k++) {
      acof[k] = 0.0;
      am1[k] = 0.0;
    }
    acof[0] = 1.0;
    am1[0] = 1.0;
    km = 0.0;
    em1 = r[0];
    for (m = 1; m <= p; m++) {
      errtmp = 0.0;
      for (k = 1; k <= m - 1; k++)
        errtmp += am1[k] * r[m - k];
      km = (r[m] - errtmp) / em1;
      kcof[m - 1] = -km;
      acof[m] = km;
      for (k = 1; k <= m - 1; k++)
        acof[k] = am1[k] - km * am1[m - k];
      em = (1 - km * km) * em1;
      for (s = 0; s <= p; s++)
        am1[s] = acof[s];
      em1 = em;
    }
  }
  *err = em;
}


x86 assembly (clang, -O0):
<llz_levinson1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
lea    -0x240(%rbp),%rdi
xor    %esi,%esi
mov    $0x208,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11a2 <llz_levinson1+0x92>
jp     11a2 <llz_levinson1+0x92>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     119d <llz_levinson1+0x8d>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1163 <llz_levinson1+0x53>
jmp    1421 <llz_levinson1+0x311>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11e3 <llz_levinson1+0xd3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a9 <llz_levinson1+0x99>
mov    -0x18(%rbp),%rax
movsd  0xe11(%rip),%xmm0
movsd  %xmm0,(%rax)
movsd  0xe05(%rip),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     141c <llz_levinson1+0x30c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1299 <llz_levinson1+0x189>
movslq -0x30(%rbp),%rax
movsd  -0x240(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x260(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1243 <llz_levinson1+0x133>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x260(%rbp),%xmm0
ff
divsd  -0x250(%rbp),%xmm0
ff
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     137c <llz_levinson1+0x26c>
movslq -0x30(%rbp),%rax
movsd  -0x240(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x38(%rbp),%eax
sub    -0x30(%rbp),%eax
cltq
movsd  -0x240(%rbp,%rax,8),%xmm2
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    130b <llz_levinson1+0x1fb>
movsd  -0x248(%rbp),%xmm0
ff
movsd  -0x248(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xc51(%rip),%xmm1
addsd  %xmm1,%xmm0
mulsd  -0x250(%rbp),%xmm0
ff
movsd  %xmm0,-0x258(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13fe <llz_levinson1+0x2ee>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x34(%rbp),%rax
movsd  %xmm0,-0x240(%rbp,%rax,8)
ff ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13ca <llz_levinson1+0x2ba>
movsd  -0x258(%rbp),%xmm0
ff
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1225 <llz_levinson1+0x115>
jmp    1421 <llz_levinson1+0x311>
movsd  -0x258(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<llz_levinson1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x248,%rsp
mov    %r8,0x10(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rdx,%rbx
mov    %esi,%ebp
mov    %rdi,%r12
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    $0x208,%edx
call   1030 <memset@plt>
movsd  (%r12),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    118c <llz_levinson1+0x6c>
jp     118c <llz_levinson1+0x6c>
test   %ebp,%ebp
jle    149b <llz_levinson1+0x37b>
mov    %ebp,%edx
lea    0x1(%rdx),%r8
mov    $0x1,%ecx
cmp    $0x4,%ebp
jae    1445 <llz_levinson1+0x325>
mov    0x8(%rsp),%rax
jmp    1569 <llz_levinson1+0x449>
test   %ebp,%ebp
js     148e <llz_levinson1+0x36e>
mov    %ebp,%r14d
lea    0x8(,%r14,8),%r15
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rbx)
mov    %rax,0x40(%rsp)
test   %ebp,%ebp
je     149b <llz_levinson1+0x37b>
movsd  (%r12),%xmm7
lea    0x8(,%r14,8),%rax
mov    %rax,0x18(%rsp)
add    $0x1,%ebp
mov    %rbp,0x28(%rsp)
lea    0x8(%r12),%r10
lea    0x38(%rsp),%r14
lea    0x48(%rsp),%r13
mov    %r12,%rbp
mov    $0x1,%r12d
xor    %r15d,%r15d
mov    %rbp,0x20(%rsp)
mov    0x8(%rsp),%r8
jmp    127b <llz_levinson1+0x15b>
nopw   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
addsd  0xde4(%rip),%xmm1
mulsd  %xmm1,%xmm7
movsd  %xmm7,0x38(%rsp)
lea    0x40(%rsp),%rdi
mov    %rbx,%rsi
mov    0x18(%rsp),%rdx
call   1040 <memcpy@plt>
movsd  0x38(%rsp),%xmm7
mov    0x8(%rsp),%r8
add    $0x1,%r12
add    $0x1,%r15
add    $0x8,%rbp
mov    0x30(%rsp),%r10
add    $0x8,%r10
add    $0x8,%r14
add    $0x8,%r13
cmp    0x28(%rsp),%r12
je     15ef <llz_levinson1+0x4cf>
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
xorpd  %xmm0,%xmm0
cmp    $0x2,%r12
jb     135a <llz_levinson1+0x23a>
lea    -0x1(%r15),%rcx
xorpd  %xmm0,%xmm0
cmp    $0x3,%rcx
jae    12b0 <llz_levinson1+0x190>
mov    $0x1,%ecx
test   $0x3,%r15b
jne    131a <llz_levinson1+0x1fa>
jmp    135a <llz_levinson1+0x23a>
xchg   %ax,%ax
mov    $0xffffffffffffffff,%rcx
lea    0x60(%rsp),%rdx
nopl   0x0(%rax)
movsd  -0x18(%rdx),%xmm1
movsd  -0x10(%rdx),%xmm2
mulsd  0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  -0x8(%rdx),%xmm1
mulsd  -0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  (%rdx),%xmm0
mulsd  -0x10(%rbp,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
add    $0x20,%rdx
lea    (%rax,%rcx,1),%rsi
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rcx
cmp    $0xffffffffffffffff,%rsi
jne    12c0 <llz_levinson1+0x1a0>
neg    %rcx
test   $0x3,%r15b
je     135a <llz_levinson1+0x23a>
mov    %r15d,%edx
and    $0x3,%edx
lea    0x0(,%rcx,8),%rdi
mov    %r10,%rsi
sub    %rdi,%rsi
lea    (%rsp,%rcx,8),%rcx
add    $0x40,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm1
mulsd  (%rsi),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rdi,%rdx
jne    1340 <llz_levinson1+0x220>
mov    %r10,0x30(%rsp)
mov    0x20(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm7,%xmm1
movapd %xmm1,%xmm0
xorpd  0xc82(%rip),%xmm0
movlpd %xmm0,-0x8(%r8,%r12,8)
movsd  %xmm1,(%rbx,%r12,8)
cmp    $0x2,%r12
jb     1220 <llz_levinson1+0x100>
mov    $0x1,%ecx
cmp    $0x4,%r15
jb     1411 <llz_levinson1+0x2f1>
lea    0x1(%rax),%rcx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
mov    %r14,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x48(%rsp,%rsi,8),%xmm3
movupd 0x58(%rsp,%rsi,8),%xmm4
movupd -0x10(%rdx),%xmm5
movupd (%rdx),%xmm6
shufpd $0x1,%xmm6,%xmm6
shufpd $0x1,%xmm5,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,0x8(%rbx,%rsi,8)
movupd %xmm5,0x18(%rbx,%rsi,8)
add    $0x4,%rsi
add    $0xffffffffffffffe0,%rdx
cmp    %rsi,%rax
jne    13c0 <llz_levinson1+0x2a0>
cmp    %rax,%r15
je     1220 <llz_levinson1+0x100>
lea    0x0(,%rcx,8),%rdx
mov    %r13,%rax
sub    %rdx,%rax
nop
movsd  (%rax),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x40(%rsp,%rcx,8),%xmm2
movsd  %xmm2,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xfffffffffffffff8,%rax
cmp    %rcx,%r12
jne    1420 <llz_levinson1+0x300>
jmp    1220 <llz_levinson1+0x100>
mov    0x8(%rsp),%rax
lea    0x8(%rax),%rsi
lea    (%rbx,%r8,8),%rdi
cmp    %rdi,%rsi
jae    1468 <llz_levinson1+0x348>
lea    (%rax,%r8,8),%rsi
lea    0x8(%rbx),%rdi
cmp    %rsi,%rdi
jb     1569 <llz_levinson1+0x449>
mov    %edx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0xc,%rdi
jae    14a0 <llz_levinson1+0x380>
xor    %edi,%edi
jmp    151a <llz_levinson1+0x3fa>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rbx)
jmp    15ef <llz_levinson1+0x4cf>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,0x8(%rax,%rdi,8)
movupd %xmm0,0x18(%rax,%rdi,8)
movupd %xmm0,0x8(%rbx,%rdi,8)
movupd %xmm0,0x18(%rbx,%rdi,8)
movupd %xmm0,0x28(%rax,%rdi,8)
movupd %xmm0,0x38(%rax,%rdi,8)
movupd %xmm0,0x28(%rbx,%rdi,8)
movupd %xmm0,0x38(%rbx,%rdi,8)
movupd %xmm0,0x48(%rax,%rdi,8)
movupd %xmm0,0x58(%rax,%rdi,8)
movupd %xmm0,0x48(%rbx,%rdi,8)
movupd %xmm0,0x58(%rbx,%rdi,8)
movupd %xmm0,0x68(%rax,%rdi,8)
movupd %xmm0,0x78(%rax,%rdi,8)
movupd %xmm0,0x68(%rbx,%rdi,8)
movupd %xmm0,0x78(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    14b0 <llz_levinson1+0x390>
test   %rbp,%rbp
je     155c <llz_levinson1+0x43c>
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x0(,%rdi,8),%rsi
or     $0x8,%rsi
movupd %xmm0,(%rax,%rsi,1)
movupd %xmm0,0x10(%rax,%rsi,1)
movupd %xmm0,(%rbx,%rsi,1)
movupd %xmm0,0x10(%rbx,%rsi,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rbp
jne    1530 <llz_levinson1+0x410>
cmp    %rcx,%rdx
je     15ef <llz_levinson1+0x4cf>
or     $0x1,%rcx
mov    %r8d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
and    $0x3,%rsi
je     159a <llz_levinson1+0x47a>
nopl   (%rax)
movq   $0x0,(%rax,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1580 <llz_levinson1+0x460>
cmp    $0x3,%rdx
jb     15ef <llz_levinson1+0x4cf>
movq   $0x0,(%rax,%rcx,8)
movq   $0x0,(%rbx,%rcx,8)
movq   $0x0,0x8(%rax,%rcx,8)
movq   $0x0,0x8(%rbx,%rcx,8)
movq   $0x0,0x10(%rax,%rcx,8)
movq   $0x0,0x10(%rbx,%rcx,8)
movq   $0x0,0x18(%rax,%rcx,8)
movq   $0x0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    15a0 <llz_levinson1+0x480>
mov    0x10(%rsp),%rax
movsd  %xmm7,(%rax)
add    $0x248,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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