void DFT2048(float *A, const float *sinTab) {
  int i, j, theta;
  float alpha, beta, beta1, beta2, y0, y1, y2, y3;
  for (i = 0; i < 2048; 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 < 2048; 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 < 2048; i += 16) {
    theta = 128;
    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 + 512];
      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 += 128;
      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 < 2048; i += 32) {
    theta = 64;
    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 + 512];
      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 += 64;
      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 < 2048; i += 64) {
    theta = 32;
    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 + 512];
      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 += 32;
      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 < 2048; i += 128) {
    theta = 16;
    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 + 512];
      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 += 16;
      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 < 2048; i += 256) {
    theta = 8;
    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 + 512];
      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 += 8;
      A[i + j] = alpha + beta1;
      A[i + j + 128] = alpha - beta1;
      A[i - j + 128] = beta + beta2;
      A[i - j + 256] = beta - beta2;
    }
  }
  for (i = 0; i < 2048; i += 512) {
    theta = 4;
    alpha = A[i];
    beta = A[i + 256];
    A[i] = alpha + beta;
    A[i + 256] = alpha - beta;
    alpha = A[i + 128];
    beta = A[i + 384];
    A[i + 128] = alpha + beta;
    A[i + 384] = alpha - beta;
    for (j = 1; j < 128; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 512];
      alpha = A[i + j];
      beta = A[i - j + 256];
      beta1 = A[i + j + 256] * y1 + A[i - j + 512] * y0;
      beta2 = A[i + j + 256] * y0 - A[i - j + 512] * y1;
      theta += 4;
      A[i + j] = alpha + beta1;
      A[i + j + 256] = alpha - beta1;
      A[i - j + 256] = beta + beta2;
      A[i - j + 512] = beta - beta2;
    }
  }
  for (i = 0; i < 2048; i += 1024) {
    theta = 2;
    alpha = A[i];
    beta = A[i + 512];
    A[i] = alpha + beta;
    A[i + 512] = alpha - beta;
    alpha = A[i + 256];
    beta = A[i + 768];
    A[i + 256] = alpha + beta;
    A[i + 768] = alpha - beta;
    for (j = 1; j < 256; j++) {
      y0 = sinTab[theta];
      y1 = sinTab[theta + 512];
      alpha = A[i + j];
      beta = A[i - j + 512];
      beta1 = A[i + j + 512] * y1 + A[i - j + 1024] * y0;
      beta2 = A[i + j + 512] * y0 - A[i - j + 1024] * y1;
      theta += 2;
      A[i + j] = alpha + beta1;
      A[i + j + 512] = alpha - beta1;
      A[i - j + 512] = beta + beta2;
      A[i - j + 1024] = beta - beta2;
    }
  }
  theta = 1;
  alpha = A[0];
  beta = A[1024];
  A[0] = alpha + beta;
  A[1024] = alpha - beta;
  alpha = A[512];
  beta = A[1536];
  A[512] = alpha + beta;
  A[1536] = alpha - beta;
  for (j = 1; j < 512; j++) {
    y0 = sinTab[theta];
    y1 = sinTab[theta + 512];
    alpha = A[j];
    beta = A[-j + 1024];
    beta1 = A[j + 1024] * y1 + A[-j + 2048] * y0;
    beta2 = A[j + 1024] * y0 - A[-j + 2048] * y1;
    theta += 1;
    A[j] = alpha + beta1;
    A[j + 1024] = alpha - beta1;
    A[-j + 1024] = beta + beta2;
    A[-j + 2048] = beta - beta2;
  }
}


x86 assembly (clang, -O0):
<DFT2048>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    122c <DFT2048+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 <DFT2048+0x13>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    1418 <DFT2048+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 <DFT2048+0x133>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    1697 <DFT2048+0x597>
movl   $0x80,-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    1684 <DFT2048+0x584>
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    $0x200,%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    $0x80,%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 <DFT2048+0x3fc>
jmp    1689 <DFT2048+0x589>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    141f <DFT2048+0x31f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    1914 <DFT2048+0x814>
movl   $0x40,-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    1901 <DFT2048+0x801>
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    $0x200,%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    $0x40,%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    177b <DFT2048+0x67b>
jmp    1906 <DFT2048+0x806>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    169e <DFT2048+0x59e>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    1b91 <DFT2048+0xa91>
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    $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    1b7e <DFT2048+0xa7e>
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    $0x200,%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    $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    $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    19f8 <DFT2048+0x8f8>
jmp    1b83 <DFT2048+0xa83>
mov    -0x14(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x14(%rbp)
jmp    191b <DFT2048+0x81b>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    1e19 <DFT2048+0xd19>
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    $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    1e04 <DFT2048+0xd04>
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    $0x200,%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    $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    $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    1c75 <DFT2048+0xb75>
jmp    1e09 <DFT2048+0xd09>
mov    -0x14(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x14(%rbp)
jmp    1b98 <DFT2048+0xa98>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    20bc <DFT2048+0xfbc>
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    $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    20a7 <DFT2048+0xfa7>
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    $0x200,%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    $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    $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    1f09 <DFT2048+0xe09>
jmp    20ac <DFT2048+0xfac>
mov    -0x14(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x14(%rbp)
jmp    1e20 <DFT2048+0xd20>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    2368 <DFT2048+0x1268>
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    $0x100,%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    $0x100,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x80,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x180,%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    $0x80,%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    $0x180,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x80,-0x18(%rbp)
jge    2353 <DFT2048+0x1253>
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    $0x200,%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    $0x100,%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    $0x100,%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    $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    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x100,%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    $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    $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    $0x100,%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    $0x100,%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    $0x200,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    21b2 <DFT2048+0x10b2>
jmp    2358 <DFT2048+0x1258>
mov    -0x14(%rbp),%eax
add    $0x200,%eax
mov    %eax,-0x14(%rbp)
jmp    20c3 <DFT2048+0xfc3>
movl   $0x0,-0x14(%rbp)
cmpl   $0x800,-0x14(%rbp)
jge    2614 <DFT2048+0x1514>
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    $0x200,%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    $0x200,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x100,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x300,%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    $0x100,%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    $0x300,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x100,-0x18(%rbp)
jge    25ff <DFT2048+0x14ff>
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    $0x200,%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    $0x200,%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    $0x200,%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    $0x400,%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    $0x200,%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    $0x400,%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    $0x200,%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    $0x200,%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    $0x400,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    245e <DFT2048+0x135e>
jmp    2604 <DFT2048+0x1504>
mov    -0x14(%rbp),%eax
add    $0x400,%eax
mov    %eax,-0x14(%rbp)
jmp    236f <DFT2048+0x126f>
movl   $0x1,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1000(%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,0x1000(%rax)
mov    -0x8(%rbp),%rax
movss  0x800(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1800(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x800(%rax)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1800(%rax)
movl   $0x1,-0x18(%rbp)
cmpl   $0x200,-0x18(%rbp)
jge    283f <DFT2048+0x173f>
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    $0x200,%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    $0x400,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x400,%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    $0x800,%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    $0x400,%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    $0x800,%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    $0x400,%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    $0x400,%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    $0x800,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    26b6 <DFT2048+0x15b6>
pop    %rbp
ret

x86 assembly (clang, -O2):
<DFT2048>:
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    $0x2000,%rax
jne    1110 <DFT2048+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    $0x2000,%rax
jne    1230 <DFT2048+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  0x200(%rsi),%xmm1
movss  0xa00(%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  0x400(%rsi),%xmm0
movss  0xc00(%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  0x600(%rsi),%xmm0
movss  0xe00(%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    $0x7f0,%rax
jb     1450 <DFT2048+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    $0xfffffffffffffe40,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopw   0x0(%rax,%rax,1)
movss  0x800(%rsi,%rax,4),%xmm0
movss  0x1000(%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    $0x40,%rax
jne    1680 <DFT2048+0x580>
lea    0x20(%r10),%rax
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%r9
cmp    $0x7e0,%r10
mov    %rax,%r10
jb     1610 <DFT2048+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    $0xfffffffffffffe20,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopl   0x0(%rax)
movss  0x800(%rsi,%rax,4),%xmm0
movss  0x1000(%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    $0x20,%rax
jne    17a0 <DFT2048+0x6a0>
lea    0x40(%r10),%rax
add    $0x100,%r8
add    $0x100,%r9
cmp    $0x7c0,%r10
mov    %rax,%r10
jb     1730 <DFT2048+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    $0xfffffffffffffe10,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x800(%rsi,%rax,4),%xmm0
movss  0x1000(%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    $0x10,%rax
jne    18c0 <DFT2048+0x7c0>
lea    0x80(%r10),%rax
add    $0x200,%r8
add    $0x200,%r9
cmp    $0x780,%r10
mov    %rax,%r10
jb     1850 <DFT2048+0x750>
mov    $0x3fc,%r8d
mov    $0x204,%r9d
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r10,4),%rax
movss  (%rdi,%r10,4),%xmm0
mov    %rax,%rcx
or     $0x200,%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     $0x100,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x300,%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    $0xfffffffffffffe08,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x800(%rsi,%rax,4),%xmm0
movss  0x1000(%rsi,%rax,4),%xmm1
movss  -0x200(%rdi,%rcx,1),%xmm2
ff ff
movss  (%rdi,%rcx,1),%xmm3
movss  -0x200(%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,-0x200(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x200(%rdi,%rdx,1)
ff ff
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x8,%rax
jne    1a00 <DFT2048+0x900>
lea    0x100(%r10),%rax
add    $0x400,%r8
add    $0x400,%r9
cmp    $0x700,%r10
mov    %rax,%r10
jb     1990 <DFT2048+0x890>
mov    $0x7fc,%r8d
mov    $0x404,%r9d
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r10,4),%rax
movss  (%rdi,%r10,4),%xmm0
mov    %rax,%rcx
or     $0x400,%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     $0x200,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x600,%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    $0xfffffffffffffe04,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x800(%rsi,%rax,4),%xmm0
movss  0x1000(%rsi,%rax,4),%xmm1
movss  -0x400(%rdi,%rcx,1),%xmm2
ff ff
movss  -0x400(%rdi,%rdx,1),%xmm3
ff ff
movss  (%rdi,%rcx,1),%xmm4
movss  (%rdi,%rdx,1),%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,-0x400(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x400(%rdi,%rdx,1)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x4,%rax
jne    1b40 <DFT2048+0xa40>
lea    0x200(%r10),%rax
add    $0x800,%r8
add    $0x800,%r9
cmp    $0x600,%r10
mov    %rax,%r10
jb     1ad0 <DFT2048+0x9d0>
movss  (%rdi),%xmm0
movss  0x800(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x800(%rdi)
movss  0x400(%rdi),%xmm0
movss  0xc00(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x400(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0xc00(%rdi)
mov    $0x4,%eax
mov    $0x1ff,%ecx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,2),%xmm0
movss  0x800(%rsi,%rax,2),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  (%rdi,%rcx,4),%xmm3
movss  0x800(%rdi,%rax,1),%xmm4
movss  0x800(%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,0x800(%rdi,%rax,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x800(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x100,%rcx
jne    1c50 <DFT2048+0xb50>
movss  0x1000(%rdi),%xmm0
movss  0x1800(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x1000(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x1800(%rdi)
movss  0x1400(%rdi),%xmm0
movss  0x1c00(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x1400(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x1c00(%rdi)
mov    $0x802,%eax
mov    $0x7ff,%ecx
nopl   0x0(%rax)
movss  -0x2000(%rsi,%rax,4),%xmm0
ff ff
movss  -0x1800(%rsi,%rax,4),%xmm1
ff ff
movss  (%rdi,%rax,2),%xmm2
movss  -0x800(%rdi,%rcx,4),%xmm3
ff ff
movss  0x800(%rdi,%rax,2),%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,2)
subss  %xmm6,%xmm2
movss  %xmm2,0x800(%rdi,%rax,2)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x800(%rdi,%rcx,4)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x2,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x700,%rcx
jne    1d40 <DFT2048+0xc40>
movss  (%rdi),%xmm0
movss  0x1000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x1000(%rdi)
movss  0x800(%rdi),%xmm0
movss  0x1800(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x800(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x1800(%rdi)
mov    $0x4,%eax
mov    $0x7ff,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,1),%xmm0
movss  0x800(%rsi,%rax,1),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  -0x1000(%rdi,%rcx,4),%xmm3
ff ff
movss  0x1000(%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,0x1000(%rdi,%rax,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x1000(%rdi,%rcx,4)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x600,%rcx
jne    1e30 <DFT2048+0xd30>
ret

LLVM IR (-O0):
define void @DFT2048(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, 2048
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, 2048
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, 2048
br i1 %226, label %227, label %401
227: ; preds = %224
store i32 128, 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, 512
%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, 128
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, 2048
br i1 %404, label %405, label %579
405: ; preds = %402
store i32 64, 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, 512
%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, 64
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, 2048
br i1 %582, label %583, label %757
583: ; preds = %580
store i32 32, 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, 512
%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, 32
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, 2048
br i1 %760, label %761, label %935
761: ; preds = %758
store i32 16, 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, 512
%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, 16
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, 2048
br i1 %938, label %939, label %1113
939: ; preds = %936
store i32 8, 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, 512
%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, 8
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 0, i32* %5
br label %1114
1114: ; preds = %1288, %1113
%1115 = load i32, i32* %5
%1116 = icmp slt i32 %1115, 2048
br i1 %1116, label %1117, label %1291
1117: ; preds = %1114
store i32 4, i32* %7
%1118 = load float*, float** %3
%1119 = load i32, i32* %5
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds float, float* %1118, i64 %1120
%1122 = load float, float* %1121
store float %1122, float* %8
%1123 = load float*, float** %3
%1124 = load i32, i32* %5
%1125 = add nsw i32 %1124, 256
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds float, float* %1123, i64 %1126
%1128 = load float, float* %1127
store float %1128, float* %9
%1129 = load float, float* %8
%1130 = load float, float* %9
%1131 = fadd float %1129, %1130
%1132 = load float*, float** %3
%1133 = load i32, i32* %5
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds float, float* %1132, i64 %1134
store float %1131, float* %1135
%1136 = load float, float* %8
%1137 = load float, float* %9
%1138 = fsub float %1136, %1137
%1139 = load float*, float** %3
%1140 = load i32, i32* %5
%1141 = add nsw i32 %1140, 256
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds float, float* %1139, i64 %1142
store float %1138, float* %1143
%1144 = load float*, float** %3
%1145 = load i32, i32* %5
%1146 = add nsw i32 %1145, 128
%1147 = sext i32 %1146 to i64
%1148 = getelementptr inbounds float, float* %1144, i64 %1147
%1149 = load float, float* %1148
store float %1149, float* %8
%1150 = load float*, float** %3
%1151 = load i32, i32* %5
%1152 = add nsw i32 %1151, 384
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds float, float* %1150, i64 %1153
%1155 = load float, float* %1154
store float %1155, float* %9
%1156 = load float, float* %8
%1157 = load float, float* %9
%1158 = fadd float %1156, %1157
%1159 = load float*, float** %3
%1160 = load i32, i32* %5
%1161 = add nsw i32 %1160, 128
%1162 = sext i32 %1161 to i64
%1163 = getelementptr inbounds float, float* %1159, i64 %1162
store float %1158, float* %1163
%1164 = load float, float* %8
%1165 = load float, float* %9
%1166 = fsub float %1164, %1165
%1167 = load float*, float** %3
%1168 = load i32, i32* %5
%1169 = add nsw i32 %1168, 384
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds float, float* %1167, i64 %1170
store float %1166, float* %1171
store i32 1, i32* %6
br label %1172
1172: ; preds = %1284, %1117
%1173 = load i32, i32* %6
%1174 = icmp slt i32 %1173, 128
br i1 %1174, label %1175, label %1287
1175: ; preds = %1172
%1176 = load float*, float** %4
%1177 = load i32, i32* %7
%1178 = sext i32 %1177 to i64
%1179 = getelementptr inbounds float, float* %1176, i64 %1178
%1180 = load float, float* %1179
store float %1180, float* %12
%1181 = load float*, float** %4
%1182 = load i32, i32* %7
%1183 = add nsw i32 %1182, 512
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds float, float* %1181, i64 %1184
%1186 = load float, float* %1185
store float %1186, float* %13
%1187 = load float*, float** %3
%1188 = load i32, i32* %5
%1189 = load i32, i32* %6
%1190 = add nsw i32 %1188, %1189
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds float, float* %1187, i64 %1191
%1193 = load float, float* %1192
store float %1193, float* %8
%1194 = load float*, float** %3
%1195 = load i32, i32* %5
%1196 = load i32, i32* %6
%1197 = sub nsw i32 %1195, %1196
%1198 = add nsw i32 %1197, 256
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds float, float* %1194, i64 %1199
%1201 = load float, float* %1200
store float %1201, float* %9
%1202 = load float*, float** %3
%1203 = load i32, i32* %5
%1204 = load i32, i32* %6
%1205 = add nsw i32 %1203, %1204
%1206 = add nsw i32 %1205, 256
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds float, float* %1202, i64 %1207
%1209 = load float, float* %1208
%1210 = load float, float* %13
%1211 = load float*, float** %3
%1212 = load i32, i32* %5
%1213 = load i32, i32* %6
%1214 = sub nsw i32 %1212, %1213
%1215 = add nsw i32 %1214, 512
%1216 = sext i32 %1215 to i64
%1217 = getelementptr inbounds float, float* %1211, i64 %1216
%1218 = load float, float* %1217
%1219 = load float, float* %12
%1220 = fmul float %1218, %1219
%1221 = call float @llvm.fmuladd.f32(float %1209, float %1210, float %1220)
store float %1221, float* %10
%1222 = load float*, float** %3
%1223 = load i32, i32* %5
%1224 = load i32, i32* %6
%1225 = add nsw i32 %1223, %1224
%1226 = add nsw i32 %1225, 256
%1227 = sext i32 %1226 to i64
%1228 = getelementptr inbounds float, float* %1222, i64 %1227
%1229 = load float, float* %1228
%1230 = load float, float* %12
%1231 = load float*, float** %3
%1232 = load i32, i32* %5
%1233 = load i32, i32* %6
%1234 = sub nsw i32 %1232, %1233
%1235 = add nsw i32 %1234, 512
%1236 = sext i32 %1235 to i64
%1237 = getelementptr inbounds float, float* %1231, i64 %1236
%1238 = load float, float* %1237
%1239 = load float, float* %13
%1240 = fmul float %1238, %1239
%1241 = fneg float %1240
%1242 = call float @llvm.fmuladd.f32(float %1229, float %1230, float %1241)
store float %1242, float* %11
%1243 = load i32, i32* %7
%1244 = add nsw i32 %1243, 4
store i32 %1244, i32* %7
%1245 = load float, float* %8
%1246 = load float, float* %10
%1247 = fadd float %1245, %1246
%1248 = load float*, float** %3
%1249 = load i32, i32* %5
%1250 = load i32, i32* %6
%1251 = add nsw i32 %1249, %1250
%1252 = sext i32 %1251 to i64
%1253 = getelementptr inbounds float, float* %1248, i64 %1252
store float %1247, float* %1253
%1254 = load float, float* %8
%1255 = load float, float* %10
%1256 = fsub float %1254, %1255
%1257 = load float*, float** %3
%1258 = load i32, i32* %5
%1259 = load i32, i32* %6
%1260 = add nsw i32 %1258, %1259
%1261 = add nsw i32 %1260, 256
%1262 = sext i32 %1261 to i64
%1263 = getelementptr inbounds float, float* %1257, i64 %1262
store float %1256, float* %1263
%1264 = load float, float* %9
%1265 = load float, float* %11
%1266 = fadd float %1264, %1265
%1267 = load float*, float** %3
%1268 = load i32, i32* %5
%1269 = load i32, i32* %6
%1270 = sub nsw i32 %1268, %1269
%1271 = add nsw i32 %1270, 256
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds float, float* %1267, i64 %1272
store float %1266, float* %1273
%1274 = load float, float* %9
%1275 = load float, float* %11
%1276 = fsub float %1274, %1275
%1277 = load float*, float** %3
%1278 = load i32, i32* %5
%1279 = load i32, i32* %6
%1280 = sub nsw i32 %1278, %1279
%1281 = add nsw i32 %1280, 512
%1282 = sext i32 %1281 to i64
%1283 = getelementptr inbounds float, float* %1277, i64 %1282
store float %1276, float* %1283
br label %1284
1284: ; preds = %1175
%1285 = load i32, i32* %6
%1286 = add nsw i32 %1285, 1
store i32 %1286, i32* %6
br label %1172
1287: ; preds = %1172
br label %1288
1288: ; preds = %1287
%1289 = load i32, i32* %5
%1290 = add nsw i32 %1289, 512
store i32 %1290, i32* %5
br label %1114
1291: ; preds = %1114
store i32 0, i32* %5
br label %1292
1292: ; preds = %1466, %1291
%1293 = load i32, i32* %5
%1294 = icmp slt i32 %1293, 2048
br i1 %1294, label %1295, label %1469
1295: ; preds = %1292
store i32 2, i32* %7
%1296 = load float*, float** %3
%1297 = load i32, i32* %5
%1298 = sext i32 %1297 to i64
%1299 = getelementptr inbounds float, float* %1296, i64 %1298
%1300 = load float, float* %1299
store float %1300, float* %8
%1301 = load float*, float** %3
%1302 = load i32, i32* %5
%1303 = add nsw i32 %1302, 512
%1304 = sext i32 %1303 to i64
%1305 = getelementptr inbounds float, float* %1301, i64 %1304
%1306 = load float, float* %1305
store float %1306, float* %9
%1307 = load float, float* %8
%1308 = load float, float* %9
%1309 = fadd float %1307, %1308
%1310 = load float*, float** %3
%1311 = load i32, i32* %5
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds float, float* %1310, i64 %1312
store float %1309, float* %1313
%1314 = load float, float* %8
%1315 = load float, float* %9
%1316 = fsub float %1314, %1315
%1317 = load float*, float** %3
%1318 = load i32, i32* %5
%1319 = add nsw i32 %1318, 512
%1320 = sext i32 %1319 to i64
%1321 = getelementptr inbounds float, float* %1317, i64 %1320
store float %1316, float* %1321
%1322 = load float*, float** %3
%1323 = load i32, i32* %5
%1324 = add nsw i32 %1323, 256
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds float, float* %1322, i64 %1325
%1327 = load float, float* %1326
store float %1327, float* %8
%1328 = load float*, float** %3
%1329 = load i32, i32* %5
%1330 = add nsw i32 %1329, 768
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds float, float* %1328, i64 %1331
%1333 = load float, float* %1332
store float %1333, float* %9
%1334 = load float, float* %8
%1335 = load float, float* %9
%1336 = fadd float %1334, %1335
%1337 = load float*, float** %3
%1338 = load i32, i32* %5
%1339 = add nsw i32 %1338, 256
%1340 = sext i32 %1339 to i64
%1341 = getelementptr inbounds float, float* %1337, i64 %1340
store float %1336, float* %1341
%1342 = load float, float* %8
%1343 = load float, float* %9
%1344 = fsub float %1342, %1343
%1345 = load float*, float** %3
%1346 = load i32, i32* %5
%1347 = add nsw i32 %1346, 768
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds float, float* %1345, i64 %1348
store float %1344, float* %1349
store i32 1, i32* %6
br label %1350
1350: ; preds = %1462, %1295
%1351 = load i32, i32* %6
%1352 = icmp slt i32 %1351, 256
br i1 %1352, label %1353, label %1465
1353: ; preds = %1350
%1354 = load float*, float** %4
%1355 = load i32, i32* %7
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds float, float* %1354, i64 %1356
%1358 = load float, float* %1357
store float %1358, float* %12
%1359 = load float*, float** %4
%1360 = load i32, i32* %7
%1361 = add nsw i32 %1360, 512
%1362 = sext i32 %1361 to i64
%1363 = getelementptr inbounds float, float* %1359, i64 %1362
%1364 = load float, float* %1363
store float %1364, float* %13
%1365 = load float*, float** %3
%1366 = load i32, i32* %5
%1367 = load i32, i32* %6
%1368 = add nsw i32 %1366, %1367
%1369 = sext i32 %1368 to i64
%1370 = getelementptr inbounds float, float* %1365, i64 %1369
%1371 = load float, float* %1370
store float %1371, float* %8
%1372 = load float*, float** %3
%1373 = load i32, i32* %5
%1374 = load i32, i32* %6
%1375 = sub nsw i32 %1373, %1374
%1376 = add nsw i32 %1375, 512
%1377 = sext i32 %1376 to i64
%1378 = getelementptr inbounds float, float* %1372, i64 %1377
%1379 = load float, float* %1378
store float %1379, float* %9
%1380 = load float*, float** %3
%1381 = load i32, i32* %5
%1382 = load i32, i32* %6
%1383 = add nsw i32 %1381, %1382
%1384 = add nsw i32 %1383, 512
%1385 = sext i32 %1384 to i64
%1386 = getelementptr inbounds float, float* %1380, i64 %1385
%1387 = load float, float* %1386
%1388 = load float, float* %13
%1389 = load float*, float** %3
%1390 = load i32, i32* %5
%1391 = load i32, i32* %6
%1392 = sub nsw i32 %1390, %1391
%1393 = add nsw i32 %1392, 1024
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds float, float* %1389, i64 %1394
%1396 = load float, float* %1395
%1397 = load float, float* %12
%1398 = fmul float %1396, %1397
%1399 = call float @llvm.fmuladd.f32(float %1387, float %1388, float %1398)
store float %1399, float* %10
%1400 = load float*, float** %3
%1401 = load i32, i32* %5
%1402 = load i32, i32* %6
%1403 = add nsw i32 %1401, %1402
%1404 = add nsw i32 %1403, 512
%1405 = sext i32 %1404 to i64
%1406 = getelementptr inbounds float, float* %1400, i64 %1405
%1407 = load float, float* %1406
%1408 = load float, float* %12
%1409 = load float*, float** %3
%1410 = load i32, i32* %5
%1411 = load i32, i32* %6
%1412 = sub nsw i32 %1410, %1411
%1413 = add nsw i32 %1412, 1024
%1414 = sext i32 %1413 to i64
%1415 = getelementptr inbounds float, float* %1409, i64 %1414
%1416 = load float, float* %1415
%1417 = load float, float* %13
%1418 = fmul float %1416, %1417
%1419 = fneg float %1418
%1420 = call float @llvm.fmuladd.f32(float %1407, float %1408, float %1419)
store float %1420, float* %11
%1421 = load i32, i32* %7
%1422 = add nsw i32 %1421, 2
store i32 %1422, i32* %7
%1423 = load float, float* %8
%1424 = load float, float* %10
%1425 = fadd float %1423, %1424
%1426 = load float*, float** %3
%1427 = load i32, i32* %5
%1428 = load i32, i32* %6
%1429 = add nsw i32 %1427, %1428
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds float, float* %1426, i64 %1430
store float %1425, float* %1431
%1432 = load float, float* %8
%1433 = load float, float* %10
%1434 = fsub float %1432, %1433
%1435 = load float*, float** %3
%1436 = load i32, i32* %5
%1437 = load i32, i32* %6
%1438 = add nsw i32 %1436, %1437
%1439 = add nsw i32 %1438, 512
%1440 = sext i32 %1439 to i64
%1441 = getelementptr inbounds float, float* %1435, i64 %1440
store float %1434, float* %1441
%1442 = load float, float* %9
%1443 = load float, float* %11
%1444 = fadd float %1442, %1443
%1445 = load float*, float** %3
%1446 = load i32, i32* %5
%1447 = load i32, i32* %6
%1448 = sub nsw i32 %1446, %1447
%1449 = add nsw i32 %1448, 512
%1450 = sext i32 %1449 to i64
%1451 = getelementptr inbounds float, float* %1445, i64 %1450
store float %1444, float* %1451
%1452 = load float, float* %9
%1453 = load float, float* %11
%1454 = fsub float %1452, %1453
%1455 = load float*, float** %3
%1456 = load i32, i32* %5
%1457 = load i32, i32* %6
%1458 = sub nsw i32 %1456, %1457
%1459 = add nsw i32 %1458, 1024
%1460 = sext i32 %1459 to i64
%1461 = getelementptr inbounds float, float* %1455, i64 %1460
store float %1454, float* %1461
br label %1462
1462: ; preds = %1353
%1463 = load i32, i32* %6
%1464 = add nsw i32 %1463, 1
store i32 %1464, i32* %6
br label %1350
1465: ; preds = %1350
br label %1466
1466: ; preds = %1465
%1467 = load i32, i32* %5
%1468 = add nsw i32 %1467, 1024
store i32 %1468, i32* %5
br label %1292
1469: ; preds = %1292
store i32 1, i32* %7
%1470 = load float*, float** %3
%1471 = getelementptr inbounds float, float* %1470, i64 0
%1472 = load float, float* %1471
store float %1472, float* %8
%1473 = load float*, float** %3
%1474 = getelementptr inbounds float, float* %1473, i64 1024
%1475 = load float, float* %1474
store float %1475, float* %9
%1476 = load float, float* %8
%1477 = load float, float* %9
%1478 = fadd float %1476, %1477
%1479 = load float*, float** %3
%1480 = getelementptr inbounds float, float* %1479, i64 0
store float %1478, float* %1480
%1481 = load float, float* %8
%1482 = load float, float* %9
%1483 = fsub float %1481, %1482
%1484 = load float*, float** %3
%1485 = getelementptr inbounds float, float* %1484, i64 1024
store float %1483, float* %1485
%1486 = load float*, float** %3
%1487 = getelementptr inbounds float, float* %1486, i64 512
%1488 = load float, float* %1487
store float %1488, float* %8
%1489 = load float*, float** %3
%1490 = getelementptr inbounds float, float* %1489, i64 1536
%1491 = load float, float* %1490
store float %1491, float* %9
%1492 = load float, float* %8
%1493 = load float, float* %9
%1494 = fadd float %1492, %1493
%1495 = load float*, float** %3
%1496 = getelementptr inbounds float, float* %1495, i64 512
store float %1494, float* %1496
%1497 = load float, float* %8
%1498 = load float, float* %9
%1499 = fsub float %1497, %1498
%1500 = load float*, float** %3
%1501 = getelementptr inbounds float, float* %1500, i64 1536
store float %1499, float* %1501
store i32 1, i32* %6
br label %1502
1502: ; preds = %1599, %1469
%1503 = load i32, i32* %6
%1504 = icmp slt i32 %1503, 512
br i1 %1504, label %1505, label %1602
1505: ; preds = %1502
%1506 = load float*, float** %4
%1507 = load i32, i32* %7
%1508 = sext i32 %1507 to i64
%1509 = getelementptr inbounds float, float* %1506, i64 %1508
%1510 = load float, float* %1509
store float %1510, float* %12
%1511 = load float*, float** %4
%1512 = load i32, i32* %7
%1513 = add nsw i32 %1512, 512
%1514 = sext i32 %1513 to i64
%1515 = getelementptr inbounds float, float* %1511, i64 %1514
%1516 = load float, float* %1515
store float %1516, float* %13
%1517 = load float*, float** %3
%1518 = load i32, i32* %6
%1519 = sext i32 %1518 to i64
%1520 = getelementptr inbounds float, float* %1517, i64 %1519
%1521 = load float, float* %1520
store float %1521, float* %8
%1522 = load float*, float** %3
%1523 = load i32, i32* %6
%1524 = sub nsw i32 0, %1523
%1525 = add nsw i32 %1524, 1024
%1526 = sext i32 %1525 to i64
%1527 = getelementptr inbounds float, float* %1522, i64 %1526
%1528 = load float, float* %1527
store float %1528, float* %9
%1529 = load float*, float** %3
%1530 = load i32, i32* %6
%1531 = add nsw i32 %1530, 1024
%1532 = sext i32 %1531 to i64
%1533 = getelementptr inbounds float, float* %1529, i64 %1532
%1534 = load float, float* %1533
%1535 = load float, float* %13
%1536 = load float*, float** %3
%1537 = load i32, i32* %6
%1538 = sub nsw i32 0, %1537
%1539 = add nsw i32 %1538, 2048
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds float, float* %1536, i64 %1540
%1542 = load float, float* %1541
%1543 = load float, float* %12
%1544 = fmul float %1542, %1543
%1545 = call float @llvm.fmuladd.f32(float %1534, float %1535, float %1544)
store float %1545, float* %10
%1546 = load float*, float** %3
%1547 = load i32, i32* %6
%1548 = add nsw i32 %1547, 1024
%1549 = sext i32 %1548 to i64
%1550 = getelementptr inbounds float, float* %1546, i64 %1549
%1551 = load float, float* %1550
%1552 = load float, float* %12
%1553 = load float*, float** %3
%1554 = load i32, i32* %6
%1555 = sub nsw i32 0, %1554
%1556 = add nsw i32 %1555, 2048
%1557 = sext i32 %1556 to i64
%1558 = getelementptr inbounds float, float* %1553, i64 %1557
%1559 = load float, float* %1558
%1560 = load float, float* %13
%1561 = fmul float %1559, %1560
%1562 = fneg float %1561
%1563 = call float @llvm.fmuladd.f32(float %1551, float %1552, float %1562)
store float %1563, float* %11
%1564 = load i32, i32* %7
%1565 = add nsw i32 %1564, 1
store i32 %1565, i32* %7
%1566 = load float, float* %8
%1567 = load float, float* %10
%1568 = fadd float %1566, %1567
%1569 = load float*, float** %3
%1570 = load i32, i32* %6
%1571 = sext i32 %1570 to i64
%1572 = getelementptr inbounds float, float* %1569, i64 %1571
store float %1568, float* %1572
%1573 = load float, float* %8
%1574 = load float, float* %10
%1575 = fsub float %1573, %1574
%1576 = load float*, float** %3
%1577 = load i32, i32* %6
%1578 = add nsw i32 %1577, 1024
%1579 = sext i32 %1578 to i64
%1580 = getelementptr inbounds float, float* %1576, i64 %1579
store float %1575, float* %1580
%1581 = load float, float* %9
%1582 = load float, float* %11
%1583 = fadd float %1581, %1582
%1584 = load float*, float** %3
%1585 = load i32, i32* %6
%1586 = sub nsw i32 0, %1585
%1587 = add nsw i32 %1586, 1024
%1588 = sext i32 %1587 to i64
%1589 = getelementptr inbounds float, float* %1584, i64 %1588
store float %1583, float* %1589
%1590 = load float, float* %9
%1591 = load float, float* %11
%1592 = fsub float %1590, %1591
%1593 = load float*, float** %3
%1594 = load i32, i32* %6
%1595 = sub nsw i32 0, %1594
%1596 = add nsw i32 %1595, 2048
%1597 = sext i32 %1596 to i64
%1598 = getelementptr inbounds float, float* %1593, i64 %1597
store float %1592, float* %1598
br label %1599
1599: ; preds = %1505
%1600 = load i32, i32* %6
%1601 = add nsw i32 %1600, 1
store i32 %1601, i32* %6
br label %1502
1602: ; preds = %1502
ret void
}

LLVM IR (-O2):
define void @DFT2048(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, 512
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, 256
br i1 %236, label %237, label %84
237: ; preds = %84
%238 = getelementptr inbounds float, float* %1, i64 128
%239 = getelementptr inbounds float, float* %1, i64 640
%240 = getelementptr inbounds float, float* %1, i64 256
%241 = getelementptr inbounds float, float* %1, i64 768
%242 = getelementptr inbounds float, float* %1, i64 384
%243 = getelementptr inbounds float, float* %1, i64 896
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, 2032
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 [ 64, %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, 512
%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, 64
%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, 2016
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 [ 32, %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, 512
%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, 32
%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, 1984
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 [ 16, %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, 512
%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, 16
%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, 1920
br i1 %490, label %438, label %491
491: ; preds = %488, %541
%492 = phi i64 [ %542, %541 ], [ 0, %488 ]
%493 = getelementptr inbounds float, float* %0, i64 %492
%494 = load float, float* %493
%495 = or i64 %492, 128
%496 = getelementptr inbounds float, float* %0, i64 %495
%497 = load float, float* %496
%498 = fadd float %494, %497
store float %498, float* %493
%499 = fsub float %494, %497
store float %499, float* %496
%500 = or i64 %492, 64
%501 = getelementptr inbounds float, float* %0, i64 %500
%502 = load float, float* %501
%503 = or i64 %492, 192
%504 = getelementptr inbounds float, float* %0, i64 %503
%505 = load float, float* %504
%506 = fadd float %502, %505
store float %506, float* %501
%507 = fsub float %502, %505
store float %507, float* %504
br label %508
508: ; preds = %491, %508
%509 = phi i64 [ 8, %491 ], [ %534, %508 ]
%510 = phi i64 [ 1, %491 ], [ %539, %508 ]
%511 = getelementptr inbounds float, float* %1, i64 %509
%512 = load float, float* %511
%513 = add nuw nsw i64 %509, 512
%514 = getelementptr inbounds float, float* %1, i64 %513
%515 = load float, float* %514
%516 = add nuw nsw i64 %510, %492
%517 = getelementptr inbounds float, float* %0, i64 %516
%518 = load float, float* %517
%519 = sub nsw i64 %492, %510
%520 = add nsw i64 %519, 128
%521 = getelementptr inbounds float, float* %0, i64 %520
%522 = load float, float* %521
%523 = add nuw nsw i64 %516, 128
%524 = getelementptr inbounds float, float* %0, i64 %523
%525 = load float, float* %524
%526 = add nsw i64 %519, 256
%527 = getelementptr inbounds float, float* %0, i64 %526
%528 = load float, float* %527
%529 = fmul float %512, %528
%530 = tail call float @llvm.fmuladd.f32(float %525, float %515, float %529)
%531 = fneg float %528
%532 = fmul float %515, %531
%533 = tail call float @llvm.fmuladd.f32(float %525, float %512, float %532)
%534 = add nuw nsw i64 %509, 8
%535 = fadd float %518, %530
store float %535, float* %517
%536 = fsub float %518, %530
store float %536, float* %524
%537 = fadd float %522, %533
store float %537, float* %521
%538 = fsub float %522, %533
store float %538, float* %527
%539 = add nuw nsw i64 %510, 1
%540 = icmp eq i64 %539, 64
br i1 %540, label %541, label %508
541: ; preds = %508
%542 = add nuw nsw i64 %492, 256
%543 = icmp ult i64 %492, 1792
br i1 %543, label %491, label %544
544: ; preds = %541, %594
%545 = phi i64 [ %595, %594 ], [ 0, %541 ]
%546 = getelementptr inbounds float, float* %0, i64 %545
%547 = load float, float* %546
%548 = or i64 %545, 256
%549 = getelementptr inbounds float, float* %0, i64 %548
%550 = load float, float* %549
%551 = fadd float %547, %550
store float %551, float* %546
%552 = fsub float %547, %550
store float %552, float* %549
%553 = or i64 %545, 128
%554 = getelementptr inbounds float, float* %0, i64 %553
%555 = load float, float* %554
%556 = or i64 %545, 384
%557 = getelementptr inbounds float, float* %0, i64 %556
%558 = load float, float* %557
%559 = fadd float %555, %558
store float %559, float* %554
%560 = fsub float %555, %558
store float %560, float* %557
br label %561
561: ; preds = %544, %561
%562 = phi i64 [ 4, %544 ], [ %587, %561 ]
%563 = phi i64 [ 1, %544 ], [ %592, %561 ]
%564 = getelementptr inbounds float, float* %1, i64 %562
%565 = load float, float* %564
%566 = add nuw nsw i64 %562, 512
%567 = getelementptr inbounds float, float* %1, i64 %566
%568 = load float, float* %567
%569 = add nuw nsw i64 %563, %545
%570 = getelementptr inbounds float, float* %0, i64 %569
%571 = load float, float* %570
%572 = sub nsw i64 %545, %563
%573 = add nsw i64 %572, 256
%574 = getelementptr inbounds float, float* %0, i64 %573
%575 = load float, float* %574
%576 = add nuw nsw i64 %569, 256
%577 = getelementptr inbounds float, float* %0, i64 %576
%578 = load float, float* %577
%579 = add nsw i64 %572, 512
%580 = getelementptr inbounds float, float* %0, i64 %579
%581 = load float, float* %580
%582 = fmul float %565, %581
%583 = tail call float @llvm.fmuladd.f32(float %578, float %568, float %582)
%584 = fneg float %581
%585 = fmul float %568, %584
%586 = tail call float @llvm.fmuladd.f32(float %578, float %565, float %585)
%587 = add nuw nsw i64 %562, 4
%588 = fadd float %571, %583
store float %588, float* %570
%589 = fsub float %571, %583
store float %589, float* %577
%590 = fadd float %575, %586
store float %590, float* %574
%591 = fsub float %575, %586
store float %591, float* %580
%592 = add nuw nsw i64 %563, 1
%593 = icmp eq i64 %592, 128
br i1 %593, label %594, label %561
594: ; preds = %561
%595 = add nuw nsw i64 %545, 512
%596 = icmp ult i64 %545, 1536
br i1 %596, label %544, label %597
597: ; preds = %594
%598 = load float, float* %0
%599 = getelementptr inbounds float, float* %0, i64 512
%600 = load float, float* %599
%601 = fadd float %598, %600
store float %601, float* %0
%602 = fsub float %598, %600
store float %602, float* %599
%603 = getelementptr inbounds float, float* %0, i64 256
%604 = load float, float* %603
%605 = getelementptr inbounds float, float* %0, i64 768
%606 = load float, float* %605
%607 = fadd float %604, %606
store float %607, float* %603
%608 = fsub float %604, %606
store float %608, float* %605
br label %609
609: ; preds = %597, %609
%610 = phi i64 [ 2, %597 ], [ %633, %609 ]
%611 = phi i64 [ 1, %597 ], [ %638, %609 ]
%612 = getelementptr inbounds float, float* %1, i64 %610
%613 = load float, float* %612
%614 = add nuw nsw i64 %610, 512
%615 = getelementptr inbounds float, float* %1, i64 %614
%616 = load float, float* %615
%617 = getelementptr inbounds float, float* %0, i64 %611
%618 = load float, float* %617
%619 = sub nsw i64 512, %611
%620 = getelementptr inbounds float, float* %0, i64 %619
%621 = load float, float* %620
%622 = add nuw nsw i64 %611, 512
%623 = getelementptr inbounds float, float* %0, i64 %622
%624 = load float, float* %623
%625 = sub nsw i64 1024, %611
%626 = getelementptr inbounds float, float* %0, i64 %625
%627 = load float, float* %626
%628 = fmul float %613, %627
%629 = tail call float @llvm.fmuladd.f32(float %624, float %616, float %628)
%630 = fneg float %627
%631 = fmul float %616, %630
%632 = tail call float @llvm.fmuladd.f32(float %624, float %613, float %631)
%633 = add nuw nsw i64 %610, 2
%634 = fadd float %618, %629
store float %634, float* %617
%635 = fsub float %618, %629
store float %635, float* %623
%636 = fadd float %621, %632
store float %636, float* %620
%637 = fsub float %621, %632
store float %637, float* %626
%638 = add nuw nsw i64 %611, 1
%639 = icmp eq i64 %638, 256
br i1 %639, label %640, label %609
640: ; preds = %609
%641 = getelementptr inbounds float, float* %0, i64 1024
%642 = load float, float* %641
%643 = getelementptr inbounds float, float* %0, i64 1536
%644 = load float, float* %643
%645 = fadd float %642, %644
store float %645, float* %641
%646 = fsub float %642, %644
store float %646, float* %643
%647 = getelementptr inbounds float, float* %0, i64 1280
%648 = load float, float* %647
%649 = getelementptr inbounds float, float* %0, i64 1792
%650 = load float, float* %649
%651 = fadd float %648, %650
store float %651, float* %647
%652 = fsub float %648, %650
store float %652, float* %649
br label %653
653: ; preds = %653, %640
%654 = phi i64 [ 2, %640 ], [ %678, %653 ]
%655 = phi i64 [ 1, %640 ], [ %683, %653 ]
%656 = getelementptr inbounds float, float* %1, i64 %654
%657 = load float, float* %656
%658 = add nuw nsw i64 %654, 512
%659 = getelementptr inbounds float, float* %1, i64 %658
%660 = load float, float* %659
%661 = add nuw nsw i64 %655, 1024
%662 = getelementptr inbounds float, float* %0, i64 %661
%663 = load float, float* %662
%664 = sub nsw i64 1536, %655
%665 = getelementptr inbounds float, float* %0, i64 %664
%666 = load float, float* %665
%667 = add nuw nsw i64 %655, 1536
%668 = getelementptr inbounds float, float* %0, i64 %667
%669 = load float, float* %668
%670 = sub nsw i64 2048, %655
%671 = getelementptr inbounds float, float* %0, i64 %670
%672 = load float, float* %671
%673 = fmul float %657, %672
%674 = tail call float @llvm.fmuladd.f32(float %669, float %660, float %673)
%675 = fneg float %672
%676 = fmul float %660, %675
%677 = tail call float @llvm.fmuladd.f32(float %669, float %657, float %676)
%678 = add nuw nsw i64 %654, 2
%679 = fadd float %663, %674
store float %679, float* %662
%680 = fsub float %663, %674
store float %680, float* %668
%681 = fadd float %666, %677
store float %681, float* %665
%682 = fsub float %666, %677
store float %682, float* %671
%683 = add nuw nsw i64 %655, 1
%684 = icmp eq i64 %683, 256
br i1 %684, label %685, label %653
685: ; preds = %653
%686 = load float, float* %0
%687 = load float, float* %641
%688 = fadd float %686, %687
store float %688, float* %0
%689 = fsub float %686, %687
store float %689, float* %641
%690 = load float, float* %599
%691 = load float, float* %643
%692 = fadd float %690, %691
store float %692, float* %599
%693 = fsub float %690, %691
store float %693, float* %643
br label %694
694: ; preds = %685, %694
%695 = phi i64 [ 1, %685 ], [ %717, %694 ]
%696 = getelementptr inbounds float, float* %1, i64 %695
%697 = load float, float* %696
%698 = add nuw nsw i64 %695, 512
%699 = getelementptr inbounds float, float* %1, i64 %698
%700 = load float, float* %699
%701 = getelementptr inbounds float, float* %0, i64 %695
%702 = load float, float* %701
%703 = sub nuw nsw i64 1024, %695
%704 = getelementptr inbounds float, float* %0, i64 %703
%705 = load float, float* %704
%706 = add nuw nsw i64 %695, 1024
%707 = getelementptr inbounds float, float* %0, i64 %706
%708 = load float, float* %707
%709 = sub nuw nsw i64 2048, %695
%710 = getelementptr inbounds float, float* %0, i64 %709
%711 = load float, float* %710
%712 = fmul float %697, %711
%713 = tail call float @llvm.fmuladd.f32(float %708, float %700, float %712)
%714 = fneg float %711
%715 = fmul float %700, %714
%716 = tail call float @llvm.fmuladd.f32(float %708, float %697, float %715)
%717 = add nuw nsw i64 %695, 1
%718 = fadd float %702, %713
store float %718, float* %701
%719 = fsub float %702, %713
store float %719, float* %707
%720 = fadd float %705, %716
store float %720, float* %704
%721 = fsub float %705, %716
store float %721, float* %710
%722 = icmp eq i64 %717, 512
br i1 %722, label %723, label %694
723: ; preds = %694
ret void
}