void imdct_step7(const unsigned int n, const float *C, float *buffer) {
  for (float *d = buffer, *e = buffer + (n / 2) - 4; d < e;
       C += 4, d += 4, e -= 4) {
    float sub0 = d[0] - e[2];
    float sub1 = d[1] + e[3];
    float sub2 = d[2] - e[0];
    float sub3 = d[3] + e[1];
    float mix0 = C[1] * sub0 + C[0] * sub1;
    float mix1 = C[1] * sub1 - C[0] * sub0;
    float mix2 = C[3] * sub2 + C[2] * sub3;
    float mix3 = C[3] * sub3 - C[2] * sub2;
    float add0 = d[0] + e[2];
    float add1 = d[1] - e[3];
    float add2 = d[2] + e[0];
    float add3 = d[3] - e[1];
    d[0] = add0 + mix0;
    d[1] = add1 + mix1;
    d[2] = add2 + mix2;
    d[3] = add3 + mix3;
    e[0] = add2 - mix2;
    e[1] = -(add3 - mix3);
    e[2] = add0 - mix0;
    e[3] = -(add1 - mix1);
  }
}


x86 assembly (clang, -O0):
<imdct_step7>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1389 <imdct_step7+0x289>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x2c(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x54(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x4c(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x50(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x28(%rbp)
jmp    1132 <imdct_step7+0x32>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step7>:
shr    %edi
lea    (%rdx,%rdi,4),%rax
add    $0xfffffffffffffff0,%rax
cmp    %rdx,%rax
jbe    11e7 <imdct_step7+0xe7>
add    $0xc,%rsi
add    $0x10,%rdx
movaps 0xedd(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx),%xmm3
movups (%rax),%xmm1
shufps $0x4e,%xmm1,%xmm1
movaps %xmm3,%xmm2
subps  %xmm1,%xmm2
addps  %xmm3,%xmm1
movaps %xmm2,%xmm4
shufps $0xd8,%xmm1,%xmm4
shufps $0xd8,%xmm4,%xmm4
movss  -0xc(%rsi),%xmm3
movss  -0x8(%rsi),%xmm5
movss  -0x4(%rsi),%xmm6
movss  (%rsi),%xmm7
shufps $0x0,%xmm7,%xmm5
mulps  %xmm4,%xmm5
movaps %xmm3,%xmm4
xorps  %xmm8,%xmm4
movaps %xmm6,%xmm7
xorps  %xmm8,%xmm7
movaps %xmm1,%xmm0
shufps $0x8d,%xmm2,%xmm0
shufps $0xd8,%xmm0,%xmm0
unpcklps %xmm7,%xmm6
unpcklps %xmm4,%xmm3
movlhps %xmm6,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm5,%xmm3
shufps $0xd8,%xmm2,%xmm1
shufps $0xd8,%xmm1,%xmm1
movaps %xmm1,%xmm0
addps  %xmm3,%xmm0
movups %xmm0,-0x10(%rdx)
subps  %xmm3,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
xorps  %xmm8,%xmm2
movaps %xmm1,%xmm3
unpcklps %xmm2,%xmm3
shufps $0xff,%xmm1,%xmm1
xorps  %xmm8,%xmm1
unpcklps %xmm1,%xmm0
movlhps %xmm3,%xmm0
movups %xmm0,(%rax)
add    $0x10,%rsi
lea    0x10(%rdx),%rcx
add    $0xfffffffffffffff0,%rax
cmp    %rax,%rdx
mov    %rcx,%rdx
jb     1130 <imdct_step7+0x30>
ret

LLVM IR (-O0):
define void @imdct_step7(i32 %0, float* %1, float* %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
store i32 %0, i32* %4
store float* %1, float** %5
store float* %2, float** %6
%21 = load float*, float** %6
store float* %21, float** %7
%22 = load float*, float** %6
%23 = load i32, i32* %4
%24 = udiv i32 %23, 2
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds float, float* %22, i64 %25
%27 = getelementptr inbounds float, float* %26, i64 -4
store float* %27, float** %8
br label %28
28: ; preds = %173, %3
%29 = load float*, float** %7
%30 = load float*, float** %8
%31 = icmp ult float* %29, %30
br i1 %31, label %32, label %180
32: ; preds = %28
%33 = load float*, float** %7
%34 = getelementptr inbounds float, float* %33, i64 0
%35 = load float, float* %34
%36 = load float*, float** %8
%37 = getelementptr inbounds float, float* %36, i64 2
%38 = load float, float* %37
%39 = fsub float %35, %38
store float %39, float* %9
%40 = load float*, float** %7
%41 = getelementptr inbounds float, float* %40, i64 1
%42 = load float, float* %41
%43 = load float*, float** %8
%44 = getelementptr inbounds float, float* %43, i64 3
%45 = load float, float* %44
%46 = fadd float %42, %45
store float %46, float* %10
%47 = load float*, float** %7
%48 = getelementptr inbounds float, float* %47, i64 2
%49 = load float, float* %48
%50 = load float*, float** %8
%51 = getelementptr inbounds float, float* %50, i64 0
%52 = load float, float* %51
%53 = fsub float %49, %52
store float %53, float* %11
%54 = load float*, float** %7
%55 = getelementptr inbounds float, float* %54, i64 3
%56 = load float, float* %55
%57 = load float*, float** %8
%58 = getelementptr inbounds float, float* %57, i64 1
%59 = load float, float* %58
%60 = fadd float %56, %59
store float %60, float* %12
%61 = load float*, float** %5
%62 = getelementptr inbounds float, float* %61, i64 1
%63 = load float, float* %62
%64 = load float, float* %9
%65 = load float*, float** %5
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
%68 = load float, float* %10
%69 = fmul float %67, %68
%70 = call float @llvm.fmuladd.f32(float %63, float %64, float %69)
store float %70, float* %13
%71 = load float*, float** %5
%72 = getelementptr inbounds float, float* %71, i64 1
%73 = load float, float* %72
%74 = load float, float* %10
%75 = load float*, float** %5
%76 = getelementptr inbounds float, float* %75, i64 0
%77 = load float, float* %76
%78 = load float, float* %9
%79 = fmul float %77, %78
%80 = fneg float %79
%81 = call float @llvm.fmuladd.f32(float %73, float %74, float %80)
store float %81, float* %14
%82 = load float*, float** %5
%83 = getelementptr inbounds float, float* %82, i64 3
%84 = load float, float* %83
%85 = load float, float* %11
%86 = load float*, float** %5
%87 = getelementptr inbounds float, float* %86, i64 2
%88 = load float, float* %87
%89 = load float, float* %12
%90 = fmul float %88, %89
%91 = call float @llvm.fmuladd.f32(float %84, float %85, float %90)
store float %91, float* %15
%92 = load float*, float** %5
%93 = getelementptr inbounds float, float* %92, i64 3
%94 = load float, float* %93
%95 = load float, float* %12
%96 = load float*, float** %5
%97 = getelementptr inbounds float, float* %96, i64 2
%98 = load float, float* %97
%99 = load float, float* %11
%100 = fmul float %98, %99
%101 = fneg float %100
%102 = call float @llvm.fmuladd.f32(float %94, float %95, float %101)
store float %102, float* %16
%103 = load float*, float** %7
%104 = getelementptr inbounds float, float* %103, i64 0
%105 = load float, float* %104
%106 = load float*, float** %8
%107 = getelementptr inbounds float, float* %106, i64 2
%108 = load float, float* %107
%109 = fadd float %105, %108
store float %109, float* %17
%110 = load float*, float** %7
%111 = getelementptr inbounds float, float* %110, i64 1
%112 = load float, float* %111
%113 = load float*, float** %8
%114 = getelementptr inbounds float, float* %113, i64 3
%115 = load float, float* %114
%116 = fsub float %112, %115
store float %116, float* %18
%117 = load float*, float** %7
%118 = getelementptr inbounds float, float* %117, i64 2
%119 = load float, float* %118
%120 = load float*, float** %8
%121 = getelementptr inbounds float, float* %120, i64 0
%122 = load float, float* %121
%123 = fadd float %119, %122
store float %123, float* %19
%124 = load float*, float** %7
%125 = getelementptr inbounds float, float* %124, i64 3
%126 = load float, float* %125
%127 = load float*, float** %8
%128 = getelementptr inbounds float, float* %127, i64 1
%129 = load float, float* %128
%130 = fsub float %126, %129
store float %130, float* %20
%131 = load float, float* %17
%132 = load float, float* %13
%133 = fadd float %131, %132
%134 = load float*, float** %7
%135 = getelementptr inbounds float, float* %134, i64 0
store float %133, float* %135
%136 = load float, float* %18
%137 = load float, float* %14
%138 = fadd float %136, %137
%139 = load float*, float** %7
%140 = getelementptr inbounds float, float* %139, i64 1
store float %138, float* %140
%141 = load float, float* %19
%142 = load float, float* %15
%143 = fadd float %141, %142
%144 = load float*, float** %7
%145 = getelementptr inbounds float, float* %144, i64 2
store float %143, float* %145
%146 = load float, float* %20
%147 = load float, float* %16
%148 = fadd float %146, %147
%149 = load float*, float** %7
%150 = getelementptr inbounds float, float* %149, i64 3
store float %148, float* %150
%151 = load float, float* %19
%152 = load float, float* %15
%153 = fsub float %151, %152
%154 = load float*, float** %8
%155 = getelementptr inbounds float, float* %154, i64 0
store float %153, float* %155
%156 = load float, float* %20
%157 = load float, float* %16
%158 = fsub float %156, %157
%159 = fneg float %158
%160 = load float*, float** %8
%161 = getelementptr inbounds float, float* %160, i64 1
store float %159, float* %161
%162 = load float, float* %17
%163 = load float, float* %13
%164 = fsub float %162, %163
%165 = load float*, float** %8
%166 = getelementptr inbounds float, float* %165, i64 2
store float %164, float* %166
%167 = load float, float* %18
%168 = load float, float* %14
%169 = fsub float %167, %168
%170 = fneg float %169
%171 = load float*, float** %8
%172 = getelementptr inbounds float, float* %171, i64 3
store float %170, float* %172
br label %173
173: ; preds = %32
%174 = load float*, float** %5
%175 = getelementptr inbounds float, float* %174, i64 4
store float* %175, float** %5
%176 = load float*, float** %7
%177 = getelementptr inbounds float, float* %176, i64 4
store float* %177, float** %7
%178 = load float*, float** %8
%179 = getelementptr inbounds float, float* %178, i64 -4
store float* %179, float** %8
br label %28
180: ; preds = %28
ret void
}

LLVM IR (-O2):
define void @imdct_step7(i32 %0, float* nocapture %1, float* %2) {
%4 = lshr i32 %0, 1
%5 = zext i32 %4 to i64
%6 = getelementptr inbounds float, float* %2, i64 %5
%7 = getelementptr inbounds float, float* %6, i64 -4
%8 = icmp ugt float* %7, %2
br i1 %8, label %10, label %9
9: ; preds = %10, %3
ret void
10: ; preds = %3, %10
%11 = phi float* [ %60, %10 ], [ %7, %3 ]
%12 = phi float* [ %58, %10 ], [ %1, %3 ]
%13 = phi float* [ %59, %10 ], [ %2, %3 ]
%14 = phi float* [ %11, %10 ], [ %6, %3 ]
%15 = getelementptr inbounds float, float* %14, i64 -2
%16 = getelementptr inbounds float, float* %14, i64 -1
%17 = bitcast float* %13 to <4 x float>*
%18 = load <4 x float>, <4 x float>* %17
%19 = getelementptr inbounds float, float* %14, i64 -3
%20 = bitcast float* %11 to <4 x float>*
%21 = load <4 x float>, <4 x float>* %20
%22 = shufflevector <4 x float> %21, <4 x float> poison, <4 x i32> <i32 2, i32 3, i32 0, i32 1>
%23 = fsub <4 x float> %18, %22
%24 = fadd <4 x float> %18, %22
%25 = shufflevector <4 x float> %23, <4 x float> %24, <4 x i32> <i32 0, i32 5, i32 2, i32 7>
%26 = getelementptr inbounds float, float* %12, i64 1
%27 = load float, float* %26
%28 = load float, float* %12
%29 = fneg float %28
%30 = getelementptr inbounds float, float* %12, i64 3
%31 = load float, float* %30
%32 = getelementptr inbounds float, float* %12, i64 2
%33 = load float, float* %32
%34 = fneg float %33
%35 = shufflevector <4 x float> %24, <4 x float> %23, <4 x i32> <i32 1, i32 4, i32 3, i32 6>
%36 = insertelement <4 x float> poison, float %28, i64 0
%37 = insertelement <4 x float> %36, float %29, i64 1
%38 = insertelement <4 x float> %37, float %33, i64 2
%39 = insertelement <4 x float> %38, float %34, i64 3
%40 = fmul <4 x float> %35, %39
%41 = insertelement <4 x float> poison, float %27, i64 0
%42 = insertelement <4 x float> %41, float %31, i64 1
%43 = shufflevector <4 x float> %42, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%44 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %43, <4 x float> %25, <4 x float> %40)
%45 = shufflevector <4 x float> %24, <4 x float> %23, <4 x i32> <i32 0, i32 5, i32 2, i32 7>
%46 = fadd <4 x float> %45, %44
%47 = bitcast float* %13 to <4 x float>*
store <4 x float> %46, <4 x float>* %47
%48 = fsub <4 x float> %45, %44
%49 = extractelement <4 x float> %48, i64 2
store float %49, float* %11
%50 = fsub <4 x float> %45, %44
%51 = extractelement <4 x float> %50, i64 3
%52 = fneg float %51
store float %52, float* %19
%53 = fsub <4 x float> %45, %44
%54 = extractelement <4 x float> %53, i64 0
store float %54, float* %15
%55 = fsub <4 x float> %45, %44
%56 = extractelement <4 x float> %55, i64 1
%57 = fneg float %56
store float %57, float* %16
%58 = getelementptr inbounds float, float* %12, i64 4
%59 = getelementptr inbounds float, float* %13, i64 4
%60 = getelementptr inbounds float, float* %11, i64 -4
%61 = icmp ult float* %59, %60
br i1 %61, label %10, label %9
}