int fittraj(steps, coef, nstep, ncoef)
int nstep, ncoef;
float steps[], coef[];
{
  float deltaco[6];
  float derivs[2 * 6];
  float normal[6][6];
  float jacobean[2 * 6][6];
  float xold;
  float x, xc, xs, xxs;
  float beta, betad, thestep;
  int i, j, k, iter;
  coef[0] = steps[0];
  coef[1] = 0.;
  coef[1] = 0.3;
  coef[2] = .01;
  coef[2] = .0;
  coef[3] = 0.1;
  coef[4] = .0;
  coef[5] = .01;
  xold = 10e10;
  for (iter = 0; iter < 64; iter++) {
    x = 0.;
    for (i = 0; i < nstep; i++) {
      xxs = sin(coef[5] * i);
      xc = cos(coef[1] * i + coef[4] * xxs);
      xs = sin(coef[1] * i + coef[4] * xxs);
      jacobean[i][0] = 1;
      jacobean[i][1] = (-coef[2] * xs + coef[3] * xc) * i;
      jacobean[i][2] = xc;
      jacobean[i][3] = xs;
      jacobean[i][4] = (-coef[2] * xs + coef[3] * xc) * xxs;
      jacobean[i][5] =
          i * cos(coef[5] * i) * coef[4] * (-coef[2] * xs + coef[3] * xc);
      derivs[i] = coef[0] + coef[2] * xc + coef[3] * xs;
      derivs[i] = steps[i] - derivs[i];
      x += derivs[i] * derivs[i];
    }
    for (i = 0; i < ncoef; i++) {
      deltaco[i] = 0.;
      for (j = 0; j < ncoef; j++) {
        normal[i][j] = 0.;
      }
    }
    for (i = 0; i < ncoef; i++) {
      for (j = 0; j < ncoef; j++) {
        for (k = 0; k < nstep; k++) {
          normal[i][j] += jacobean[k][i] * jacobean[k][j];
        }
      }
      for (k = 0; k < nstep; k++) {
        deltaco[i] -= jacobean[k][i] * derivs[k];
      }
      normal[i][i] += .1;
    }
    mom_solve(&normal[0][0], &deltaco[0], 6, 6);
    coef[0] -= deltaco[0];
    coef[1] -= deltaco[1];
    coef[2] -= deltaco[2];
    coef[3] -= deltaco[3];
    coef[4] -= deltaco[4];
    coef[5] -= deltaco[5];
    if (x < 1.e-7)
      break;
    if (fabs(x - xold) < 1.e-9)
      break;
    xold = x;
  }
}


x86 assembly (clang, -O0):
<fittraj>:
push   %rbp
mov    %rsp,%rbp
sub    $0x260,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0xe9b(%rip),%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0xe82(%rip),%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0xe69(%rip),%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movss  0xe48(%rip),%xmm0
movss  %xmm0,0x14(%rax)
movss  0xe37(%rip),%xmm0
movss  %xmm0,-0x224(%rbp)
ff
movl   $0x0,-0x250(%rbp)
cmpl   $0x40,-0x250(%rbp)
jge    189c <fittraj+0x76c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x228(%rbp)
ff
movl   $0x0,-0x244(%rbp)
mov    -0x244(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1531 <fittraj+0x401>
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtsi2ssl -0x244(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x234(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtsi2ssl -0x244(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mulss  -0x234(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x22c(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtsi2ssl -0x244(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mulss  -0x234(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x230(%rbp)
ff
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  0xd3f(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x230(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  -0x22c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtsi2ssl -0x244(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x4(%rax)
movss  -0x22c(%rbp),%xmm0
ff
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x8(%rax)
movss  -0x230(%rbp),%xmm0
ff
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x230(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm1
mulss  -0x22c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x234(%rbp),%xmm0
ff
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x10(%rax)
cvtsi2sdl -0x244(%rbp),%xmm0
ff
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtsi2ssl -0x244(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x258(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x230(%rbp),%xmm3
ff
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mulss  -0x22c(%rbp),%xmm2
ff
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x244(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x14(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x22c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x230(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x244(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x244(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x244(%rbp),%rax
subss  -0x70(%rbp,%rax,4),%xmm0
movslq -0x244(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x244(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movslq -0x244(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm2
movss  -0x228(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x228(%rbp)
ff
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    11fd <fittraj+0xcd>
movl   $0x0,-0x244(%rbp)
mov    -0x244(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15c4 <fittraj+0x494>
movslq -0x244(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
movl   $0x0,-0x248(%rbp)
mov    -0x248(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15ab <fittraj+0x47b>
movslq -0x244(%rbp),%rcx
lea    -0x100(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x248(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x248(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x248(%rbp)
jmp    1564 <fittraj+0x434>
jmp    15b0 <fittraj+0x480>
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    153b <fittraj+0x40b>
movl   $0x0,-0x244(%rbp)
mov    -0x244(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    177e <fittraj+0x64e>
movl   $0x0,-0x248(%rbp)
mov    -0x248(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    16ac <fittraj+0x57c>
movl   $0x0,-0x24c(%rbp)
mov    -0x24c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1693 <fittraj+0x563>
movslq -0x24c(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x244(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24c(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x248(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x244(%rbp),%rcx
lea    -0x100(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x248(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24c(%rbp)
jmp    1600 <fittraj+0x4d0>
jmp    1698 <fittraj+0x568>
mov    -0x248(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x248(%rbp)
jmp    15e7 <fittraj+0x4b7>
movl   $0x0,-0x24c(%rbp)
mov    -0x24c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1730 <fittraj+0x600>
movslq -0x24c(%rbp),%rcx
lea    -0x220(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x244(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x24c(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm2
movslq -0x244(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
mov    -0x24c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24c(%rbp)
jmp    16b6 <fittraj+0x586>
movslq -0x244(%rbp),%rcx
lea    -0x100(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x244(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8cb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x244(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x244(%rbp)
jmp    15ce <fittraj+0x49e>
lea    -0x100(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    $0x6,%ecx
mov    %ecx,%edx
mov    $0x0,%al
call   1040 <mom_solve@plt>
movss  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x30(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x2c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x228(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x7e5(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1842 <fittraj+0x712>
jmp    189c <fittraj+0x76c>
movss  -0x228(%rbp),%xmm0
ff
subss  -0x224(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x7d3(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x7b7(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1878 <fittraj+0x748>
jmp    189c <fittraj+0x76c>
movss  -0x228(%rbp),%xmm0
ff
movss  %xmm0,-0x224(%rbp)
ff
mov    -0x250(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
jmp    11db <fittraj+0xab>
mov    -0x4(%rbp),%eax
add    $0x260,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fittraj>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x278,%rsp
mov    %ecx,%r13d
mov    %edx,%r12d
mov    %rdi,0x88(%rsp)
movss  (%rdi),%xmm0
movss  %xmm0,(%rsi)
movaps 0xe92(%rip),%xmm0
movups %xmm0,0x4(%rsi)
movl   $0x3c23d70a,0x14(%rsi)
mov    %ecx,%r14d
lea    0x0(,%r14,4),%rax
mov    %rax,0x70(%rsp)
mov    %edx,%r15d
mov    %r15,0x68(%rsp)
lea    -0x1(%r14),%rax
mov    %rax,0x60(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x28(%rsp)
mov    %r14d,%eax
and    $0x7,%eax
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x80(%rsp)
and    $0xfffffffe,%r15d
mov    %rax,0x58(%rsp)
lea    0x0(,%rax,8),%rax
lea    (%rax,%rax,2),%rax
mov    %rax,0x50(%rsp)
movss  0xe47(%rip),%xmm0
movss  %xmm0,0x18(%rsp)
movss  0xe3d(%rip),%xmm0
movl   $0x0,0x14(%rsp)
mov    %r13d,0x10(%rsp)
mov    %rsi,0x78(%rsp)
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
test   %r12d,%r12d
jle    13c5 <fittraj+0x285>
lea    0x164(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%r13
xorps  %xmm2,%xmm2
cvtsi2ss %ebp,%xmm2
movss  %xmm2,0x8(%rsp)
movss  %xmm1,0x24(%rsp)
mulss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  %xmm1,(%rsp)
movss  0x10(%r13),%xmm0
mulss  %xmm1,%xmm0
movss  0x4(%r13),%xmm1
mulss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
call   1060 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x10(%r13),%xmm0
mulss  (%rsp),%xmm0
movss  0x4(%r13),%xmm1
mulss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
call   1040 <sin@plt>
xorps  %xmm4,%xmm4
cvtsd2ss %xmm0,%xmm4
movss  %xmm4,0x20(%rsp)
movl   $0x3f800000,-0x14(%rbx)
movss  0xc(%r13),%xmm0
movss  0x1c(%rsp),%xmm2
mulss  %xmm2,%xmm0
movss  0x8(%r13),%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm0
movaps %xmm0,%xmm1
movss  0x8(%rsp),%xmm3
mulss  %xmm3,%xmm1
movss  %xmm1,-0x10(%rbx)
movss  %xmm2,-0xc(%rbx)
movss  %xmm4,-0x8(%rbx)
mulss  (%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
movsd  %xmm1,(%rsp)
movss  %xmm0,-0x4(%rbx)
mulss  0x14(%r13),%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
call   1060 <cos@plt>
mulsd  (%rsp),%xmm0
movss  0x10(%r13),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movss  0x8(%r13),%xmm0
movss  0xc(%r13),%xmm2
movaps %xmm2,%xmm3
movss  0x1c(%rsp),%xmm6
mulss  %xmm6,%xmm3
movaps %xmm0,%xmm4
movss  0x20(%rsp),%xmm5
mulss  %xmm5,%xmm4
subss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%rbx)
mulss  %xmm6,%xmm0
addss  0x0(%r13),%xmm0
mulss  %xmm5,%xmm2
addss  %xmm0,%xmm2
mov    0x88(%rsp),%rax
movss  (%rax,%rbp,4),%xmm1
subss  %xmm2,%xmm1
movss  %xmm1,0x90(%rsp,%rbp,4)
mulss  %xmm1,%xmm1
addss  0x24(%rsp),%xmm1
cmp    %rbp,0x28(%rsp)
je     13c0 <fittraj+0x280>
mov    %r13,%rsi
movss  0x14(%r13),%xmm0
add    $0x18,%rbx
add    $0x1,%rbp
jmp    1220 <fittraj+0xe0>
nop
mov    0x10(%rsp),%r13d
movss  %xmm1,(%rsp)
test   %r13d,%r13d
jle    16d0 <fittraj+0x590>
lea    0x30(%rsp),%rdi
xor    %esi,%esi
mov    0x70(%rsp),%rbp
mov    %rbp,%rdx
call   1030 <memset@plt>
cmpq   $0x7,0x60(%rsp)
jae    1400 <fittraj+0x2c0>
xor    %ebx,%ebx
jmp    149e <fittraj+0x35e>
cs nopw 0x0(%rax,%rax,1)
lea    0xc0(%rsp),%r13
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x18(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x30(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x48(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x60(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x78(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0x90(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    0xa8(%r13),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
add    $0x8,%rbx
add    $0xc0,%r13
cmp    %rbx,0x80(%rsp)
jne    1410 <fittraj+0x2d0>
cmpq   $0x0,0x58(%rsp)
mov    0x50(%rsp),%r13
je     14ef <fittraj+0x3af>
mov    %rbp,%rdx
lea    (%rbx,%rbx,2),%rax
lea    (%rsp,%rax,8),%rax
add    $0xc0,%rax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
xor    %esi,%esi
mov    %rdx,%rbx
call   1030 <memset@plt>
mov    %rbx,%rdx
add    $0x18,%rbp
cmp    %rbp,%r13
jne    14d0 <fittraj+0x390>
mov    0x10(%rsp),%r13d
test   %r13d,%r13d
mov    0x68(%rsp),%r9
mov    0x28(%rsp),%rax
movsd  0xb1f(%rip),%xmm3
lea    0x150(%rsp),%r10
jle    16d0 <fittraj+0x590>
mov    %r10,%r8
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1560 <fittraj+0x420>
movss  %xmm0,0x30(%rsp,%rdx,4)
lea    (%rdx,%rdx,2),%rsi
lea    (%rsp,%rsi,8),%rsi
add    $0xc0,%rsi
movss  (%rsi,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0x4,%rcx
add    $0x4,%r8
cmp    %r14,%rdx
je     16d0 <fittraj+0x590>
xor    %esi,%esi
jmp    1585 <fittraj+0x445>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdi,%rsi,4),%rdi
movss  %xmm0,(%rdi)
add    $0x1,%rsi
cmp    %r14,%rsi
je     1640 <fittraj+0x500>
test   %r12d,%r12d
jle    15f0 <fittraj+0x4b0>
lea    (%rdx,%rdx,2),%rdi
lea    (%rsp,%rdi,8),%rdi
add    $0xc0,%rdi
movss  (%rdi,%rsi,4),%xmm0
test   %rax,%rax
je     1600 <fittraj+0x4c0>
mov    %r10,%rbx
xor    %ebp,%ebp
movaps %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,1),%xmm2
mulss  (%rbx,%rsi,4),%xmm2
movss  0x18(%rbx,%rcx,1),%xmm0
addss  %xmm1,%xmm2
mulss  0x18(%rbx,%rsi,4),%xmm0
addss  %xmm2,%xmm0
add    $0x2,%rbp
add    $0x30,%rbx
movaps %xmm0,%xmm1
cmp    %rbp,%r15
jne    15b0 <fittraj+0x470>
test   $0x1,%r9b
je     1570 <fittraj+0x430>
jmp    160c <fittraj+0x4cc>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r14,%rsi
jne    1585 <fittraj+0x445>
jmp    1526 <fittraj+0x3e6>
xchg   %ax,%ax
xor    %ebp,%ebp
test   $0x1,%r9b
je     1570 <fittraj+0x430>
lea    0x0(%rbp,%rbp,2),%rbp
lea    (%rsp,%rbp,8),%rbp
add    $0x150,%rbp
movss  0x0(%rbp,%rdx,4),%xmm1
mulss  0x0(%rbp,%rsi,4),%xmm1
addss  %xmm1,%xmm0
jmp    1570 <fittraj+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r12d,%r12d
jle    1526 <fittraj+0x3e6>
movss  0x30(%rsp,%rdx,4),%xmm0
test   %rax,%rax
je     169c <fittraj+0x55c>
mov    %r8,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movss  (%rdi),%xmm1
mulss  0x90(%rsp,%rsi,4),%xmm1
movss  0x18(%rdi),%xmm2
subss  %xmm1,%xmm0
mulss  0x94(%rsp,%rsi,4),%xmm2
subss  %xmm2,%xmm0
add    $0x2,%rsi
add    $0x30,%rdi
cmp    %rsi,%r15
jne    1660 <fittraj+0x520>
test   $0x1,%r9b
je     1520 <fittraj+0x3e0>
jmp    16a8 <fittraj+0x568>
xor    %esi,%esi
test   $0x1,%r9b
je     1520 <fittraj+0x3e0>
lea    (%rsi,%rsi,2),%rdi
lea    (%rsp,%rdi,8),%rdi
add    $0x150,%rdi
movss  (%rdi,%rdx,4),%xmm1
mulss  0x90(%rsp,%rsi,4),%xmm1
subss  %xmm1,%xmm0
jmp    1520 <fittraj+0x3e0>
xchg   %ax,%ax
lea    0xc0(%rsp),%rdi
lea    0x30(%rsp),%rsi
mov    $0x6,%edx
mov    $0x6,%ecx
xor    %eax,%eax
call   1050 <mom_solve@plt>
mov    0x78(%rsp),%rsi
movups (%rsi),%xmm0
subps  0x30(%rsp),%xmm0
movups %xmm0,(%rsi)
movss  0x10(%rsi),%xmm0
subss  0x40(%rsp),%xmm0
movss  %xmm0,0x10(%rsi)
movss  0x14(%rsi),%xmm0
subss  0x44(%rsp),%xmm0
movss  %xmm0,0x14(%rsi)
movss  (%rsp),%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movsd  0x8fe(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     1774 <fittraj+0x634>
movaps %xmm3,%xmm1
subss  0x18(%rsp),%xmm1
andps  0x8c8(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x8e4(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     1774 <fittraj+0x634>
mov    0x14(%rsp),%eax
add    $0x1,%eax
movss  %xmm3,0x18(%rsp)
mov    %eax,0x14(%rsp)
cmp    $0x40,%eax
jne    1200 <fittraj+0xc0>
add    $0x278,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @fittraj(float* %0, float* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca [6 x float]
%11 = alloca [12 x float]
%12 = alloca [6 x [6 x float]]
%13 = alloca [12 x [6 x float]]
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%26 = load float*, float** %6
%27 = getelementptr inbounds float, float* %26, i64 0
%28 = load float, float* %27
%29 = load float*, float** %7
%30 = getelementptr inbounds float, float* %29, i64 0
store float %28, float* %30
%31 = load float*, float** %7
%32 = getelementptr inbounds float, float* %31, i64 1
store float 0.000000e+00, float* %32
%33 = load float*, float** %7
%34 = getelementptr inbounds float, float* %33, i64 1
store float 0x3FD3333340000000, float* %34
%35 = load float*, float** %7
%36 = getelementptr inbounds float, float* %35, i64 2
store float 0x3F847AE140000000, float* %36
%37 = load float*, float** %7
%38 = getelementptr inbounds float, float* %37, i64 2
store float 0.000000e+00, float* %38
%39 = load float*, float** %7
%40 = getelementptr inbounds float, float* %39, i64 3
store float 0x3FB99999A0000000, float* %40
%41 = load float*, float** %7
%42 = getelementptr inbounds float, float* %41, i64 4
store float 0.000000e+00, float* %42
%43 = load float*, float** %7
%44 = getelementptr inbounds float, float* %43, i64 5
store float 0x3F847AE140000000, float* %44
store float 0x42374876E0000000, float* %14
store i32 0, i32* %25
br label %45
45: ; preds = %383, %4
%46 = load i32, i32* %25
%47 = icmp slt i32 %46, 64
br i1 %47, label %48, label %386
48: ; preds = %45
store float 0.000000e+00, float* %15
store i32 0, i32* %22
br label %49
49: ; preds = %213, %48
%50 = load i32, i32* %22
%51 = load i32, i32* %8
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %216
53: ; preds = %49
%54 = load float*, float** %7
%55 = getelementptr inbounds float, float* %54, i64 5
%56 = load float, float* %55
%57 = load i32, i32* %22
%58 = sitofp i32 %57 to float
%59 = fmul float %56, %58
%60 = fpext float %59 to double
%61 = call double @sin(double %60)
%62 = fptrunc double %61 to float
store float %62, float* %18
%63 = load float*, float** %7
%64 = getelementptr inbounds float, float* %63, i64 1
%65 = load float, float* %64
%66 = load i32, i32* %22
%67 = sitofp i32 %66 to float
%68 = load float*, float** %7
%69 = getelementptr inbounds float, float* %68, i64 4
%70 = load float, float* %69
%71 = load float, float* %18
%72 = fmul float %70, %71
%73 = call float @llvm.fmuladd.f32(float %65, float %67, float %72)
%74 = fpext float %73 to double
%75 = call double @cos(double %74)
%76 = fptrunc double %75 to float
store float %76, float* %16
%77 = load float*, float** %7
%78 = getelementptr inbounds float, float* %77, i64 1
%79 = load float, float* %78
%80 = load i32, i32* %22
%81 = sitofp i32 %80 to float
%82 = load float*, float** %7
%83 = getelementptr inbounds float, float* %82, i64 4
%84 = load float, float* %83
%85 = load float, float* %18
%86 = fmul float %84, %85
%87 = call float @llvm.fmuladd.f32(float %79, float %81, float %86)
%88 = fpext float %87 to double
%89 = call double @sin(double %88)
%90 = fptrunc double %89 to float
store float %90, float* %17
%91 = load i32, i32* %22
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %92
%94 = getelementptr inbounds [6 x float], [6 x float]* %93, i64 0, i64 0
store float 1.000000e+00, float* %94
%95 = load float*, float** %7
%96 = getelementptr inbounds float, float* %95, i64 2
%97 = load float, float* %96
%98 = fneg float %97
%99 = load float, float* %17
%100 = load float*, float** %7
%101 = getelementptr inbounds float, float* %100, i64 3
%102 = load float, float* %101
%103 = load float, float* %16
%104 = fmul float %102, %103
%105 = call float @llvm.fmuladd.f32(float %98, float %99, float %104)
%106 = load i32, i32* %22
%107 = sitofp i32 %106 to float
%108 = fmul float %105, %107
%109 = load i32, i32* %22
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %110
%112 = getelementptr inbounds [6 x float], [6 x float]* %111, i64 0, i64 1
store float %108, float* %112
%113 = load float, float* %16
%114 = load i32, i32* %22
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %115
%117 = getelementptr inbounds [6 x float], [6 x float]* %116, i64 0, i64 2
store float %113, float* %117
%118 = load float, float* %17
%119 = load i32, i32* %22
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %120
%122 = getelementptr inbounds [6 x float], [6 x float]* %121, i64 0, i64 3
store float %118, float* %122
%123 = load float*, float** %7
%124 = getelementptr inbounds float, float* %123, i64 2
%125 = load float, float* %124
%126 = fneg float %125
%127 = load float, float* %17
%128 = load float*, float** %7
%129 = getelementptr inbounds float, float* %128, i64 3
%130 = load float, float* %129
%131 = load float, float* %16
%132 = fmul float %130, %131
%133 = call float @llvm.fmuladd.f32(float %126, float %127, float %132)
%134 = load float, float* %18
%135 = fmul float %133, %134
%136 = load i32, i32* %22
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %137
%139 = getelementptr inbounds [6 x float], [6 x float]* %138, i64 0, i64 4
store float %135, float* %139
%140 = load i32, i32* %22
%141 = sitofp i32 %140 to double
%142 = load float*, float** %7
%143 = getelementptr inbounds float, float* %142, i64 5
%144 = load float, float* %143
%145 = load i32, i32* %22
%146 = sitofp i32 %145 to float
%147 = fmul float %144, %146
%148 = fpext float %147 to double
%149 = call double @cos(double %148)
%150 = fmul double %141, %149
%151 = load float*, float** %7
%152 = getelementptr inbounds float, float* %151, i64 4
%153 = load float, float* %152
%154 = fpext float %153 to double
%155 = fmul double %150, %154
%156 = load float*, float** %7
%157 = getelementptr inbounds float, float* %156, i64 2
%158 = load float, float* %157
%159 = fneg float %158
%160 = load float, float* %17
%161 = load float*, float** %7
%162 = getelementptr inbounds float, float* %161, i64 3
%163 = load float, float* %162
%164 = load float, float* %16
%165 = fmul float %163, %164
%166 = call float @llvm.fmuladd.f32(float %159, float %160, float %165)
%167 = fpext float %166 to double
%168 = fmul double %155, %167
%169 = fptrunc double %168 to float
%170 = load i32, i32* %22
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %171
%173 = getelementptr inbounds [6 x float], [6 x float]* %172, i64 0, i64 5
store float %169, float* %173
%174 = load float*, float** %7
%175 = getelementptr inbounds float, float* %174, i64 0
%176 = load float, float* %175
%177 = load float*, float** %7
%178 = getelementptr inbounds float, float* %177, i64 2
%179 = load float, float* %178
%180 = load float, float* %16
%181 = call float @llvm.fmuladd.f32(float %179, float %180, float %176)
%182 = load float*, float** %7
%183 = getelementptr inbounds float, float* %182, i64 3
%184 = load float, float* %183
%185 = load float, float* %17
%186 = call float @llvm.fmuladd.f32(float %184, float %185, float %181)
%187 = load i32, i32* %22
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %188
store float %186, float* %189
%190 = load float*, float** %6
%191 = load i32, i32* %22
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %190, i64 %192
%194 = load float, float* %193
%195 = load i32, i32* %22
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %196
%198 = load float, float* %197
%199 = fsub float %194, %198
%200 = load i32, i32* %22
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %201
store float %199, float* %202
%203 = load i32, i32* %22
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %204
%206 = load float, float* %205
%207 = load i32, i32* %22
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %208
%210 = load float, float* %209
%211 = load float, float* %15
%212 = call float @llvm.fmuladd.f32(float %206, float %210, float %211)
store float %212, float* %15
br label %213
213: ; preds = %53
%214 = load i32, i32* %22
%215 = add nsw i32 %214, 1
store i32 %215, i32* %22
br label %49
216: ; preds = %49
store i32 0, i32* %22
br label %217
217: ; preds = %240, %216
%218 = load i32, i32* %22
%219 = load i32, i32* %9
%220 = icmp slt i32 %218, %219
br i1 %220, label %221, label %243
221: ; preds = %217
%222 = load i32, i32* %22
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 %223
store float 0.000000e+00, float* %224
store i32 0, i32* %23
br label %225
225: ; preds = %236, %221
%226 = load i32, i32* %23
%227 = load i32, i32* %9
%228 = icmp slt i32 %226, %227
br i1 %228, label %229, label %239
229: ; preds = %225
%230 = load i32, i32* %22
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [6 x [6 x float]], [6 x [6 x float]]* %12, i64 0, i64 %231
%233 = load i32, i32* %23
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [6 x float], [6 x float]* %232, i64 0, i64 %234
store float 0.000000e+00, float* %235
br label %236
236: ; preds = %229
%237 = load i32, i32* %23
%238 = add nsw i32 %237, 1
store i32 %238, i32* %23
br label %225
239: ; preds = %225
br label %240
240: ; preds = %239
%241 = load i32, i32* %22
%242 = add nsw i32 %241, 1
store i32 %242, i32* %22
br label %217
243: ; preds = %217
store i32 0, i32* %22
br label %244
244: ; preds = %325, %243
%245 = load i32, i32* %22
%246 = load i32, i32* %9
%247 = icmp slt i32 %245, %246
br i1 %247, label %248, label %328
248: ; preds = %244
store i32 0, i32* %23
br label %249
249: ; preds = %285, %248
%250 = load i32, i32* %23
%251 = load i32, i32* %9
%252 = icmp slt i32 %250, %251
br i1 %252, label %253, label %288
253: ; preds = %249
store i32 0, i32* %24
br label %254
254: ; preds = %281, %253
%255 = load i32, i32* %24
%256 = load i32, i32* %8
%257 = icmp slt i32 %255, %256
br i1 %257, label %258, label %284
258: ; preds = %254
%259 = load i32, i32* %24
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %260
%262 = load i32, i32* %22
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [6 x float], [6 x float]* %261, i64 0, i64 %263
%265 = load float, float* %264
%266 = load i32, i32* %24
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %267
%269 = load i32, i32* %23
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [6 x float], [6 x float]* %268, i64 0, i64 %270
%272 = load float, float* %271
%273 = load i32, i32* %22
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [6 x [6 x float]], [6 x [6 x float]]* %12, i64 0, i64 %274
%276 = load i32, i32* %23
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds [6 x float], [6 x float]* %275, i64 0, i64 %277
%279 = load float, float* %278
%280 = call float @llvm.fmuladd.f32(float %265, float %272, float %279)
store float %280, float* %278
br label %281
281: ; preds = %258
%282 = load i32, i32* %24
%283 = add nsw i32 %282, 1
store i32 %283, i32* %24
br label %254
284: ; preds = %254
br label %285
285: ; preds = %284
%286 = load i32, i32* %23
%287 = add nsw i32 %286, 1
store i32 %287, i32* %23
br label %249
288: ; preds = %249
store i32 0, i32* %24
br label %289
289: ; preds = %311, %288
%290 = load i32, i32* %24
%291 = load i32, i32* %8
%292 = icmp slt i32 %290, %291
br i1 %292, label %293, label %314
293: ; preds = %289
%294 = load i32, i32* %24
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [12 x [6 x float]], [12 x [6 x float]]* %13, i64 0, i64 %295
%297 = load i32, i32* %22
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [6 x float], [6 x float]* %296, i64 0, i64 %298
%300 = load float, float* %299
%301 = load i32, i32* %24
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds [12 x float], [12 x float]* %11, i64 0, i64 %302
%304 = load float, float* %303
%305 = load i32, i32* %22
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 %306
%308 = load float, float* %307
%309 = fneg float %300
%310 = call float @llvm.fmuladd.f32(float %309, float %304, float %308)
store float %310, float* %307
br label %311
311: ; preds = %293
%312 = load i32, i32* %24
%313 = add nsw i32 %312, 1
store i32 %313, i32* %24
br label %289
314: ; preds = %289
%315 = load i32, i32* %22
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds [6 x [6 x float]], [6 x [6 x float]]* %12, i64 0, i64 %316
%318 = load i32, i32* %22
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [6 x float], [6 x float]* %317, i64 0, i64 %319
%321 = load float, float* %320
%322 = fpext float %321 to double
%323 = fadd double %322, 1.000000e-01
%324 = fptrunc double %323 to float
store float %324, float* %320
br label %325
325: ; preds = %314
%326 = load i32, i32* %22
%327 = add nsw i32 %326, 1
store i32 %327, i32* %22
br label %244
328: ; preds = %244
%329 = getelementptr inbounds [6 x [6 x float]], [6 x [6 x float]]* %12, i64 0, i64 0
%330 = getelementptr inbounds [6 x float], [6 x float]* %329, i64 0, i64 0
%331 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 0
%332 = call i32 (float*, float*, i32, i32, ...) bitcast (i32 (...)* @mom_solve to i32 (float*, float*, i32, i32, ...)*)(float* %330, float* %331, i32 6, i32 6)
%333 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 0
%334 = load float, float* %333
%335 = load float*, float** %7
%336 = getelementptr inbounds float, float* %335, i64 0
%337 = load float, float* %336
%338 = fsub float %337, %334
store float %338, float* %336
%339 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 1
%340 = load float, float* %339
%341 = load float*, float** %7
%342 = getelementptr inbounds float, float* %341, i64 1
%343 = load float, float* %342
%344 = fsub float %343, %340
store float %344, float* %342
%345 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 2
%346 = load float, float* %345
%347 = load float*, float** %7
%348 = getelementptr inbounds float, float* %347, i64 2
%349 = load float, float* %348
%350 = fsub float %349, %346
store float %350, float* %348
%351 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 3
%352 = load float, float* %351
%353 = load float*, float** %7
%354 = getelementptr inbounds float, float* %353, i64 3
%355 = load float, float* %354
%356 = fsub float %355, %352
store float %356, float* %354
%357 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 4
%358 = load float, float* %357
%359 = load float*, float** %7
%360 = getelementptr inbounds float, float* %359, i64 4
%361 = load float, float* %360
%362 = fsub float %361, %358
store float %362, float* %360
%363 = getelementptr inbounds [6 x float], [6 x float]* %10, i64 0, i64 5
%364 = load float, float* %363
%365 = load float*, float** %7
%366 = getelementptr inbounds float, float* %365, i64 5
%367 = load float, float* %366
%368 = fsub float %367, %364
store float %368, float* %366
%369 = load float, float* %15
%370 = fpext float %369 to double
%371 = fcmp olt double %370, 0x3E7AD7F29ABCAF48
br i1 %371, label %372, label %373
372: ; preds = %328
br label %386
373: ; preds = %328
%374 = load float, float* %15
%375 = load float, float* %14
%376 = fsub float %374, %375
%377 = fpext float %376 to double
%378 = call double @llvm.fabs.f64(double %377)
%379 = fcmp olt double %378, 1.000000e-09
br i1 %379, label %380, label %381
380: ; preds = %373
br label %386
381: ; preds = %373
%382 = load float, float* %15
store float %382, float* %14
br label %383
383: ; preds = %381
%384 = load i32, i32* %25
%385 = add nsw i32 %384, 1
store i32 %385, i32* %25
br label %45
386: ; preds = %380, %372, %45
%387 = load i32, i32* %5
ret i32 %387
}

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