#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 chebpc(float c[], float d[], int n) {
  int k, j;
  float sv, *dd;
  dd = vector(0, n - 1);
  for (j = 0; j < n; j++)
    d[j] = dd[j] = 0.0;
  d[0] = c[n - 1];
  for (j = n - 2; j >= 1; j--) {
    for (k = n - j; k >= 1; k--) {
      sv = d[k];
      d[k] = 2.0 * d[k - 1] - dd[k];
      dd[k] = sv;
    }
    sv = d[0];
    d[0] = -dd[0] + c[j];
    dd[0] = sv;
  }
  for (j = n - 1; j >= 1; j--)
    d[j] = d[j - 1] - dd[j];
  d[0] = -dd[0] + 0.5 * c[0];
  free_vector(dd, 0, n - 1);
}


x86 assembly (clang, -O0):
<chebpc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <vector@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1185 <chebpc+0x65>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    114b <chebpc+0x2b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jl     12a0 <chebpc+0x180>
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x1,-0x18(%rbp)
jl     124e <chebpc+0x12e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11bb <chebpc+0x9b>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x20(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    11a8 <chebpc+0x88>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jl     12ed <chebpc+0x1cd>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    12a9 <chebpc+0x189>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1030 <free_vector@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<chebpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r15d
mov    %rsi,%rbx
mov    %rdi,%r12
lea    -0x1(%r15),%r14d
xor    %edi,%edi
mov    %r14d,%esi
call   1040 <vector@plt>
mov    %rax,%rdi
test   %r15d,%r15d
jle    120c <chebpc+0xec>
mov    %r15d,%r9d
cmp    $0x8,%r15d
jb     1171 <chebpc+0x51>
lea    (%rbx,%r9,4),%rcx
cmp    %rcx,%rdi
jae    121e <chebpc+0xfe>
lea    (%rdi,%r9,4),%rcx
cmp    %rbx,%rcx
jbe    121e <chebpc+0xfe>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     11a8 <chebpc+0x88>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,(%rdi,%rcx,4)
movl   $0x0,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1190 <chebpc+0x70>
cmp    $0x3,%rdx
jb     12f5 <chebpc+0x1d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rdi,%rcx,4)
movl   $0x0,(%rbx,%rcx,4)
movl   $0x0,0x4(%rdi,%rcx,4)
movl   $0x0,0x4(%rbx,%rcx,4)
movl   $0x0,0x8(%rdi,%rcx,4)
movl   $0x0,0x8(%rbx,%rcx,4)
movl   $0x0,0xc(%rdi,%rcx,4)
movl   $0x0,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11c0 <chebpc+0xa0>
jmp    12f5 <chebpc+0x1d5>
movslq %r14d,%rax
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rbx)
jmp    13de <chebpc+0x2be>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    1244 <chebpc+0x124>
xor    %ebp,%ebp
jmp    12a8 <chebpc+0x188>
and    $0xfffffffffffffffc,%rsi
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
nopl   (%rax)
movups %xmm0,(%rdi,%rbp,4)
movups %xmm0,0x10(%rdi,%rbp,4)
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
movups %xmm0,0x20(%rdi,%rbp,4)
movups %xmm0,0x30(%rdi,%rbp,4)
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm0,0x30(%rbx,%rbp,4)
movups %xmm0,0x40(%rdi,%rbp,4)
movups %xmm0,0x50(%rdi,%rbp,4)
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm0,0x50(%rbx,%rbp,4)
movups %xmm0,0x60(%rdi,%rbp,4)
movups %xmm0,0x70(%rdi,%rbp,4)
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm0,0x70(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rsi
jne    1250 <chebpc+0x130>
test   %r8,%r8
je     12ec <chebpc+0x1cc>
lea    (%rbx,%rbp,4),%rsi
add    $0x10,%rsi
lea    (%rdi,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %edx,%edx
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rbp,%rdx,1)
movups %xmm0,0x0(%rbp,%rdx,1)
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm0,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    12d0 <chebpc+0x1b0>
cmp    %r9,%rcx
jne    1173 <chebpc+0x53>
movslq %r14d,%rcx
movss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%rbx)
cmp    $0x3,%r15d
jl     1391 <chebpc+0x271>
lea    -0x2(%r15),%ecx
mov    $0x2,%edx
mov    $0x1,%ebp
jmp    1347 <chebpc+0x227>
nopl   0x0(%rax)
movss  (%rbx),%xmm0
movss  (%r12,%rcx,4),%xmm1
subss  (%rdi),%xmm1
movss  %xmm1,(%rbx)
movss  %xmm0,(%rdi)
add    $0xffffffffffffffff,%rcx
add    $0x1,%rdx
add    $0x1,%rbp
cmp    %r9,%rdx
je     1391 <chebpc+0x271>
cmp    %r9,%rcx
jge    1320 <chebpc+0x200>
mov    %rbp,%rsi
nop
movss  0x4(%rbx,%rsi,4),%xmm0
mov    %esi,%eax
movss  (%rbx,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x4(%rdi,%rsi,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm1,%xmm1
subsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%rbx,%rsi,4)
movss  %xmm0,0x4(%rdi,%rsi,4)
add    $0xffffffffffffffff,%rsi
lea    0x2(%rsi),%eax
cmp    $0x1,%eax
jg     1350 <chebpc+0x230>
jmp    1320 <chebpc+0x200>
cmp    $0x2,%r15d
jl     13de <chebpc+0x2be>
mov    %r14d,%esi
cmp    $0x1,%r14d
mov    %rsi,%r8
adc    $0xffffffffffffffff,%r8
add    $0x1,%r8
cmp    $0x8,%r8
jae    141f <chebpc+0x2ff>
add    $0x1,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x2(%rsi),%eax
movss  (%rbx,%rax,4),%xmm0
subss  -0x4(%rdi,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rsi,4)
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%rsi
ja     13c0 <chebpc+0x2a0>
movss  (%rdi),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%r12),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  0xc08(%rip),%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx)
xor    %esi,%esi
mov    %r14d,%edx
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>
cmp    $0x1,%r14d
mov    %rsi,%rcx
adc    $0xffffffffffffffff,%rcx
add    $0xfffffffe,%r15d
mov    $0x4,%edx
mov    %rcx,%rax
mul    %rdx
seto   %dl
cmp    %ecx,%r15d
jb     13af <chebpc+0x28f>
shr    $0x20,%rcx
jne    13af <chebpc+0x28f>
lea    (%rbx,%rsi,4),%rbp
mov    %rbp,%rcx
sub    %rax,%rcx
cmp    %rbp,%rcx
ja     13af <chebpc+0x28f>
test   %dl,%dl
jne    13af <chebpc+0x28f>
lea    (%rbx,%r15,4),%rbp
mov    %rbp,%rcx
sub    %rax,%rcx
cmp    %rbp,%rcx
ja     13af <chebpc+0x28f>
test   %dl,%dl
jne    13af <chebpc+0x28f>
lea    (%rdi,%rsi,4),%rbp
mov    %rbp,%rcx
sub    %rax,%rcx
cmp    %rbp,%rcx
ja     13af <chebpc+0x28f>
test   %dl,%dl
jne    13af <chebpc+0x28f>
xor    %eax,%eax
test   %r14d,%r14d
setne  %al
lea    (%rbx,%rax,4),%rcx
lea    (%rbx,%rsi,4),%rdx
add    $0x4,%rdx
lea    (%rax,%r15,1),%rbp
sub    %rsi,%rbp
lea    (%rbx,%rbp,4),%r9
lea    (%rbx,%r15,4),%rbp
add    $0x4,%rbp
lea    (%rdi,%rax,4),%r10
lea    (%rdi,%rsi,4),%rax
add    $0x4,%rax
cmp    %rbp,%rcx
setb   %r11b
cmp    %rdx,%r9
setb   %r9b
cmp    %rax,%rcx
setb   %al
cmp    %rdx,%r10
setb   %cl
test   %r9b,%r11b
jne    13af <chebpc+0x28f>
and    %cl,%al
jne    13af <chebpc+0x28f>
mov    $0xffffffff,%r9d
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     15ce <chebpc+0x4ae>
mov    %rdx,(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
and    %r11,%rax
lea    (%rbx,%rsi,4),%r10
add    $0xfffffffffffffff4,%r10
lea    (%rdi,%rsi,4),%rbp
add    $0xfffffffffffffff4,%rbp
lea    (%rsi,%r9,1),%r15
add    $0xfffffffffffffff8,%r15
lea    (%rsi,%r9,1),%r13
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%r13,1),%r9d
movups -0x1c(%rbx,%r9,4),%xmm0
movups -0xc(%rbx,%r9,4),%xmm1
movups -0x10(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x0(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm1,(%r10,%rcx,4)
movups %xmm0,-0x10(%r10,%rcx,4)
lea    (%r15,%rcx,1),%edx
movups -0x1c(%rbx,%rdx,4),%xmm0
movups -0xc(%rbx,%rdx,4),%xmm1
movups -0x30(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups -0x20(%rbp,%rcx,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm1,-0x20(%r10,%rcx,4)
movups %xmm0,-0x30(%r10,%rcx,4)
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rax
jne    1560 <chebpc+0x440>
neg    %rcx
mov    (%rsp),%rdx
mov    $0xffffffff,%r9d
jmp    15d0 <chebpc+0x4b0>
xor    %ecx,%ecx
test   $0x1,%r11b
je     1605 <chebpc+0x4e5>
mov    %rsi,%rax
sub    %rcx,%rax
add    %eax,%r9d
movups -0x1c(%rbx,%r9,4),%xmm0
movups -0xc(%rbx,%r9,4),%xmm1
movups -0x1c(%rdi,%rax,4),%xmm2
subps  %xmm2,%xmm0
movups -0xc(%rdi,%rax,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm1,-0xc(%rbx,%rax,4)
movups %xmm0,-0x1c(%rbx,%rax,4)
cmp    %rdx,%r8
je     13de <chebpc+0x2be>
sub    %rdx,%rsi
jmp    13af <chebpc+0x28f>

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

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