#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

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


x86 assembly (clang, -O0):
<cftmdl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1373 <cftmdl+0x273>
mov    -0x28(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
subss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
subss  -0x9c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    112c <cftmdl+0x2c>
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x60(%rbp),%rcx
cmp    %rcx,%rax
jae    165b <cftmdl+0x55b>
mov    -0x28(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
subss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x84(%rbp),%xmm0
ff
subss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
subss  -0x88(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
addss  -0x88(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0xa0(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
subss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm1
ff
subss  -0x84(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm1
ff
addss  -0x84(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1389 <cftmdl+0x289>
movq   $0x0,-0x50(%rbp)
mov    -0x60(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1f0e <cftmdl+0xe0e>
mov    -0x50(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm1
movss  0x90c(%rip),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  0x8e0(%rip),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x48(%rbp),%rcx
cmp    %rcx,%rax
jae    1aca <cftmdl+0x9ca>
mov    -0x28(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x98(%rbp),%xmm1
movss  -0x88(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x74(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
subss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1751 <cftmdl+0x651>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0x8(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movss  0xc(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm1
movss  0x503(%rip),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  0x4d7(%rip),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x48(%rbp),%rdx
add    -0x60(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1ef8 <cftmdl+0xdf8>
mov    -0x28(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
subss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0x94(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x88(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
subss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
addss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x6c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x70(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x8c(%rbp),%xmm0
ff
addss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
subss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1b5e <cftmdl+0xa5e>
jmp    1efd <cftmdl+0xdfd>
mov    -0x68(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1677 <cftmdl+0x577>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cftmdl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,-0x70(%rsp)
mov    %rdi,-0x50(%rsp)
mov    %rsi,%rdi
lea    0x0(,%rsi,4),%r9
test   %rsi,%rsi
mov    %rsi,-0x78(%rsp)
je     1219 <cftmdl+0x119>
xor    %eax,%eax
nop
lea    (%rax,%rdi,1),%rsi
mov    -0x78(%rsp),%rcx
lea    (%rsi,%rcx,1),%rdi
mov    -0x78(%rsp),%rcx
add    %rdi,%rcx
lea    0x0(,%rax,4),%rbp
movss  (%rdx,%rax,4),%xmm8
movss  (%rdx,%rsi,4),%xmm2
movss  0x4(%rdx,%rsi,4),%xmm3
movaps %xmm8,%xmm4
addss  %xmm2,%xmm4
or     $0x4,%rbp
movss  (%rdx,%rbp,1),%xmm1
movaps %xmm1,%xmm5
addss  %xmm3,%xmm5
subss  %xmm2,%xmm8
subss  %xmm3,%xmm1
movss  (%rdx,%rdi,4),%xmm0
movss  0x4(%rdx,%rdi,4),%xmm3
movss  (%rdx,%rcx,4),%xmm6
movss  0x4(%rdx,%rcx,4),%xmm9
movaps %xmm0,%xmm2
addss  %xmm6,%xmm2
movaps %xmm3,%xmm7
addss  %xmm9,%xmm7
subss  %xmm6,%xmm0
subss  %xmm9,%xmm3
movaps %xmm4,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,(%rdx,%rax,4)
movaps %xmm5,%xmm6
addss  %xmm7,%xmm6
movss  %xmm6,(%rdx,%rbp,1)
subss  %xmm2,%xmm4
movss  %xmm4,(%rdx,%rdi,4)
subss  %xmm7,%xmm5
movss  %xmm5,0x4(%rdx,%rdi,4)
mov    -0x78(%rsp),%rdi
movaps %xmm8,%xmm2
subss  %xmm3,%xmm2
movss  %xmm2,(%rdx,%rsi,4)
movaps %xmm1,%xmm2
addss  %xmm0,%xmm2
movss  %xmm2,0x4(%rdx,%rsi,4)
addss  %xmm8,%xmm3
movss  %xmm3,(%rdx,%rcx,4)
subss  %xmm0,%xmm1
movss  %xmm1,0x4(%rdx,%rcx,4)
add    $0x2,%rax
cmp    %rdi,%rax
jb     1130 <cftmdl+0x30>
lea    (%rdi,%rdi,4),%r8
cmp    %r8,%r9
jae    136b <cftmdl+0x26b>
mov    -0x70(%rsp),%rax
movss  0x8(%rax),%xmm8
lea    (%rdx,%r9,4),%rcx
add    $0x4,%rcx
lea    0x4(%rdx,%r8,4),%rsi
mov    -0x78(%rsp),%rax
lea    (%rax,%rax,2),%rdi
lea    (%rdx,%rdi,8),%rdi
add    $0x4,%rdi
lea    (%rax,%rax,8),%rbp
lea    0x0(%rbp,%rbp,2),%rbp
add    %rax,%rbp
add    %rdx,%rbp
add    $0x4,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rcx,%rbx,4),%xmm10
movss  (%rcx,%rbx,4),%xmm9
movss  -0x4(%rsi,%rbx,4),%xmm3
movss  (%rsi,%rbx,4),%xmm4
movaps %xmm10,%xmm5
addss  %xmm3,%xmm5
movaps %xmm9,%xmm6
addss  %xmm4,%xmm6
subss  %xmm3,%xmm10
subss  %xmm4,%xmm9
movss  -0x4(%rdi,%rbx,4),%xmm3
movss  (%rdi,%rbx,4),%xmm2
movss  -0x4(%rbp,%rbx,4),%xmm7
movss  0x0(%rbp,%rbx,4),%xmm0
movaps %xmm3,%xmm1
addss  %xmm7,%xmm1
movaps %xmm2,%xmm4
addss  %xmm0,%xmm4
subss  %xmm7,%xmm3
subss  %xmm0,%xmm2
movaps %xmm5,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rcx,%rbx,4)
movaps %xmm6,%xmm0
addss  %xmm4,%xmm0
movss  %xmm0,(%rcx,%rbx,4)
subss  %xmm6,%xmm4
movss  %xmm4,-0x4(%rdi,%rbx,4)
subss  %xmm1,%xmm5
movss  %xmm5,(%rdi,%rbx,4)
movaps %xmm10,%xmm0
subss  %xmm2,%xmm0
movaps %xmm9,%xmm1
addss  %xmm3,%xmm1
movaps %xmm0,%xmm4
subss  %xmm1,%xmm4
mulss  %xmm8,%xmm4
movss  %xmm4,-0x4(%rsi,%rbx,4)
addss  %xmm0,%xmm1
mulss  %xmm8,%xmm1
movss  %xmm1,(%rsi,%rbx,4)
addss  %xmm10,%xmm2
subss  %xmm9,%xmm3
movaps %xmm3,%xmm0
subss  %xmm2,%xmm0
mulss  %xmm8,%xmm0
movss  %xmm0,-0x4(%rbp,%rbx,4)
addss  %xmm2,%xmm3
mulss  %xmm8,%xmm3
movss  %xmm3,0x0(%rbp,%rbx,4)
lea    (%r9,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    %r8,%rax
jb     1270 <cftmdl+0x170>
mov    %r9,-0x58(%rsp)
mov    -0x78(%rsp),%rdi
lea    0x0(,%rdi,8),%r9
cmp    -0x50(%rsp),%r9
jae    17e3 <cftmdl+0x6e3>
lea    (%rdx,%r9,4),%r10
add    $0x4,%r10
lea    (%rdi,%rdi,8),%rax
lea    (%rdx,%rax,4),%r11
add    $0x4,%r11
lea    (%rdx,%r8,8),%r15
add    $0x4,%r15
imul   $0x2c,%rdi,%rax
lea    (%rax,%rdx,1),%r12
add    $0x4,%r12
mov    -0x58(%rsp),%rax
lea    (%rax,%rax,2),%r14
lea    (%rdx,%r14,4),%r13
add    $0x4,%r13
imul   $0x34,%rdi,%rax
lea    (%rax,%rdx,1),%rbx
add    $0x4,%rbx
imul   $0x38,%rdi,%rax
add    %rdx,%rax
add    $0x4,%rax
imul   $0x3c,%rdi,%rcx
add    %rcx,%rdx
add    $0x4,%rdx
xor    %ecx,%ecx
mov    %rcx,-0x68(%rsp)
mov    %r9,%r8
xor    %esi,%esi
jmp    141c <cftmdl+0x31c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x60(%rsp),%rsi
add    $0x2,%rsi
add    %r9,%r8
add    %r9,-0x68(%rsp)
cmp    -0x50(%rsp),%r8
jae    17e3 <cftmdl+0x6e3>
mov    -0x70(%rsp),%rcx
movss  0x8(%rcx,%rsi,4),%xmm14
mov    %rsi,-0x60(%rsp)
movss  0xc(%rcx,%rsi,4),%xmm15
lea    (%r8,%rdi,1),%rbp
cmp    %rbp,%r8
jae    15f8 <cftmdl+0x4f8>
mov    -0x70(%rsp),%rcx
mov    -0x60(%rsp),%rsi
movss  0x10(%rcx,%rsi,8),%xmm11
movss  0x14(%rcx,%rsi,8),%xmm1
movaps %xmm15,%xmm13
addss  %xmm15,%xmm13
movaps %xmm13,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm11,%xmm6
subss  %xmm0,%xmm6
movaps %xmm1,%xmm2
movaps 0xb85(%rip),%xmm0
xorps  %xmm0,%xmm2
movaps %xmm2,-0x38(%rsp)
mulss  %xmm11,%xmm13
movaps %xmm1,-0x28(%rsp)
subss  %xmm1,%xmm13
movaps %xmm15,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,-0x48(%rsp)
movaps %xmm13,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,-0x18(%rsp)
mov    -0x68(%rsp),%rcx
nop
movss  -0x4(%r10,%rcx,4),%xmm12
movss  (%r10,%rcx,4),%xmm2
movss  -0x4(%r11,%rcx,4),%xmm0
movss  (%r11,%rcx,4),%xmm5
movaps %xmm12,%xmm1
addss  %xmm0,%xmm1
movaps %xmm2,%xmm7
addss  %xmm5,%xmm7
subss  %xmm0,%xmm12
subss  %xmm5,%xmm2
movss  -0x4(%r15,%rcx,4),%xmm10
movss  (%r15,%rcx,4),%xmm0
movss  -0x4(%r12,%rcx,4),%xmm8
movss  (%r12,%rcx,4),%xmm9
movaps %xmm10,%xmm5
addss  %xmm8,%xmm5
subss  %xmm8,%xmm10
movaps %xmm0,%xmm3
addss  %xmm9,%xmm3
subss  %xmm9,%xmm0
movaps %xmm1,%xmm4
addss  %xmm5,%xmm4
movss  %xmm4,-0x4(%r10,%rcx,4)
movaps %xmm7,%xmm4
addss  %xmm3,%xmm4
movss  %xmm4,(%r10,%rcx,4)
subss  %xmm5,%xmm1
subss  %xmm3,%xmm7
movaps %xmm14,%xmm3
mulss  %xmm7,%xmm3
mulss  -0x48(%rsp),%xmm7
movaps %xmm14,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm7,%xmm4
movss  %xmm4,-0x4(%r15,%rcx,4)
mulss  %xmm15,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%r15,%rcx,4)
movaps %xmm12,%xmm1
subss  %xmm0,%xmm1
movaps %xmm2,%xmm3
addss  %xmm10,%xmm3
movaps %xmm11,%xmm4
mulss  %xmm3,%xmm4
mulss  -0x38(%rsp),%xmm3
movaps %xmm11,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,-0x4(%r11,%rcx,4)
mulss  -0x28(%rsp),%xmm1
addss  %xmm4,%xmm1
movss  %xmm1,(%r11,%rcx,4)
addss  %xmm12,%xmm0
subss  %xmm10,%xmm2
movaps %xmm6,%xmm1
mulss  %xmm2,%xmm1
mulss  -0x18(%rsp),%xmm2
movaps %xmm6,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x4(%r12,%rcx,4)
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rcx,4)
lea    (%r9,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    %rbp,%rsi
jb     14b0 <cftmdl+0x3b0>
mov    -0x58(%rsp),%rcx
add    %r8,%rcx
lea    (%rcx,%rdi,1),%rbp
cmp    %rbp,%rcx
jae    1400 <cftmdl+0x300>
mov    -0x60(%rsp),%rcx
add    %rcx,%rcx
add    $0x4,%rcx
shl    $0x2,%rcx
mov    %rcx,%rsi
or     $0x8,%rsi
mov    -0x70(%rsp),%rdi
movss  (%rdi,%rsi,1),%xmm8
or     $0xc,%rcx
movss  (%rdi,%rcx,1),%xmm1
mov    -0x78(%rsp),%rdi
movaps %xmm14,%xmm13
addss  %xmm14,%xmm13
movaps %xmm13,%xmm0
mulss  %xmm1,%xmm0
movaps %xmm8,%xmm6
subss  %xmm0,%xmm6
movaps %xmm1,%xmm2
movaps 0x9a0(%rip),%xmm0
xorps  %xmm0,%xmm2
movaps %xmm2,-0x38(%rsp)
mulss  %xmm8,%xmm13
movaps %xmm1,-0x28(%rsp)
subss  %xmm1,%xmm13
xorps  %xmm0,%xmm15
movaps %xmm14,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,-0x48(%rsp)
movaps %xmm13,%xmm12
xorps  %xmm0,%xmm12
mov    -0x68(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%r13,%rcx,4),%xmm11
movss  0x0(%r13,%rcx,4),%xmm7
movss  -0x4(%rbx,%rcx,4),%xmm0
movss  (%rbx,%rcx,4),%xmm5
movaps %xmm11,%xmm4
addss  %xmm0,%xmm4
movaps %xmm7,%xmm2
addss  %xmm5,%xmm2
subss  %xmm0,%xmm11
subss  %xmm5,%xmm7
movss  -0x4(%rax,%rcx,4),%xmm10
movss  (%rax,%rcx,4),%xmm0
movss  -0x4(%rdx,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm9
movaps %xmm10,%xmm5
addss  %xmm3,%xmm5
subss  %xmm3,%xmm10
movaps %xmm0,%xmm3
addss  %xmm9,%xmm3
subss  %xmm9,%xmm0
movaps %xmm4,%xmm1
addss  %xmm5,%xmm1
movss  %xmm1,-0x4(%r13,%rcx,4)
movaps %xmm2,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,0x0(%r13,%rcx,4)
subss  %xmm5,%xmm4
subss  %xmm3,%xmm2
movaps %xmm15,%xmm1
mulss  %xmm2,%xmm1
mulss  -0x48(%rsp),%xmm2
movaps %xmm15,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x4(%rax,%rcx,4)
mulss  %xmm14,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%rax,%rcx,4)
movaps %xmm11,%xmm1
subss  %xmm0,%xmm1
movaps %xmm7,%xmm2
addss  %xmm10,%xmm2
movaps %xmm8,%xmm3
mulss  %xmm2,%xmm3
mulss  -0x38(%rsp),%xmm2
movaps %xmm8,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,-0x4(%rbx,%rcx,4)
mulss  -0x28(%rsp),%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
addss  %xmm11,%xmm0
subss  %xmm10,%xmm7
movaps %xmm6,%xmm1
mulss  %xmm7,%xmm1
mulss  %xmm12,%xmm7
movaps %xmm6,%xmm2
mulss  %xmm0,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,-0x4(%rdx,%rcx,4)
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rdx,%rcx,4)
lea    (%r14,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    %rbp,%rsi
jb     16a0 <cftmdl+0x5a0>
jmp    1400 <cftmdl+0x300>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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