#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(float *, int /*<<< orphan*/, int);
void fa_levinson(float *r, int p, float *acof, float *kcof, float *err) {
  int i, j;
  float acc;
  float tmp[64 + 1];
  memset(tmp, 0, sizeof(float) * (64 + 1));
  if (r[0] == 0.0) {
    for (i = 1; i <= p; i++) {
      acof[i] = 0.0;
      kcof[i] = 0.0;
    }
    *err = 0.0;
  } else {
    acof[0] = (float)1.0;
    *err = r[0];
    for (i = 1; i <= p; ++i) {
      acc = r[i];
      for (j = 1; j <= i - 1; ++j)
        acc += acof[j] * r[i - j];
      kcof[i - 1] = -acc / (*err);
      acof[i] = kcof[i - 1];
      for (j = 0; j < p; ++j)
        tmp[j] = acof[j];
      for (j = 1; j < i; ++j)
        acof[j] += kcof[i - 1] * tmp[i - j];
      *err *= (1 - kcof[i - 1] * kcof[i - 1]);
    }
  }
}


x86 assembly (clang, -O0):
<fa_levinson>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
lea    -0x140(%rbp),%rdi
xor    %esi,%esi
mov    $0x104,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11b1 <fa_levinson+0xa1>
jp     11b1 <fa_levinson+0xa1>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11a1 <fa_levinson+0x91>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1167 <fa_levinson+0x57>
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    1391 <fa_levinson+0x281>
mov    -0x18(%rbp),%rax
movss  0xe43(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     138c <fa_levinson+0x27c>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     124d <fa_levinson+0x13d>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fd <fa_levinson+0xed>
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
divss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d3 <fa_levinson+0x1c3>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x140(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129f <fa_levinson+0x18f>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1331 <fa_levinson+0x221>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
cltq
movss  -0x140(%rbp,%rax,4),%xmm2
ff ff
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12da <fa_levinson+0x1ca>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xc92(%rip),%xmm1
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d8 <fa_levinson+0xc8>
jmp    1391 <fa_levinson+0x281>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fa_levinson>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %esi,%r12d
mov    %rdi,%rbp
lea    0x50(%rsp),%rdi
xor    %esi,%esi
mov    $0x104,%edx
call   1030 <memset@plt>
movss  0x0(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11ce <fa_levinson+0xae>
jp     11ce <fa_levinson+0xae>
test   %r12d,%r12d
jle    163c <fa_levinson+0x51c>
mov    %r12d,%edx
lea    0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x8,%r12d
jb     15b8 <fa_levinson+0x498>
lea    0x4(%rbx),%rsi
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    11a4 <fa_levinson+0x84>
lea    (%rbx,%rax,4),%rsi
lea    0x4(%r13),%rdi
cmp    %rsi,%rdi
jb     15b8 <fa_levinson+0x498>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    14ff <fa_levinson+0x3df>
xor    %edi,%edi
jmp    1572 <fa_levinson+0x452>
mov    %rbp,%rcx
movl   $0x3f800000,(%rbx)
movss  0x0(%rbp),%xmm0
mov    %r14,0x38(%rsp)
movss  %xmm0,(%r14)
test   %r12d,%r12d
jle    1643 <fa_levinson+0x523>
mov    %r12,%rax
mov    %eax,%edx
shl    $0x2,%rdx
mov    %rdx,0x20(%rsp)
add    $0x1,%eax
mov    %rax,0x30(%rsp)
lea    0x4(%rbx),%rax
mov    %rax,0x18(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x10(%rsp)
lea    0x4(%rcx),%r14
lea    0x44(%rsp),%r10
lea    0x14(%rbx),%rax
mov    %rax,0x8(%rsp)
mov    $0x1,%r12d
xor    %r9d,%r9d
lea    0x50(%rsp),%r11
mov    %rcx,%rbp
mov    %rcx,0x28(%rsp)
jmp    129c <fa_levinson+0x17c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r13,%r12,4),%xmm1
mulss  %xmm1,%xmm1
movss  0xdad(%rip),%xmm0
subss  %xmm1,%xmm0
mov    0x38(%rsp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
add    $0x1,%r12
add    $0x1,%r9
add    $0x4,%rbp
add    $0x4,%r14
add    $0x4,%r10
add    $0x4,%r11
cmp    0x30(%rsp),%r12
mov    0x28(%rsp),%rcx
je     1643 <fa_levinson+0x523>
movss  (%rcx,%r12,4),%xmm1
cmp    $0x2,%r12
mov    %r10,0x48(%rsp)
mov    %r11,0x40(%rsp)
jb     137a <fa_levinson+0x25a>
lea    -0x1(%r9),%rcx
mov    $0x1,%eax
cmp    $0x3,%rcx
jb     1334 <fa_levinson+0x214>
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
mov    $0xffffffffffffffff,%rax
mov    0x10(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
movss  -0xc(%rdx),%xmm2
movss  -0x8(%rdx),%xmm3
mulss  0x4(%rbp,%rax,4),%xmm2
addss  %xmm1,%xmm2
mulss  0x0(%rbp,%rax,4),%xmm3
addss  %xmm2,%xmm3
movss  -0x4(%rdx),%xmm2
mulss  -0x4(%rbp,%rax,4),%xmm2
addss  %xmm3,%xmm2
movss  (%rdx),%xmm1
mulss  -0x8(%rbp,%rax,4),%xmm1
addss  %xmm2,%xmm1
add    $0x10,%rdx
lea    (%rcx,%rax,1),%rsi
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rax
cmp    $0xffffffffffffffff,%rsi
jne    12e0 <fa_levinson+0x1c0>
neg    %rax
test   $0x3,%r9b
je     137a <fa_levinson+0x25a>
mov    %r9d,%ecx
and    $0x3,%ecx
lea    0x0(,%rax,4),%rsi
mov    %r14,%rdx
sub    %rsi,%rdx
lea    (%rbx,%rax,4),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rsi,4),%xmm2
mulss  (%rdx),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rsi
add    $0xfffffffffffffffc,%rdx
cmp    %rsi,%rcx
jne    1360 <fa_levinson+0x240>
xorps  0xc7f(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r13,%r12,4)
movss  %xmm1,(%rbx,%r12,4)
lea    0x50(%rsp),%rdi
mov    %rbx,%rsi
mov    0x20(%rsp),%rdx
mov    %r9,%r15
call   1040 <memcpy@plt>
mov    %r15,%r9
cmp    $0x2,%r12
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%r11
jb     1250 <fa_levinson+0x130>
mov    $0x1,%eax
cmp    $0x8,%r9
jb     1470 <fa_levinson+0x350>
lea    0x0(,%r12,4),%rcx
add    %r13,%rcx
cmp    %rcx,0x18(%rsp)
jae    13f3 <fa_levinson+0x2d3>
lea    (%rbx,%r12,4),%rcx
lea    0x0(,%r9,4),%rdx
add    %r13,%rdx
cmp    %rcx,%rdx
jb     1470 <fa_levinson+0x350>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rcx,%rdx
neg    %rdx
lea    0x1(%rcx),%rax
movss  -0x4(%r13,%r12,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x8(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%r10,%rdi,4),%xmm1
movups (%r10,%rdi,4),%xmm2
shufps $0x1b,%xmm2,%xmm2
shufps $0x1b,%xmm1,%xmm1
movups -0x10(%rsi),%xmm3
movups (%rsi),%xmm4
mulps  %xmm0,%xmm2
addps  %xmm3,%xmm2
mulps  %xmm0,%xmm1
addps  %xmm4,%xmm1
movups %xmm2,-0x10(%rsi)
movups %xmm1,(%rsi)
add    $0xfffffffffffffff8,%rdi
add    $0x20,%rsi
cmp    %rdi,%rdx
jne    1420 <fa_levinson+0x300>
cmp    %rcx,%r9
je     1250 <fa_levinson+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rcx
test   $0x1,%r12b
jne    149a <fa_levinson+0x37a>
movss  -0x4(%r13,%r12,4),%xmm0
mov    %r12,%rcx
sub    %rax,%rcx
mulss  0x50(%rsp,%rcx,4),%xmm0
addss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
lea    0x1(%rax),%rcx
cmp    %rax,%r9
je     1250 <fa_levinson+0x130>
lea    0x0(,%rcx,4),%rdx
mov    %r11,%rax
sub    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r13,%r12,4),%xmm0
mulss  0x4(%rax),%xmm0
addss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rbx,%rcx,4)
movss  -0x4(%r13,%r12,4),%xmm0
mulss  (%rax),%xmm0
addss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rbx,%rcx,4)
add    $0x2,%rcx
add    $0xfffffffffffffff8,%rax
cmp    %rcx,%r12
jne    14c0 <fa_levinson+0x3a0>
jmp    1250 <fa_levinson+0x130>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorps  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movups %xmm0,0x4(%rbx,%rdi,4)
movups %xmm0,0x14(%rbx,%rdi,4)
movups %xmm0,0x4(%r13,%rdi,4)
movups %xmm0,0x14(%r13,%rdi,4)
movups %xmm0,0x24(%rbx,%rdi,4)
movups %xmm0,0x34(%rbx,%rdi,4)
movups %xmm0,0x24(%r13,%rdi,4)
movups %xmm0,0x34(%r13,%rdi,4)
movups %xmm0,0x44(%rbx,%rdi,4)
movups %xmm0,0x54(%rbx,%rdi,4)
movups %xmm0,0x44(%r13,%rdi,4)
movups %xmm0,0x54(%r13,%rdi,4)
movups %xmm0,0x64(%rbx,%rdi,4)
movups %xmm0,0x74(%rbx,%rdi,4)
movups %xmm0,0x64(%r13,%rdi,4)
movups %xmm0,0x74(%r13,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1510 <fa_levinson+0x3f0>
test   %rbp,%rbp
je     15ab <fa_levinson+0x48b>
xorps  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movups %xmm0,(%rbx,%rsi,1)
movups %xmm0,0x10(%rbx,%rsi,1)
movups %xmm0,0x0(%r13,%rsi,1)
movups %xmm0,0x10(%r13,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    1580 <fa_levinson+0x460>
cmp    %rcx,%rdx
je     163c <fa_levinson+0x51c>
or     $0x1,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     15ea <fa_levinson+0x4ca>
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    15d0 <fa_levinson+0x4b0>
cmp    $0x3,%rdx
jb     163c <fa_levinson+0x51c>
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,0x0(%r13,%rcx,4)
movl   $0x0,0x4(%rbx,%rcx,4)
movl   $0x0,0x4(%r13,%rcx,4)
movl   $0x0,0x8(%rbx,%rcx,4)
movl   $0x0,0x8(%r13,%rcx,4)
movl   $0x0,0xc(%rbx,%rcx,4)
movl   $0x0,0xc(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    15f0 <fa_levinson+0x4d0>
movl   $0x0,(%r14)
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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