#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, int);
float *vector(int, int);
void spline(float x[], float y[], int n, float yp1, float ypn, float y2[]) {
  int i, k;
  float p, qn, sig, un, *u;
  u = vector(1, n - 1);
  if (yp1 > 0.99e30)
    y2[1] = u[1] = 0.0;
  else {
    y2[1] = -0.5;
    u[1] = (3.0 / (x[2] - x[1])) * ((y[2] - y[1]) / (x[2] - x[1]) - yp1);
  }
  for (i = 2; i <= n - 1; i++) {
    sig = (x[i] - x[i - 1]) / (x[i + 1] - x[i - 1]);
    p = sig * y2[i - 1] + 2.0;
    y2[i] = (sig - 1.0) / p;
    u[i] = (y[i + 1] - y[i]) / (x[i + 1] - x[i]) -
           (y[i] - y[i - 1]) / (x[i] - x[i - 1]);
    u[i] = (6.0 * u[i] / (x[i + 1] - x[i - 1]) - sig * u[i - 1]) / p;
  }
  if (ypn > 0.99e30)
    qn = un = 0.0;
  else {
    qn = 0.5;
    un = (3.0 / (x[n] - x[n - 1])) *
         (ypn - (y[n] - y[n - 1]) / (x[n] - x[n - 1]));
  }
  y2[n] = (un - qn * u[n - 1]) / (qn * y2[n - 1] + 1.0);
  for (k = n - 1; k >= 1; k--)
    y2[k] = y2[k] * y2[k + 1] + u[k];
  free_vector(u, 1, n - 1);
}


x86 assembly (clang, -O0):
<spline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x48(%rbp)
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe9a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    118d <spline+0x6d>
mov    -0x48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
jmp    1202 <spline+0xe2>
mov    -0x28(%rbp),%rax
movss  0xe8f(%rip),%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe4c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
subss  0x4(%rax),%xmm2
divss  %xmm2,%xmm1
subss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13f2 <spline+0x2d2>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd97(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd69(%rip),%xmm1
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
divss  %xmm2,%xmm1
subss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xca1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1209 <spline+0xe9>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbfd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1422 <spline+0x302>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    14ba <spline+0x39a>
movss  0xc02(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbae(%rip),%xmm0
divsd  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm3
divss  %xmm3,%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x38(%rbp),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xafe(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jl     158d <spline+0x46d>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1534 <spline+0x414>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spline>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rcx,%rbx
movss  %xmm1,0xc(%rsp)
movss  %xmm0,0x8(%rsp)
mov    %edx,%r15d
mov    %rsi,%r12
mov    %rdi,%rbp
lea    -0x1(%r15),%r14d
mov    $0x1,%edi
mov    %r14d,%esi
call   1040 <vector@plt>
movss  0x8(%rsp),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
ucomisd 0xe96(%rip),%xmm0
jbe    117b <spline+0x5b>
movl   $0x0,0x4(%rax)
xorps  %xmm0,%xmm0
mov    %rbx,%rcx
jmp    11c7 <spline+0xa7>
movl   $0xbf000000,0x4(%rbx)
movss  0x8(%rbp),%xmm0
subss  0x4(%rbp),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xe6d(%rip),%xmm2
divsd  %xmm1,%xmm2
movss  0x8(%r12),%xmm1
subss  0x4(%r12),%xmm1
divss  %xmm0,%xmm1
subss  %xmm3,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    %rax,%rcx
movss  %xmm0,0x4(%rcx)
cmp    $0x3,%r15d
jl     140e <spline+0x2ee>
mov    %r15d,%ecx
lea    0x4(%rbx),%rdx
lea    (%rax,%rcx,4),%rsi
cmp    %rsi,%rdx
jae    12f4 <spline+0x1d4>
lea    (%rbx,%rcx,4),%rdx
mov    %rax,%rsi
add    $0x4,%rsi
cmp    %rdx,%rsi
jae    12f4 <spline+0x1d4>
shl    $0x2,%rcx
mov    $0x8,%edx
movss  0xe18(%rip),%xmm8
movsd  0xdf8(%rip),%xmm1
movsd  0xdf8(%rip),%xmm2
movss  -0x4(%rbp,%rdx,1),%xmm4
movss  0x0(%rbp,%rdx,1),%xmm3
subss  %xmm4,%xmm3
movss  0x4(%rbp,%rdx,1),%xmm5
subss  %xmm4,%xmm5
divss  %xmm5,%xmm3
movss  -0x4(%rbx,%rdx,1),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm8,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm3,%xmm5
addsd  %xmm1,%xmm5
cvtss2sd %xmm4,%xmm4
divsd  %xmm4,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  %xmm5,(%rbx,%rdx,1)
movss  (%r12,%rdx,1),%xmm5
movss  0x4(%r12,%rdx,1),%xmm6
subss  %xmm5,%xmm6
movss  0x0(%rbp,%rdx,1),%xmm7
movss  0x4(%rbp,%rdx,1),%xmm0
subss  %xmm7,%xmm0
subss  -0x4(%r12,%rdx,1),%xmm5
divss  %xmm0,%xmm6
subss  -0x4(%rbp,%rdx,1),%xmm7
divss  %xmm7,%xmm5
subss  %xmm5,%xmm6
movss  %xmm6,(%rax,%rdx,1)
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulsd  %xmm2,%xmm0
movss  0x4(%rbp,%rdx,1),%xmm5
subss  -0x4(%rbp,%rdx,1),%xmm5
cvtss2sd %xmm5,%xmm5
divsd  %xmm5,%xmm0
mulss  -0x4(%rax,%rdx,1),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm0
divsd  %xmm4,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1220 <spline+0x100>
jmp    140e <spline+0x2ee>
movss  0x4(%rbx),%xmm0
movss  0x4(%rax),%xmm4
shl    $0x2,%rcx
mov    $0x8,%edx
movss  0xd18(%rip),%xmm8
movsd  0xcf7(%rip),%xmm9
movsd  0xcf6(%rip),%xmm10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,1),%xmm5
movss  -0x4(%rbp,%rdx,1),%xmm6
shufps $0x0,%xmm6,%xmm6
subps  %xmm6,%xmm5
movaps %xmm5,%xmm6
shufps $0x55,%xmm5,%xmm6
divss  %xmm6,%xmm5
mulss  %xmm5,%xmm0
addss  %xmm8,%xmm0
xorps  %xmm7,%xmm7
cvtss2sd %xmm5,%xmm7
addsd  %xmm9,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
divsd  %xmm6,%xmm7
xorps  %xmm0,%xmm0
cvtsd2ss %xmm7,%xmm0
movss  %xmm0,(%rbx,%rdx,1)
movsd  (%r12,%rdx,1),%xmm7
movss  -0x4(%r12,%rdx,1),%xmm1
movlhps %xmm7,%xmm1
shufps $0xe2,%xmm7,%xmm1
shufps $0xe1,%xmm7,%xmm7
movsd  0x0(%rbp,%rdx,1),%xmm2
movss  -0x4(%rbp,%rdx,1),%xmm3
movlhps %xmm2,%xmm3
shufps $0xe2,%xmm2,%xmm3
shufps $0xe1,%xmm2,%xmm2
subps  %xmm1,%xmm7
subps  %xmm3,%xmm2
divps  %xmm2,%xmm7
movaps %xmm7,%xmm1
shufps $0x55,%xmm7,%xmm1
subss  %xmm1,%xmm7
movss  %xmm7,(%rax,%rdx,1)
xorps  %xmm1,%xmm1
cvtss2sd %xmm7,%xmm1
mulsd  %xmm10,%xmm1
movss  0x4(%rbp,%rdx,1),%xmm2
subss  -0x4(%rbp,%rdx,1),%xmm2
cvtss2sd %xmm2,%xmm2
divsd  %xmm2,%xmm1
mulss  %xmm4,%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm6,%xmm1
xorps  %xmm4,%xmm4
cvtsd2ss %xmm1,%xmm4
movss  %xmm4,(%rax,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1330 <spline+0x210>
movss  0xc(%rsp),%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
ucomisd 0xbdd(%rip),%xmm0
jbe    1433 <spline+0x313>
movslq %r14d,%rdx
movslq %r15d,%rcx
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
jmp    1486 <spline+0x366>
movslq %r15d,%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
movslq %r14d,%rdx
subss  0x0(%rbp,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xbb4(%rip),%xmm2
movss  (%r12,%rcx,4),%xmm3
subss  (%r12,%rdx,4),%xmm3
divsd  %xmm1,%xmm2
divss  %xmm0,%xmm3
subss  %xmm3,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  0xba6(%rip),%xmm0
movss  (%rax,%rdx,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulss  (%rbx,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xb78(%rip),%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
cmp    $0x2,%r15d
jl     14f1 <spline+0x3d1>
mov    %r14d,%ecx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rbx,%rcx,4),%xmm0
mulss  (%rbx,%rcx,4),%xmm0
addss  -0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rcx,4)
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     14d0 <spline+0x3b0>
mov    %rax,%rdi
mov    $0x1,%esi
mov    %r14d,%edx
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>

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

LLVM IR (-O2):
define void @spline(float* nocapture %0, float* nocapture %1, i32 %2, float %3, float %4, float* nocapture %5) {
%7 = add nsw i32 %2, -1
%8 = tail call float* @vector(i32 1, i32 %7)
%9 = fpext float %3 to double
%10 = fcmp ogt double %9, 9.900000e+29
br i1 %10, label %11, label %13
11: ; preds = %6
%12 = getelementptr inbounds float, float* %8, i64 1
store float 0.000000e+00, float* %12
br label %32
13: ; preds = %6
%14 = getelementptr inbounds float, float* %5, i64 1
store float -5.000000e-01, float* %14
%15 = getelementptr inbounds float, float* %0, i64 2
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %0, i64 1
%18 = load float, float* %17
%19 = fsub float %16, %18
%20 = fpext float %19 to double
%21 = fdiv double 3.000000e+00, %20
%22 = getelementptr inbounds float, float* %1, i64 2
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %1, i64 1
%25 = load float, float* %24
%26 = fsub float %23, %25
%27 = fdiv float %26, %19
%28 = fsub float %27, %3
%29 = fpext float %28 to double
%30 = fmul double %21, %29
%31 = fptrunc double %30 to float
br label %32
32: ; preds = %13, %11
%33 = phi float* [ %8, %13 ], [ %5, %11 ]
%34 = phi float [ %31, %13 ], [ 0.000000e+00, %11 ]
%35 = getelementptr inbounds float, float* %33, i64 1
store float %34, float* %35
%36 = icmp sgt i32 %2, 2
br i1 %36, label %37, label %164
37: ; preds = %32
%38 = zext i32 %2 to i64
%39 = getelementptr float, float* %5, i64 1
%40 = getelementptr float, float* %5, i64 %38
%41 = getelementptr float, float* %8, i64 1
%42 = getelementptr float, float* %8, i64 %38
%43 = icmp ult float* %39, %42
%44 = icmp ult float* %41, %40
%45 = and i1 %43, %44
br i1 %45, label %46, label %101
46: ; preds = %37, %46
%47 = phi i64 [ %54, %46 ], [ 2, %37 ]
%48 = getelementptr inbounds float, float* %0, i64 %47
%49 = load float, float* %48
%50 = add nsw i64 %47, -1
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = fsub float %49, %52
%54 = add nuw nsw i64 %47, 1
%55 = getelementptr inbounds float, float* %0, i64 %54
%56 = load float, float* %55
%57 = fsub float %56, %52
%58 = fdiv float %53, %57
%59 = getelementptr inbounds float, float* %5, i64 %50
%60 = load float, float* %59
%61 = fmul float %60, %58
%62 = fadd float %61, 2.000000e+00
%63 = fpext float %58 to double
%64 = fadd double %63, -1.000000e+00
%65 = fpext float %62 to double
%66 = fdiv double %64, %65
%67 = fptrunc double %66 to float
%68 = getelementptr inbounds float, float* %5, i64 %47
store float %67, float* %68
%69 = getelementptr inbounds float, float* %1, i64 %54
%70 = load float, float* %69
%71 = getelementptr inbounds float, float* %1, i64 %47
%72 = load float, float* %71
%73 = fsub float %70, %72
%74 = load float, float* %55
%75 = load float, float* %48
%76 = fsub float %74, %75
%77 = fdiv float %73, %76
%78 = getelementptr inbounds float, float* %1, i64 %50
%79 = load float, float* %78
%80 = fsub float %72, %79
%81 = load float, float* %51
%82 = fsub float %75, %81
%83 = fdiv float %80, %82
%84 = fsub float %77, %83
%85 = getelementptr inbounds float, float* %8, i64 %47
store float %84, float* %85
%86 = fpext float %84 to double
%87 = fmul double %86, 6.000000e+00
%88 = load float, float* %55
%89 = load float, float* %51
%90 = fsub float %88, %89
%91 = fpext float %90 to double
%92 = fdiv double %87, %91
%93 = getelementptr inbounds float, float* %8, i64 %50
%94 = load float, float* %93
%95 = fmul float %58, %94
%96 = fpext float %95 to double
%97 = fsub double %92, %96
%98 = fdiv double %97, %65
%99 = fptrunc double %98 to float
store float %99, float* %85
%100 = icmp eq i64 %54, %38
br i1 %100, label %164, label %46
101: ; preds = %37
%102 = getelementptr float, float* %5, i64 1
%103 = load float, float* %102
%104 = getelementptr float, float* %8, i64 1
%105 = load float, float* %104
br label %106
106: ; preds = %101, %106
%107 = phi float [ %105, %101 ], [ %162, %106 ]
%108 = phi float [ %103, %101 ], [ %130, %106 ]
%109 = phi i64 [ 2, %101 ], [ %114, %106 ]
%110 = getelementptr inbounds float, float* %0, i64 %109
%111 = add nsw i64 %109, -1
%112 = getelementptr inbounds float, float* %0, i64 %111
%113 = load float, float* %112
%114 = add nuw nsw i64 %109, 1
%115 = getelementptr inbounds float, float* %0, i64 %114
%116 = bitcast float* %110 to <2 x float>*
%117 = load <2 x float>, <2 x float>* %116
%118 = insertelement <2 x float> poison, float %113, i64 0
%119 = shufflevector <2 x float> %118, <2 x float> poison, <2 x i32> zeroinitializer
%120 = fsub <2 x float> %117, %119
%121 = extractelement <2 x float> %120, i64 0
%122 = extractelement <2 x float> %120, i64 1
%123 = fdiv float %121, %122
%124 = fmul float %108, %123
%125 = fadd float %124, 2.000000e+00
%126 = fpext float %123 to double
%127 = fadd double %126, -1.000000e+00
%128 = fpext float %125 to double
%129 = fdiv double %127, %128
%130 = fptrunc double %129 to float
%131 = getelementptr inbounds float, float* %5, i64 %109
store float %130, float* %131
%132 = getelementptr inbounds float, float* %1, i64 %109
%133 = bitcast float* %132 to <2 x float>*
%134 = load <2 x float>, <2 x float>* %133
%135 = shufflevector <2 x float> %134, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%136 = bitcast float* %110 to <2 x float>*
%137 = load <2 x float>, <2 x float>* %136
%138 = shufflevector <2 x float> %137, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%139 = getelementptr inbounds float, float* %1, i64 %111
%140 = load float, float* %139
%141 = insertelement <2 x float> %134, float %140, i64 1
%142 = fsub <2 x float> %135, %141
%143 = load float, float* %112
%144 = insertelement <2 x float> %137, float %143, i64 1
%145 = fsub <2 x float> %138, %144
%146 = fdiv <2 x float> %142, %145
%147 = shufflevector <2 x float> %146, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%148 = fsub <2 x float> %146, %147
%149 = extractelement <2 x float> %148, i64 0
%150 = getelementptr inbounds float, float* %8, i64 %109
store float %149, float* %150
%151 = fpext float %149 to double
%152 = fmul double %151, 6.000000e+00
%153 = load float, float* %115
%154 = load float, float* %112
%155 = fsub float %153, %154
%156 = fpext float %155 to double
%157 = fdiv double %152, %156
%158 = fmul float %123, %107
%159 = fpext float %158 to double
%160 = fsub double %157, %159
%161 = fdiv double %160, %128
%162 = fptrunc double %161 to float
store float %162, float* %150
%163 = icmp eq i64 %114, %38
br i1 %163, label %164, label %106
164: ; preds = %106, %46, %32
%165 = fpext float %4 to double
%166 = fcmp ogt double %165, 9.900000e+29
br i1 %166, label %167, label %170
167: ; preds = %164
%168 = sext i32 %7 to i64
%169 = sext i32 %2 to i64
br label %190
170: ; preds = %164
%171 = sext i32 %2 to i64
%172 = getelementptr inbounds float, float* %0, i64 %171
%173 = load float, float* %172
%174 = sext i32 %7 to i64
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = load float, float* %175
%177 = fsub float %173, %176
%178 = fpext float %177 to double
%179 = fdiv double 3.000000e+00, %178
%180 = getelementptr inbounds float, float* %1, i64 %171
%181 = load float, float* %180
%182 = getelementptr inbounds float, float* %1, i64 %174
%183 = load float, float* %182
%184 = fsub float %181, %183
%185 = fdiv float %184, %177
%186 = fsub float %4, %185
%187 = fpext float %186 to double
%188 = fmul double %179, %187
%189 = fptrunc double %188 to float
br label %190
190: ; preds = %167, %170
%191 = phi i64 [ %169, %167 ], [ %171, %170 ]
%192 = phi i64 [ %168, %167 ], [ %174, %170 ]
%193 = phi float [ 0.000000e+00, %167 ], [ 5.000000e-01, %170 ]
%194 = phi float [ 0.000000e+00, %167 ], [ %189, %170 ]
%195 = getelementptr inbounds float, float* %8, i64 %192
%196 = load float, float* %195
%197 = fneg float %193
%198 = tail call float @llvm.fmuladd.f32(float %197, float %196, float %194)
%199 = fpext float %198 to double
%200 = getelementptr inbounds float, float* %5, i64 %192
%201 = load float, float* %200
%202 = fmul float %193, %201
%203 = fpext float %202 to double
%204 = fadd double %203, 1.000000e+00
%205 = fdiv double %199, %204
%206 = fptrunc double %205 to float
%207 = getelementptr inbounds float, float* %5, i64 %191
store float %206, float* %207
%208 = icmp sgt i32 %2, 1
br i1 %208, label %209, label %223
209: ; preds = %190
%210 = zext i32 %7 to i64
br label %211
211: ; preds = %209, %211
%212 = phi i64 [ %210, %209 ], [ %221, %211 ]
%213 = getelementptr inbounds float, float* %5, i64 %212
%214 = load float, float* %213
%215 = add nuw nsw i64 %212, 1
%216 = getelementptr inbounds float, float* %5, i64 %215
%217 = load float, float* %216
%218 = getelementptr inbounds float, float* %8, i64 %212
%219 = load float, float* %218
%220 = tail call float @llvm.fmuladd.f32(float %214, float %217, float %219)
store float %220, float* %213
%221 = add nsw i64 %212, -1
%222 = icmp ugt i64 %212, 1
br i1 %222, label %211, label %223
223: ; preds = %211, %190
%224 = tail call i32 @free_vector(float* %8, i32 1, i32 %7)
ret void
}