void cftmdl(int n, int l, double *a, double const *w) {
  int j, j1, j2, j3, k, k1, k2, m, m2;
  double wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
  m = l << 2;
  for (j = 0; j < l; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    x0r = a[j] + a[j1];
    x0i = a[j + 1] + a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = a[j + 1] - a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j2] = x0r - x2r;
    a[j2 + 1] = x0i - x2i;
    a[j1] = x1r - x3i;
    a[j1 + 1] = x1i + x3r;
    a[j3] = x1r + x3i;
    a[j3 + 1] = x1i - x3r;
  }
  wk1r = w[2];
  for (j = m; j < l + m; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    x0r = a[j] + a[j1];
    x0i = a[j + 1] + a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = a[j + 1] - a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    a[j] = x0r + x2r;
    a[j + 1] = x0i + x2i;
    a[j2] = x2i - x0i;
    a[j2 + 1] = x0r - x2r;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    a[j1] = wk1r * (x0r - x0i);
    a[j1 + 1] = wk1r * (x0r + x0i);
    x0r = x3i + x1r;
    x0i = x3r - x1i;
    a[j3] = wk1r * (x0i - x0r);
    a[j3 + 1] = wk1r * (x0i + x0r);
  }
  k1 = 0;
  m2 = 2 * m;
  for (k = m2; k < n; k += m2) {
    k1 += 2;
    k2 = 2 * k1;
    wk2r = w[k1];
    wk2i = w[k1 + 1];
    wk1r = w[k2];
    wk1i = w[k2 + 1];
    wk3r = wk1r - 2 * wk2i * wk1i;
    wk3i = 2 * wk2i * wk1r - wk1i;
    for (j = k; j < l + k; j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      x0r -= x2r;
      x0i -= x2i;
      a[j2] = wk2r * x0r - wk2i * x0i;
      a[j2 + 1] = wk2r * x0i + wk2i * x0r;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j1] = wk1r * x0r - wk1i * x0i;
      a[j1 + 1] = wk1r * x0i + wk1i * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3] = wk3r * x0r - wk3i * x0i;
      a[j3 + 1] = wk3r * x0i + wk3i * x0r;
    }
    wk1r = w[k2 + 2];
    wk1i = w[k2 + 3];
    wk3r = wk1r - 2 * wk2r * wk1i;
    wk3i = 2 * wk2r * wk1r - wk1i;
    for (j = k + m; j < l + (k + m); j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      a[j] = x0r + x2r;
      a[j + 1] = x0i + x2i;
      x0r -= x2r;
      x0i -= x2i;
      a[j2] = -wk2i * x0r - wk2r * x0i;
      a[j2 + 1] = -wk2i * x0i + wk2r * x0r;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      a[j1] = wk1r * x0r - wk1i * x0i;
      a[j1 + 1] = wk1r * x0i + wk1i * x0r;
      x0r = x1r + x3i;
      x0i = x1i - x3r;
      a[j3] = wk3r * x0r - wk3i * x0i;
      a[j3 + 1] = wk3r * x0i + wk3i * x0r;
    }
  }
}


x86 assembly (clang, -O0):
<cftmdl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    137d <cftmdl+0x27d>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1126 <cftmdl+0x26>
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    164d <cftmdl+0x54d>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
subsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
subsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
addsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1391 <cftmdl+0x291>
movl   $0x0,-0x30(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1f20 <cftmdl+0xe20>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  0x920(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x8ea(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jge    1abe <cftmdl+0x9be>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    174f <cftmdl+0x64f>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  0x507(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x4d1(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%ecx
mov    -0x2c(%rbp),%edx
add    -0x38(%rbp),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jge    1f0d <cftmdl+0xe0d>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b6b <cftmdl+0xa6b>
jmp    1f12 <cftmdl+0xe12>
mov    -0x3c(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1663 <cftmdl+0x563>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,-0x68(%rsp)
lea    0x0(,%rsi,4),%r8d
test   %esi,%esi
jle    11b7 <cftmdl+0xb7>
mov    %esi,%r9d
lea    (%rdx,%r9,8),%r10
mov    %r9,%rax
shl    $0x4,%rax
add    %rdx,%rax
lea    (%r9,%r9,2),%rbp
lea    (%rdx,%rbp,8),%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
movupd (%rdx,%rbx,8),%xmm0
movupd (%r10,%rbx,8),%xmm1
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd 0x0(%rbp,%rbx,8),%xmm3
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
subpd  %xmm3,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rdx,%rbx,8)
subpd  %xmm4,%xmm2
movupd %xmm2,(%rax,%rbx,8)
movapd %xmm0,%xmm2
subpd  %xmm1,%xmm2
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
movsd  %xmm2,%xmm0
movupd %xmm0,(%r10,%rbx,8)
shufpd $0x2,%xmm2,%xmm1
movupd %xmm1,0x0(%rbp,%rbx,8)
add    $0x2,%rbx
cmp    %r9,%rbx
jb     1140 <cftmdl+0x40>
lea    (%rsi,%rsi,4),%eax
movslq %r8d,%rcx
mov    %rcx,-0x58(%rsp)
movslq %esi,%rcx
mov    %rcx,-0x78(%rsp)
cmp    %eax,%r8d
jge    12f6 <cftmdl+0x1f6>
mov    -0x68(%rsp),%rcx
movsd  0x10(%rcx),%xmm8
movslq %eax,%r9
mov    -0x78(%rsp),%rax
lea    (%rdx,%rax,8),%rbp
add    $0x8,%rbp
mov    %rax,%r10
shl    $0x4,%r10
add    %rdx,%r10
lea    (%rax,%rax,2),%rax
lea    (%rdx,%rax,8),%rbx
add    $0x8,%rbx
mov    -0x58(%rsp),%rax
nopl   0x0(%rax)
movsd  (%rdx,%rax,8),%xmm3
movsd  0x8(%rdx,%rax,8),%xmm5
movsd  -0x8(%rbp,%rax,8),%xmm9
movsd  0x0(%rbp,%rax,8),%xmm7
movapd %xmm5,%xmm4
subsd  %xmm7,%xmm4
movsd  (%r10,%rax,8),%xmm1
movsd  0x8(%r10,%rax,8),%xmm2
unpcklpd %xmm1,%xmm5
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm6
unpcklpd %xmm0,%xmm7
addpd  %xmm5,%xmm7
movapd %xmm2,%xmm5
unpcklpd %xmm3,%xmm5
subsd  %xmm9,%xmm3
subsd  %xmm6,%xmm2
unpcklpd %xmm9,%xmm6
addpd  %xmm5,%xmm6
subsd  %xmm0,%xmm1
movapd %xmm7,%xmm0
addpd  %xmm6,%xmm0
shufpd $0x1,%xmm0,%xmm0
movupd %xmm0,(%rdx,%rax,8)
subpd  %xmm7,%xmm6
movupd %xmm6,(%r10,%rax,8)
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm4,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm0,%xmm6
subsd  %xmm5,%xmm6
mulsd  %xmm8,%xmm6
movsd  %xmm6,-0x8(%rbp,%rax,8)
addsd  %xmm0,%xmm5
mulsd  %xmm8,%xmm5
movsd  %xmm5,0x0(%rbp,%rax,8)
addsd  %xmm3,%xmm2
subsd  %xmm4,%xmm1
movapd %xmm1,%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm8,%xmm0
movsd  %xmm0,-0x8(%rbx,%rax,8)
addsd  %xmm2,%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %r9,%rax
jl     1210 <cftmdl+0x110>
mov    %rdx,-0x60(%rsp)
lea    0x0(,%rsi,8),%eax
mov    %eax,-0x6c(%rsp)
cmp    %edi,%eax
jge    1755 <cftmdl+0x655>
movslq -0x6c(%rsp),%rcx
lea    (%r8,%r8,2),%eax
mov    %eax,-0x7c(%rsp)
movslq %edi,%rax
mov    %rax,-0x30(%rsp)
mov    -0x60(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdx
mov    -0x78(%rsp),%rbp
lea    0x0(%rbp,%rcx,1),%rax
lea    (%rdi,%rax,8),%r13
lea    (%rcx,%rbp,2),%rax
lea    (%rdi,%rax,8),%r9
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
add    %rcx,%rax
lea    (%rdi,%rax,8),%r11
mov    %rbp,%rdi
shl    $0x4,%rdi
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%r12
xor    %r8d,%r8d
xor    %r15d,%r15d
mov    %rcx,%r10
mov    %rsi,-0x28(%rsp)
mov    %rcx,-0x38(%rsp)
jmp    13b6 <cftmdl+0x2b6>
nopl   0x0(%rax)
mov    -0x38(%rsp),%rcx
mov    -0x50(%rsp),%r10
add    %rcx,%r10
mov    -0x7c(%rsp),%eax
add    -0x6c(%rsp),%eax
mov    %eax,-0x7c(%rsp)
mov    -0x18(%rsp),%r8
add    %rcx,%r8
mov    -0x20(%rsp),%r15
cmp    -0x30(%rsp),%r10
mov    -0x28(%rsp),%rsi
jge    1755 <cftmdl+0x655>
lea    0x2(%r15),%r14
mov    -0x68(%rsp),%rax
movsd  0x10(%rax,%r15,8),%xmm0
movaps %xmm0,(%rsp)
movsd  0x18(%rax,%r15,8),%xmm0
movapd %xmm0,-0x10(%rsp)
test   %esi,%esi
jle    1567 <cftmdl+0x467>
mov    %r14,%rbx
shl    $0x4,%rbx
mov    -0x78(%rsp),%rax
add    %r10,%rax
mov    -0x68(%rsp),%rbp
movsd  0x0(%rbp,%rbx,1),%xmm13
movsd  0x8(%rbp,%rbx,1),%xmm2
movapd -0x10(%rsp),%xmm4
movapd %xmm4,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm1,%xmm15
mulsd  %xmm13,%xmm15
subsd  %xmm2,%xmm15
mulsd  %xmm2,%xmm1
unpcklpd %xmm2,%xmm0
movapd %xmm0,-0x50(%rsp)
xorpd  0xbcd(%rip),%xmm2
movapd %xmm13,%xmm5
subsd  %xmm1,%xmm5
movapd %xmm4,%xmm10
movapd 0xbb7(%rip),%xmm0
xorpd  %xmm0,%xmm10
unpcklpd %xmm5,%xmm5
unpcklpd %xmm15,%xmm14
xorpd  %xmm0,%xmm15
unpcklpd %xmm13,%xmm13
movapd (%rsp),%xmm3
unpcklpd %xmm3,%xmm3
unpcklpd %xmm4,%xmm12
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%rbx,8),%xmm11
movupd 0x0(%r13,%rbx,8),%xmm1
movapd %xmm11,%xmm0
addpd  %xmm1,%xmm0
subpd  %xmm1,%xmm11
movupd (%r9,%rbx,8),%xmm1
movupd (%r11,%rbx,8),%xmm8
movapd %xmm1,%xmm9
addpd  %xmm8,%xmm9
subpd  %xmm8,%xmm1
shufpd $0x1,%xmm1,%xmm1
movapd %xmm0,%xmm7
addpd  %xmm9,%xmm7
movupd %xmm7,(%rdx,%rbx,8)
subpd  %xmm9,%xmm0
movapd %xmm0,%xmm7
unpckhpd %xmm12,%xmm7
movapd %xmm10,%xmm6
unpcklpd %xmm0,%xmm6
mulpd  %xmm7,%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm6,%xmm0
movupd %xmm0,(%r9,%rbx,8)
movapd %xmm11,%xmm0
subpd  %xmm1,%xmm0
addpd  %xmm11,%xmm1
movapd %xmm1,%xmm6
unpckhpd -0x50(%rsp),%xmm6
movapd %xmm2,%xmm7
unpcklpd %xmm0,%xmm7
mulpd  %xmm6,%xmm7
movapd %xmm0,%xmm6
movsd  %xmm1,%xmm6
movapd %xmm15,%xmm4
unpcklpd %xmm1,%xmm4
movsd  %xmm0,%xmm1
mulpd  %xmm13,%xmm1
addpd  %xmm1,%xmm7
movupd %xmm7,0x0(%r13,%rbx,8)
mulpd  %xmm5,%xmm6
unpckhpd %xmm14,%xmm0
mulpd  %xmm0,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm4,(%r11,%rbx,8)
lea    (%rcx,%rbx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rbx
cmp    %rax,%rbp
jl     1480 <cftmdl+0x380>
mov    %r14,-0x20(%rsp)
mov    %r10,-0x50(%rsp)
mov    %r8,-0x18(%rsp)
test   %esi,%esi
mov    -0x60(%rsp),%rsi
movapd (%rsp),%xmm11
jle    1380 <cftmdl+0x280>
mov    %r15,%rcx
movslq -0x7c(%rsp),%r15
mov    -0x78(%rsp),%rax
lea    (%rax,%r15,1),%rbp
mov    %r15,%r10
shl    $0x20,%r10
lea    (%rsi,%r15,8),%r14
lea    (%rsi,%rbp,8),%r8
lea    (%rcx,%rcx,1),%rsi
add    $0x4,%rsi
shl    $0x3,%rsi
mov    -0x68(%rsp),%rcx
mov    %rsi,%rbp
or     $0x10,%rbp
or     $0x18,%rsi
mov    -0x58(%rsp),%rax
mov    -0x50(%rsp),%rbx
add    %rbx,%rax
add    -0x78(%rsp),%rax
movsd  (%rcx,%rbp,1),%xmm12
movabs $0x200000000,%rbp
movsd  (%rcx,%rsi,1),%xmm7
mov    -0x60(%rsp),%rbx
movapd %xmm11,%xmm0
addsd  %xmm11,%xmm0
movapd %xmm0,%xmm5
mulsd  %xmm12,%xmm5
subsd  %xmm7,%xmm5
mulsd  %xmm7,%xmm0
unpcklpd %xmm7,%xmm13
xorpd  0x9e7(%rip),%xmm7
movapd %xmm12,%xmm4
subsd  %xmm0,%xmm4
movapd 0x9d6(%rip),%xmm0
movapd -0x10(%rsp),%xmm1
xorpd  %xmm0,%xmm1
unpcklpd %xmm4,%xmm4
unpcklpd %xmm5,%xmm8
xorpd  %xmm0,%xmm5
unpcklpd %xmm12,%xmm12
pshufd $0x44,%xmm1,%xmm9
unpcklpd %xmm11,%xmm10
xorpd  %xmm0,%xmm11
cs nopw 0x0(%rax,%rax,1)
movupd (%r8),%xmm0
mov    %r10,%rsi
sar    $0x1d,%rsi
or     $0x8,%rsi
movsd  (%r14),%xmm1
movhpd (%rbx,%rsi,1),%xmm1
movapd %xmm1,%xmm6
addpd  %xmm0,%xmm6
subpd  %xmm0,%xmm1
movupd (%r14,%rdi,1),%xmm0
movupd (%r14,%r12,1),%xmm3
movapd %xmm0,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm0
shufpd $0x1,%xmm0,%xmm0
movapd %xmm6,%xmm3
addpd  %xmm2,%xmm3
movlpd %xmm3,(%r14)
movhpd %xmm3,(%rbx,%rsi,1)
subpd  %xmm2,%xmm6
movapd %xmm6,%xmm2
unpckhpd %xmm10,%xmm2
movapd %xmm11,%xmm3
unpcklpd %xmm6,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm9,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm6,(%r14,%rdi,1)
movapd %xmm1,%xmm2
subpd  %xmm0,%xmm2
addpd  %xmm1,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm13,%xmm1
movapd %xmm7,%xmm3
unpcklpd %xmm2,%xmm3
mulpd  %xmm1,%xmm3
movapd %xmm2,%xmm1
movsd  %xmm0,%xmm1
movapd %xmm5,%xmm6
unpcklpd %xmm0,%xmm6
movsd  %xmm2,%xmm0
mulpd  %xmm12,%xmm0
addpd  %xmm0,%xmm3
movupd %xmm3,(%r8)
mulpd  %xmm4,%xmm1
unpckhpd %xmm8,%xmm2
mulpd  %xmm2,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm6,(%r14,%r12,1)
add    $0x2,%r15
add    %rbp,%r10
add    $0x10,%r14
add    $0x10,%r8
cmp    %rax,%r15
jl     1660 <cftmdl+0x560>
jmp    1380 <cftmdl+0x280>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cftmdl(i32 %0, i32 %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
store i32 %0, i32* %5
store i32 %1, i32* %6
store double* %2, double** %7
store double* %3, double** %8
%32 = load i32, i32* %6
%33 = shl i32 %32, 2
store i32 %33, i32* %16
store i32 0, i32* %9
br label %34
34: ; preds = %204, %4
%35 = load i32, i32* %9
%36 = load i32, i32* %6
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %207
38: ; preds = %34
%39 = load i32, i32* %9
%40 = load i32, i32* %6
%41 = add nsw i32 %39, %40
store i32 %41, i32* %10
%42 = load i32, i32* %10
%43 = load i32, i32* %6
%44 = add nsw i32 %42, %43
store i32 %44, i32* %11
%45 = load i32, i32* %11
%46 = load i32, i32* %6
%47 = add nsw i32 %45, %46
store i32 %47, i32* %12
%48 = load double*, double** %7
%49 = load i32, i32* %9
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %48, i64 %50
%52 = load double, double* %51
%53 = load double*, double** %7
%54 = load i32, i32* %10
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
%57 = load double, double* %56
%58 = fadd double %52, %57
store double %58, double* %24
%59 = load double*, double** %7
%60 = load i32, i32* %9
%61 = add nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %59, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %7
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %65, i64 %68
%70 = load double, double* %69
%71 = fadd double %64, %70
store double %71, double* %25
%72 = load double*, double** %7
%73 = load i32, i32* %9
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %72, i64 %74
%76 = load double, double* %75
%77 = load double*, double** %7
%78 = load i32, i32* %10
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = fsub double %76, %81
store double %82, double* %26
%83 = load double*, double** %7
%84 = load i32, i32* %9
%85 = add nsw i32 %84, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %83, i64 %86
%88 = load double, double* %87
%89 = load double*, double** %7
%90 = load i32, i32* %10
%91 = add nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %89, i64 %92
%94 = load double, double* %93
%95 = fsub double %88, %94
store double %95, double* %27
%96 = load double*, double** %7
%97 = load i32, i32* %11
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
%100 = load double, double* %99
%101 = load double*, double** %7
%102 = load i32, i32* %12
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
%105 = load double, double* %104
%106 = fadd double %100, %105
store double %106, double* %28
%107 = load double*, double** %7
%108 = load i32, i32* %11
%109 = add nsw i32 %108, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %107, i64 %110
%112 = load double, double* %111
%113 = load double*, double** %7
%114 = load i32, i32* %12
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %113, i64 %116
%118 = load double, double* %117
%119 = fadd double %112, %118
store double %119, double* %29
%120 = load double*, double** %7
%121 = load i32, i32* %11
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
%124 = load double, double* %123
%125 = load double*, double** %7
%126 = load i32, i32* %12
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = fsub double %124, %129
store double %130, double* %30
%131 = load double*, double** %7
%132 = load i32, i32* %11
%133 = add nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %131, i64 %134
%136 = load double, double* %135
%137 = load double*, double** %7
%138 = load i32, i32* %12
%139 = add nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %137, i64 %140
%142 = load double, double* %141
%143 = fsub double %136, %142
store double %143, double* %31
%144 = load double, double* %24
%145 = load double, double* %28
%146 = fadd double %144, %145
%147 = load double*, double** %7
%148 = load i32, i32* %9
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %147, i64 %149
store double %146, double* %150
%151 = load double, double* %25
%152 = load double, double* %29
%153 = fadd double %151, %152
%154 = load double*, double** %7
%155 = load i32, i32* %9
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
store double %153, double* %158
%159 = load double, double* %24
%160 = load double, double* %28
%161 = fsub double %159, %160
%162 = load double*, double** %7
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
store double %161, double* %165
%166 = load double, double* %25
%167 = load double, double* %29
%168 = fsub double %166, %167
%169 = load double*, double** %7
%170 = load i32, i32* %11
%171 = add nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %169, i64 %172
store double %168, double* %173
%174 = load double, double* %26
%175 = load double, double* %31
%176 = fsub double %174, %175
%177 = load double*, double** %7
%178 = load i32, i32* %10
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
store double %176, double* %180
%181 = load double, double* %27
%182 = load double, double* %30
%183 = fadd double %181, %182
%184 = load double*, double** %7
%185 = load i32, i32* %10
%186 = add nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %184, i64 %187
store double %183, double* %188
%189 = load double, double* %26
%190 = load double, double* %31
%191 = fadd double %189, %190
%192 = load double*, double** %7
%193 = load i32, i32* %12
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %192, i64 %194
store double %191, double* %195
%196 = load double, double* %27
%197 = load double, double* %30
%198 = fsub double %196, %197
%199 = load double*, double** %7
%200 = load i32, i32* %12
%201 = add nsw i32 %200, 1
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %199, i64 %202
store double %198, double* %203
br label %204
204: ; preds = %38
%205 = load i32, i32* %9
%206 = add nsw i32 %205, 2
store i32 %206, i32* %9
br label %34
207: ; preds = %34
%208 = load double*, double** %8
%209 = getelementptr inbounds double, double* %208, i64 2
%210 = load double, double* %209
store double %210, double* %18
%211 = load i32, i32* %16
store i32 %211, i32* %9
br label %212
212: ; preds = %404, %207
%213 = load i32, i32* %9
%214 = load i32, i32* %6
%215 = load i32, i32* %16
%216 = add nsw i32 %214, %215
%217 = icmp slt i32 %213, %216
br i1 %217, label %218, label %407
218: ; preds = %212
%219 = load i32, i32* %9
%220 = load i32, i32* %6
%221 = add nsw i32 %219, %220
store i32 %221, i32* %10
%222 = load i32, i32* %10
%223 = load i32, i32* %6
%224 = add nsw i32 %222, %223
store i32 %224, i32* %11
%225 = load i32, i32* %11
%226 = load i32, i32* %6
%227 = add nsw i32 %225, %226
store i32 %227, i32* %12
%228 = load double*, double** %7
%229 = load i32, i32* %9
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %228, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %7
%234 = load i32, i32* %10
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = fadd double %232, %237
store double %238, double* %24
%239 = load double*, double** %7
%240 = load i32, i32* %9
%241 = add nsw i32 %240, 1
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %239, i64 %242
%244 = load double, double* %243
%245 = load double*, double** %7
%246 = load i32, i32* %10
%247 = add nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %245, i64 %248
%250 = load double, double* %249
%251 = fadd double %244, %250
store double %251, double* %25
%252 = load double*, double** %7
%253 = load i32, i32* %9
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %252, i64 %254
%256 = load double, double* %255
%257 = load double*, double** %7
%258 = load i32, i32* %10
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
%262 = fsub double %256, %261
store double %262, double* %26
%263 = load double*, double** %7
%264 = load i32, i32* %9
%265 = add nsw i32 %264, 1
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %263, i64 %266
%268 = load double, double* %267
%269 = load double*, double** %7
%270 = load i32, i32* %10
%271 = add nsw i32 %270, 1
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %269, i64 %272
%274 = load double, double* %273
%275 = fsub double %268, %274
store double %275, double* %27
%276 = load double*, double** %7
%277 = load i32, i32* %11
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds double, double* %276, i64 %278
%280 = load double, double* %279
%281 = load double*, double** %7
%282 = load i32, i32* %12
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = fadd double %280, %285
store double %286, double* %28
%287 = load double*, double** %7
%288 = load i32, i32* %11
%289 = add nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %287, i64 %290
%292 = load double, double* %291
%293 = load double*, double** %7
%294 = load i32, i32* %12
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %293, i64 %296
%298 = load double, double* %297
%299 = fadd double %292, %298
store double %299, double* %29
%300 = load double*, double** %7
%301 = load i32, i32* %11
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %300, i64 %302
%304 = load double, double* %303
%305 = load double*, double** %7
%306 = load i32, i32* %12
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
%310 = fsub double %304, %309
store double %310, double* %30
%311 = load double*, double** %7
%312 = load i32, i32* %11
%313 = add nsw i32 %312, 1
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds double, double* %311, i64 %314
%316 = load double, double* %315
%317 = load double*, double** %7
%318 = load i32, i32* %12
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %317, i64 %320
%322 = load double, double* %321
%323 = fsub double %316, %322
store double %323, double* %31
%324 = load double, double* %24
%325 = load double, double* %28
%326 = fadd double %324, %325
%327 = load double*, double** %7
%328 = load i32, i32* %9
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %327, i64 %329
store double %326, double* %330
%331 = load double, double* %25
%332 = load double, double* %29
%333 = fadd double %331, %332
%334 = load double*, double** %7
%335 = load i32, i32* %9
%336 = add nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %334, i64 %337
store double %333, double* %338
%339 = load double, double* %29
%340 = load double, double* %25
%341 = fsub double %339, %340
%342 = load double*, double** %7
%343 = load i32, i32* %11
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %342, i64 %344
store double %341, double* %345
%346 = load double, double* %24
%347 = load double, double* %28
%348 = fsub double %346, %347
%349 = load double*, double** %7
%350 = load i32, i32* %11
%351 = add nsw i32 %350, 1
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %349, i64 %352
store double %348, double* %353
%354 = load double, double* %26
%355 = load double, double* %31
%356 = fsub double %354, %355
store double %356, double* %24
%357 = load double, double* %27
%358 = load double, double* %30
%359 = fadd double %357, %358
store double %359, double* %25
%360 = load double, double* %18
%361 = load double, double* %24
%362 = load double, double* %25
%363 = fsub double %361, %362
%364 = fmul double %360, %363
%365 = load double*, double** %7
%366 = load i32, i32* %10
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %365, i64 %367
store double %364, double* %368
%369 = load double, double* %18
%370 = load double, double* %24
%371 = load double, double* %25
%372 = fadd double %370, %371
%373 = fmul double %369, %372
%374 = load double*, double** %7
%375 = load i32, i32* %10
%376 = add nsw i32 %375, 1
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double, double* %374, i64 %377
store double %373, double* %378
%379 = load double, double* %31
%380 = load double, double* %26
%381 = fadd double %379, %380
store double %381, double* %24
%382 = load double, double* %30
%383 = load double, double* %27
%384 = fsub double %382, %383
store double %384, double* %25
%385 = load double, double* %18
%386 = load double, double* %25
%387 = load double, double* %24
%388 = fsub double %386, %387
%389 = fmul double %385, %388
%390 = load double*, double** %7
%391 = load i32, i32* %12
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %390, i64 %392
store double %389, double* %393
%394 = load double, double* %18
%395 = load double, double* %25
%396 = load double, double* %24
%397 = fadd double %395, %396
%398 = fmul double %394, %397
%399 = load double*, double** %7
%400 = load i32, i32* %12
%401 = add nsw i32 %400, 1
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %399, i64 %402
store double %398, double* %403
br label %404
404: ; preds = %218
%405 = load i32, i32* %9
%406 = add nsw i32 %405, 2
store i32 %406, i32* %9
br label %212
407: ; preds = %212
store i32 0, i32* %14
%408 = load i32, i32* %16
%409 = mul nsw i32 2, %408
store i32 %409, i32* %17
%410 = load i32, i32* %17
store i32 %410, i32* %13
br label %411
411: ; preds = %916, %407
%412 = load i32, i32* %13
%413 = load i32, i32* %5
%414 = icmp slt i32 %412, %413
br i1 %414, label %415, label %920
415: ; preds = %411
%416 = load i32, i32* %14
%417 = add nsw i32 %416, 2
store i32 %417, i32* %14
%418 = load i32, i32* %14
%419 = mul nsw i32 2, %418
store i32 %419, i32* %15
%420 = load double*, double** %8
%421 = load i32, i32* %14
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %420, i64 %422
%424 = load double, double* %423
store double %424, double* %20
%425 = load double*, double** %8
%426 = load i32, i32* %14
%427 = add nsw i32 %426, 1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %425, i64 %428
%430 = load double, double* %429
store double %430, double* %21
%431 = load double*, double** %8
%432 = load i32, i32* %15
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
store double %435, double* %18
%436 = load double*, double** %8
%437 = load i32, i32* %15
%438 = add nsw i32 %437, 1
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %436, i64 %439
%441 = load double, double* %440
store double %441, double* %19
%442 = load double, double* %18
%443 = load double, double* %21
%444 = fmul double 2.000000e+00, %443
%445 = load double, double* %19
%446 = fneg double %444
%447 = call double @llvm.fmuladd.f64(double %446, double %445, double %442)
store double %447, double* %22
%448 = load double, double* %21
%449 = fmul double 2.000000e+00, %448
%450 = load double, double* %18
%451 = load double, double* %19
%452 = fneg double %451
%453 = call double @llvm.fmuladd.f64(double %449, double %450, double %452)
store double %453, double* %23
%454 = load i32, i32* %13
store i32 %454, i32* %9
br label %455
455: ; preds = %666, %415
%456 = load i32, i32* %9
%457 = load i32, i32* %6
%458 = load i32, i32* %13
%459 = add nsw i32 %457, %458
%460 = icmp slt i32 %456, %459
br i1 %460, label %461, label %669
461: ; preds = %455
%462 = load i32, i32* %9
%463 = load i32, i32* %6
%464 = add nsw i32 %462, %463
store i32 %464, i32* %10
%465 = load i32, i32* %10
%466 = load i32, i32* %6
%467 = add nsw i32 %465, %466
store i32 %467, i32* %11
%468 = load i32, i32* %11
%469 = load i32, i32* %6
%470 = add nsw i32 %468, %469
store i32 %470, i32* %12
%471 = load double*, double** %7
%472 = load i32, i32* %9
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %471, i64 %473
%475 = load double, double* %474
%476 = load double*, double** %7
%477 = load i32, i32* %10
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
%480 = load double, double* %479
%481 = fadd double %475, %480
store double %481, double* %24
%482 = load double*, double** %7
%483 = load i32, i32* %9
%484 = add nsw i32 %483, 1
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds double, double* %482, i64 %485
%487 = load double, double* %486
%488 = load double*, double** %7
%489 = load i32, i32* %10
%490 = add nsw i32 %489, 1
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %488, i64 %491
%493 = load double, double* %492
%494 = fadd double %487, %493
store double %494, double* %25
%495 = load double*, double** %7
%496 = load i32, i32* %9
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %495, i64 %497
%499 = load double, double* %498
%500 = load double*, double** %7
%501 = load i32, i32* %10
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double, double* %500, i64 %502
%504 = load double, double* %503
%505 = fsub double %499, %504
store double %505, double* %26
%506 = load double*, double** %7
%507 = load i32, i32* %9
%508 = add nsw i32 %507, 1
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds double, double* %506, i64 %509
%511 = load double, double* %510
%512 = load double*, double** %7
%513 = load i32, i32* %10
%514 = add nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %512, i64 %515
%517 = load double, double* %516
%518 = fsub double %511, %517
store double %518, double* %27
%519 = load double*, double** %7
%520 = load i32, i32* %11
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double*, double** %7
%525 = load i32, i32* %12
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double, double* %524, i64 %526
%528 = load double, double* %527
%529 = fadd double %523, %528
store double %529, double* %28
%530 = load double*, double** %7
%531 = load i32, i32* %11
%532 = add nsw i32 %531, 1
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %530, i64 %533
%535 = load double, double* %534
%536 = load double*, double** %7
%537 = load i32, i32* %12
%538 = add nsw i32 %537, 1
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %536, i64 %539
%541 = load double, double* %540
%542 = fadd double %535, %541
store double %542, double* %29
%543 = load double*, double** %7
%544 = load i32, i32* %11
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %543, i64 %545
%547 = load double, double* %546
%548 = load double*, double** %7
%549 = load i32, i32* %12
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds double, double* %548, i64 %550
%552 = load double, double* %551
%553 = fsub double %547, %552
store double %553, double* %30
%554 = load double*, double** %7
%555 = load i32, i32* %11
%556 = add nsw i32 %555, 1
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double, double* %554, i64 %557
%559 = load double, double* %558
%560 = load double*, double** %7
%561 = load i32, i32* %12
%562 = add nsw i32 %561, 1
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %560, i64 %563
%565 = load double, double* %564
%566 = fsub double %559, %565
store double %566, double* %31
%567 = load double, double* %24
%568 = load double, double* %28
%569 = fadd double %567, %568
%570 = load double*, double** %7
%571 = load i32, i32* %9
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds double, double* %570, i64 %572
store double %569, double* %573
%574 = load double, double* %25
%575 = load double, double* %29
%576 = fadd double %574, %575
%577 = load double*, double** %7
%578 = load i32, i32* %9
%579 = add nsw i32 %578, 1
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds double, double* %577, i64 %580
store double %576, double* %581
%582 = load double, double* %28
%583 = load double, double* %24
%584 = fsub double %583, %582
store double %584, double* %24
%585 = load double, double* %29
%586 = load double, double* %25
%587 = fsub double %586, %585
store double %587, double* %25
%588 = load double, double* %20
%589 = load double, double* %24
%590 = load double, double* %21
%591 = load double, double* %25
%592 = fmul double %590, %591
%593 = fneg double %592
%594 = call double @llvm.fmuladd.f64(double %588, double %589, double %593)
%595 = load double*, double** %7
%596 = load i32, i32* %11
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds double, double* %595, i64 %597
store double %594, double* %598
%599 = load double, double* %20
%600 = load double, double* %25
%601 = load double, double* %21
%602 = load double, double* %24
%603 = fmul double %601, %602
%604 = call double @llvm.fmuladd.f64(double %599, double %600, double %603)
%605 = load double*, double** %7
%606 = load i32, i32* %11
%607 = add nsw i32 %606, 1
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds double, double* %605, i64 %608
store double %604, double* %609
%610 = load double, double* %26
%611 = load double, double* %31
%612 = fsub double %610, %611
store double %612, double* %24
%613 = load double, double* %27
%614 = load double, double* %30
%615 = fadd double %613, %614
store double %615, double* %25
%616 = load double, double* %18
%617 = load double, double* %24
%618 = load double, double* %19
%619 = load double, double* %25
%620 = fmul double %618, %619
%621 = fneg double %620
%622 = call double @llvm.fmuladd.f64(double %616, double %617, double %621)
%623 = load double*, double** %7
%624 = load i32, i32* %10
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %623, i64 %625
store double %622, double* %626
%627 = load double, double* %18
%628 = load double, double* %25
%629 = load double, double* %19
%630 = load double, double* %24
%631 = fmul double %629, %630
%632 = call double @llvm.fmuladd.f64(double %627, double %628, double %631)
%633 = load double*, double** %7
%634 = load i32, i32* %10
%635 = add nsw i32 %634, 1
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds double, double* %633, i64 %636
store double %632, double* %637
%638 = load double, double* %26
%639 = load double, double* %31
%640 = fadd double %638, %639
store double %640, double* %24
%641 = load double, double* %27
%642 = load double, double* %30
%643 = fsub double %641, %642
store double %643, double* %25
%644 = load double, double* %22
%645 = load double, double* %24
%646 = load double, double* %23
%647 = load double, double* %25
%648 = fmul double %646, %647
%649 = fneg double %648
%650 = call double @llvm.fmuladd.f64(double %644, double %645, double %649)
%651 = load double*, double** %7
%652 = load i32, i32* %12
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds double, double* %651, i64 %653
store double %650, double* %654
%655 = load double, double* %22
%656 = load double, double* %25
%657 = load double, double* %23
%658 = load double, double* %24
%659 = fmul double %657, %658
%660 = call double @llvm.fmuladd.f64(double %655, double %656, double %659)
%661 = load double*, double** %7
%662 = load i32, i32* %12
%663 = add nsw i32 %662, 1
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds double, double* %661, i64 %664
store double %660, double* %665
br label %666
666: ; preds = %461
%667 = load i32, i32* %9
%668 = add nsw i32 %667, 2
store i32 %668, i32* %9
br label %455
669: ; preds = %455
%670 = load double*, double** %8
%671 = load i32, i32* %15
%672 = add nsw i32 %671, 2
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds double, double* %670, i64 %673
%675 = load double, double* %674
store double %675, double* %18
%676 = load double*, double** %8
%677 = load i32, i32* %15
%678 = add nsw i32 %677, 3
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %676, i64 %679
%681 = load double, double* %680
store double %681, double* %19
%682 = load double, double* %18
%683 = load double, double* %20
%684 = fmul double 2.000000e+00, %683
%685 = load double, double* %19
%686 = fneg double %684
%687 = call double @llvm.fmuladd.f64(double %686, double %685, double %682)
store double %687, double* %22
%688 = load double, double* %20
%689 = fmul double 2.000000e+00, %688
%690 = load double, double* %18
%691 = load double, double* %19
%692 = fneg double %691
%693 = call double @llvm.fmuladd.f64(double %689, double %690, double %692)
store double %693, double* %23
%694 = load i32, i32* %13
%695 = load i32, i32* %16
%696 = add nsw i32 %694, %695
store i32 %696, i32* %9
br label %697
697: ; preds = %912, %669
%698 = load i32, i32* %9
%699 = load i32, i32* %6
%700 = load i32, i32* %13
%701 = load i32, i32* %16
%702 = add nsw i32 %700, %701
%703 = add nsw i32 %699, %702
%704 = icmp slt i32 %698, %703
br i1 %704, label %705, label %915
705: ; preds = %697
%706 = load i32, i32* %9
%707 = load i32, i32* %6
%708 = add nsw i32 %706, %707
store i32 %708, i32* %10
%709 = load i32, i32* %10
%710 = load i32, i32* %6
%711 = add nsw i32 %709, %710
store i32 %711, i32* %11
%712 = load i32, i32* %11
%713 = load i32, i32* %6
%714 = add nsw i32 %712, %713
store i32 %714, i32* %12
%715 = load double*, double** %7
%716 = load i32, i32* %9
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %715, i64 %717
%719 = load double, double* %718
%720 = load double*, double** %7
%721 = load i32, i32* %10
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %720, i64 %722
%724 = load double, double* %723
%725 = fadd double %719, %724
store double %725, double* %24
%726 = load double*, double** %7
%727 = load i32, i32* %9
%728 = add nsw i32 %727, 1
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds double, double* %726, i64 %729
%731 = load double, double* %730
%732 = load double*, double** %7
%733 = load i32, i32* %10
%734 = add nsw i32 %733, 1
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %732, i64 %735
%737 = load double, double* %736
%738 = fadd double %731, %737
store double %738, double* %25
%739 = load double*, double** %7
%740 = load i32, i32* %9
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds double, double* %739, i64 %741
%743 = load double, double* %742
%744 = load double*, double** %7
%745 = load i32, i32* %10
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double, double* %744, i64 %746
%748 = load double, double* %747
%749 = fsub double %743, %748
store double %749, double* %26
%750 = load double*, double** %7
%751 = load i32, i32* %9
%752 = add nsw i32 %751, 1
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds double, double* %750, i64 %753
%755 = load double, double* %754
%756 = load double*, double** %7
%757 = load i32, i32* %10
%758 = add nsw i32 %757, 1
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %756, i64 %759
%761 = load double, double* %760
%762 = fsub double %755, %761
store double %762, double* %27
%763 = load double*, double** %7
%764 = load i32, i32* %11
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds double, double* %763, i64 %765
%767 = load double, double* %766
%768 = load double*, double** %7
%769 = load i32, i32* %12
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %768, i64 %770
%772 = load double, double* %771
%773 = fadd double %767, %772
store double %773, double* %28
%774 = load double*, double** %7
%775 = load i32, i32* %11
%776 = add nsw i32 %775, 1
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds double, double* %774, i64 %777
%779 = load double, double* %778
%780 = load double*, double** %7
%781 = load i32, i32* %12
%782 = add nsw i32 %781, 1
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds double, double* %780, i64 %783
%785 = load double, double* %784
%786 = fadd double %779, %785
store double %786, double* %29
%787 = load double*, double** %7
%788 = load i32, i32* %11
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds double, double* %787, i64 %789
%791 = load double, double* %790
%792 = load double*, double** %7
%793 = load i32, i32* %12
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %792, i64 %794
%796 = load double, double* %795
%797 = fsub double %791, %796
store double %797, double* %30
%798 = load double*, double** %7
%799 = load i32, i32* %11
%800 = add nsw i32 %799, 1
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds double, double* %798, i64 %801
%803 = load double, double* %802
%804 = load double*, double** %7
%805 = load i32, i32* %12
%806 = add nsw i32 %805, 1
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %804, i64 %807
%809 = load double, double* %808
%810 = fsub double %803, %809
store double %810, double* %31
%811 = load double, double* %24
%812 = load double, double* %28
%813 = fadd double %811, %812
%814 = load double*, double** %7
%815 = load i32, i32* %9
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds double, double* %814, i64 %816
store double %813, double* %817
%818 = load double, double* %25
%819 = load double, double* %29
%820 = fadd double %818, %819
%821 = load double*, double** %7
%822 = load i32, i32* %9
%823 = add nsw i32 %822, 1
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds double, double* %821, i64 %824
store double %820, double* %825
%826 = load double, double* %28
%827 = load double, double* %24
%828 = fsub double %827, %826
store double %828, double* %24
%829 = load double, double* %29
%830 = load double, double* %25
%831 = fsub double %830, %829
store double %831, double* %25
%832 = load double, double* %21
%833 = fneg double %832
%834 = load double, double* %24
%835 = load double, double* %20
%836 = load double, double* %25
%837 = fmul double %835, %836
%838 = fneg double %837
%839 = call double @llvm.fmuladd.f64(double %833, double %834, double %838)
%840 = load double*, double** %7
%841 = load i32, i32* %11
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds double, double* %840, i64 %842
store double %839, double* %843
%844 = load double, double* %21
%845 = fneg double %844
%846 = load double, double* %25
%847 = load double, double* %20
%848 = load double, double* %24
%849 = fmul double %847, %848
%850 = call double @llvm.fmuladd.f64(double %845, double %846, double %849)
%851 = load double*, double** %7
%852 = load i32, i32* %11
%853 = add nsw i32 %852, 1
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds double, double* %851, i64 %854
store double %850, double* %855
%856 = load double, double* %26
%857 = load double, double* %31
%858 = fsub double %856, %857
store double %858, double* %24
%859 = load double, double* %27
%860 = load double, double* %30
%861 = fadd double %859, %860
store double %861, double* %25
%862 = load double, double* %18
%863 = load double, double* %24
%864 = load double, double* %19
%865 = load double, double* %25
%866 = fmul double %864, %865
%867 = fneg double %866
%868 = call double @llvm.fmuladd.f64(double %862, double %863, double %867)
%869 = load double*, double** %7
%870 = load i32, i32* %10
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %869, i64 %871
store double %868, double* %872
%873 = load double, double* %18
%874 = load double, double* %25
%875 = load double, double* %19
%876 = load double, double* %24
%877 = fmul double %875, %876
%878 = call double @llvm.fmuladd.f64(double %873, double %874, double %877)
%879 = load double*, double** %7
%880 = load i32, i32* %10
%881 = add nsw i32 %880, 1
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds double, double* %879, i64 %882
store double %878, double* %883
%884 = load double, double* %26
%885 = load double, double* %31
%886 = fadd double %884, %885
store double %886, double* %24
%887 = load double, double* %27
%888 = load double, double* %30
%889 = fsub double %887, %888
store double %889, double* %25
%890 = load double, double* %22
%891 = load double, double* %24
%892 = load double, double* %23
%893 = load double, double* %25
%894 = fmul double %892, %893
%895 = fneg double %894
%896 = call double @llvm.fmuladd.f64(double %890, double %891, double %895)
%897 = load double*, double** %7
%898 = load i32, i32* %12
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %897, i64 %899
store double %896, double* %900
%901 = load double, double* %22
%902 = load double, double* %25
%903 = load double, double* %23
%904 = load double, double* %24
%905 = fmul double %903, %904
%906 = call double @llvm.fmuladd.f64(double %901, double %902, double %905)
%907 = load double*, double** %7
%908 = load i32, i32* %12
%909 = add nsw i32 %908, 1
%910 = sext i32 %909 to i64
%911 = getelementptr inbounds double, double* %907, i64 %910
store double %906, double* %911
br label %912
912: ; preds = %705
%913 = load i32, i32* %9
%914 = add nsw i32 %913, 2
store i32 %914, i32* %9
br label %697
915: ; preds = %697
br label %916
916: ; preds = %915
%917 = load i32, i32* %17
%918 = load i32, i32* %13
%919 = add nsw i32 %918, %917
store i32 %919, i32* %13
br label %411
920: ; preds = %411
ret void
}

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