#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_vector(float *, int /*<<< orphan*/, int);
float *vector(int /*<<< orphan*/, int);
void polcoe(float x[], float y[], int n, float cof[]) {
  int k, j, i;
  float phi, ff, b, *s;
  s = vector(0, n);
  for (i = 0; i <= n; i++)
    s[i] = cof[i] = 0.0;
  s[n] = -x[0];
  for (i = 1; i <= n; i++) {
    for (j = n - i; j <= n - 1; j++)
      s[j] -= x[i] * s[j + 1];
    s[n] -= x[i];
  }
  for (j = 0; j <= n; j++) {
    phi = n + 1;
    for (k = n; k >= 1; k--)
      phi = k * s[k] + x[j] * phi;
    ff = y[j] / phi;
    b = 1.0;
    for (k = n; k >= 0; k--) {
      cof[k] += b * ff;
      b = s[k] + x[j] * b;
    }
  }
  free_vector(s, 0, n);
}


x86 assembly (clang, -O0):
<polcoe>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x14(%rbp),%esi
xor    %edi,%edi
call   1040 <vector@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1186 <polcoe+0x66>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%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    114c <polcoe+0x2c>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     125b <polcoe+0x13b>
mov    -0x14(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     122a <polcoe+0x10a>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c4 <polcoe+0xa4>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11af <polcoe+0x8f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1371 <polcoe+0x251>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jl     12cc <polcoe+0x1ac>
cvtsi2ssl -0x24(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1283 <polcoe+0x163>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xd15(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     135e <polcoe+0x23e>
movss  -0x38(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    12f6 <polcoe+0x1d6>
jmp    1363 <polcoe+0x243>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1262 <polcoe+0x142>
mov    -0x40(%rbp),%rdi
mov    -0x14(%rbp),%edx
xor    %esi,%esi
call   1030 <free_vector@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<polcoe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%rbx
mov    %edx,%r14d
mov    %rsi,%r12
mov    %rdi,%r15
xor    %edi,%edi
mov    %edx,%esi
call   1040 <vector@plt>
test   %r14d,%r14d
js     120c <polcoe+0xec>
lea    0x1(%r14),%r10d
cmp    $0x7,%r14d
jb     1170 <polcoe+0x50>
lea    (%rax,%r10,4),%rcx
cmp    %rbx,%rcx
jbe    1225 <polcoe+0x105>
lea    (%rbx,%r10,4),%rcx
cmp    %rcx,%rax
jae    1225 <polcoe+0x105>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r10,%rdx
mov    %r10,%rsi
and    $0x3,%rsi
je     11a8 <polcoe+0x88>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1190 <polcoe+0x70>
cmp    $0x3,%rdx
jb     1304 <polcoe+0x1e4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,0x4(%rbx,%rcx,4)
movl   $0x0,0x4(%rax,%rcx,4)
movl   $0x0,0x8(%rbx,%rcx,4)
movl   $0x0,0x8(%rax,%rcx,4)
movl   $0x0,0xc(%rbx,%rcx,4)
movl   $0x0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    11c0 <polcoe+0xa0>
jmp    1304 <polcoe+0x1e4>
movss  (%r15),%xmm0
xorps  0xde8(%rip),%xmm0
movslq %r14d,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    167d <polcoe+0x55d>
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1249 <polcoe+0x129>
xor    %edi,%edi
jmp    12b8 <polcoe+0x198>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups %xmm0,(%rbx,%rdi,4)
movups %xmm0,0x10(%rbx,%rdi,4)
movups %xmm0,(%rax,%rdi,4)
movups %xmm0,0x10(%rax,%rdi,4)
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm0,0x30(%rbx,%rdi,4)
movups %xmm0,0x20(%rax,%rdi,4)
movups %xmm0,0x30(%rax,%rdi,4)
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm0,0x50(%rbx,%rdi,4)
movups %xmm0,0x40(%rax,%rdi,4)
movups %xmm0,0x50(%rax,%rdi,4)
movups %xmm0,0x60(%rbx,%rdi,4)
movups %xmm0,0x70(%rbx,%rdi,4)
movups %xmm0,0x60(%rax,%rdi,4)
movups %xmm0,0x70(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1260 <polcoe+0x140>
test   %rdx,%rdx
je     12fb <polcoe+0x1db>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm0,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    12e0 <polcoe+0x1c0>
cmp    %r10,%rcx
jne    1172 <polcoe+0x52>
mov    %r12,0x20(%rsp)
movss  (%r15),%xmm0
xorps  0xceb(%rip),%xmm0
movslq %r14d,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    %r14,0x10(%rsp)
test   %r14d,%r14d
jle    14cd <polcoe+0x3ad>
mov    0x10(%rsp),%rdx
lea    -0x1(%rdx),%r11d
lea    0x4(%rax),%rsi
mov    %rsi,0x30(%rsp)
lea    0x14(%rax),%rsi
mov    %rsi,0x28(%rsp)
mov    $0x1,%edi
xor    %r8d,%r8d
movaps 0xcab(%rip),%xmm0
mov    %r11d,0xc(%rsp)
mov    %edx,%r13d
mov    %r10,0x18(%rsp)
jmp    1395 <polcoe+0x275>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rcx,4),%xmm1
subss  (%r15,%rdi,4),%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rdi
add    $0x1,%r8
add    $0xffffffff,%r11d
cmp    %r10,%rdi
je     14cd <polcoe+0x3ad>
movslq %r11d,%r14
lea    0x1(%r14),%r9
cmp    %rcx,%r9
cmovle %rcx,%r9
mov    0xc(%rsp),%edx
sub    %r8d,%edx
movslq %edx,%rsi
lea    0x1(%rsi),%rdx
cmp    %rcx,%rdx
mov    %rcx,%r12
cmovg  %rdx,%r12
sub    %rsi,%r12
add    $0xffffffff,%r13d
movslq %r13d,%rbp
movss  (%rax,%rbp,4),%xmm1
cmp    $0x8,%r12
jb     14a0 <polcoe+0x380>
lea    (%r15,%r8,4),%r10
add    $0x8,%r10
cmp    %rcx,%rdx
cmovle %rcx,%rdx
lea    (%rax,%rsi,4),%rsi
cmp    %r10,%rsi
jae    1410 <polcoe+0x2f0>
lea    (%r15,%rdi,4),%r10
mov    0x30(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
cmp    %rdx,%r10
jae    1410 <polcoe+0x2f0>
mov    0x18(%rsp),%r10
jmp    14a0 <polcoe+0x380>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdx
lea    (%rdx,%r14,4),%r10
sub    %r14,%r9
and    $0xfffffffffffffff8,%r9
mov    %r12,%r14
and    $0xfffffffffffffff8,%r14
add    %r14,%rbp
shufps $0x0,%xmm1,%xmm1
movss  (%r15,%rdi,4),%xmm2
shufps $0x0,%xmm2,%xmm2
xorps  %xmm0,%xmm2
xor    %edx,%edx
nopl   (%rax)
movups -0x10(%r10,%rdx,4),%xmm3
shufps $0x3,%xmm3,%xmm1
shufps $0x98,%xmm3,%xmm1
movaps %xmm2,%xmm4
mulps  %xmm3,%xmm4
addps  %xmm1,%xmm4
movups (%r10,%rdx,4),%xmm1
shufps $0x3,%xmm1,%xmm3
shufps $0x98,%xmm1,%xmm3
movaps %xmm2,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,-0x14(%r10,%rdx,4)
movups %xmm5,-0x4(%r10,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1440 <polcoe+0x320>
cmp    %r14,%r12
mov    0x18(%rsp),%r10
je     1370 <polcoe+0x250>
shufps $0xff,%xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%rax,%rbp,4),%xmm2
movss  (%r15,%rdi,4),%xmm3
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm1
movss  %xmm1,(%rax,%rbp,4)
lea    0x1(%rbp),%rdx
movaps %xmm2,%xmm1
mov    %rdx,%rbp
cmp    %rcx,%rdx
jl     14a0 <polcoe+0x380>
jmp    1370 <polcoe+0x250>
mov    0x10(%rsp),%r14
test   %r14d,%r14d
mov    0x20(%rsp),%r9
js     167d <polcoe+0x55d>
xorps  %xmm0,%xmm0
cvtsi2ss %r10d,%xmm0
mov    %r14d,%edi
lea    -0x1(%rdi),%rsi
mov    %edi,%r8d
and    $0x3,%r8d
xor    %ecx,%ecx
movss  0xb10(%rip),%xmm1
jmp    151d <polcoe+0x3fd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %r10,%rcx
je     167d <polcoe+0x55d>
movaps %xmm0,%xmm3
test   %r14d,%r14d
je     15e9 <polcoe+0x4c9>
movss  (%r15,%rcx,4),%xmm2
mov    %rdi,%rdx
movaps %xmm0,%xmm3
test   %r8,%r8
je     156e <polcoe+0x44e>
mov    %r8,%rbp
mov    %rdi,%rdx
movaps %xmm0,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  (%rax,%rdx,4),%xmm4
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rbp
jne    1550 <polcoe+0x430>
cmp    $0x3,%rsi
jb     15e9 <polcoe+0x4c9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm4,%xmm4
cvtsi2ss %edx,%xmm4
mulss  (%rax,%rdx,4),%xmm4
lea    -0x1(%rdx),%ebp
xorps  %xmm5,%xmm5
cvtsi2ss %ebp,%xmm5
mulss  %xmm2,%xmm3
addss  %xmm3,%xmm4
mulss  -0x4(%rax,%rdx,4),%xmm5
lea    -0x2(%rdx),%ebp
xorps  %xmm6,%xmm6
cvtsi2ss %ebp,%xmm6
mulss  %xmm2,%xmm4
addss  %xmm4,%xmm5
mulss  -0x8(%rax,%rdx,4),%xmm6
lea    -0x3(%rdx),%ebp
xorps  %xmm3,%xmm3
cvtsi2ss %ebp,%xmm3
mulss  %xmm2,%xmm5
addss  %xmm5,%xmm6
mulss  -0xc(%rax,%rdx,4),%xmm3
mulss  %xmm2,%xmm6
addss  %xmm6,%xmm3
lea    -0x4(%rdx),%rbp
cmp    $0x4,%rdx
mov    %rbp,%rdx
jg     1580 <polcoe+0x460>
movss  (%r9,%rcx,4),%xmm2
divss  %xmm3,%xmm2
mov    %rdi,%rdx
movaps %xmm1,%xmm3
test   $0x1,%dil
jne    161b <polcoe+0x4fb>
movss  (%rbx,%rdi,4),%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
movss  (%r15,%rcx,4),%xmm3
addss  (%rax,%rdi,4),%xmm3
mov    %rsi,%rdx
test   %r14d,%r14d
je     1510 <polcoe+0x3f0>
add    $0x2,%rdx
nopl   0x0(%rax,%rax,1)
movaps %xmm3,%xmm4
mulss  %xmm2,%xmm4
addss  -0x8(%rbx,%rdx,4),%xmm4
movss  %xmm4,-0x8(%rbx,%rdx,4)
mulss  (%r15,%rcx,4),%xmm3
addss  -0x8(%rax,%rdx,4),%xmm3
movaps %xmm3,%xmm4
mulss  %xmm2,%xmm4
addss  -0xc(%rbx,%rdx,4),%xmm4
movss  %xmm4,-0xc(%rbx,%rdx,4)
mulss  (%r15,%rcx,4),%xmm3
addss  -0xc(%rax,%rdx,4),%xmm3
add    $0xfffffffffffffffe,%rdx
cmp    $0x1,%rdx
jg     1630 <polcoe+0x510>
jmp    1510 <polcoe+0x3f0>
mov    %rax,%rdi
xor    %esi,%esi
mov    %r14d,%edx
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>

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

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