void iresp_vcalc(float sf_co[], float pwf_z_co[], float pwf_p_co[], float h[]) {
  static float temp[5];
  static float rc[5];
  float a0, a1, a2;
  int i, k;
  temp[0] = rc[0] = 1.0;
  for (k = 1; k < 5; k++) {
    a0 = a1 = a2 = 0.0;
    for (i = k; i >= 1; i--) {
      temp[i] = temp[i - 1];
      rc[i] = rc[i - 1];
      a0 -= sf_co[i] * temp[i];
      a1 += pwf_z_co[i] * temp[i];
      a2 -= pwf_p_co[i] * rc[i];
    }
    temp[0] = a0;
    rc[0] = a0 + a1 + a2;
  }
  for (k = 0; k < 5; k++)
    h[k] = rc[5 - 1 - k];
}


x86 assembly (clang, -O0):
<iresp_vcalc>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  0xee4(%rip),%xmm0
movss  %xmm0,0x2f2c(%rip)
movss  0xed4(%rip),%xmm0
movss  %xmm0,0x2efc(%rip)
movl   $0x1,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    129e <iresp_vcalc+0x19e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jl     126c <iresp_vcalc+0x16c>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2eb3(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rcx
lea    0x2ea3(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2eae(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rcx
lea    0x2e9e(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rcx
lea    0x2e61(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rcx
lea    0x2e25(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x30(%rbp),%rcx
lea    0x2e16(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1163 <iresp_vcalc+0x63>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,0x2db7(%rip)
movss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,0x2dc0(%rip)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    113b <iresp_vcalc+0x3b>
movl   $0x0,-0x34(%rbp)
cmpl   $0x5,-0x34(%rbp)
jge    12e1 <iresp_vcalc+0x1e1>
mov    $0x4,%eax
sub    -0x34(%rbp),%eax
movslq %eax,%rcx
lea    0x2d8f(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a5 <iresp_vcalc+0x1a5>
pop    %rbp
ret

x86 assembly (clang, -O2):
<iresp_vcalc>:
movss  0x4(%rdi),%xmm13
movss  0x8(%rdi),%xmm11
xorps  %xmm0,%xmm0
xorps  %xmm15,%xmm15
subss  %xmm13,%xmm15
movss  0x4(%rsi),%xmm9
movss  0x8(%rsi),%xmm8
xorps  %xmm4,%xmm4
subss  %xmm11,%xmm4
movaps %xmm8,%xmm1
addss  %xmm0,%xmm1
movaps %xmm13,%xmm2
mulss  %xmm15,%xmm2
subss  %xmm2,%xmm4
movaps %xmm9,%xmm14
mulss  %xmm15,%xmm14
addss  %xmm1,%xmm14
addss  %xmm4,%xmm14
movss  0xc(%rdi),%xmm12
xorps  %xmm7,%xmm7
subss  %xmm12,%xmm7
movss  0xc(%rsi),%xmm10
movaps %xmm10,%xmm6
addss  %xmm0,%xmm6
movaps %xmm11,%xmm1
mulss  %xmm15,%xmm1
subss  %xmm1,%xmm7
movaps %xmm13,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm9,%xmm2
mulss  %xmm4,%xmm2
mulss  %xmm4,%xmm11
mulss  %xmm8,%xmm4
mulss  %xmm15,%xmm8
addss  %xmm6,%xmm8
subss  %xmm1,%xmm7
addss  %xmm8,%xmm2
addss  %xmm7,%xmm2
mulss  %xmm7,%xmm13
mulss  %xmm9,%xmm7
addss  %xmm0,%xmm9
movss  0x4(%rdx),%xmm3
movss  0x8(%rdx),%xmm8
xorps  %xmm5,%xmm5
subss  %xmm3,%xmm5
addss  %xmm15,%xmm9
addss  %xmm5,%xmm9
xorps  %xmm5,%xmm5
subss  %xmm8,%xmm5
movaps %xmm3,%xmm1
mulss  %xmm9,%xmm1
subss  %xmm1,%xmm5
addss  %xmm5,%xmm14
movss  0xc(%rdx),%xmm1
xorps  %xmm5,%xmm5
subss  %xmm1,%xmm5
movaps %xmm8,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm5
movaps %xmm3,%xmm6
mulss  %xmm14,%xmm6
subss  %xmm6,%xmm5
addss  %xmm5,%xmm2
xorps  %xmm5,%xmm5
subss  0x10(%rdi),%xmm5
mulss  %xmm15,%xmm12
subss  %xmm12,%xmm5
mulss  %xmm10,%xmm15
movss  0x10(%rsi),%xmm6
addss  %xmm0,%xmm6
addss  %xmm6,%xmm15
subss  0x10(%rdx),%xmm0
mulss  %xmm9,%xmm1
subss  %xmm1,%xmm0
subss  %xmm11,%xmm5
addss  %xmm15,%xmm4
mulss  %xmm14,%xmm8
subss  %xmm8,%xmm0
subss  %xmm13,%xmm5
addss  %xmm4,%xmm7
addss  %xmm5,%xmm7
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm0
addss  %xmm7,%xmm0
movl   $0x3f800000,(%rcx)
movss  %xmm9,0x4(%rcx)
movss  %xmm14,0x8(%rcx)
movss  %xmm2,0xc(%rcx)
movss  %xmm0,0x10(%rcx)
ret

LLVM IR (-O0):
@iresp_vcalc.temp = internal global [5 x float] zeroinitializer
@iresp_vcalc.rc = internal global [5 x float] zeroinitializer
define void @iresp_vcalc(float* %0, float* %1, float* %2, float* %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca i32
%13 = alloca i32
store float* %0, float** %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
store float 1.000000e+00, float* getelementptr inbounds ([5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 0)
store float 1.000000e+00, float* getelementptr inbounds ([5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 0)
store i32 1, i32* %13
br label %14
14: ; preds = %84, %4
%15 = load i32, i32* %13
%16 = icmp slt i32 %15, 5
br i1 %16, label %17, label %87
17: ; preds = %14
store float 0.000000e+00, float* %11
store float 0.000000e+00, float* %10
store float 0.000000e+00, float* %9
%18 = load i32, i32* %13
store i32 %18, i32* %12
br label %19
19: ; preds = %74, %17
%20 = load i32, i32* %12
%21 = icmp sge i32 %20, 1
br i1 %21, label %22, label %77
22: ; preds = %19
%23 = load i32, i32* %12
%24 = sub nsw i32 %23, 1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 %25
%27 = load float, float* %26
%28 = load i32, i32* %12
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 %29
store float %27, float* %30
%31 = load i32, i32* %12
%32 = sub nsw i32 %31, 1
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 %33
%35 = load float, float* %34
%36 = load i32, i32* %12
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 %37
store float %35, float* %38
%39 = load float*, float** %5
%40 = load i32, i32* %12
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
%44 = load i32, i32* %12
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 %45
%47 = load float, float* %46
%48 = load float, float* %9
%49 = fneg float %43
%50 = call float @llvm.fmuladd.f32(float %49, float %47, float %48)
store float %50, float* %9
%51 = load float*, float** %6
%52 = load i32, i32* %12
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = load i32, i32* %12
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 %57
%59 = load float, float* %58
%60 = load float, float* %10
%61 = call float @llvm.fmuladd.f32(float %55, float %59, float %60)
store float %61, float* %10
%62 = load float*, float** %7
%63 = load i32, i32* %12
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %62, i64 %64
%66 = load float, float* %65
%67 = load i32, i32* %12
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 %68
%70 = load float, float* %69
%71 = load float, float* %11
%72 = fneg float %66
%73 = call float @llvm.fmuladd.f32(float %72, float %70, float %71)
store float %73, float* %11
br label %74
74: ; preds = %22
%75 = load i32, i32* %12
%76 = add nsw i32 %75, -1
store i32 %76, i32* %12
br label %19
77: ; preds = %19
%78 = load float, float* %9
store float %78, float* getelementptr inbounds ([5 x float], [5 x float]* @iresp_vcalc.temp, i64 0, i64 0)
%79 = load float, float* %9
%80 = load float, float* %10
%81 = fadd float %79, %80
%82 = load float, float* %11
%83 = fadd float %81, %82
store float %83, float* getelementptr inbounds ([5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 0)
br label %84
84: ; preds = %77
%85 = load i32, i32* %13
%86 = add nsw i32 %85, 1
store i32 %86, i32* %13
br label %14
87: ; preds = %14
store i32 0, i32* %13
br label %88
88: ; preds = %101, %87
%89 = load i32, i32* %13
%90 = icmp slt i32 %89, 5
br i1 %90, label %91, label %104
91: ; preds = %88
%92 = load i32, i32* %13
%93 = sub nsw i32 4, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [5 x float], [5 x float]* @iresp_vcalc.rc, i64 0, i64 %94
%96 = load float, float* %95
%97 = load float*, float** %8
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %97, i64 %99
store float %96, float* %100
br label %101
101: ; preds = %91
%102 = load i32, i32* %13
%103 = add nsw i32 %102, 1
store i32 %103, i32* %13
br label %88
104: ; preds = %88
ret void
}

LLVM IR (-O2):
define void @iresp_vcalc(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture writeonly %3) {
%5 = getelementptr inbounds float, float* %0, i64 1
%6 = load float, float* %5
%7 = fneg float %6
%8 = fsub float 0.000000e+00, %6
%9 = getelementptr inbounds float, float* %1, i64 1
%10 = load float, float* %9
%11 = fadd float %10, 0.000000e+00
%12 = getelementptr inbounds float, float* %2, i64 1
%13 = load float, float* %12
%14 = fneg float %13
%15 = fsub float 0.000000e+00, %13
%16 = fadd float %8, %11
%17 = fadd float %16, %15
%18 = getelementptr inbounds float, float* %0, i64 2
%19 = load float, float* %18
%20 = fneg float %19
%21 = fsub float 0.000000e+00, %19
%22 = getelementptr inbounds float, float* %1, i64 2
%23 = load float, float* %22
%24 = fadd float %23, 0.000000e+00
%25 = getelementptr inbounds float, float* %2, i64 2
%26 = load float, float* %25
%27 = fneg float %26
%28 = fsub float 0.000000e+00, %26
%29 = tail call float @llvm.fmuladd.f32(float %7, float %8, float %21)
%30 = tail call float @llvm.fmuladd.f32(float %10, float %8, float %24)
%31 = tail call float @llvm.fmuladd.f32(float %14, float %17, float %28)
%32 = fadd float %29, %30
%33 = fadd float %32, %31
%34 = getelementptr inbounds float, float* %0, i64 3
%35 = load float, float* %34
%36 = fneg float %35
%37 = fsub float 0.000000e+00, %35
%38 = getelementptr inbounds float, float* %1, i64 3
%39 = load float, float* %38
%40 = fadd float %39, 0.000000e+00
%41 = getelementptr inbounds float, float* %2, i64 3
%42 = load float, float* %41
%43 = fneg float %42
%44 = fsub float 0.000000e+00, %42
%45 = tail call float @llvm.fmuladd.f32(float %20, float %8, float %37)
%46 = tail call float @llvm.fmuladd.f32(float %23, float %8, float %40)
%47 = tail call float @llvm.fmuladd.f32(float %27, float %17, float %44)
%48 = tail call float @llvm.fmuladd.f32(float %7, float %29, float %45)
%49 = tail call float @llvm.fmuladd.f32(float %10, float %29, float %46)
%50 = tail call float @llvm.fmuladd.f32(float %14, float %33, float %47)
%51 = fadd float %48, %49
%52 = fadd float %51, %50
%53 = getelementptr inbounds float, float* %0, i64 4
%54 = load float, float* %53
%55 = fsub float 0.000000e+00, %54
%56 = getelementptr inbounds float, float* %1, i64 4
%57 = load float, float* %56
%58 = fadd float %57, 0.000000e+00
%59 = getelementptr inbounds float, float* %2, i64 4
%60 = load float, float* %59
%61 = fsub float 0.000000e+00, %60
%62 = tail call float @llvm.fmuladd.f32(float %36, float %8, float %55)
%63 = tail call float @llvm.fmuladd.f32(float %39, float %8, float %58)
%64 = tail call float @llvm.fmuladd.f32(float %43, float %17, float %61)
%65 = tail call float @llvm.fmuladd.f32(float %20, float %29, float %62)
%66 = tail call float @llvm.fmuladd.f32(float %23, float %29, float %63)
%67 = tail call float @llvm.fmuladd.f32(float %27, float %33, float %64)
%68 = tail call float @llvm.fmuladd.f32(float %7, float %48, float %65)
%69 = tail call float @llvm.fmuladd.f32(float %10, float %48, float %66)
%70 = tail call float @llvm.fmuladd.f32(float %14, float %52, float %67)
%71 = fadd float %68, %69
%72 = fadd float %71, %70
store float 1.000000e+00, float* %3
%73 = getelementptr inbounds float, float* %3, i64 1
store float %17, float* %73
%74 = getelementptr inbounds float, float* %3, i64 2
store float %33, float* %74
%75 = getelementptr inbounds float, float* %3, i64 3
store float %52, float* %75
%76 = getelementptr inbounds float, float* %3, i64 4
store float %72, float* %76
ret void
}