void imdct_setup_step1(const unsigned int n, const float *A, const float *Y,
                       float *v) {
  v += n / 2;
  for (int i = 0, j = -4; i < (int)(n / 4); i += 4, j -= 4) {
    v[j + 3] = Y[(i + 0) * 2] * A[i + 0] - Y[(i + 1) * 2] * A[i + 1];
    v[j + 2] = Y[(i + 0) * 2] * A[i + 1] + Y[(i + 1) * 2] * A[i + 0];
    v[j + 1] = Y[(i + 2) * 2] * A[i + 2] - Y[(i + 3) * 2] * A[i + 3];
    v[j + 0] = Y[(i + 2) * 2] * A[i + 3] + Y[(i + 3) * 2] * A[i + 2];
  }
  Y += n / 2;
  A += n / 4;
  v -= n / 4;
  for (int i = 0, j = -4; i < (int)(n / 4); i += 4, j -= 4) {
    v[j + 3] = -Y[(j + 3) * 2 + 1] * A[i + 0] - -Y[(j + 2) * 2 + 1] * A[i + 1];
    v[j + 2] = -Y[(j + 3) * 2 + 1] * A[i + 1] + -Y[(j + 2) * 2 + 1] * A[i + 0];
    v[j + 1] = -Y[(j + 1) * 2 + 1] * A[i + 2] - -Y[(j + 0) * 2 + 1] * A[i + 3];
    v[j + 0] = -Y[(j + 1) * 2 + 1] * A[i + 3] + -Y[(j + 0) * 2 + 1] * A[i + 2];
  }
}


x86 assembly (clang, -O0):
<imdct_setup_step1>:
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
mov    -0x20(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0xfffffffc,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
cmp    %ecx,%eax
jge    131a <imdct_setup_step1+0x21a>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x28(%rbp)
jmp    1138 <imdct_setup_step1+0x38>
mov    -0x4(%rbp),%ecx
shr    $0x1,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0xfffffffc,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
shr    $0x2,%ecx
cmp    %ecx,%eax
jge    15d6 <imdct_setup_step1+0x4d6>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    1374 <imdct_setup_step1+0x274>
pop    %rbp
ret

x86 assembly (clang, -O2):
<imdct_setup_step1>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    $0x4,%edi
jb     155a <imdct_setup_step1+0x45a>
mov    %edi,%r8d
shr    %r8d
lea    (%rcx,%r8,4),%r10
mov    %edi,%r9d
shr    $0x2,%r9d
cmp    $0x5,%r9
mov    $0x4,%r14d
cmovae %r9,%r14
mov    $0x4,%eax
add    $0xffffffffffffffff,%r14
mov    $0xfffffffffffffffc,%r11
cmp    $0xf,%r14
ja     114d <imdct_setup_step1+0x4d>
xor    %eax,%eax
jmp    13e0 <imdct_setup_step1+0x2e0>
cmp    $0x5,%r9
cmovae %r9,%rax
lea    -0x1(%rax),%rbx
and    $0xfffffffffffffffc,%rbx
mov    %r8,%rbp
sub    %rbx,%rbp
lea    (%rcx,%rbp,4),%rbp
add    $0xfffffffffffffff0,%rbp
lea    -0x8(,%rax,8),%rax
ff
or     $0x1c,%rax
add    %rdx,%rax
cmp    %rax,%rbp
setb   %r15b
cmp    %rdx,%r10
seta   %r12b
lea    (%rsi,%rbx,4),%rax
add    $0x10,%rax
cmp    %rax,%rbp
setb   %bl
cmp    %rsi,%r10
seta   %bpl
xor    %eax,%eax
test   %r12b,%r15b
jne    13e0 <imdct_setup_step1+0x2e0>
and    %bpl,%bl
jne    13e0 <imdct_setup_step1+0x2e0>
shr    $0x2,%r14
lea    0x1(%r14),%rax
mov    %eax,%ebp
and    $0x3,%ebp
test   %rbp,%rbp
mov    $0x4,%ebx
cmovne %rbp,%rbx
sub    %rbx,%rax
shl    $0x2,%rax
mov    %rax,%r11
xor    $0xfffffffffffffffc,%r11
not    %r14
add    %rbx,%r14
lea    (%rcx,%r8,4),%r15
add    $0xffffffffffffffc0,%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups 0x50(%rdx,%rbx,2),%xmm10
movups 0x70(%rdx,%rbx,2),%xmm1
movups (%rdx,%rbx,2),%xmm12
movups 0x10(%rdx,%rbx,2),%xmm9
movups 0x20(%rdx,%rbx,2),%xmm2
movups 0x30(%rdx,%rbx,2),%xmm3
movups 0x40(%rdx,%rbx,2),%xmm4
movups 0x60(%rdx,%rbx,2),%xmm6
movaps %xmm6,%xmm0
movlhps %xmm4,%xmm0
movaps %xmm12,%xmm11
unpcklps %xmm2,%xmm11
shufps $0x24,%xmm0,%xmm11
unpckhpd %xmm4,%xmm6
unpckhps %xmm2,%xmm12
shufps $0x24,%xmm6,%xmm12
movaps %xmm1,%xmm0
movlhps %xmm10,%xmm0
movaps %xmm9,%xmm8
unpcklps %xmm3,%xmm8
shufps $0x24,%xmm0,%xmm8
unpckhpd %xmm10,%xmm1
unpckhps %xmm3,%xmm9
shufps $0x24,%xmm1,%xmm9
movss  0x30(%rsi,%rbx,1),%xmm0
movss  0x20(%rsi,%rbx,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rsi,%rbx,1),%xmm2
movss  (%rsi,%rbx,1),%xmm13
unpcklps %xmm2,%xmm13
movlhps %xmm1,%xmm13
movss  0x4(%rsi,%rbx,1),%xmm2
movss  0x8(%rsi,%rbx,1),%xmm1
movss  0xc(%rsi,%rbx,1),%xmm10
movss  0x34(%rsi,%rbx,1),%xmm4
movss  0x24(%rsi,%rbx,1),%xmm6
unpcklps %xmm4,%xmm6
movss  0x14(%rsi,%rbx,1),%xmm4
unpcklps %xmm4,%xmm2
movlhps %xmm6,%xmm2
mulps  %xmm12,%xmm2
mulps  %xmm11,%xmm13
subps  %xmm2,%xmm13
movups 0x10(%rsi,%rbx,1),%xmm4
movups (%rsi,%rbx,1),%xmm14
movups 0x20(%rsi,%rbx,1),%xmm5
movups 0x30(%rsi,%rbx,1),%xmm0
movaps %xmm0,%xmm2
movlhps %xmm5,%xmm2
movaps %xmm14,%xmm7
unpcklps %xmm4,%xmm7
shufps $0x24,%xmm2,%xmm7
movaps %xmm5,%xmm2
unpcklps %xmm0,%xmm2
movaps %xmm4,%xmm6
shufps $0x11,%xmm14,%xmm6
shufps $0xe2,%xmm2,%xmm6
movaps %xmm0,%xmm3
unpckhpd %xmm5,%xmm3
movaps %xmm14,%xmm2
unpckhps %xmm4,%xmm2
shufps $0x24,%xmm3,%xmm2
unpckhps %xmm0,%xmm5
shufps $0x33,%xmm14,%xmm4
shufps $0xe2,%xmm5,%xmm4
mulps  %xmm12,%xmm7
mulps  %xmm11,%xmm6
addps  %xmm7,%xmm6
movss  0x38(%rsi,%rbx,1),%xmm0
movss  0x28(%rsi,%rbx,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x18(%rsi,%rbx,1),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movss  0x3c(%rsi,%rbx,1),%xmm0
movss  0x2c(%rsi,%rbx,1),%xmm3
unpcklps %xmm0,%xmm3
movss  0x1c(%rsi,%rbx,1),%xmm0
unpcklps %xmm0,%xmm10
movlhps %xmm3,%xmm10
mulps  %xmm9,%xmm10
mulps  %xmm8,%xmm1
subps  %xmm10,%xmm1
mulps  %xmm9,%xmm2
mulps  %xmm8,%xmm4
addps  %xmm2,%xmm4
movaps %xmm1,%xmm2
movaps %xmm1,%xmm0
unpckhpd %xmm4,%xmm0
movlhps %xmm4,%xmm1
shufps $0x1b,%xmm4,%xmm4
shufps $0x1b,%xmm2,%xmm2
movaps %xmm13,%xmm3
movaps %xmm13,%xmm5
shufps $0xff,%xmm6,%xmm5
shufps $0x55,%xmm6,%xmm13
shufps $0x1b,%xmm6,%xmm6
shufps $0x1b,%xmm3,%xmm3
movaps %xmm4,%xmm7
unpcklps %xmm2,%xmm7
shufps $0x24,%xmm5,%xmm7
movaps %xmm6,%xmm5
unpcklps %xmm3,%xmm5
shufps $0xe2,%xmm5,%xmm0
unpckhps %xmm2,%xmm4
shufps $0x24,%xmm13,%xmm4
unpckhps %xmm3,%xmm6
shufps $0xe2,%xmm6,%xmm1
movups %xmm1,0x30(%r15)
movups %xmm4,0x20(%r15)
movups %xmm0,0x10(%r15)
movups %xmm7,(%r15)
add    $0x40,%rbx
add    $0xffffffffffffffc0,%r15
add    $0x4,%r14
jne    11f0 <imdct_setup_step1+0xf0>
xchg   %ax,%ax
movss  (%rdx,%rax,8),%xmm0
movss  0x4(%rsi,%rax,4),%xmm1
mulss  0x8(%rdx,%rax,8),%xmm1
mulss  (%rsi,%rax,4),%xmm0
subss  %xmm1,%xmm0
lea    0x0(,%r11,4),%rbp
mov    %rbp,%rbx
or     $0xc,%rbx
movss  %xmm0,(%r10,%rbx,1)
movss  (%rdx,%rax,8),%xmm0
movss  0x8(%rdx,%rax,8),%xmm1
mulss  (%rsi,%rax,4),%xmm1
mulss  0x4(%rsi,%rax,4),%xmm0
addss  %xmm1,%xmm0
mov    %rbp,%rbx
or     $0x8,%rbx
movss  %xmm0,(%r10,%rbx,1)
movss  0x10(%rdx,%rax,8),%xmm0
movss  0xc(%rsi,%rax,4),%xmm1
mulss  0x18(%rdx,%rax,8),%xmm1
mulss  0x8(%rsi,%rax,4),%xmm0
subss  %xmm1,%xmm0
or     $0x4,%rbp
movss  %xmm0,(%r10,%rbp,1)
movss  0x18(%rdx,%rax,8),%xmm0
mulss  0x8(%rsi,%rax,4),%xmm0
movss  0x10(%rdx,%rax,8),%xmm1
mulss  0xc(%rsi,%rax,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r10,%r11,4)
add    $0x4,%rax
add    $0xfffffffffffffffc,%r11
cmp    %r9,%rax
jb     13e0 <imdct_setup_step1+0x2e0>
cmp    $0x4,%edi
jb     155a <imdct_setup_step1+0x45a>
lea    (%rsi,%r9,4),%rax
add    $0xc,%rax
lea    -0x1(%r8),%rsi
sub    %r9,%rsi
lea    (%rcx,%rsi,4),%rcx
lea    (%rdx,%r8,4),%rdx
add    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
movaps 0xb44(%rip),%xmm0
xor    %edi,%edi
xchg   %ax,%ax
movss  -0x8(%rdx,%rsi,2),%xmm1
movss  (%rdx,%rsi,2),%xmm2
mulss  -0x8(%rax,%rdi,4),%xmm1
mulss  -0xc(%rax,%rdi,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rcx,%rsi,1)
movss  (%rdx,%rsi,2),%xmm1
xorps  %xmm0,%xmm1
movss  -0xc(%rax,%rdi,4),%xmm2
mulss  -0x8(%rdx,%rsi,2),%xmm2
mulss  -0x8(%rax,%rdi,4),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,-0x4(%rcx,%rsi,1)
movss  -0x18(%rdx,%rsi,2),%xmm1
movss  -0x10(%rdx,%rsi,2),%xmm2
mulss  (%rax,%rdi,4),%xmm1
mulss  -0x4(%rax,%rdi,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,-0x8(%rcx,%rsi,1)
movss  -0x10(%rdx,%rsi,2),%xmm1
movss  -0x4(%rax,%rdi,4),%xmm2
mulss  -0x18(%rdx,%rsi,2),%xmm2
xorps  %xmm0,%xmm1
mulss  (%rax,%rdi,4),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,-0xc(%rcx,%rsi,1)
add    $0x4,%rdi
add    $0xfffffffffffffff0,%rsi
cmp    %r9,%rdi
jb     14c0 <imdct_setup_step1+0x3c0>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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