double llsfit(int N, double (*f)(double, int), int D, double x[], double y[],
              double w[], double A[], int order[], double WORK[]) {
  int d, n, m, mmax, RUN;
  double chi, nchi, inner, norm, isave, nsave;
  for (RUN = 0; RUN <= 1; RUN++) {
    for (n = 0; n < N; n++)
      order[n] = n;
    for (n = 0; n < N; n++) {
      for (d = 0; d < D; d++)
        WORK[D * order[n] + (d)] = (*f)(x[d], n);
    }
    for (d = 0; d < D; d++)
      WORK[D * (N + 1) + (d)] = y[d];
    if (RUN) {
      for (n = 0; n < N; n++)
        WORK[D * (N + 2) + N * (n) + (0)] =
            A[n] * A[n] *
            fdot(D, w, &WORK[D * order[n] + (0)], &WORK[D * order[n] + (0)]);
      for (n = 0; n < N; n++) {
        chi = WORK[D * (N + 2) + N * (order[n]) + (0)];
        mmax = n;
        for (m = n + 1; m < N; m++) {
          if (WORK[D * (N + 2) + N * (order[m]) + (0)] > chi) {
            mmax = m;
            chi = WORK[D * (N + 2) + N * (order[m]) + (0)];
          }
        }
        m = order[n];
        order[n] = order[mmax];
        order[mmax] = m;
      }
    }
    for (n = 0; n < N; n++) {
      if (!RUN) {
        mmax = n;
        chi = isave = nsave = 0.0;
        for (m = n; m < N; m++) {
          inner =
              fdot(D, w, &WORK[D * order[m] + (0)], &WORK[D * (N + 1) + (0)]);
          norm =
              fdot(D, w, &WORK[D * order[m] + (0)], &WORK[D * order[m] + (0)]);
          fortho(D, &WORK[D * (N) + (0)], &WORK[D * (N + 1) + (0)],
                 &WORK[D * order[m] + (0)], inner / norm);
          nchi = fdot(D, w, &WORK[D * (N) + (0)], &WORK[D * (N) + (0)]);
          if (!chi || (nchi < chi)) {
            chi = nchi;
            mmax = m;
            isave = inner;
            nsave = norm;
          }
        }
        m = order[n];
        order[n] = order[mmax];
        order[mmax] = m;
        inner = isave;
        norm = nsave;
      } else {
        inner = fdot(D, w, &WORK[D * order[n] + (0)], &WORK[D * (N + 1) + (0)]);
        norm = fdot(D, w, &WORK[D * order[n] + (0)], &WORK[D * order[n] + (0)]);
      }
      A[order[n]] = inner / norm;
      fortho(D, &WORK[D * (N + 1) + (0)], &WORK[D * (N + 1) + (0)],
             &WORK[D * order[n] + (0)], inner / norm);
      for (m = n + 1; m < N; m++) {
        inner =
            fdot(D, w, &WORK[D * order[n] + (0)], &WORK[D * order[m] + (0)]);
        WORK[D * (N + 2) + N * (order[m]) + (order[n])] = inner / norm;
        fortho(D, &WORK[D * order[m] + (0)], &WORK[D * order[m] + (0)],
               &WORK[D * order[n] + (0)], inner / norm);
      }
    }
    for (n = N - 1; n >= 0; n--)
      for (m = n + 1; m < N; m++)
        A[order[n]] -=
            WORK[D * (N + 2) + N * (order[m]) + (order[n])] * A[order[m]];
  }
  return sqrt(fdot(D, w, &WORK[D * (N + 1) + (0)], &WORK[D * (N + 1) + (0)]) /
              D);
}


x86 assembly (clang, -O0):
<llsfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x1,-0x44(%rbp)
jg     19fc <llsfit+0x8cc>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    119d <llsfit+0x6d>
mov    -0x38(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1175 <llsfit+0x45>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1218 <llsfit+0xe8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1205 <llsfit+0xd5>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x38(%rbp),%edi
call   *%rax
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    0x18(%rbp),%rdx
movslq -0x38(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b7 <llsfit+0x87>
jmp    120a <llsfit+0xda>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11a4 <llsfit+0x74>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1261 <llsfit+0x131>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121f <llsfit+0xef>
cmpl   $0x0,-0x44(%rbp)
je     144f <llsfit+0x31f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    132a <llsfit+0x1fa>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x38(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
movsd  -0x80(%rbp),%xmm0
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
imul   -0x38(%rbp),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1272 <llsfit+0x142>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    144a <llsfit+0x31a>
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x38(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    140a <llsfit+0x2da>
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    13f7 <llsfit+0x2c7>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    13fc <llsfit+0x2cc>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    137d <llsfit+0x24d>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1331 <llsfit+0x201>
jmp    144f <llsfit+0x31f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    191e <llsfit+0x7ee>
cmpl   $0x0,-0x44(%rbp)
jne    16a8 <llsfit+0x578>
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    165d <llsfit+0x52d>
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%r8d
add    $0x1,%r8d
imul   %r8d,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x3c(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%edi
mov    0x20(%rbp),%rsi
mov    -0x14(%rbp),%eax
imul   -0x4(%rbp),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x3c(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    $0x1,%al
call   1040 <fortho@plt>
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
imul   -0x4(%rbp),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
imul   -0x4(%rbp),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1612 <llsfit+0x4e2>
jp     1612 <llsfit+0x4e2>
jmp    1626 <llsfit+0x4f6>
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    164a <llsfit+0x51a>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    164f <llsfit+0x51f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1490 <llsfit+0x360>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1755 <llsfit+0x625>
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%r8d
add    $0x1,%r8d
imul   %r8d,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x38(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%edi
mov    0x20(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x38(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    $0x1,%al
call   1040 <fortho@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    190b <llsfit+0x7db>
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x3c(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
mov    0x18(%rbp),%rdx
movslq -0x38(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%edi
mov    0x20(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%r8
imul   (%rcx,%r8,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    0x18(%rbp),%r8
movslq -0x38(%rbp),%r9
imul   (%r8,%r9,4),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
movsd  -0x60(%rbp),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    $0x1,%al
call   1040 <fortho@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17e9 <llsfit+0x6b9>
jmp    1910 <llsfit+0x7e0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1456 <llsfit+0x326>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     19e9 <llsfit+0x8b9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    19d6 <llsfit+0x8a6>
mov    0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
imul   (%rsi,%rdi,4),%edx
add    %edx,%ecx
mov    0x18(%rbp),%rdx
movslq -0x38(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    193a <llsfit+0x80a>
jmp    19db <llsfit+0x8ab>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1927 <llsfit+0x7f7>
jmp    19ee <llsfit+0x8be>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1164 <llsfit+0x34>
mov    -0x14(%rbp),%edi
mov    -0x30(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    0x20(%rbp),%rcx
mov    -0x14(%rbp),%eax
mov    -0x4(%rbp),%r8d
add    $0x1,%r8d
imul   %r8d,%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    $0x0,%al
call   1030 <fdot@plt>
cltd
idivl  -0x14(%rbp)
cvtsi2sd %eax,%xmm0
call   1050 <sqrt@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<llsfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r8,%r13
lea    0x1(%rdi),%eax
imul   %edx,%eax
lea    0x2(%rdi),%r10d
imul   %edx,%r10d
movslq %eax,%r12
mov    %edx,%ebx
imul   %edi,%ebx
movslq %edi,%r11
mov    %r11d,%eax
mov    %edx,(%rsp)
mov    %edx,%r14d
mov    %rax,0x8(%rsp)
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    %rdx,0x108(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x100(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %r14d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,0xf8(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,0xf0(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %edx,%r8d
and    $0x3,%r8d
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0xb8(%rsp)
mov    0x1a0(%rsp),%r15
lea    (%r15,%r12,8),%rax
lea    0x0(,%r14,8),%rdx
add    %r13,%rdx
mov    %rax,0x48(%rsp)
cmp    %rdx,%rax
mov    %r12,0xd8(%rsp)
lea    (%r12,%r14,1),%rdx
lea    (%r15,%rdx,8),%rdx
setb   %al
cmp    %r13,%rdx
seta   %dl
mov    %rcx,0x78(%rsp)
mov    %rsi,0x138(%rsp)
mov    %r9,0x30(%rsp)
and    %al,%dl
mov    %dl,0x7(%rsp)
movslq %ebx,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0x140(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
and    $0xfffffffffffffffc,%rbp
mov    %rbp,0xb0(%rsp)
mov    %r14,0x98(%rsp)
and    $0x3,%r14d
mov    %r14,0x110(%rsp)
mov    %r8,0xe8(%rsp)
shl    $0x5,%r8
mov    %r8,0x88(%rsp)
mov    %rax,0xe0(%rsp)
shl    $0x5,%rax
mov    %rax,0x120(%rsp)
movslq %r10d,%rax
lea    (%r15,%rax,8),%rax
mov    %rax,0x118(%rsp)
mov    0x198(%rsp),%rax
mov    0x190(%rsp),%rcx
mov    %rcx,0x58(%rsp)
mov    %rax,0x18(%rsp)
add    $0x10,%rax
mov    %rax,0xd0(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0xc8(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0xc0(%rsp)
lea    0x0(,%r11,8),%r14
mov    $0x1,%al
mov    %eax,0x24(%rsp)
mov    %r13,0x90(%rsp)
mov    %rdi,0x10(%rsp)
mov    %r10d,0x3c(%rsp)
mov    %r11,0x70(%rsp)
mov    %r14,0x128(%rsp)
mov    %r15,0xa0(%rsp)
jmp    1318 <llsfit+0x1e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
testb  $0x1,0x24(%rsp)
movl   $0x0,0x24(%rsp)
mov    0x10(%rsp),%rdi
je     1d01 <llsfit+0xbd1>
movslq (%rsp),%rax
mov    %rax,0x28(%rsp)
test   %edi,%edi
mov    0x98(%rsp),%rdi
mov    0x78(%rsp),%rcx
mov    0x18(%rsp),%r12
jle    1560 <llsfit+0x430>
mov    0x10(%rsp),%rdx
cmp    $0x8,%edx
jae    1360 <llsfit+0x230>
xor    %eax,%eax
mov    0x8(%rsp),%rsi
jmp    14e0 <llsfit+0x3b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x18,0x100(%rsp)
jae    1397 <llsfit+0x267>
xor    %eax,%eax
movdqa 0xc8b(%rip),%xmm0
mov    0x8(%rsp),%rsi
mov    0x88(%rsp),%rbp
movdqa 0xc86(%rip),%xmm3
movdqa 0xc8e(%rip),%xmm4
jmp    1480 <llsfit+0x350>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
movdqa 0xc57(%rip),%xmm0
mov    0x8(%rsp),%rsi
mov    0x88(%rsp),%rbp
movdqa 0xc52(%rip),%xmm3
movdqa 0xc5a(%rip),%xmm4
movdqa 0xc61(%rip),%xmm8
movdqa 0xc68(%rip),%xmm9
movdqa 0xc6f(%rip),%xmm10
movdqa 0xc77(%rip),%xmm5
movdqa 0xc7f(%rip),%xmm6
movdqa 0xc87(%rip),%xmm7
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,(%r12,%rax,4)
movdqu %xmm1,0x10(%r12,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm1,0x20(%r12,%rax,4)
movdqu %xmm2,0x30(%r12,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm9,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm10,%xmm2
movdqu %xmm1,0x40(%r12,%rax,4)
movdqu %xmm2,0x50(%r12,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm5,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqu %xmm1,0x60(%r12,%rax,4)
movdqu %xmm2,0x70(%r12,%rax,4)
add    $0x20,%rax
paddd  %xmm7,%xmm0
add    $0xfffffffffffffffc,%rcx
jne    1400 <llsfit+0x2d0>
cmpq   $0x0,0xe8(%rsp)
je     14c0 <llsfit+0x390>
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,-0x10(%rax,%rcx,1)
movdqu %xmm1,(%rax,%rcx,1)
paddd  %xmm4,%xmm0
add    $0x20,%rcx
cmp    %rcx,%rbp
jne    14a0 <llsfit+0x370>
mov    0x108(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
mov    0x78(%rsp),%rcx
je     14ed <llsfit+0x3bd>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    14e0 <llsfit+0x3b0>
test   %edx,%edx
jle    1560 <llsfit+0x430>
xor    %r14d,%r14d
jmp    150b <llsfit+0x3db>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x8(%rsp),%r14
je     1560 <llsfit+0x430>
cmpl   $0x0,(%rsp)
mov    0x28(%rsp),%rbx
jle    1500 <llsfit+0x3d0>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movq   (%rcx,%rbp,8),%xmm0
mov    %r14d,%edi
call   *0x138(%rsp)
mov    0x78(%rsp),%rcx
mov    0x98(%rsp),%rdi
movslq (%r12,%r14,4),%rax
imul   %rbx,%rax
add    %rbp,%rax
movq   %xmm0,(%r15,%rax,8)
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1520 <llsfit+0x3f0>
jmp    1500 <llsfit+0x3d0>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,(%rsp)
mov    0x10(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x120(%rsp),%rbp
jle    16fc <llsfit+0x5cc>
cmpl   $0x4,(%rsp)
setb   %al
or     0x7(%rsp),%al
je     1590 <llsfit+0x460>
xor    %eax,%eax
jmp    1682 <llsfit+0x552>
cmpq   $0xc,0xf0(%rsp)
jae    15a2 <llsfit+0x472>
mov    %rdx,%rbx
xor    %eax,%eax
jmp    1615 <llsfit+0x4e5>
mov    %rdx,%rbx
mov    0xb0(%rsp),%rcx
xor    %eax,%eax
nop
movups 0x0(%r13,%rax,8),%xmm0
movups 0x10(%r13,%rax,8),%xmm1
movups %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
movups 0x20(%r13,%rax,8),%xmm0
movups 0x30(%r13,%rax,8),%xmm1
movups %xmm0,0x20(%rsi,%rax,8)
movups %xmm1,0x30(%rsi,%rax,8)
movups 0x40(%r13,%rax,8),%xmm0
movups 0x50(%r13,%rax,8),%xmm1
movups %xmm0,0x40(%rsi,%rax,8)
movups %xmm1,0x50(%rsi,%rax,8)
movdqu 0x60(%r13,%rax,8),%xmm0
movdqu 0x70(%r13,%rax,8),%xmm1
movdqu %xmm0,0x60(%rsi,%rax,8)
movdqu %xmm1,0x70(%rsi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    15b0 <llsfit+0x480>
cmpq   $0x0,0xe0(%rsp)
je     166f <llsfit+0x53f>
mov    0xd8(%rsp),%rcx
add    %rax,%rcx
mov    0xc8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rax,%rdx,1),%xmm0
movdqu (%rax,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    1650 <llsfit+0x520>
mov    0xf8(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
mov    %rbx,%rdx
je     16fc <llsfit+0x5cc>
mov    %rdx,%rbp
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    0x110(%rsp),%rdx
test   %rdx,%rdx
je     16b6 <llsfit+0x586>
nopl   0x0(%rax,%rax,1)
movq   0x0(%r13,%rax,8),%xmm0
movq   %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    16a0 <llsfit+0x570>
cmp    $0x3,%rcx
mov    %rbp,%rdx
jb     16fc <llsfit+0x5cc>
nop
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x10(%r13,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rax,8)
movq   0x18(%r13,%rax,8),%xmm0
movq   %xmm0,0x18(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    16c0 <llsfit+0x590>
testb  $0x1,0x24(%rsp)
mov    0x28(%rsp),%rcx
je     1bd0 <llsfit+0xaa0>
test   %edx,%edx
mov    0x8(%rsp),%rax
jle    1300 <llsfit+0x1d0>
mov    %r15,%r8
mov    %rax,%r15
mov    0x18(%rsp),%r13
xor    %esi,%esi
mov    (%rsp),%ebx
jmp    1760 <llsfit+0x630>
nopl   0x0(%rax,%rax,1)
mov    %r15,%r8
add    $0x4,%rbp
add    $0xffffffffffffffff,%rdx
mov    0x40(%rsp),%rsi
cmp    0x8(%rsp),%rsi
mov    0x3c(%rsp),%r10d
mov    0x28(%rsp),%rcx
mov    %rdx,%r15
mov    %rbp,%r13
mov    0x10(%rsp),%rdx
je     1ad0 <llsfit+0x9a0>
mov    %rsi,%rbp
testb  $0x1,0x24(%rsp)
mov    %r15,0xa8(%rsp)
mov    %r13,0x130(%rsp)
mov    %rsi,0x68(%rsp)
je     1900 <llsfit+0x7d0>
pxor   %xmm0,%xmm0
movq   %xmm0,0x60(%rsp)
mov    %rbp,%r14
pxor   %xmm0,%xmm0
pxor   %xmm2,%xmm2
mov    %ebp,%eax
mov    %ebp,0x54(%rsp)
mov    0x30(%rsp),%rbp
jmp    17e0 <llsfit+0x6b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14d,%eax
mov    %r14d,0x54(%rsp)
movapd %xmm1,%xmm2
movsd  0x40(%rsp),%xmm0
movsd  0x148(%rsp),%xmm1
movsd  %xmm1,0x60(%rsp)
add    $0x1,%r14
cmp    %r14,0x8(%rsp)
je     1980 <llsfit+0x850>
movq   %xmm2,0x150(%rsp)
movq   %xmm0,0x80(%rsp)
mov    0x18(%rsp),%r15
movslq (%r15,%r14,4),%rax
mov    0x28(%rsp),%rbx
imul   %rbx,%rax
mov    0xa0(%rsp),%r13
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
mov    (%rsp),%r12d
mov    %r12d,%edi
mov    %rbp,%rsi
mov    0x48(%rsp),%rbp
mov    %rbp,%rcx
xor    %eax,%eax
call   1030 <fdot@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x40(%rsp)
movslq (%r15,%r14,4),%rax
imul   %rbx,%rax
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
mov    %r12d,%edi
mov    0x30(%rsp),%rsi
mov    %rcx,%rdx
xor    %eax,%eax
call   1030 <fdot@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movslq (%r15,%r14,4),%rax
imul   %rbx,%rax
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
movsd  0x40(%rsp),%xmm0
movsd  %xmm1,0x148(%rsp)
divsd  %xmm1,%xmm0
mov    %r12d,%edi
mov    0x140(%rsp),%rbx
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    0x30(%rsp),%rbp
mov    $0x1,%al
call   1040 <fortho@plt>
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %rbx,%rcx
xor    %eax,%eax
call   1030 <fdot@plt>
movsd  0x150(%rsp),%xmm2
movsd  0x80(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
ucomisd 0x7b0(%rip),%xmm2
jne    18e8 <llsfit+0x7b8>
jnp    17b0 <llsfit+0x680>
ucomisd %xmm1,%xmm2
jbe    17d1 <llsfit+0x6a1>
jmp    17b0 <llsfit+0x680>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%r12
movslq (%r12,%rbp,4),%rax
imul   %rcx,%rax
mov    %r8,%r15
lea    (%r8,%rax,8),%rdx
mov    %ebx,%edi
mov    0x30(%rsp),%r13
mov    %r13,%rsi
mov    %rcx,%rbx
mov    0x48(%rsp),%r14
mov    %r14,%rcx
xor    %eax,%eax
call   1030 <fdot@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x80(%rsp)
movslq (%r12,%rbp,4),%rax
imul   %rbx,%rax
lea    (%r15,%rax,8),%rcx
mov    (%rsp),%edi
mov    %r13,%rsi
mov    0x58(%rsp),%rbx
mov    (%rsp),%r13d
mov    %rcx,%rdx
xor    %eax,%eax
call   1030 <fdot@plt>
mov    0x28(%rsp),%rcx
movsd  0x80(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
jmp    19c0 <llsfit+0x890>
nopl   0x0(%rax)
mov    0x18(%rsp),%r12
mov    0x68(%rsp),%rbp
mov    (%r12,%rbp,4),%eax
movslq 0x54(%rsp),%rcx
mov    (%r12,%rcx,4),%edx
mov    %edx,(%r12,%rbp,4)
mov    %eax,(%r12,%rcx,4)
mov    0x48(%rsp),%r14
mov    0x58(%rsp),%rbx
mov    0x28(%rsp),%rcx
mov    0xa0(%rsp),%r15
movsd  0x60(%rsp),%xmm1
mov    (%rsp),%r13d
movsd  %xmm1,0x60(%rsp)
divsd  %xmm1,%xmm0
movslq (%r12,%rbp,4),%rax
movsd  %xmm0,(%rbx,%rax,8)
imul   %rcx,%rax
lea    (%r15,%rax,8),%rcx
mov    %r13d,%edi
mov    %r14,%rsi
mov    %r14,%rdx
mov    $0x1,%al
call   1040 <fortho@plt>
mov    0x68(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x40(%rsp)
cmp    0x70(%rsp),%rcx
mov    %r13d,%ebx
mov    0x30(%rsp),%r13
mov    0xa8(%rsp),%rdx
mov    0x130(%rsp),%rbp
jge    1730 <llsfit+0x600>
mov    $0x1,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%r12
movslq (%r12,%rax,4),%rax
mov    0x28(%rsp),%rcx
imul   %rcx,%rax
lea    (%r15,%rax,8),%rdx
movslq 0x0(%rbp,%r14,4),%rax
imul   %rcx,%rax
lea    (%r15,%rax,8),%rcx
mov    %ebx,%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <fdot@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  0x60(%rsp),%xmm0
mov    0x0(%rbp,%r14,4),%eax
mov    %eax,%ecx
imul   0x10(%rsp),%ecx
add    0x3c(%rsp),%ecx
mov    0x68(%rsp),%rdx
mov    (%r12,%rdx,4),%esi
add    %esi,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%r15,%rcx,8)
imul   %ebx,%eax
cltq
lea    (%r15,%rax,8),%rdx
imul   %ebx,%esi
movslq %esi,%rax
lea    (%r15,%rax,8),%rcx
mov    %ebx,%edi
mov    %rdx,%rsi
mov    $0x1,%al
call   1040 <fortho@plt>
mov    0xa8(%rsp),%rdx
mov    0x68(%rsp),%rax
add    $0x1,%r14
cmp    %r14,%rdx
jne    1a30 <llsfit+0x900>
jmp    1730 <llsfit+0x600>
xchg   %ax,%ax
test   %edx,%edx
mov    0x90(%rsp),%r13
mov    0x70(%rsp),%r11
mov    %r8,%r15
jle    1300 <llsfit+0x1d0>
xor    %r12d,%r12d
mov    %r11,%r8
jmp    1afe <llsfit+0x9ce>
add    $0x1,%r12d
cmp    $0x2,%r9
jl     1300 <llsfit+0x1d0>
mov    %r8,%r9
add    $0xffffffffffffffff,%r8
cmp    %r11,%r9
mov    0x18(%rsp),%rbx
mov    0x58(%rsp),%rax
jge    1af0 <llsfit+0x9c0>
movslq (%rbx,%r8,4),%rsi
movsd  (%rax,%rsi,8),%xmm0
test   $0x1,%r12b
jne    1b30 <llsfit+0xa00>
mov    %r9,%rdi
jmp    1b5c <llsfit+0xa2c>
nopl   0x0(%rax,%rax,1)
movslq (%rbx,%r9,4),%rdi
mov    %edi,%ebp
imul   0x10(%rsp),%ebp
add    %r10d,%ebp
movslq %ebp,%rbp
add    %rsi,%rbp
movsd  (%r15,%rbp,8),%xmm1
mulsd  (%rax,%rdi,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rsi,8)
lea    0x1(%r9),%rdi
cmp    $0x1,%r12d
mov    0x10(%rsp),%rdx
je     1af0 <llsfit+0x9c0>
nopw   0x0(%rax,%rax,1)
movslq (%rbx,%rdi,4),%rbp
mov    %ebp,%ecx
imul   %edx,%ecx
add    %r10d,%ecx
add    %esi,%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm1
mulsd  (%rax,%rbp,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rsi,8)
movslq 0x4(%rbx,%rdi,4),%rcx
mov    %ecx,%ebp
imul   %edx,%ebp
add    %r10d,%ebp
add    %esi,%ebp
movslq %ebp,%rbp
movsd  (%r15,%rbp,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rsi,8)
add    $0x2,%rdi
cmp    %edi,0x8(%rsp)
jne    1b70 <llsfit+0xa40>
jmp    1af0 <llsfit+0x9c0>
nopw   0x0(%rax,%rax,1)
test   %edx,%edx
jle    1d01 <llsfit+0xbd1>
mov    0x118(%rsp),%r14
xor    %r13d,%r13d
mov    0x58(%rsp),%rbx
mov    %rcx,%r12
mov    0x18(%rsp),%rbp
movsd  (%rbx,%r13,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
movslq 0x0(%rbp,%r13,4),%rax
imul   %r12,%rax
lea    (%r15,%rax,8),%rcx
mov    (%rsp),%edi
mov    0x30(%rsp),%rsi
mov    %rcx,%rdx
xor    %eax,%eax
call   1030 <fdot@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r14)
add    $0x1,%r13
add    0x128(%rsp),%r14
cmp    %r13,0x8(%rsp)
jne    1bf0 <llsfit+0xac0>
cmpl   $0x0,0x10(%rsp)
mov    0x90(%rsp),%r13
mov    0x3c(%rsp),%r10d
mov    0x70(%rsp),%r11
jle    1300 <llsfit+0x1d0>
mov    $0x1,%r12d
xor    %esi,%esi
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rbx
jmp    1ca9 <llsfit+0xb79>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,%edi
mov    0x8(%rsp),%rbp
movslq %edi,%rax
mov    (%rbx,%rax,4),%edi
mov    %edi,(%rbx,%rsi,4)
mov    %r8d,(%rbx,%rax,4)
add    $0x1,%r12
mov    %r9,%rsi
cmp    %rbp,%r9
mov    0x28(%rsp),%rcx
je     170c <llsfit+0x5dc>
mov    (%rbx,%rsi,4),%r8d
lea    0x1(%rsi),%r9
cmp    %r11,%r9
jge    1c80 <llsfit+0xb50>
mov    %r8d,%eax
imul   %edx,%eax
add    %r10d,%eax
cltq
movsd  (%r15,%rax,8),%xmm0
mov    %r12,%rax
mov    %esi,%edi
nopl   0x0(%rax)
mov    (%rbx,%rax,4),%ebp
imul   %edx,%ebp
add    %r10d,%ebp
movslq %ebp,%rbp
movsd  (%r15,%rbp,8),%xmm1
mov    0x8(%rsp),%rbp
ucomisd %xmm0,%xmm1
cmova  %eax,%edi
maxsd  %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
cmp    %rax,%rbp
jne    1cd0 <llsfit+0xba0>
jmp    1c87 <llsfit+0xb57>
mov    (%rsp),%ebx
mov    %ebx,%edi
mov    0x30(%rsp),%rsi
mov    0x48(%rsp),%rcx
mov    %rcx,%rdx
xor    %eax,%eax
call   1030 <fdot@plt>
cltd
idiv   %ebx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
pxor   %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1d44 <llsfit+0xc14>
sqrtsd %xmm0,%xmm0
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sqrt@plt>

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

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