void fnFilterAlphaC(int *n, double *u, double *beta, double *vstar,
                    double *lstar) {
  int i;
  vstar[0] = (u[0] * u[0]);
  lstar[0] = 1;
  for (i = 1; i < *n; i++) {
    vstar[i] = (u[i] * u[i]) + *beta * vstar[i - 1];
    lstar[i] = 1 + *beta * lstar[i - 1];
  }
}


x86 assembly (clang, -O0):
<fnFilterAlphaC>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movsd  0xec4(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%eax
jge    11e4 <fnFilterAlphaC+0xe4>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe3b(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1147 <fnFilterAlphaC+0x47>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fnFilterAlphaC>:
movsd  (%rsi),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rcx)
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r8)
mov    (%rdi),%r10d
cmp    $0x2,%r10d
jl     118a <fnFilterAlphaC+0x8a>
lea    (%r8,%r10,8),%rdi
cmp    %rcx,%rdi
jbe    118b <fnFilterAlphaC+0x8b>
lea    (%rcx,%r10,8),%rdi
cmp    %r8,%rdi
jbe    118b <fnFilterAlphaC+0x8b>
mov    $0x1,%edi
movsd  0xebf(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
movsd  (%rdx),%xmm2
mulsd  -0x8(%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
movsd  (%rdx),%xmm1
mulsd  -0x8(%r8,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r10
jne    1150 <fnFilterAlphaC+0x50>
ret
mov    %r10d,%r9d
movsd  (%rcx),%xmm1
movsd  (%r8),%xmm0
add    $0xffffffffffffffff,%r10
mov    $0x1,%edi
cmp    $0x2,%r9d
je     121d <fnFilterAlphaC+0x11d>
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
neg    %r9
mov    $0x1,%edi
movsd  0xe43(%rip),%xmm2
nopl   (%rax)
movsd  (%rsi,%rdi,8),%xmm3
mulsd  (%rdx),%xmm1
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,(%rcx,%rdi,8)
mulsd  (%rdx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r8,%rdi,8)
movsd  0x8(%rsi,%rdi,8),%xmm1
mulsd  (%rdx),%xmm3
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,0x8(%rcx,%rdi,8)
mulsd  (%rdx),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%r8,%rdi,8)
lea    (%r9,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
jne    11c0 <fnFilterAlphaC+0xc0>
test   $0x1,%r10b
je     118a <fnFilterAlphaC+0x8a>
movsd  (%rsi,%rdi,8),%xmm2
mulsd  (%rdx),%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rdi,8)
mulsd  (%rdx),%xmm0
addsd  0xdb7(%rip),%xmm0
movsd  %xmm0,(%r8,%rdi,8)
ret

LLVM IR (-O0):
define void @fnFilterAlphaC(i32* %0, double* %1, double* %2, double* %3, double* %4) {
%6 = alloca i32*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
store i32* %0, i32** %6
store double* %1, double** %7
store double* %2, double** %8
store double* %3, double** %9
store double* %4, double** %10
%12 = load double*, double** %7
%13 = getelementptr inbounds double, double* %12, i64 0
%14 = load double, double* %13
%15 = load double*, double** %7
%16 = getelementptr inbounds double, double* %15, i64 0
%17 = load double, double* %16
%18 = fmul double %14, %17
%19 = load double*, double** %9
%20 = getelementptr inbounds double, double* %19, i64 0
store double %18, double* %20
%21 = load double*, double** %10
%22 = getelementptr inbounds double, double* %21, i64 0
store double 1.000000e+00, double* %22
store i32 1, i32* %11
br label %23
23: ; preds = %66, %5
%24 = load i32, i32* %11
%25 = load i32*, i32** %6
%26 = load i32, i32* %25
%27 = icmp slt i32 %24, %26
br i1 %27, label %28, label %69
28: ; preds = %23
%29 = load double*, double** %7
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = load double*, double** %7
%35 = load i32, i32* %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds double, double* %34, i64 %36
%38 = load double, double* %37
%39 = load double*, double** %8
%40 = load double, double* %39
%41 = load double*, double** %9
%42 = load i32, i32* %11
%43 = sub nsw i32 %42, 1
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %41, i64 %44
%46 = load double, double* %45
%47 = fmul double %40, %46
%48 = call double @llvm.fmuladd.f64(double %33, double %38, double %47)
%49 = load double*, double** %9
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double %48, double* %52
%53 = load double*, double** %8
%54 = load double, double* %53
%55 = load double*, double** %10
%56 = load i32, i32* %11
%57 = sub nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %55, i64 %58
%60 = load double, double* %59
%61 = call double @llvm.fmuladd.f64(double %54, double %60, double 1.000000e+00)
%62 = load double*, double** %10
%63 = load i32, i32* %11
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
store double %61, double* %65
br label %66
66: ; preds = %28
%67 = load i32, i32* %11
%68 = add nsw i32 %67, 1
store i32 %68, i32* %11
br label %23
69: ; preds = %23
ret void
}

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