#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 */
typedef float dx;

/* Variables and functions */
int /*<<< orphan*/ free(float *);
float *malloc(int);
void agbnp3_cspline_setup(float dx, int n, float *y, float yp1, float ypn,
                          float *y2) {
  float *u;
  int i, k;
  float p, qn, sig, un;
  u = malloc(n * sizeof(float));
  if (yp1 > 0.99e30)
    y2[0] = u[0] = 0.0;
  else {
    y2[0] = -0.5;
    u[0] = (3.0 / (dx)) * ((y[1] - y[0]) / (dx)-yp1);
  }
  for (i = 1; i < n - 1; i++) {
    sig = 0.5;
    p = sig * y2[i - 1] + 2.0;
    y2[i] = (sig - 1.0) / p;
    u[i] = (y[i + 1] - y[i]) / (dx) - (y[i] - y[i - 1]) / (dx);
    u[i] = (6.0 * u[i] / (2. * dx) - sig * u[i - 1]) / p;
  }
  if (ypn > 0.99e30)
    qn = un = 0.0;
  else {
    qn = 0.5;
    un = (3.0 / (dx)) * (ypn - (y[n - 1] - y[n - 2]) / (2. * dx));
  }
  y2[n - 1] = (un - qn * u[n - 2]) / (qn * y2[n - 2] + 1.0);
  for (k = n - 2; k >= 0; k--) {
    y2[k] = y2[k] * y2[k + 1] + u[k];
  }
  free(u);
}


x86 assembly (clang, -O0):
<agbnp3_cspline_setup>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movss  %xmm0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm1,-0x14(%rbp)
movss  %xmm2,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe9a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    118b <agbnp3_cspline_setup+0x6b>
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    11df <agbnp3_cspline_setup+0xbf>
mov    -0x20(%rbp),%rax
movss  0xe91(%rip),%xmm0
movss  %xmm0,(%rax)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe5c(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm1
divss  -0x4(%rbp),%xmm1
subss  -0x14(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1341 <agbnp3_cspline_setup+0x221>
movss  0xe2d(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xde9(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdd3(%rip),%xmm1
subsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%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
divss  -0x4(%rbp),%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
divss  -0x4(%rbp),%xmm1
subss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd47(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x4(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xd22(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
mov    -0x28(%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    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e6 <agbnp3_cspline_setup+0xc6>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcae(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1371 <agbnp3_cspline_setup+0x251>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    13ee <agbnp3_cspline_setup+0x2ce>
movss  0xcb3(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc79(%rip),%xmm0
divsd  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x4(%rbp),%xmm3
cvtss2sd %xmm3,%xmm4
movsd  0xc3b(%rip),%xmm3
mulsd  %xmm4,%xmm3
divsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%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    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xbd2(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     14c6 <agbnp3_cspline_setup+0x3a6>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    146d <agbnp3_cspline_setup+0x34d>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<agbnp3_cspline_setup>:
push   %r15
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %rdx,%rbx
movss  %xmm2,0xc(%rsp)
movss  %xmm1,0x8(%rsp)
mov    %rsi,%r15
mov    %edi,%r14d
movaps %xmm0,0x10(%rsp)
lea    0x0(,%r14,4),%edi
call   1040 <malloc@plt>
movss  0x8(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
ucomisd 0xe9b(%rip),%xmm0
jbe    1181 <agbnp3_cspline_setup+0x61>
movl   $0x0,(%rax)
movl   $0x0,(%rbx)
xorps  %xmm0,%xmm0
xorps  %xmm7,%xmm7
movaps 0x10(%rsp),%xmm11
jmp    11cd <agbnp3_cspline_setup+0xad>
movl   $0xbf000000,(%rbx)
movaps 0x10(%rsp),%xmm11
xorps  %xmm0,%xmm0
cvtss2sd %xmm11,%xmm0
movsd  0xe6b(%rip),%xmm1
divsd  %xmm0,%xmm1
movss  0x4(%r15),%xmm0
subss  (%r15),%xmm0
divss  %xmm11,%xmm0
subss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0xe53(%rip),%xmm7
lea    -0x1(%r14),%edx
cmp    $0x3,%r14d
jl     129e <agbnp3_cspline_setup+0x17e>
xorps  %xmm1,%xmm1
cvtss2sd %xmm11,%xmm1
addsd  %xmm1,%xmm1
mov    %edx,%ecx
movaps %xmm11,%xmm2
shufps $0x0,%xmm11,%xmm2
mov    $0x1,%esi
movss  0xe24(%rip),%xmm8
movss  0xe1f(%rip),%xmm9
movss  0xe0f(%rip),%xmm3
movsd  0xdf6(%rip),%xmm10
nopw   0x0(%rax,%rax,1)
mulss  %xmm8,%xmm7
addss  %xmm9,%xmm7
xorps  %xmm4,%xmm4
cvtss2sd %xmm7,%xmm4
movaps %xmm3,%xmm5
divss  %xmm7,%xmm5
movss  %xmm5,(%rbx,%rsi,4)
movsd  (%r15,%rsi,4),%xmm7
movss  -0x4(%r15,%rsi,4),%xmm6
movlhps %xmm7,%xmm6
shufps $0xe2,%xmm7,%xmm6
shufps $0xe1,%xmm7,%xmm7
subps  %xmm6,%xmm7
divps  %xmm2,%xmm7
movaps %xmm7,%xmm6
shufps $0x55,%xmm7,%xmm6
subss  %xmm6,%xmm7
xorps  %xmm6,%xmm6
cvtss2sd %xmm7,%xmm6
mulsd  %xmm10,%xmm6
divsd  %xmm1,%xmm6
mulss  %xmm3,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm6,%xmm0
divsd  %xmm4,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rsi,4)
lea    0x1(%rsi),%rdi
movaps %xmm5,%xmm7
mov    %rdi,%rsi
cmp    %rdi,%rcx
jne    1220 <agbnp3_cspline_setup+0x100>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd 0xd50(%rip),%xmm0
jbe    12c5 <agbnp3_cspline_setup+0x1a5>
lea    -0x2(%r14),%ecx
movslq %ecx,%rsi
movslq %edx,%rdx
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
jmp    1324 <agbnp3_cspline_setup+0x204>
xorps  %xmm1,%xmm1
cvtss2sd %xmm11,%xmm1
movslq %edx,%rdx
movss  (%r15,%rdx,4),%xmm2
lea    -0x2(%r14),%ecx
movslq %r14d,%rsi
subss  -0x8(%r15,%rsi,4),%xmm2
add    $0xfffffffffffffffe,%rsi
cvtss2sd %xmm2,%xmm2
movaps %xmm1,%xmm3
addsd  %xmm1,%xmm3
movaps 0xd36(%rip),%xmm4
movlhps %xmm2,%xmm4
unpcklpd %xmm3,%xmm1
divpd  %xmm1,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
subsd  %xmm1,%xmm0
mulsd  %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  0xd00(%rip),%xmm0
movss  (%rax,%rsi,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulss  (%rbx,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xcd2(%rip),%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx,%rdx,4)
cmp    $0x2,%r14d
jl     13b1 <agbnp3_cspline_setup+0x291>
mov    %ecx,%edx
test   $0x1,%cl
jne    137c <agbnp3_cspline_setup+0x25c>
movss  (%rbx,%rdx,4),%xmm0
mulss  0x4(%rbx,%rdx,4),%xmm0
addss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
add    $0xffffffffffffffff,%rdx
test   %ecx,%ecx
je     13b1 <agbnp3_cspline_setup+0x291>
movss  (%rbx,%rdx,4),%xmm0
mulss  0x4(%rbx,%rdx,4),%xmm0
addss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%rbx,%rdx,4)
mulss  -0x4(%rbx,%rdx,4),%xmm0
addss  -0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rbx,%rdx,4)
add    $0xfffffffffffffffe,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1380 <agbnp3_cspline_setup+0x260>
mov    %rax,%rdi
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1030 <free@plt>

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

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