void cftmdl(int n, int l, double *a, double *w) {
  int j, j1, j2, j3, j4, j5, j6, j7, k, k1, m;
  double wn4r, wtmp, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, wk4r, wk4i, wk5r, wk5i,
      wk6r, wk6i, wk7r, wk7i;
  double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i,
      y3r, y3i, y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i;
  m = l << 3;
  wn4r = w[2];
  for (j = 0; j < l; j += 2) {
    j1 = j + l;
    j2 = j1 + l;
    j3 = j2 + l;
    j4 = j3 + l;
    j5 = j4 + l;
    j6 = j5 + l;
    j7 = j6 + l;
    x0r = a[j] + a[j1];
    x0i = a[j + 1] + a[j1 + 1];
    x1r = a[j] - a[j1];
    x1i = a[j + 1] - a[j1 + 1];
    x2r = a[j2] + a[j3];
    x2i = a[j2 + 1] + a[j3 + 1];
    x3r = a[j2] - a[j3];
    x3i = a[j2 + 1] - a[j3 + 1];
    y0r = x0r + x2r;
    y0i = x0i + x2i;
    y2r = x0r - x2r;
    y2i = x0i - x2i;
    y1r = x1r - x3i;
    y1i = x1i + x3r;
    y3r = x1r + x3i;
    y3i = x1i - x3r;
    x0r = a[j4] + a[j5];
    x0i = a[j4 + 1] + a[j5 + 1];
    x1r = a[j4] - a[j5];
    x1i = a[j4 + 1] - a[j5 + 1];
    x2r = a[j6] + a[j7];
    x2i = a[j6 + 1] + a[j7 + 1];
    x3r = a[j6] - a[j7];
    x3i = a[j6 + 1] - a[j7 + 1];
    y4r = x0r + x2r;
    y4i = x0i + x2i;
    y6r = x0r - x2r;
    y6i = x0i - x2i;
    x0r = x1r - x3i;
    x0i = x1i + x3r;
    x2r = x1r + x3i;
    x2i = x1i - x3r;
    y5r = wn4r * (x0r - x0i);
    y5i = wn4r * (x0r + x0i);
    y7r = wn4r * (x2r - x2i);
    y7i = wn4r * (x2r + x2i);
    a[j1] = y1r + y5r;
    a[j1 + 1] = y1i + y5i;
    a[j5] = y1r - y5r;
    a[j5 + 1] = y1i - y5i;
    a[j3] = y3r - y7i;
    a[j3 + 1] = y3i + y7r;
    a[j7] = y3r + y7i;
    a[j7 + 1] = y3i - y7r;
    a[j] = y0r + y4r;
    a[j + 1] = y0i + y4i;
    a[j4] = y0r - y4r;
    a[j4 + 1] = y0i - y4i;
    a[j2] = y2r - y6i;
    a[j2 + 1] = y2i + y6r;
    a[j6] = y2r + y6i;
    a[j6 + 1] = y2i - y6r;
  }
  if (m < n) {
    wk1r = w[4];
    wk1i = w[5];
    for (j = m; j < l + m; j += 2) {
      j1 = j + l;
      j2 = j1 + l;
      j3 = j2 + l;
      j4 = j3 + l;
      j5 = j4 + l;
      j6 = j5 + l;
      j7 = j6 + l;
      x0r = a[j] + a[j1];
      x0i = a[j + 1] + a[j1 + 1];
      x1r = a[j] - a[j1];
      x1i = a[j + 1] - a[j1 + 1];
      x2r = a[j2] + a[j3];
      x2i = a[j2 + 1] + a[j3 + 1];
      x3r = a[j2] - a[j3];
      x3i = a[j2 + 1] - a[j3 + 1];
      y0r = x0r + x2r;
      y0i = x0i + x2i;
      y2r = x0r - x2r;
      y2i = x0i - x2i;
      y1r = x1r - x3i;
      y1i = x1i + x3r;
      y3r = x1r + x3i;
      y3i = x1i - x3r;
      x0r = a[j4] + a[j5];
      x0i = a[j4 + 1] + a[j5 + 1];
      x1r = a[j4] - a[j5];
      x1i = a[j4 + 1] - a[j5 + 1];
      x2r = a[j6] + a[j7];
      x2i = a[j6 + 1] + a[j7 + 1];
      x3r = a[j6] - a[j7];
      x3i = a[j6 + 1] - a[j7 + 1];
      y4r = x0r + x2r;
      y4i = x0i + x2i;
      y6r = x0r - x2r;
      y6i = x0i - x2i;
      x0r = x1r - x3i;
      x0i = x1i + x3r;
      x2r = x1r + x3i;
      x2i = x3r - x1i;
      y5r = wk1i * x0r - wk1r * x0i;
      y5i = wk1i * x0i + wk1r * x0r;
      y7r = wk1r * x2r + wk1i * x2i;
      y7i = wk1r * x2i - wk1i * x2r;
      x0r = wk1r * y1r - wk1i * y1i;
      x0i = wk1r * y1i + wk1i * y1r;
      a[j1] = x0r + y5r;
      a[j1 + 1] = x0i + y5i;
      a[j5] = y5i - x0i;
      a[j5 + 1] = x0r - y5r;
      x0r = wk1i * y3r - wk1r * y3i;
      x0i = wk1i * y3i + wk1r * y3r;
      a[j3] = x0r - y7r;
      a[j3 + 1] = x0i + y7i;
      a[j7] = y7i - x0i;
      a[j7 + 1] = x0r + y7r;
      a[j] = y0r + y4r;
      a[j + 1] = y0i + y4i;
      a[j4] = y4i - y0i;
      a[j4 + 1] = y0r - y4r;
      x0r = y2r - y6i;
      x0i = y2i + y6r;
      a[j2] = wn4r * (x0r - x0i);
      a[j2 + 1] = wn4r * (x0i + x0r);
      x0r = y6r - y2i;
      x0i = y2r + y6i;
      a[j6] = wn4r * (x0r - x0i);
      a[j6 + 1] = wn4r * (x0i + x0r);
    }
    k1 = 4;
    for (k = 2 * m; k < n; k += m) {
      k1 += 4;
      wk1r = w[k1];
      wk1i = w[k1 + 1];
      wk2r = w[k1 + 2];
      wk2i = w[k1 + 3];
      wtmp = 2 * wk2i;
      wk3r = wk1r - wtmp * wk1i;
      wk3i = wtmp * wk1r - wk1i;
      wk4r = 1 - wtmp * wk2i;
      wk4i = wtmp * wk2r;
      wtmp = 2 * wk4i;
      wk5r = wk3r - wtmp * wk1i;
      wk5i = wtmp * wk1r - wk3i;
      wk6r = wk2r - wtmp * wk2i;
      wk6i = wtmp * wk2r - wk2i;
      wk7r = wk1r - wtmp * wk3i;
      wk7i = wtmp * wk3r - wk1i;
      for (j = k; j < l + k; j += 2) {
        j1 = j + l;
        j2 = j1 + l;
        j3 = j2 + l;
        j4 = j3 + l;
        j5 = j4 + l;
        j6 = j5 + l;
        j7 = j6 + l;
        x0r = a[j] + a[j1];
        x0i = a[j + 1] + a[j1 + 1];
        x1r = a[j] - a[j1];
        x1i = a[j + 1] - a[j1 + 1];
        x2r = a[j2] + a[j3];
        x2i = a[j2 + 1] + a[j3 + 1];
        x3r = a[j2] - a[j3];
        x3i = a[j2 + 1] - a[j3 + 1];
        y0r = x0r + x2r;
        y0i = x0i + x2i;
        y2r = x0r - x2r;
        y2i = x0i - x2i;
        y1r = x1r - x3i;
        y1i = x1i + x3r;
        y3r = x1r + x3i;
        y3i = x1i - x3r;
        x0r = a[j4] + a[j5];
        x0i = a[j4 + 1] + a[j5 + 1];
        x1r = a[j4] - a[j5];
        x1i = a[j4 + 1] - a[j5 + 1];
        x2r = a[j6] + a[j7];
        x2i = a[j6 + 1] + a[j7 + 1];
        x3r = a[j6] - a[j7];
        x3i = a[j6 + 1] - a[j7 + 1];
        y4r = x0r + x2r;
        y4i = x0i + x2i;
        y6r = x0r - x2r;
        y6i = x0i - x2i;
        x0r = x1r - x3i;
        x0i = x1i + x3r;
        x2r = x1r + x3i;
        x2i = x1i - x3r;
        y5r = wn4r * (x0r - x0i);
        y5i = wn4r * (x0r + x0i);
        y7r = wn4r * (x2r - x2i);
        y7i = wn4r * (x2r + x2i);
        x0r = y1r + y5r;
        x0i = y1i + y5i;
        a[j1] = wk1r * x0r - wk1i * x0i;
        a[j1 + 1] = wk1r * x0i + wk1i * x0r;
        x0r = y1r - y5r;
        x0i = y1i - y5i;
        a[j5] = wk5r * x0r - wk5i * x0i;
        a[j5 + 1] = wk5r * x0i + wk5i * x0r;
        x0r = y3r - y7i;
        x0i = y3i + y7r;
        a[j3] = wk3r * x0r - wk3i * x0i;
        a[j3 + 1] = wk3r * x0i + wk3i * x0r;
        x0r = y3r + y7i;
        x0i = y3i - y7r;
        a[j7] = wk7r * x0r - wk7i * x0i;
        a[j7 + 1] = wk7r * x0i + wk7i * x0r;
        a[j] = y0r + y4r;
        a[j + 1] = y0i + y4i;
        x0r = y0r - y4r;
        x0i = y0i - y4i;
        a[j4] = wk4r * x0r - wk4i * x0i;
        a[j4 + 1] = wk4r * x0i + wk4i * x0r;
        x0r = y2r - y6i;
        x0i = y2i + y6r;
        a[j2] = wk2r * x0r - wk2i * x0i;
        a[j2 + 1] = wk2r * x0i + wk2i * x0r;
        x0r = y2r + y6i;
        x0i = y2i - y6r;
        a[j6] = wk6r * x0r - wk6i * x0i;
        a[j6 + 1] = wk6r * x0i + wk6i * x0r;
      }
    }
  }
}


x86 assembly (clang, -O0):
<cftmdl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x108,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17fc <cftmdl+0x6fc>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
addsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
addsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x160(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x128(%rbp),%xmm0
ff
addsd  -0x168(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
subsd  -0x160(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x128(%rbp),%xmm0
ff
subsd  -0x168(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
subsd  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x148(%rbp),%xmm0
ff
addsd  -0x180(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x180(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x150(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
addsd  -0x158(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
subsd  -0x150(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
subsd  -0x158(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x178(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x178(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x170(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%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    1137 <cftmdl+0x37>
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2d4c <cftmdl+0x1c4c>
mov    -0x18(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jge    20a0 <cftmdl+0xfa0>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xf8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x128(%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  -0x60(%rbp),%xmm0
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0x160(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x168(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x168(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0x160(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x148(%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  -0x68(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0x180(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x188(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x188(%rbp),%xmm0
ff
subsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0x180(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x150(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
addsd  -0x158(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x158(%rbp),%xmm0
ff
subsd  -0x118(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
subsd  -0x150(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
addsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x170(%rbp),%xmm0
ff
subsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm1
ff
addsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%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    182a <cftmdl+0x72a>
movl   $0x4,-0x40(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2d47 <cftmdl+0x1c47>
mov    -0x40(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xedc(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe44(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xe16(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x80(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    2d34 <cftmdl+0x1c34>
mov    -0x1c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
subsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
addsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xf0(%rbp),%xmm1
ff
addsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
addsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
subsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
subsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
subsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
addsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x150(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
addsd  -0x158(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x110(%rbp),%xmm0
ff
subsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
subsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
subsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x130(%rbp),%xmm0
ff
addsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%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    2347 <cftmdl+0x1247>
jmp    2d39 <cftmdl+0x1c39>
mov    -0x44(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    20b0 <cftmdl+0xfb0>
jmp    2d4c <cftmdl+0x1c4c>
add    $0x108,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
lea    0x0(,%rsi,8),%r8d
mov    %rcx,-0x58(%rsp)
movsd  0x10(%rcx),%xmm14
mov    %rsi,-0x80(%rsp)
test   %esi,%esi
movapd %xmm14,-0x70(%rsp)
jle    1318 <cftmdl+0x218>
mov    -0x80(%rsp),%r9d
movapd %xmm14,%xmm8
unpcklpd %xmm14,%xmm8
lea    (%rdx,%r9,8),%r10
mov    %r9,%r11
shl    $0x4,%r11
add    %rdx,%r11
lea    (%r9,%r9,2),%r15
lea    (%rdx,%r15,8),%rbx
mov    %r9,%rbp
shl    $0x5,%rbp
add    %rdx,%rbp
lea    (%r9,%r9,4),%rax
lea    (%rdx,%rax,8),%r14
shl    $0x4,%r15
add    %rdx,%r15
imul   $0x38,%r9,%rsi
add    %rdx,%rsi
xor    %eax,%eax
nop
movupd (%rdx,%rax,8),%xmm0
movupd (%r10,%rax,8),%xmm1
movapd %xmm0,%xmm11
addpd  %xmm1,%xmm11
subpd  %xmm1,%xmm0
movupd (%r11,%rax,8),%xmm4
movupd (%rbx,%rax,8),%xmm1
movapd %xmm4,%xmm2
addpd  %xmm1,%xmm2
subpd  %xmm1,%xmm4
shufpd $0x1,%xmm4,%xmm4
movapd %xmm11,%xmm10
addpd  %xmm2,%xmm10
subpd  %xmm2,%xmm11
movapd %xmm0,%xmm15
subpd  %xmm4,%xmm15
addpd  %xmm0,%xmm4
movupd 0x0(%rbp,%rax,8),%xmm0
movupd (%r14,%rax,8),%xmm1
movapd %xmm0,%xmm5
addpd  %xmm1,%xmm5
subpd  %xmm1,%xmm0
movupd (%r15,%rax,8),%xmm14
movupd (%rsi,%rax,8),%xmm9
movapd %xmm14,%xmm12
subpd  %xmm9,%xmm14
movapd %xmm14,%xmm6
unpckhpd %xmm14,%xmm6
movapd %xmm0,%xmm13
subsd  %xmm6,%xmm13
addsd  %xmm0,%xmm6
unpckhpd %xmm0,%xmm0
movapd %xmm0,%xmm1
subsd  %xmm14,%xmm0
movapd %xmm6,%xmm7
subsd  %xmm0,%xmm7
addsd  %xmm6,%xmm0
mulsd  -0x70(%rsp),%xmm0
movapd %xmm4,%xmm6
subsd  %xmm0,%xmm6
addsd  %xmm4,%xmm0
movsd  %xmm15,%xmm4
unpckhpd %xmm15,%xmm15
addpd  %xmm9,%xmm12
movapd %xmm5,%xmm2
addpd  %xmm12,%xmm2
subpd  %xmm12,%xmm5
shufpd $0x1,%xmm5,%xmm5
addsd  %xmm14,%xmm1
movapd -0x70(%rsp),%xmm14
movapd %xmm13,%xmm3
subsd  %xmm1,%xmm3
addsd  %xmm13,%xmm1
unpcklpd %xmm1,%xmm3
mulpd  %xmm8,%xmm3
mulsd  %xmm14,%xmm7
movapd %xmm4,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%r10,%rax,8)
subpd  %xmm3,%xmm4
movupd %xmm4,(%r14,%rax,8)
movsd  %xmm6,(%rbx,%rax,8)
movapd %xmm15,%xmm1
addsd  %xmm7,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  %xmm0,(%rsi,%rax,8)
subsd  %xmm7,%xmm15
movsd  %xmm15,0x8(%rsi,%rax,8)
movapd %xmm10,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%rdx,%rax,8)
subpd  %xmm2,%xmm10
movupd %xmm10,0x0(%rbp,%rax,8)
movapd %xmm11,%xmm0
subpd  %xmm5,%xmm0
addpd  %xmm11,%xmm5
movapd %xmm5,%xmm1
movsd  %xmm0,%xmm1
movupd %xmm1,(%r11,%rax,8)
shufpd $0x2,%xmm0,%xmm5
movupd %xmm5,(%r15,%rax,8)
add    $0x2,%rax
cmp    %r9,%rax
jb     1180 <cftmdl+0x80>
cmp    %edi,%r8d
jge    1b6a <cftmdl+0xa6a>
mov    -0x80(%rsp),%rcx
lea    (%rcx,%rcx,8),%eax
movslq %r8d,%rsi
mov    %rsi,-0x50(%rsp)
movslq %ecx,%rcx
mov    %rcx,-0x78(%rsp)
cmp    %eax,%r8d
jge    1657 <cftmdl+0x557>
mov    -0x58(%rsp),%rcx
movupd 0x20(%rcx),%xmm13
movapd %xmm13,%xmm12
unpckhpd %xmm13,%xmm12
unpcklpd %xmm13,%xmm12
movapd 0xc9c(%rip),%xmm0
xorpd  %xmm12,%xmm0
movslq %eax,%r8
movapd %xmm13,%xmm1
shufpd $0x1,%xmm13,%xmm1
movapd %xmm1,-0x20(%rsp)
movapd %xmm13,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm1,-0x30(%rsp)
movapd %xmm13,%xmm1
movapd %xmm0,-0x10(%rsp)
unpckhpd %xmm0,%xmm1
movapd %xmm1,-0x40(%rsp)
mov    -0x78(%rsp),%rcx
lea    (%rdx,%rcx,8),%r10
mov    %rcx,%rax
shl    $0x4,%rax
lea    (%rax,%rdx,1),%rbp
add    $0x8,%rbp
lea    (%rcx,%rcx,2),%rax
lea    (%rdx,%rax,8),%r11
mov    %rcx,%r15
shl    $0x5,%r15
add    %rdx,%r15
lea    (%rcx,%rcx,4),%rsi
lea    (%rdx,%rsi,8),%r14
shl    $0x4,%rax
lea    (%rax,%rdx,1),%rbx
add    $0x8,%rbx
imul   $0x38,%rcx,%rsi
add    %rdx,%rsi
mov    -0x50(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm7
movsd  0x8(%r15,%rax,8),%xmm2
movsd  (%rdx,%rax,8),%xmm5
movsd  0x8(%rdx,%rax,8),%xmm15
movapd %xmm2,%xmm4
unpcklpd %xmm5,%xmm4
movsd  (%r14,%rax,8),%xmm3
movsd  0x8(%r14,%rax,8),%xmm8
movsd  (%r10,%rax,8),%xmm0
movsd  0x8(%r10,%rax,8),%xmm10
movapd %xmm8,%xmm1
unpcklpd %xmm0,%xmm1
addpd  %xmm4,%xmm1
movsd  -0x8(%rbx,%rax,8),%xmm6
movsd  (%rsi,%rax,8),%xmm9
movapd %xmm15,%xmm4
unpcklpd %xmm7,%xmm4
movapd %xmm10,%xmm14
unpcklpd %xmm3,%xmm14
addpd  %xmm4,%xmm14
movsd  0x0(%rbp,%rax,8),%xmm4
unpcklpd %xmm4,%xmm2
unpcklpd %xmm6,%xmm4
movsd  0x8(%r11,%rax,8),%xmm11
unpcklpd %xmm11,%xmm8
unpcklpd %xmm9,%xmm11
addpd  %xmm4,%xmm11
subpd  %xmm8,%xmm2
unpcklpd %xmm5,%xmm6
unpcklpd %xmm0,%xmm9
movsd  (%rbx,%rax,8),%xmm5
movhpd -0x8(%rbp,%rax,8),%xmm5
subpd  %xmm9,%xmm6
movsd  0x8(%rsi,%rax,8),%xmm4
movhpd (%r11,%rax,8),%xmm4
unpcklpd %xmm15,%xmm7
movapd %xmm5,%xmm0
addpd  %xmm4,%xmm0
unpcklpd %xmm10,%xmm3
movapd %xmm1,%xmm8
subpd  %xmm0,%xmm8
subpd  %xmm3,%xmm7
movapd %xmm14,%xmm9
subpd  %xmm11,%xmm9
subpd  %xmm4,%xmm5
addpd  %xmm14,%xmm11
movapd -0x70(%rsp),%xmm14
addpd  %xmm1,%xmm0
movapd %xmm7,%xmm1
subpd  %xmm5,%xmm1
addpd  %xmm7,%xmm5
movapd %xmm5,%xmm4
movsd  %xmm1,%xmm4
mulpd  -0x30(%rsp),%xmm4
movapd %xmm6,%xmm7
addpd  %xmm2,%xmm7
subpd  %xmm2,%xmm6
movapd %xmm6,%xmm2
movsd  %xmm7,%xmm2
mulpd  -0x20(%rsp),%xmm2
addpd  %xmm4,%xmm2
movapd %xmm6,%xmm4
shufpd $0x1,%xmm7,%xmm4
mulpd  -0x40(%rsp),%xmm4
movapd %xmm5,%xmm3
shufpd $0x1,%xmm1,%xmm3
mulpd  %xmm13,%xmm3
addpd  %xmm4,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm2,%xmm4
shufpd $0x1,%xmm4,%xmm4
movupd %xmm4,(%r10,%rax,8)
subpd  %xmm3,%xmm2
movapd %xmm1,%xmm3
movsd  %xmm5,%xmm3
movupd %xmm2,(%r14,%rax,8)
movapd %xmm7,%xmm2
movsd  %xmm6,%xmm2
mulpd  -0x10(%rsp),%xmm3
mulpd  %xmm13,%xmm2
addpd  %xmm3,%xmm2
shufpd $0x1,%xmm6,%xmm7
shufpd $0x1,%xmm5,%xmm1
mulpd  %xmm13,%xmm7
mulpd  %xmm12,%xmm1
addpd  %xmm7,%xmm1
movapd %xmm2,%xmm3
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm1
movapd %xmm3,%xmm2
shufpd $0x1,%xmm1,%xmm2
movupd %xmm2,(%r11,%rax,8)
movapd %xmm8,%xmm2
unpckhpd %xmm8,%xmm2
movsd  %xmm3,%xmm1
movapd %xmm9,%xmm5
unpckhpd %xmm9,%xmm5
movupd %xmm1,(%rsi,%rax,8)
movapd %xmm11,%xmm1
addpd  %xmm0,%xmm1
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rdx,%rax,8)
subpd  %xmm11,%xmm0
movupd %xmm0,(%r15,%rax,8)
movapd %xmm2,%xmm0
subsd  %xmm8,%xmm0
movapd %xmm9,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm0,%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm14,%xmm3
movsd  %xmm3,-0x8(%rbp,%rax,8)
addsd  %xmm0,%xmm1
mulsd  %xmm14,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
subsd  %xmm9,%xmm5
addsd  %xmm8,%xmm2
movapd %xmm5,%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm14,%xmm0
movsd  %xmm0,-0x8(%rbx,%rax,8)
addsd  %xmm5,%xmm2
mulsd  %xmm14,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
add    $0x2,%rax
cmp    %r8,%rax
jl     13f0 <cftmdl+0x2f0>
mov    -0x80(%rsp),%rax
shl    $0x4,%eax
cmp    %edi,%eax
jge    1b6a <cftmdl+0xa6a>
movslq %eax,%r11
movslq %edi,%rax
mov    %rax,0x8(%rsp)
unpcklpd %xmm14,%xmm14
lea    (%rdx,%r11,8),%r14
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r11,1),%rax
lea    (%rdx,%rax,8),%r15
lea    (%r11,%rcx,2),%rax
lea    (%rdx,%rax,8),%r12
lea    (%rcx,%rcx,2),%rsi
lea    (%rsi,%r11,1),%rax
lea    (%rdx,%rax,8),%r13
lea    (%r11,%rcx,4),%rax
lea    (%rdx,%rax,8),%rax
lea    (%rcx,%rcx,4),%rdi
add    %r11,%rdi
lea    (%rdx,%rdi,8),%rbx
lea    (%r11,%rsi,2),%rsi
lea    (%rdx,%rsi,8),%rdi
lea    0x0(,%rcx,8),%rsi
sub    %rcx,%rsi
add    %r11,%rsi
lea    (%rdx,%rsi,8),%rdx
mov    $0x4,%ebp
xor    %ecx,%ecx
mov    %rcx,-0x48(%rsp)
mov    %r11,%r10
jmp    16fc <cftmdl+0x5fc>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rbp
mov    -0x50(%rsp),%rcx
add    %rcx,%r10
add    %rcx,-0x48(%rsp)
cmp    0x8(%rsp),%r10
jge    1b6a <cftmdl+0xa6a>
cmpl   $0x0,-0x80(%rsp)
jle    16e0 <cftmdl+0x5e0>
mov    -0x78(%rsp),%rcx
lea    (%r10,%rcx,1),%rsi
mov    -0x58(%rsp),%rcx
movsd  0x20(%rcx,%rbp,8),%xmm15
movsd  0x28(%rcx,%rbp,8),%xmm13
movsd  0x30(%rcx,%rbp,8),%xmm11
movsd  0x38(%rcx,%rbp,8),%xmm10
movapd %xmm10,%xmm8
addsd  %xmm10,%xmm8
movapd %xmm8,%xmm4
movapd 0x8bb(%rip),%xmm9
xorpd  %xmm9,%xmm4
movapd %xmm8,%xmm0
mulsd  %xmm13,%xmm0
movapd %xmm15,%xmm5
subsd  %xmm0,%xmm5
movapd %xmm11,%xmm0
mulsd  %xmm8,%xmm0
mulsd  %xmm15,%xmm8
subsd  %xmm13,%xmm8
movapd %xmm0,%xmm7
addsd  %xmm0,%xmm7
movapd %xmm7,%xmm1
xorpd  %xmm9,%xmm1
movapd %xmm7,%xmm12
movapd %xmm7,%xmm3
mulsd  %xmm5,%xmm7
subsd  %xmm13,%xmm7
movapd %xmm1,%xmm2
mulsd  %xmm13,%xmm2
unpcklpd %xmm13,%xmm6
movapd %xmm6,0xa0(%rsp)
xorpd  %xmm9,%xmm13
movapd %xmm13,0x90(%rsp)
mulsd  %xmm15,%xmm12
subsd  %xmm8,%xmm12
movapd %xmm1,%xmm13
mulsd  %xmm8,%xmm13
unpcklpd %xmm8,%xmm6
movapd %xmm6,0x80(%rsp)
xorpd  %xmm9,%xmm8
movapd %xmm8,0x70(%rsp)
mulsd  %xmm11,%xmm3
subsd  %xmm10,%xmm3
mulsd  %xmm10,%xmm4
mulsd  %xmm10,%xmm1
unpcklpd %xmm10,%xmm6
movapd %xmm6,0x60(%rsp)
xorpd  %xmm9,%xmm10
movapd %xmm10,0x50(%rsp)
addsd  %xmm5,%xmm2
addsd  %xmm15,%xmm13
addsd  0x7ec(%rip),%xmm4
addsd  %xmm11,%xmm1
unpcklpd %xmm12,%xmm6
movapd %xmm6,0x40(%rsp)
xorpd  %xmm9,%xmm12
unpcklpd %xmm1,%xmm1
movapd %xmm1,0xd0(%rsp)
unpcklpd %xmm3,%xmm1
movapd %xmm1,0x30(%rsp)
xorpd  %xmm9,%xmm3
movapd %xmm3,0xc0(%rsp)
unpcklpd %xmm11,%xmm11
movapd %xmm11,-0x10(%rsp)
unpcklpd %xmm4,%xmm4
movapd %xmm4,-0x20(%rsp)
unpcklpd %xmm0,%xmm1
movapd %xmm1,0x20(%rsp)
xorpd  %xmm9,%xmm0
movapd %xmm0,-0x30(%rsp)
unpcklpd %xmm13,%xmm13
unpcklpd %xmm7,%xmm0
movapd %xmm0,0x10(%rsp)
xorpd  %xmm9,%xmm7
movapd %xmm7,0xb0(%rsp)
unpcklpd %xmm5,%xmm5
movapd %xmm5,-0x40(%rsp)
unpcklpd %xmm2,%xmm2
movapd %xmm2,%xmm10
unpcklpd %xmm15,%xmm15
movapd %xmm15,-0x70(%rsp)
mov    -0x48(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movupd (%r14,%r8,8),%xmm0
movupd (%r15,%r8,8),%xmm3
movapd %xmm0,%xmm2
addpd  %xmm3,%xmm2
subpd  %xmm3,%xmm0
movupd (%r12,%r8,8),%xmm7
movupd 0x0(%r13,%r8,8),%xmm3
movapd %xmm7,%xmm5
addpd  %xmm3,%xmm5
subpd  %xmm3,%xmm7
shufpd $0x1,%xmm7,%xmm7
movapd %xmm2,%xmm4
addpd  %xmm5,%xmm4
subpd  %xmm5,%xmm2
movapd %xmm0,%xmm5
subpd  %xmm7,%xmm5
addpd  %xmm0,%xmm7
movapd %xmm7,%xmm3
movsd  %xmm5,%xmm3
shufpd $0x2,%xmm5,%xmm7
movupd (%rax,%r8,8),%xmm5
movupd (%rbx,%r8,8),%xmm6
movapd %xmm5,%xmm0
addpd  %xmm6,%xmm0
subpd  %xmm6,%xmm5
movupd (%rdi,%r8,8),%xmm1
movupd (%rdx,%r8,8),%xmm9
movapd %xmm14,%xmm8
movapd %xmm1,%xmm14
subpd  %xmm9,%xmm1
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
movapd %xmm5,%xmm11
subsd  %xmm6,%xmm11
addsd  %xmm5,%xmm6
unpckhpd %xmm5,%xmm5
addpd  %xmm9,%xmm14
movapd %xmm0,%xmm15
addpd  %xmm14,%xmm15
subpd  %xmm14,%xmm0
movapd %xmm8,%xmm14
movapd %xmm5,%xmm9
addsd  %xmm1,%xmm9
subsd  %xmm1,%xmm5
movapd %xmm11,%xmm1
subsd  %xmm9,%xmm1
addsd  %xmm11,%xmm9
unpcklpd %xmm9,%xmm1
mulpd  %xmm8,%xmm1
movapd %xmm6,%xmm9
addsd  %xmm5,%xmm9
subsd  %xmm5,%xmm6
unpcklpd %xmm6,%xmm9
movapd %xmm3,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm5,%xmm11
unpckhpd 0xa0(%rsp),%xmm11
movapd 0x90(%rsp),%xmm6
unpcklpd %xmm5,%xmm6
mulpd  %xmm11,%xmm6
mulpd  -0x70(%rsp),%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm8,%xmm9
movupd %xmm5,(%r15,%r8,8)
subpd  %xmm1,%xmm3
movapd %xmm3,%xmm1
unpckhpd 0x40(%rsp),%xmm1
movapd %xmm12,%xmm5
unpcklpd %xmm3,%xmm5
mulpd  %xmm1,%xmm5
mulpd  %xmm10,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm3,(%rbx,%r8,8)
movapd %xmm7,%xmm1
subpd  %xmm9,%xmm1
addpd  %xmm7,%xmm9
movapd %xmm9,%xmm3
unpckhpd 0x80(%rsp),%xmm3
movapd 0x70(%rsp),%xmm5
unpcklpd %xmm1,%xmm5
mulpd  %xmm3,%xmm5
movapd %xmm1,%xmm3
movsd  %xmm9,%xmm3
movapd 0xb0(%rsp),%xmm6
unpcklpd %xmm9,%xmm6
movsd  %xmm1,%xmm9
mulpd  -0x40(%rsp),%xmm9
addpd  %xmm9,%xmm5
movupd %xmm5,0x0(%r13,%r8,8)
unpckhpd 0x10(%rsp),%xmm1
mulpd  %xmm1,%xmm6
mulpd  %xmm13,%xmm3
addpd  %xmm3,%xmm6
shufpd $0x1,%xmm0,%xmm0
movupd %xmm6,(%rdx,%r8,8)
movapd %xmm4,%xmm1
addpd  %xmm15,%xmm1
movupd %xmm1,(%r14,%r8,8)
subpd  %xmm15,%xmm4
movapd %xmm4,%xmm1
unpckhpd 0x20(%rsp),%xmm1
movapd -0x30(%rsp),%xmm3
unpcklpd %xmm4,%xmm3
mulpd  %xmm1,%xmm3
mulpd  -0x20(%rsp),%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%rax,%r8,8)
movapd %xmm2,%xmm1
subpd  %xmm0,%xmm1
addpd  %xmm2,%xmm0
movapd %xmm0,%xmm2
unpckhpd 0x60(%rsp),%xmm2
movapd 0x50(%rsp),%xmm3
unpcklpd %xmm1,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm1,%xmm2
movsd  %xmm0,%xmm2
movapd 0xc0(%rsp),%xmm4
unpcklpd %xmm0,%xmm4
movsd  %xmm1,%xmm0
mulpd  -0x10(%rsp),%xmm0
addpd  %xmm0,%xmm3
movupd %xmm3,(%r12,%r8,8)
unpckhpd 0x30(%rsp),%xmm1
mulpd  %xmm1,%xmm4
mulpd  0xd0(%rsp),%xmm2
addpd  %xmm2,%xmm4
movupd %xmm4,(%rdi,%r8,8)
lea    (%r11,%r8,1),%r9
add    $0x2,%r9
add    $0x2,%r8
cmp    %rsi,%r9
jl     18d0 <cftmdl+0x7d0>
jmp    16e0 <cftmdl+0x5e0>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cftmdl(i32 %0, i32 %1, double* %2, double* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca double*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%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
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
store i32 %0, i32* %5
store i32 %1, i32* %6
store double* %2, double** %7
store double* %3, double** %8
%60 = load i32, i32* %6
%61 = shl i32 %60, 3
store i32 %61, i32* %19
%62 = load double*, double** %8
%63 = getelementptr inbounds double, double* %62, i64 2
%64 = load double, double* %63
store double %64, double* %20
store i32 0, i32* %9
br label %65
65: ; preds = %471, %4
%66 = load i32, i32* %9
%67 = load i32, i32* %6
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %474
69: ; preds = %65
%70 = load i32, i32* %9
%71 = load i32, i32* %6
%72 = add nsw i32 %70, %71
store i32 %72, i32* %10
%73 = load i32, i32* %10
%74 = load i32, i32* %6
%75 = add nsw i32 %73, %74
store i32 %75, i32* %11
%76 = load i32, i32* %11
%77 = load i32, i32* %6
%78 = add nsw i32 %76, %77
store i32 %78, i32* %12
%79 = load i32, i32* %12
%80 = load i32, i32* %6
%81 = add nsw i32 %79, %80
store i32 %81, i32* %13
%82 = load i32, i32* %13
%83 = load i32, i32* %6
%84 = add nsw i32 %82, %83
store i32 %84, i32* %14
%85 = load i32, i32* %14
%86 = load i32, i32* %6
%87 = add nsw i32 %85, %86
store i32 %87, i32* %15
%88 = load i32, i32* %15
%89 = load i32, i32* %6
%90 = add nsw i32 %88, %89
store i32 %90, i32* %16
%91 = load double*, double** %7
%92 = load i32, i32* %9
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %91, i64 %93
%95 = load double, double* %94
%96 = load double*, double** %7
%97 = load i32, i32* %10
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %96, i64 %98
%100 = load double, double* %99
%101 = fadd double %95, %100
store double %101, double* %36
%102 = load double*, double** %7
%103 = load i32, i32* %9
%104 = add nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %102, i64 %105
%107 = load double, double* %106
%108 = load double*, double** %7
%109 = load i32, i32* %10
%110 = add nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %108, i64 %111
%113 = load double, double* %112
%114 = fadd double %107, %113
store double %114, double* %37
%115 = load double*, double** %7
%116 = load i32, i32* %9
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
%119 = load double, double* %118
%120 = load double*, double** %7
%121 = load i32, i32* %10
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
%124 = load double, double* %123
%125 = fsub double %119, %124
store double %125, double* %38
%126 = load double*, double** %7
%127 = load i32, i32* %9
%128 = add nsw i32 %127, 1
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %126, i64 %129
%131 = load double, double* %130
%132 = load double*, double** %7
%133 = load i32, i32* %10
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %132, i64 %135
%137 = load double, double* %136
%138 = fsub double %131, %137
store double %138, double* %39
%139 = load double*, double** %7
%140 = load i32, i32* %11
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
%143 = load double, double* %142
%144 = load double*, double** %7
%145 = load i32, i32* %12
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %144, i64 %146
%148 = load double, double* %147
%149 = fadd double %143, %148
store double %149, double* %40
%150 = load double*, double** %7
%151 = load i32, i32* %11
%152 = add nsw i32 %151, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %150, i64 %153
%155 = load double, double* %154
%156 = load double*, double** %7
%157 = load i32, i32* %12
%158 = add nsw i32 %157, 1
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %156, i64 %159
%161 = load double, double* %160
%162 = fadd double %155, %161
store double %162, double* %41
%163 = load double*, double** %7
%164 = load i32, i32* %11
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %163, i64 %165
%167 = load double, double* %166
%168 = load double*, double** %7
%169 = load i32, i32* %12
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = load double, double* %171
%173 = fsub double %167, %172
store double %173, double* %42
%174 = load double*, double** %7
%175 = load i32, i32* %11
%176 = add nsw i32 %175, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %174, i64 %177
%179 = load double, double* %178
%180 = load double*, double** %7
%181 = load i32, i32* %12
%182 = add nsw i32 %181, 1
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %180, i64 %183
%185 = load double, double* %184
%186 = fsub double %179, %185
store double %186, double* %43
%187 = load double, double* %36
%188 = load double, double* %40
%189 = fadd double %187, %188
store double %189, double* %44
%190 = load double, double* %37
%191 = load double, double* %41
%192 = fadd double %190, %191
store double %192, double* %45
%193 = load double, double* %36
%194 = load double, double* %40
%195 = fsub double %193, %194
store double %195, double* %48
%196 = load double, double* %37
%197 = load double, double* %41
%198 = fsub double %196, %197
store double %198, double* %49
%199 = load double, double* %38
%200 = load double, double* %43
%201 = fsub double %199, %200
store double %201, double* %46
%202 = load double, double* %39
%203 = load double, double* %42
%204 = fadd double %202, %203
store double %204, double* %47
%205 = load double, double* %38
%206 = load double, double* %43
%207 = fadd double %205, %206
store double %207, double* %50
%208 = load double, double* %39
%209 = load double, double* %42
%210 = fsub double %208, %209
store double %210, double* %51
%211 = load double*, double** %7
%212 = load i32, i32* %13
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = load double*, double** %7
%217 = load i32, i32* %14
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = fadd double %215, %220
store double %221, double* %36
%222 = load double*, double** %7
%223 = load i32, i32* %13
%224 = add nsw i32 %223, 1
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %222, i64 %225
%227 = load double, double* %226
%228 = load double*, double** %7
%229 = load i32, i32* %14
%230 = add nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %228, i64 %231
%233 = load double, double* %232
%234 = fadd double %227, %233
store double %234, double* %37
%235 = load double*, double** %7
%236 = load i32, i32* %13
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds double, double* %235, i64 %237
%239 = load double, double* %238
%240 = load double*, double** %7
%241 = load i32, i32* %14
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %240, i64 %242
%244 = load double, double* %243
%245 = fsub double %239, %244
store double %245, double* %38
%246 = load double*, double** %7
%247 = load i32, i32* %13
%248 = add nsw i32 %247, 1
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %246, i64 %249
%251 = load double, double* %250
%252 = load double*, double** %7
%253 = load i32, i32* %14
%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
%258 = fsub double %251, %257
store double %258, double* %39
%259 = load double*, double** %7
%260 = load i32, i32* %15
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %259, i64 %261
%263 = load double, double* %262
%264 = load double*, double** %7
%265 = load i32, i32* %16
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds double, double* %264, i64 %266
%268 = load double, double* %267
%269 = fadd double %263, %268
store double %269, double* %40
%270 = load double*, double** %7
%271 = load i32, i32* %15
%272 = add nsw i32 %271, 1
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double, double* %270, i64 %273
%275 = load double, double* %274
%276 = load double*, double** %7
%277 = load i32, i32* %16
%278 = add nsw i32 %277, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds double, double* %276, i64 %279
%281 = load double, double* %280
%282 = fadd double %275, %281
store double %282, double* %41
%283 = load double*, double** %7
%284 = load i32, i32* %15
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %283, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %7
%289 = load i32, i32* %16
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = fsub double %287, %292
store double %293, double* %42
%294 = load double*, double** %7
%295 = load i32, i32* %15
%296 = add nsw i32 %295, 1
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds double, double* %294, i64 %297
%299 = load double, double* %298
%300 = load double*, double** %7
%301 = load i32, i32* %16
%302 = add nsw i32 %301, 1
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %300, i64 %303
%305 = load double, double* %304
%306 = fsub double %299, %305
store double %306, double* %43
%307 = load double, double* %36
%308 = load double, double* %40
%309 = fadd double %307, %308
store double %309, double* %52
%310 = load double, double* %37
%311 = load double, double* %41
%312 = fadd double %310, %311
store double %312, double* %53
%313 = load double, double* %36
%314 = load double, double* %40
%315 = fsub double %313, %314
store double %315, double* %56
%316 = load double, double* %37
%317 = load double, double* %41
%318 = fsub double %316, %317
store double %318, double* %57
%319 = load double, double* %38
%320 = load double, double* %43
%321 = fsub double %319, %320
store double %321, double* %36
%322 = load double, double* %39
%323 = load double, double* %42
%324 = fadd double %322, %323
store double %324, double* %37
%325 = load double, double* %38
%326 = load double, double* %43
%327 = fadd double %325, %326
store double %327, double* %40
%328 = load double, double* %39
%329 = load double, double* %42
%330 = fsub double %328, %329
store double %330, double* %41
%331 = load double, double* %20
%332 = load double, double* %36
%333 = load double, double* %37
%334 = fsub double %332, %333
%335 = fmul double %331, %334
store double %335, double* %54
%336 = load double, double* %20
%337 = load double, double* %36
%338 = load double, double* %37
%339 = fadd double %337, %338
%340 = fmul double %336, %339
store double %340, double* %55
%341 = load double, double* %20
%342 = load double, double* %40
%343 = load double, double* %41
%344 = fsub double %342, %343
%345 = fmul double %341, %344
store double %345, double* %58
%346 = load double, double* %20
%347 = load double, double* %40
%348 = load double, double* %41
%349 = fadd double %347, %348
%350 = fmul double %346, %349
store double %350, double* %59
%351 = load double, double* %46
%352 = load double, double* %54
%353 = fadd double %351, %352
%354 = load double*, double** %7
%355 = load i32, i32* %10
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds double, double* %354, i64 %356
store double %353, double* %357
%358 = load double, double* %47
%359 = load double, double* %55
%360 = fadd double %358, %359
%361 = load double*, double** %7
%362 = load i32, i32* %10
%363 = add nsw i32 %362, 1
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %361, i64 %364
store double %360, double* %365
%366 = load double, double* %46
%367 = load double, double* %54
%368 = fsub double %366, %367
%369 = load double*, double** %7
%370 = load i32, i32* %14
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %369, i64 %371
store double %368, double* %372
%373 = load double, double* %47
%374 = load double, double* %55
%375 = fsub double %373, %374
%376 = load double*, double** %7
%377 = load i32, i32* %14
%378 = add nsw i32 %377, 1
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %376, i64 %379
store double %375, double* %380
%381 = load double, double* %50
%382 = load double, double* %59
%383 = fsub double %381, %382
%384 = load double*, double** %7
%385 = load i32, i32* %12
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
store double %383, double* %387
%388 = load double, double* %51
%389 = load double, double* %58
%390 = fadd double %388, %389
%391 = load double*, double** %7
%392 = load i32, i32* %12
%393 = add nsw i32 %392, 1
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %391, i64 %394
store double %390, double* %395
%396 = load double, double* %50
%397 = load double, double* %59
%398 = fadd double %396, %397
%399 = load double*, double** %7
%400 = load i32, i32* %16
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %399, i64 %401
store double %398, double* %402
%403 = load double, double* %51
%404 = load double, double* %58
%405 = fsub double %403, %404
%406 = load double*, double** %7
%407 = load i32, i32* %16
%408 = add nsw i32 %407, 1
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %406, i64 %409
store double %405, double* %410
%411 = load double, double* %44
%412 = load double, double* %52
%413 = fadd double %411, %412
%414 = load double*, double** %7
%415 = load i32, i32* %9
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %414, i64 %416
store double %413, double* %417
%418 = load double, double* %45
%419 = load double, double* %53
%420 = fadd double %418, %419
%421 = load double*, double** %7
%422 = load i32, i32* %9
%423 = add nsw i32 %422, 1
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds double, double* %421, i64 %424
store double %420, double* %425
%426 = load double, double* %44
%427 = load double, double* %52
%428 = fsub double %426, %427
%429 = load double*, double** %7
%430 = load i32, i32* %13
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %429, i64 %431
store double %428, double* %432
%433 = load double, double* %45
%434 = load double, double* %53
%435 = fsub double %433, %434
%436 = load double*, double** %7
%437 = load i32, i32* %13
%438 = add nsw i32 %437, 1
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %436, i64 %439
store double %435, double* %440
%441 = load double, double* %48
%442 = load double, double* %57
%443 = fsub double %441, %442
%444 = load double*, double** %7
%445 = load i32, i32* %11
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %444, i64 %446
store double %443, double* %447
%448 = load double, double* %49
%449 = load double, double* %56
%450 = fadd double %448, %449
%451 = load double*, double** %7
%452 = load i32, i32* %11
%453 = add nsw i32 %452, 1
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %451, i64 %454
store double %450, double* %455
%456 = load double, double* %48
%457 = load double, double* %57
%458 = fadd double %456, %457
%459 = load double*, double** %7
%460 = load i32, i32* %15
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %459, i64 %461
store double %458, double* %462
%463 = load double, double* %49
%464 = load double, double* %56
%465 = fsub double %463, %464
%466 = load double*, double** %7
%467 = load i32, i32* %15
%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
br label %471
471: ; preds = %69
%472 = load i32, i32* %9
%473 = add nsw i32 %472, 2
store i32 %473, i32* %9
br label %65
474: ; preds = %65
%475 = load i32, i32* %19
%476 = load i32, i32* %5
%477 = icmp slt i32 %475, %476
br i1 %477, label %478, label %1542
478: ; preds = %474
%479 = load double*, double** %8
%480 = getelementptr inbounds double, double* %479, i64 4
%481 = load double, double* %480
store double %481, double* %22
%482 = load double*, double** %8
%483 = getelementptr inbounds double, double* %482, i64 5
%484 = load double, double* %483
store double %484, double* %23
%485 = load i32, i32* %19
store i32 %485, i32* %9
br label %486
486: ; preds = %946, %478
%487 = load i32, i32* %9
%488 = load i32, i32* %6
%489 = load i32, i32* %19
%490 = add nsw i32 %488, %489
%491 = icmp slt i32 %487, %490
br i1 %491, label %492, label %949
492: ; preds = %486
%493 = load i32, i32* %9
%494 = load i32, i32* %6
%495 = add nsw i32 %493, %494
store i32 %495, i32* %10
%496 = load i32, i32* %10
%497 = load i32, i32* %6
%498 = add nsw i32 %496, %497
store i32 %498, i32* %11
%499 = load i32, i32* %11
%500 = load i32, i32* %6
%501 = add nsw i32 %499, %500
store i32 %501, i32* %12
%502 = load i32, i32* %12
%503 = load i32, i32* %6
%504 = add nsw i32 %502, %503
store i32 %504, i32* %13
%505 = load i32, i32* %13
%506 = load i32, i32* %6
%507 = add nsw i32 %505, %506
store i32 %507, i32* %14
%508 = load i32, i32* %14
%509 = load i32, i32* %6
%510 = add nsw i32 %508, %509
store i32 %510, i32* %15
%511 = load i32, i32* %15
%512 = load i32, i32* %6
%513 = add nsw i32 %511, %512
store i32 %513, i32* %16
%514 = load double*, double** %7
%515 = load i32, i32* %9
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds double, double* %514, i64 %516
%518 = load double, double* %517
%519 = load double*, double** %7
%520 = load i32, i32* %10
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = fadd double %518, %523
store double %524, double* %36
%525 = load double*, double** %7
%526 = load i32, i32* %9
%527 = add nsw i32 %526, 1
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %525, i64 %528
%530 = load double, double* %529
%531 = load double*, double** %7
%532 = load i32, i32* %10
%533 = add nsw i32 %532, 1
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %531, i64 %534
%536 = load double, double* %535
%537 = fadd double %530, %536
store double %537, double* %37
%538 = load double*, double** %7
%539 = load i32, i32* %9
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
%542 = load double, double* %541
%543 = load double*, double** %7
%544 = load i32, i32* %10
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %543, i64 %545
%547 = load double, double* %546
%548 = fsub double %542, %547
store double %548, double* %38
%549 = load double*, double** %7
%550 = load i32, i32* %9
%551 = add nsw i32 %550, 1
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds double, double* %549, i64 %552
%554 = load double, double* %553
%555 = load double*, double** %7
%556 = load i32, i32* %10
%557 = add nsw i32 %556, 1
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds double, double* %555, i64 %558
%560 = load double, double* %559
%561 = fsub double %554, %560
store double %561, double* %39
%562 = load double*, double** %7
%563 = load i32, i32* %11
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds double, double* %562, i64 %564
%566 = load double, double* %565
%567 = load double*, double** %7
%568 = load i32, i32* %12
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %567, i64 %569
%571 = load double, double* %570
%572 = fadd double %566, %571
store double %572, double* %40
%573 = load double*, double** %7
%574 = load i32, i32* %11
%575 = add nsw i32 %574, 1
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds double, double* %573, i64 %576
%578 = load double, double* %577
%579 = load double*, double** %7
%580 = load i32, i32* %12
%581 = add nsw i32 %580, 1
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %579, i64 %582
%584 = load double, double* %583
%585 = fadd double %578, %584
store double %585, double* %41
%586 = load double*, double** %7
%587 = load i32, i32* %11
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %586, i64 %588
%590 = load double, double* %589
%591 = load double*, double** %7
%592 = load i32, i32* %12
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %591, i64 %593
%595 = load double, double* %594
%596 = fsub double %590, %595
store double %596, double* %42
%597 = load double*, double** %7
%598 = load i32, i32* %11
%599 = add nsw i32 %598, 1
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds double, double* %597, i64 %600
%602 = load double, double* %601
%603 = load double*, double** %7
%604 = load i32, i32* %12
%605 = add nsw i32 %604, 1
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %603, i64 %606
%608 = load double, double* %607
%609 = fsub double %602, %608
store double %609, double* %43
%610 = load double, double* %36
%611 = load double, double* %40
%612 = fadd double %610, %611
store double %612, double* %44
%613 = load double, double* %37
%614 = load double, double* %41
%615 = fadd double %613, %614
store double %615, double* %45
%616 = load double, double* %36
%617 = load double, double* %40
%618 = fsub double %616, %617
store double %618, double* %48
%619 = load double, double* %37
%620 = load double, double* %41
%621 = fsub double %619, %620
store double %621, double* %49
%622 = load double, double* %38
%623 = load double, double* %43
%624 = fsub double %622, %623
store double %624, double* %46
%625 = load double, double* %39
%626 = load double, double* %42
%627 = fadd double %625, %626
store double %627, double* %47
%628 = load double, double* %38
%629 = load double, double* %43
%630 = fadd double %628, %629
store double %630, double* %50
%631 = load double, double* %39
%632 = load double, double* %42
%633 = fsub double %631, %632
store double %633, double* %51
%634 = load double*, double** %7
%635 = load i32, i32* %13
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds double, double* %634, i64 %636
%638 = load double, double* %637
%639 = load double*, double** %7
%640 = load i32, i32* %14
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds double, double* %639, i64 %641
%643 = load double, double* %642
%644 = fadd double %638, %643
store double %644, double* %36
%645 = load double*, double** %7
%646 = load i32, i32* %13
%647 = add nsw i32 %646, 1
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %645, i64 %648
%650 = load double, double* %649
%651 = load double*, double** %7
%652 = load i32, i32* %14
%653 = add nsw i32 %652, 1
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %651, i64 %654
%656 = load double, double* %655
%657 = fadd double %650, %656
store double %657, double* %37
%658 = load double*, double** %7
%659 = load i32, i32* %13
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %658, i64 %660
%662 = load double, double* %661
%663 = load double*, double** %7
%664 = load i32, i32* %14
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
%667 = load double, double* %666
%668 = fsub double %662, %667
store double %668, double* %38
%669 = load double*, double** %7
%670 = load i32, i32* %13
%671 = add nsw i32 %670, 1
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %669, i64 %672
%674 = load double, double* %673
%675 = load double*, double** %7
%676 = load i32, i32* %14
%677 = add nsw i32 %676, 1
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds double, double* %675, i64 %678
%680 = load double, double* %679
%681 = fsub double %674, %680
store double %681, double* %39
%682 = load double*, double** %7
%683 = load i32, i32* %15
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds double, double* %682, i64 %684
%686 = load double, double* %685
%687 = load double*, double** %7
%688 = load i32, i32* %16
%689 = sext i32 %688 to i64
%690 = getelementptr inbounds double, double* %687, i64 %689
%691 = load double, double* %690
%692 = fadd double %686, %691
store double %692, double* %40
%693 = load double*, double** %7
%694 = load i32, i32* %15
%695 = add nsw i32 %694, 1
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds double, double* %693, i64 %696
%698 = load double, double* %697
%699 = load double*, double** %7
%700 = load i32, i32* %16
%701 = add nsw i32 %700, 1
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds double, double* %699, i64 %702
%704 = load double, double* %703
%705 = fadd double %698, %704
store double %705, double* %41
%706 = load double*, double** %7
%707 = load i32, i32* %15
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %706, i64 %708
%710 = load double, double* %709
%711 = load double*, double** %7
%712 = load i32, i32* %16
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %711, i64 %713
%715 = load double, double* %714
%716 = fsub double %710, %715
store double %716, double* %42
%717 = load double*, double** %7
%718 = load i32, i32* %15
%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
%723 = load double*, double** %7
%724 = load i32, i32* %16
%725 = add nsw i32 %724, 1
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds double, double* %723, i64 %726
%728 = load double, double* %727
%729 = fsub double %722, %728
store double %729, double* %43
%730 = load double, double* %36
%731 = load double, double* %40
%732 = fadd double %730, %731
store double %732, double* %52
%733 = load double, double* %37
%734 = load double, double* %41
%735 = fadd double %733, %734
store double %735, double* %53
%736 = load double, double* %36
%737 = load double, double* %40
%738 = fsub double %736, %737
store double %738, double* %56
%739 = load double, double* %37
%740 = load double, double* %41
%741 = fsub double %739, %740
store double %741, double* %57
%742 = load double, double* %38
%743 = load double, double* %43
%744 = fsub double %742, %743
store double %744, double* %36
%745 = load double, double* %39
%746 = load double, double* %42
%747 = fadd double %745, %746
store double %747, double* %37
%748 = load double, double* %38
%749 = load double, double* %43
%750 = fadd double %748, %749
store double %750, double* %40
%751 = load double, double* %42
%752 = load double, double* %39
%753 = fsub double %751, %752
store double %753, double* %41
%754 = load double, double* %23
%755 = load double, double* %36
%756 = load double, double* %22
%757 = load double, double* %37
%758 = fmul double %756, %757
%759 = fneg double %758
%760 = call double @llvm.fmuladd.f64(double %754, double %755, double %759)
store double %760, double* %54
%761 = load double, double* %23
%762 = load double, double* %37
%763 = load double, double* %22
%764 = load double, double* %36
%765 = fmul double %763, %764
%766 = call double @llvm.fmuladd.f64(double %761, double %762, double %765)
store double %766, double* %55
%767 = load double, double* %22
%768 = load double, double* %40
%769 = load double, double* %23
%770 = load double, double* %41
%771 = fmul double %769, %770
%772 = call double @llvm.fmuladd.f64(double %767, double %768, double %771)
store double %772, double* %58
%773 = load double, double* %22
%774 = load double, double* %41
%775 = load double, double* %23
%776 = load double, double* %40
%777 = fmul double %775, %776
%778 = fneg double %777
%779 = call double @llvm.fmuladd.f64(double %773, double %774, double %778)
store double %779, double* %59
%780 = load double, double* %22
%781 = load double, double* %46
%782 = load double, double* %23
%783 = load double, double* %47
%784 = fmul double %782, %783
%785 = fneg double %784
%786 = call double @llvm.fmuladd.f64(double %780, double %781, double %785)
store double %786, double* %36
%787 = load double, double* %22
%788 = load double, double* %47
%789 = load double, double* %23
%790 = load double, double* %46
%791 = fmul double %789, %790
%792 = call double @llvm.fmuladd.f64(double %787, double %788, double %791)
store double %792, double* %37
%793 = load double, double* %36
%794 = load double, double* %54
%795 = fadd double %793, %794
%796 = load double*, double** %7
%797 = load i32, i32* %10
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %796, i64 %798
store double %795, double* %799
%800 = load double, double* %37
%801 = load double, double* %55
%802 = fadd double %800, %801
%803 = load double*, double** %7
%804 = load i32, i32* %10
%805 = add nsw i32 %804, 1
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double, double* %803, i64 %806
store double %802, double* %807
%808 = load double, double* %55
%809 = load double, double* %37
%810 = fsub double %808, %809
%811 = load double*, double** %7
%812 = load i32, i32* %14
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds double, double* %811, i64 %813
store double %810, double* %814
%815 = load double, double* %36
%816 = load double, double* %54
%817 = fsub double %815, %816
%818 = load double*, double** %7
%819 = load i32, i32* %14
%820 = add nsw i32 %819, 1
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %818, i64 %821
store double %817, double* %822
%823 = load double, double* %23
%824 = load double, double* %50
%825 = load double, double* %22
%826 = load double, double* %51
%827 = fmul double %825, %826
%828 = fneg double %827
%829 = call double @llvm.fmuladd.f64(double %823, double %824, double %828)
store double %829, double* %36
%830 = load double, double* %23
%831 = load double, double* %51
%832 = load double, double* %22
%833 = load double, double* %50
%834 = fmul double %832, %833
%835 = call double @llvm.fmuladd.f64(double %830, double %831, double %834)
store double %835, double* %37
%836 = load double, double* %36
%837 = load double, double* %58
%838 = fsub double %836, %837
%839 = load double*, double** %7
%840 = load i32, i32* %12
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds double, double* %839, i64 %841
store double %838, double* %842
%843 = load double, double* %37
%844 = load double, double* %59
%845 = fadd double %843, %844
%846 = load double*, double** %7
%847 = load i32, i32* %12
%848 = add nsw i32 %847, 1
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double, double* %846, i64 %849
store double %845, double* %850
%851 = load double, double* %59
%852 = load double, double* %37
%853 = fsub double %851, %852
%854 = load double*, double** %7
%855 = load i32, i32* %16
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds double, double* %854, i64 %856
store double %853, double* %857
%858 = load double, double* %36
%859 = load double, double* %58
%860 = fadd double %858, %859
%861 = load double*, double** %7
%862 = load i32, i32* %16
%863 = add nsw i32 %862, 1
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double, double* %861, i64 %864
store double %860, double* %865
%866 = load double, double* %44
%867 = load double, double* %52
%868 = fadd double %866, %867
%869 = load double*, double** %7
%870 = load i32, i32* %9
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %869, i64 %871
store double %868, double* %872
%873 = load double, double* %45
%874 = load double, double* %53
%875 = fadd double %873, %874
%876 = load double*, double** %7
%877 = load i32, i32* %9
%878 = add nsw i32 %877, 1
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds double, double* %876, i64 %879
store double %875, double* %880
%881 = load double, double* %53
%882 = load double, double* %45
%883 = fsub double %881, %882
%884 = load double*, double** %7
%885 = load i32, i32* %13
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %884, i64 %886
store double %883, double* %887
%888 = load double, double* %44
%889 = load double, double* %52
%890 = fsub double %888, %889
%891 = load double*, double** %7
%892 = load i32, i32* %13
%893 = add nsw i32 %892, 1
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds double, double* %891, i64 %894
store double %890, double* %895
%896 = load double, double* %48
%897 = load double, double* %57
%898 = fsub double %896, %897
store double %898, double* %36
%899 = load double, double* %49
%900 = load double, double* %56
%901 = fadd double %899, %900
store double %901, double* %37
%902 = load double, double* %20
%903 = load double, double* %36
%904 = load double, double* %37
%905 = fsub double %903, %904
%906 = fmul double %902, %905
%907 = load double*, double** %7
%908 = load i32, i32* %11
%909 = sext i32 %908 to i64
%910 = getelementptr inbounds double, double* %907, i64 %909
store double %906, double* %910
%911 = load double, double* %20
%912 = load double, double* %37
%913 = load double, double* %36
%914 = fadd double %912, %913
%915 = fmul double %911, %914
%916 = load double*, double** %7
%917 = load i32, i32* %11
%918 = add nsw i32 %917, 1
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds double, double* %916, i64 %919
store double %915, double* %920
%921 = load double, double* %56
%922 = load double, double* %49
%923 = fsub double %921, %922
store double %923, double* %36
%924 = load double, double* %48
%925 = load double, double* %57
%926 = fadd double %924, %925
store double %926, double* %37
%927 = load double, double* %20
%928 = load double, double* %36
%929 = load double, double* %37
%930 = fsub double %928, %929
%931 = fmul double %927, %930
%932 = load double*, double** %7
%933 = load i32, i32* %15
%934 = sext i32 %933 to i64
%935 = getelementptr inbounds double, double* %932, i64 %934
store double %931, double* %935
%936 = load double, double* %20
%937 = load double, double* %37
%938 = load double, double* %36
%939 = fadd double %937, %938
%940 = fmul double %936, %939
%941 = load double*, double** %7
%942 = load i32, i32* %15
%943 = add nsw i32 %942, 1
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %941, i64 %944
store double %940, double* %945
br label %946
946: ; preds = %492
%947 = load i32, i32* %9
%948 = add nsw i32 %947, 2
store i32 %948, i32* %9
br label %486
949: ; preds = %486
store i32 4, i32* %18
%950 = load i32, i32* %19
%951 = mul nsw i32 2, %950
store i32 %951, i32* %17
br label %952
952: ; preds = %1537, %949
%953 = load i32, i32* %17
%954 = load i32, i32* %5
%955 = icmp slt i32 %953, %954
br i1 %955, label %956, label %1541
956: ; preds = %952
%957 = load i32, i32* %18
%958 = add nsw i32 %957, 4
store i32 %958, i32* %18
%959 = load double*, double** %8
%960 = load i32, i32* %18
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds double, double* %959, i64 %961
%963 = load double, double* %962
store double %963, double* %22
%964 = load double*, double** %8
%965 = load i32, i32* %18
%966 = add nsw i32 %965, 1
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds double, double* %964, i64 %967
%969 = load double, double* %968
store double %969, double* %23
%970 = load double*, double** %8
%971 = load i32, i32* %18
%972 = add nsw i32 %971, 2
%973 = sext i32 %972 to i64
%974 = getelementptr inbounds double, double* %970, i64 %973
%975 = load double, double* %974
store double %975, double* %24
%976 = load double*, double** %8
%977 = load i32, i32* %18
%978 = add nsw i32 %977, 3
%979 = sext i32 %978 to i64
%980 = getelementptr inbounds double, double* %976, i64 %979
%981 = load double, double* %980
store double %981, double* %25
%982 = load double, double* %25
%983 = fmul double 2.000000e+00, %982
store double %983, double* %21
%984 = load double, double* %22
%985 = load double, double* %21
%986 = load double, double* %23
%987 = fneg double %985
%988 = call double @llvm.fmuladd.f64(double %987, double %986, double %984)
store double %988, double* %26
%989 = load double, double* %21
%990 = load double, double* %22
%991 = load double, double* %23
%992 = fneg double %991
%993 = call double @llvm.fmuladd.f64(double %989, double %990, double %992)
store double %993, double* %27
%994 = load double, double* %21
%995 = load double, double* %25
%996 = fneg double %994
%997 = call double @llvm.fmuladd.f64(double %996, double %995, double 1.000000e+00)
store double %997, double* %28
%998 = load double, double* %21
%999 = load double, double* %24
%1000 = fmul double %998, %999
store double %1000, double* %29
%1001 = load double, double* %29
%1002 = fmul double 2.000000e+00, %1001
store double %1002, double* %21
%1003 = load double, double* %26
%1004 = load double, double* %21
%1005 = load double, double* %23
%1006 = fneg double %1004
%1007 = call double @llvm.fmuladd.f64(double %1006, double %1005, double %1003)
store double %1007, double* %30
%1008 = load double, double* %21
%1009 = load double, double* %22
%1010 = load double, double* %27
%1011 = fneg double %1010
%1012 = call double @llvm.fmuladd.f64(double %1008, double %1009, double %1011)
store double %1012, double* %31
%1013 = load double, double* %24
%1014 = load double, double* %21
%1015 = load double, double* %25
%1016 = fneg double %1014
%1017 = call double @llvm.fmuladd.f64(double %1016, double %1015, double %1013)
store double %1017, double* %32
%1018 = load double, double* %21
%1019 = load double, double* %24
%1020 = load double, double* %25
%1021 = fneg double %1020
%1022 = call double @llvm.fmuladd.f64(double %1018, double %1019, double %1021)
store double %1022, double* %33
%1023 = load double, double* %22
%1024 = load double, double* %21
%1025 = load double, double* %27
%1026 = fneg double %1024
%1027 = call double @llvm.fmuladd.f64(double %1026, double %1025, double %1023)
store double %1027, double* %34
%1028 = load double, double* %21
%1029 = load double, double* %26
%1030 = load double, double* %23
%1031 = fneg double %1030
%1032 = call double @llvm.fmuladd.f64(double %1028, double %1029, double %1031)
store double %1032, double* %35
%1033 = load i32, i32* %17
store i32 %1033, i32* %9
br label %1034
1034: ; preds = %1533, %956
%1035 = load i32, i32* %9
%1036 = load i32, i32* %6
%1037 = load i32, i32* %17
%1038 = add nsw i32 %1036, %1037
%1039 = icmp slt i32 %1035, %1038
br i1 %1039, label %1040, label %1536
1040: ; preds = %1034
%1041 = load i32, i32* %9
%1042 = load i32, i32* %6
%1043 = add nsw i32 %1041, %1042
store i32 %1043, i32* %10
%1044 = load i32, i32* %10
%1045 = load i32, i32* %6
%1046 = add nsw i32 %1044, %1045
store i32 %1046, i32* %11
%1047 = load i32, i32* %11
%1048 = load i32, i32* %6
%1049 = add nsw i32 %1047, %1048
store i32 %1049, i32* %12
%1050 = load i32, i32* %12
%1051 = load i32, i32* %6
%1052 = add nsw i32 %1050, %1051
store i32 %1052, i32* %13
%1053 = load i32, i32* %13
%1054 = load i32, i32* %6
%1055 = add nsw i32 %1053, %1054
store i32 %1055, i32* %14
%1056 = load i32, i32* %14
%1057 = load i32, i32* %6
%1058 = add nsw i32 %1056, %1057
store i32 %1058, i32* %15
%1059 = load i32, i32* %15
%1060 = load i32, i32* %6
%1061 = add nsw i32 %1059, %1060
store i32 %1061, i32* %16
%1062 = load double*, double** %7
%1063 = load i32, i32* %9
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds double, double* %1062, i64 %1064
%1066 = load double, double* %1065
%1067 = load double*, double** %7
%1068 = load i32, i32* %10
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds double, double* %1067, i64 %1069
%1071 = load double, double* %1070
%1072 = fadd double %1066, %1071
store double %1072, double* %36
%1073 = load double*, double** %7
%1074 = load i32, i32* %9
%1075 = add nsw i32 %1074, 1
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1073, i64 %1076
%1078 = load double, double* %1077
%1079 = load double*, double** %7
%1080 = load i32, i32* %10
%1081 = add nsw i32 %1080, 1
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds double, double* %1079, i64 %1082
%1084 = load double, double* %1083
%1085 = fadd double %1078, %1084
store double %1085, double* %37
%1086 = load double*, double** %7
%1087 = load i32, i32* %9
%1088 = sext i32 %1087 to i64
%1089 = getelementptr inbounds double, double* %1086, i64 %1088
%1090 = load double, double* %1089
%1091 = load double*, double** %7
%1092 = load i32, i32* %10
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds double, double* %1091, i64 %1093
%1095 = load double, double* %1094
%1096 = fsub double %1090, %1095
store double %1096, double* %38
%1097 = load double*, double** %7
%1098 = load i32, i32* %9
%1099 = add nsw i32 %1098, 1
%1100 = sext i32 %1099 to i64
%1101 = getelementptr inbounds double, double* %1097, i64 %1100
%1102 = load double, double* %1101
%1103 = load double*, double** %7
%1104 = load i32, i32* %10
%1105 = add nsw i32 %1104, 1
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds double, double* %1103, i64 %1106
%1108 = load double, double* %1107
%1109 = fsub double %1102, %1108
store double %1109, double* %39
%1110 = load double*, double** %7
%1111 = load i32, i32* %11
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds double, double* %1110, i64 %1112
%1114 = load double, double* %1113
%1115 = load double*, double** %7
%1116 = load i32, i32* %12
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds double, double* %1115, i64 %1117
%1119 = load double, double* %1118
%1120 = fadd double %1114, %1119
store double %1120, double* %40
%1121 = load double*, double** %7
%1122 = load i32, i32* %11
%1123 = add nsw i32 %1122, 1
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds double, double* %1121, i64 %1124
%1126 = load double, double* %1125
%1127 = load double*, double** %7
%1128 = load i32, i32* %12
%1129 = add nsw i32 %1128, 1
%1130 = sext i32 %1129 to i64
%1131 = getelementptr inbounds double, double* %1127, i64 %1130
%1132 = load double, double* %1131
%1133 = fadd double %1126, %1132
store double %1133, double* %41
%1134 = load double*, double** %7
%1135 = load i32, i32* %11
%1136 = sext i32 %1135 to i64
%1137 = getelementptr inbounds double, double* %1134, i64 %1136
%1138 = load double, double* %1137
%1139 = load double*, double** %7
%1140 = load i32, i32* %12
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds double, double* %1139, i64 %1141
%1143 = load double, double* %1142
%1144 = fsub double %1138, %1143
store double %1144, double* %42
%1145 = load double*, double** %7
%1146 = load i32, i32* %11
%1147 = add nsw i32 %1146, 1
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds double, double* %1145, i64 %1148
%1150 = load double, double* %1149
%1151 = load double*, double** %7
%1152 = load i32, i32* %12
%1153 = add nsw i32 %1152, 1
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds double, double* %1151, i64 %1154
%1156 = load double, double* %1155
%1157 = fsub double %1150, %1156
store double %1157, double* %43
%1158 = load double, double* %36
%1159 = load double, double* %40
%1160 = fadd double %1158, %1159
store double %1160, double* %44
%1161 = load double, double* %37
%1162 = load double, double* %41
%1163 = fadd double %1161, %1162
store double %1163, double* %45
%1164 = load double, double* %36
%1165 = load double, double* %40
%1166 = fsub double %1164, %1165
store double %1166, double* %48
%1167 = load double, double* %37
%1168 = load double, double* %41
%1169 = fsub double %1167, %1168
store double %1169, double* %49
%1170 = load double, double* %38
%1171 = load double, double* %43
%1172 = fsub double %1170, %1171
store double %1172, double* %46
%1173 = load double, double* %39
%1174 = load double, double* %42
%1175 = fadd double %1173, %1174
store double %1175, double* %47
%1176 = load double, double* %38
%1177 = load double, double* %43
%1178 = fadd double %1176, %1177
store double %1178, double* %50
%1179 = load double, double* %39
%1180 = load double, double* %42
%1181 = fsub double %1179, %1180
store double %1181, double* %51
%1182 = load double*, double** %7
%1183 = load i32, i32* %13
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds double, double* %1182, i64 %1184
%1186 = load double, double* %1185
%1187 = load double*, double** %7
%1188 = load i32, i32* %14
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds double, double* %1187, i64 %1189
%1191 = load double, double* %1190
%1192 = fadd double %1186, %1191
store double %1192, double* %36
%1193 = load double*, double** %7
%1194 = load i32, i32* %13
%1195 = add nsw i32 %1194, 1
%1196 = sext i32 %1195 to i64
%1197 = getelementptr inbounds double, double* %1193, i64 %1196
%1198 = load double, double* %1197
%1199 = load double*, double** %7
%1200 = load i32, i32* %14
%1201 = add nsw i32 %1200, 1
%1202 = sext i32 %1201 to i64
%1203 = getelementptr inbounds double, double* %1199, i64 %1202
%1204 = load double, double* %1203
%1205 = fadd double %1198, %1204
store double %1205, double* %37
%1206 = load double*, double** %7
%1207 = load i32, i32* %13
%1208 = sext i32 %1207 to i64
%1209 = getelementptr inbounds double, double* %1206, i64 %1208
%1210 = load double, double* %1209
%1211 = load double*, double** %7
%1212 = load i32, i32* %14
%1213 = sext i32 %1212 to i64
%1214 = getelementptr inbounds double, double* %1211, i64 %1213
%1215 = load double, double* %1214
%1216 = fsub double %1210, %1215
store double %1216, double* %38
%1217 = load double*, double** %7
%1218 = load i32, i32* %13
%1219 = add nsw i32 %1218, 1
%1220 = sext i32 %1219 to i64
%1221 = getelementptr inbounds double, double* %1217, i64 %1220
%1222 = load double, double* %1221
%1223 = load double*, double** %7
%1224 = load i32, i32* %14
%1225 = add nsw i32 %1224, 1
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds double, double* %1223, i64 %1226
%1228 = load double, double* %1227
%1229 = fsub double %1222, %1228
store double %1229, double* %39
%1230 = load double*, double** %7
%1231 = load i32, i32* %15
%1232 = sext i32 %1231 to i64
%1233 = getelementptr inbounds double, double* %1230, i64 %1232
%1234 = load double, double* %1233
%1235 = load double*, double** %7
%1236 = load i32, i32* %16
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds double, double* %1235, i64 %1237
%1239 = load double, double* %1238
%1240 = fadd double %1234, %1239
store double %1240, double* %40
%1241 = load double*, double** %7
%1242 = load i32, i32* %15
%1243 = add nsw i32 %1242, 1
%1244 = sext i32 %1243 to i64
%1245 = getelementptr inbounds double, double* %1241, i64 %1244
%1246 = load double, double* %1245
%1247 = load double*, double** %7
%1248 = load i32, i32* %16
%1249 = add nsw i32 %1248, 1
%1250 = sext i32 %1249 to i64
%1251 = getelementptr inbounds double, double* %1247, i64 %1250
%1252 = load double, double* %1251
%1253 = fadd double %1246, %1252
store double %1253, double* %41
%1254 = load double*, double** %7
%1255 = load i32, i32* %15
%1256 = sext i32 %1255 to i64
%1257 = getelementptr inbounds double, double* %1254, i64 %1256
%1258 = load double, double* %1257
%1259 = load double*, double** %7
%1260 = load i32, i32* %16
%1261 = sext i32 %1260 to i64
%1262 = getelementptr inbounds double, double* %1259, i64 %1261
%1263 = load double, double* %1262
%1264 = fsub double %1258, %1263
store double %1264, double* %42
%1265 = load double*, double** %7
%1266 = load i32, i32* %15
%1267 = add nsw i32 %1266, 1
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds double, double* %1265, i64 %1268
%1270 = load double, double* %1269
%1271 = load double*, double** %7
%1272 = load i32, i32* %16
%1273 = add nsw i32 %1272, 1
%1274 = sext i32 %1273 to i64
%1275 = getelementptr inbounds double, double* %1271, i64 %1274
%1276 = load double, double* %1275
%1277 = fsub double %1270, %1276
store double %1277, double* %43
%1278 = load double, double* %36
%1279 = load double, double* %40
%1280 = fadd double %1278, %1279
store double %1280, double* %52
%1281 = load double, double* %37
%1282 = load double, double* %41
%1283 = fadd double %1281, %1282
store double %1283, double* %53
%1284 = load double, double* %36
%1285 = load double, double* %40
%1286 = fsub double %1284, %1285
store double %1286, double* %56
%1287 = load double, double* %37
%1288 = load double, double* %41
%1289 = fsub double %1287, %1288
store double %1289, double* %57
%1290 = load double, double* %38
%1291 = load double, double* %43
%1292 = fsub double %1290, %1291
store double %1292, double* %36
%1293 = load double, double* %39
%1294 = load double, double* %42
%1295 = fadd double %1293, %1294
store double %1295, double* %37
%1296 = load double, double* %38
%1297 = load double, double* %43
%1298 = fadd double %1296, %1297
store double %1298, double* %40
%1299 = load double, double* %39
%1300 = load double, double* %42
%1301 = fsub double %1299, %1300
store double %1301, double* %41
%1302 = load double, double* %20
%1303 = load double, double* %36
%1304 = load double, double* %37
%1305 = fsub double %1303, %1304
%1306 = fmul double %1302, %1305
store double %1306, double* %54
%1307 = load double, double* %20
%1308 = load double, double* %36
%1309 = load double, double* %37
%1310 = fadd double %1308, %1309
%1311 = fmul double %1307, %1310
store double %1311, double* %55
%1312 = load double, double* %20
%1313 = load double, double* %40
%1314 = load double, double* %41
%1315 = fsub double %1313, %1314
%1316 = fmul double %1312, %1315
store double %1316, double* %58
%1317 = load double, double* %20
%1318 = load double, double* %40
%1319 = load double, double* %41
%1320 = fadd double %1318, %1319
%1321 = fmul double %1317, %1320
store double %1321, double* %59
%1322 = load double, double* %46
%1323 = load double, double* %54
%1324 = fadd double %1322, %1323
store double %1324, double* %36
%1325 = load double, double* %47
%1326 = load double, double* %55
%1327 = fadd double %1325, %1326
store double %1327, double* %37
%1328 = load double, double* %22
%1329 = load double, double* %36
%1330 = load double, double* %23
%1331 = load double, double* %37
%1332 = fmul double %1330, %1331
%1333 = fneg double %1332
%1334 = call double @llvm.fmuladd.f64(double %1328, double %1329, double %1333)
%1335 = load double*, double** %7
%1336 = load i32, i32* %10
%1337 = sext i32 %1336 to i64
%1338 = getelementptr inbounds double, double* %1335, i64 %1337
store double %1334, double* %1338
%1339 = load double, double* %22
%1340 = load double, double* %37
%1341 = load double, double* %23
%1342 = load double, double* %36
%1343 = fmul double %1341, %1342
%1344 = call double @llvm.fmuladd.f64(double %1339, double %1340, double %1343)
%1345 = load double*, double** %7
%1346 = load i32, i32* %10
%1347 = add nsw i32 %1346, 1
%1348 = sext i32 %1347 to i64
%1349 = getelementptr inbounds double, double* %1345, i64 %1348
store double %1344, double* %1349
%1350 = load double, double* %46
%1351 = load double, double* %54
%1352 = fsub double %1350, %1351
store double %1352, double* %36
%1353 = load double, double* %47
%1354 = load double, double* %55
%1355 = fsub double %1353, %1354
store double %1355, double* %37
%1356 = load double, double* %30
%1357 = load double, double* %36
%1358 = load double, double* %31
%1359 = load double, double* %37
%1360 = fmul double %1358, %1359
%1361 = fneg double %1360
%1362 = call double @llvm.fmuladd.f64(double %1356, double %1357, double %1361)
%1363 = load double*, double** %7
%1364 = load i32, i32* %14
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds double, double* %1363, i64 %1365
store double %1362, double* %1366
%1367 = load double, double* %30
%1368 = load double, double* %37
%1369 = load double, double* %31
%1370 = load double, double* %36
%1371 = fmul double %1369, %1370
%1372 = call double @llvm.fmuladd.f64(double %1367, double %1368, double %1371)
%1373 = load double*, double** %7
%1374 = load i32, i32* %14
%1375 = add nsw i32 %1374, 1
%1376 = sext i32 %1375 to i64
%1377 = getelementptr inbounds double, double* %1373, i64 %1376
store double %1372, double* %1377
%1378 = load double, double* %50
%1379 = load double, double* %59
%1380 = fsub double %1378, %1379
store double %1380, double* %36
%1381 = load double, double* %51
%1382 = load double, double* %58
%1383 = fadd double %1381, %1382
store double %1383, double* %37
%1384 = load double, double* %26
%1385 = load double, double* %36
%1386 = load double, double* %27
%1387 = load double, double* %37
%1388 = fmul double %1386, %1387
%1389 = fneg double %1388
%1390 = call double @llvm.fmuladd.f64(double %1384, double %1385, double %1389)
%1391 = load double*, double** %7
%1392 = load i32, i32* %12
%1393 = sext i32 %1392 to i64
%1394 = getelementptr inbounds double, double* %1391, i64 %1393
store double %1390, double* %1394
%1395 = load double, double* %26
%1396 = load double, double* %37
%1397 = load double, double* %27
%1398 = load double, double* %36
%1399 = fmul double %1397, %1398
%1400 = call double @llvm.fmuladd.f64(double %1395, double %1396, double %1399)
%1401 = load double*, double** %7
%1402 = load i32, i32* %12
%1403 = add nsw i32 %1402, 1
%1404 = sext i32 %1403 to i64
%1405 = getelementptr inbounds double, double* %1401, i64 %1404
store double %1400, double* %1405
%1406 = load double, double* %50
%1407 = load double, double* %59
%1408 = fadd double %1406, %1407
store double %1408, double* %36
%1409 = load double, double* %51
%1410 = load double, double* %58
%1411 = fsub double %1409, %1410
store double %1411, double* %37
%1412 = load double, double* %34
%1413 = load double, double* %36
%1414 = load double, double* %35
%1415 = load double, double* %37
%1416 = fmul double %1414, %1415
%1417 = fneg double %1416
%1418 = call double @llvm.fmuladd.f64(double %1412, double %1413, double %1417)
%1419 = load double*, double** %7
%1420 = load i32, i32* %16
%1421 = sext i32 %1420 to i64
%1422 = getelementptr inbounds double, double* %1419, i64 %1421
store double %1418, double* %1422
%1423 = load double, double* %34
%1424 = load double, double* %37
%1425 = load double, double* %35
%1426 = load double, double* %36
%1427 = fmul double %1425, %1426
%1428 = call double @llvm.fmuladd.f64(double %1423, double %1424, double %1427)
%1429 = load double*, double** %7
%1430 = load i32, i32* %16
%1431 = add nsw i32 %1430, 1
%1432 = sext i32 %1431 to i64
%1433 = getelementptr inbounds double, double* %1429, i64 %1432
store double %1428, double* %1433
%1434 = load double, double* %44
%1435 = load double, double* %52
%1436 = fadd double %1434, %1435
%1437 = load double*, double** %7
%1438 = load i32, i32* %9
%1439 = sext i32 %1438 to i64
%1440 = getelementptr inbounds double, double* %1437, i64 %1439
store double %1436, double* %1440
%1441 = load double, double* %45
%1442 = load double, double* %53
%1443 = fadd double %1441, %1442
%1444 = load double*, double** %7
%1445 = load i32, i32* %9
%1446 = add nsw i32 %1445, 1
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds double, double* %1444, i64 %1447
store double %1443, double* %1448
%1449 = load double, double* %44
%1450 = load double, double* %52
%1451 = fsub double %1449, %1450
store double %1451, double* %36
%1452 = load double, double* %45
%1453 = load double, double* %53
%1454 = fsub double %1452, %1453
store double %1454, double* %37
%1455 = load double, double* %28
%1456 = load double, double* %36
%1457 = load double, double* %29
%1458 = load double, double* %37
%1459 = fmul double %1457, %1458
%1460 = fneg double %1459
%1461 = call double @llvm.fmuladd.f64(double %1455, double %1456, double %1460)
%1462 = load double*, double** %7
%1463 = load i32, i32* %13
%1464 = sext i32 %1463 to i64
%1465 = getelementptr inbounds double, double* %1462, i64 %1464
store double %1461, double* %1465
%1466 = load double, double* %28
%1467 = load double, double* %37
%1468 = load double, double* %29
%1469 = load double, double* %36
%1470 = fmul double %1468, %1469
%1471 = call double @llvm.fmuladd.f64(double %1466, double %1467, double %1470)
%1472 = load double*, double** %7
%1473 = load i32, i32* %13
%1474 = add nsw i32 %1473, 1
%1475 = sext i32 %1474 to i64
%1476 = getelementptr inbounds double, double* %1472, i64 %1475
store double %1471, double* %1476
%1477 = load double, double* %48
%1478 = load double, double* %57
%1479 = fsub double %1477, %1478
store double %1479, double* %36
%1480 = load double, double* %49
%1481 = load double, double* %56
%1482 = fadd double %1480, %1481
store double %1482, double* %37
%1483 = load double, double* %24
%1484 = load double, double* %36
%1485 = load double, double* %25
%1486 = load double, double* %37
%1487 = fmul double %1485, %1486
%1488 = fneg double %1487
%1489 = call double @llvm.fmuladd.f64(double %1483, double %1484, double %1488)
%1490 = load double*, double** %7
%1491 = load i32, i32* %11
%1492 = sext i32 %1491 to i64
%1493 = getelementptr inbounds double, double* %1490, i64 %1492
store double %1489, double* %1493
%1494 = load double, double* %24
%1495 = load double, double* %37
%1496 = load double, double* %25
%1497 = load double, double* %36
%1498 = fmul double %1496, %1497
%1499 = call double @llvm.fmuladd.f64(double %1494, double %1495, double %1498)
%1500 = load double*, double** %7
%1501 = load i32, i32* %11
%1502 = add nsw i32 %1501, 1
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds double, double* %1500, i64 %1503
store double %1499, double* %1504
%1505 = load double, double* %48
%1506 = load double, double* %57
%1507 = fadd double %1505, %1506
store double %1507, double* %36
%1508 = load double, double* %49
%1509 = load double, double* %56
%1510 = fsub double %1508, %1509
store double %1510, double* %37
%1511 = load double, double* %32
%1512 = load double, double* %36
%1513 = load double, double* %33
%1514 = load double, double* %37
%1515 = fmul double %1513, %1514
%1516 = fneg double %1515
%1517 = call double @llvm.fmuladd.f64(double %1511, double %1512, double %1516)
%1518 = load double*, double** %7
%1519 = load i32, i32* %15
%1520 = sext i32 %1519 to i64
%1521 = getelementptr inbounds double, double* %1518, i64 %1520
store double %1517, double* %1521
%1522 = load double, double* %32
%1523 = load double, double* %37
%1524 = load double, double* %33
%1525 = load double, double* %36
%1526 = fmul double %1524, %1525
%1527 = call double @llvm.fmuladd.f64(double %1522, double %1523, double %1526)
%1528 = load double*, double** %7
%1529 = load i32, i32* %15
%1530 = add nsw i32 %1529, 1
%1531 = sext i32 %1530 to i64
%1532 = getelementptr inbounds double, double* %1528, i64 %1531
store double %1527, double* %1532
br label %1533
1533: ; preds = %1040
%1534 = load i32, i32* %9
%1535 = add nsw i32 %1534, 2
store i32 %1535, i32* %9
br label %1034
1536: ; preds = %1034
br label %1537
1537: ; preds = %1536
%1538 = load i32, i32* %19
%1539 = load i32, i32* %17
%1540 = add nsw i32 %1539, %1538
store i32 %1540, i32* %17
br label %952
1541: ; preds = %952
br label %1542
1542: ; preds = %1541, %474
ret void
}

LLVM IR (-O2):
define void @cftmdl(i32 %0, i32 %1, double* %2, double* nocapture %3) {
%5 = shl i32 %1, 3
%6 = getelementptr inbounds double, double* %3, i64 2
%7 = load double, double* %6
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %113
9: ; preds = %4
%10 = zext i32 %1 to i64
%11 = insertelement <2 x double> poison, double %7, i64 0
%12 = shufflevector <2 x double> %11, <2 x double> poison, <2 x i32> zeroinitializer
br label %13
13: ; preds = %9, %13
%14 = phi i64 [ 0, %9 ], [ %111, %13 ]
%15 = add nuw nsw i64 %14, %10
%16 = add nuw nsw i64 %15, %10
%17 = add nuw nsw i64 %16, %10
%18 = add nuw nsw i64 %17, %10
%19 = add nuw nsw i64 %18, %10
%20 = add nuw nsw i64 %19, %10
%21 = add nsw i64 %20, %10
%22 = getelementptr inbounds double, double* %2, i64 %14
%23 = getelementptr inbounds double, double* %2, i64 %15
%24 = bitcast double* %22 to <2 x double>*
%25 = load <2 x double>, <2 x double>* %24
%26 = bitcast double* %23 to <2 x double>*
%27 = load <2 x double>, <2 x double>* %26
%28 = fadd <2 x double> %25, %27
%29 = fsub <2 x double> %25, %27
%30 = getelementptr inbounds double, double* %2, i64 %16
%31 = getelementptr inbounds double, double* %2, i64 %17
%32 = bitcast double* %30 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = add nuw nsw i64 %17, 1
%35 = getelementptr inbounds double, double* %2, i64 %34
%36 = bitcast double* %31 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = fadd <2 x double> %33, %37
%39 = fsub <2 x double> %33, %37
%40 = shufflevector <2 x double> %39, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%41 = fadd <2 x double> %28, %38
%42 = fsub <2 x double> %28, %38
%43 = fsub <2 x double> %29, %40
%44 = fadd <2 x double> %29, %40
%45 = shufflevector <2 x double> %43, <2 x double> %44, <2 x i32> <i32 0, i32 3>
%46 = fadd <2 x double> %29, %40
%47 = extractelement <2 x double> %46, i64 0
%48 = fsub <2 x double> %29, %40
%49 = extractelement <2 x double> %48, i64 1
%50 = getelementptr inbounds double, double* %2, i64 %18
%51 = getelementptr inbounds double, double* %2, i64 %19
%52 = bitcast double* %50 to <2 x double>*
%53 = load <2 x double>, <2 x double>* %52
%54 = bitcast double* %51 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = fadd <2 x double> %53, %55
%57 = fsub <2 x double> %53, %55
%58 = extractelement <2 x double> %57, i64 0
%59 = fsub <2 x double> %53, %55
%60 = extractelement <2 x double> %59, i64 1
%61 = getelementptr inbounds double, double* %2, i64 %20
%62 = getelementptr inbounds double, double* %2, i64 %21
%63 = bitcast double* %61 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = add nsw i64 %21, 1
%66 = getelementptr inbounds double, double* %2, i64 %65
%67 = bitcast double* %62 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = fadd <2 x double> %64, %68
%70 = fsub <2 x double> %64, %68
%71 = extractelement <2 x double> %70, i64 0
%72 = fsub <2 x double> %64, %68
%73 = extractelement <2 x double> %72, i64 1
%74 = fadd <2 x double> %56, %69
%75 = fsub <2 x double> %56, %69
%76 = shufflevector <2 x double> %75, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%77 = fsub double %58, %73
%78 = fadd double %60, %71
%79 = fadd double %58, %73
%80 = fsub double %60, %71
%81 = insertelement <2 x double> poison, double %77, i64 0
%82 = shufflevector <2 x double> %81, <2 x double> poison, <2 x i32> zeroinitializer
%83 = insertelement <2 x double> poison, double %78, i64 0
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> zeroinitializer
%85 = fsub <2 x double> %82, %84
%86 = fadd <2 x double> %82, %84
%87 = shufflevector <2 x double> %85, <2 x double> %86, <2 x i32> <i32 0, i32 3>
%88 = fmul <2 x double> %12, %87
%89 = fsub double %79, %80
%90 = fmul double %7, %89
%91 = fadd double %80, %79
%92 = fmul double %7, %91
%93 = fadd <2 x double> %45, %88
%94 = bitcast double* %23 to <2 x double>*
store <2 x double> %93, <2 x double>* %94
%95 = fsub <2 x double> %45, %88
%96 = bitcast double* %51 to <2 x double>*
store <2 x double> %95, <2 x double>* %96
%97 = fsub double %47, %92
store double %97, double* %31
%98 = fadd double %49, %90
store double %98, double* %35
%99 = fadd double %47, %92
store double %99, double* %62
%100 = fsub double %49, %90
store double %100, double* %66
%101 = fadd <2 x double> %41, %74
%102 = bitcast double* %22 to <2 x double>*
store <2 x double> %101, <2 x double>* %102
%103 = fsub <2 x double> %41, %74
%104 = bitcast double* %50 to <2 x double>*
store <2 x double> %103, <2 x double>* %104
%105 = fsub <2 x double> %42, %76
%106 = fadd <2 x double> %42, %76
%107 = shufflevector <2 x double> %105, <2 x double> %106, <2 x i32> <i32 0, i32 3>
%108 = bitcast double* %30 to <2 x double>*
store <2 x double> %107, <2 x double>* %108
%109 = shufflevector <2 x double> %106, <2 x double> %105, <2 x i32> <i32 0, i32 3>
%110 = bitcast double* %61 to <2 x double>*
store <2 x double> %109, <2 x double>* %110
%111 = add nuw nsw i64 %14, 2
%112 = icmp ult i64 %111, %10
br i1 %112, label %13, label %113
113: ; preds = %13, %4
%114 = icmp slt i32 %5, %0
br i1 %114, label %115, label %482
115: ; preds = %113
%116 = getelementptr inbounds double, double* %3, i64 4
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = mul i32 %1, 9
%120 = icmp slt i32 %5, %119
br i1 %120, label %121, label %274
121: ; preds = %115
%122 = shufflevector <2 x double> %118, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%123 = shufflevector <2 x double> %122, <2 x double> %118, <2 x i32> <i32 0, i32 2>
%124 = fneg <2 x double> %123
%125 = sext i32 %5 to i64
%126 = sext i32 %1 to i64
%127 = sext i32 %119 to i64
%128 = shufflevector <2 x double> %118, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%129 = shufflevector <2 x double> %118, <2 x double> %124, <2 x i32> <i32 0, i32 2>
%130 = shufflevector <2 x double> %122, <2 x double> %124, <2 x i32> <i32 0, i32 3>
br label %131
131: ; preds = %121, %131
%132 = phi i64 [ %125, %121 ], [ %272, %131 ]
%133 = add nsw i64 %132, %126
%134 = add nsw i64 %133, %126
%135 = add nsw i64 %134, %126
%136 = add nsw i64 %135, %126
%137 = add nsw i64 %136, %126
%138 = add nsw i64 %137, %126
%139 = add nsw i64 %138, %126
%140 = getelementptr inbounds double, double* %2, i64 %132
%141 = load double, double* %140
%142 = getelementptr inbounds double, double* %2, i64 %133
%143 = load double, double* %142
%144 = or i64 %132, 1
%145 = getelementptr inbounds double, double* %2, i64 %144
%146 = load double, double* %145
%147 = add nsw i64 %133, 1
%148 = getelementptr inbounds double, double* %2, i64 %147
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %2, i64 %134
%151 = load double, double* %150
%152 = getelementptr inbounds double, double* %2, i64 %135
%153 = load double, double* %152
%154 = add nsw i64 %134, 1
%155 = getelementptr inbounds double, double* %2, i64 %154
%156 = load double, double* %155
%157 = add nsw i64 %135, 1
%158 = getelementptr inbounds double, double* %2, i64 %157
%159 = load double, double* %158
%160 = add nsw i64 %136, 1
%161 = getelementptr inbounds double, double* %2, i64 %160
%162 = load double, double* %161
%163 = add nsw i64 %137, 1
%164 = getelementptr inbounds double, double* %2, i64 %163
%165 = load double, double* %164
%166 = insertelement <2 x double> poison, double %162, i64 0
%167 = insertelement <2 x double> %166, double %141, i64 1
%168 = insertelement <2 x double> poison, double %165, i64 0
%169 = insertelement <2 x double> %168, double %143, i64 1
%170 = fadd <2 x double> %167, %169
%171 = add nsw i64 %138, 1
%172 = getelementptr inbounds double, double* %2, i64 %171
%173 = load double, double* %172
%174 = add nsw i64 %139, 1
%175 = getelementptr inbounds double, double* %2, i64 %174
%176 = load double, double* %175
%177 = insertelement <2 x double> poison, double %173, i64 0
%178 = insertelement <2 x double> %177, double %151, i64 1
%179 = insertelement <2 x double> poison, double %176, i64 0
%180 = insertelement <2 x double> %179, double %153, i64 1
%181 = fadd <2 x double> %178, %180
%182 = fsub <2 x double> %170, %181
%183 = extractelement <2 x double> %182, i64 1
%184 = getelementptr inbounds double, double* %2, i64 %136
%185 = load double, double* %184
%186 = getelementptr inbounds double, double* %2, i64 %137
%187 = load double, double* %186
%188 = insertelement <2 x double> poison, double %146, i64 0
%189 = insertelement <2 x double> %188, double %185, i64 1
%190 = insertelement <2 x double> poison, double %149, i64 0
%191 = insertelement <2 x double> %190, double %187, i64 1
%192 = fadd <2 x double> %189, %191
%193 = getelementptr inbounds double, double* %2, i64 %138
%194 = load double, double* %193
%195 = getelementptr inbounds double, double* %2, i64 %139
%196 = load double, double* %195
%197 = insertelement <2 x double> poison, double %156, i64 0
%198 = insertelement <2 x double> %197, double %194, i64 1
%199 = insertelement <2 x double> poison, double %159, i64 0
%200 = insertelement <2 x double> %199, double %196, i64 1
%201 = fadd <2 x double> %198, %200
%202 = fsub <2 x double> %192, %201
%203 = extractelement <2 x double> %202, i64 0
%204 = insertelement <2 x double> %166, double %156, i64 1
%205 = insertelement <2 x double> %168, double %159, i64 1
%206 = fsub <2 x double> %204, %205
%207 = insertelement <2 x double> poison, double %194, i64 0
%208 = insertelement <2 x double> %207, double %141, i64 1
%209 = insertelement <2 x double> poison, double %196, i64 0
%210 = insertelement <2 x double> %209, double %143, i64 1
%211 = fsub <2 x double> %208, %210
%212 = insertelement <2 x double> poison, double %185, i64 0
%213 = insertelement <2 x double> %212, double %146, i64 1
%214 = insertelement <2 x double> poison, double %187, i64 0
%215 = insertelement <2 x double> %214, double %149, i64 1
%216 = fsub <2 x double> %213, %215
%217 = fsub <2 x double> %178, %180
%218 = fadd <2 x double> %192, %201
%219 = fadd <2 x double> %170, %181
%220 = fsub <2 x double> %192, %201
%221 = extractelement <2 x double> %220, i64 1
%222 = fsub <2 x double> %170, %181
%223 = extractelement <2 x double> %222, i64 0
%224 = fsub <2 x double> %216, %217
%225 = fadd <2 x double> %216, %217
%226 = shufflevector <2 x double> %224, <2 x double> %225, <2 x i32> <i32 0, i32 3>
%227 = fadd <2 x double> %211, %206
%228 = fsub <2 x double> %211, %206
%229 = shufflevector <2 x double> %227, <2 x double> %228, <2 x i32> <i32 0, i32 3>
%230 = shufflevector <2 x double> %225, <2 x double> %224, <2 x i32> <i32 0, i32 3>
%231 = shufflevector <2 x double> %228, <2 x double> %227, <2 x i32> <i32 0, i32 3>
%232 = fmul <2 x double> %129, %226
%233 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %128, <2 x double> %229, <2 x double> %232)
%234 = shufflevector <2 x double> %228, <2 x double> %227, <2 x i32> <i32 1, i32 2>
%235 = fmul <2 x double> %130, %234
%236 = shufflevector <2 x double> %225, <2 x double> %224, <2 x i32> <i32 1, i32 2>
%237 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %118, <2 x double> %236, <2 x double> %235)
%238 = fadd <2 x double> %237, %233
%239 = shufflevector <2 x double> %238, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%240 = bitcast double* %142 to <2 x double>*
store <2 x double> %239, <2 x double>* %240
%241 = fsub <2 x double> %233, %237
%242 = bitcast double* %186 to <2 x double>*
store <2 x double> %241, <2 x double>* %242
%243 = fmul <2 x double> %230, %124
%244 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %118, <2 x double> %231, <2 x double> %243)
%245 = shufflevector <2 x double> %227, <2 x double> %228, <2 x i32> <i32 1, i32 2>
%246 = fmul <2 x double> %118, %245
%247 = shufflevector <2 x double> %224, <2 x double> %225, <2 x i32> <i32 1, i32 2>
%248 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %123, <2 x double> %247, <2 x double> %246)
%249 = fsub <2 x double> %244, %248
%250 = fadd <2 x double> %244, %248
%251 = shufflevector <2 x double> %249, <2 x double> %250, <2 x i32> <i32 1, i32 2>
%252 = bitcast double* %152 to <2 x double>*
store <2 x double> %251, <2 x double>* %252
%253 = shufflevector <2 x double> %249, <2 x double> %250, <2 x i32> <i32 0, i32 3>
%254 = bitcast double* %195 to <2 x double>*
store <2 x double> %253, <2 x double>* %254
%255 = fadd <2 x double> %218, %219
%256 = shufflevector <2 x double> %255, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%257 = bitcast double* %140 to <2 x double>*
store <2 x double> %256, <2 x double>* %257
%258 = fsub <2 x double> %219, %218
%259 = bitcast double* %184 to <2 x double>*
store <2 x double> %258, <2 x double>* %259
%260 = fsub double %183, %223
%261 = fadd double %203, %221
%262 = fsub double %260, %261
%263 = fmul double %7, %262
store double %263, double* %150
%264 = fadd double %261, %260
%265 = fmul double %7, %264
store double %265, double* %155
%266 = fsub double %221, %203
%267 = fadd double %183, %223
%268 = fsub double %266, %267
%269 = fmul double %7, %268
store double %269, double* %193
%270 = fadd double %266, %267
%271 = fmul double %7, %270
store double %271, double* %172
%272 = add nsw i64 %132, 2
%273 = icmp slt i64 %272, %127
br i1 %273, label %131, label %274
274: ; preds = %131, %115
%275 = shl i32 %1, 4
%276 = icmp slt i32 %275, %0
br i1 %276, label %277, label %482
277: ; preds = %274
%278 = sext i32 %275 to i64
%279 = sext i32 %5 to i64
%280 = sext i32 %1 to i64
%281 = sext i32 %0 to i64
%282 = insertelement <2 x double> poison, double %7, i64 0
%283 = shufflevector <2 x double> %282, <2 x double> poison, <2 x i32> zeroinitializer
%284 = insertelement <2 x double> poison, double %7, i64 0
%285 = shufflevector <2 x double> %284, <2 x double> poison, <2 x i32> zeroinitializer
br label %286
286: ; preds = %277, %479
%287 = phi i64 [ 4, %277 ], [ %289, %479 ]
%288 = phi i64 [ %278, %277 ], [ %480, %479 ]
%289 = add nuw nsw i64 %287, 4
%290 = getelementptr inbounds double, double* %3, i64 %289
%291 = load double, double* %290
%292 = add nuw nsw i64 %287, 5
%293 = getelementptr inbounds double, double* %3, i64 %292
%294 = load double, double* %293
%295 = add nuw nsw i64 %287, 6
%296 = getelementptr inbounds double, double* %3, i64 %295
%297 = load double, double* %296
%298 = add nuw nsw i64 %287, 7
%299 = getelementptr inbounds double, double* %3, i64 %298
%300 = load double, double* %299
%301 = fmul double %300, 2.000000e+00
%302 = fneg double %301
%303 = tail call double @llvm.fmuladd.f64(double %302, double %294, double %291)
%304 = fneg double %294
%305 = tail call double @llvm.fmuladd.f64(double %301, double %291, double %304)
%306 = fmul double %297, %301
%307 = fmul double %306, 2.000000e+00
%308 = fneg double %307
%309 = fneg double %305
%310 = tail call double @llvm.fmuladd.f64(double %307, double %291, double %309)
%311 = fneg double %300
%312 = tail call double @llvm.fmuladd.f64(double %307, double %297, double %311)
%313 = tail call double @llvm.fmuladd.f64(double %307, double %303, double %304)
%314 = add nsw i64 %288, %280
br i1 %8, label %315, label %479
315: ; preds = %286
%316 = tail call double @llvm.fmuladd.f64(double %308, double %294, double %303)
%317 = tail call double @llvm.fmuladd.f64(double %308, double %305, double %291)
%318 = tail call double @llvm.fmuladd.f64(double %302, double %300, double 1.000000e+00)
%319 = tail call double @llvm.fmuladd.f64(double %308, double %300, double %297)
%320 = fneg double %310
%321 = fneg double %313
%322 = fneg double %306
%323 = fneg double %312
%324 = insertelement <2 x double> poison, double %319, i64 0
%325 = shufflevector <2 x double> %324, <2 x double> poison, <2 x i32> zeroinitializer
%326 = insertelement <2 x double> poison, double %312, i64 1
%327 = insertelement <2 x double> poison, double %323, i64 0
%328 = insertelement <2 x double> poison, double %297, i64 0
%329 = shufflevector <2 x double> %328, <2 x double> poison, <2 x i32> zeroinitializer
%330 = insertelement <2 x double> poison, double %300, i64 1
%331 = insertelement <2 x double> poison, double %311, i64 0
%332 = insertelement <2 x double> poison, double %318, i64 0
%333 = shufflevector <2 x double> %332, <2 x double> poison, <2 x i32> zeroinitializer
%334 = insertelement <2 x double> poison, double %306, i64 1
%335 = insertelement <2 x double> poison, double %322, i64 0
%336 = insertelement <2 x double> poison, double %317, i64 0
%337 = shufflevector <2 x double> %336, <2 x double> poison, <2 x i32> zeroinitializer
%338 = insertelement <2 x double> poison, double %313, i64 1
%339 = insertelement <2 x double> poison, double %321, i64 0
%340 = insertelement <2 x double> poison, double %303, i64 0
%341 = shufflevector <2 x double> %340, <2 x double> poison, <2 x i32> zeroinitializer
%342 = insertelement <2 x double> poison, double %305, i64 1
%343 = insertelement <2 x double> poison, double %309, i64 0
%344 = insertelement <2 x double> poison, double %316, i64 0
%345 = shufflevector <2 x double> %344, <2 x double> poison, <2 x i32> zeroinitializer
%346 = insertelement <2 x double> poison, double %310, i64 1
%347 = insertelement <2 x double> poison, double %320, i64 0
%348 = insertelement <2 x double> poison, double %291, i64 0
%349 = shufflevector <2 x double> %348, <2 x double> poison, <2 x i32> zeroinitializer
%350 = insertelement <2 x double> poison, double %294, i64 1
%351 = insertelement <2 x double> poison, double %304, i64 0
br label %352
352: ; preds = %315, %352
%353 = phi i64 [ %288, %315 ], [ %477, %352 ]
%354 = add nsw i64 %353, %280
%355 = add nsw i64 %354, %280
%356 = add nsw i64 %355, %280
%357 = add nsw i64 %356, %280
%358 = add nsw i64 %357, %280
%359 = add nsw i64 %358, %280
%360 = add nsw i64 %359, %280
%361 = getelementptr inbounds double, double* %2, i64 %353
%362 = getelementptr inbounds double, double* %2, i64 %354
%363 = bitcast double* %361 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = bitcast double* %362 to <2 x double>*
%366 = load <2 x double>, <2 x double>* %365
%367 = fadd <2 x double> %364, %366
%368 = fsub <2 x double> %364, %366
%369 = getelementptr inbounds double, double* %2, i64 %355
%370 = getelementptr inbounds double, double* %2, i64 %356
%371 = bitcast double* %369 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = bitcast double* %370 to <2 x double>*
%374 = load <2 x double>, <2 x double>* %373
%375 = fadd <2 x double> %372, %374
%376 = fsub <2 x double> %372, %374
%377 = shufflevector <2 x double> %376, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%378 = fadd <2 x double> %367, %375
%379 = fsub <2 x double> %367, %375
%380 = fsub <2 x double> %368, %377
%381 = fadd <2 x double> %368, %377
%382 = shufflevector <2 x double> %380, <2 x double> %381, <2 x i32> <i32 0, i32 3>
%383 = shufflevector <2 x double> %381, <2 x double> %380, <2 x i32> <i32 0, i32 3>
%384 = getelementptr inbounds double, double* %2, i64 %357
%385 = getelementptr inbounds double, double* %2, i64 %358
%386 = bitcast double* %384 to <2 x double>*
%387 = load <2 x double>, <2 x double>* %386
%388 = bitcast double* %385 to <2 x double>*
%389 = load <2 x double>, <2 x double>* %388
%390 = fadd <2 x double> %387, %389
%391 = fsub <2 x double> %387, %389
%392 = extractelement <2 x double> %391, i64 0
%393 = fsub <2 x double> %387, %389
%394 = extractelement <2 x double> %393, i64 1
%395 = getelementptr inbounds double, double* %2, i64 %359
%396 = getelementptr inbounds double, double* %2, i64 %360
%397 = bitcast double* %395 to <2 x double>*
%398 = load <2 x double>, <2 x double>* %397
%399 = bitcast double* %396 to <2 x double>*
%400 = load <2 x double>, <2 x double>* %399
%401 = fadd <2 x double> %398, %400
%402 = fsub <2 x double> %398, %400
%403 = extractelement <2 x double> %402, i64 0
%404 = fsub <2 x double> %398, %400
%405 = extractelement <2 x double> %404, i64 1
%406 = fadd <2 x double> %390, %401
%407 = fsub <2 x double> %390, %401
%408 = shufflevector <2 x double> %407, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%409 = fsub double %392, %405
%410 = fadd double %394, %403
%411 = fadd double %392, %405
%412 = fsub double %394, %403
%413 = insertelement <2 x double> poison, double %409, i64 0
%414 = shufflevector <2 x double> %413, <2 x double> poison, <2 x i32> zeroinitializer
%415 = insertelement <2 x double> poison, double %410, i64 0
%416 = shufflevector <2 x double> %415, <2 x double> poison, <2 x i32> zeroinitializer
%417 = fsub <2 x double> %414, %416
%418 = fadd <2 x double> %414, %416
%419 = shufflevector <2 x double> %417, <2 x double> %418, <2 x i32> <i32 0, i32 3>
%420 = fmul <2 x double> %285, %419
%421 = insertelement <2 x double> poison, double %411, i64 0
%422 = shufflevector <2 x double> %421, <2 x double> poison, <2 x i32> zeroinitializer
%423 = insertelement <2 x double> poison, double %412, i64 0
%424 = shufflevector <2 x double> %423, <2 x double> poison, <2 x i32> zeroinitializer
%425 = fadd <2 x double> %422, %424
%426 = fsub <2 x double> %422, %424
%427 = shufflevector <2 x double> %425, <2 x double> %426, <2 x i32> <i32 0, i32 3>
%428 = fmul <2 x double> %283, %427
%429 = fadd <2 x double> %382, %420
%430 = shufflevector <2 x double> %350, <2 x double> %429, <2 x i32> <i32 3, i32 1>
%431 = shufflevector <2 x double> %351, <2 x double> %429, <2 x i32> <i32 0, i32 2>
%432 = fmul <2 x double> %430, %431
%433 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %349, <2 x double> %429, <2 x double> %432)
%434 = bitcast double* %362 to <2 x double>*
store <2 x double> %433, <2 x double>* %434
%435 = fsub <2 x double> %382, %420
%436 = shufflevector <2 x double> %346, <2 x double> %435, <2 x i32> <i32 3, i32 1>
%437 = shufflevector <2 x double> %347, <2 x double> %435, <2 x i32> <i32 0, i32 2>
%438 = fmul <2 x double> %436, %437
%439 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %345, <2 x double> %435, <2 x double> %438)
%440 = bitcast double* %385 to <2 x double>*
store <2 x double> %439, <2 x double>* %440
%441 = fsub <2 x double> %383, %428
%442 = fadd <2 x double> %383, %428
%443 = shufflevector <2 x double> %441, <2 x double> %442, <2 x i32> <i32 0, i32 3>
%444 = shufflevector <2 x double> %342, <2 x double> %442, <2 x i32> <i32 3, i32 1>
%445 = shufflevector <2 x double> %343, <2 x double> %441, <2 x i32> <i32 0, i32 2>
%446 = fmul <2 x double> %444, %445
%447 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %341, <2 x double> %443, <2 x double> %446)
%448 = bitcast double* %370 to <2 x double>*
store <2 x double> %447, <2 x double>* %448
%449 = shufflevector <2 x double> %442, <2 x double> %441, <2 x i32> <i32 0, i32 3>
%450 = shufflevector <2 x double> %338, <2 x double> %441, <2 x i32> <i32 3, i32 1>
%451 = shufflevector <2 x double> %339, <2 x double> %442, <2 x i32> <i32 0, i32 2>
%452 = fmul <2 x double> %450, %451
%453 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %337, <2 x double> %449, <2 x double> %452)
%454 = bitcast double* %396 to <2 x double>*
store <2 x double> %453, <2 x double>* %454
%455 = fadd <2 x double> %378, %406
%456 = bitcast double* %361 to <2 x double>*
store <2 x double> %455, <2 x double>* %456
%457 = fsub <2 x double> %378, %406
%458 = shufflevector <2 x double> %334, <2 x double> %457, <2 x i32> <i32 3, i32 1>
%459 = shufflevector <2 x double> %335, <2 x double> %457, <2 x i32> <i32 0, i32 2>
%460 = fmul <2 x double> %458, %459
%461 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %333, <2 x double> %457, <2 x double> %460)
%462 = bitcast double* %384 to <2 x double>*
store <2 x double> %461, <2 x double>* %462
%463 = fsub <2 x double> %379, %408
%464 = fadd <2 x double> %379, %408
%465 = shufflevector <2 x double> %463, <2 x double> %464, <2 x i32> <i32 0, i32 3>
%466 = shufflevector <2 x double> %330, <2 x double> %464, <2 x i32> <i32 3, i32 1>
%467 = shufflevector <2 x double> %331, <2 x double> %463, <2 x i32> <i32 0, i32 2>
%468 = fmul <2 x double> %466, %467
%469 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %329, <2 x double> %465, <2 x double> %468)
%470 = bitcast double* %369 to <2 x double>*
store <2 x double> %469, <2 x double>* %470
%471 = shufflevector <2 x double> %464, <2 x double> %463, <2 x i32> <i32 0, i32 3>
%472 = shufflevector <2 x double> %326, <2 x double> %463, <2 x i32> <i32 3, i32 1>
%473 = shufflevector <2 x double> %327, <2 x double> %464, <2 x i32> <i32 0, i32 2>
%474 = fmul <2 x double> %472, %473
%475 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %325, <2 x double> %471, <2 x double> %474)
%476 = bitcast double* %395 to <2 x double>*
store <2 x double> %475, <2 x double>* %476
%477 = add nsw i64 %353, 2
%478 = icmp slt i64 %477, %314
br i1 %478, label %352, label %479
479: ; preds = %352, %286
%480 = add i64 %288, %279
%481 = icmp slt i64 %480, %281
br i1 %481, label %286, label %482
482: ; preds = %479, %274, %113
ret void
}