void DFT512(float *A, const float *sinTab) {
  int i, j, theta;
  float alpha, beta, beta1, beta2, y0, y1, y2, y3;
  for (i = 0; i < 512; i += 4) {
    alpha = A[i];
    beta = A[i + 1];
    beta1 = A[i + 2];
    beta2 = A[i + 3];
    y0 = alpha + beta;
    y1 = alpha - beta;
    y2 = beta1 + beta2;
    y3 = beta1 - beta2;
    A[i] = y0 + y2;
    A[i + 2] = y0 - y2;
    A[i + 1] = y1 + y3;
    A[i + 3] = y1 - y3;
  }
  for (i = 0; i < 512; i += 8) {
    alpha = A[i];
    beta = A[i + 4];
    A[i] = alpha + beta;
    A[i + 4] = alpha - beta;
    alpha = A[i + 2];
    beta = A[i + 6];
    A[i + 2] = alpha + beta;
    A[i + 6] = alpha - beta;
    alpha = A[i + 1];
    beta1 = 0.70710678118654752440084436210485f * (A[i + 5] + A[i + 7]);
    beta2 = 0.70710678118654752440084436210485f * (A[i + 5] - A[i + 7]);
    A[i + 1] = alpha + beta1;
    A[i + 5] = alpha - beta1;
    alpha = A[i + 3];
    A[i + 3] = alpha + beta2;
    A[i + 7] = alpha - beta2;
  }
  for (i = 0; i < 512; i += 16) {
    theta = 32;
    alpha = A[i];
    beta = A[i + 8];
    A[i] = alpha + beta;
    A[i + 8] = alpha - beta;
    alpha = A[i + 4];
    beta = A[i + 12];
    A[i + 4] = alpha + beta;
    A[i + 12] = alpha - beta;
    for (j = 1; j < 4; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 128];
      alpha = A[i + j];
      beta = A[i - j + 8];
      beta1 = A[i + j + 8] * y1 + A[i - j + 16] * y0;
      beta2 = A[i + j + 8] * y0 - A[i - j + 16] * y1;
      theta += 32;
      A[i + j] = alpha + beta1;
      A[i + j + 8] = alpha - beta1;
      A[i - j + 8] = beta + beta2;
      A[i - j + 16] = beta - beta2;
    }
  }
  for (i = 0; i < 512; i += 32) {
    theta = 16;
    alpha = A[i];
    beta = A[i + 16];
    A[i] = alpha + beta;
    A[i + 16] = alpha - beta;
    alpha = A[i + 8];
    beta = A[i + 24];
    A[i + 8] = alpha + beta;
    A[i + 24] = alpha - beta;
    for (j = 1; j < 8; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 128];
      alpha = A[i + j];
      beta = A[i - j + 16];
      beta1 = A[i + j + 16] * y1 + A[i - j + 32] * y0;
      beta2 = A[i + j + 16] * y0 - A[i - j + 32] * y1;
      theta += 16;
      A[i + j] = alpha + beta1;
      A[i + j + 16] = alpha - beta1;
      A[i - j + 16] = beta + beta2;
      A[i - j + 32] = beta - beta2;
    }
  }
  for (i = 0; i < 512; i += 64) {
    theta = 8;
    alpha = A[i];
    beta = A[i + 32];
    A[i] = alpha + beta;
    A[i + 32] = alpha - beta;
    alpha = A[i + 16];
    beta = A[i + 48];
    A[i + 16] = alpha + beta;
    A[i + 48] = alpha - beta;
    for (j = 1; j < 16; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 128];
      alpha = A[i + j];
      beta = A[i - j + 32];
      beta1 = A[i + j + 32] * y1 + A[i - j + 64] * y0;
      beta2 = A[i + j + 32] * y0 - A[i - j + 64] * y1;
      theta += 8;
      A[i + j] = alpha + beta1;
      A[i + j + 32] = alpha - beta1;
      A[i - j + 32] = beta + beta2;
      A[i - j + 64] = beta - beta2;
    }
  }
  for (i = 0; i < 512; i += 128) {
    theta = 4;
    alpha = A[i];
    beta = A[i + 64];
    A[i] = alpha + beta;
    A[i + 64] = alpha - beta;
    alpha = A[i + 32];
    beta = A[i + 96];
    A[i + 32] = alpha + beta;
    A[i + 96] = alpha - beta;
    for (j = 1; j < 32; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 128];
      alpha = A[i + j];
      beta = A[i - j + 64];
      beta1 = A[i + j + 64] * y1 + A[i - j + 128] * y0;
      beta2 = A[i + j + 64] * y0 - A[i - j + 128] * y1;
      theta += 4;
      A[i + j] = alpha + beta1;
      A[i + j + 64] = alpha - beta1;
      A[i - j + 64] = beta + beta2;
      A[i - j + 128] = beta - beta2;
    }
  }
  for (i = 0; i < 512; i += 256) {
    theta = 2;
    alpha = A[i];
    beta = A[i + 128];
    A[i] = alpha + beta;
    A[i + 128] = alpha - beta;
    alpha = A[i + 64];
    beta = A[i + 192];
    A[i + 64] = alpha + beta;
    A[i + 192] = alpha - beta;
    for (j = 1; j < 64; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 128];
      alpha = A[i + j];
      beta = A[i - j + 128];
      beta1 = A[i + j + 128] * y1 + A[i - j + 256] * y0;
      beta2 = A[i + j + 128] * y0 - A[i - j + 256] * y1;
      theta += 2;
      A[i + j] = alpha + beta1;
      A[i + j + 128] = alpha - beta1;
      A[i - j + 128] = beta + beta2;
      A[i - j + 256] = beta - beta2;
    }
  }
  theta = 1;
  alpha = A[0];
  beta = A[256];
  A[0] = alpha + beta;
  A[256] = alpha - beta;
  alpha = A[128];
  beta = A[384];
  A[128] = alpha + beta;
  A[384] = alpha - beta;
  for (j = 1; j < 128; j++) {
    y0 = sinTab[theta];
    y1 = sinTab[theta + 128];
    alpha = A[j];
    beta = A[-j + 256];
    beta1 = A[j + 256] * y1 + A[-j + 512] * y0;
    beta2 = A[j + 256] * y0 - A[-j + 512] * y1;
    theta += 1;
    A[j] = alpha + beta1;
    A[j + 256] = alpha - beta1;
    A[-j + 256] = beta + beta2;
    A[-j + 512] = beta - beta2;
  }
}


x86 assembly (clang, -O0):
<DFT512>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    122c <DFT512+0x12c>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x28(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x28(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x30(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1113 <DFT512+0x13>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    1418 <DFT512+0x318>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
movss  0x1cbb(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0x1c86(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14(%rbp)
jmp    1233 <DFT512+0x133>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    1695 <DFT512+0x595>
movl   $0x20,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1682 <DFT512+0x582>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14fc <DFT512+0x3fc>
jmp    1687 <DFT512+0x587>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    141f <DFT512+0x31f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    1912 <DFT512+0x812>
movl   $0x10,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x18,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x18,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x8,-0x18(%rbp)
jge    18ff <DFT512+0x7ff>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1779 <DFT512+0x679>
jmp    1904 <DFT512+0x804>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    169c <DFT512+0x59c>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    1b8f <DFT512+0xa8f>
movl   $0x8,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x30,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x10,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x30,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x10,-0x18(%rbp)
jge    1b7c <DFT512+0xa7c>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    19f6 <DFT512+0x8f6>
jmp    1b81 <DFT512+0xa81>
mov    -0x14(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x14(%rbp)
jmp    1919 <DFT512+0x819>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    1e17 <DFT512+0xd17>
movl   $0x4,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x60,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x60,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x20,-0x18(%rbp)
jge    1e02 <DFT512+0xd02>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1c73 <DFT512+0xb73>
jmp    1e07 <DFT512+0xd07>
mov    -0x14(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x14(%rbp)
jmp    1b96 <DFT512+0xa96>
movl   $0x0,-0x14(%rbp)
cmpl   $0x200,-0x14(%rbp)
jge    20ba <DFT512+0xfba>
movl   $0x2,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x40,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x40,-0x18(%rbp)
jge    20a5 <DFT512+0xfa5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1f07 <DFT512+0xe07>
jmp    20aa <DFT512+0xfaa>
mov    -0x14(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x14(%rbp)
jmp    1e1e <DFT512+0xd1e>
movl   $0x1,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x400(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x400(%rax)
mov    -0x8(%rbp),%rax
movss  0x200(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x600(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x200(%rax)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x600(%rax)
movl   $0x1,-0x18(%rbp)
cmpl   $0x80,-0x18(%rbp)
jge    22e5 <DFT512+0x11e5>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%ecx
add    $0x200,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%ecx
add    $0x200,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x20(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
xor    %ecx,%ecx
sub    -0x18(%rbp),%ecx
add    $0x200,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    215c <DFT512+0x105c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<DFT512>:
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x30(%rdi,%rax,1),%xmm0
movss  0x20(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x10(%rdi,%rax,1),%xmm2
movss  (%rdi,%rax,1),%xmm0
unpcklps %xmm2,%xmm0
movlhps %xmm1,%xmm0
movss  0x4(%rdi,%rax,1),%xmm4
movss  0x8(%rdi,%rax,1),%xmm1
movss  0xc(%rdi,%rax,1),%xmm2
movss  0x34(%rdi,%rax,1),%xmm3
movss  0x24(%rdi,%rax,1),%xmm5
unpcklps %xmm3,%xmm5
movss  0x14(%rdi,%rax,1),%xmm3
unpcklps %xmm3,%xmm4
movlhps %xmm5,%xmm4
movss  0x38(%rdi,%rax,1),%xmm3
movss  0x28(%rdi,%rax,1),%xmm5
unpcklps %xmm3,%xmm5
movss  0x18(%rdi,%rax,1),%xmm3
unpcklps %xmm3,%xmm1
movlhps %xmm5,%xmm1
movss  0x3c(%rdi,%rax,1),%xmm3
movss  0x2c(%rdi,%rax,1),%xmm5
unpcklps %xmm3,%xmm5
movss  0x1c(%rdi,%rax,1),%xmm3
unpcklps %xmm3,%xmm2
movlhps %xmm5,%xmm2
movaps %xmm0,%xmm3
addps  %xmm4,%xmm3
subps  %xmm4,%xmm0
movaps %xmm1,%xmm4
addps  %xmm2,%xmm4
subps  %xmm2,%xmm1
movaps %xmm3,%xmm2
addps  %xmm4,%xmm2
subps  %xmm4,%xmm3
movaps %xmm0,%xmm4
addps  %xmm1,%xmm4
subps  %xmm1,%xmm0
movaps %xmm3,%xmm1
unpcklps %xmm0,%xmm1
movaps %xmm4,%xmm5
shufps $0x11,%xmm2,%xmm5
shufps $0xe2,%xmm1,%xmm5
movaps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movaps %xmm2,%xmm6
unpcklps %xmm4,%xmm6
shufps $0x24,%xmm1,%xmm6
movaps %xmm3,%xmm1
unpckhps %xmm0,%xmm1
movaps %xmm4,%xmm7
shufps $0x33,%xmm2,%xmm7
shufps $0xe2,%xmm1,%xmm7
unpckhpd %xmm3,%xmm0
unpckhps %xmm4,%xmm2
shufps $0x24,%xmm0,%xmm2
movups %xmm2,0x20(%rdi,%rax,1)
movups %xmm7,0x30(%rdi,%rax,1)
movups %xmm6,(%rdi,%rax,1)
movups %xmm5,0x10(%rdi,%rax,1)
add    $0x40,%rax
cmp    $0x800,%rax
jne    1110 <DFT512+0x10>
xor    %eax,%eax
movaps 0xddf(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x60(%rdi,%rax,1),%xmm0
movss  0x40(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x20(%rdi,%rax,1),%xmm0
movss  (%rdi,%rax,1),%xmm10
unpcklps %xmm0,%xmm10
movlhps %xmm1,%xmm10
movss  0x4(%rdi,%rax,1),%xmm3
movss  0x8(%rdi,%rax,1),%xmm13
movss  0xc(%rdi,%rax,1),%xmm12
movss  0x70(%rdi,%rax,1),%xmm0
movss  0x50(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x30(%rdi,%rax,1),%xmm0
movss  0x10(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm10,%xmm9
addps  %xmm5,%xmm9
subps  %xmm5,%xmm10
movss  0x68(%rdi,%rax,1),%xmm0
movss  0x48(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x28(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm13
movlhps %xmm1,%xmm13
movss  0x78(%rdi,%rax,1),%xmm0
movss  0x58(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x38(%rdi,%rax,1),%xmm0
movss  0x18(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm13,%xmm11
addps  %xmm5,%xmm11
subps  %xmm5,%xmm13
movss  0x64(%rdi,%rax,1),%xmm0
movss  0x44(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x24(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x74(%rdi,%rax,1),%xmm0
movss  0x54(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x34(%rdi,%rax,1),%xmm0
movss  0x14(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movlhps %xmm5,%xmm1
movss  0x7c(%rdi,%rax,1),%xmm0
movss  0x5c(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x3c(%rdi,%rax,1),%xmm0
movss  0x1c(%rdi,%rax,1),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm5,%xmm6
movaps %xmm1,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm8,%xmm0
subps  %xmm6,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm3,%xmm7
addps  %xmm0,%xmm7
subps  %xmm0,%xmm3
movss  0x6c(%rdi,%rax,1),%xmm0
movss  0x4c(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x2c(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm12
movlhps %xmm5,%xmm12
movaps %xmm1,%xmm0
addps  %xmm12,%xmm0
subps  %xmm1,%xmm12
movaps %xmm0,%xmm1
movlhps %xmm11,%xmm1
movaps %xmm9,%xmm14
unpcklps %xmm7,%xmm14
shufps $0x24,%xmm1,%xmm14
movaps %xmm12,%xmm6
movlhps %xmm13,%xmm6
movaps %xmm10,%xmm15
unpcklps %xmm3,%xmm15
shufps $0x24,%xmm6,%xmm15
movaps %xmm11,%xmm4
unpcklps %xmm0,%xmm4
movaps %xmm7,%xmm6
shufps $0x11,%xmm9,%xmm6
shufps $0xe2,%xmm4,%xmm6
movaps %xmm13,%xmm4
unpcklps %xmm12,%xmm4
movaps %xmm3,%xmm2
shufps $0x11,%xmm10,%xmm2
shufps $0xe2,%xmm4,%xmm2
movaps %xmm0,%xmm4
unpckhpd %xmm11,%xmm4
movaps %xmm9,%xmm5
unpckhps %xmm7,%xmm5
shufps $0x24,%xmm4,%xmm5
movaps %xmm12,%xmm4
unpckhpd %xmm13,%xmm4
movaps %xmm10,%xmm1
unpckhps %xmm3,%xmm1
shufps $0x24,%xmm4,%xmm1
unpckhps %xmm0,%xmm11
shufps $0x33,%xmm9,%xmm7
shufps $0xe2,%xmm11,%xmm7
unpckhps %xmm12,%xmm13
shufps $0x33,%xmm10,%xmm3
shufps $0xe2,%xmm13,%xmm3
movups %xmm3,0x70(%rdi,%rax,1)
movups %xmm7,0x60(%rdi,%rax,1)
movups %xmm1,0x50(%rdi,%rax,1)
movups %xmm5,0x40(%rdi,%rax,1)
movups %xmm2,0x30(%rdi,%rax,1)
movups %xmm6,0x20(%rdi,%rax,1)
movups %xmm15,0x10(%rdi,%rax,1)
movups %xmm14,(%rdi,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x800,%rax
jne    1230 <DFT512+0x130>
mov    $0xfffffffffffffff0,%rax
movss  0x60(%rdi,%rax,4),%xmm1
movss  0x40(%rdi,%rax,4),%xmm2
movss  0x44(%rdi,%rax,4),%xmm0
movaps %xmm2,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x40(%rdi,%rax,4)
subss  %xmm1,%xmm2
movss  %xmm2,0x60(%rdi,%rax,4)
movss  0x50(%rdi,%rax,4),%xmm1
movss  0x70(%rdi,%rax,4),%xmm2
movaps %xmm1,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,0x50(%rdi,%rax,4)
subss  %xmm2,%xmm1
movss  %xmm1,0x70(%rdi,%rax,4)
movss  0x80(%rsi),%xmm1
movss  0x280(%rsi),%xmm2
movss  0x5c(%rdi,%rax,4),%xmm3
movss  0x64(%rdi,%rax,4),%xmm4
movss  0x7c(%rdi,%rax,4),%xmm5
movaps %xmm4,%xmm6
mulss  %xmm1,%xmm4
mulss  %xmm5,%xmm1
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
mulss  %xmm5,%xmm2
subss  %xmm2,%xmm4
movaps %xmm0,%xmm1
addss  %xmm6,%xmm1
movss  %xmm1,0x44(%rdi,%rax,4)
subss  %xmm6,%xmm0
movss  %xmm0,0x64(%rdi,%rax,4)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x5c(%rdi,%rax,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x7c(%rdi,%rax,4)
movss  0x100(%rsi),%xmm0
movss  0x300(%rsi),%xmm1
movss  0x48(%rdi,%rax,4),%xmm2
movss  0x58(%rdi,%rax,4),%xmm3
movss  0x68(%rdi,%rax,4),%xmm4
movss  0x78(%rdi,%rax,4),%xmm5
movaps %xmm4,%xmm6
mulss  %xmm0,%xmm4
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm4
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,0x48(%rdi,%rax,4)
subss  %xmm6,%xmm2
movss  %xmm2,0x68(%rdi,%rax,4)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x58(%rdi,%rax,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x78(%rdi,%rax,4)
movss  0x180(%rsi),%xmm0
movss  0x380(%rsi),%xmm1
movss  0x4c(%rdi,%rax,4),%xmm2
movss  0x54(%rdi,%rax,4),%xmm3
movss  0x6c(%rdi,%rax,4),%xmm4
movss  0x74(%rdi,%rax,4),%xmm5
movaps %xmm4,%xmm6
mulss  %xmm0,%xmm4
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm4
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,0x4c(%rdi,%rax,4)
subss  %xmm6,%xmm2
movss  %xmm2,0x6c(%rdi,%rax,4)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,0x54(%rdi,%rax,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x74(%rdi,%rax,4)
add    $0x10,%rax
cmp    $0x1f0,%rax
jb     1450 <DFT512+0x350>
mov    $0x7c,%r8d
mov    $0x44,%r9d
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r10,4),%rax
movss  (%rdi,%r10,4),%xmm0
mov    %rax,%rcx
or     $0x40,%rcx
movss  (%rdi,%rcx,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%r10,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rcx,1)
mov    %rax,%rcx
or     $0x20,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x60,%rax
movss  (%rdi,%rax,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rax,1)
mov    $0xffffffffffffff90,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopw   0x0(%rax,%rax,1)
movss  0x200(%rsi,%rax,4),%xmm0
movss  0x400(%rsi,%rax,4),%xmm1
movss  -0x40(%rdi,%rcx,1),%xmm2
movss  (%rdi,%rcx,1),%xmm3
movss  -0x40(%rdi,%rdx,1),%xmm4
movss  (%rdi,%rdx,1),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,-0x40(%rdi,%rcx,1)
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x40(%rdi,%rdx,1)
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x10,%rax
jne    1680 <DFT512+0x580>
lea    0x20(%r10),%rax
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%r9
cmp    $0x1e0,%r10
mov    %rax,%r10
jb     1610 <DFT512+0x510>
mov    $0xfc,%r8d
mov    $0x84,%r9d
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r10,4),%rax
movss  (%rdi,%r10,4),%xmm0
mov    %rax,%rcx
or     $0x80,%rcx
movss  (%rdi,%rcx,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%r10,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rcx,1)
mov    %rax,%rcx
or     $0x40,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0xc0,%rax
movss  (%rdi,%rax,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rax,1)
mov    $0xffffffffffffff88,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopl   0x0(%rax)
movss  0x200(%rsi,%rax,4),%xmm0
movss  0x400(%rsi,%rax,4),%xmm1
movss  -0x80(%rdi,%rcx,1),%xmm2
movss  (%rdi,%rcx,1),%xmm3
movss  -0x80(%rdi,%rdx,1),%xmm4
movss  (%rdi,%rdx,1),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,-0x80(%rdi,%rcx,1)
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x80(%rdi,%rdx,1)
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x8,%rax
jne    17a0 <DFT512+0x6a0>
lea    0x40(%r10),%rax
add    $0x100,%r8
add    $0x100,%r9
cmp    $0x1c0,%r10
mov    %rax,%r10
jb     1730 <DFT512+0x630>
mov    $0x1fc,%r8d
mov    $0x104,%r9d
xor    %r10d,%r10d
xchg   %ax,%ax
lea    0x0(,%r10,4),%rax
movss  (%rdi,%r10,4),%xmm0
mov    %rax,%rcx
or     $0x100,%rcx
movss  (%rdi,%rcx,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%r10,4)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rcx,1)
mov    %rax,%rcx
or     $0x80,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x180,%rax
movss  (%rdi,%rax,1),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
subss  %xmm1,%xmm0
movss  %xmm0,(%rdi,%rax,1)
mov    $0xffffffffffffff84,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x200(%rsi,%rax,4),%xmm0
movss  0x400(%rsi,%rax,4),%xmm1
movss  -0x100(%rdi,%rcx,1),%xmm2
ff ff
movss  (%rdi,%rcx,1),%xmm3
movss  -0x100(%rdi,%rdx,1),%xmm4
ff ff
movss  (%rdi,%rdx,1),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,-0x100(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x100(%rdi,%rdx,1)
ff ff
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x4,%rax
jne    18c0 <DFT512+0x7c0>
lea    0x80(%r10),%rax
add    $0x200,%r8
add    $0x200,%r9
cmp    $0x180,%r10
mov    %rax,%r10
jb     1850 <DFT512+0x750>
movss  0x200(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x100(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x200(%rdi)
movss  0x300(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x100(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0x300(%rdi)
mov    $0x4,%eax
mov    $0x7f,%ecx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,2),%xmm0
movss  0x200(%rsi,%rax,2),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  0x200(%rdi,%rax,1),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  0x200(%rdi,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,1)
subss  %xmm6,%xmm2
movss  %xmm2,0x200(%rdi,%rax,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
subss  %xmm3,%xmm4
movss  %xmm4,0x200(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x40,%rcx
jne    19d0 <DFT512+0x8d0>
movss  0x600(%rdi),%xmm0
movss  0x400(%rdi),%xmm1
movss  0x500(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x400(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x600(%rdi)
movss  0x700(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x500(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0x700(%rdi)
mov    $0x202,%eax
mov    $0x1ff,%ecx
nopl   0x0(%rax)
movss  -0x800(%rsi,%rax,4),%xmm0
ff ff
movss  -0x600(%rsi,%rax,4),%xmm1
ff ff
movss  (%rdi,%rax,2),%xmm2
movss  0x200(%rdi,%rax,2),%xmm3
movss  -0x200(%rdi,%rcx,4),%xmm4
ff ff
movss  (%rdi,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,2)
subss  %xmm6,%xmm2
movss  %xmm2,0x200(%rdi,%rax,2)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x200(%rdi,%rcx,4)
ff ff
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rcx,4)
add    $0x2,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x1c0,%rcx
jne    1ac0 <DFT512+0x9c0>
movss  0x400(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x200(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x400(%rdi)
movss  0x600(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x200(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0x600(%rdi)
mov    $0x4,%eax
mov    $0x1ff,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,1),%xmm0
movss  0x200(%rsi,%rax,1),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  -0x400(%rdi,%rcx,4),%xmm3
ff ff
movss  0x400(%rdi,%rax,1),%xmm4
movss  (%rdi,%rcx,4),%xmm5
movaps %xmm4,%xmm6
mulss  %xmm0,%xmm4
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm4
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,1)
subss  %xmm6,%xmm2
movss  %xmm2,0x400(%rdi,%rax,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x400(%rdi,%rcx,4)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x180,%rcx
jne    1bb0 <DFT512+0xab0>
ret

LLVM IR (-O0):
define void @DFT512(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
store float* %0, float** %3
store float* %1, float** %4
store i32 0, i32* %5
br label %16
16: ; preds = %86, %2
%17 = load i32, i32* %5
%18 = icmp slt i32 %17, 512
br i1 %18, label %19, label %89
19: ; preds = %16
%20 = load float*, float** %3
%21 = load i32, i32* %5
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %20, i64 %22
%24 = load float, float* %23
store float %24, float* %8
%25 = load float*, float** %3
%26 = load i32, i32* %5
%27 = add nsw i32 %26, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %25, i64 %28
%30 = load float, float* %29
store float %30, float* %9
%31 = load float*, float** %3
%32 = load i32, i32* %5
%33 = add nsw i32 %32, 2
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %31, i64 %34
%36 = load float, float* %35
store float %36, float* %10
%37 = load float*, float** %3
%38 = load i32, i32* %5
%39 = add nsw i32 %38, 3
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %37, i64 %40
%42 = load float, float* %41
store float %42, float* %11
%43 = load float, float* %8
%44 = load float, float* %9
%45 = fadd float %43, %44
store float %45, float* %12
%46 = load float, float* %8
%47 = load float, float* %9
%48 = fsub float %46, %47
store float %48, float* %13
%49 = load float, float* %10
%50 = load float, float* %11
%51 = fadd float %49, %50
store float %51, float* %14
%52 = load float, float* %10
%53 = load float, float* %11
%54 = fsub float %52, %53
store float %54, float* %15
%55 = load float, float* %12
%56 = load float, float* %14
%57 = fadd float %55, %56
%58 = load float*, float** %3
%59 = load i32, i32* %5
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds float, float* %58, i64 %60
store float %57, float* %61
%62 = load float, float* %12
%63 = load float, float* %14
%64 = fsub float %62, %63
%65 = load float*, float** %3
%66 = load i32, i32* %5
%67 = add nsw i32 %66, 2
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %65, i64 %68
store float %64, float* %69
%70 = load float, float* %13
%71 = load float, float* %15
%72 = fadd float %70, %71
%73 = load float*, float** %3
%74 = load i32, i32* %5
%75 = add nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %73, i64 %76
store float %72, float* %77
%78 = load float, float* %13
%79 = load float, float* %15
%80 = fsub float %78, %79
%81 = load float*, float** %3
%82 = load i32, i32* %5
%83 = add nsw i32 %82, 3
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float, float* %81, i64 %84
store float %80, float* %85
br label %86
86: ; preds = %19
%87 = load i32, i32* %5
%88 = add nsw i32 %87, 4
store i32 %88, i32* %5
br label %16
89: ; preds = %16
store i32 0, i32* %5
br label %90
90: ; preds = %220, %89
%91 = load i32, i32* %5
%92 = icmp slt i32 %91, 512
br i1 %92, label %93, label %223
93: ; preds = %90
%94 = load float*, float** %3
%95 = load i32, i32* %5
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = load float, float* %97
store float %98, float* %8
%99 = load float*, float** %3
%100 = load i32, i32* %5
%101 = add nsw i32 %100, 4
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds float, float* %99, i64 %102
%104 = load float, float* %103
store float %104, float* %9
%105 = load float, float* %8
%106 = load float, float* %9
%107 = fadd float %105, %106
%108 = load float*, float** %3
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
store float %107, float* %111
%112 = load float, float* %8
%113 = load float, float* %9
%114 = fsub float %112, %113
%115 = load float*, float** %3
%116 = load i32, i32* %5
%117 = add nsw i32 %116, 4
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %115, i64 %118
store float %114, float* %119
%120 = load float*, float** %3
%121 = load i32, i32* %5
%122 = add nsw i32 %121, 2
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %120, i64 %123
%125 = load float, float* %124
store float %125, float* %8
%126 = load float*, float** %3
%127 = load i32, i32* %5
%128 = add nsw i32 %127, 6
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %126, i64 %129
%131 = load float, float* %130
store float %131, float* %9
%132 = load float, float* %8
%133 = load float, float* %9
%134 = fadd float %132, %133
%135 = load float*, float** %3
%136 = load i32, i32* %5
%137 = add nsw i32 %136, 2
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %135, i64 %138
store float %134, float* %139
%140 = load float, float* %8
%141 = load float, float* %9
%142 = fsub float %140, %141
%143 = load float*, float** %3
%144 = load i32, i32* %5
%145 = add nsw i32 %144, 6
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %143, i64 %146
store float %142, float* %147
%148 = load float*, float** %3
%149 = load i32, i32* %5
%150 = add nsw i32 %149, 1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %148, i64 %151
%153 = load float, float* %152
store float %153, float* %8
%154 = load float*, float** %3
%155 = load i32, i32* %5
%156 = add nsw i32 %155, 5
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float, float* %154, i64 %157
%159 = load float, float* %158
%160 = load float*, float** %3
%161 = load i32, i32* %5
%162 = add nsw i32 %161, 7
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds float, float* %160, i64 %163
%165 = load float, float* %164
%166 = fadd float %159, %165
%167 = fmul float 0x3FE6A09E60000000, %166
store float %167, float* %10
%168 = load float*, float** %3
%169 = load i32, i32* %5
%170 = add nsw i32 %169, 5
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %168, i64 %171
%173 = load float, float* %172
%174 = load float*, float** %3
%175 = load i32, i32* %5
%176 = add nsw i32 %175, 7
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %174, i64 %177
%179 = load float, float* %178
%180 = fsub float %173, %179
%181 = fmul float 0x3FE6A09E60000000, %180
store float %181, float* %11
%182 = load float, float* %8
%183 = load float, float* %10
%184 = fadd float %182, %183
%185 = load float*, float** %3
%186 = load i32, i32* %5
%187 = add nsw i32 %186, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds float, float* %185, i64 %188
store float %184, float* %189
%190 = load float, float* %8
%191 = load float, float* %10
%192 = fsub float %190, %191
%193 = load float*, float** %3
%194 = load i32, i32* %5
%195 = add nsw i32 %194, 5
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %193, i64 %196
store float %192, float* %197
%198 = load float*, float** %3
%199 = load i32, i32* %5
%200 = add nsw i32 %199, 3
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds float, float* %198, i64 %201
%203 = load float, float* %202
store float %203, float* %8
%204 = load float, float* %8
%205 = load float, float* %11
%206 = fadd float %204, %205
%207 = load float*, float** %3
%208 = load i32, i32* %5
%209 = add nsw i32 %208, 3
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %207, i64 %210
store float %206, float* %211
%212 = load float, float* %8
%213 = load float, float* %11
%214 = fsub float %212, %213
%215 = load float*, float** %3
%216 = load i32, i32* %5
%217 = add nsw i32 %216, 7
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %215, i64 %218
store float %214, float* %219
br label %220
220: ; preds = %93
%221 = load i32, i32* %5
%222 = add nsw i32 %221, 8
store i32 %222, i32* %5
br label %90
223: ; preds = %90
store i32 0, i32* %5
br label %224
224: ; preds = %398, %223
%225 = load i32, i32* %5
%226 = icmp slt i32 %225, 512
br i1 %226, label %227, label %401
227: ; preds = %224
store i32 32, i32* %7
%228 = load float*, float** %3
%229 = load i32, i32* %5
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %228, i64 %230
%232 = load float, float* %231
store float %232, float* %8
%233 = load float*, float** %3
%234 = load i32, i32* %5
%235 = add nsw i32 %234, 8
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %233, i64 %236
%238 = load float, float* %237
store float %238, float* %9
%239 = load float, float* %8
%240 = load float, float* %9
%241 = fadd float %239, %240
%242 = load float*, float** %3
%243 = load i32, i32* %5
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds float, float* %242, i64 %244
store float %241, float* %245
%246 = load float, float* %8
%247 = load float, float* %9
%248 = fsub float %246, %247
%249 = load float*, float** %3
%250 = load i32, i32* %5
%251 = add nsw i32 %250, 8
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %249, i64 %252
store float %248, float* %253
%254 = load float*, float** %3
%255 = load i32, i32* %5
%256 = add nsw i32 %255, 4
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %254, i64 %257
%259 = load float, float* %258
store float %259, float* %8
%260 = load float*, float** %3
%261 = load i32, i32* %5
%262 = add nsw i32 %261, 12
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %260, i64 %263
%265 = load float, float* %264
store float %265, float* %9
%266 = load float, float* %8
%267 = load float, float* %9
%268 = fadd float %266, %267
%269 = load float*, float** %3
%270 = load i32, i32* %5
%271 = add nsw i32 %270, 4
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %269, i64 %272
store float %268, float* %273
%274 = load float, float* %8
%275 = load float, float* %9
%276 = fsub float %274, %275
%277 = load float*, float** %3
%278 = load i32, i32* %5
%279 = add nsw i32 %278, 12
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %277, i64 %280
store float %276, float* %281
store i32 1, i32* %6
br label %282
282: ; preds = %394, %227
%283 = load i32, i32* %6
%284 = icmp slt i32 %283, 4
br i1 %284, label %285, label %397
285: ; preds = %282
%286 = load float*, float** %4
%287 = load i32, i32* %7
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %286, i64 %288
%290 = load float, float* %289
store float %290, float* %12
%291 = load float*, float** %4
%292 = load i32, i32* %7
%293 = add nsw i32 %292, 128
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %291, i64 %294
%296 = load float, float* %295
store float %296, float* %13
%297 = load float*, float** %3
%298 = load i32, i32* %5
%299 = load i32, i32* %6
%300 = add nsw i32 %298, %299
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %297, i64 %301
%303 = load float, float* %302
store float %303, float* %8
%304 = load float*, float** %3
%305 = load i32, i32* %5
%306 = load i32, i32* %6
%307 = sub nsw i32 %305, %306
%308 = add nsw i32 %307, 8
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %304, i64 %309
%311 = load float, float* %310
store float %311, float* %9
%312 = load float*, float** %3
%313 = load i32, i32* %5
%314 = load i32, i32* %6
%315 = add nsw i32 %313, %314
%316 = add nsw i32 %315, 8
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds float, float* %312, i64 %317
%319 = load float, float* %318
%320 = load float, float* %13
%321 = load float*, float** %3
%322 = load i32, i32* %5
%323 = load i32, i32* %6
%324 = sub nsw i32 %322, %323
%325 = add nsw i32 %324, 16
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %321, i64 %326
%328 = load float, float* %327
%329 = load float, float* %12
%330 = fmul float %328, %329
%331 = call float @llvm.fmuladd.f32(float %319, float %320, float %330)
store float %331, float* %10
%332 = load float*, float** %3
%333 = load i32, i32* %5
%334 = load i32, i32* %6
%335 = add nsw i32 %333, %334
%336 = add nsw i32 %335, 8
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %332, i64 %337
%339 = load float, float* %338
%340 = load float, float* %12
%341 = load float*, float** %3
%342 = load i32, i32* %5
%343 = load i32, i32* %6
%344 = sub nsw i32 %342, %343
%345 = add nsw i32 %344, 16
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %341, i64 %346
%348 = load float, float* %347
%349 = load float, float* %13
%350 = fmul float %348, %349
%351 = fneg float %350
%352 = call float @llvm.fmuladd.f32(float %339, float %340, float %351)
store float %352, float* %11
%353 = load i32, i32* %7
%354 = add nsw i32 %353, 32
store i32 %354, i32* %7
%355 = load float, float* %8
%356 = load float, float* %10
%357 = fadd float %355, %356
%358 = load float*, float** %3
%359 = load i32, i32* %5
%360 = load i32, i32* %6
%361 = add nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %358, i64 %362
store float %357, float* %363
%364 = load float, float* %8
%365 = load float, float* %10
%366 = fsub float %364, %365
%367 = load float*, float** %3
%368 = load i32, i32* %5
%369 = load i32, i32* %6
%370 = add nsw i32 %368, %369
%371 = add nsw i32 %370, 8
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %367, i64 %372
store float %366, float* %373
%374 = load float, float* %9
%375 = load float, float* %11
%376 = fadd float %374, %375
%377 = load float*, float** %3
%378 = load i32, i32* %5
%379 = load i32, i32* %6
%380 = sub nsw i32 %378, %379
%381 = add nsw i32 %380, 8
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float, float* %377, i64 %382
store float %376, float* %383
%384 = load float, float* %9
%385 = load float, float* %11
%386 = fsub float %384, %385
%387 = load float*, float** %3
%388 = load i32, i32* %5
%389 = load i32, i32* %6
%390 = sub nsw i32 %388, %389
%391 = add nsw i32 %390, 16
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds float, float* %387, i64 %392
store float %386, float* %393
br label %394
394: ; preds = %285
%395 = load i32, i32* %6
%396 = add nsw i32 %395, 1
store i32 %396, i32* %6
br label %282
397: ; preds = %282
br label %398
398: ; preds = %397
%399 = load i32, i32* %5
%400 = add nsw i32 %399, 16
store i32 %400, i32* %5
br label %224
401: ; preds = %224
store i32 0, i32* %5
br label %402
402: ; preds = %576, %401
%403 = load i32, i32* %5
%404 = icmp slt i32 %403, 512
br i1 %404, label %405, label %579
405: ; preds = %402
store i32 16, i32* %7
%406 = load float*, float** %3
%407 = load i32, i32* %5
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds float, float* %406, i64 %408
%410 = load float, float* %409
store float %410, float* %8
%411 = load float*, float** %3
%412 = load i32, i32* %5
%413 = add nsw i32 %412, 16
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds float, float* %411, i64 %414
%416 = load float, float* %415
store float %416, float* %9
%417 = load float, float* %8
%418 = load float, float* %9
%419 = fadd float %417, %418
%420 = load float*, float** %3
%421 = load i32, i32* %5
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float, float* %420, i64 %422
store float %419, float* %423
%424 = load float, float* %8
%425 = load float, float* %9
%426 = fsub float %424, %425
%427 = load float*, float** %3
%428 = load i32, i32* %5
%429 = add nsw i32 %428, 16
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds float, float* %427, i64 %430
store float %426, float* %431
%432 = load float*, float** %3
%433 = load i32, i32* %5
%434 = add nsw i32 %433, 8
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %432, i64 %435
%437 = load float, float* %436
store float %437, float* %8
%438 = load float*, float** %3
%439 = load i32, i32* %5
%440 = add nsw i32 %439, 24
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds float, float* %438, i64 %441
%443 = load float, float* %442
store float %443, float* %9
%444 = load float, float* %8
%445 = load float, float* %9
%446 = fadd float %444, %445
%447 = load float*, float** %3
%448 = load i32, i32* %5
%449 = add nsw i32 %448, 8
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %447, i64 %450
store float %446, float* %451
%452 = load float, float* %8
%453 = load float, float* %9
%454 = fsub float %452, %453
%455 = load float*, float** %3
%456 = load i32, i32* %5
%457 = add nsw i32 %456, 24
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds float, float* %455, i64 %458
store float %454, float* %459
store i32 1, i32* %6
br label %460
460: ; preds = %572, %405
%461 = load i32, i32* %6
%462 = icmp slt i32 %461, 8
br i1 %462, label %463, label %575
463: ; preds = %460
%464 = load float*, float** %4
%465 = load i32, i32* %7
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds float, float* %464, i64 %466
%468 = load float, float* %467
store float %468, float* %12
%469 = load float*, float** %4
%470 = load i32, i32* %7
%471 = add nsw i32 %470, 128
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float, float* %469, i64 %472
%474 = load float, float* %473
store float %474, float* %13
%475 = load float*, float** %3
%476 = load i32, i32* %5
%477 = load i32, i32* %6
%478 = add nsw i32 %476, %477
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds float, float* %475, i64 %479
%481 = load float, float* %480
store float %481, float* %8
%482 = load float*, float** %3
%483 = load i32, i32* %5
%484 = load i32, i32* %6
%485 = sub nsw i32 %483, %484
%486 = add nsw i32 %485, 16
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %482, i64 %487
%489 = load float, float* %488
store float %489, float* %9
%490 = load float*, float** %3
%491 = load i32, i32* %5
%492 = load i32, i32* %6
%493 = add nsw i32 %491, %492
%494 = add nsw i32 %493, 16
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds float, float* %490, i64 %495
%497 = load float, float* %496
%498 = load float, float* %13
%499 = load float*, float** %3
%500 = load i32, i32* %5
%501 = load i32, i32* %6
%502 = sub nsw i32 %500, %501
%503 = add nsw i32 %502, 32
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %499, i64 %504
%506 = load float, float* %505
%507 = load float, float* %12
%508 = fmul float %506, %507
%509 = call float @llvm.fmuladd.f32(float %497, float %498, float %508)
store float %509, float* %10
%510 = load float*, float** %3
%511 = load i32, i32* %5
%512 = load i32, i32* %6
%513 = add nsw i32 %511, %512
%514 = add nsw i32 %513, 16
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float, float* %510, i64 %515
%517 = load float, float* %516
%518 = load float, float* %12
%519 = load float*, float** %3
%520 = load i32, i32* %5
%521 = load i32, i32* %6
%522 = sub nsw i32 %520, %521
%523 = add nsw i32 %522, 32
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %519, i64 %524
%526 = load float, float* %525
%527 = load float, float* %13
%528 = fmul float %526, %527
%529 = fneg float %528
%530 = call float @llvm.fmuladd.f32(float %517, float %518, float %529)
store float %530, float* %11
%531 = load i32, i32* %7
%532 = add nsw i32 %531, 16
store i32 %532, i32* %7
%533 = load float, float* %8
%534 = load float, float* %10
%535 = fadd float %533, %534
%536 = load float*, float** %3
%537 = load i32, i32* %5
%538 = load i32, i32* %6
%539 = add nsw i32 %537, %538
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds float, float* %536, i64 %540
store float %535, float* %541
%542 = load float, float* %8
%543 = load float, float* %10
%544 = fsub float %542, %543
%545 = load float*, float** %3
%546 = load i32, i32* %5
%547 = load i32, i32* %6
%548 = add nsw i32 %546, %547
%549 = add nsw i32 %548, 16
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %545, i64 %550
store float %544, float* %551
%552 = load float, float* %9
%553 = load float, float* %11
%554 = fadd float %552, %553
%555 = load float*, float** %3
%556 = load i32, i32* %5
%557 = load i32, i32* %6
%558 = sub nsw i32 %556, %557
%559 = add nsw i32 %558, 16
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds float, float* %555, i64 %560
store float %554, float* %561
%562 = load float, float* %9
%563 = load float, float* %11
%564 = fsub float %562, %563
%565 = load float*, float** %3
%566 = load i32, i32* %5
%567 = load i32, i32* %6
%568 = sub nsw i32 %566, %567
%569 = add nsw i32 %568, 32
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds float, float* %565, i64 %570
store float %564, float* %571
br label %572
572: ; preds = %463
%573 = load i32, i32* %6
%574 = add nsw i32 %573, 1
store i32 %574, i32* %6
br label %460
575: ; preds = %460
br label %576
576: ; preds = %575
%577 = load i32, i32* %5
%578 = add nsw i32 %577, 32
store i32 %578, i32* %5
br label %402
579: ; preds = %402
store i32 0, i32* %5
br label %580
580: ; preds = %754, %579
%581 = load i32, i32* %5
%582 = icmp slt i32 %581, 512
br i1 %582, label %583, label %757
583: ; preds = %580
store i32 8, i32* %7
%584 = load float*, float** %3
%585 = load i32, i32* %5
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds float, float* %584, i64 %586
%588 = load float, float* %587
store float %588, float* %8
%589 = load float*, float** %3
%590 = load i32, i32* %5
%591 = add nsw i32 %590, 32
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds float, float* %589, i64 %592
%594 = load float, float* %593
store float %594, float* %9
%595 = load float, float* %8
%596 = load float, float* %9
%597 = fadd float %595, %596
%598 = load float*, float** %3
%599 = load i32, i32* %5
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds float, float* %598, i64 %600
store float %597, float* %601
%602 = load float, float* %8
%603 = load float, float* %9
%604 = fsub float %602, %603
%605 = load float*, float** %3
%606 = load i32, i32* %5
%607 = add nsw i32 %606, 32
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds float, float* %605, i64 %608
store float %604, float* %609
%610 = load float*, float** %3
%611 = load i32, i32* %5
%612 = add nsw i32 %611, 16
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds float, float* %610, i64 %613
%615 = load float, float* %614
store float %615, float* %8
%616 = load float*, float** %3
%617 = load i32, i32* %5
%618 = add nsw i32 %617, 48
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds float, float* %616, i64 %619
%621 = load float, float* %620
store float %621, float* %9
%622 = load float, float* %8
%623 = load float, float* %9
%624 = fadd float %622, %623
%625 = load float*, float** %3
%626 = load i32, i32* %5
%627 = add nsw i32 %626, 16
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds float, float* %625, i64 %628
store float %624, float* %629
%630 = load float, float* %8
%631 = load float, float* %9
%632 = fsub float %630, %631
%633 = load float*, float** %3
%634 = load i32, i32* %5
%635 = add nsw i32 %634, 48
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds float, float* %633, i64 %636
store float %632, float* %637
store i32 1, i32* %6
br label %638
638: ; preds = %750, %583
%639 = load i32, i32* %6
%640 = icmp slt i32 %639, 16
br i1 %640, label %641, label %753
641: ; preds = %638
%642 = load float*, float** %4
%643 = load i32, i32* %7
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds float, float* %642, i64 %644
%646 = load float, float* %645
store float %646, float* %12
%647 = load float*, float** %4
%648 = load i32, i32* %7
%649 = add nsw i32 %648, 128
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds float, float* %647, i64 %650
%652 = load float, float* %651
store float %652, float* %13
%653 = load float*, float** %3
%654 = load i32, i32* %5
%655 = load i32, i32* %6
%656 = add nsw i32 %654, %655
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds float, float* %653, i64 %657
%659 = load float, float* %658
store float %659, float* %8
%660 = load float*, float** %3
%661 = load i32, i32* %5
%662 = load i32, i32* %6
%663 = sub nsw i32 %661, %662
%664 = add nsw i32 %663, 32
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds float, float* %660, i64 %665
%667 = load float, float* %666
store float %667, float* %9
%668 = load float*, float** %3
%669 = load i32, i32* %5
%670 = load i32, i32* %6
%671 = add nsw i32 %669, %670
%672 = add nsw i32 %671, 32
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds float, float* %668, i64 %673
%675 = load float, float* %674
%676 = load float, float* %13
%677 = load float*, float** %3
%678 = load i32, i32* %5
%679 = load i32, i32* %6
%680 = sub nsw i32 %678, %679
%681 = add nsw i32 %680, 64
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds float, float* %677, i64 %682
%684 = load float, float* %683
%685 = load float, float* %12
%686 = fmul float %684, %685
%687 = call float @llvm.fmuladd.f32(float %675, float %676, float %686)
store float %687, float* %10
%688 = load float*, float** %3
%689 = load i32, i32* %5
%690 = load i32, i32* %6
%691 = add nsw i32 %689, %690
%692 = add nsw i32 %691, 32
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds float, float* %688, i64 %693
%695 = load float, float* %694
%696 = load float, float* %12
%697 = load float*, float** %3
%698 = load i32, i32* %5
%699 = load i32, i32* %6
%700 = sub nsw i32 %698, %699
%701 = add nsw i32 %700, 64
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %697, i64 %702
%704 = load float, float* %703
%705 = load float, float* %13
%706 = fmul float %704, %705
%707 = fneg float %706
%708 = call float @llvm.fmuladd.f32(float %695, float %696, float %707)
store float %708, float* %11
%709 = load i32, i32* %7
%710 = add nsw i32 %709, 8
store i32 %710, i32* %7
%711 = load float, float* %8
%712 = load float, float* %10
%713 = fadd float %711, %712
%714 = load float*, float** %3
%715 = load i32, i32* %5
%716 = load i32, i32* %6
%717 = add nsw i32 %715, %716
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds float, float* %714, i64 %718
store float %713, float* %719
%720 = load float, float* %8
%721 = load float, float* %10
%722 = fsub float %720, %721
%723 = load float*, float** %3
%724 = load i32, i32* %5
%725 = load i32, i32* %6
%726 = add nsw i32 %724, %725
%727 = add nsw i32 %726, 32
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds float, float* %723, i64 %728
store float %722, float* %729
%730 = load float, float* %9
%731 = load float, float* %11
%732 = fadd float %730, %731
%733 = load float*, float** %3
%734 = load i32, i32* %5
%735 = load i32, i32* %6
%736 = sub nsw i32 %734, %735
%737 = add nsw i32 %736, 32
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds float, float* %733, i64 %738
store float %732, float* %739
%740 = load float, float* %9
%741 = load float, float* %11
%742 = fsub float %740, %741
%743 = load float*, float** %3
%744 = load i32, i32* %5
%745 = load i32, i32* %6
%746 = sub nsw i32 %744, %745
%747 = add nsw i32 %746, 64
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds float, float* %743, i64 %748
store float %742, float* %749
br label %750
750: ; preds = %641
%751 = load i32, i32* %6
%752 = add nsw i32 %751, 1
store i32 %752, i32* %6
br label %638
753: ; preds = %638
br label %754
754: ; preds = %753
%755 = load i32, i32* %5
%756 = add nsw i32 %755, 64
store i32 %756, i32* %5
br label %580
757: ; preds = %580
store i32 0, i32* %5
br label %758
758: ; preds = %932, %757
%759 = load i32, i32* %5
%760 = icmp slt i32 %759, 512
br i1 %760, label %761, label %935
761: ; preds = %758
store i32 4, i32* %7
%762 = load float*, float** %3
%763 = load i32, i32* %5
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds float, float* %762, i64 %764
%766 = load float, float* %765
store float %766, float* %8
%767 = load float*, float** %3
%768 = load i32, i32* %5
%769 = add nsw i32 %768, 64
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds float, float* %767, i64 %770
%772 = load float, float* %771
store float %772, float* %9
%773 = load float, float* %8
%774 = load float, float* %9
%775 = fadd float %773, %774
%776 = load float*, float** %3
%777 = load i32, i32* %5
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds float, float* %776, i64 %778
store float %775, float* %779
%780 = load float, float* %8
%781 = load float, float* %9
%782 = fsub float %780, %781
%783 = load float*, float** %3
%784 = load i32, i32* %5
%785 = add nsw i32 %784, 64
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds float, float* %783, i64 %786
store float %782, float* %787
%788 = load float*, float** %3
%789 = load i32, i32* %5
%790 = add nsw i32 %789, 32
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds float, float* %788, i64 %791
%793 = load float, float* %792
store float %793, float* %8
%794 = load float*, float** %3
%795 = load i32, i32* %5
%796 = add nsw i32 %795, 96
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds float, float* %794, i64 %797
%799 = load float, float* %798
store float %799, float* %9
%800 = load float, float* %8
%801 = load float, float* %9
%802 = fadd float %800, %801
%803 = load float*, float** %3
%804 = load i32, i32* %5
%805 = add nsw i32 %804, 32
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds float, float* %803, i64 %806
store float %802, float* %807
%808 = load float, float* %8
%809 = load float, float* %9
%810 = fsub float %808, %809
%811 = load float*, float** %3
%812 = load i32, i32* %5
%813 = add nsw i32 %812, 96
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %811, i64 %814
store float %810, float* %815
store i32 1, i32* %6
br label %816
816: ; preds = %928, %761
%817 = load i32, i32* %6
%818 = icmp slt i32 %817, 32
br i1 %818, label %819, label %931
819: ; preds = %816
%820 = load float*, float** %4
%821 = load i32, i32* %7
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds float, float* %820, i64 %822
%824 = load float, float* %823
store float %824, float* %12
%825 = load float*, float** %4
%826 = load i32, i32* %7
%827 = add nsw i32 %826, 128
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float, float* %825, i64 %828
%830 = load float, float* %829
store float %830, float* %13
%831 = load float*, float** %3
%832 = load i32, i32* %5
%833 = load i32, i32* %6
%834 = add nsw i32 %832, %833
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds float, float* %831, i64 %835
%837 = load float, float* %836
store float %837, float* %8
%838 = load float*, float** %3
%839 = load i32, i32* %5
%840 = load i32, i32* %6
%841 = sub nsw i32 %839, %840
%842 = add nsw i32 %841, 64
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds float, float* %838, i64 %843
%845 = load float, float* %844
store float %845, float* %9
%846 = load float*, float** %3
%847 = load i32, i32* %5
%848 = load i32, i32* %6
%849 = add nsw i32 %847, %848
%850 = add nsw i32 %849, 64
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds float, float* %846, i64 %851
%853 = load float, float* %852
%854 = load float, float* %13
%855 = load float*, float** %3
%856 = load i32, i32* %5
%857 = load i32, i32* %6
%858 = sub nsw i32 %856, %857
%859 = add nsw i32 %858, 128
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds float, float* %855, i64 %860
%862 = load float, float* %861
%863 = load float, float* %12
%864 = fmul float %862, %863
%865 = call float @llvm.fmuladd.f32(float %853, float %854, float %864)
store float %865, float* %10
%866 = load float*, float** %3
%867 = load i32, i32* %5
%868 = load i32, i32* %6
%869 = add nsw i32 %867, %868
%870 = add nsw i32 %869, 64
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds float, float* %866, i64 %871
%873 = load float, float* %872
%874 = load float, float* %12
%875 = load float*, float** %3
%876 = load i32, i32* %5
%877 = load i32, i32* %6
%878 = sub nsw i32 %876, %877
%879 = add nsw i32 %878, 128
%880 = sext i32 %879 to i64
%881 = getelementptr inbounds float, float* %875, i64 %880
%882 = load float, float* %881
%883 = load float, float* %13
%884 = fmul float %882, %883
%885 = fneg float %884
%886 = call float @llvm.fmuladd.f32(float %873, float %874, float %885)
store float %886, float* %11
%887 = load i32, i32* %7
%888 = add nsw i32 %887, 4
store i32 %888, i32* %7
%889 = load float, float* %8
%890 = load float, float* %10
%891 = fadd float %889, %890
%892 = load float*, float** %3
%893 = load i32, i32* %5
%894 = load i32, i32* %6
%895 = add nsw i32 %893, %894
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds float, float* %892, i64 %896
store float %891, float* %897
%898 = load float, float* %8
%899 = load float, float* %10
%900 = fsub float %898, %899
%901 = load float*, float** %3
%902 = load i32, i32* %5
%903 = load i32, i32* %6
%904 = add nsw i32 %902, %903
%905 = add nsw i32 %904, 64
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds float, float* %901, i64 %906
store float %900, float* %907
%908 = load float, float* %9
%909 = load float, float* %11
%910 = fadd float %908, %909
%911 = load float*, float** %3
%912 = load i32, i32* %5
%913 = load i32, i32* %6
%914 = sub nsw i32 %912, %913
%915 = add nsw i32 %914, 64
%916 = sext i32 %915 to i64
%917 = getelementptr inbounds float, float* %911, i64 %916
store float %910, float* %917
%918 = load float, float* %9
%919 = load float, float* %11
%920 = fsub float %918, %919
%921 = load float*, float** %3
%922 = load i32, i32* %5
%923 = load i32, i32* %6
%924 = sub nsw i32 %922, %923
%925 = add nsw i32 %924, 128
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds float, float* %921, i64 %926
store float %920, float* %927
br label %928
928: ; preds = %819
%929 = load i32, i32* %6
%930 = add nsw i32 %929, 1
store i32 %930, i32* %6
br label %816
931: ; preds = %816
br label %932
932: ; preds = %931
%933 = load i32, i32* %5
%934 = add nsw i32 %933, 128
store i32 %934, i32* %5
br label %758
935: ; preds = %758
store i32 0, i32* %5
br label %936
936: ; preds = %1110, %935
%937 = load i32, i32* %5
%938 = icmp slt i32 %937, 512
br i1 %938, label %939, label %1113
939: ; preds = %936
store i32 2, i32* %7
%940 = load float*, float** %3
%941 = load i32, i32* %5
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds float, float* %940, i64 %942
%944 = load float, float* %943
store float %944, float* %8
%945 = load float*, float** %3
%946 = load i32, i32* %5
%947 = add nsw i32 %946, 128
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds float, float* %945, i64 %948
%950 = load float, float* %949
store float %950, float* %9
%951 = load float, float* %8
%952 = load float, float* %9
%953 = fadd float %951, %952
%954 = load float*, float** %3
%955 = load i32, i32* %5
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds float, float* %954, i64 %956
store float %953, float* %957
%958 = load float, float* %8
%959 = load float, float* %9
%960 = fsub float %958, %959
%961 = load float*, float** %3
%962 = load i32, i32* %5
%963 = add nsw i32 %962, 128
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds float, float* %961, i64 %964
store float %960, float* %965
%966 = load float*, float** %3
%967 = load i32, i32* %5
%968 = add nsw i32 %967, 64
%969 = sext i32 %968 to i64
%970 = getelementptr inbounds float, float* %966, i64 %969
%971 = load float, float* %970
store float %971, float* %8
%972 = load float*, float** %3
%973 = load i32, i32* %5
%974 = add nsw i32 %973, 192
%975 = sext i32 %974 to i64
%976 = getelementptr inbounds float, float* %972, i64 %975
%977 = load float, float* %976
store float %977, float* %9
%978 = load float, float* %8
%979 = load float, float* %9
%980 = fadd float %978, %979
%981 = load float*, float** %3
%982 = load i32, i32* %5
%983 = add nsw i32 %982, 64
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds float, float* %981, i64 %984
store float %980, float* %985
%986 = load float, float* %8
%987 = load float, float* %9
%988 = fsub float %986, %987
%989 = load float*, float** %3
%990 = load i32, i32* %5
%991 = add nsw i32 %990, 192
%992 = sext i32 %991 to i64
%993 = getelementptr inbounds float, float* %989, i64 %992
store float %988, float* %993
store i32 1, i32* %6
br label %994
994: ; preds = %1106, %939
%995 = load i32, i32* %6
%996 = icmp slt i32 %995, 64
br i1 %996, label %997, label %1109
997: ; preds = %994
%998 = load float*, float** %4
%999 = load i32, i32* %7
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds float, float* %998, i64 %1000
%1002 = load float, float* %1001
store float %1002, float* %12
%1003 = load float*, float** %4
%1004 = load i32, i32* %7
%1005 = add nsw i32 %1004, 128
%1006 = sext i32 %1005 to i64
%1007 = getelementptr inbounds float, float* %1003, i64 %1006
%1008 = load float, float* %1007
store float %1008, float* %13
%1009 = load float*, float** %3
%1010 = load i32, i32* %5
%1011 = load i32, i32* %6
%1012 = add nsw i32 %1010, %1011
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds float, float* %1009, i64 %1013
%1015 = load float, float* %1014
store float %1015, float* %8
%1016 = load float*, float** %3
%1017 = load i32, i32* %5
%1018 = load i32, i32* %6
%1019 = sub nsw i32 %1017, %1018
%1020 = add nsw i32 %1019, 128
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds float, float* %1016, i64 %1021
%1023 = load float, float* %1022
store float %1023, float* %9
%1024 = load float*, float** %3
%1025 = load i32, i32* %5
%1026 = load i32, i32* %6
%1027 = add nsw i32 %1025, %1026
%1028 = add nsw i32 %1027, 128
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds float, float* %1024, i64 %1029
%1031 = load float, float* %1030
%1032 = load float, float* %13
%1033 = load float*, float** %3
%1034 = load i32, i32* %5
%1035 = load i32, i32* %6
%1036 = sub nsw i32 %1034, %1035
%1037 = add nsw i32 %1036, 256
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds float, float* %1033, i64 %1038
%1040 = load float, float* %1039
%1041 = load float, float* %12
%1042 = fmul float %1040, %1041
%1043 = call float @llvm.fmuladd.f32(float %1031, float %1032, float %1042)
store float %1043, float* %10
%1044 = load float*, float** %3
%1045 = load i32, i32* %5
%1046 = load i32, i32* %6
%1047 = add nsw i32 %1045, %1046
%1048 = add nsw i32 %1047, 128
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds float, float* %1044, i64 %1049
%1051 = load float, float* %1050
%1052 = load float, float* %12
%1053 = load float*, float** %3
%1054 = load i32, i32* %5
%1055 = load i32, i32* %6
%1056 = sub nsw i32 %1054, %1055
%1057 = add nsw i32 %1056, 256
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds float, float* %1053, i64 %1058
%1060 = load float, float* %1059
%1061 = load float, float* %13
%1062 = fmul float %1060, %1061
%1063 = fneg float %1062
%1064 = call float @llvm.fmuladd.f32(float %1051, float %1052, float %1063)
store float %1064, float* %11
%1065 = load i32, i32* %7
%1066 = add nsw i32 %1065, 2
store i32 %1066, i32* %7
%1067 = load float, float* %8
%1068 = load float, float* %10
%1069 = fadd float %1067, %1068
%1070 = load float*, float** %3
%1071 = load i32, i32* %5
%1072 = load i32, i32* %6
%1073 = add nsw i32 %1071, %1072
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds float, float* %1070, i64 %1074
store float %1069, float* %1075
%1076 = load float, float* %8
%1077 = load float, float* %10
%1078 = fsub float %1076, %1077
%1079 = load float*, float** %3
%1080 = load i32, i32* %5
%1081 = load i32, i32* %6
%1082 = add nsw i32 %1080, %1081
%1083 = add nsw i32 %1082, 128
%1084 = sext i32 %1083 to i64
%1085 = getelementptr inbounds float, float* %1079, i64 %1084
store float %1078, float* %1085
%1086 = load float, float* %9
%1087 = load float, float* %11
%1088 = fadd float %1086, %1087
%1089 = load float*, float** %3
%1090 = load i32, i32* %5
%1091 = load i32, i32* %6
%1092 = sub nsw i32 %1090, %1091
%1093 = add nsw i32 %1092, 128
%1094 = sext i32 %1093 to i64
%1095 = getelementptr inbounds float, float* %1089, i64 %1094
store float %1088, float* %1095
%1096 = load float, float* %9
%1097 = load float, float* %11
%1098 = fsub float %1096, %1097
%1099 = load float*, float** %3
%1100 = load i32, i32* %5
%1101 = load i32, i32* %6
%1102 = sub nsw i32 %1100, %1101
%1103 = add nsw i32 %1102, 256
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds float, float* %1099, i64 %1104
store float %1098, float* %1105
br label %1106
1106: ; preds = %997
%1107 = load i32, i32* %6
%1108 = add nsw i32 %1107, 1
store i32 %1108, i32* %6
br label %994
1109: ; preds = %994
br label %1110
1110: ; preds = %1109
%1111 = load i32, i32* %5
%1112 = add nsw i32 %1111, 256
store i32 %1112, i32* %5
br label %936
1113: ; preds = %936
store i32 1, i32* %7
%1114 = load float*, float** %3
%1115 = getelementptr inbounds float, float* %1114, i64 0
%1116 = load float, float* %1115
store float %1116, float* %8
%1117 = load float*, float** %3
%1118 = getelementptr inbounds float, float* %1117, i64 256
%1119 = load float, float* %1118
store float %1119, float* %9
%1120 = load float, float* %8
%1121 = load float, float* %9
%1122 = fadd float %1120, %1121
%1123 = load float*, float** %3
%1124 = getelementptr inbounds float, float* %1123, i64 0
store float %1122, float* %1124
%1125 = load float, float* %8
%1126 = load float, float* %9
%1127 = fsub float %1125, %1126
%1128 = load float*, float** %3
%1129 = getelementptr inbounds float, float* %1128, i64 256
store float %1127, float* %1129
%1130 = load float*, float** %3
%1131 = getelementptr inbounds float, float* %1130, i64 128
%1132 = load float, float* %1131
store float %1132, float* %8
%1133 = load float*, float** %3
%1134 = getelementptr inbounds float, float* %1133, i64 384
%1135 = load float, float* %1134
store float %1135, float* %9
%1136 = load float, float* %8
%1137 = load float, float* %9
%1138 = fadd float %1136, %1137
%1139 = load float*, float** %3
%1140 = getelementptr inbounds float, float* %1139, i64 128
store float %1138, float* %1140
%1141 = load float, float* %8
%1142 = load float, float* %9
%1143 = fsub float %1141, %1142
%1144 = load float*, float** %3
%1145 = getelementptr inbounds float, float* %1144, i64 384
store float %1143, float* %1145
store i32 1, i32* %6
br label %1146
1146: ; preds = %1243, %1113
%1147 = load i32, i32* %6
%1148 = icmp slt i32 %1147, 128
br i1 %1148, label %1149, label %1246
1149: ; preds = %1146
%1150 = load float*, float** %4
%1151 = load i32, i32* %7
%1152 = sext i32 %1151 to i64
%1153 = getelementptr inbounds float, float* %1150, i64 %1152
%1154 = load float, float* %1153
store float %1154, float* %12
%1155 = load float*, float** %4
%1156 = load i32, i32* %7
%1157 = add nsw i32 %1156, 128
%1158 = sext i32 %1157 to i64
%1159 = getelementptr inbounds float, float* %1155, i64 %1158
%1160 = load float, float* %1159
store float %1160, float* %13
%1161 = load float*, float** %3
%1162 = load i32, i32* %6
%1163 = sext i32 %1162 to i64
%1164 = getelementptr inbounds float, float* %1161, i64 %1163
%1165 = load float, float* %1164
store float %1165, float* %8
%1166 = load float*, float** %3
%1167 = load i32, i32* %6
%1168 = sub nsw i32 0, %1167
%1169 = add nsw i32 %1168, 256
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds float, float* %1166, i64 %1170
%1172 = load float, float* %1171
store float %1172, float* %9
%1173 = load float*, float** %3
%1174 = load i32, i32* %6
%1175 = add nsw i32 %1174, 256
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds float, float* %1173, i64 %1176
%1178 = load float, float* %1177
%1179 = load float, float* %13
%1180 = load float*, float** %3
%1181 = load i32, i32* %6
%1182 = sub nsw i32 0, %1181
%1183 = add nsw i32 %1182, 512
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds float, float* %1180, i64 %1184
%1186 = load float, float* %1185
%1187 = load float, float* %12
%1188 = fmul float %1186, %1187
%1189 = call float @llvm.fmuladd.f32(float %1178, float %1179, float %1188)
store float %1189, float* %10
%1190 = load float*, float** %3
%1191 = load i32, i32* %6
%1192 = add nsw i32 %1191, 256
%1193 = sext i32 %1192 to i64
%1194 = getelementptr inbounds float, float* %1190, i64 %1193
%1195 = load float, float* %1194
%1196 = load float, float* %12
%1197 = load float*, float** %3
%1198 = load i32, i32* %6
%1199 = sub nsw i32 0, %1198
%1200 = add nsw i32 %1199, 512
%1201 = sext i32 %1200 to i64
%1202 = getelementptr inbounds float, float* %1197, i64 %1201
%1203 = load float, float* %1202
%1204 = load float, float* %13
%1205 = fmul float %1203, %1204
%1206 = fneg float %1205
%1207 = call float @llvm.fmuladd.f32(float %1195, float %1196, float %1206)
store float %1207, float* %11
%1208 = load i32, i32* %7
%1209 = add nsw i32 %1208, 1
store i32 %1209, i32* %7
%1210 = load float, float* %8
%1211 = load float, float* %10
%1212 = fadd float %1210, %1211
%1213 = load float*, float** %3
%1214 = load i32, i32* %6
%1215 = sext i32 %1214 to i64
%1216 = getelementptr inbounds float, float* %1213, i64 %1215
store float %1212, float* %1216
%1217 = load float, float* %8
%1218 = load float, float* %10
%1219 = fsub float %1217, %1218
%1220 = load float*, float** %3
%1221 = load i32, i32* %6
%1222 = add nsw i32 %1221, 256
%1223 = sext i32 %1222 to i64
%1224 = getelementptr inbounds float, float* %1220, i64 %1223
store float %1219, float* %1224
%1225 = load float, float* %9
%1226 = load float, float* %11
%1227 = fadd float %1225, %1226
%1228 = load float*, float** %3
%1229 = load i32, i32* %6
%1230 = sub nsw i32 0, %1229
%1231 = add nsw i32 %1230, 256
%1232 = sext i32 %1231 to i64
%1233 = getelementptr inbounds float, float* %1228, i64 %1232
store float %1227, float* %1233
%1234 = load float, float* %9
%1235 = load float, float* %11
%1236 = fsub float %1234, %1235
%1237 = load float*, float** %3
%1238 = load i32, i32* %6
%1239 = sub nsw i32 0, %1238
%1240 = add nsw i32 %1239, 512
%1241 = sext i32 %1240 to i64
%1242 = getelementptr inbounds float, float* %1237, i64 %1241
store float %1236, float* %1242
br label %1243
1243: ; preds = %1149
%1244 = load i32, i32* %6
%1245 = add nsw i32 %1244, 1
store i32 %1245, i32* %6
br label %1146
1246: ; preds = %1146
ret void
}

LLVM IR (-O2):
define void @DFT512(float* %0, float* nocapture %1) {
br label %3
3: ; preds = %3, %2
%4 = phi i64 [ 0, %2 ], [ %82, %3 ]
%5 = shl i64 %4, 2
%6 = or i64 %5, 4
%7 = or i64 %5, 8
%8 = or i64 %5, 12
%9 = getelementptr inbounds float, float* %0, i64 %5
%10 = getelementptr inbounds float, float* %0, i64 %6
%11 = getelementptr inbounds float, float* %0, i64 %7
%12 = getelementptr inbounds float, float* %0, i64 %8
%13 = load float, float* %9
%14 = load float, float* %10
%15 = load float, float* %11
%16 = load float, float* %12
%17 = insertelement <4 x float> poison, float %13, i64 0
%18 = insertelement <4 x float> %17, float %14, i64 1
%19 = insertelement <4 x float> %18, float %15, i64 2
%20 = insertelement <4 x float> %19, float %16, i64 3
%21 = or i64 %5, 1
%22 = or i64 %5, 5
%23 = or i64 %5, 9
%24 = or i64 %5, 13
%25 = getelementptr inbounds float, float* %0, i64 %21
%26 = getelementptr inbounds float, float* %0, i64 %22
%27 = getelementptr inbounds float, float* %0, i64 %23
%28 = getelementptr inbounds float, float* %0, i64 %24
%29 = load float, float* %25
%30 = load float, float* %26
%31 = load float, float* %27
%32 = load float, float* %28
%33 = insertelement <4 x float> poison, float %29, i64 0
%34 = insertelement <4 x float> %33, float %30, i64 1
%35 = insertelement <4 x float> %34, float %31, i64 2
%36 = insertelement <4 x float> %35, float %32, i64 3
%37 = or i64 %5, 2
%38 = or i64 %5, 6
%39 = or i64 %5, 10
%40 = or i64 %5, 14
%41 = getelementptr inbounds float, float* %0, i64 %37
%42 = getelementptr inbounds float, float* %0, i64 %38
%43 = getelementptr inbounds float, float* %0, i64 %39
%44 = getelementptr inbounds float, float* %0, i64 %40
%45 = load float, float* %41
%46 = load float, float* %42
%47 = load float, float* %43
%48 = load float, float* %44
%49 = insertelement <4 x float> poison, float %45, i64 0
%50 = insertelement <4 x float> %49, float %46, i64 1
%51 = insertelement <4 x float> %50, float %47, i64 2
%52 = insertelement <4 x float> %51, float %48, i64 3
%53 = or i64 %5, 3
%54 = or i64 %5, 7
%55 = or i64 %5, 11
%56 = or i64 %5, 15
%57 = getelementptr inbounds float, float* %0, i64 %53
%58 = getelementptr inbounds float, float* %0, i64 %54
%59 = getelementptr inbounds float, float* %0, i64 %55
%60 = getelementptr inbounds float, float* %0, i64 %56
%61 = load float, float* %57
%62 = load float, float* %58
%63 = load float, float* %59
%64 = load float, float* %60
%65 = insertelement <4 x float> poison, float %61, i64 0
%66 = insertelement <4 x float> %65, float %62, i64 1
%67 = insertelement <4 x float> %66, float %63, i64 2
%68 = insertelement <4 x float> %67, float %64, i64 3
%69 = fadd <4 x float> %20, %36
%70 = fsub <4 x float> %20, %36
%71 = fadd <4 x float> %52, %68
%72 = fsub <4 x float> %52, %68
%73 = fadd <4 x float> %69, %71
%74 = fsub <4 x float> %69, %71
%75 = fadd <4 x float> %70, %72
%76 = fsub <4 x float> %70, %72
%77 = getelementptr inbounds float, float* %57, i64 -3
%78 = bitcast float* %77 to <16 x float>*
%79 = shufflevector <4 x float> %73, <4 x float> %75, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%80 = shufflevector <4 x float> %74, <4 x float> %76, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%81 = shufflevector <8 x float> %79, <8 x float> %80, <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> %81, <16 x float>* %78
%82 = add nuw i64 %4, 4
%83 = icmp eq i64 %82, 128
br i1 %83, label %84, label %3
84: ; preds = %3, %84
%85 = phi i64 [ %235, %84 ], [ 0, %3 ]
%86 = shl i64 %85, 3
%87 = or i64 %86, 8
%88 = or i64 %86, 16
%89 = or i64 %86, 24
%90 = getelementptr inbounds float, float* %0, i64 %86
%91 = getelementptr inbounds float, float* %0, i64 %87
%92 = getelementptr inbounds float, float* %0, i64 %88
%93 = getelementptr inbounds float, float* %0, i64 %89
%94 = load float, float* %90
%95 = load float, float* %91
%96 = load float, float* %92
%97 = load float, float* %93
%98 = insertelement <4 x float> poison, float %94, i64 0
%99 = insertelement <4 x float> %98, float %95, i64 1
%100 = insertelement <4 x float> %99, float %96, i64 2
%101 = insertelement <4 x float> %100, float %97, i64 3
%102 = or i64 %86, 4
%103 = or i64 %86, 12
%104 = or i64 %86, 20
%105 = or i64 %86, 28
%106 = getelementptr inbounds float, float* %0, i64 %102
%107 = getelementptr inbounds float, float* %0, i64 %103
%108 = getelementptr inbounds float, float* %0, i64 %104
%109 = getelementptr inbounds float, float* %0, i64 %105
%110 = load float, float* %106
%111 = load float, float* %107
%112 = load float, float* %108
%113 = load float, float* %109
%114 = insertelement <4 x float> poison, float %110, i64 0
%115 = insertelement <4 x float> %114, float %111, i64 1
%116 = insertelement <4 x float> %115, float %112, i64 2
%117 = insertelement <4 x float> %116, float %113, i64 3
%118 = fadd <4 x float> %101, %117
%119 = fsub <4 x float> %101, %117
%120 = or i64 %86, 2
%121 = or i64 %86, 10
%122 = or i64 %86, 18
%123 = or i64 %86, 26
%124 = getelementptr inbounds float, float* %0, i64 %120
%125 = getelementptr inbounds float, float* %0, i64 %121
%126 = getelementptr inbounds float, float* %0, i64 %122
%127 = getelementptr inbounds float, float* %0, i64 %123
%128 = load float, float* %124
%129 = load float, float* %125
%130 = load float, float* %126
%131 = load float, float* %127
%132 = insertelement <4 x float> poison, float %128, i64 0
%133 = insertelement <4 x float> %132, float %129, i64 1
%134 = insertelement <4 x float> %133, float %130, i64 2
%135 = insertelement <4 x float> %134, float %131, i64 3
%136 = or i64 %86, 6
%137 = or i64 %86, 14
%138 = or i64 %86, 22
%139 = or i64 %86, 30
%140 = getelementptr inbounds float, float* %0, i64 %136
%141 = getelementptr inbounds float, float* %0, i64 %137
%142 = getelementptr inbounds float, float* %0, i64 %138
%143 = getelementptr inbounds float, float* %0, i64 %139
%144 = load float, float* %140
%145 = load float, float* %141
%146 = load float, float* %142
%147 = load float, float* %143
%148 = insertelement <4 x float> poison, float %144, i64 0
%149 = insertelement <4 x float> %148, float %145, i64 1
%150 = insertelement <4 x float> %149, float %146, i64 2
%151 = insertelement <4 x float> %150, float %147, i64 3
%152 = fadd <4 x float> %135, %151
%153 = fsub <4 x float> %135, %151
%154 = or i64 %86, 1
%155 = or i64 %86, 9
%156 = or i64 %86, 17
%157 = or i64 %86, 25
%158 = getelementptr inbounds float, float* %0, i64 %154
%159 = getelementptr inbounds float, float* %0, i64 %155
%160 = getelementptr inbounds float, float* %0, i64 %156
%161 = getelementptr inbounds float, float* %0, i64 %157
%162 = load float, float* %158
%163 = load float, float* %159
%164 = load float, float* %160
%165 = load float, float* %161
%166 = insertelement <4 x float> poison, float %162, i64 0
%167 = insertelement <4 x float> %166, float %163, i64 1
%168 = insertelement <4 x float> %167, float %164, i64 2
%169 = insertelement <4 x float> %168, float %165, i64 3
%170 = or i64 %86, 5
%171 = or i64 %86, 13
%172 = or i64 %86, 21
%173 = or i64 %86, 29
%174 = getelementptr inbounds float, float* %0, i64 %170
%175 = getelementptr inbounds float, float* %0, i64 %171
%176 = getelementptr inbounds float, float* %0, i64 %172
%177 = getelementptr inbounds float, float* %0, i64 %173
%178 = load float, float* %174
%179 = load float, float* %175
%180 = load float, float* %176
%181 = load float, float* %177
%182 = insertelement <4 x float> poison, float %178, i64 0
%183 = insertelement <4 x float> %182, float %179, i64 1
%184 = insertelement <4 x float> %183, float %180, i64 2
%185 = insertelement <4 x float> %184, float %181, i64 3
%186 = or i64 %86, 7
%187 = or i64 %86, 15
%188 = or i64 %86, 23
%189 = or i64 %86, 31
%190 = getelementptr inbounds float, float* %0, i64 %186
%191 = getelementptr inbounds float, float* %0, i64 %187
%192 = getelementptr inbounds float, float* %0, i64 %188
%193 = getelementptr inbounds float, float* %0, i64 %189
%194 = load float, float* %190
%195 = load float, float* %191
%196 = load float, float* %192
%197 = load float, float* %193
%198 = insertelement <4 x float> poison, float %194, i64 0
%199 = insertelement <4 x float> %198, float %195, i64 1
%200 = insertelement <4 x float> %199, float %196, i64 2
%201 = insertelement <4 x float> %200, float %197, i64 3
%202 = fadd <4 x float> %185, %201
%203 = fmul <4 x float> %202, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%204 = fsub <4 x float> %185, %201
%205 = fmul <4 x float> %204, <float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000, float 0x3FE6A09E60000000>
%206 = fadd <4 x float> %169, %203
%207 = fsub <4 x float> %169, %203
%208 = or i64 %86, 3
%209 = or i64 %86, 11
%210 = or i64 %86, 19
%211 = or i64 %86, 27
%212 = getelementptr inbounds float, float* %0, i64 %208
%213 = getelementptr inbounds float, float* %0, i64 %209
%214 = getelementptr inbounds float, float* %0, i64 %210
%215 = getelementptr inbounds float, float* %0, i64 %211
%216 = load float, float* %212
%217 = load float, float* %213
%218 = load float, float* %214
%219 = load float, float* %215
%220 = insertelement <4 x float> poison, float %216, i64 0
%221 = insertelement <4 x float> %220, float %217, i64 1
%222 = insertelement <4 x float> %221, float %218, i64 2
%223 = insertelement <4 x float> %222, float %219, i64 3
%224 = fadd <4 x float> %205, %223
%225 = fsub <4 x float> %223, %205
%226 = getelementptr inbounds float, float* %190, i64 -7
%227 = bitcast float* %226 to <32 x float>*
%228 = shufflevector <4 x float> %118, <4 x float> %206, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%229 = shufflevector <4 x float> %152, <4 x float> %224, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%230 = shufflevector <4 x float> %119, <4 x float> %207, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%231 = shufflevector <4 x float> %153, <4 x float> %225, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%232 = shufflevector <8 x float> %228, <8 x float> %229, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%233 = shufflevector <8 x float> %230, <8 x float> %231, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
%234 = shufflevector <16 x float> %232, <16 x float> %233, <32 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28, i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29, i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30, i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31>
store <32 x float> %234, <32 x float>* %227
%235 = add nuw i64 %85, 4
%236 = icmp eq i64 %235, 64
br i1 %236, label %237, label %84
237: ; preds = %84
%238 = getelementptr inbounds float, float* %1, i64 32
%239 = getelementptr inbounds float, float* %1, i64 160
%240 = getelementptr inbounds float, float* %1, i64 64
%241 = getelementptr inbounds float, float* %1, i64 192
%242 = getelementptr inbounds float, float* %1, i64 96
%243 = getelementptr inbounds float, float* %1, i64 224
br label %244
244: ; preds = %237, %244
%245 = phi i64 [ 0, %237 ], [ %330, %244 ]
%246 = getelementptr inbounds float, float* %0, i64 %245
%247 = load float, float* %246
%248 = or i64 %245, 8
%249 = getelementptr inbounds float, float* %0, i64 %248
%250 = load float, float* %249
%251 = fadd float %247, %250
store float %251, float* %246
%252 = fsub float %247, %250
store float %252, float* %249
%253 = or i64 %245, 4
%254 = getelementptr inbounds float, float* %0, i64 %253
%255 = load float, float* %254
%256 = or i64 %245, 12
%257 = getelementptr inbounds float, float* %0, i64 %256
%258 = load float, float* %257
%259 = fadd float %255, %258
store float %259, float* %254
%260 = fsub float %255, %258
store float %260, float* %257
%261 = load float, float* %238
%262 = load float, float* %239
%263 = or i64 %245, 1
%264 = getelementptr inbounds float, float* %0, i64 %263
%265 = load float, float* %264
%266 = or i64 %245, 7
%267 = getelementptr inbounds float, float* %0, i64 %266
%268 = load float, float* %267
%269 = or i64 %245, 9
%270 = getelementptr inbounds float, float* %0, i64 %269
%271 = load float, float* %270
%272 = or i64 %245, 15
%273 = getelementptr inbounds float, float* %0, i64 %272
%274 = load float, float* %273
%275 = fmul float %261, %274
%276 = tail call float @llvm.fmuladd.f32(float %271, float %262, float %275)
%277 = fneg float %274
%278 = fmul float %262, %277
%279 = tail call float @llvm.fmuladd.f32(float %271, float %261, float %278)
%280 = fadd float %265, %276
store float %280, float* %264
%281 = fsub float %265, %276
store float %281, float* %270
%282 = fadd float %268, %279
store float %282, float* %267
%283 = fsub float %268, %279
store float %283, float* %273
%284 = load float, float* %240
%285 = load float, float* %241
%286 = or i64 %245, 2
%287 = getelementptr inbounds float, float* %0, i64 %286
%288 = load float, float* %287
%289 = or i64 %245, 6
%290 = getelementptr inbounds float, float* %0, i64 %289
%291 = load float, float* %290
%292 = or i64 %245, 10
%293 = getelementptr inbounds float, float* %0, i64 %292
%294 = load float, float* %293
%295 = or i64 %245, 14
%296 = getelementptr inbounds float, float* %0, i64 %295
%297 = load float, float* %296
%298 = fmul float %284, %297
%299 = tail call float @llvm.fmuladd.f32(float %294, float %285, float %298)
%300 = fneg float %297
%301 = fmul float %285, %300
%302 = tail call float @llvm.fmuladd.f32(float %294, float %284, float %301)
%303 = fadd float %288, %299
store float %303, float* %287
%304 = fsub float %288, %299
store float %304, float* %293
%305 = fadd float %291, %302
store float %305, float* %290
%306 = fsub float %291, %302
store float %306, float* %296
%307 = load float, float* %242
%308 = load float, float* %243
%309 = or i64 %245, 3
%310 = getelementptr inbounds float, float* %0, i64 %309
%311 = load float, float* %310
%312 = or i64 %245, 5
%313 = getelementptr inbounds float, float* %0, i64 %312
%314 = load float, float* %313
%315 = or i64 %245, 11
%316 = getelementptr inbounds float, float* %0, i64 %315
%317 = load float, float* %316
%318 = or i64 %245, 13
%319 = getelementptr inbounds float, float* %0, i64 %318
%320 = load float, float* %319
%321 = fmul float %307, %320
%322 = tail call float @llvm.fmuladd.f32(float %317, float %308, float %321)
%323 = fneg float %320
%324 = fmul float %308, %323
%325 = tail call float @llvm.fmuladd.f32(float %317, float %307, float %324)
%326 = fadd float %311, %322
store float %326, float* %310
%327 = fsub float %311, %322
store float %327, float* %316
%328 = fadd float %314, %325
store float %328, float* %313
%329 = fsub float %314, %325
store float %329, float* %319
%330 = add nuw nsw i64 %245, 16
%331 = icmp ult i64 %245, 496
br i1 %331, label %244, label %332
332: ; preds = %244, %382
%333 = phi i64 [ %383, %382 ], [ 0, %244 ]
%334 = getelementptr inbounds float, float* %0, i64 %333
%335 = load float, float* %334
%336 = or i64 %333, 16
%337 = getelementptr inbounds float, float* %0, i64 %336
%338 = load float, float* %337
%339 = fadd float %335, %338
store float %339, float* %334
%340 = fsub float %335, %338
store float %340, float* %337
%341 = or i64 %333, 8
%342 = getelementptr inbounds float, float* %0, i64 %341
%343 = load float, float* %342
%344 = or i64 %333, 24
%345 = getelementptr inbounds float, float* %0, i64 %344
%346 = load float, float* %345
%347 = fadd float %343, %346
store float %347, float* %342
%348 = fsub float %343, %346
store float %348, float* %345
br label %349
349: ; preds = %332, %349
%350 = phi i64 [ 16, %332 ], [ %375, %349 ]
%351 = phi i64 [ 1, %332 ], [ %380, %349 ]
%352 = getelementptr inbounds float, float* %1, i64 %350
%353 = load float, float* %352
%354 = add nuw nsw i64 %350, 128
%355 = getelementptr inbounds float, float* %1, i64 %354
%356 = load float, float* %355
%357 = add nuw nsw i64 %351, %333
%358 = getelementptr inbounds float, float* %0, i64 %357
%359 = load float, float* %358
%360 = sub nsw i64 %333, %351
%361 = add nsw i64 %360, 16
%362 = getelementptr inbounds float, float* %0, i64 %361
%363 = load float, float* %362
%364 = add nuw nsw i64 %357, 16
%365 = getelementptr inbounds float, float* %0, i64 %364
%366 = load float, float* %365
%367 = add nsw i64 %360, 32
%368 = getelementptr inbounds float, float* %0, i64 %367
%369 = load float, float* %368
%370 = fmul float %353, %369
%371 = tail call float @llvm.fmuladd.f32(float %366, float %356, float %370)
%372 = fneg float %369
%373 = fmul float %356, %372
%374 = tail call float @llvm.fmuladd.f32(float %366, float %353, float %373)
%375 = add nuw nsw i64 %350, 16
%376 = fadd float %359, %371
store float %376, float* %358
%377 = fsub float %359, %371
store float %377, float* %365
%378 = fadd float %363, %374
store float %378, float* %362
%379 = fsub float %363, %374
store float %379, float* %368
%380 = add nuw nsw i64 %351, 1
%381 = icmp eq i64 %380, 8
br i1 %381, label %382, label %349
382: ; preds = %349
%383 = add nuw nsw i64 %333, 32
%384 = icmp ult i64 %333, 480
br i1 %384, label %332, label %385
385: ; preds = %382, %435
%386 = phi i64 [ %436, %435 ], [ 0, %382 ]
%387 = getelementptr inbounds float, float* %0, i64 %386
%388 = load float, float* %387
%389 = or i64 %386, 32
%390 = getelementptr inbounds float, float* %0, i64 %389
%391 = load float, float* %390
%392 = fadd float %388, %391
store float %392, float* %387
%393 = fsub float %388, %391
store float %393, float* %390
%394 = or i64 %386, 16
%395 = getelementptr inbounds float, float* %0, i64 %394
%396 = load float, float* %395
%397 = or i64 %386, 48
%398 = getelementptr inbounds float, float* %0, i64 %397
%399 = load float, float* %398
%400 = fadd float %396, %399
store float %400, float* %395
%401 = fsub float %396, %399
store float %401, float* %398
br label %402
402: ; preds = %385, %402
%403 = phi i64 [ 8, %385 ], [ %428, %402 ]
%404 = phi i64 [ 1, %385 ], [ %433, %402 ]
%405 = getelementptr inbounds float, float* %1, i64 %403
%406 = load float, float* %405
%407 = add nuw nsw i64 %403, 128
%408 = getelementptr inbounds float, float* %1, i64 %407
%409 = load float, float* %408
%410 = add nuw nsw i64 %404, %386
%411 = getelementptr inbounds float, float* %0, i64 %410
%412 = load float, float* %411
%413 = sub nsw i64 %386, %404
%414 = add nsw i64 %413, 32
%415 = getelementptr inbounds float, float* %0, i64 %414
%416 = load float, float* %415
%417 = add nuw nsw i64 %410, 32
%418 = getelementptr inbounds float, float* %0, i64 %417
%419 = load float, float* %418
%420 = add nsw i64 %413, 64
%421 = getelementptr inbounds float, float* %0, i64 %420
%422 = load float, float* %421
%423 = fmul float %406, %422
%424 = tail call float @llvm.fmuladd.f32(float %419, float %409, float %423)
%425 = fneg float %422
%426 = fmul float %409, %425
%427 = tail call float @llvm.fmuladd.f32(float %419, float %406, float %426)
%428 = add nuw nsw i64 %403, 8
%429 = fadd float %412, %424
store float %429, float* %411
%430 = fsub float %412, %424
store float %430, float* %418
%431 = fadd float %416, %427
store float %431, float* %415
%432 = fsub float %416, %427
store float %432, float* %421
%433 = add nuw nsw i64 %404, 1
%434 = icmp eq i64 %433, 16
br i1 %434, label %435, label %402
435: ; preds = %402
%436 = add nuw nsw i64 %386, 64
%437 = icmp ult i64 %386, 448
br i1 %437, label %385, label %438
438: ; preds = %435, %488
%439 = phi i64 [ %489, %488 ], [ 0, %435 ]
%440 = getelementptr inbounds float, float* %0, i64 %439
%441 = load float, float* %440
%442 = or i64 %439, 64
%443 = getelementptr inbounds float, float* %0, i64 %442
%444 = load float, float* %443
%445 = fadd float %441, %444
store float %445, float* %440
%446 = fsub float %441, %444
store float %446, float* %443
%447 = or i64 %439, 32
%448 = getelementptr inbounds float, float* %0, i64 %447
%449 = load float, float* %448
%450 = or i64 %439, 96
%451 = getelementptr inbounds float, float* %0, i64 %450
%452 = load float, float* %451
%453 = fadd float %449, %452
store float %453, float* %448
%454 = fsub float %449, %452
store float %454, float* %451
br label %455
455: ; preds = %438, %455
%456 = phi i64 [ 4, %438 ], [ %481, %455 ]
%457 = phi i64 [ 1, %438 ], [ %486, %455 ]
%458 = getelementptr inbounds float, float* %1, i64 %456
%459 = load float, float* %458
%460 = add nuw nsw i64 %456, 128
%461 = getelementptr inbounds float, float* %1, i64 %460
%462 = load float, float* %461
%463 = add nuw nsw i64 %457, %439
%464 = getelementptr inbounds float, float* %0, i64 %463
%465 = load float, float* %464
%466 = sub nsw i64 %439, %457
%467 = add nsw i64 %466, 64
%468 = getelementptr inbounds float, float* %0, i64 %467
%469 = load float, float* %468
%470 = add nuw nsw i64 %463, 64
%471 = getelementptr inbounds float, float* %0, i64 %470
%472 = load float, float* %471
%473 = add nsw i64 %466, 128
%474 = getelementptr inbounds float, float* %0, i64 %473
%475 = load float, float* %474
%476 = fmul float %459, %475
%477 = tail call float @llvm.fmuladd.f32(float %472, float %462, float %476)
%478 = fneg float %475
%479 = fmul float %462, %478
%480 = tail call float @llvm.fmuladd.f32(float %472, float %459, float %479)
%481 = add nuw nsw i64 %456, 4
%482 = fadd float %465, %477
store float %482, float* %464
%483 = fsub float %465, %477
store float %483, float* %471
%484 = fadd float %469, %480
store float %484, float* %468
%485 = fsub float %469, %480
store float %485, float* %474
%486 = add nuw nsw i64 %457, 1
%487 = icmp eq i64 %486, 32
br i1 %487, label %488, label %455
488: ; preds = %455
%489 = add nuw nsw i64 %439, 128
%490 = icmp ult i64 %439, 384
br i1 %490, label %438, label %491
491: ; preds = %488
%492 = load float, float* %0
%493 = getelementptr inbounds float, float* %0, i64 128
%494 = load float, float* %493
%495 = fadd float %492, %494
store float %495, float* %0
%496 = fsub float %492, %494
store float %496, float* %493
%497 = getelementptr inbounds float, float* %0, i64 64
%498 = load float, float* %497
%499 = getelementptr inbounds float, float* %0, i64 192
%500 = load float, float* %499
%501 = fadd float %498, %500
store float %501, float* %497
%502 = fsub float %498, %500
store float %502, float* %499
br label %503
503: ; preds = %491, %503
%504 = phi i64 [ 2, %491 ], [ %527, %503 ]
%505 = phi i64 [ 1, %491 ], [ %532, %503 ]
%506 = getelementptr inbounds float, float* %1, i64 %504
%507 = load float, float* %506
%508 = add nuw nsw i64 %504, 128
%509 = getelementptr inbounds float, float* %1, i64 %508
%510 = load float, float* %509
%511 = getelementptr inbounds float, float* %0, i64 %505
%512 = load float, float* %511
%513 = sub nsw i64 128, %505
%514 = getelementptr inbounds float, float* %0, i64 %513
%515 = load float, float* %514
%516 = add nuw nsw i64 %505, 128
%517 = getelementptr inbounds float, float* %0, i64 %516
%518 = load float, float* %517
%519 = sub nsw i64 256, %505
%520 = getelementptr inbounds float, float* %0, i64 %519
%521 = load float, float* %520
%522 = fmul float %507, %521
%523 = tail call float @llvm.fmuladd.f32(float %518, float %510, float %522)
%524 = fneg float %521
%525 = fmul float %510, %524
%526 = tail call float @llvm.fmuladd.f32(float %518, float %507, float %525)
%527 = add nuw nsw i64 %504, 2
%528 = fadd float %512, %523
store float %528, float* %511
%529 = fsub float %512, %523
store float %529, float* %517
%530 = fadd float %515, %526
store float %530, float* %514
%531 = fsub float %515, %526
store float %531, float* %520
%532 = add nuw nsw i64 %505, 1
%533 = icmp eq i64 %532, 64
br i1 %533, label %534, label %503
534: ; preds = %503
%535 = getelementptr inbounds float, float* %0, i64 256
%536 = load float, float* %535
%537 = getelementptr inbounds float, float* %0, i64 384
%538 = load float, float* %537
%539 = fadd float %536, %538
store float %539, float* %535
%540 = fsub float %536, %538
store float %540, float* %537
%541 = getelementptr inbounds float, float* %0, i64 320
%542 = load float, float* %541
%543 = getelementptr inbounds float, float* %0, i64 448
%544 = load float, float* %543
%545 = fadd float %542, %544
store float %545, float* %541
%546 = fsub float %542, %544
store float %546, float* %543
br label %547
547: ; preds = %547, %534
%548 = phi i64 [ 2, %534 ], [ %572, %547 ]
%549 = phi i64 [ 1, %534 ], [ %577, %547 ]
%550 = getelementptr inbounds float, float* %1, i64 %548
%551 = load float, float* %550
%552 = add nuw nsw i64 %548, 128
%553 = getelementptr inbounds float, float* %1, i64 %552
%554 = load float, float* %553
%555 = add nuw nsw i64 %549, 256
%556 = getelementptr inbounds float, float* %0, i64 %555
%557 = load float, float* %556
%558 = sub nsw i64 384, %549
%559 = getelementptr inbounds float, float* %0, i64 %558
%560 = load float, float* %559
%561 = add nuw nsw i64 %549, 384
%562 = getelementptr inbounds float, float* %0, i64 %561
%563 = load float, float* %562
%564 = sub nsw i64 512, %549
%565 = getelementptr inbounds float, float* %0, i64 %564
%566 = load float, float* %565
%567 = fmul float %551, %566
%568 = tail call float @llvm.fmuladd.f32(float %563, float %554, float %567)
%569 = fneg float %566
%570 = fmul float %554, %569
%571 = tail call float @llvm.fmuladd.f32(float %563, float %551, float %570)
%572 = add nuw nsw i64 %548, 2
%573 = fadd float %557, %568
store float %573, float* %556
%574 = fsub float %557, %568
store float %574, float* %562
%575 = fadd float %560, %571
store float %575, float* %559
%576 = fsub float %560, %571
store float %576, float* %565
%577 = add nuw nsw i64 %549, 1
%578 = icmp eq i64 %577, 64
br i1 %578, label %579, label %547
579: ; preds = %547
%580 = load float, float* %0
%581 = load float, float* %535
%582 = fadd float %580, %581
store float %582, float* %0
%583 = fsub float %580, %581
store float %583, float* %535
%584 = load float, float* %493
%585 = load float, float* %537
%586 = fadd float %584, %585
store float %586, float* %493
%587 = fsub float %584, %585
store float %587, float* %537
br label %588
588: ; preds = %579, %588
%589 = phi i64 [ 1, %579 ], [ %611, %588 ]
%590 = getelementptr inbounds float, float* %1, i64 %589
%591 = load float, float* %590
%592 = add nuw nsw i64 %589, 128
%593 = getelementptr inbounds float, float* %1, i64 %592
%594 = load float, float* %593
%595 = getelementptr inbounds float, float* %0, i64 %589
%596 = load float, float* %595
%597 = sub nuw nsw i64 256, %589
%598 = getelementptr inbounds float, float* %0, i64 %597
%599 = load float, float* %598
%600 = add nuw nsw i64 %589, 256
%601 = getelementptr inbounds float, float* %0, i64 %600
%602 = load float, float* %601
%603 = sub nuw nsw i64 512, %589
%604 = getelementptr inbounds float, float* %0, i64 %603
%605 = load float, float* %604
%606 = fmul float %591, %605
%607 = tail call float @llvm.fmuladd.f32(float %602, float %594, float %606)
%608 = fneg float %605
%609 = fmul float %594, %608
%610 = tail call float @llvm.fmuladd.f32(float %602, float %591, float %609)
%611 = add nuw nsw i64 %589, 1
%612 = fadd float %596, %607
store float %612, float* %595
%613 = fsub float %596, %607
store float %613, float* %601
%614 = fadd float %599, %610
store float %614, float* %598
%615 = fsub float %599, %610
store float %615, float* %604
%616 = icmp eq i64 %611, 128
br i1 %616, label %617, label %588
617: ; preds = %588
ret void
}