#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float *A) {
  float *ee0 = e + i_off;
  float *ee2 = ee0 + k_off;
  int i;
  assert((n & 3) == 0);
  for (i = (n >> 2); i > 0; --i) {
    float k00_20, k01_21;
    k00_20 = ee0[0] - ee2[0];
    k01_21 = ee0[-1] - ee2[-1];
    ee0[0] += ee2[0];
    ee0[-1] += ee2[-1];
    ee2[0] = k00_20 * A[0] - k01_21 * A[1];
    ee2[-1] = k01_21 * A[0] + k00_20 * A[1];
    A += 8;
    k00_20 = ee0[-2] - ee2[-2];
    k01_21 = ee0[-3] - ee2[-3];
    ee0[-2] += ee2[-2];
    ee0[-3] += ee2[-3];
    ee2[-2] = k00_20 * A[0] - k01_21 * A[1];
    ee2[-3] = k01_21 * A[0] + k00_20 * A[1];
    A += 8;
    k00_20 = ee0[-4] - ee2[-4];
    k01_21 = ee0[-5] - ee2[-5];
    ee0[-4] += ee2[-4];
    ee0[-5] += ee2[-5];
    ee2[-4] = k00_20 * A[0] - k01_21 * A[1];
    ee2[-5] = k01_21 * A[0] + k00_20 * A[1];
    A += 8;
    k00_20 = ee0[-6] - ee2[-6];
    k01_21 = ee0[-7] - ee2[-7];
    ee0[-6] += ee2[-6];
    ee0[-7] += ee2[-7];
    ee2[-6] = k00_20 * A[0] - k01_21 * A[1];
    ee2[-7] = k01_21 * A[0] + k00_20 * A[1];
    A += 8;
    ee0 -= 8;
    ee2 -= 8;
  }
}


x86 assembly (clang, -O0):
<imdct_step3_iter0_loop>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
and    $0x3,%eax
cmp    $0x0,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x4(%rbp),%eax
sar    $0x2,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    14cc <imdct_step3_iter0_loop+0x3bc>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movss  -0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x4(%rax),%xmm0
movss  %xmm0,-0x4(%rax)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%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    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,-0x4(%rax)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movss  -0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x8(%rax),%xmm0
movss  %xmm0,-0x8(%rax)
mov    -0x30(%rbp),%rax
movss  -0xc(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0xc(%rax),%xmm0
movss  %xmm0,-0xc(%rax)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%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    -0x30(%rbp),%rax
movss  %xmm0,-0x8(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,-0xc(%rax)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x10(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x14(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movss  -0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x10(%rax),%xmm0
movss  %xmm0,-0x10(%rax)
mov    -0x30(%rbp),%rax
movss  -0x14(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x14(%rax),%xmm0
movss  %xmm0,-0x14(%rax)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%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    -0x30(%rbp),%rax
movss  %xmm0,-0x10(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,-0x14(%rax)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x18(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x30(%rbp),%rax
subss  -0x1c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movss  -0x18(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x18(%rax),%xmm0
movss  %xmm0,-0x18(%rax)
mov    -0x30(%rbp),%rax
movss  -0x1c(%rax),%xmm0
mov    -0x28(%rbp),%rax
addss  -0x1c(%rax),%xmm0
movss  %xmm0,-0x1c(%rax)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%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    -0x30(%rbp),%rax
movss  %xmm0,-0x18(%rax)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,-0x1c(%rax)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    116e <imdct_step3_iter0_loop+0x5e>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step3_iter0_loop>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r8,%rbx
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %rsi,%r15
mov    %edi,%ebp
xor    %edi,%edi
test   $0x3,%bpl
sete   %dil
call   1030 <assert@plt>
cmp    $0x4,%ebp
jl     12ee <imdct_step3_iter0_loop+0x1de>
movslq %r12d,%rax
lea    (%r15,%rax,4),%rax
shr    $0x2,%ebp
movslq %r14d,%rcx
add    $0x1,%ebp
xchg   %ax,%ax
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(%rbx),%xmm0
mulss  %xmm4,%xmm0
movss  (%rbx),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
mulss  0x4(%rbx),%xmm3
mulss  (%rbx),%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)
movss  0x24(%rbx),%xmm0
mulss  %xmm4,%xmm0
movss  0x20(%rbx),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x8(%rax,%rcx,4)
mulss  0x24(%rbx),%xmm3
mulss  0x20(%rbx),%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)
movss  0x44(%rbx),%xmm0
mulss  %xmm4,%xmm0
movss  0x40(%rbx),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x10(%rax,%rcx,4)
mulss  0x44(%rbx),%xmm3
mulss  0x40(%rbx),%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)
movss  0x64(%rbx),%xmm0
mulss  %xmm4,%xmm0
movss  0x60(%rbx),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x18(%rax,%rcx,4)
mulss  0x64(%rbx),%xmm3
mulss  0x60(%rbx),%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,-0x1c(%rax,%rcx,4)
add    $0xffffffffffffffe0,%rax
add    $0xffffffff,%ebp
sub    $0xffffffffffffff80,%rbx
cmp    $0x1,%ebp
ja     1150 <imdct_step3_iter0_loop+0x40>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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