void rep(float v1, float v2, float c, float *i1, float *i2, int n, float a1,
         float a2) {
  int i;
  float lb[8192];
  lb[0] = v1;
  lb[1] = v2;
  for (i = 2; i < n - 2; i++) {
    lb[i] = c - a1 * lb[i - 1] - a2 * lb[i - 2];
  }
  lb[n - 2] = 0.0;
  lb[n - 1] = 0.0;
  for (i = n - 3; i >= 0; i--) {
    lb[i] = lb[i] - a1 * lb[i + 1] - a2 * lb[i + 2];
  }
  *i1 = lb[0];
  *i2 = lb[1];
}


x86 assembly (clang, -O0):
<rep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7fb0,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
movss  %xmm4,-0x2c(%rbp)
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x8030(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x802c(%rbp)
ff
movl   $0x2,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    11d7 <rep+0xd7>
movss  -0xc(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x8030(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%eax
sub    $0x2,%eax
cltq
movss  -0x8030(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x8030(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1150 <rep+0x50>
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
cltq
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8030(%rbp,%rax,4)
ff ff
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8030(%rbp,%rax,4)
ff ff
mov    -0x24(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1290 <rep+0x190>
movslq -0x30(%rbp),%rax
movss  -0x8030(%rbp,%rax,4),%xmm0
ff ff
movss  -0x28(%rbp),%xmm1
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x8030(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x30(%rbp),%eax
add    $0x2,%eax
cltq
movss  -0x8030(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x30(%rbp),%rax
movss  %xmm0,-0x8030(%rbp,%rax,4)
ff ff
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1208 <rep+0x108>
movss  -0x8030(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x802c(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x7fb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rep>:
sub    $0x7f88,%rsp
movss  %xmm0,-0x80(%rsp)
movss  %xmm1,-0x7c(%rsp)
lea    -0x2(%rdx),%r9d
cmp    $0x5,%edx
jl     1202 <rep+0x102>
mulss  %xmm3,%xmm1
movaps %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm0
subss  %xmm0,%xmm5
movss  %xmm5,-0x78(%rsp)
cmp    $0x3,%r9d
je     1202 <rep+0x102>
movaps 0xeb6(%rip),%xmm0
movaps %xmm3,%xmm1
xorps  %xmm0,%xmm1
xorps  %xmm4,%xmm0
mov    %r9d,%r8d
add    $0xfffffffffffffffd,%r8
cmp    $0x4,%r9d
jne    1175 <rep+0x75>
mov    $0x1,%eax
mov    $0x3,%ecx
test   $0x1,%r8b
jne    11ea <rep+0xea>
jmp    1202 <rep+0x102>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
neg    %r10
mov    $0x3,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mulss  %xmm1,%xmm5
addss  %xmm2,%xmm5
movss  -0x88(%rsp,%rcx,4),%xmm6
ff ff
mulss  %xmm0,%xmm6
addss  %xmm5,%xmm6
movss  %xmm6,-0x80(%rsp,%rcx,4)
mulss  %xmm1,%xmm6
addss  %xmm2,%xmm6
movss  -0x84(%rsp,%rcx,4),%xmm5
ff ff
mulss  %xmm0,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,-0x7c(%rsp,%rcx,4)
lea    (%r10,%rcx,1),%rax
add    $0x2,%rax
add    $0x2,%rcx
cmp    $0x3,%rax
jne    1190 <rep+0x90>
lea    -0x2(%rcx),%rax
test   $0x1,%r8b
je     1202 <rep+0x102>
mulss  %xmm5,%xmm1
addss  %xmm2,%xmm1
mulss  -0x80(%rsp,%rax,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rsp,%rcx,4)
movslq %r9d,%rax
movl   $0x0,-0x80(%rsp,%rax,4)
movslq %edx,%rax
movl   $0x0,-0x84(%rsp,%rax,4)
cmp    $0x3,%edx
jl     12bf <rep+0x1bf>
add    $0xfffffffd,%edx
movaps 0xdd2(%rip),%xmm0
xorps  %xmm0,%xmm3
xorps  %xmm0,%xmm4
mov    %rdx,%rax
test   $0x1,%dl
jne    1264 <rep+0x164>
movss  -0x7c(%rsp,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
addss  -0x80(%rsp,%rdx,4),%xmm0
movss  -0x78(%rsp,%rdx,4),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,-0x80(%rsp,%rdx,4)
lea    -0x1(%rdx),%rax
test   %rdx,%rdx
je     12bf <rep+0x1bf>
nopl   0x0(%rax)
movss  -0x7c(%rsp,%rax,4),%xmm0
movaps %xmm3,%xmm1
mulss  %xmm0,%xmm1
addss  -0x80(%rsp,%rax,4),%xmm1
movss  -0x78(%rsp,%rax,4),%xmm2
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,-0x80(%rsp,%rax,4)
mulss  %xmm3,%xmm2
addss  -0x84(%rsp,%rax,4),%xmm2
ff ff
mulss  %xmm4,%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,-0x84(%rsp,%rax,4)
ff ff
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rax
jne    1270 <rep+0x170>
movss  -0x80(%rsp),%xmm0
movss  %xmm0,(%rdi)
movss  -0x7c(%rsp),%xmm0
movss  %xmm0,(%rsi)
add    $0x7f88,%rsp
ret

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

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