void imdct_step3_inner_r_loop(int lim, float *e, int d0, int k_off, float *A,
                              int k1) {
  int i;
  float k00_20, k01_21;
  float *e0 = e + d0;
  float *e2 = e0 + k_off;
  for (i = lim >> 2; i > 0; --i) {
    k00_20 = e0[-0] - e2[-0];
    k01_21 = e0[-1] - e2[-1];
    e0[-0] += e2[-0];
    e0[-1] += e2[-1];
    e2[-0] = (k00_20)*A[0] - (k01_21)*A[1];
    e2[-1] = (k01_21)*A[0] + (k00_20)*A[1];
    A += k1;
    k00_20 = e0[-2] - e2[-2];
    k01_21 = e0[-3] - e2[-3];
    e0[-2] += e2[-2];
    e0[-3] += e2[-3];
    e2[-2] = (k00_20)*A[0] - (k01_21)*A[1];
    e2[-3] = (k01_21)*A[0] + (k00_20)*A[1];
    A += k1;
    k00_20 = e0[-4] - e2[-4];
    k01_21 = e0[-5] - e2[-5];
    e0[-4] += e2[-4];
    e0[-5] += e2[-5];
    e2[-4] = (k00_20)*A[0] - (k01_21)*A[1];
    e2[-5] = (k01_21)*A[0] + (k00_20)*A[1];
    A += k1;
    k00_20 = e0[-6] - e2[-6];
    k01_21 = e0[-7] - e2[-7];
    e0[-6] += e2[-6];
    e0[-7] += e2[-7];
    e2[-6] = (k00_20)*A[0] - (k01_21)*A[1];
    e2[-7] = (k01_21)*A[0] + (k00_20)*A[1];
    e0 -= 8;
    e2 -= 8;
    A += k1;
  }
}


x86 assembly (clang, -O0):
<imdct_step3_inner_r_loop>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    14ca <imdct_step3_inner_r_loop+0x3ca>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x4(%rax),%xmm0
movss  %xmm0,-0x4(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x4(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x8(%rax),%xmm0
movss  %xmm0,-0x8(%rax)
mov    -0x40(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0xc(%rax),%xmm0
movss  %xmm0,-0xc(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x8(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0xc(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x10(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x14(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x10(%rax),%xmm0
movss  %xmm0,-0x10(%rax)
mov    -0x40(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x14(%rax),%xmm0
movss  %xmm0,-0x14(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x10(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x14(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x18(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x38(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x40(%rbp),%rax
subss  -0x1c(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x18(%rax),%xmm0
movss  %xmm0,-0x18(%rax)
mov    -0x40(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x38(%rbp),%rax
addss  -0x1c(%rax),%xmm0
movss  %xmm0,-0x1c(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x18(%rax)
movss  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,-0x1c(%rax)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1148 <imdct_step3_inner_r_loop+0x48>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step3_inner_r_loop>:
cmp    $0x4,%edi
jl     12db <imdct_step3_inner_r_loop+0x1db>
movslq %edx,%rax
lea    (%rsi,%rax,4),%rax
shr    $0x2,%edi
movslq %ecx,%rcx
movslq %r9d,%rdx
add    $0x1,%edi
shl    $0x2,%rdx
movss  -0x4(%rax),%xmm0
movss  (%rax),%xmm1
movss  (%rax,%rcx,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0x4(%rax,%rcx,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,(%rax)
addss  -0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rax)
movss  0x4(%r8),%xmm0
mulss  %xmm4,%xmm0
movss  (%r8),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
mulss  0x4(%r8),%xmm3
mulss  (%r8),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0x4(%rax,%rcx,4)
movss  -0xc(%rax),%xmm0
movss  -0x8(%rax),%xmm1
movss  -0x8(%rax,%rcx,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0xc(%rax,%rcx,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x8(%rax)
addss  -0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rax)
lea    (%r8,%rdx,1),%rsi
movss  0x4(%r8,%rdx,1),%xmm0
mulss  %xmm4,%xmm0
movss  (%r8,%rdx,1),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rax,%rcx,4)
mulss  0x4(%r8,%rdx,1),%xmm3
mulss  (%r8,%rdx,1),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0xc(%rax,%rcx,4)
movss  -0x14(%rax),%xmm0
movss  -0x10(%rax),%xmm1
movss  -0x10(%rax,%rcx,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0x14(%rax,%rcx,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x10(%rax)
addss  -0x14(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x14(%rax)
lea    (%rsi,%rdx,1),%r9
movss  0x4(%rdx,%rsi,1),%xmm0
mulss  %xmm4,%xmm0
movss  (%rdx,%rsi,1),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x10(%rax,%rcx,4)
mulss  0x4(%rdx,%rsi,1),%xmm3
mulss  (%rdx,%rsi,1),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0x14(%rax,%rcx,4)
movss  -0x1c(%rax),%xmm0
movss  -0x18(%rax),%xmm1
movss  -0x18(%rax,%rcx,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0x1c(%rax,%rcx,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x18(%rax)
addss  -0x1c(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rax)
lea    (%r9,%rdx,1),%r8
movss  0x4(%rdx,%r9,1),%xmm0
mulss  %xmm4,%xmm0
movss  (%rdx,%r9,1),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x18(%rax,%rcx,4)
mulss  0x4(%rdx,%r9,1),%xmm3
mulss  (%rdx,%r9,1),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0x1c(%rax,%rcx,4)
add    $0xffffffffffffffe0,%rax
add    $0xffffffff,%edi
add    %rdx,%r8
cmp    $0x1,%edi
ja     1120 <imdct_step3_inner_r_loop+0x20>
ret

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

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