int bspline_c2p(float *v[3], float *p[3]) {
  float aa, bb, cc, dd, ee, ff, gg, hh, ii, kk, ll, mm, nn;
  float oo, pp, qq, rr, ss, tt, uu, vv, ww, xx, yy, zz;
  int i;
  aa = -13.0 / 18.0;
  bb = -0.5;
  cc = 2.0;
  dd = -0.5;
  ee = 5.0 / 90.0;
  ff = 7.0 / 36.0;
  gg = 7.0 / 4.0;
  hh = -1.0;
  ii = 0.25;
  kk = -1.0 / 36.0;
  ll = -5.0 / 90.0;
  mm = -0.5;
  nn = 2.0;
  oo = -0.5;
  pp = 5.0 / 90.0;
  qq = 1.0 / 36.0;
  rr = 0.25;
  ss = -1.0;
  tt = 7.0 / 4.0;
  uu = -7.0 / 36.0;
  vv = -5.0 / 90.0;
  ww = -0.5;
  xx = 2.0;
  yy = -0.5;
  zz = 13.0 / 18.0;
  for (i = 0; i < 3; i++) {
    p[0][i] = aa * v[0][i] + bb * v[1][i] + cc * v[2][i] + dd * v[3][i] +
              ee * v[4][i];
    p[1][i] = ff * v[0][i] + gg * v[1][i] + hh * v[2][i] + ii * v[3][i] +
              kk * v[4][i];
    p[2][i] = ll * v[0][i] + mm * v[1][i] + nn * v[2][i] + oo * v[3][i] +
              pp * v[4][i];
    p[3][i] = qq * v[0][i] + rr * v[1][i] + ss * v[2][i] + tt * v[3][i] +
              uu * v[4][i];
    p[4][i] = vv * v[0][i] + ww * v[1][i] + xx * v[2][i] + yy * v[3][i] +
              zz * v[4][i];
  }
  return 0;
}


x86 assembly (clang, -O0):
<bspline_c2p>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  0xf1c(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movss  0xee3(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xeda(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  0xec9(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  0xedc(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xed7(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  0xeb2(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  0xea9(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  0xea0(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xe9f(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  0xe76(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xe61(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0xe58(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xe47(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0xe5a(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xe49(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0xe38(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  0xe27(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xe16(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0xe05(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  0xdf4(%rip),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  0xddf(%rip),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  0xdd6(%rip),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  0xdc5(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xdb4(%rip),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
cmpl   $0x3,-0x78(%rbp)
jge    1585 <bspline_c2p+0x485>
movss  -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x28(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x6c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x70(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1258 <bspline_c2p+0x158>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<bspline_c2p>:
push   %r14
push   %rbx
mov    (%rdi),%r8
mov    0x8(%rdi),%rcx
mov    0x10(%rdi),%rdx
mov    0x18(%rdi),%rax
mov    0x20(%rdi),%rdi
mov    (%rsi),%r9
mov    0x8(%rsi),%r10
mov    0x10(%rsi),%r11
mov    0x18(%rsi),%r14
mov    0x20(%rsi),%rsi
xor    %ebx,%ebx
movss  0xecd(%rip),%xmm0
movss  0xec8(%rip),%xmm8
movss  0xec4(%rip),%xmm2
movss  0xec0(%rip),%xmm3
movss  0xebb(%rip),%xmm9
movss  0xeb7(%rip),%xmm5
movss  0xeb2(%rip),%xmm10
movss  0xeae(%rip),%xmm7
movss  0xea9(%rip),%xmm11
movss  0xea4(%rip),%xmm12
movss  0xea0(%rip),%xmm6
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
movss  (%r8,%rbx,1),%xmm4
mulss  %xmm8,%xmm4
addss  %xmm1,%xmm4
movss  (%rdx,%rbx,1),%xmm1
addss  %xmm1,%xmm1
addss  %xmm4,%xmm1
movss  (%rax,%rbx,1),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  (%rdi,%rbx,1),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%r9,%rbx,1)
movss  (%rcx,%rbx,1),%xmm1
mulss  %xmm3,%xmm1
movss  (%r8,%rbx,1),%xmm4
mulss  %xmm9,%xmm4
addss  %xmm1,%xmm4
subss  (%rdx,%rbx,1),%xmm4
movss  (%rax,%rbx,1),%xmm1
mulss  %xmm5,%xmm1
addss  %xmm4,%xmm1
movss  (%rdi,%rbx,1),%xmm4
mulss  %xmm10,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%r10,%rbx,1)
movss  (%rcx,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
movss  (%r8,%rbx,1),%xmm4
mulss  %xmm7,%xmm4
addss  %xmm1,%xmm4
movss  (%rdx,%rbx,1),%xmm1
addss  %xmm1,%xmm1
addss  %xmm4,%xmm1
movss  (%rax,%rbx,1),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  (%rdi,%rbx,1),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%r11,%rbx,1)
movss  (%rcx,%rbx,1),%xmm1
mulss  %xmm5,%xmm1
movss  (%r8,%rbx,1),%xmm4
mulss  %xmm11,%xmm4
addss  %xmm1,%xmm4
subss  (%rdx,%rbx,1),%xmm4
movss  (%rax,%rbx,1),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
movss  (%rdi,%rbx,1),%xmm4
mulss  %xmm12,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%r14,%rbx,1)
movss  (%rcx,%rbx,1),%xmm1
mulss  %xmm0,%xmm1
movss  (%r8,%rbx,1),%xmm4
mulss  %xmm7,%xmm4
addss  %xmm1,%xmm4
movss  (%rdx,%rbx,1),%xmm1
addss  %xmm1,%xmm1
addss  %xmm4,%xmm1
movss  (%rax,%rbx,1),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  (%rdi,%rbx,1),%xmm1
mulss  %xmm6,%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%rsi,%rbx,1)
add    $0x4,%rbx
cmp    $0xc,%rbx
jne    1190 <bspline_c2p+0x90>
xor    %eax,%eax
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @bspline_c2p(float** nocapture %0, float** nocapture %1) {
%3 = load float*, float** %0
%4 = getelementptr inbounds float*, float** %0, i64 1
%5 = load float*, float** %4
%6 = getelementptr inbounds float*, float** %0, i64 2
%7 = load float*, float** %6
%8 = getelementptr inbounds float*, float** %0, i64 3
%9 = load float*, float** %8
%10 = getelementptr inbounds float*, float** %0, i64 4
%11 = load float*, float** %10
%12 = load float*, float** %1
%13 = getelementptr inbounds float*, float** %1, i64 1
%14 = load float*, float** %13
%15 = getelementptr inbounds float*, float** %1, i64 2
%16 = load float*, float** %15
%17 = getelementptr inbounds float*, float** %1, i64 3
%18 = load float*, float** %17
%19 = getelementptr inbounds float*, float** %1, i64 4
%20 = load float*, float** %19
br label %21
21: ; preds = %2, %21
%22 = phi i64 [ 0, %2 ], [ %83, %21 ]
%23 = getelementptr inbounds float, float* %3, i64 %22
%24 = load float, float* %23
%25 = getelementptr inbounds float, float* %5, i64 %22
%26 = load float, float* %25
%27 = fmul float %26, -5.000000e-01
%28 = tail call float @llvm.fmuladd.f32(float %24, float 0xBFE71C71C0000000, float %27)
%29 = getelementptr inbounds float, float* %7, i64 %22
%30 = load float, float* %29
%31 = tail call float @llvm.fmuladd.f32(float %30, float 2.000000e+00, float %28)
%32 = getelementptr inbounds float, float* %9, i64 %22
%33 = load float, float* %32
%34 = tail call float @llvm.fmuladd.f32(float %33, float -5.000000e-01, float %31)
%35 = getelementptr inbounds float, float* %11, i64 %22
%36 = load float, float* %35
%37 = tail call float @llvm.fmuladd.f32(float %36, float 0x3FAC71C720000000, float %34)
%38 = getelementptr inbounds float, float* %12, i64 %22
store float %37, float* %38
%39 = load float, float* %23
%40 = load float, float* %25
%41 = fmul float %40, 1.750000e+00
%42 = tail call float @llvm.fmuladd.f32(float %39, float 0x3FC8E38E40000000, float %41)
%43 = load float, float* %29
%44 = tail call float @llvm.fmuladd.f32(float %43, float -1.000000e+00, float %42)
%45 = load float, float* %32
%46 = tail call float @llvm.fmuladd.f32(float %45, float 2.500000e-01, float %44)
%47 = load float, float* %35
%48 = tail call float @llvm.fmuladd.f32(float %47, float 0xBF9C71C720000000, float %46)
%49 = getelementptr inbounds float, float* %14, i64 %22
store float %48, float* %49
%50 = load float, float* %23
%51 = load float, float* %25
%52 = fmul float %51, -5.000000e-01
%53 = tail call float @llvm.fmuladd.f32(float %50, float 0xBFAC71C720000000, float %52)
%54 = load float, float* %29
%55 = tail call float @llvm.fmuladd.f32(float %54, float 2.000000e+00, float %53)
%56 = load float, float* %32
%57 = tail call float @llvm.fmuladd.f32(float %56, float -5.000000e-01, float %55)
%58 = load float, float* %35
%59 = tail call float @llvm.fmuladd.f32(float %58, float 0x3FAC71C720000000, float %57)
%60 = getelementptr inbounds float, float* %16, i64 %22
store float %59, float* %60
%61 = load float, float* %23
%62 = load float, float* %25
%63 = fmul float %62, 2.500000e-01
%64 = tail call float @llvm.fmuladd.f32(float %61, float 0x3F9C71C720000000, float %63)
%65 = load float, float* %29
%66 = tail call float @llvm.fmuladd.f32(float %65, float -1.000000e+00, float %64)
%67 = load float, float* %32
%68 = tail call float @llvm.fmuladd.f32(float %67, float 1.750000e+00, float %66)
%69 = load float, float* %35
%70 = tail call float @llvm.fmuladd.f32(float %69, float 0xBFC8E38E40000000, float %68)
%71 = getelementptr inbounds float, float* %18, i64 %22
store float %70, float* %71
%72 = load float, float* %23
%73 = load float, float* %25
%74 = fmul float %73, -5.000000e-01
%75 = tail call float @llvm.fmuladd.f32(float %72, float 0xBFAC71C720000000, float %74)
%76 = load float, float* %29
%77 = tail call float @llvm.fmuladd.f32(float %76, float 2.000000e+00, float %75)
%78 = load float, float* %32
%79 = tail call float @llvm.fmuladd.f32(float %78, float -5.000000e-01, float %77)
%80 = load float, float* %35
%81 = tail call float @llvm.fmuladd.f32(float %80, float 0x3FE71C71C0000000, float %79)
%82 = getelementptr inbounds float, float* %20, i64 %22
store float %81, float* %82
%83 = add nuw nsw i64 %22, 1
%84 = icmp eq i64 %83, 3
br i1 %84, label %85, label %21
85: ; preds = %21
ret i32 0
}