void imdct_step3_inner_s_loop(const unsigned int lim, const float *A, float *e,
                              int i_off, int k0, int k1) {
  const float A0 = A[0];
  const float A1 = A[0 + 1];
  const float A2 = A[0 + k1];
  const float A3 = A[0 + k1 + 1];
  const float A4 = A[0 + k1 * 2 + 0];
  const float A5 = A[0 + k1 * 2 + 1];
  const float A6 = A[0 + k1 * 3 + 0];
  const float A7 = A[0 + k1 * 3 + 1];
  float *e0 = e + i_off;
  float *e2 = e0 - k0 / 2;
  for (int i = lim; i > 0; i--, e0 -= k0, e2 -= k0) {
    float k00, k11;
    k00 = e0[-1] - e2[-1];
    k11 = e0[-2] - e2[-2];
    e0[-1] = e0[-1] + e2[-1];
    e0[-2] = e0[-2] + e2[-2];
    e2[-1] = k00 * A0 - k11 * A1;
    e2[-2] = k11 * A0 + k00 * A1;
    k00 = e0[-3] - e2[-3];
    k11 = e0[-4] - e2[-4];
    e0[-3] = e0[-3] + e2[-3];
    e0[-4] = e0[-4] + e2[-4];
    e2[-3] = k00 * A2 - k11 * A3;
    e2[-4] = k11 * A2 + k00 * A3;
    k00 = e0[-5] - e2[-5];
    k11 = e0[-6] - e2[-6];
    e0[-5] = e0[-5] + e2[-5];
    e0[-6] = e0[-6] + e2[-6];
    e2[-5] = k00 * A4 - k11 * A5;
    e2[-6] = k11 * A4 + k00 * A5;
    k00 = e0[-7] - e2[-7];
    k11 = e0[-8] - e2[-8];
    e0[-7] = e0[-7] + e2[-7];
    e0[-8] = e0[-8] + e2[-8];
    e2[-7] = k00 * A6 - k11 * A7;
    e2[-8] = k11 * A6 + k00 * A7;
  }
}


x86 assembly (clang, -O0):
<imdct_step3_inner_s_loop>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x0,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jle    1553 <imdct_step3_inner_s_loop+0x453>
mov    -0x50(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x4(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x8(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x4(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x4(%rax)
mov    -0x50(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x8(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x8(%rax)
movss  -0x60(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x4(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x8(%rax)
mov    -0x50(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0xc(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x10(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0xc(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0xc(%rax)
mov    -0x50(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x10(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x10(%rax)
movss  -0x60(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0xc(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x10(%rax)
mov    -0x50(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x14(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x18(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x14(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x14(%rax)
mov    -0x50(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x18(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x18(%rax)
movss  -0x60(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x14(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x18(%rax)
mov    -0x50(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x1c(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x20(%rax),%xmm0
mov    -0x58(%rbp),%rax
subss  -0x20(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x50(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x1c(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x1c(%rax)
mov    -0x50(%rbp),%rax
movss  -0x20(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  -0x20(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,-0x20(%rax)
movss  -0x60(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x1c(%rax)
movss  -0x64(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,-0x20(%rax)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    121b <imdct_step3_inner_s_loop+0x11b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step3_inner_s_loop>:
test   %edi,%edi
jle    130d <imdct_step3_inner_s_loop+0x20d>
movss  (%rsi),%xmm8
movss  0x4(%rsi),%xmm9
movslq %r9d,%r9
movss  (%rsi,%r9,4),%xmm10
movss  0x4(%rsi,%r9,4),%xmm11
lea    (%r9,%r9,1),%eax
cltq
movss  (%rsi,%rax,4),%xmm12
lea    0x1(%r9,%r9,1),%eax
cltq
movss  (%rsi,%rax,4),%xmm5
lea    (%r9,%r9,2),%eax
cltq
movss  (%rsi,%rax,4),%xmm6
movss  0x4(%rsi,%rax,4),%xmm7
movslq %ecx,%rsi
mov    %r8d,%eax
shr    $0x1f,%eax
add    %r8d,%eax
sar    %eax
neg    %eax
cltq
movslq %r8d,%rcx
lea    (%rdx,%rsi,4),%rdx
add    $0xfffffffffffffffc,%rdx
shl    $0x2,%rcx
neg    %rcx
add    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rdx),%xmm4
movss  (%rdx),%xmm3
movss  (%rdx,%rax,4),%xmm2
movaps %xmm3,%xmm1
subss  %xmm2,%xmm1
movaps %xmm4,%xmm0
subss  -0x4(%rdx,%rax,4),%xmm0
addss  %xmm2,%xmm3
movss  %xmm3,(%rdx)
addss  -0x4(%rdx,%rax,4),%xmm4
movss  %xmm4,-0x4(%rdx)
movaps %xmm9,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm9,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm8,%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,(%rdx,%rax,4)
mulss  %xmm8,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x4(%rdx,%rax,4)
movss  -0xc(%rdx),%xmm0
movss  -0x8(%rdx),%xmm1
movss  -0x8(%rdx,%rax,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0xc(%rdx,%rax,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x8(%rdx)
addss  -0xc(%rdx,%rax,4),%xmm0
movss  %xmm0,-0xc(%rdx)
movaps %xmm11,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm10,%xmm3
subss  %xmm0,%xmm3
movss  %xmm3,-0x8(%rdx,%rax,4)
mulss  %xmm10,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,-0xc(%rdx,%rax,4)
movss  -0x14(%rdx),%xmm0
movss  -0x10(%rdx),%xmm1
movss  -0x10(%rdx,%rax,4),%xmm2
movaps %xmm1,%xmm3
movaps %xmm0,%xmm4
subss  -0x14(%rdx,%rax,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x10(%rdx)
addss  -0x14(%rdx,%rax,4),%xmm0
subss  %xmm2,%xmm3
movss  %xmm0,-0x14(%rdx)
movaps %xmm5,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm5,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm12,%xmm3
subss  %xmm0,%xmm3
movss  %xmm3,-0x10(%rdx,%rax,4)
mulss  %xmm12,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,-0x14(%rdx,%rax,4)
movss  -0x1c(%rdx),%xmm0
movss  -0x18(%rdx),%xmm1
movss  -0x18(%rdx,%rax,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0x1c(%rdx,%rax,4),%xmm4
addss  %xmm2,%xmm1
movss  %xmm1,-0x18(%rdx)
addss  -0x1c(%rdx,%rax,4),%xmm0
movss  %xmm0,-0x1c(%rdx)
movaps %xmm7,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm6,%xmm3
subss  %xmm0,%xmm3
movss  %xmm3,-0x18(%rdx,%rax,4)
mulss  %xmm6,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,-0x1c(%rdx,%rax,4)
add    %rcx,%rdx
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     1180 <imdct_step3_inner_s_loop+0x80>
ret

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

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