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