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


x86 assembly (clang, -O0):
<DFT32768>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    122c <DFT32768+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 <DFT32768+0x13>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    1418 <DFT32768+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  0x2cbb(%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  0x2c86(%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 <DFT32768+0x133>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    1697 <DFT32768+0x597>
movl   $0x800,-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 <DFT32768+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    $0x2000,%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    $0x800,%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 <DFT32768+0x3fc>
jmp    1689 <DFT32768+0x589>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    141f <DFT32768+0x31f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    1916 <DFT32768+0x816>
movl   $0x400,-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    1903 <DFT32768+0x803>
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    $0x2000,%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    $0x400,%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 <DFT32768+0x67b>
jmp    1908 <DFT32768+0x808>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    169e <DFT32768+0x59e>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    1b95 <DFT32768+0xa95>
movl   $0x200,-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    1b82 <DFT32768+0xa82>
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    $0x2000,%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    $0x200,%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    19fa <DFT32768+0x8fa>
jmp    1b87 <DFT32768+0xa87>
mov    -0x14(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x14(%rbp)
jmp    191d <DFT32768+0x81d>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    1e1f <DFT32768+0xd1f>
movl   $0x100,-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    1e0a <DFT32768+0xd0a>
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    $0x2000,%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    $0x100,%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    1c79 <DFT32768+0xb79>
jmp    1e0f <DFT32768+0xd0f>
mov    -0x14(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x14(%rbp)
jmp    1b9c <DFT32768+0xa9c>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    20c4 <DFT32768+0xfc4>
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    $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    20af <DFT32768+0xfaf>
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    $0x2000,%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    $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    $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    1f0f <DFT32768+0xe0f>
jmp    20b4 <DFT32768+0xfb4>
mov    -0x14(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x14(%rbp)
jmp    1e26 <DFT32768+0xd26>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    2370 <DFT32768+0x1270>
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    $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    235b <DFT32768+0x125b>
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    $0x2000,%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    $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    $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    21ba <DFT32768+0x10ba>
jmp    2360 <DFT32768+0x1260>
mov    -0x14(%rbp),%eax
add    $0x200,%eax
mov    %eax,-0x14(%rbp)
jmp    20cb <DFT32768+0xfcb>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    261c <DFT32768+0x151c>
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    $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    2607 <DFT32768+0x1507>
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    $0x2000,%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    $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    $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    2466 <DFT32768+0x1366>
jmp    260c <DFT32768+0x150c>
mov    -0x14(%rbp),%eax
add    $0x400,%eax
mov    %eax,-0x14(%rbp)
jmp    2377 <DFT32768+0x1277>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    28c8 <DFT32768+0x17c8>
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    $0x400,%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    $0x400,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x200,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x600,%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    $0x200,%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    $0x600,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x200,-0x18(%rbp)
jge    28b3 <DFT32768+0x17b3>
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    $0x2000,%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    $0x400,%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    $0x400,%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    $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    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    $0x400,%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    $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    $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    $0x400,%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    $0x400,%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    $0x800,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    2712 <DFT32768+0x1612>
jmp    28b8 <DFT32768+0x17b8>
mov    -0x14(%rbp),%eax
add    $0x800,%eax
mov    %eax,-0x14(%rbp)
jmp    2623 <DFT32768+0x1523>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    2b74 <DFT32768+0x1a74>
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    $0x800,%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    $0x800,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x400,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0xc00,%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    $0x400,%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    $0xc00,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x400,-0x18(%rbp)
jge    2b5f <DFT32768+0x1a5f>
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    $0x2000,%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    $0x800,%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    $0x800,%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    $0x1000,%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    $0x800,%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    $0x1000,%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    $0x800,%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    $0x800,%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    $0x1000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    29be <DFT32768+0x18be>
jmp    2b64 <DFT32768+0x1a64>
mov    -0x14(%rbp),%eax
add    $0x1000,%eax
mov    %eax,-0x14(%rbp)
jmp    28cf <DFT32768+0x17cf>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    2e20 <DFT32768+0x1d20>
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    $0x1000,%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    $0x1000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x800,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1800,%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    $0x800,%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    $0x1800,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x800,-0x18(%rbp)
jge    2e0b <DFT32768+0x1d0b>
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    $0x2000,%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    $0x1000,%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    $0x1000,%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    $0x2000,%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    $0x1000,%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    $0x2000,%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    $0x1000,%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    $0x1000,%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    $0x2000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    2c6a <DFT32768+0x1b6a>
jmp    2e10 <DFT32768+0x1d10>
mov    -0x14(%rbp),%eax
add    $0x2000,%eax
mov    %eax,-0x14(%rbp)
jmp    2b7b <DFT32768+0x1a7b>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8000,-0x14(%rbp)
jge    30cc <DFT32768+0x1fcc>
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    $0x2000,%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    $0x2000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1000,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x3000,%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    $0x1000,%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    $0x3000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
cmpl   $0x1000,-0x18(%rbp)
jge    30b7 <DFT32768+0x1fb7>
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    $0x2000,%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    $0x2000,%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    $0x2000,%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    $0x4000,%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    $0x2000,%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    $0x4000,%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    $0x2000,%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    $0x2000,%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    $0x4000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    2f16 <DFT32768+0x1e16>
jmp    30bc <DFT32768+0x1fbc>
mov    -0x14(%rbp),%eax
add    $0x4000,%eax
mov    %eax,-0x14(%rbp)
jmp    2e27 <DFT32768+0x1d27>
movl   $0x1,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10000(%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,0x10000(%rax)
mov    -0x8(%rbp),%rax
movss  0x8000(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18000(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8000(%rax)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18000(%rax)
movl   $0x1,-0x18(%rbp)
cmpl   $0x2000,-0x18(%rbp)
jge    32f7 <DFT32768+0x21f7>
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    $0x2000,%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    $0x4000,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x4000,%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    $0x8000,%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    $0x4000,%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    $0x8000,%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    $0x4000,%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    $0x4000,%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    $0x8000,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    316e <DFT32768+0x206e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<DFT32768>:
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    $0x20000,%rax
jne    1110 <DFT32768+0x10>
xor    %eax,%eax
movaps 0x1ddf(%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    $0x20000,%rax
jne    1230 <DFT32768+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  0x2000(%rsi),%xmm1
movss  0xa000(%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  0x4000(%rsi),%xmm0
movss  0xc000(%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  0x6000(%rsi),%xmm0
movss  0xe000(%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    $0x7ff0,%rax
jb     1450 <DFT32768+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    $0xffffffffffffe400,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopw   0x0(%rax,%rax,1)
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%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    $0x400,%rax
jne    1680 <DFT32768+0x580>
lea    0x20(%r10),%rax
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%r9
cmp    $0x7fe0,%r10
mov    %rax,%r10
jb     1610 <DFT32768+0x510>
mov    $0xfc,%r8d
mov    $0x84,%r9d
xor    %r10d,%r10d
nopw   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    $0xffffffffffffe200,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopl   0x0(%rax)
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%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    $0x200,%rax
jne    17a0 <DFT32768+0x6a0>
lea    0x40(%r10),%rax
add    $0x100,%r8
add    $0x100,%r9
cmp    $0x7fc0,%r10
mov    %rax,%r10
jb     1730 <DFT32768+0x630>
mov    $0x1fc,%r8d
mov    $0x104,%r9d
xor    %r10d,%r10d
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    $0xffffffffffffe100,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%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    $0x100,%rax
jne    18c0 <DFT32768+0x7c0>
lea    0x80(%r10),%rax
add    $0x200,%r8
add    $0x200,%r9
cmp    $0x7f80,%r10
mov    %rax,%r10
jb     1850 <DFT32768+0x750>
mov    $0x3fc,%r8d
mov    $0x204,%r9d
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    $0xffffffffffffe080,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%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
sub    $0xffffffffffffff80,%rax
jne    1a00 <DFT32768+0x900>
lea    0x100(%r10),%rax
add    $0x400,%r8
add    $0x400,%r9
cmp    $0x7f00,%r10
mov    %rax,%r10
jb     1990 <DFT32768+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    $0xffffffffffffe040,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%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    $0x40,%rax
jne    1b40 <DFT32768+0xa40>
lea    0x200(%r10),%rax
add    $0x800,%r8
add    $0x800,%r9
cmp    $0x7e00,%r10
mov    %rax,%r10
jb     1ad0 <DFT32768+0x9d0>
mov    $0xffc,%r8d
mov    $0x804,%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     $0x800,%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     $0x400,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0xc00,%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    $0xffffffffffffe020,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%rsi,%rax,4),%xmm1
movss  -0x800(%rdi,%rcx,1),%xmm2
ff ff
movss  -0x800(%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,-0x800(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x800(%rdi,%rdx,1)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x20,%rax
jne    1c80 <DFT32768+0xb80>
lea    0x400(%r10),%rax
add    $0x1000,%r8
add    $0x1000,%r9
cmp    $0x7c00,%r10
mov    %rax,%r10
jb     1c10 <DFT32768+0xb10>
mov    $0x1ffc,%r8d
mov    $0x1004,%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     $0x1000,%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     $0x800,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x1800,%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    $0xffffffffffffe010,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%rsi,%rax,4),%xmm1
movss  -0x1000(%rdi,%rcx,1),%xmm2
ff ff
movss  -0x1000(%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,-0x1000(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x1000(%rdi,%rdx,1)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x10,%rax
jne    1dc0 <DFT32768+0xcc0>
lea    0x800(%r10),%rax
add    $0x2000,%r8
add    $0x2000,%r9
cmp    $0x7800,%r10
mov    %rax,%r10
jb     1d50 <DFT32768+0xc50>
mov    $0x3ffc,%r8d
mov    $0x2004,%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     $0x2000,%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     $0x1000,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x3000,%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    $0xffffffffffffe008,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%rsi,%rax,4),%xmm1
movss  -0x2000(%rdi,%rcx,1),%xmm2
ff ff
movss  -0x2000(%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,-0x2000(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x2000(%rdi,%rdx,1)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x8,%rax
jne    1f00 <DFT32768+0xe00>
lea    0x1000(%r10),%rax
add    $0x4000,%r8
add    $0x4000,%r9
cmp    $0x7000,%r10
mov    %rax,%r10
jb     1e90 <DFT32768+0xd90>
mov    $0x7ffc,%r8d
mov    $0x4004,%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     $0x4000,%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     $0x2000,%rcx
movss  (%rdi,%rcx,1),%xmm0
or     $0x6000,%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    $0xffffffffffffe004,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nop
movss  0x8000(%rsi,%rax,4),%xmm0
movss  0x10000(%rsi,%rax,4),%xmm1
movss  -0x4000(%rdi,%rcx,1),%xmm2
ff ff
movss  -0x4000(%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,-0x4000(%rdi,%rcx,1)
ff ff
subss  %xmm6,%xmm2
movss  %xmm2,(%rdi,%rcx,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x4000(%rdi,%rdx,1)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rcx
add    $0x4,%rax
jne    2040 <DFT32768+0xf40>
lea    0x2000(%r10),%rax
add    $0x8000,%r8
add    $0x8000,%r9
cmp    $0x6000,%r10
mov    %rax,%r10
jb     1fd0 <DFT32768+0xed0>
movss  (%rdi),%xmm0
movss  0x8000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x8000(%rdi)
movss  0x4000(%rdi),%xmm0
movss  0xc000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x4000(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0xc000(%rdi)
mov    $0x4,%eax
mov    $0x1fff,%ecx
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,2),%xmm0
movss  0x8000(%rsi,%rax,2),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  (%rdi,%rcx,4),%xmm3
movss  0x8000(%rdi,%rax,1),%xmm4
movss  0x8000(%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,0x8000(%rdi,%rax,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
subss  %xmm4,%xmm3
movss  %xmm3,0x8000(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x1000,%rcx
jne    2150 <DFT32768+0x1050>
movss  0x10000(%rdi),%xmm0
movss  0x18000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x10000(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x18000(%rdi)
movss  0x14000(%rdi),%xmm0
movss  0x1c000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x14000(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x1c000(%rdi)
mov    $0x8002,%eax
mov    $0x7fff,%ecx
nopl   0x0(%rax)
movss  -0x20000(%rsi,%rax,4),%xmm0
fe ff
movss  -0x18000(%rsi,%rax,4),%xmm1
fe ff
movss  (%rdi,%rax,2),%xmm2
movss  -0x8000(%rdi,%rcx,4),%xmm3
ff ff
movss  0x8000(%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,0x8000(%rdi,%rax,2)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x8000(%rdi,%rcx,4)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x2,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x7000,%rcx
jne    2240 <DFT32768+0x1140>
movss  (%rdi),%xmm0
movss  0x10000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x10000(%rdi)
movss  0x8000(%rdi),%xmm0
movss  0x18000(%rdi),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x8000(%rdi)
subss  %xmm1,%xmm0
movss  %xmm0,0x18000(%rdi)
mov    $0x4,%eax
mov    $0x7fff,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,1),%xmm0
movss  0x8000(%rsi,%rax,1),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  -0x10000(%rdi,%rcx,4),%xmm3
ff ff
movss  0x10000(%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,0x10000(%rdi,%rax,1)
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,-0x10000(%rdi,%rcx,4)
ff ff
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x6000,%rcx
jne    2330 <DFT32768+0x1230>
ret

LLVM IR (-O0):
define void @DFT32768(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, 32768
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, 32768
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, 32768
br i1 %226, label %227, label %401
227: ; preds = %224
store i32 2048, 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, 8192
%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, 2048
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, 32768
br i1 %404, label %405, label %579
405: ; preds = %402
store i32 1024, 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, 8192
%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, 1024
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, 32768
br i1 %582, label %583, label %757
583: ; preds = %580
store i32 512, 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, 8192
%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, 512
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, 32768
br i1 %760, label %761, label %935
761: ; preds = %758
store i32 256, 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, 8192
%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, 256
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, 32768
br i1 %938, label %939, label %1113
939: ; preds = %936
store i32 128, 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, 8192
%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, 128
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, 32768
br i1 %1116, label %1117, label %1291
1117: ; preds = %1114
store i32 64, 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, 8192
%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, 64
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, 32768
br i1 %1294, label %1295, label %1469
1295: ; preds = %1292
store i32 32, 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, 8192
%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, 32
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 0, i32* %5
br label %1470
1470: ; preds = %1644, %1469
%1471 = load i32, i32* %5
%1472 = icmp slt i32 %1471, 32768
br i1 %1472, label %1473, label %1647
1473: ; preds = %1470
store i32 16, i32* %7
%1474 = load float*, float** %3
%1475 = load i32, i32* %5
%1476 = sext i32 %1475 to i64
%1477 = getelementptr inbounds float, float* %1474, i64 %1476
%1478 = load float, float* %1477
store float %1478, float* %8
%1479 = load float*, float** %3
%1480 = load i32, i32* %5
%1481 = add nsw i32 %1480, 1024
%1482 = sext i32 %1481 to i64
%1483 = getelementptr inbounds float, float* %1479, i64 %1482
%1484 = load float, float* %1483
store float %1484, float* %9
%1485 = load float, float* %8
%1486 = load float, float* %9
%1487 = fadd float %1485, %1486
%1488 = load float*, float** %3
%1489 = load i32, i32* %5
%1490 = sext i32 %1489 to i64
%1491 = getelementptr inbounds float, float* %1488, i64 %1490
store float %1487, float* %1491
%1492 = load float, float* %8
%1493 = load float, float* %9
%1494 = fsub float %1492, %1493
%1495 = load float*, float** %3
%1496 = load i32, i32* %5
%1497 = add nsw i32 %1496, 1024
%1498 = sext i32 %1497 to i64
%1499 = getelementptr inbounds float, float* %1495, i64 %1498
store float %1494, float* %1499
%1500 = load float*, float** %3
%1501 = load i32, i32* %5
%1502 = add nsw i32 %1501, 512
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds float, float* %1500, i64 %1503
%1505 = load float, float* %1504
store float %1505, float* %8
%1506 = load float*, float** %3
%1507 = load i32, i32* %5
%1508 = add nsw i32 %1507, 1536
%1509 = sext i32 %1508 to i64
%1510 = getelementptr inbounds float, float* %1506, i64 %1509
%1511 = load float, float* %1510
store float %1511, float* %9
%1512 = load float, float* %8
%1513 = load float, float* %9
%1514 = fadd float %1512, %1513
%1515 = load float*, float** %3
%1516 = load i32, i32* %5
%1517 = add nsw i32 %1516, 512
%1518 = sext i32 %1517 to i64
%1519 = getelementptr inbounds float, float* %1515, i64 %1518
store float %1514, float* %1519
%1520 = load float, float* %8
%1521 = load float, float* %9
%1522 = fsub float %1520, %1521
%1523 = load float*, float** %3
%1524 = load i32, i32* %5
%1525 = add nsw i32 %1524, 1536
%1526 = sext i32 %1525 to i64
%1527 = getelementptr inbounds float, float* %1523, i64 %1526
store float %1522, float* %1527
store i32 1, i32* %6
br label %1528
1528: ; preds = %1640, %1473
%1529 = load i32, i32* %6
%1530 = icmp slt i32 %1529, 512
br i1 %1530, label %1531, label %1643
1531: ; preds = %1528
%1532 = load float*, float** %4
%1533 = load i32, i32* %7
%1534 = sext i32 %1533 to i64
%1535 = getelementptr inbounds float, float* %1532, i64 %1534
%1536 = load float, float* %1535
store float %1536, float* %12
%1537 = load float*, float** %4
%1538 = load i32, i32* %7
%1539 = add nsw i32 %1538, 8192
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds float, float* %1537, i64 %1540
%1542 = load float, float* %1541
store float %1542, float* %13
%1543 = load float*, float** %3
%1544 = load i32, i32* %5
%1545 = load i32, i32* %6
%1546 = add nsw i32 %1544, %1545
%1547 = sext i32 %1546 to i64
%1548 = getelementptr inbounds float, float* %1543, i64 %1547
%1549 = load float, float* %1548
store float %1549, float* %8
%1550 = load float*, float** %3
%1551 = load i32, i32* %5
%1552 = load i32, i32* %6
%1553 = sub nsw i32 %1551, %1552
%1554 = add nsw i32 %1553, 1024
%1555 = sext i32 %1554 to i64
%1556 = getelementptr inbounds float, float* %1550, i64 %1555
%1557 = load float, float* %1556
store float %1557, float* %9
%1558 = load float*, float** %3
%1559 = load i32, i32* %5
%1560 = load i32, i32* %6
%1561 = add nsw i32 %1559, %1560
%1562 = add nsw i32 %1561, 1024
%1563 = sext i32 %1562 to i64
%1564 = getelementptr inbounds float, float* %1558, i64 %1563
%1565 = load float, float* %1564
%1566 = load float, float* %13
%1567 = load float*, float** %3
%1568 = load i32, i32* %5
%1569 = load i32, i32* %6
%1570 = sub nsw i32 %1568, %1569
%1571 = add nsw i32 %1570, 2048
%1572 = sext i32 %1571 to i64
%1573 = getelementptr inbounds float, float* %1567, i64 %1572
%1574 = load float, float* %1573
%1575 = load float, float* %12
%1576 = fmul float %1574, %1575
%1577 = call float @llvm.fmuladd.f32(float %1565, float %1566, float %1576)
store float %1577, float* %10
%1578 = load float*, float** %3
%1579 = load i32, i32* %5
%1580 = load i32, i32* %6
%1581 = add nsw i32 %1579, %1580
%1582 = add nsw i32 %1581, 1024
%1583 = sext i32 %1582 to i64
%1584 = getelementptr inbounds float, float* %1578, i64 %1583
%1585 = load float, float* %1584
%1586 = load float, float* %12
%1587 = load float*, float** %3
%1588 = load i32, i32* %5
%1589 = load i32, i32* %6
%1590 = sub nsw i32 %1588, %1589
%1591 = add nsw i32 %1590, 2048
%1592 = sext i32 %1591 to i64
%1593 = getelementptr inbounds float, float* %1587, i64 %1592
%1594 = load float, float* %1593
%1595 = load float, float* %13
%1596 = fmul float %1594, %1595
%1597 = fneg float %1596
%1598 = call float @llvm.fmuladd.f32(float %1585, float %1586, float %1597)
store float %1598, float* %11
%1599 = load i32, i32* %7
%1600 = add nsw i32 %1599, 16
store i32 %1600, i32* %7
%1601 = load float, float* %8
%1602 = load float, float* %10
%1603 = fadd float %1601, %1602
%1604 = load float*, float** %3
%1605 = load i32, i32* %5
%1606 = load i32, i32* %6
%1607 = add nsw i32 %1605, %1606
%1608 = sext i32 %1607 to i64
%1609 = getelementptr inbounds float, float* %1604, i64 %1608
store float %1603, float* %1609
%1610 = load float, float* %8
%1611 = load float, float* %10
%1612 = fsub float %1610, %1611
%1613 = load float*, float** %3
%1614 = load i32, i32* %5
%1615 = load i32, i32* %6
%1616 = add nsw i32 %1614, %1615
%1617 = add nsw i32 %1616, 1024
%1618 = sext i32 %1617 to i64
%1619 = getelementptr inbounds float, float* %1613, i64 %1618
store float %1612, float* %1619
%1620 = load float, float* %9
%1621 = load float, float* %11
%1622 = fadd float %1620, %1621
%1623 = load float*, float** %3
%1624 = load i32, i32* %5
%1625 = load i32, i32* %6
%1626 = sub nsw i32 %1624, %1625
%1627 = add nsw i32 %1626, 1024
%1628 = sext i32 %1627 to i64
%1629 = getelementptr inbounds float, float* %1623, i64 %1628
store float %1622, float* %1629
%1630 = load float, float* %9
%1631 = load float, float* %11
%1632 = fsub float %1630, %1631
%1633 = load float*, float** %3
%1634 = load i32, i32* %5
%1635 = load i32, i32* %6
%1636 = sub nsw i32 %1634, %1635
%1637 = add nsw i32 %1636, 2048
%1638 = sext i32 %1637 to i64
%1639 = getelementptr inbounds float, float* %1633, i64 %1638
store float %1632, float* %1639
br label %1640
1640: ; preds = %1531
%1641 = load i32, i32* %6
%1642 = add nsw i32 %1641, 1
store i32 %1642, i32* %6
br label %1528
1643: ; preds = %1528
br label %1644
1644: ; preds = %1643
%1645 = load i32, i32* %5
%1646 = add nsw i32 %1645, 2048
store i32 %1646, i32* %5
br label %1470
1647: ; preds = %1470
store i32 0, i32* %5
br label %1648
1648: ; preds = %1822, %1647
%1649 = load i32, i32* %5
%1650 = icmp slt i32 %1649, 32768
br i1 %1650, label %1651, label %1825
1651: ; preds = %1648
store i32 8, i32* %7
%1652 = load float*, float** %3
%1653 = load i32, i32* %5
%1654 = sext i32 %1653 to i64
%1655 = getelementptr inbounds float, float* %1652, i64 %1654
%1656 = load float, float* %1655
store float %1656, float* %8
%1657 = load float*, float** %3
%1658 = load i32, i32* %5
%1659 = add nsw i32 %1658, 2048
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds float, float* %1657, i64 %1660
%1662 = load float, float* %1661
store float %1662, float* %9
%1663 = load float, float* %8
%1664 = load float, float* %9
%1665 = fadd float %1663, %1664
%1666 = load float*, float** %3
%1667 = load i32, i32* %5
%1668 = sext i32 %1667 to i64
%1669 = getelementptr inbounds float, float* %1666, i64 %1668
store float %1665, float* %1669
%1670 = load float, float* %8
%1671 = load float, float* %9
%1672 = fsub float %1670, %1671
%1673 = load float*, float** %3
%1674 = load i32, i32* %5
%1675 = add nsw i32 %1674, 2048
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds float, float* %1673, i64 %1676
store float %1672, float* %1677
%1678 = load float*, float** %3
%1679 = load i32, i32* %5
%1680 = add nsw i32 %1679, 1024
%1681 = sext i32 %1680 to i64
%1682 = getelementptr inbounds float, float* %1678, i64 %1681
%1683 = load float, float* %1682
store float %1683, float* %8
%1684 = load float*, float** %3
%1685 = load i32, i32* %5
%1686 = add nsw i32 %1685, 3072
%1687 = sext i32 %1686 to i64
%1688 = getelementptr inbounds float, float* %1684, i64 %1687
%1689 = load float, float* %1688
store float %1689, float* %9
%1690 = load float, float* %8
%1691 = load float, float* %9
%1692 = fadd float %1690, %1691
%1693 = load float*, float** %3
%1694 = load i32, i32* %5
%1695 = add nsw i32 %1694, 1024
%1696 = sext i32 %1695 to i64
%1697 = getelementptr inbounds float, float* %1693, i64 %1696
store float %1692, float* %1697
%1698 = load float, float* %8
%1699 = load float, float* %9
%1700 = fsub float %1698, %1699
%1701 = load float*, float** %3
%1702 = load i32, i32* %5
%1703 = add nsw i32 %1702, 3072
%1704 = sext i32 %1703 to i64
%1705 = getelementptr inbounds float, float* %1701, i64 %1704
store float %1700, float* %1705
store i32 1, i32* %6
br label %1706
1706: ; preds = %1818, %1651
%1707 = load i32, i32* %6
%1708 = icmp slt i32 %1707, 1024
br i1 %1708, label %1709, label %1821
1709: ; preds = %1706
%1710 = load float*, float** %4
%1711 = load i32, i32* %7
%1712 = sext i32 %1711 to i64
%1713 = getelementptr inbounds float, float* %1710, i64 %1712
%1714 = load float, float* %1713
store float %1714, float* %12
%1715 = load float*, float** %4
%1716 = load i32, i32* %7
%1717 = add nsw i32 %1716, 8192
%1718 = sext i32 %1717 to i64
%1719 = getelementptr inbounds float, float* %1715, i64 %1718
%1720 = load float, float* %1719
store float %1720, float* %13
%1721 = load float*, float** %3
%1722 = load i32, i32* %5
%1723 = load i32, i32* %6
%1724 = add nsw i32 %1722, %1723
%1725 = sext i32 %1724 to i64
%1726 = getelementptr inbounds float, float* %1721, i64 %1725
%1727 = load float, float* %1726
store float %1727, float* %8
%1728 = load float*, float** %3
%1729 = load i32, i32* %5
%1730 = load i32, i32* %6
%1731 = sub nsw i32 %1729, %1730
%1732 = add nsw i32 %1731, 2048
%1733 = sext i32 %1732 to i64
%1734 = getelementptr inbounds float, float* %1728, i64 %1733
%1735 = load float, float* %1734
store float %1735, float* %9
%1736 = load float*, float** %3
%1737 = load i32, i32* %5
%1738 = load i32, i32* %6
%1739 = add nsw i32 %1737, %1738
%1740 = add nsw i32 %1739, 2048
%1741 = sext i32 %1740 to i64
%1742 = getelementptr inbounds float, float* %1736, i64 %1741
%1743 = load float, float* %1742
%1744 = load float, float* %13
%1745 = load float*, float** %3
%1746 = load i32, i32* %5
%1747 = load i32, i32* %6
%1748 = sub nsw i32 %1746, %1747
%1749 = add nsw i32 %1748, 4096
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds float, float* %1745, i64 %1750
%1752 = load float, float* %1751
%1753 = load float, float* %12
%1754 = fmul float %1752, %1753
%1755 = call float @llvm.fmuladd.f32(float %1743, float %1744, float %1754)
store float %1755, float* %10
%1756 = load float*, float** %3
%1757 = load i32, i32* %5
%1758 = load i32, i32* %6
%1759 = add nsw i32 %1757, %1758
%1760 = add nsw i32 %1759, 2048
%1761 = sext i32 %1760 to i64
%1762 = getelementptr inbounds float, float* %1756, i64 %1761
%1763 = load float, float* %1762
%1764 = load float, float* %12
%1765 = load float*, float** %3
%1766 = load i32, i32* %5
%1767 = load i32, i32* %6
%1768 = sub nsw i32 %1766, %1767
%1769 = add nsw i32 %1768, 4096
%1770 = sext i32 %1769 to i64
%1771 = getelementptr inbounds float, float* %1765, i64 %1770
%1772 = load float, float* %1771
%1773 = load float, float* %13
%1774 = fmul float %1772, %1773
%1775 = fneg float %1774
%1776 = call float @llvm.fmuladd.f32(float %1763, float %1764, float %1775)
store float %1776, float* %11
%1777 = load i32, i32* %7
%1778 = add nsw i32 %1777, 8
store i32 %1778, i32* %7
%1779 = load float, float* %8
%1780 = load float, float* %10
%1781 = fadd float %1779, %1780
%1782 = load float*, float** %3
%1783 = load i32, i32* %5
%1784 = load i32, i32* %6
%1785 = add nsw i32 %1783, %1784
%1786 = sext i32 %1785 to i64
%1787 = getelementptr inbounds float, float* %1782, i64 %1786
store float %1781, float* %1787
%1788 = load float, float* %8
%1789 = load float, float* %10
%1790 = fsub float %1788, %1789
%1791 = load float*, float** %3
%1792 = load i32, i32* %5
%1793 = load i32, i32* %6
%1794 = add nsw i32 %1792, %1793
%1795 = add nsw i32 %1794, 2048
%1796 = sext i32 %1795 to i64
%1797 = getelementptr inbounds float, float* %1791, i64 %1796
store float %1790, float* %1797
%1798 = load float, float* %9
%1799 = load float, float* %11
%1800 = fadd float %1798, %1799
%1801 = load float*, float** %3
%1802 = load i32, i32* %5
%1803 = load i32, i32* %6
%1804 = sub nsw i32 %1802, %1803
%1805 = add nsw i32 %1804, 2048
%1806 = sext i32 %1805 to i64
%1807 = getelementptr inbounds float, float* %1801, i64 %1806
store float %1800, float* %1807
%1808 = load float, float* %9
%1809 = load float, float* %11
%1810 = fsub float %1808, %1809
%1811 = load float*, float** %3
%1812 = load i32, i32* %5
%1813 = load i32, i32* %6
%1814 = sub nsw i32 %1812, %1813
%1815 = add nsw i32 %1814, 4096
%1816 = sext i32 %1815 to i64
%1817 = getelementptr inbounds float, float* %1811, i64 %1816
store float %1810, float* %1817
br label %1818
1818: ; preds = %1709
%1819 = load i32, i32* %6
%1820 = add nsw i32 %1819, 1
store i32 %1820, i32* %6
br label %1706
1821: ; preds = %1706
br label %1822
1822: ; preds = %1821
%1823 = load i32, i32* %5
%1824 = add nsw i32 %1823, 4096
store i32 %1824, i32* %5
br label %1648
1825: ; preds = %1648
store i32 0, i32* %5
br label %1826
1826: ; preds = %2000, %1825
%1827 = load i32, i32* %5
%1828 = icmp slt i32 %1827, 32768
br i1 %1828, label %1829, label %2003
1829: ; preds = %1826
store i32 4, i32* %7
%1830 = load float*, float** %3
%1831 = load i32, i32* %5
%1832 = sext i32 %1831 to i64
%1833 = getelementptr inbounds float, float* %1830, i64 %1832
%1834 = load float, float* %1833
store float %1834, float* %8
%1835 = load float*, float** %3
%1836 = load i32, i32* %5
%1837 = add nsw i32 %1836, 4096
%1838 = sext i32 %1837 to i64
%1839 = getelementptr inbounds float, float* %1835, i64 %1838
%1840 = load float, float* %1839
store float %1840, float* %9
%1841 = load float, float* %8
%1842 = load float, float* %9
%1843 = fadd float %1841, %1842
%1844 = load float*, float** %3
%1845 = load i32, i32* %5
%1846 = sext i32 %1845 to i64
%1847 = getelementptr inbounds float, float* %1844, i64 %1846
store float %1843, float* %1847
%1848 = load float, float* %8
%1849 = load float, float* %9
%1850 = fsub float %1848, %1849
%1851 = load float*, float** %3
%1852 = load i32, i32* %5
%1853 = add nsw i32 %1852, 4096
%1854 = sext i32 %1853 to i64
%1855 = getelementptr inbounds float, float* %1851, i64 %1854
store float %1850, float* %1855
%1856 = load float*, float** %3
%1857 = load i32, i32* %5
%1858 = add nsw i32 %1857, 2048
%1859 = sext i32 %1858 to i64
%1860 = getelementptr inbounds float, float* %1856, i64 %1859
%1861 = load float, float* %1860
store float %1861, float* %8
%1862 = load float*, float** %3
%1863 = load i32, i32* %5
%1864 = add nsw i32 %1863, 6144
%1865 = sext i32 %1864 to i64
%1866 = getelementptr inbounds float, float* %1862, i64 %1865
%1867 = load float, float* %1866
store float %1867, float* %9
%1868 = load float, float* %8
%1869 = load float, float* %9
%1870 = fadd float %1868, %1869
%1871 = load float*, float** %3
%1872 = load i32, i32* %5
%1873 = add nsw i32 %1872, 2048
%1874 = sext i32 %1873 to i64
%1875 = getelementptr inbounds float, float* %1871, i64 %1874
store float %1870, float* %1875
%1876 = load float, float* %8
%1877 = load float, float* %9
%1878 = fsub float %1876, %1877
%1879 = load float*, float** %3
%1880 = load i32, i32* %5
%1881 = add nsw i32 %1880, 6144
%1882 = sext i32 %1881 to i64
%1883 = getelementptr inbounds float, float* %1879, i64 %1882
store float %1878, float* %1883
store i32 1, i32* %6
br label %1884
1884: ; preds = %1996, %1829
%1885 = load i32, i32* %6
%1886 = icmp slt i32 %1885, 2048
br i1 %1886, label %1887, label %1999
1887: ; preds = %1884
%1888 = load float*, float** %4
%1889 = load i32, i32* %7
%1890 = sext i32 %1889 to i64
%1891 = getelementptr inbounds float, float* %1888, i64 %1890
%1892 = load float, float* %1891
store float %1892, float* %12
%1893 = load float*, float** %4
%1894 = load i32, i32* %7
%1895 = add nsw i32 %1894, 8192
%1896 = sext i32 %1895 to i64
%1897 = getelementptr inbounds float, float* %1893, i64 %1896
%1898 = load float, float* %1897
store float %1898, float* %13
%1899 = load float*, float** %3
%1900 = load i32, i32* %5
%1901 = load i32, i32* %6
%1902 = add nsw i32 %1900, %1901
%1903 = sext i32 %1902 to i64
%1904 = getelementptr inbounds float, float* %1899, i64 %1903
%1905 = load float, float* %1904
store float %1905, float* %8
%1906 = load float*, float** %3
%1907 = load i32, i32* %5
%1908 = load i32, i32* %6
%1909 = sub nsw i32 %1907, %1908
%1910 = add nsw i32 %1909, 4096
%1911 = sext i32 %1910 to i64
%1912 = getelementptr inbounds float, float* %1906, i64 %1911
%1913 = load float, float* %1912
store float %1913, float* %9
%1914 = load float*, float** %3
%1915 = load i32, i32* %5
%1916 = load i32, i32* %6
%1917 = add nsw i32 %1915, %1916
%1918 = add nsw i32 %1917, 4096
%1919 = sext i32 %1918 to i64
%1920 = getelementptr inbounds float, float* %1914, i64 %1919
%1921 = load float, float* %1920
%1922 = load float, float* %13
%1923 = load float*, float** %3
%1924 = load i32, i32* %5
%1925 = load i32, i32* %6
%1926 = sub nsw i32 %1924, %1925
%1927 = add nsw i32 %1926, 8192
%1928 = sext i32 %1927 to i64
%1929 = getelementptr inbounds float, float* %1923, i64 %1928
%1930 = load float, float* %1929
%1931 = load float, float* %12
%1932 = fmul float %1930, %1931
%1933 = call float @llvm.fmuladd.f32(float %1921, float %1922, float %1932)
store float %1933, float* %10
%1934 = load float*, float** %3
%1935 = load i32, i32* %5
%1936 = load i32, i32* %6
%1937 = add nsw i32 %1935, %1936
%1938 = add nsw i32 %1937, 4096
%1939 = sext i32 %1938 to i64
%1940 = getelementptr inbounds float, float* %1934, i64 %1939
%1941 = load float, float* %1940
%1942 = load float, float* %12
%1943 = load float*, float** %3
%1944 = load i32, i32* %5
%1945 = load i32, i32* %6
%1946 = sub nsw i32 %1944, %1945
%1947 = add nsw i32 %1946, 8192
%1948 = sext i32 %1947 to i64
%1949 = getelementptr inbounds float, float* %1943, i64 %1948
%1950 = load float, float* %1949
%1951 = load float, float* %13
%1952 = fmul float %1950, %1951
%1953 = fneg float %1952
%1954 = call float @llvm.fmuladd.f32(float %1941, float %1942, float %1953)
store float %1954, float* %11
%1955 = load i32, i32* %7
%1956 = add nsw i32 %1955, 4
store i32 %1956, i32* %7
%1957 = load float, float* %8
%1958 = load float, float* %10
%1959 = fadd float %1957, %1958
%1960 = load float*, float** %3
%1961 = load i32, i32* %5
%1962 = load i32, i32* %6
%1963 = add nsw i32 %1961, %1962
%1964 = sext i32 %1963 to i64
%1965 = getelementptr inbounds float, float* %1960, i64 %1964
store float %1959, float* %1965
%1966 = load float, float* %8
%1967 = load float, float* %10
%1968 = fsub float %1966, %1967
%1969 = load float*, float** %3
%1970 = load i32, i32* %5
%1971 = load i32, i32* %6
%1972 = add nsw i32 %1970, %1971
%1973 = add nsw i32 %1972, 4096
%1974 = sext i32 %1973 to i64
%1975 = getelementptr inbounds float, float* %1969, i64 %1974
store float %1968, float* %1975
%1976 = load float, float* %9
%1977 = load float, float* %11
%1978 = fadd float %1976, %1977
%1979 = load float*, float** %3
%1980 = load i32, i32* %5
%1981 = load i32, i32* %6
%1982 = sub nsw i32 %1980, %1981
%1983 = add nsw i32 %1982, 4096
%1984 = sext i32 %1983 to i64
%1985 = getelementptr inbounds float, float* %1979, i64 %1984
store float %1978, float* %1985
%1986 = load float, float* %9
%1987 = load float, float* %11
%1988 = fsub float %1986, %1987
%1989 = load float*, float** %3
%1990 = load i32, i32* %5
%1991 = load i32, i32* %6
%1992 = sub nsw i32 %1990, %1991
%1993 = add nsw i32 %1992, 8192
%1994 = sext i32 %1993 to i64
%1995 = getelementptr inbounds float, float* %1989, i64 %1994
store float %1988, float* %1995
br label %1996
1996: ; preds = %1887
%1997 = load i32, i32* %6
%1998 = add nsw i32 %1997, 1
store i32 %1998, i32* %6
br label %1884
1999: ; preds = %1884
br label %2000
2000: ; preds = %1999
%2001 = load i32, i32* %5
%2002 = add nsw i32 %2001, 8192
store i32 %2002, i32* %5
br label %1826
2003: ; preds = %1826
store i32 0, i32* %5
br label %2004
2004: ; preds = %2178, %2003
%2005 = load i32, i32* %5
%2006 = icmp slt i32 %2005, 32768
br i1 %2006, label %2007, label %2181
2007: ; preds = %2004
store i32 2, i32* %7
%2008 = load float*, float** %3
%2009 = load i32, i32* %5
%2010 = sext i32 %2009 to i64
%2011 = getelementptr inbounds float, float* %2008, i64 %2010
%2012 = load float, float* %2011
store float %2012, float* %8
%2013 = load float*, float** %3
%2014 = load i32, i32* %5
%2015 = add nsw i32 %2014, 8192
%2016 = sext i32 %2015 to i64
%2017 = getelementptr inbounds float, float* %2013, i64 %2016
%2018 = load float, float* %2017
store float %2018, float* %9
%2019 = load float, float* %8
%2020 = load float, float* %9
%2021 = fadd float %2019, %2020
%2022 = load float*, float** %3
%2023 = load i32, i32* %5
%2024 = sext i32 %2023 to i64
%2025 = getelementptr inbounds float, float* %2022, i64 %2024
store float %2021, float* %2025
%2026 = load float, float* %8
%2027 = load float, float* %9
%2028 = fsub float %2026, %2027
%2029 = load float*, float** %3
%2030 = load i32, i32* %5
%2031 = add nsw i32 %2030, 8192
%2032 = sext i32 %2031 to i64
%2033 = getelementptr inbounds float, float* %2029, i64 %2032
store float %2028, float* %2033
%2034 = load float*, float** %3
%2035 = load i32, i32* %5
%2036 = add nsw i32 %2035, 4096
%2037 = sext i32 %2036 to i64
%2038 = getelementptr inbounds float, float* %2034, i64 %2037
%2039 = load float, float* %2038
store float %2039, float* %8
%2040 = load float*, float** %3
%2041 = load i32, i32* %5
%2042 = add nsw i32 %2041, 12288
%2043 = sext i32 %2042 to i64
%2044 = getelementptr inbounds float, float* %2040, i64 %2043
%2045 = load float, float* %2044
store float %2045, float* %9
%2046 = load float, float* %8
%2047 = load float, float* %9
%2048 = fadd float %2046, %2047
%2049 = load float*, float** %3
%2050 = load i32, i32* %5
%2051 = add nsw i32 %2050, 4096
%2052 = sext i32 %2051 to i64
%2053 = getelementptr inbounds float, float* %2049, i64 %2052
store float %2048, float* %2053
%2054 = load float, float* %8
%2055 = load float, float* %9
%2056 = fsub float %2054, %2055
%2057 = load float*, float** %3
%2058 = load i32, i32* %5
%2059 = add nsw i32 %2058, 12288
%2060 = sext i32 %2059 to i64
%2061 = getelementptr inbounds float, float* %2057, i64 %2060
store float %2056, float* %2061
store i32 1, i32* %6
br label %2062
2062: ; preds = %2174, %2007
%2063 = load i32, i32* %6
%2064 = icmp slt i32 %2063, 4096
br i1 %2064, label %2065, label %2177
2065: ; preds = %2062
%2066 = load float*, float** %4
%2067 = load i32, i32* %7
%2068 = sext i32 %2067 to i64
%2069 = getelementptr inbounds float, float* %2066, i64 %2068
%2070 = load float, float* %2069
store float %2070, float* %12
%2071 = load float*, float** %4
%2072 = load i32, i32* %7
%2073 = add nsw i32 %2072, 8192
%2074 = sext i32 %2073 to i64
%2075 = getelementptr inbounds float, float* %2071, i64 %2074
%2076 = load float, float* %2075
store float %2076, float* %13
%2077 = load float*, float** %3
%2078 = load i32, i32* %5
%2079 = load i32, i32* %6
%2080 = add nsw i32 %2078, %2079
%2081 = sext i32 %2080 to i64
%2082 = getelementptr inbounds float, float* %2077, i64 %2081
%2083 = load float, float* %2082
store float %2083, float* %8
%2084 = load float*, float** %3
%2085 = load i32, i32* %5
%2086 = load i32, i32* %6
%2087 = sub nsw i32 %2085, %2086
%2088 = add nsw i32 %2087, 8192
%2089 = sext i32 %2088 to i64
%2090 = getelementptr inbounds float, float* %2084, i64 %2089
%2091 = load float, float* %2090
store float %2091, float* %9
%2092 = load float*, float** %3
%2093 = load i32, i32* %5
%2094 = load i32, i32* %6
%2095 = add nsw i32 %2093, %2094
%2096 = add nsw i32 %2095, 8192
%2097 = sext i32 %2096 to i64
%2098 = getelementptr inbounds float, float* %2092, i64 %2097
%2099 = load float, float* %2098
%2100 = load float, float* %13
%2101 = load float*, float** %3
%2102 = load i32, i32* %5
%2103 = load i32, i32* %6
%2104 = sub nsw i32 %2102, %2103
%2105 = add nsw i32 %2104, 16384
%2106 = sext i32 %2105 to i64
%2107 = getelementptr inbounds float, float* %2101, i64 %2106
%2108 = load float, float* %2107
%2109 = load float, float* %12
%2110 = fmul float %2108, %2109
%2111 = call float @llvm.fmuladd.f32(float %2099, float %2100, float %2110)
store float %2111, float* %10
%2112 = load float*, float** %3
%2113 = load i32, i32* %5
%2114 = load i32, i32* %6
%2115 = add nsw i32 %2113, %2114
%2116 = add nsw i32 %2115, 8192
%2117 = sext i32 %2116 to i64
%2118 = getelementptr inbounds float, float* %2112, i64 %2117
%2119 = load float, float* %2118
%2120 = load float, float* %12
%2121 = load float*, float** %3
%2122 = load i32, i32* %5
%2123 = load i32, i32* %6
%2124 = sub nsw i32 %2122, %2123
%2125 = add nsw i32 %2124, 16384
%2126 = sext i32 %2125 to i64
%2127 = getelementptr inbounds float, float* %2121, i64 %2126
%2128 = load float, float* %2127
%2129 = load float, float* %13
%2130 = fmul float %2128, %2129
%2131 = fneg float %2130
%2132 = call float @llvm.fmuladd.f32(float %2119, float %2120, float %2131)
store float %2132, float* %11
%2133 = load i32, i32* %7
%2134 = add nsw i32 %2133, 2
store i32 %2134, i32* %7
%2135 = load float, float* %8
%2136 = load float, float* %10
%2137 = fadd float %2135, %2136
%2138 = load float*, float** %3
%2139 = load i32, i32* %5
%2140 = load i32, i32* %6
%2141 = add nsw i32 %2139, %2140
%2142 = sext i32 %2141 to i64
%2143 = getelementptr inbounds float, float* %2138, i64 %2142
store float %2137, float* %2143
%2144 = load float, float* %8
%2145 = load float, float* %10
%2146 = fsub float %2144, %2145
%2147 = load float*, float** %3
%2148 = load i32, i32* %5
%2149 = load i32, i32* %6
%2150 = add nsw i32 %2148, %2149
%2151 = add nsw i32 %2150, 8192
%2152 = sext i32 %2151 to i64
%2153 = getelementptr inbounds float, float* %2147, i64 %2152
store float %2146, float* %2153
%2154 = load float, float* %9
%2155 = load float, float* %11
%2156 = fadd float %2154, %2155
%2157 = load float*, float** %3
%2158 = load i32, i32* %5
%2159 = load i32, i32* %6
%2160 = sub nsw i32 %2158, %2159
%2161 = add nsw i32 %2160, 8192
%2162 = sext i32 %2161 to i64
%2163 = getelementptr inbounds float, float* %2157, i64 %2162
store float %2156, float* %2163
%2164 = load float, float* %9
%2165 = load float, float* %11
%2166 = fsub float %2164, %2165
%2167 = load float*, float** %3
%2168 = load i32, i32* %5
%2169 = load i32, i32* %6
%2170 = sub nsw i32 %2168, %2169
%2171 = add nsw i32 %2170, 16384
%2172 = sext i32 %2171 to i64
%2173 = getelementptr inbounds float, float* %2167, i64 %2172
store float %2166, float* %2173
br label %2174
2174: ; preds = %2065
%2175 = load i32, i32* %6
%2176 = add nsw i32 %2175, 1
store i32 %2176, i32* %6
br label %2062
2177: ; preds = %2062
br label %2178
2178: ; preds = %2177
%2179 = load i32, i32* %5
%2180 = add nsw i32 %2179, 16384
store i32 %2180, i32* %5
br label %2004
2181: ; preds = %2004
store i32 1, i32* %7
%2182 = load float*, float** %3
%2183 = getelementptr inbounds float, float* %2182, i64 0
%2184 = load float, float* %2183
store float %2184, float* %8
%2185 = load float*, float** %3
%2186 = getelementptr inbounds float, float* %2185, i64 16384
%2187 = load float, float* %2186
store float %2187, float* %9
%2188 = load float, float* %8
%2189 = load float, float* %9
%2190 = fadd float %2188, %2189
%2191 = load float*, float** %3
%2192 = getelementptr inbounds float, float* %2191, i64 0
store float %2190, float* %2192
%2193 = load float, float* %8
%2194 = load float, float* %9
%2195 = fsub float %2193, %2194
%2196 = load float*, float** %3
%2197 = getelementptr inbounds float, float* %2196, i64 16384
store float %2195, float* %2197
%2198 = load float*, float** %3
%2199 = getelementptr inbounds float, float* %2198, i64 8192
%2200 = load float, float* %2199
store float %2200, float* %8
%2201 = load float*, float** %3
%2202 = getelementptr inbounds float, float* %2201, i64 24576
%2203 = load float, float* %2202
store float %2203, float* %9
%2204 = load float, float* %8
%2205 = load float, float* %9
%2206 = fadd float %2204, %2205
%2207 = load float*, float** %3
%2208 = getelementptr inbounds float, float* %2207, i64 8192
store float %2206, float* %2208
%2209 = load float, float* %8
%2210 = load float, float* %9
%2211 = fsub float %2209, %2210
%2212 = load float*, float** %3
%2213 = getelementptr inbounds float, float* %2212, i64 24576
store float %2211, float* %2213
store i32 1, i32* %6
br label %2214
2214: ; preds = %2311, %2181
%2215 = load i32, i32* %6
%2216 = icmp slt i32 %2215, 8192
br i1 %2216, label %2217, label %2314
2217: ; preds = %2214
%2218 = load float*, float** %4
%2219 = load i32, i32* %7
%2220 = sext i32 %2219 to i64
%2221 = getelementptr inbounds float, float* %2218, i64 %2220
%2222 = load float, float* %2221
store float %2222, float* %12
%2223 = load float*, float** %4
%2224 = load i32, i32* %7
%2225 = add nsw i32 %2224, 8192
%2226 = sext i32 %2225 to i64
%2227 = getelementptr inbounds float, float* %2223, i64 %2226
%2228 = load float, float* %2227
store float %2228, float* %13
%2229 = load float*, float** %3
%2230 = load i32, i32* %6
%2231 = sext i32 %2230 to i64
%2232 = getelementptr inbounds float, float* %2229, i64 %2231
%2233 = load float, float* %2232
store float %2233, float* %8
%2234 = load float*, float** %3
%2235 = load i32, i32* %6
%2236 = sub nsw i32 0, %2235
%2237 = add nsw i32 %2236, 16384
%2238 = sext i32 %2237 to i64
%2239 = getelementptr inbounds float, float* %2234, i64 %2238
%2240 = load float, float* %2239
store float %2240, float* %9
%2241 = load float*, float** %3
%2242 = load i32, i32* %6
%2243 = add nsw i32 %2242, 16384
%2244 = sext i32 %2243 to i64
%2245 = getelementptr inbounds float, float* %2241, i64 %2244
%2246 = load float, float* %2245
%2247 = load float, float* %13
%2248 = load float*, float** %3
%2249 = load i32, i32* %6
%2250 = sub nsw i32 0, %2249
%2251 = add nsw i32 %2250, 32768
%2252 = sext i32 %2251 to i64
%2253 = getelementptr inbounds float, float* %2248, i64 %2252
%2254 = load float, float* %2253
%2255 = load float, float* %12
%2256 = fmul float %2254, %2255
%2257 = call float @llvm.fmuladd.f32(float %2246, float %2247, float %2256)
store float %2257, float* %10
%2258 = load float*, float** %3
%2259 = load i32, i32* %6
%2260 = add nsw i32 %2259, 16384
%2261 = sext i32 %2260 to i64
%2262 = getelementptr inbounds float, float* %2258, i64 %2261
%2263 = load float, float* %2262
%2264 = load float, float* %12
%2265 = load float*, float** %3
%2266 = load i32, i32* %6
%2267 = sub nsw i32 0, %2266
%2268 = add nsw i32 %2267, 32768
%2269 = sext i32 %2268 to i64
%2270 = getelementptr inbounds float, float* %2265, i64 %2269
%2271 = load float, float* %2270
%2272 = load float, float* %13
%2273 = fmul float %2271, %2272
%2274 = fneg float %2273
%2275 = call float @llvm.fmuladd.f32(float %2263, float %2264, float %2274)
store float %2275, float* %11
%2276 = load i32, i32* %7
%2277 = add nsw i32 %2276, 1
store i32 %2277, i32* %7
%2278 = load float, float* %8
%2279 = load float, float* %10
%2280 = fadd float %2278, %2279
%2281 = load float*, float** %3
%2282 = load i32, i32* %6
%2283 = sext i32 %2282 to i64
%2284 = getelementptr inbounds float, float* %2281, i64 %2283
store float %2280, float* %2284
%2285 = load float, float* %8
%2286 = load float, float* %10
%2287 = fsub float %2285, %2286
%2288 = load float*, float** %3
%2289 = load i32, i32* %6
%2290 = add nsw i32 %2289, 16384
%2291 = sext i32 %2290 to i64
%2292 = getelementptr inbounds float, float* %2288, i64 %2291
store float %2287, float* %2292
%2293 = load float, float* %9
%2294 = load float, float* %11
%2295 = fadd float %2293, %2294
%2296 = load float*, float** %3
%2297 = load i32, i32* %6
%2298 = sub nsw i32 0, %2297
%2299 = add nsw i32 %2298, 16384
%2300 = sext i32 %2299 to i64
%2301 = getelementptr inbounds float, float* %2296, i64 %2300
store float %2295, float* %2301
%2302 = load float, float* %9
%2303 = load float, float* %11
%2304 = fsub float %2302, %2303
%2305 = load float*, float** %3
%2306 = load i32, i32* %6
%2307 = sub nsw i32 0, %2306
%2308 = add nsw i32 %2307, 32768
%2309 = sext i32 %2308 to i64
%2310 = getelementptr inbounds float, float* %2305, i64 %2309
store float %2304, float* %2310
br label %2311
2311: ; preds = %2217
%2312 = load i32, i32* %6
%2313 = add nsw i32 %2312, 1
store i32 %2313, i32* %6
br label %2214
2314: ; preds = %2214
ret void
}

LLVM IR (-O2):
define void @DFT32768(float* %0, float* %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, 8192
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, 4096
br i1 %236, label %237, label %84
237: ; preds = %84
%238 = getelementptr inbounds float, float* %1, i64 2048
%239 = getelementptr inbounds float, float* %1, i64 10240
%240 = getelementptr inbounds float, float* %1, i64 4096
%241 = getelementptr inbounds float, float* %1, i64 12288
%242 = getelementptr inbounds float, float* %1, i64 6144
%243 = getelementptr inbounds float, float* %1, i64 14336
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, 32752
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 [ 1024, %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, 8192
%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, 1024
%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, 32736
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 [ 512, %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, 8192
%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, 512
%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, 32704
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 [ 256, %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, 8192
%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, 256
%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, 32640
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 [ 128, %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, 8192
%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, 128
%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, 32512
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 [ 64, %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, 8192
%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, 64
%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, 32256
br i1 %596, label %544, label %597
597: ; preds = %594, %647
%598 = phi i64 [ %648, %647 ], [ 0, %594 ]
%599 = getelementptr inbounds float, float* %0, i64 %598
%600 = load float, float* %599
%601 = or i64 %598, 512
%602 = getelementptr inbounds float, float* %0, i64 %601
%603 = load float, float* %602
%604 = fadd float %600, %603
store float %604, float* %599
%605 = fsub float %600, %603
store float %605, float* %602
%606 = or i64 %598, 256
%607 = getelementptr inbounds float, float* %0, i64 %606
%608 = load float, float* %607
%609 = or i64 %598, 768
%610 = getelementptr inbounds float, float* %0, i64 %609
%611 = load float, float* %610
%612 = fadd float %608, %611
store float %612, float* %607
%613 = fsub float %608, %611
store float %613, float* %610
br label %614
614: ; preds = %597, %614
%615 = phi i64 [ 32, %597 ], [ %640, %614 ]
%616 = phi i64 [ 1, %597 ], [ %645, %614 ]
%617 = getelementptr inbounds float, float* %1, i64 %615
%618 = load float, float* %617
%619 = add nuw nsw i64 %615, 8192
%620 = getelementptr inbounds float, float* %1, i64 %619
%621 = load float, float* %620
%622 = add nuw nsw i64 %616, %598
%623 = getelementptr inbounds float, float* %0, i64 %622
%624 = load float, float* %623
%625 = sub nsw i64 %598, %616
%626 = add nsw i64 %625, 512
%627 = getelementptr inbounds float, float* %0, i64 %626
%628 = load float, float* %627
%629 = add nuw nsw i64 %622, 512
%630 = getelementptr inbounds float, float* %0, i64 %629
%631 = load float, float* %630
%632 = add nsw i64 %625, 1024
%633 = getelementptr inbounds float, float* %0, i64 %632
%634 = load float, float* %633
%635 = fmul float %618, %634
%636 = tail call float @llvm.fmuladd.f32(float %631, float %621, float %635)
%637 = fneg float %634
%638 = fmul float %621, %637
%639 = tail call float @llvm.fmuladd.f32(float %631, float %618, float %638)
%640 = add nuw nsw i64 %615, 32
%641 = fadd float %624, %636
store float %641, float* %623
%642 = fsub float %624, %636
store float %642, float* %630
%643 = fadd float %628, %639
store float %643, float* %627
%644 = fsub float %628, %639
store float %644, float* %633
%645 = add nuw nsw i64 %616, 1
%646 = icmp eq i64 %645, 256
br i1 %646, label %647, label %614
647: ; preds = %614
%648 = add nuw nsw i64 %598, 1024
%649 = icmp ult i64 %598, 31744
br i1 %649, label %597, label %650
650: ; preds = %647, %700
%651 = phi i64 [ %701, %700 ], [ 0, %647 ]
%652 = getelementptr inbounds float, float* %0, i64 %651
%653 = load float, float* %652
%654 = or i64 %651, 1024
%655 = getelementptr inbounds float, float* %0, i64 %654
%656 = load float, float* %655
%657 = fadd float %653, %656
store float %657, float* %652
%658 = fsub float %653, %656
store float %658, float* %655
%659 = or i64 %651, 512
%660 = getelementptr inbounds float, float* %0, i64 %659
%661 = load float, float* %660
%662 = or i64 %651, 1536
%663 = getelementptr inbounds float, float* %0, i64 %662
%664 = load float, float* %663
%665 = fadd float %661, %664
store float %665, float* %660
%666 = fsub float %661, %664
store float %666, float* %663
br label %667
667: ; preds = %650, %667
%668 = phi i64 [ 16, %650 ], [ %693, %667 ]
%669 = phi i64 [ 1, %650 ], [ %698, %667 ]
%670 = getelementptr inbounds float, float* %1, i64 %668
%671 = load float, float* %670
%672 = add nuw nsw i64 %668, 8192
%673 = getelementptr inbounds float, float* %1, i64 %672
%674 = load float, float* %673
%675 = add nuw nsw i64 %669, %651
%676 = getelementptr inbounds float, float* %0, i64 %675
%677 = load float, float* %676
%678 = sub nsw i64 %651, %669
%679 = add nsw i64 %678, 1024
%680 = getelementptr inbounds float, float* %0, i64 %679
%681 = load float, float* %680
%682 = add nuw nsw i64 %675, 1024
%683 = getelementptr inbounds float, float* %0, i64 %682
%684 = load float, float* %683
%685 = add nsw i64 %678, 2048
%686 = getelementptr inbounds float, float* %0, i64 %685
%687 = load float, float* %686
%688 = fmul float %671, %687
%689 = tail call float @llvm.fmuladd.f32(float %684, float %674, float %688)
%690 = fneg float %687
%691 = fmul float %674, %690
%692 = tail call float @llvm.fmuladd.f32(float %684, float %671, float %691)
%693 = add nuw nsw i64 %668, 16
%694 = fadd float %677, %689
store float %694, float* %676
%695 = fsub float %677, %689
store float %695, float* %683
%696 = fadd float %681, %692
store float %696, float* %680
%697 = fsub float %681, %692
store float %697, float* %686
%698 = add nuw nsw i64 %669, 1
%699 = icmp eq i64 %698, 512
br i1 %699, label %700, label %667
700: ; preds = %667
%701 = add nuw nsw i64 %651, 2048
%702 = icmp ult i64 %651, 30720
br i1 %702, label %650, label %703
703: ; preds = %700, %753
%704 = phi i64 [ %754, %753 ], [ 0, %700 ]
%705 = getelementptr inbounds float, float* %0, i64 %704
%706 = load float, float* %705
%707 = or i64 %704, 2048
%708 = getelementptr inbounds float, float* %0, i64 %707
%709 = load float, float* %708
%710 = fadd float %706, %709
store float %710, float* %705
%711 = fsub float %706, %709
store float %711, float* %708
%712 = or i64 %704, 1024
%713 = getelementptr inbounds float, float* %0, i64 %712
%714 = load float, float* %713
%715 = or i64 %704, 3072
%716 = getelementptr inbounds float, float* %0, i64 %715
%717 = load float, float* %716
%718 = fadd float %714, %717
store float %718, float* %713
%719 = fsub float %714, %717
store float %719, float* %716
br label %720
720: ; preds = %703, %720
%721 = phi i64 [ 8, %703 ], [ %746, %720 ]
%722 = phi i64 [ 1, %703 ], [ %751, %720 ]
%723 = getelementptr inbounds float, float* %1, i64 %721
%724 = load float, float* %723
%725 = add nuw nsw i64 %721, 8192
%726 = getelementptr inbounds float, float* %1, i64 %725
%727 = load float, float* %726
%728 = add nuw nsw i64 %722, %704
%729 = getelementptr inbounds float, float* %0, i64 %728
%730 = load float, float* %729
%731 = sub nsw i64 %704, %722
%732 = add nsw i64 %731, 2048
%733 = getelementptr inbounds float, float* %0, i64 %732
%734 = load float, float* %733
%735 = add nuw nsw i64 %728, 2048
%736 = getelementptr inbounds float, float* %0, i64 %735
%737 = load float, float* %736
%738 = add nsw i64 %731, 4096
%739 = getelementptr inbounds float, float* %0, i64 %738
%740 = load float, float* %739
%741 = fmul float %724, %740
%742 = tail call float @llvm.fmuladd.f32(float %737, float %727, float %741)
%743 = fneg float %740
%744 = fmul float %727, %743
%745 = tail call float @llvm.fmuladd.f32(float %737, float %724, float %744)
%746 = add nuw nsw i64 %721, 8
%747 = fadd float %730, %742
store float %747, float* %729
%748 = fsub float %730, %742
store float %748, float* %736
%749 = fadd float %734, %745
store float %749, float* %733
%750 = fsub float %734, %745
store float %750, float* %739
%751 = add nuw nsw i64 %722, 1
%752 = icmp eq i64 %751, 1024
br i1 %752, label %753, label %720
753: ; preds = %720
%754 = add nuw nsw i64 %704, 4096
%755 = icmp ult i64 %704, 28672
br i1 %755, label %703, label %756
756: ; preds = %753, %806
%757 = phi i64 [ %807, %806 ], [ 0, %753 ]
%758 = getelementptr inbounds float, float* %0, i64 %757
%759 = load float, float* %758
%760 = or i64 %757, 4096
%761 = getelementptr inbounds float, float* %0, i64 %760
%762 = load float, float* %761
%763 = fadd float %759, %762
store float %763, float* %758
%764 = fsub float %759, %762
store float %764, float* %761
%765 = or i64 %757, 2048
%766 = getelementptr inbounds float, float* %0, i64 %765
%767 = load float, float* %766
%768 = or i64 %757, 6144
%769 = getelementptr inbounds float, float* %0, i64 %768
%770 = load float, float* %769
%771 = fadd float %767, %770
store float %771, float* %766
%772 = fsub float %767, %770
store float %772, float* %769
br label %773
773: ; preds = %756, %773
%774 = phi i64 [ 4, %756 ], [ %799, %773 ]
%775 = phi i64 [ 1, %756 ], [ %804, %773 ]
%776 = getelementptr inbounds float, float* %1, i64 %774
%777 = load float, float* %776
%778 = add nuw nsw i64 %774, 8192
%779 = getelementptr inbounds float, float* %1, i64 %778
%780 = load float, float* %779
%781 = add nuw nsw i64 %775, %757
%782 = getelementptr inbounds float, float* %0, i64 %781
%783 = load float, float* %782
%784 = sub nsw i64 %757, %775
%785 = add nsw i64 %784, 4096
%786 = getelementptr inbounds float, float* %0, i64 %785
%787 = load float, float* %786
%788 = add nuw nsw i64 %781, 4096
%789 = getelementptr inbounds float, float* %0, i64 %788
%790 = load float, float* %789
%791 = add nsw i64 %784, 8192
%792 = getelementptr inbounds float, float* %0, i64 %791
%793 = load float, float* %792
%794 = fmul float %777, %793
%795 = tail call float @llvm.fmuladd.f32(float %790, float %780, float %794)
%796 = fneg float %793
%797 = fmul float %780, %796
%798 = tail call float @llvm.fmuladd.f32(float %790, float %777, float %797)
%799 = add nuw nsw i64 %774, 4
%800 = fadd float %783, %795
store float %800, float* %782
%801 = fsub float %783, %795
store float %801, float* %789
%802 = fadd float %787, %798
store float %802, float* %786
%803 = fsub float %787, %798
store float %803, float* %792
%804 = add nuw nsw i64 %775, 1
%805 = icmp eq i64 %804, 2048
br i1 %805, label %806, label %773
806: ; preds = %773
%807 = add nuw nsw i64 %757, 8192
%808 = icmp ult i64 %757, 24576
br i1 %808, label %756, label %809
809: ; preds = %806
%810 = load float, float* %0
%811 = getelementptr inbounds float, float* %0, i64 8192
%812 = load float, float* %811
%813 = fadd float %810, %812
store float %813, float* %0
%814 = fsub float %810, %812
store float %814, float* %811
%815 = getelementptr inbounds float, float* %0, i64 4096
%816 = load float, float* %815
%817 = getelementptr inbounds float, float* %0, i64 12288
%818 = load float, float* %817
%819 = fadd float %816, %818
store float %819, float* %815
%820 = fsub float %816, %818
store float %820, float* %817
br label %821
821: ; preds = %809, %821
%822 = phi i64 [ 2, %809 ], [ %845, %821 ]
%823 = phi i64 [ 1, %809 ], [ %850, %821 ]
%824 = getelementptr inbounds float, float* %1, i64 %822
%825 = load float, float* %824
%826 = add nuw nsw i64 %822, 8192
%827 = getelementptr inbounds float, float* %1, i64 %826
%828 = load float, float* %827
%829 = getelementptr inbounds float, float* %0, i64 %823
%830 = load float, float* %829
%831 = sub nsw i64 8192, %823
%832 = getelementptr inbounds float, float* %0, i64 %831
%833 = load float, float* %832
%834 = add nuw nsw i64 %823, 8192
%835 = getelementptr inbounds float, float* %0, i64 %834
%836 = load float, float* %835
%837 = sub nsw i64 16384, %823
%838 = getelementptr inbounds float, float* %0, i64 %837
%839 = load float, float* %838
%840 = fmul float %825, %839
%841 = tail call float @llvm.fmuladd.f32(float %836, float %828, float %840)
%842 = fneg float %839
%843 = fmul float %828, %842
%844 = tail call float @llvm.fmuladd.f32(float %836, float %825, float %843)
%845 = add nuw nsw i64 %822, 2
%846 = fadd float %830, %841
store float %846, float* %829
%847 = fsub float %830, %841
store float %847, float* %835
%848 = fadd float %833, %844
store float %848, float* %832
%849 = fsub float %833, %844
store float %849, float* %838
%850 = add nuw nsw i64 %823, 1
%851 = icmp eq i64 %850, 4096
br i1 %851, label %852, label %821
852: ; preds = %821
%853 = getelementptr inbounds float, float* %0, i64 16384
%854 = load float, float* %853
%855 = getelementptr inbounds float, float* %0, i64 24576
%856 = load float, float* %855
%857 = fadd float %854, %856
store float %857, float* %853
%858 = fsub float %854, %856
store float %858, float* %855
%859 = getelementptr inbounds float, float* %0, i64 20480
%860 = load float, float* %859
%861 = getelementptr inbounds float, float* %0, i64 28672
%862 = load float, float* %861
%863 = fadd float %860, %862
store float %863, float* %859
%864 = fsub float %860, %862
store float %864, float* %861
br label %865
865: ; preds = %865, %852
%866 = phi i64 [ 2, %852 ], [ %890, %865 ]
%867 = phi i64 [ 1, %852 ], [ %895, %865 ]
%868 = getelementptr inbounds float, float* %1, i64 %866
%869 = load float, float* %868
%870 = add nuw nsw i64 %866, 8192
%871 = getelementptr inbounds float, float* %1, i64 %870
%872 = load float, float* %871
%873 = add nuw nsw i64 %867, 16384
%874 = getelementptr inbounds float, float* %0, i64 %873
%875 = load float, float* %874
%876 = sub nsw i64 24576, %867
%877 = getelementptr inbounds float, float* %0, i64 %876
%878 = load float, float* %877
%879 = add nuw nsw i64 %867, 24576
%880 = getelementptr inbounds float, float* %0, i64 %879
%881 = load float, float* %880
%882 = sub nsw i64 32768, %867
%883 = getelementptr inbounds float, float* %0, i64 %882
%884 = load float, float* %883
%885 = fmul float %869, %884
%886 = tail call float @llvm.fmuladd.f32(float %881, float %872, float %885)
%887 = fneg float %884
%888 = fmul float %872, %887
%889 = tail call float @llvm.fmuladd.f32(float %881, float %869, float %888)
%890 = add nuw nsw i64 %866, 2
%891 = fadd float %875, %886
store float %891, float* %874
%892 = fsub float %875, %886
store float %892, float* %880
%893 = fadd float %878, %889
store float %893, float* %877
%894 = fsub float %878, %889
store float %894, float* %883
%895 = add nuw nsw i64 %867, 1
%896 = icmp eq i64 %895, 4096
br i1 %896, label %897, label %865
897: ; preds = %865
%898 = load float, float* %0
%899 = load float, float* %853
%900 = fadd float %898, %899
store float %900, float* %0
%901 = fsub float %898, %899
store float %901, float* %853
%902 = load float, float* %811
%903 = load float, float* %855
%904 = fadd float %902, %903
store float %904, float* %811
%905 = fsub float %902, %903
store float %905, float* %855
br label %906
906: ; preds = %897, %906
%907 = phi i64 [ 1, %897 ], [ %929, %906 ]
%908 = getelementptr inbounds float, float* %1, i64 %907
%909 = load float, float* %908
%910 = add nuw nsw i64 %907, 8192
%911 = getelementptr inbounds float, float* %1, i64 %910
%912 = load float, float* %911
%913 = getelementptr inbounds float, float* %0, i64 %907
%914 = load float, float* %913
%915 = sub nuw nsw i64 16384, %907
%916 = getelementptr inbounds float, float* %0, i64 %915
%917 = load float, float* %916
%918 = add nuw nsw i64 %907, 16384
%919 = getelementptr inbounds float, float* %0, i64 %918
%920 = load float, float* %919
%921 = sub nuw nsw i64 32768, %907
%922 = getelementptr inbounds float, float* %0, i64 %921
%923 = load float, float* %922
%924 = fmul float %909, %923
%925 = tail call float @llvm.fmuladd.f32(float %920, float %912, float %924)
%926 = fneg float %923
%927 = fmul float %912, %926
%928 = tail call float @llvm.fmuladd.f32(float %920, float %909, float %927)
%929 = add nuw nsw i64 %907, 1
%930 = fadd float %914, %925
store float %930, float* %913
%931 = fsub float %914, %925
store float %931, float* %919
%932 = fadd float %917, %928
store float %932, float* %916
%933 = fsub float %917, %928
store float %933, float* %922
%934 = icmp eq i64 %929, 8192
br i1 %934, label %935, label %906
935: ; preds = %906
ret void
}