void cftmdl2(int n, double *a, double *w) {
  int j, j0, j1, j2, j3, k, kr, m, mh;
  double wn4r, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i;
  mh = n >> 3;
  m = 2 * mh;
  wn4r = w[1];
  j1 = m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[0] - a[j2 + 1];
  x0i = a[1] + a[j2];
  x1r = a[0] + a[j2 + 1];
  x1i = a[1] - a[j2];
  x2r = a[j1] - a[j3 + 1];
  x2i = a[j1 + 1] + a[j3];
  x3r = a[j1] + a[j3 + 1];
  x3i = a[j1 + 1] - a[j3];
  y0r = wn4r * (x2r - x2i);
  y0i = wn4r * (x2i + x2r);
  a[0] = x0r + y0r;
  a[1] = x0i + y0i;
  a[j1] = x0r - y0r;
  a[j1 + 1] = x0i - y0i;
  y0r = wn4r * (x3r - x3i);
  y0i = wn4r * (x3i + x3r);
  a[j2] = x1r - y0i;
  a[j2 + 1] = x1i + y0r;
  a[j3] = x1r + y0i;
  a[j3 + 1] = x1i - y0r;
  k = 0;
  kr = 2 * m;
  for (j = 2; j < mh; j += 2) {
    k += 4;
    wk1r = w[k];
    wk1i = w[k + 1];
    wk3r = w[k + 2];
    wk3i = -w[k + 3];
    kr -= 4;
    wd1i = w[kr];
    wd1r = w[kr + 1];
    wd3i = w[kr + 2];
    wd3r = -w[kr + 3];
    j1 = j + m;
    j2 = j1 + m;
    j3 = j2 + m;
    x0r = a[j] - a[j2 + 1];
    x0i = a[j + 1] + a[j2];
    x1r = a[j] + a[j2 + 1];
    x1i = a[j + 1] - a[j2];
    x2r = a[j1] - a[j3 + 1];
    x2i = a[j1 + 1] + a[j3];
    x3r = a[j1] + a[j3 + 1];
    x3i = a[j1 + 1] - a[j3];
    y0r = wk1r * x0r - wk1i * x0i;
    y0i = wk1r * x0i + wk1i * x0r;
    y2r = wd1r * x2r - wd1i * x2i;
    y2i = wd1r * x2i + wd1i * x2r;
    a[j] = y0r + y2r;
    a[j + 1] = y0i + y2i;
    a[j1] = y0r - y2r;
    a[j1 + 1] = y0i - y2i;
    y0r = wk3r * x1r + wk3i * x1i;
    y0i = wk3r * x1i - wk3i * x1r;
    y2r = wd3r * x3r + wd3i * x3i;
    y2i = wd3r * x3i - wd3i * x3r;
    a[j2] = y0r + y2r;
    a[j2 + 1] = y0i + y2i;
    a[j3] = y0r - y2r;
    a[j3 + 1] = y0i - y2i;
    j0 = m - j;
    j1 = j0 + m;
    j2 = j1 + m;
    j3 = j2 + m;
    x0r = a[j0] - a[j2 + 1];
    x0i = a[j0 + 1] + a[j2];
    x1r = a[j0] + a[j2 + 1];
    x1i = a[j0 + 1] - a[j2];
    x2r = a[j1] - a[j3 + 1];
    x2i = a[j1 + 1] + a[j3];
    x3r = a[j1] + a[j3 + 1];
    x3i = a[j1 + 1] - a[j3];
    y0r = wd1i * x0r - wd1r * x0i;
    y0i = wd1i * x0i + wd1r * x0r;
    y2r = wk1i * x2r - wk1r * x2i;
    y2i = wk1i * x2i + wk1r * x2r;
    a[j0] = y0r + y2r;
    a[j0 + 1] = y0i + y2i;
    a[j1] = y0r - y2r;
    a[j1 + 1] = y0i - y2i;
    y0r = wd3i * x1r + wd3r * x1i;
    y0i = wd3i * x1i - wd3r * x1r;
    y2r = wk3i * x3r + wk3r * x3i;
    y2i = wk3i * x3i - wk3r * x3r;
    a[j2] = y0r + y2r;
    a[j2 + 1] = y0i + y2i;
    a[j3] = y0r - y2r;
    a[j3 + 1] = y0i - y2i;
  }
  wk1r = w[m];
  wk1i = w[m + 1];
  j0 = mh;
  j1 = j0 + m;
  j2 = j1 + m;
  j3 = j2 + m;
  x0r = a[j0] - a[j2 + 1];
  x0i = a[j0 + 1] + a[j2];
  x1r = a[j0] + a[j2 + 1];
  x1i = a[j0 + 1] - a[j2];
  x2r = a[j1] - a[j3 + 1];
  x2i = a[j1 + 1] + a[j3];
  x3r = a[j1] + a[j3 + 1];
  x3i = a[j1 + 1] - a[j3];
  y0r = wk1r * x0r - wk1i * x0i;
  y0i = wk1r * x0i + wk1i * x0r;
  y2r = wk1i * x2r - wk1r * x2i;
  y2i = wk1i * x2i + wk1r * x2r;
  a[j0] = y0r + y2r;
  a[j0 + 1] = y0i + y2i;
  a[j1] = y0r - y2r;
  a[j1 + 1] = y0i - y2i;
  y0r = wk1i * x1r - wk1r * x1i;
  y0i = wk1i * x1i + wk1r * x1r;
  y2r = wk1r * x3r - wk1i * x3i;
  y2i = wk1r * x3i + wk1i * x3r;
  a[j2] = y0r - y2r;
  a[j2 + 1] = y0i - y2i;
  a[j3] = y0r + y2r;
  a[j3 + 1] = y0i + y2i;
}


x86 assembly (clang, -O0):
<cftmdl2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x68,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%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
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
subsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
addsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
subsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
addsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x2,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1d06 <cftmdl2+0xc06>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%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,-0x90(%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
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%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
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x20(%rbp),%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
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%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
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%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    13f0 <cftmdl2+0x2f0>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%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,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x20(%rbp),%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
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%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
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%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
movslq -0x2c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%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
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xe0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xe0(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xe8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
add    $0x68,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,%eax
sar    $0x3,%eax
lea    (%rax,%rax,1),%ebp
mov    %rdx,-0x68(%rsp)
movsd  0x8(%rdx),%xmm8
lea    0x0(,%rax,4),%edx
lea    0x0(%rbp,%rbp,2),%ebx
lea    0x1(,%rax,4),%ecx
movslq %ecx,%r8
movsd  (%rsi,%r8,8),%xmm5
movsd  (%rsi),%xmm9
movsd  0x8(%rsi),%xmm0
movapd %xmm9,%xmm3
subsd  %xmm5,%xmm3
movslq %edx,%rdx
movsd  (%rsi,%rdx,8),%xmm6
movapd %xmm0,%xmm4
addsd  %xmm6,%xmm4
addsd  %xmm5,%xmm9
subsd  %xmm6,%xmm0
movslq %ebp,%rcx
movsd  (%rsi,%rcx,8),%xmm1
movslq %ebx,%rbp
or     $0x1,%ebx
movslq %ebx,%r9
movsd  (%rsi,%r9,8),%xmm10
movapd %xmm1,%xmm6
subsd  %xmm10,%xmm6
lea    0x1(%rax,%rax,1),%ebx
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm7
movsd  (%rsi,%rbp,8),%xmm2
movapd %xmm7,%xmm5
addsd  %xmm2,%xmm5
addsd  %xmm10,%xmm1
subsd  %xmm2,%xmm7
movapd %xmm6,%xmm2
subsd  %xmm5,%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm6,%xmm5
mulsd  %xmm8,%xmm5
movapd %xmm3,%xmm6
addsd  %xmm2,%xmm6
movsd  %xmm6,(%rsi)
movapd %xmm4,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,0x8(%rsi)
subsd  %xmm2,%xmm3
mov    %rcx,-0x70(%rsp)
movsd  %xmm3,(%rsi,%rcx,8)
subsd  %xmm5,%xmm4
mov    %rbx,-0x40(%rsp)
movsd  %xmm4,(%rsi,%rbx,8)
movapd %xmm1,%xmm2
subsd  %xmm7,%xmm2
mulsd  %xmm8,%xmm2
addsd  %xmm1,%xmm7
mulsd  %xmm8,%xmm7
movapd %xmm9,%xmm1
subsd  %xmm7,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
movapd %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%r8,8)
addsd  %xmm9,%xmm7
movsd  %xmm7,(%rsi,%rbp,8)
subsd  %xmm2,%xmm0
movsd  %xmm0,(%rsi,%r9,8)
movslq %eax,%r9
cmp    $0x18,%edi
jl     16a3 <cftmdl2+0x5a3>
mov    %rdx,%r15
movabs $0xfffffffe00000000,%r8
ff ff ff
lea    -0x1(%rdx),%rdi
mov    -0x68(%rsp),%rax
lea    (%rax,%rdx,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x60(%rsp)
lea    0x38(%rax),%r10
mov    -0x70(%rsp),%r11
lea    (%r11,%r11,2),%eax
movslq %eax,%rbp
lea    0x3(%rbp),%rax
add    $0x3,%r15
add    $0xffffffffffffffff,%rbp
lea    -0x2(%r11),%rdx
mov    %r11,%rbx
shl    $0x4,%rbx
lea    -0x10(%rbx),%rcx
mov    %r9,-0x38(%rsp)
lea    0x0(,%r11,8),%r9
lea    (%r9,%r9,2),%r12
add    $0xfffffffffffffff0,%r12
mov    %r11,%r14
shl    $0x22,%r14
add    %r8,%r14
mov    %r14,-0x50(%rsp)
mov    %r11,%r8
shl    $0x5,%r8
add    $0xfffffffffffffff0,%r8
mov    %r8,-0x58(%rsp)
lea    0x2(%r11),%r8
add    $0x10,%rbx
lea    (%r9,%r9,2),%r14
add    $0x10,%r14
mov    $0x2,%r11d
mov    -0x38(%rsp),%r13
mov    %r14,-0x28(%rsp)
mov    %r8,-0x20(%rsp)
movsd  -0x8(%r10),%xmm0
movsd  %xmm0,-0x48(%rsp)
movsd  (%r10),%xmm12
mov    %r10,%r9
mov    -0x60(%rsp),%r10
movsd  -0x8(%r10),%xmm11
movsd  (%r10),%xmm0
movaps %xmm0,-0x18(%rsp)
movsd  (%rsi,%r15,8),%xmm1
movupd (%rsi,%r11,8),%xmm2
movsd  (%rsi,%rbx,1),%xmm13
movapd %xmm2,%xmm0
addsd  %xmm1,%xmm0
unpcklpd %xmm13,%xmm1
movapd %xmm2,%xmm5
subpd  %xmm1,%xmm5
addpd  %xmm2,%xmm1
movsd  (%rsi,%rax,8),%xmm6
movupd (%rsi,%r8,8),%xmm3
unpckhpd %xmm2,%xmm2
movsd  (%rsi,%r14,1),%xmm7
movapd %xmm3,%xmm15
addsd  %xmm6,%xmm15
unpcklpd %xmm7,%xmm6
movapd %xmm3,%xmm4
subsd  %xmm13,%xmm2
subpd  %xmm6,%xmm4
addpd  %xmm3,%xmm6
unpckhpd %xmm3,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm1,%xmm8
mov    %r9,-0x30(%rsp)
movsd  -0x18(%r9),%xmm13
movsd  -0x10(%r9),%xmm10
movapd %xmm10,%xmm14
movapd 0xc62(%rip),%xmm9
xorpd  %xmm9,%xmm14
movsd  %xmm5,%xmm8
shufpd $0x1,%xmm10,%xmm1
unpcklpd %xmm5,%xmm14
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
mulpd  %xmm1,%xmm14
movapd %xmm6,%xmm5
mulpd  %xmm8,%xmm7
addpd  %xmm14,%xmm7
movsd  -0x18(%r10),%xmm8
movapd %xmm8,%xmm1
movsd  %xmm4,%xmm5
xorpd  %xmm9,%xmm1
unpcklpd %xmm4,%xmm1
movsd  -0x10(%r10),%xmm14
shufpd $0x1,%xmm8,%xmm6
mulpd  %xmm6,%xmm1
movapd %xmm14,%xmm4
unpcklpd %xmm14,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm7,%xmm1
addpd  %xmm4,%xmm1
subpd  %xmm4,%xmm7
movsd  -0x48(%rsp),%xmm5
movapd %xmm5,%xmm4
mulsd  %xmm2,%xmm4
mulsd  %xmm12,%xmm2
mulsd  %xmm0,%xmm5
subsd  %xmm2,%xmm5
movapd -0x18(%rsp),%xmm6
movapd %xmm6,%xmm2
xorpd  %xmm9,%xmm2
movupd %xmm1,(%rsi,%r11,8)
mulsd  %xmm12,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm11,%xmm1
movapd %xmm6,%xmm4
mulsd  %xmm15,%xmm4
mulsd  %xmm3,%xmm1
subsd  %xmm4,%xmm1
mulsd  %xmm11,%xmm15
mulsd  %xmm2,%xmm3
movupd %xmm7,(%rsi,%r8,8)
subsd  %xmm15,%xmm3
movapd %xmm5,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm2,(%rsi,%rbx,1)
movsd  %xmm4,(%rsi,%r15,8)
subsd  %xmm1,%xmm5
subsd  %xmm3,%xmm0
movsd  %xmm5,(%rsi,%r14,1)
movsd  %xmm0,(%rsi,%rax,8)
movsd  (%rsi,%rbp,8),%xmm7
movupd (%rsi,%rdx,8),%xmm0
movsd  (%rsi,%r12,1),%xmm1
movapd %xmm0,%xmm15
addsd  %xmm7,%xmm15
unpcklpd %xmm1,%xmm7
movapd %xmm0,%xmm4
subpd  %xmm7,%xmm4
addpd  %xmm0,%xmm7
unpckhpd %xmm0,%xmm0
movsd  (%rsi,%rcx,1),%xmm9
mov    -0x50(%rsp),%r8
mov    %r8,%r9
sar    $0x1d,%r9
subsd  %xmm1,%xmm0
or     $0x8,%r9
movsd  (%rsi,%r9,1),%xmm6
movsd  (%rsi,%rdi,8),%xmm3
movapd %xmm9,%xmm1
unpcklpd %xmm3,%xmm1
addsd  %xmm6,%xmm9
mov    -0x58(%rsp),%r14
movsd  (%rsi,%r14,1),%xmm5
unpcklpd %xmm5,%xmm6
movapd %xmm1,%xmm2
subpd  %xmm6,%xmm2
addpd  %xmm1,%xmm6
subsd  %xmm5,%xmm3
movapd %xmm7,%xmm1
movsd  %xmm4,%xmm1
shufpd $0x1,%xmm14,%xmm7
movapd 0xac3(%rip),%xmm5
xorpd  %xmm5,%xmm14
unpcklpd %xmm4,%xmm14
mulpd  %xmm7,%xmm14
unpcklpd %xmm8,%xmm8
mulpd  %xmm1,%xmm8
addpd  %xmm14,%xmm8
movapd %xmm6,%xmm1
movsd  %xmm2,%xmm1
shufpd $0x1,%xmm13,%xmm6
xorpd  %xmm5,%xmm13
movapd %xmm5,%xmm4
unpcklpd %xmm2,%xmm13
mulpd  %xmm6,%xmm13
unpcklpd %xmm10,%xmm10
mulpd  %xmm1,%xmm10
addpd  %xmm13,%xmm10
movapd %xmm8,%xmm1
addpd  %xmm10,%xmm1
movupd %xmm1,(%rsi,%rdx,8)
subpd  %xmm10,%xmm8
movapd %xmm0,%xmm1
movapd -0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm11,%xmm0
mulsd  %xmm15,%xmm11
subsd  %xmm1,%xmm11
mulsd  %xmm2,%xmm15
addsd  %xmm15,%xmm0
movapd %xmm12,%xmm1
mulsd  %xmm9,%xmm12
movsd  -0x48(%rsp),%xmm2
mulsd  %xmm2,%xmm9
mulsd  %xmm3,%xmm2
subsd  %xmm12,%xmm2
xorpd  %xmm5,%xmm1
mulsd  %xmm1,%xmm3
subsd  %xmm9,%xmm3
movlpd %xmm8,(%rsi,%rcx,1)
movhpd %xmm8,(%rsi,%rdi,8)
movapd %xmm11,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%r12,1)
movapd %xmm0,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
subsd  %xmm2,%xmm11
movsd  %xmm11,(%rsi,%r14,1)
subsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%r9,1)
add    $0x2,%r11
add    $0xffffffffffffffe0,%r10
mov    %r10,-0x60(%rsp)
mov    -0x30(%rsp),%r10
add    $0x20,%r10
add    $0x2,%rax
add    $0x2,%r15
add    $0xfffffffffffffffe,%rdi
add    $0xfffffffffffffffe,%rbp
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffff0,%r12
mov    %r12,%r9
movabs $0xfffffffe00000000,%r12
ff ff ff
add    %r12,%r8
mov    %r8,-0x50(%rsp)
mov    -0x20(%rsp),%r8
mov    %r9,%r12
add    $0xfffffffffffffff0,%r14
mov    %r14,-0x58(%rsp)
mov    -0x28(%rsp),%r14
add    $0x2,%r8
add    $0x10,%rbx
add    $0x10,%r14
mov    %r13,%r9
cmp    %r13,%r11
jl     12e0 <cftmdl2+0x1e0>
mov    %r9,%rbx
lea    (%r9,%r9,2),%ecx
lea    (%r9,%r9,4),%eax
lea    0x0(,%r9,8),%edx
sub    %ebx,%edx
movupd (%rsi,%r9,8),%xmm1
cltq
movupd (%rsi,%rax,8),%xmm3
shufpd $0x1,%xmm3,%xmm3
movapd %xmm1,%xmm12
subpd  %xmm3,%xmm12
addpd  %xmm1,%xmm3
movapd %xmm12,%xmm8
movsd  %xmm3,%xmm8
movapd 0x916(%rip),%xmm4
mov    -0x68(%rsp),%rdi
mov    -0x40(%rsp),%rbp
movsd  (%rdi,%rbp,8),%xmm10
movapd %xmm10,%xmm0
xorpd  %xmm4,%xmm0
movapd %xmm3,%xmm9
mov    -0x70(%rsp),%rbp
movsd  (%rdi,%rbp,8),%xmm11
xorpd  %xmm11,%xmm4
movapd %xmm4,%xmm1
unpcklpd %xmm3,%xmm4
movsd  %xmm12,%xmm3
movslq %ecx,%rcx
movupd (%rsi,%rcx,8),%xmm7
movslq %edx,%rdx
movupd (%rsi,%rdx,8),%xmm5
shufpd $0x1,%xmm5,%xmm5
movapd %xmm7,%xmm6
subpd  %xmm5,%xmm6
addpd  %xmm7,%xmm5
movapd %xmm6,%xmm13
movsd  %xmm5,%xmm13
movapd %xmm0,%xmm2
movapd %xmm5,%xmm7
unpcklpd %xmm5,%xmm0
movsd  %xmm6,%xmm5
shufpd $0x1,%xmm10,%xmm9
unpcklpd %xmm12,%xmm2
mulpd  %xmm9,%xmm2
shufpd $0x1,%xmm11,%xmm7
shufpd $0x1,%xmm11,%xmm12
unpcklpd %xmm11,%xmm11
mulpd  %xmm11,%xmm3
addpd  %xmm2,%xmm3
unpcklpd %xmm6,%xmm1
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm10,%xmm6
unpcklpd %xmm10,%xmm10
mulpd  %xmm10,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm3,%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,(%rsi,%r9,8)
subpd  %xmm5,%xmm3
movupd %xmm3,(%rsi,%rcx,8)
mulpd  %xmm12,%xmm4
mulpd  %xmm8,%xmm10
addpd  %xmm4,%xmm10
mulpd  %xmm6,%xmm0
mulpd  %xmm13,%xmm11
addpd  %xmm0,%xmm11
movapd %xmm10,%xmm0
subpd  %xmm11,%xmm0
movupd %xmm0,(%rsi,%rax,8)
addpd  %xmm10,%xmm11
movupd %xmm11,(%rsi,%rdx,8)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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