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


x86 assembly (clang, -O0):
<DFT128>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x80,-0x14(%rbp)
jge    122c <DFT128+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 <DFT128+0x13>
movl   $0x0,-0x14(%rbp)
cmpl   $0x80,-0x14(%rbp)
jge    1418 <DFT128+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  0xcbb(%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  0xc86(%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 <DFT128+0x133>
movl   $0x0,-0x14(%rbp)
cmpl   $0x80,-0x14(%rbp)
jge    1692 <DFT128+0x592>
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    $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    167f <DFT128+0x57f>
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    $0x20,%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    $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    $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 <DFT128+0x3fc>
jmp    1684 <DFT128+0x584>
mov    -0x14(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x14(%rbp)
jmp    141f <DFT128+0x31f>
movl   $0x0,-0x14(%rbp)
cmpl   $0x80,-0x14(%rbp)
jge    190c <DFT128+0x80c>
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    $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    18f9 <DFT128+0x7f9>
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    $0x20,%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    $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    $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    1776 <DFT128+0x676>
jmp    18fe <DFT128+0x7fe>
mov    -0x14(%rbp),%eax
add    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    1699 <DFT128+0x599>
movl   $0x0,-0x14(%rbp)
cmpl   $0x80,-0x14(%rbp)
jge    1b86 <DFT128+0xa86>
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    $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    1b73 <DFT128+0xa73>
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    $0x20,%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    $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    $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    19f0 <DFT128+0x8f0>
jmp    1b78 <DFT128+0xa78>
mov    -0x14(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x14(%rbp)
jmp    1913 <DFT128+0x813>
movl   $0x1,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x100(%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,0x100(%rax)
mov    -0x8(%rbp),%rax
movss  0x80(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x180(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x20(%rbp),%xmm0
addss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x80(%rax)
movss  -0x20(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x180(%rax)
movl   $0x1,-0x18(%rbp)
cmpl   $0x20,-0x18(%rbp)
jge    1d9c <DFT128+0xc9c>
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    $0x20,%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    $0x40,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x40,%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    $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    -0x18(%rbp),%ecx
add    $0x40,%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    $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    $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    $0x40,%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    $0x40,%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    $0x80,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1c28 <DFT128+0xb28>
pop    %rbp
ret

x86 assembly (clang, -O2):
<DFT128>:
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    $0x200,%rax
jne    1110 <DFT128+0x10>
xor    %eax,%eax
movaps 0xddf(%rip),%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x60(%rdi,%rax,1),%xmm0
movss  0x40(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x20(%rdi,%rax,1),%xmm0
movss  (%rdi,%rax,1),%xmm10
unpcklps %xmm0,%xmm10
movlhps %xmm1,%xmm10
movss  0x4(%rdi,%rax,1),%xmm3
movss  0x8(%rdi,%rax,1),%xmm13
movss  0xc(%rdi,%rax,1),%xmm12
movss  0x70(%rdi,%rax,1),%xmm0
movss  0x50(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x30(%rdi,%rax,1),%xmm0
movss  0x10(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm10,%xmm9
addps  %xmm5,%xmm9
subps  %xmm5,%xmm10
movss  0x68(%rdi,%rax,1),%xmm0
movss  0x48(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x28(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm13
movlhps %xmm1,%xmm13
movss  0x78(%rdi,%rax,1),%xmm0
movss  0x58(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x38(%rdi,%rax,1),%xmm0
movss  0x18(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movlhps %xmm1,%xmm5
movaps %xmm13,%xmm11
addps  %xmm5,%xmm11
subps  %xmm5,%xmm13
movss  0x64(%rdi,%rax,1),%xmm0
movss  0x44(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movss  0x24(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x74(%rdi,%rax,1),%xmm0
movss  0x54(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x34(%rdi,%rax,1),%xmm0
movss  0x14(%rdi,%rax,1),%xmm1
unpcklps %xmm0,%xmm1
movlhps %xmm5,%xmm1
movss  0x7c(%rdi,%rax,1),%xmm0
movss  0x5c(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x3c(%rdi,%rax,1),%xmm0
movss  0x1c(%rdi,%rax,1),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm5,%xmm6
movaps %xmm1,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm8,%xmm0
subps  %xmm6,%xmm1
mulps  %xmm8,%xmm1
movaps %xmm3,%xmm7
addps  %xmm0,%xmm7
subps  %xmm0,%xmm3
movss  0x6c(%rdi,%rax,1),%xmm0
movss  0x4c(%rdi,%rax,1),%xmm5
unpcklps %xmm0,%xmm5
movss  0x2c(%rdi,%rax,1),%xmm0
unpcklps %xmm0,%xmm12
movlhps %xmm5,%xmm12
movaps %xmm1,%xmm0
addps  %xmm12,%xmm0
subps  %xmm1,%xmm12
movaps %xmm0,%xmm1
movlhps %xmm11,%xmm1
movaps %xmm9,%xmm14
unpcklps %xmm7,%xmm14
shufps $0x24,%xmm1,%xmm14
movaps %xmm12,%xmm6
movlhps %xmm13,%xmm6
movaps %xmm10,%xmm15
unpcklps %xmm3,%xmm15
shufps $0x24,%xmm6,%xmm15
movaps %xmm11,%xmm4
unpcklps %xmm0,%xmm4
movaps %xmm7,%xmm6
shufps $0x11,%xmm9,%xmm6
shufps $0xe2,%xmm4,%xmm6
movaps %xmm13,%xmm4
unpcklps %xmm12,%xmm4
movaps %xmm3,%xmm2
shufps $0x11,%xmm10,%xmm2
shufps $0xe2,%xmm4,%xmm2
movaps %xmm0,%xmm4
unpckhpd %xmm11,%xmm4
movaps %xmm9,%xmm5
unpckhps %xmm7,%xmm5
shufps $0x24,%xmm4,%xmm5
movaps %xmm12,%xmm4
unpckhpd %xmm13,%xmm4
movaps %xmm10,%xmm1
unpckhps %xmm3,%xmm1
shufps $0x24,%xmm4,%xmm1
unpckhps %xmm0,%xmm11
shufps $0x33,%xmm9,%xmm7
shufps $0xe2,%xmm11,%xmm7
unpckhps %xmm12,%xmm13
shufps $0x33,%xmm10,%xmm3
shufps $0xe2,%xmm13,%xmm3
movups %xmm3,0x70(%rdi,%rax,1)
movups %xmm7,0x60(%rdi,%rax,1)
movups %xmm1,0x50(%rdi,%rax,1)
movups %xmm5,0x40(%rdi,%rax,1)
movups %xmm2,0x30(%rdi,%rax,1)
movups %xmm6,0x20(%rdi,%rax,1)
movups %xmm15,0x10(%rdi,%rax,1)
movups %xmm14,(%rdi,%rax,1)
sub    $0xffffffffffffff80,%rax
cmp    $0x200,%rax
jne    1230 <DFT128+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  0x20(%rsi),%xmm1
movss  0xa0(%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  0x40(%rsi),%xmm0
movss  0xc0(%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  0x60(%rsi),%xmm0
movss  0xe0(%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    $0x70,%rax
jb     1450 <DFT128+0x350>
mov    $0x7c,%r8d
mov    $0x44,%r9d
xor    %r10d,%r10d
nopl   (%rax)
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    $0xffffffffffffffe4,%rax
mov    %r9,%rcx
mov    %r8,%rdx
nopw   0x0(%rax,%rax,1)
movss  0x80(%rsi,%rax,4),%xmm0
movss  0x100(%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    $0x4,%rax
jne    1670 <DFT128+0x570>
lea    0x20(%r10),%rax
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%r9
cmp    $0x60,%r10
mov    %rax,%r10
jb     1600 <DFT128+0x500>
movss  0x80(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x40(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x80(%rdi)
movss  0xc0(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x40(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0xc0(%rdi)
mov    $0x4,%eax
mov    $0x1f,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,2),%xmm0
movss  0x80(%rsi,%rax,2),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  0x80(%rdi,%rax,1),%xmm3
movss  (%rdi,%rcx,4),%xmm4
movss  0x80(%rdi,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,1)
subss  %xmm6,%xmm2
movss  %xmm2,0x80(%rdi,%rax,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%rdi,%rcx,4)
subss  %xmm3,%xmm4
movss  %xmm4,0x80(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x10,%rcx
jne    1760 <DFT128+0x660>
movss  0x180(%rdi),%xmm0
movss  0x100(%rdi),%xmm1
movss  0x140(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,0x100(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x180(%rdi)
movss  0x1c0(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x140(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0x1c0(%rdi)
mov    $0x82,%eax
mov    $0x7f,%ecx
nopl   0x0(%rax)
movss  -0x200(%rsi,%rax,4),%xmm0
ff ff
movss  -0x180(%rsi,%rax,4),%xmm1
ff ff
movss  (%rdi,%rax,2),%xmm2
movss  0x80(%rdi,%rax,2),%xmm3
movss  -0x80(%rdi,%rcx,4),%xmm4
movss  (%rdi,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,2)
subss  %xmm6,%xmm2
movss  %xmm2,0x80(%rdi,%rax,2)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x80(%rdi,%rcx,4)
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rcx,4)
add    $0x2,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x70,%rcx
jne    1850 <DFT128+0x750>
movss  0x100(%rdi),%xmm0
movss  (%rdi),%xmm1
movss  0x80(%rdi),%xmm2
movaps %xmm1,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi)
subss  %xmm0,%xmm1
movss  %xmm1,0x100(%rdi)
movss  0x180(%rdi),%xmm0
movaps %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x80(%rdi)
subss  %xmm0,%xmm2
movss  %xmm2,0x180(%rdi)
mov    $0x4,%eax
mov    $0x7f,%ecx
nop
movss  (%rsi,%rax,1),%xmm0
movss  0x80(%rsi,%rax,1),%xmm1
movss  (%rdi,%rax,1),%xmm2
movss  0x100(%rdi,%rax,1),%xmm3
movss  -0x100(%rdi,%rcx,4),%xmm4
ff ff
movss  (%rdi,%rcx,4),%xmm5
movaps %xmm3,%xmm6
mulss  %xmm0,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
mulss  %xmm5,%xmm1
subss  %xmm1,%xmm3
movaps %xmm2,%xmm0
addss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rax,1)
subss  %xmm6,%xmm2
movss  %xmm2,0x100(%rdi,%rax,1)
movaps %xmm4,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,-0x100(%rdi,%rcx,4)
ff ff
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rcx,4)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x60,%rcx
jne    1930 <DFT128+0x830>
ret

LLVM IR (-O0):
define void @DFT128(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, 128
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, 128
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, 128
br i1 %226, label %227, label %401
227: ; preds = %224
store i32 8, 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, 32
%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, 8
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, 128
br i1 %404, label %405, label %579
405: ; preds = %402
store i32 4, 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, 32
%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, 4
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, 128
br i1 %582, label %583, label %757
583: ; preds = %580
store i32 2, 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, 32
%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, 2
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 1, i32* %7
%758 = load float*, float** %3
%759 = getelementptr inbounds float, float* %758, i64 0
%760 = load float, float* %759
store float %760, float* %8
%761 = load float*, float** %3
%762 = getelementptr inbounds float, float* %761, i64 64
%763 = load float, float* %762
store float %763, float* %9
%764 = load float, float* %8
%765 = load float, float* %9
%766 = fadd float %764, %765
%767 = load float*, float** %3
%768 = getelementptr inbounds float, float* %767, i64 0
store float %766, float* %768
%769 = load float, float* %8
%770 = load float, float* %9
%771 = fsub float %769, %770
%772 = load float*, float** %3
%773 = getelementptr inbounds float, float* %772, i64 64
store float %771, float* %773
%774 = load float*, float** %3
%775 = getelementptr inbounds float, float* %774, i64 32
%776 = load float, float* %775
store float %776, float* %8
%777 = load float*, float** %3
%778 = getelementptr inbounds float, float* %777, i64 96
%779 = load float, float* %778
store float %779, float* %9
%780 = load float, float* %8
%781 = load float, float* %9
%782 = fadd float %780, %781
%783 = load float*, float** %3
%784 = getelementptr inbounds float, float* %783, i64 32
store float %782, float* %784
%785 = load float, float* %8
%786 = load float, float* %9
%787 = fsub float %785, %786
%788 = load float*, float** %3
%789 = getelementptr inbounds float, float* %788, i64 96
store float %787, float* %789
store i32 1, i32* %6
br label %790
790: ; preds = %887, %757
%791 = load i32, i32* %6
%792 = icmp slt i32 %791, 32
br i1 %792, label %793, label %890
793: ; preds = %790
%794 = load float*, float** %4
%795 = load i32, i32* %7
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds float, float* %794, i64 %796
%798 = load float, float* %797
store float %798, float* %12
%799 = load float*, float** %4
%800 = load i32, i32* %7
%801 = add nsw i32 %800, 32
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds float, float* %799, i64 %802
%804 = load float, float* %803
store float %804, float* %13
%805 = load float*, float** %3
%806 = load i32, i32* %6
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds float, float* %805, i64 %807
%809 = load float, float* %808
store float %809, float* %8
%810 = load float*, float** %3
%811 = load i32, i32* %6
%812 = sub nsw i32 0, %811
%813 = add nsw i32 %812, 64
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %810, i64 %814
%816 = load float, float* %815
store float %816, float* %9
%817 = load float*, float** %3
%818 = load i32, i32* %6
%819 = add nsw i32 %818, 64
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds float, float* %817, i64 %820
%822 = load float, float* %821
%823 = load float, float* %13
%824 = load float*, float** %3
%825 = load i32, i32* %6
%826 = sub nsw i32 0, %825
%827 = add nsw i32 %826, 128
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float, float* %824, i64 %828
%830 = load float, float* %829
%831 = load float, float* %12
%832 = fmul float %830, %831
%833 = call float @llvm.fmuladd.f32(float %822, float %823, float %832)
store float %833, float* %10
%834 = load float*, float** %3
%835 = load i32, i32* %6
%836 = add nsw i32 %835, 64
%837 = sext i32 %836 to i64
%838 = getelementptr inbounds float, float* %834, i64 %837
%839 = load float, float* %838
%840 = load float, float* %12
%841 = load float*, float** %3
%842 = load i32, i32* %6
%843 = sub nsw i32 0, %842
%844 = add nsw i32 %843, 128
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds float, float* %841, i64 %845
%847 = load float, float* %846
%848 = load float, float* %13
%849 = fmul float %847, %848
%850 = fneg float %849
%851 = call float @llvm.fmuladd.f32(float %839, float %840, float %850)
store float %851, float* %11
%852 = load i32, i32* %7
%853 = add nsw i32 %852, 1
store i32 %853, i32* %7
%854 = load float, float* %8
%855 = load float, float* %10
%856 = fadd float %854, %855
%857 = load float*, float** %3
%858 = load i32, i32* %6
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds float, float* %857, i64 %859
store float %856, float* %860
%861 = load float, float* %8
%862 = load float, float* %10
%863 = fsub float %861, %862
%864 = load float*, float** %3
%865 = load i32, i32* %6
%866 = add nsw i32 %865, 64
%867 = sext i32 %866 to i64
%868 = getelementptr inbounds float, float* %864, i64 %867
store float %863, float* %868
%869 = load float, float* %9
%870 = load float, float* %11
%871 = fadd float %869, %870
%872 = load float*, float** %3
%873 = load i32, i32* %6
%874 = sub nsw i32 0, %873
%875 = add nsw i32 %874, 64
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds float, float* %872, i64 %876
store float %871, float* %877
%878 = load float, float* %9
%879 = load float, float* %11
%880 = fsub float %878, %879
%881 = load float*, float** %3
%882 = load i32, i32* %6
%883 = sub nsw i32 0, %882
%884 = add nsw i32 %883, 128
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds float, float* %881, i64 %885
store float %880, float* %886
br label %887
887: ; preds = %793
%888 = load i32, i32* %6
%889 = add nsw i32 %888, 1
store i32 %889, i32* %6
br label %790
890: ; preds = %790
ret void
}

LLVM IR (-O2):
define void @DFT128(float* %0, float* nocapture %1) {
br label %3
3: ; preds = %3, %2
%4 = phi i64 [ 0, %2 ], [ %82, %3 ]
%5 = shl i64 %4, 2
%6 = or i64 %5, 4
%7 = or i64 %5, 8
%8 = or i64 %5, 12
%9 = getelementptr inbounds float, float* %0, i64 %5
%10 = getelementptr inbounds float, float* %0, i64 %6
%11 = getelementptr inbounds float, float* %0, i64 %7
%12 = getelementptr inbounds float, float* %0, i64 %8
%13 = load float, float* %9
%14 = load float, float* %10
%15 = load float, float* %11
%16 = load float, float* %12
%17 = insertelement <4 x float> poison, float %13, i64 0
%18 = insertelement <4 x float> %17, float %14, i64 1
%19 = insertelement <4 x float> %18, float %15, i64 2
%20 = insertelement <4 x float> %19, float %16, i64 3
%21 = or i64 %5, 1
%22 = or i64 %5, 5
%23 = or i64 %5, 9
%24 = or i64 %5, 13
%25 = getelementptr inbounds float, float* %0, i64 %21
%26 = getelementptr inbounds float, float* %0, i64 %22
%27 = getelementptr inbounds float, float* %0, i64 %23
%28 = getelementptr inbounds float, float* %0, i64 %24
%29 = load float, float* %25
%30 = load float, float* %26
%31 = load float, float* %27
%32 = load float, float* %28
%33 = insertelement <4 x float> poison, float %29, i64 0
%34 = insertelement <4 x float> %33, float %30, i64 1
%35 = insertelement <4 x float> %34, float %31, i64 2
%36 = insertelement <4 x float> %35, float %32, i64 3
%37 = or i64 %5, 2
%38 = or i64 %5, 6
%39 = or i64 %5, 10
%40 = or i64 %5, 14
%41 = getelementptr inbounds float, float* %0, i64 %37
%42 = getelementptr inbounds float, float* %0, i64 %38
%43 = getelementptr inbounds float, float* %0, i64 %39
%44 = getelementptr inbounds float, float* %0, i64 %40
%45 = load float, float* %41
%46 = load float, float* %42
%47 = load float, float* %43
%48 = load float, float* %44
%49 = insertelement <4 x float> poison, float %45, i64 0
%50 = insertelement <4 x float> %49, float %46, i64 1
%51 = insertelement <4 x float> %50, float %47, i64 2
%52 = insertelement <4 x float> %51, float %48, i64 3
%53 = or i64 %5, 3
%54 = or i64 %5, 7
%55 = or i64 %5, 11
%56 = or i64 %5, 15
%57 = getelementptr inbounds float, float* %0, i64 %53
%58 = getelementptr inbounds float, float* %0, i64 %54
%59 = getelementptr inbounds float, float* %0, i64 %55
%60 = getelementptr inbounds float, float* %0, i64 %56
%61 = load float, float* %57
%62 = load float, float* %58
%63 = load float, float* %59
%64 = load float, float* %60
%65 = insertelement <4 x float> poison, float %61, i64 0
%66 = insertelement <4 x float> %65, float %62, i64 1
%67 = insertelement <4 x float> %66, float %63, i64 2
%68 = insertelement <4 x float> %67, float %64, i64 3
%69 = fadd <4 x float> %20, %36
%70 = fsub <4 x float> %20, %36
%71 = fadd <4 x float> %52, %68
%72 = fsub <4 x float> %52, %68
%73 = fadd <4 x float> %69, %71
%74 = fsub <4 x float> %69, %71
%75 = fadd <4 x float> %70, %72
%76 = fsub <4 x float> %70, %72
%77 = getelementptr inbounds float, float* %57, i64 -3
%78 = bitcast float* %77 to <16 x float>*
%79 = shufflevector <4 x float> %73, <4 x float> %75, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%80 = shufflevector <4 x float> %74, <4 x float> %76, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%81 = shufflevector <8 x float> %79, <8 x float> %80, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
store <16 x float> %81, <16 x float>* %78
%82 = add nuw i64 %4, 4
%83 = icmp eq i64 %82, 32
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, 16
br i1 %236, label %237, label %84
237: ; preds = %84
%238 = getelementptr inbounds float, float* %1, i64 8
%239 = getelementptr inbounds float, float* %1, i64 40
%240 = getelementptr inbounds float, float* %1, i64 16
%241 = getelementptr inbounds float, float* %1, i64 48
%242 = getelementptr inbounds float, float* %1, i64 24
%243 = getelementptr inbounds float, float* %1, i64 56
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, 112
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 [ 4, %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, 32
%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, 4
%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, 96
br i1 %384, label %332, label %385
385: ; preds = %382
%386 = load float, float* %0
%387 = getelementptr inbounds float, float* %0, i64 32
%388 = load float, float* %387
%389 = fadd float %386, %388
store float %389, float* %0
%390 = fsub float %386, %388
store float %390, float* %387
%391 = getelementptr inbounds float, float* %0, i64 16
%392 = load float, float* %391
%393 = getelementptr inbounds float, float* %0, i64 48
%394 = load float, float* %393
%395 = fadd float %392, %394
store float %395, float* %391
%396 = fsub float %392, %394
store float %396, float* %393
br label %397
397: ; preds = %385, %397
%398 = phi i64 [ 2, %385 ], [ %421, %397 ]
%399 = phi i64 [ 1, %385 ], [ %426, %397 ]
%400 = getelementptr inbounds float, float* %1, i64 %398
%401 = load float, float* %400
%402 = add nuw nsw i64 %398, 32
%403 = getelementptr inbounds float, float* %1, i64 %402
%404 = load float, float* %403
%405 = getelementptr inbounds float, float* %0, i64 %399
%406 = load float, float* %405
%407 = sub nsw i64 32, %399
%408 = getelementptr inbounds float, float* %0, i64 %407
%409 = load float, float* %408
%410 = add nuw nsw i64 %399, 32
%411 = getelementptr inbounds float, float* %0, i64 %410
%412 = load float, float* %411
%413 = sub nsw i64 64, %399
%414 = getelementptr inbounds float, float* %0, i64 %413
%415 = load float, float* %414
%416 = fmul float %401, %415
%417 = tail call float @llvm.fmuladd.f32(float %412, float %404, float %416)
%418 = fneg float %415
%419 = fmul float %404, %418
%420 = tail call float @llvm.fmuladd.f32(float %412, float %401, float %419)
%421 = add nuw nsw i64 %398, 2
%422 = fadd float %406, %417
store float %422, float* %405
%423 = fsub float %406, %417
store float %423, float* %411
%424 = fadd float %409, %420
store float %424, float* %408
%425 = fsub float %409, %420
store float %425, float* %414
%426 = add nuw nsw i64 %399, 1
%427 = icmp eq i64 %426, 16
br i1 %427, label %428, label %397
428: ; preds = %397
%429 = getelementptr inbounds float, float* %0, i64 64
%430 = load float, float* %429
%431 = getelementptr inbounds float, float* %0, i64 96
%432 = load float, float* %431
%433 = fadd float %430, %432
store float %433, float* %429
%434 = fsub float %430, %432
store float %434, float* %431
%435 = getelementptr inbounds float, float* %0, i64 80
%436 = load float, float* %435
%437 = getelementptr inbounds float, float* %0, i64 112
%438 = load float, float* %437
%439 = fadd float %436, %438
store float %439, float* %435
%440 = fsub float %436, %438
store float %440, float* %437
br label %441
441: ; preds = %441, %428
%442 = phi i64 [ 2, %428 ], [ %466, %441 ]
%443 = phi i64 [ 1, %428 ], [ %471, %441 ]
%444 = getelementptr inbounds float, float* %1, i64 %442
%445 = load float, float* %444
%446 = add nuw nsw i64 %442, 32
%447 = getelementptr inbounds float, float* %1, i64 %446
%448 = load float, float* %447
%449 = add nuw nsw i64 %443, 64
%450 = getelementptr inbounds float, float* %0, i64 %449
%451 = load float, float* %450
%452 = sub nsw i64 96, %443
%453 = getelementptr inbounds float, float* %0, i64 %452
%454 = load float, float* %453
%455 = add nuw nsw i64 %443, 96
%456 = getelementptr inbounds float, float* %0, i64 %455
%457 = load float, float* %456
%458 = sub nsw i64 128, %443
%459 = getelementptr inbounds float, float* %0, i64 %458
%460 = load float, float* %459
%461 = fmul float %445, %460
%462 = tail call float @llvm.fmuladd.f32(float %457, float %448, float %461)
%463 = fneg float %460
%464 = fmul float %448, %463
%465 = tail call float @llvm.fmuladd.f32(float %457, float %445, float %464)
%466 = add nuw nsw i64 %442, 2
%467 = fadd float %451, %462
store float %467, float* %450
%468 = fsub float %451, %462
store float %468, float* %456
%469 = fadd float %454, %465
store float %469, float* %453
%470 = fsub float %454, %465
store float %470, float* %459
%471 = add nuw nsw i64 %443, 1
%472 = icmp eq i64 %471, 16
br i1 %472, label %473, label %441
473: ; preds = %441
%474 = load float, float* %0
%475 = load float, float* %429
%476 = fadd float %474, %475
store float %476, float* %0
%477 = fsub float %474, %475
store float %477, float* %429
%478 = load float, float* %387
%479 = load float, float* %431
%480 = fadd float %478, %479
store float %480, float* %387
%481 = fsub float %478, %479
store float %481, float* %431
br label %482
482: ; preds = %473, %482
%483 = phi i64 [ 1, %473 ], [ %505, %482 ]
%484 = getelementptr inbounds float, float* %1, i64 %483
%485 = load float, float* %484
%486 = add nuw nsw i64 %483, 32
%487 = getelementptr inbounds float, float* %1, i64 %486
%488 = load float, float* %487
%489 = getelementptr inbounds float, float* %0, i64 %483
%490 = load float, float* %489
%491 = sub nuw nsw i64 64, %483
%492 = getelementptr inbounds float, float* %0, i64 %491
%493 = load float, float* %492
%494 = add nuw nsw i64 %483, 64
%495 = getelementptr inbounds float, float* %0, i64 %494
%496 = load float, float* %495
%497 = sub nuw nsw i64 128, %483
%498 = getelementptr inbounds float, float* %0, i64 %497
%499 = load float, float* %498
%500 = fmul float %485, %499
%501 = tail call float @llvm.fmuladd.f32(float %496, float %488, float %500)
%502 = fneg float %499
%503 = fmul float %488, %502
%504 = tail call float @llvm.fmuladd.f32(float %496, float %485, float %503)
%505 = add nuw nsw i64 %483, 1
%506 = fadd float %490, %501
store float %506, float* %489
%507 = fsub float %490, %501
store float %507, float* %495
%508 = fadd float %493, %504
store float %508, float* %492
%509 = fsub float %493, %504
store float %509, float* %498
%510 = icmp eq i64 %505, 32
br i1 %510, label %511, label %482
511: ; preds = %482
ret void
}