void imdct_step8_decode(const unsigned int n, const float *B, const float *in,
                        float *out) {
  B += (n / 2) - 16;
  float *d0 = &out[0];
  float *d1 = &out[(n / 2) - 8];
  float *d2 = &out[(n / 2)];
  float *d3 = &out[n - 8];
  for (const float *e = in + (n / 2) - 16; e >= in;
       e -= 16, B -= 16, d0 += 8, d1 -= 8, d2 += 8, d3 -= 8) {
    float p0, p1, p2, p3;
    p3 = e[14] * B[15] - e[15] * B[14];
    p2 = -e[14] * B[14] - e[15] * B[15];
    d0[0] = p3;
    d1[7] = -p3;
    d2[0] = p2;
    d3[7] = p2;
    p1 = e[12] * B[13] - e[13] * B[12];
    p0 = -e[12] * B[12] - e[13] * B[13];
    d0[1] = p1;
    d1[6] = -p1;
    d2[1] = p0;
    d3[6] = p0;
    p3 = e[10] * B[11] - e[11] * B[10];
    p2 = -e[10] * B[10] - e[11] * B[11];
    d0[2] = p3;
    d1[5] = -p3;
    d2[2] = p2;
    d3[5] = p2;
    p1 = e[8] * B[9] - e[9] * B[8];
    p0 = -e[8] * B[8] - e[9] * B[9];
    d0[3] = p1;
    d1[4] = -p1;
    d2[3] = p0;
    d3[4] = p0;
    p3 = e[6] * B[7] - e[7] * B[6];
    p2 = -e[6] * B[6] - e[7] * B[7];
    d0[4] = p3;
    d1[3] = -p3;
    d2[4] = p2;
    d3[3] = p2;
    p1 = e[4] * B[5] - e[5] * B[4];
    p0 = -e[4] * B[4] - e[5] * B[5];
    d0[5] = p1;
    d1[2] = -p1;
    d2[5] = p0;
    d3[2] = p0;
    p3 = e[2] * B[3] - e[3] * B[2];
    p2 = -e[2] * B[2] - e[3] * B[3];
    d0[6] = p3;
    d1[1] = -p3;
    d2[6] = p2;
    d3[1] = p2;
    p1 = e[0] * B[1] - e[1] * B[0];
    p0 = -e[0] * B[0] - e[1] * B[1];
    d0[7] = p1;
    d1[0] = -p1;
    d2[7] = p0;
    d3[0] = p0;
  }
}


x86 assembly (clang, -O0):
<imdct_step8_decode>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
sub    $0x10,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
sub    $0x8,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x8,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xffffffffffffffc0,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     185b <imdct_step8_decode+0x75b>
mov    -0x48(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
movss  0x38(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x3c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x3c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x48(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x30(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movss  0x30(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x48(%rbp),%rax
movss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
movss  0x28(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x48(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movss  0x20(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x48(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
movss  0x18(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffc0,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffc0,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffe0,%rax
mov    %rax,-0x40(%rbp)
jmp    1198 <imdct_step8_decode+0x98>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_step8_decode>:
mov    %edi,%r8d
shr    %r8d
lea    (%rdx,%r8,4),%r11
add    $0xffffffffffffffc0,%r11
cmp    %rdx,%r11
jb     13fb <imdct_step8_decode+0x2fb>
add    $0xfffffff8,%edi
lea    -0x8(%r8),%r9d
lea    -0x10(%r8),%eax
lea    (%rsi,%rax,4),%rsi
add    $0x3c,%rsi
lea    0x1c(,%r9,4),%r9
shl    $0x2,%r8
lea    0x1c(,%rdi,4),%r10
xor    %edi,%edi
movaps 0xeb9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rsi),%xmm1
movss  (%rsi),%xmm2
movss  0x38(%r11),%xmm3
movss  0x3c(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,(%rcx,%r9,1)
movss  %xmm3,(%rcx,%r8,1)
movss  %xmm3,(%rcx,%r10,1)
movss  -0xc(%rsi),%xmm1
movss  -0x8(%rsi),%xmm2
movss  0x30(%r11),%xmm3
movss  0x34(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x4(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x4(%rcx,%r9,1)
movss  %xmm3,0x4(%rcx,%r8,1)
movss  %xmm3,-0x4(%rcx,%r10,1)
movss  -0x14(%rsi),%xmm1
movss  -0x10(%rsi),%xmm2
movss  0x28(%r11),%xmm3
movss  0x2c(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x8(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x8(%rcx,%r9,1)
movss  %xmm3,0x8(%rcx,%r8,1)
movss  %xmm3,-0x8(%rcx,%r10,1)
movss  -0x1c(%rsi),%xmm1
movss  -0x18(%rsi),%xmm2
movss  0x20(%r11),%xmm3
movss  0x24(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0xc(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0xc(%rcx,%r9,1)
movss  %xmm3,0xc(%rcx,%r8,1)
movss  %xmm3,-0xc(%rcx,%r10,1)
movss  -0x24(%rsi),%xmm1
movss  -0x20(%rsi),%xmm2
movss  0x18(%r11),%xmm3
movss  0x1c(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x10(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x10(%rcx,%r9,1)
movss  %xmm3,0x10(%rcx,%r8,1)
movss  %xmm3,-0x10(%rcx,%r10,1)
movss  -0x2c(%rsi),%xmm1
movss  -0x28(%rsi),%xmm2
movss  0x10(%r11),%xmm3
movss  0x14(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x14(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x14(%rcx,%r9,1)
movss  %xmm3,0x14(%rcx,%r8,1)
movss  %xmm3,-0x14(%rcx,%r10,1)
movss  -0x34(%rsi),%xmm1
movss  -0x30(%rsi),%xmm2
movss  0x8(%r11),%xmm3
movss  0xc(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x18(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x18(%rcx,%r9,1)
movss  %xmm3,0x18(%rcx,%r8,1)
movss  %xmm3,-0x18(%rcx,%r10,1)
movss  -0x3c(%rsi),%xmm1
movss  -0x38(%rsi),%xmm2
movss  (%r11),%xmm3
movss  0x4(%r11),%xmm4
movaps %xmm3,%xmm5
xorps  %xmm0,%xmm3
mulss  %xmm1,%xmm3
mulss  %xmm4,%xmm1
mulss  %xmm2,%xmm5
subss  %xmm1,%xmm5
mulss  %xmm4,%xmm2
subss  %xmm2,%xmm3
movss  %xmm5,0x1c(%rcx,%rdi,2)
xorps  %xmm0,%xmm5
movss  %xmm5,-0x1c(%rcx,%r9,1)
movss  %xmm3,0x1c(%rcx,%r8,1)
movss  %xmm3,-0x1c(%rcx,%r10,1)
add    $0xffffffffffffffc0,%r11
add    $0xffffffffffffffc0,%rsi
add    $0x10,%rdi
add    $0xffffffffffffffe0,%r9
add    $0x20,%r8
add    $0xffffffffffffffe0,%r10
cmp    %rdx,%r11
jae    1150 <imdct_step8_decode+0x50>
ret

LLVM IR (-O0):
define void @imdct_step8_decode(i32 %0, float* %1, float* %2, float* %3) {
%5 = alloca i32
%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
store i32 %0, i32* %5
store float* %1, float** %6
store float* %2, float** %7
store float* %3, float** %8
%18 = load i32, i32* %5
%19 = udiv i32 %18, 2
%20 = sub i32 %19, 16
%21 = load float*, float** %6
%22 = zext i32 %20 to i64
%23 = getelementptr inbounds float, float* %21, i64 %22
store float* %23, float** %6
%24 = load float*, float** %8
%25 = getelementptr inbounds float, float* %24, i64 0
store float* %25, float** %9
%26 = load float*, float** %8
%27 = load i32, i32* %5
%28 = udiv i32 %27, 2
%29 = sub i32 %28, 8
%30 = zext i32 %29 to i64
%31 = getelementptr inbounds float, float* %26, i64 %30
store float* %31, float** %10
%32 = load float*, float** %8
%33 = load i32, i32* %5
%34 = udiv i32 %33, 2
%35 = zext i32 %34 to i64
%36 = getelementptr inbounds float, float* %32, i64 %35
store float* %36, float** %11
%37 = load float*, float** %8
%38 = load i32, i32* %5
%39 = sub i32 %38, 8
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds float, float* %37, i64 %40
store float* %41, float** %12
%42 = load float*, float** %7
%43 = load i32, i32* %5
%44 = udiv i32 %43, 2
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds float, float* %42, i64 %45
%47 = getelementptr inbounds float, float* %46, i64 -16
store float* %47, float** %13
br label %48
48: ; preds = %405, %4
%49 = load float*, float** %13
%50 = load float*, float** %7
%51 = icmp uge float* %49, %50
br i1 %51, label %52, label %418
52: ; preds = %48
%53 = load float*, float** %13
%54 = getelementptr inbounds float, float* %53, i64 14
%55 = load float, float* %54
%56 = load float*, float** %6
%57 = getelementptr inbounds float, float* %56, i64 15
%58 = load float, float* %57
%59 = load float*, float** %13
%60 = getelementptr inbounds float, float* %59, i64 15
%61 = load float, float* %60
%62 = load float*, float** %6
%63 = getelementptr inbounds float, float* %62, i64 14
%64 = load float, float* %63
%65 = fmul float %61, %64
%66 = fneg float %65
%67 = call float @llvm.fmuladd.f32(float %55, float %58, float %66)
store float %67, float* %17
%68 = load float*, float** %13
%69 = getelementptr inbounds float, float* %68, i64 14
%70 = load float, float* %69
%71 = fneg float %70
%72 = load float*, float** %6
%73 = getelementptr inbounds float, float* %72, i64 14
%74 = load float, float* %73
%75 = load float*, float** %13
%76 = getelementptr inbounds float, float* %75, i64 15
%77 = load float, float* %76
%78 = load float*, float** %6
%79 = getelementptr inbounds float, float* %78, i64 15
%80 = load float, float* %79
%81 = fmul float %77, %80
%82 = fneg float %81
%83 = call float @llvm.fmuladd.f32(float %71, float %74, float %82)
store float %83, float* %16
%84 = load float, float* %17
%85 = load float*, float** %9
%86 = getelementptr inbounds float, float* %85, i64 0
store float %84, float* %86
%87 = load float, float* %17
%88 = fneg float %87
%89 = load float*, float** %10
%90 = getelementptr inbounds float, float* %89, i64 7
store float %88, float* %90
%91 = load float, float* %16
%92 = load float*, float** %11
%93 = getelementptr inbounds float, float* %92, i64 0
store float %91, float* %93
%94 = load float, float* %16
%95 = load float*, float** %12
%96 = getelementptr inbounds float, float* %95, i64 7
store float %94, float* %96
%97 = load float*, float** %13
%98 = getelementptr inbounds float, float* %97, i64 12
%99 = load float, float* %98
%100 = load float*, float** %6
%101 = getelementptr inbounds float, float* %100, i64 13
%102 = load float, float* %101
%103 = load float*, float** %13
%104 = getelementptr inbounds float, float* %103, i64 13
%105 = load float, float* %104
%106 = load float*, float** %6
%107 = getelementptr inbounds float, float* %106, i64 12
%108 = load float, float* %107
%109 = fmul float %105, %108
%110 = fneg float %109
%111 = call float @llvm.fmuladd.f32(float %99, float %102, float %110)
store float %111, float* %15
%112 = load float*, float** %13
%113 = getelementptr inbounds float, float* %112, i64 12
%114 = load float, float* %113
%115 = fneg float %114
%116 = load float*, float** %6
%117 = getelementptr inbounds float, float* %116, i64 12
%118 = load float, float* %117
%119 = load float*, float** %13
%120 = getelementptr inbounds float, float* %119, i64 13
%121 = load float, float* %120
%122 = load float*, float** %6
%123 = getelementptr inbounds float, float* %122, i64 13
%124 = load float, float* %123
%125 = fmul float %121, %124
%126 = fneg float %125
%127 = call float @llvm.fmuladd.f32(float %115, float %118, float %126)
store float %127, float* %14
%128 = load float, float* %15
%129 = load float*, float** %9
%130 = getelementptr inbounds float, float* %129, i64 1
store float %128, float* %130
%131 = load float, float* %15
%132 = fneg float %131
%133 = load float*, float** %10
%134 = getelementptr inbounds float, float* %133, i64 6
store float %132, float* %134
%135 = load float, float* %14
%136 = load float*, float** %11
%137 = getelementptr inbounds float, float* %136, i64 1
store float %135, float* %137
%138 = load float, float* %14
%139 = load float*, float** %12
%140 = getelementptr inbounds float, float* %139, i64 6
store float %138, float* %140
%141 = load float*, float** %13
%142 = getelementptr inbounds float, float* %141, i64 10
%143 = load float, float* %142
%144 = load float*, float** %6
%145 = getelementptr inbounds float, float* %144, i64 11
%146 = load float, float* %145
%147 = load float*, float** %13
%148 = getelementptr inbounds float, float* %147, i64 11
%149 = load float, float* %148
%150 = load float*, float** %6
%151 = getelementptr inbounds float, float* %150, i64 10
%152 = load float, float* %151
%153 = fmul float %149, %152
%154 = fneg float %153
%155 = call float @llvm.fmuladd.f32(float %143, float %146, float %154)
store float %155, float* %17
%156 = load float*, float** %13
%157 = getelementptr inbounds float, float* %156, i64 10
%158 = load float, float* %157
%159 = fneg float %158
%160 = load float*, float** %6
%161 = getelementptr inbounds float, float* %160, i64 10
%162 = load float, float* %161
%163 = load float*, float** %13
%164 = getelementptr inbounds float, float* %163, i64 11
%165 = load float, float* %164
%166 = load float*, float** %6
%167 = getelementptr inbounds float, float* %166, i64 11
%168 = load float, float* %167
%169 = fmul float %165, %168
%170 = fneg float %169
%171 = call float @llvm.fmuladd.f32(float %159, float %162, float %170)
store float %171, float* %16
%172 = load float, float* %17
%173 = load float*, float** %9
%174 = getelementptr inbounds float, float* %173, i64 2
store float %172, float* %174
%175 = load float, float* %17
%176 = fneg float %175
%177 = load float*, float** %10
%178 = getelementptr inbounds float, float* %177, i64 5
store float %176, float* %178
%179 = load float, float* %16
%180 = load float*, float** %11
%181 = getelementptr inbounds float, float* %180, i64 2
store float %179, float* %181
%182 = load float, float* %16
%183 = load float*, float** %12
%184 = getelementptr inbounds float, float* %183, i64 5
store float %182, float* %184
%185 = load float*, float** %13
%186 = getelementptr inbounds float, float* %185, i64 8
%187 = load float, float* %186
%188 = load float*, float** %6
%189 = getelementptr inbounds float, float* %188, i64 9
%190 = load float, float* %189
%191 = load float*, float** %13
%192 = getelementptr inbounds float, float* %191, i64 9
%193 = load float, float* %192
%194 = load float*, float** %6
%195 = getelementptr inbounds float, float* %194, i64 8
%196 = load float, float* %195
%197 = fmul float %193, %196
%198 = fneg float %197
%199 = call float @llvm.fmuladd.f32(float %187, float %190, float %198)
store float %199, float* %15
%200 = load float*, float** %13
%201 = getelementptr inbounds float, float* %200, i64 8
%202 = load float, float* %201
%203 = fneg float %202
%204 = load float*, float** %6
%205 = getelementptr inbounds float, float* %204, i64 8
%206 = load float, float* %205
%207 = load float*, float** %13
%208 = getelementptr inbounds float, float* %207, i64 9
%209 = load float, float* %208
%210 = load float*, float** %6
%211 = getelementptr inbounds float, float* %210, i64 9
%212 = load float, float* %211
%213 = fmul float %209, %212
%214 = fneg float %213
%215 = call float @llvm.fmuladd.f32(float %203, float %206, float %214)
store float %215, float* %14
%216 = load float, float* %15
%217 = load float*, float** %9
%218 = getelementptr inbounds float, float* %217, i64 3
store float %216, float* %218
%219 = load float, float* %15
%220 = fneg float %219
%221 = load float*, float** %10
%222 = getelementptr inbounds float, float* %221, i64 4
store float %220, float* %222
%223 = load float, float* %14
%224 = load float*, float** %11
%225 = getelementptr inbounds float, float* %224, i64 3
store float %223, float* %225
%226 = load float, float* %14
%227 = load float*, float** %12
%228 = getelementptr inbounds float, float* %227, i64 4
store float %226, float* %228
%229 = load float*, float** %13
%230 = getelementptr inbounds float, float* %229, i64 6
%231 = load float, float* %230
%232 = load float*, float** %6
%233 = getelementptr inbounds float, float* %232, i64 7
%234 = load float, float* %233
%235 = load float*, float** %13
%236 = getelementptr inbounds float, float* %235, i64 7
%237 = load float, float* %236
%238 = load float*, float** %6
%239 = getelementptr inbounds float, float* %238, i64 6
%240 = load float, float* %239
%241 = fmul float %237, %240
%242 = fneg float %241
%243 = call float @llvm.fmuladd.f32(float %231, float %234, float %242)
store float %243, float* %17
%244 = load float*, float** %13
%245 = getelementptr inbounds float, float* %244, i64 6
%246 = load float, float* %245
%247 = fneg float %246
%248 = load float*, float** %6
%249 = getelementptr inbounds float, float* %248, i64 6
%250 = load float, float* %249
%251 = load float*, float** %13
%252 = getelementptr inbounds float, float* %251, i64 7
%253 = load float, float* %252
%254 = load float*, float** %6
%255 = getelementptr inbounds float, float* %254, i64 7
%256 = load float, float* %255
%257 = fmul float %253, %256
%258 = fneg float %257
%259 = call float @llvm.fmuladd.f32(float %247, float %250, float %258)
store float %259, float* %16
%260 = load float, float* %17
%261 = load float*, float** %9
%262 = getelementptr inbounds float, float* %261, i64 4
store float %260, float* %262
%263 = load float, float* %17
%264 = fneg float %263
%265 = load float*, float** %10
%266 = getelementptr inbounds float, float* %265, i64 3
store float %264, float* %266
%267 = load float, float* %16
%268 = load float*, float** %11
%269 = getelementptr inbounds float, float* %268, i64 4
store float %267, float* %269
%270 = load float, float* %16
%271 = load float*, float** %12
%272 = getelementptr inbounds float, float* %271, i64 3
store float %270, float* %272
%273 = load float*, float** %13
%274 = getelementptr inbounds float, float* %273, i64 4
%275 = load float, float* %274
%276 = load float*, float** %6
%277 = getelementptr inbounds float, float* %276, i64 5
%278 = load float, float* %277
%279 = load float*, float** %13
%280 = getelementptr inbounds float, float* %279, i64 5
%281 = load float, float* %280
%282 = load float*, float** %6
%283 = getelementptr inbounds float, float* %282, i64 4
%284 = load float, float* %283
%285 = fmul float %281, %284
%286 = fneg float %285
%287 = call float @llvm.fmuladd.f32(float %275, float %278, float %286)
store float %287, float* %15
%288 = load float*, float** %13
%289 = getelementptr inbounds float, float* %288, i64 4
%290 = load float, float* %289
%291 = fneg float %290
%292 = load float*, float** %6
%293 = getelementptr inbounds float, float* %292, i64 4
%294 = load float, float* %293
%295 = load float*, float** %13
%296 = getelementptr inbounds float, float* %295, i64 5
%297 = load float, float* %296
%298 = load float*, float** %6
%299 = getelementptr inbounds float, float* %298, i64 5
%300 = load float, float* %299
%301 = fmul float %297, %300
%302 = fneg float %301
%303 = call float @llvm.fmuladd.f32(float %291, float %294, float %302)
store float %303, float* %14
%304 = load float, float* %15
%305 = load float*, float** %9
%306 = getelementptr inbounds float, float* %305, i64 5
store float %304, float* %306
%307 = load float, float* %15
%308 = fneg float %307
%309 = load float*, float** %10
%310 = getelementptr inbounds float, float* %309, i64 2
store float %308, float* %310
%311 = load float, float* %14
%312 = load float*, float** %11
%313 = getelementptr inbounds float, float* %312, i64 5
store float %311, float* %313
%314 = load float, float* %14
%315 = load float*, float** %12
%316 = getelementptr inbounds float, float* %315, i64 2
store float %314, float* %316
%317 = load float*, float** %13
%318 = getelementptr inbounds float, float* %317, i64 2
%319 = load float, float* %318
%320 = load float*, float** %6
%321 = getelementptr inbounds float, float* %320, i64 3
%322 = load float, float* %321
%323 = load float*, float** %13
%324 = getelementptr inbounds float, float* %323, i64 3
%325 = load float, float* %324
%326 = load float*, float** %6
%327 = getelementptr inbounds float, float* %326, i64 2
%328 = load float, float* %327
%329 = fmul float %325, %328
%330 = fneg float %329
%331 = call float @llvm.fmuladd.f32(float %319, float %322, float %330)
store float %331, float* %17
%332 = load float*, float** %13
%333 = getelementptr inbounds float, float* %332, i64 2
%334 = load float, float* %333
%335 = fneg float %334
%336 = load float*, float** %6
%337 = getelementptr inbounds float, float* %336, i64 2
%338 = load float, float* %337
%339 = load float*, float** %13
%340 = getelementptr inbounds float, float* %339, i64 3
%341 = load float, float* %340
%342 = load float*, float** %6
%343 = getelementptr inbounds float, float* %342, i64 3
%344 = load float, float* %343
%345 = fmul float %341, %344
%346 = fneg float %345
%347 = call float @llvm.fmuladd.f32(float %335, float %338, float %346)
store float %347, float* %16
%348 = load float, float* %17
%349 = load float*, float** %9
%350 = getelementptr inbounds float, float* %349, i64 6
store float %348, float* %350
%351 = load float, float* %17
%352 = fneg float %351
%353 = load float*, float** %10
%354 = getelementptr inbounds float, float* %353, i64 1
store float %352, float* %354
%355 = load float, float* %16
%356 = load float*, float** %11
%357 = getelementptr inbounds float, float* %356, i64 6
store float %355, float* %357
%358 = load float, float* %16
%359 = load float*, float** %12
%360 = getelementptr inbounds float, float* %359, i64 1
store float %358, float* %360
%361 = load float*, float** %13
%362 = getelementptr inbounds float, float* %361, i64 0
%363 = load float, float* %362
%364 = load float*, float** %6
%365 = getelementptr inbounds float, float* %364, i64 1
%366 = load float, float* %365
%367 = load float*, float** %13
%368 = getelementptr inbounds float, float* %367, i64 1
%369 = load float, float* %368
%370 = load float*, float** %6
%371 = getelementptr inbounds float, float* %370, i64 0
%372 = load float, float* %371
%373 = fmul float %369, %372
%374 = fneg float %373
%375 = call float @llvm.fmuladd.f32(float %363, float %366, float %374)
store float %375, float* %15
%376 = load float*, float** %13
%377 = getelementptr inbounds float, float* %376, i64 0
%378 = load float, float* %377
%379 = fneg float %378
%380 = load float*, float** %6
%381 = getelementptr inbounds float, float* %380, i64 0
%382 = load float, float* %381
%383 = load float*, float** %13
%384 = getelementptr inbounds float, float* %383, i64 1
%385 = load float, float* %384
%386 = load float*, float** %6
%387 = getelementptr inbounds float, float* %386, i64 1
%388 = load float, float* %387
%389 = fmul float %385, %388
%390 = fneg float %389
%391 = call float @llvm.fmuladd.f32(float %379, float %382, float %390)
store float %391, float* %14
%392 = load float, float* %15
%393 = load float*, float** %9
%394 = getelementptr inbounds float, float* %393, i64 7
store float %392, float* %394
%395 = load float, float* %15
%396 = fneg float %395
%397 = load float*, float** %10
%398 = getelementptr inbounds float, float* %397, i64 0
store float %396, float* %398
%399 = load float, float* %14
%400 = load float*, float** %11
%401 = getelementptr inbounds float, float* %400, i64 7
store float %399, float* %401
%402 = load float, float* %14
%403 = load float*, float** %12
%404 = getelementptr inbounds float, float* %403, i64 0
store float %402, float* %404
br label %405
405: ; preds = %52
%406 = load float*, float** %13
%407 = getelementptr inbounds float, float* %406, i64 -16
store float* %407, float** %13
%408 = load float*, float** %6
%409 = getelementptr inbounds float, float* %408, i64 -16
store float* %409, float** %6
%410 = load float*, float** %9
%411 = getelementptr inbounds float, float* %410, i64 8
store float* %411, float** %9
%412 = load float*, float** %10
%413 = getelementptr inbounds float, float* %412, i64 -8
store float* %413, float** %10
%414 = load float*, float** %11
%415 = getelementptr inbounds float, float* %414, i64 8
store float* %415, float** %11
%416 = load float*, float** %12
%417 = getelementptr inbounds float, float* %416, i64 -8
store float* %417, float** %12
br label %48
418: ; preds = %48
ret void
}

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