int formk_(int n, int *nsub, int *ind, int *nenter, int *ileave, int *indx2,
           int *iupdat, int *updatd, double *wn, double *wn1, int m, double *ws,
           double *wy, double *sy, double theta, int col, int *head,
           int *info) {
  int wn_offset, wn1_offset, ws_offset, wy_offset, sy_offset, i1, i2, i3;
  int i, k, k1, m2, is, js, iy, jy, is1, js1, col2, dend, pend;
  int upcl;
  double temp1, temp2, temp3, temp4;
  int ipntr, jpntr, dbegin, pbegin;
  m2 = m * 2;
  --indx2;
  --ind;
  sy_offset = 1 + m;
  sy -= sy_offset;
  wy_offset = 1 + n;
  wy -= wy_offset;
  ws_offset = 1 + n;
  ws -= ws_offset;
  wn1_offset = 1 + m2;
  wn1 -= wn1_offset;
  wn_offset = 1 + m2;
  wn -= wn_offset;
  if (*updatd) {
    if (*iupdat > m) {
      i1 = m - 1;
      for (jy = 1; jy <= i1; ++jy) {
        js = m + jy;
        i2 = m - jy;
        dcopy_(i2, &wn1[jy + 1 + (jy + 1) * m2], &wn1[jy + jy * m2]);
        i2 = m - jy;
        dcopy_(i2, &wn1[js + 1 + (js + 1) * m2], &wn1[js + js * m2]);
        i2 = m - 1;
        dcopy_(i2, &wn1[m + 2 + (jy + 1) * m2], &wn1[m + 1 + jy * m2]);
      }
    }
    pbegin = 1;
    pend = *nsub;
    dbegin = *nsub + 1;
    dend = n;
    iy = col;
    is = m + col;
    ipntr = *head + col - 1;
    if (ipntr > m) {
      ipntr -= m;
    }
    jpntr = *head;
    for (jy = 1; jy <= col; ++jy) {
      js = m + jy;
      temp1 = 0.;
      temp2 = 0.;
      temp3 = 0.;
      i2 = pend;
      for (k = pbegin; k <= i2; ++k) {
        k1 = ind[k];
        temp1 += wy[k1 + ipntr * n] * wy[k1 + jpntr * n];
      }
      i2 = dend;
      for (k = dbegin; k <= i2; ++k) {
        k1 = ind[k];
        temp2 += ws[k1 + ipntr * n] * ws[k1 + jpntr * n];
        temp3 += ws[k1 + ipntr * n] * wy[k1 + jpntr * n];
      }
      wn1[iy + jy * m2] = temp1;
      wn1[is + js * m2] = temp2;
      wn1[is + jy * m2] = temp3;
      jpntr = jpntr % m + 1;
    }
    jy = col;
    jpntr = *head + col - 1;
    if (jpntr > m) {
      jpntr -= m;
    }
    ipntr = *head;
    for (i = 1; i <= col; ++i) {
      is = m + i;
      temp3 = 0.;
      i2 = pend;
      for (k = pbegin; k <= i2; ++k) {
        k1 = ind[k];
        temp3 += ws[k1 + ipntr * n] * wy[k1 + jpntr * n];
      }
      ipntr = ipntr % m + 1;
      wn1[is + jy * m2] = temp3;
    }
    upcl = col - 1;
  } else {
    upcl = col;
  }
  ipntr = *head;
  for (iy = 1; iy <= upcl; ++iy) {
    is = m + iy;
    jpntr = *head;
    for (jy = 1; jy <= iy; ++jy) {
      js = m + jy;
      temp1 = 0.;
      temp2 = 0.;
      temp3 = 0.;
      temp4 = 0.;
      i3 = *nenter;
      for (k = 1; k <= i3; ++k) {
        k1 = indx2[k];
        temp1 += wy[k1 + ipntr * n] * wy[k1 + jpntr * n];
        temp2 += ws[k1 + ipntr * n] * ws[k1 + jpntr * n];
      }
      i3 = n;
      for (k = *ileave; k <= i3; ++k) {
        k1 = indx2[k];
        temp3 += wy[k1 + ipntr * n] * wy[k1 + jpntr * n];
        temp4 += ws[k1 + ipntr * n] * ws[k1 + jpntr * n];
      }
      wn1[iy + jy * m2] = wn1[iy + jy * m2] + temp1 - temp3;
      wn1[is + js * m2] = wn1[is + js * m2] - temp2 + temp4;
      jpntr = jpntr % m + 1;
    }
    ipntr = ipntr % m + 1;
  }
  ipntr = *head;
  i1 = m + upcl;
  for (is = m + 1; is <= i1; ++is) {
    jpntr = *head;
    i2 = upcl;
    for (jy = 1; jy <= i2; ++jy) {
      temp1 = 0.;
      temp3 = 0.;
      for (k = 1; k <= *nenter; ++k) {
        k1 = indx2[k];
        temp1 += ws[k1 + ipntr * n] * wy[k1 + jpntr * n];
      }
      for (k = *ileave; k <= n; ++k) {
        k1 = indx2[k];
        temp3 += ws[k1 + ipntr * n] * wy[k1 + jpntr * n];
      }
      if (is <= jy + m) {
        wn1[is + jy * m2] = wn1[is + jy * m2] + temp1 - temp3;
      } else {
        wn1[is + jy * m2] = wn1[is + jy * m2] - temp1 + temp3;
      }
      jpntr = jpntr % m + 1;
    }
    ipntr = ipntr % m + 1;
  }
  for (iy = 1; iy <= col; ++iy) {
    is = col + iy;
    is1 = m + iy;
    for (jy = 1; jy <= iy; ++jy) {
      js = col + jy;
      js1 = m + jy;
      wn[jy + iy * m2] = wn1[iy + jy * m2] / theta;
      wn[js + is * m2] = wn1[is1 + js1 * m2] * theta;
    }
    for (jy = 1; jy <= iy - 1; ++jy) {
      wn[jy + is * m2] = -wn1[is1 + jy * m2];
    }
    for (jy = iy; jy <= col; ++jy) {
      wn[jy + is * m2] = wn1[is1 + jy * m2];
    }
    wn[iy + iy * m2] += sy[iy + iy * m];
  }
  dpofa_(&wn[wn_offset], m2, col, info);
  if (*info != 0) {
    *info = -1;
    return 0;
  }
  col2 = col << 1;
  for (js = col + 1; js <= col2; ++js) {
    dtrsl_(&wn[wn_offset], m2, col, &wn[js * m2 + 1], 1, info);
  }
  for (is = col + 1; is <= col2; ++is) {
    for (js = is; js <= col2; ++js) {
      wn[is + js * m2] += ddot_(col, &wn[is * m2 + 1], &wn[js * m2 + 1]);
    }
  }
  dpofa_(&wn[col + 1 + (col + 1) * m2], m2, col, info);
  if (*info != 0) {
    *info = -2;
    return 0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<formk_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
mov    0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
mov    0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%ecx
mov    0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x48(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%ecx
mov    0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x40(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%ecx
mov    0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x38(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
mov    0x28(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x28(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
mov    0x20(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
cmpl   $0x0,(%rax)
je     1775 <formk_+0x635>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
cmp    0x30(%rbp),%eax
jle    1399 <formk_+0x259>
mov    0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1394 <formk_+0x254>
mov    0x30(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x30(%rbp),%eax
sub    -0x78(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x28(%rbp),%rdx
mov    -0x78(%rbp),%eax
mov    -0x78(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x0,%al
call   1030 <dcopy_@plt>
mov    0x30(%rbp),%eax
sub    -0x78(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x28(%rbp),%rdx
mov    -0x70(%rbp),%eax
mov    -0x70(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x0,%al
call   1030 <dcopy_@plt>
mov    0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edi
mov    0x28(%rbp),%rsi
mov    0x30(%rbp),%eax
add    $0x2,%eax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x28(%rbp),%rdx
mov    0x30(%rbp),%eax
add    $0x1,%eax
mov    -0x78(%rbp),%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x0,%al
call   1030 <dcopy_@plt>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    128d <formk_+0x14d>
jmp    1399 <formk_+0x259>
movl   $0x1,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    0x50(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    0x30(%rbp),%eax
add    0x50(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
add    0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    0x30(%rbp),%eax
jle    1408 <formk_+0x2c8>
mov    0x30(%rbp),%ecx
mov    -0xb4(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb8(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x50(%rbp),%eax
jg     1630 <formk_+0x4f0>
mov    0x30(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     14d9 <formk_+0x399>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1463 <formk_+0x323>
mov    -0x88(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     15af <formk_+0x46f>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    14eb <formk_+0x3ab>
movsd  -0x98(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb8(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    141b <formk_+0x2db>
mov    0x50(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
add    0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    0x30(%rbp),%eax
jle    1668 <formk_+0x528>
mov    0x30(%rbp),%ecx
mov    -0xb8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb4(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x50(%rbp),%eax
jg     1764 <formk_+0x624>
mov    0x30(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1723 <formk_+0x5e3>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    16ad <formk_+0x56d>
mov    -0xb4(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    167b <formk_+0x53b>
mov    0x50(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    177e <formk_+0x63e>
mov    0x50(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb4(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x90(%rbp),%eax
jg     1a66 <formk_+0x926>
mov    0x30(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb8(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1a45 <formk_+0x905>
mov    0x30(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     18d1 <formk_+0x791>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    180d <formk_+0x6cd>
mov    -0x8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x58(%rbp),%eax
jg     19a4 <formk_+0x864>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    18e0 <formk_+0x7a0>
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb8(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    17bc <formk_+0x67c>
mov    -0xb4(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1791 <formk_+0x651>
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb4(%rbp)
mov    0x30(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1ca8 <formk_+0xb68>
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1c87 <formk_+0xb47>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jg     1b51 <formk_+0xa11>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1ad8 <formk_+0x998>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1bd0 <formk_+0xa90>
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb4(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0xb8(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1b5a <formk_+0xa1a>
mov    -0x6c(%rbp),%eax
mov    -0x78(%rbp),%ecx
add    0x30(%rbp),%ecx
cmp    %ecx,%eax
jg     1c26 <formk_+0xae6>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x98(%rbp),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c66 <formk_+0xb26>
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb8(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1aaf <formk_+0x96f>
mov    -0xb4(%rbp),%eax
cltd
idivl  0x30(%rbp)
add    $0x1,%edx
mov    %edx,-0xb4(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1a87 <formk_+0x947>
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x50(%rbp),%eax
jg     1e6a <formk_+0xd2a>
mov    0x50(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x30(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1d6a <formk_+0xc2a>
mov    0x50(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x30(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    0x28(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1cd4 <formk_+0xb94>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x74(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1dd7 <formk_+0xc97>
mov    0x28(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x20(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1d71 <formk_+0xc31>
mov    -0x74(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x50(%rbp),%eax
jg     1e27 <formk_+0xce7>
mov    0x28(%rbp),%rax
mov    -0x7c(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x78(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1ddd <formk_+0xc9d>
mov    0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x74(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1caf <formk_+0xb6f>
mov    0x20(%rbp),%rdi
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%esi
mov    0x50(%rbp),%edx
mov    0x60(%rbp),%rcx
mov    $0x0,%al
call   1050 <dpofa_@plt>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
je     1ead <formk_+0xd6d>
mov    0x60(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    201d <formk_+0xedd>
mov    0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x84(%rbp),%eax
jg     1f1c <formk_+0xddc>
mov    0x20(%rbp),%rdi
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%esi
mov    0x50(%rbp),%edx
mov    0x20(%rbp),%rcx
mov    -0x70(%rbp),%eax
imul   -0x68(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rcx
mov    0x60(%rbp),%r9
mov    $0x1,%r8d
mov    $0x0,%al
call   1060 <dtrsl_@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1ec2 <formk_+0xd82>
mov    0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x84(%rbp),%eax
jg     1fc3 <formk_+0xe83>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x84(%rbp),%eax
jg     1fb0 <formk_+0xe70>
mov    0x50(%rbp),%edi
mov    0x20(%rbp),%rsi
mov    -0x6c(%rbp),%eax
imul   -0x68(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    0x20(%rbp),%rdx
mov    -0x70(%rbp),%eax
imul   -0x68(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x0,%al
call   1040 <ddot_@plt>
cvtsi2sd %eax,%xmm0
mov    0x20(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1f3a <formk_+0xdfa>
jmp    1fb5 <formk_+0xe75>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1f25 <formk_+0xde5>
mov    0x20(%rbp),%rdi
mov    0x50(%rbp),%eax
add    $0x1,%eax
mov    0x50(%rbp),%ecx
add    $0x1,%ecx
imul   -0x68(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x68(%rbp),%esi
mov    0x50(%rbp),%edx
mov    0x60(%rbp),%rcx
mov    $0x0,%al
call   1050 <dpofa_@plt>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
je     2016 <formk_+0xed6>
mov    0x60(%rbp),%rax
movl   $0xfffffffe,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    201d <formk_+0xedd>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<formk_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,%r12
mov    %r8,0x90(%rsp)
mov    %rcx,0xa8(%rsp)
movslq 0x110(%rsp),%rbp
mov    0x138(%rsp),%r9
mov    0x130(%rsp),%r8d
mov    0x108(%rsp),%r10
lea    0x0(%rbp,%rbp,1),%ecx
lea    0x1(%rbp),%eax
mov    %eax,0x70(%rsp)
mov    %rdi,%rax
mov    %rdi,(%rsp)
not    %eax
movslq %eax,%r15
shl    $0x3,%r15
mov    0x120(%rsp),%r14
add    %r15,%r14
mov    %ecx,%eax
not    %eax
cltq
mov    %rax,0x88(%rsp)
lea    (%r10,%rax,8),%rdi
movslq %ebp,%rax
mov    %rax,0x60(%rsp)
mov    %ecx,0x1c(%rsp)
movslq %ecx,%rax
mov    %rax,0x38(%rsp)
mov    %r8d,%eax
mov    %rax,0x98(%rsp)
add    0x118(%rsp),%r15
mov    0xf8(%rsp),%rax
cmpl   $0x0,(%rax)
mov    %rbp,0x40(%rsp)
mov    %rdi,0x58(%rsp)
je     175b <formk_+0x61b>
mov    %rdx,%rbx
mov    %rsi,0xb0(%rsp)
movsd  %xmm0,0xa0(%rsp)
mov    0xf0(%rsp),%rax
cmp    %ebp,(%rax)
mov    0x1c(%rsp),%esi
jle    13dd <formk_+0x29d>
cmpl   $0x2,0x40(%rsp)
jl     13dd <formk_+0x29d>
mov    %rdi,%rdx
mov    0x40(%rsp),%rcx
lea    -0x1(%rcx),%r8d
mov    0x70(%rsp),%eax
mov    %ecx,%edi
mov    0x38(%rsp),%r11
add    %r11,%rax
mov    0x88(%rsp),%r9
lea    -0x8(,%r9,8),%rcx
ff
lea    (%rcx,%rax,8),%rax
add    $0x8,%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%r11,8),%rax
mov    %rax,0x48(%rsp)
lea    0x1(%rdi),%rax
imul   %r11,%rax
add    %r9,%rax
add    $0xffffffffffffffff,%rax
add    %rdi,%rax
lea    0x10(,%rax,8),%rax
mov    %rax,0x20(%rsp)
lea    0x8(,%r11,8),%rax
mov    %rax,0x78(%rsp)
lea    0x2(%rdi),%rax
imul   %r11,%rax
add    %r9,%rax
add    $0xffffffffffffffff,%rax
add    %rdi,%rax
lea    0x18(,%rax,8),%rax
mov    %rax,0x30(%rsp)
mov    %r11,%rax
shl    $0x4,%rax
lea    (%rax,%r9,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    (%rax,%r9,8),%rbp
add    $0x10,%rbp
lea    (%rcx,%rdi,8),%rax
add    $0x18,%rax
mov    %rax,0x68(%rsp)
add    $0xffffffffffffffff,%rdi
mov    %rdi,0x80(%rsp)
xor    %eax,%eax
mov    %esi,%r13d
mov    %r8d,0x50(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %r8d,0x10(%rsp)
mov    %rax,0x8(%rsp)
movslq %r13d,%r13
mov    0x8(%rsp),%rax
add    %r13,%rax
lea    (%r10,%rbp,1),%rsi
lea    (%rdx,%rax,8),%rdx
add    $0x8,%rdx
mov    0x10(%rsp),%edi
xor    %eax,%eax
call   1030 <dcopy_@plt>
mov    0x108(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,1),%rsi
mov    0x108(%rsp),%rax
mov    0x20(%rsp),%rcx
lea    (%rax,%rcx,1),%rdx
mov    0x10(%rsp),%edi
xor    %eax,%eax
call   1030 <dcopy_@plt>
mov    0x108(%rsp),%rax
mov    0x68(%rsp),%rcx
lea    (%rax,%rcx,1),%rsi
mov    0x108(%rsp),%rax
mov    0x28(%rsp),%rcx
lea    (%rax,%rcx,1),%rdx
mov    0x50(%rsp),%edi
xor    %eax,%eax
call   1030 <dcopy_@plt>
mov    0x58(%rsp),%rdx
mov    0x1c(%rsp),%esi
mov    0x108(%rsp),%r10
mov    0x10(%rsp),%r8d
add    $0xffffffff,%r8d
add    %esi,%r13d
addq   $0x1,0x8(%rsp)
mov    0x48(%rsp),%rax
add    %rax,0x28(%rsp)
mov    0x78(%rsp),%rcx
add    %rcx,0x20(%rsp)
add    %rcx,0x30(%rsp)
add    %rcx,%rbp
add    %rax,0x68(%rsp)
mov    0x8(%rsp),%rax
cmp    %rax,0x80(%rsp)
jne    1300 <formk_+0x1c0>
mov    0x138(%rsp),%rax
mov    (%rax),%edi
mov    0x130(%rsp),%ecx
lea    -0x1(%rcx),%r8d
lea    (%rcx,%rdi,1),%r10d
add    $0xffffffff,%r10d
xor    %eax,%eax
mov    0x40(%rsp),%r13
cmp    %r13d,%r10d
cmovg  %r13d,%eax
test   %ecx,%ecx
jle    1768 <formk_+0x628>
mov    %r8,0x50(%rsp)
mov    0xb0(%rsp),%rdx
movslq (%rdx),%rbp
sub    %eax,%r10d
lea    (%rcx,%r13,1),%eax
mov    %rdi,%rsi
mov    (%rsp),%rdx
imul   %edx,%r10d
mov    %rbp,%rdi
mov    %rbp,0x8(%rsp)
lea    0x1(%rbp),%edi
cltq
mov    %rax,0x30(%rsp)
lea    0x1(%rcx),%eax
mov    %rax,0x10(%rsp)
movslq %edx,%r8
lea    -0x1(%rdi),%r11
add    $0xfffffffffffffffe,%rdi
mov    %rdi,0x28(%rsp)
mov    %r11,%rax
mov    %r11,0x20(%rsp)
and    $0xfffffffffffffffe,%r11
neg    %r11
mov    $0x1,%r9d
mov    %rsi,0x48(%rsp)
mov    %esi,%edx
jmp    14d5 <formk_+0x395>
nopw   0x0(%rax,%rax,1)
mov    %r9,%rcx
mov    0x38(%rsp),%rdi
imul   %rdi,%rcx
mov    0x98(%rsp),%rsi
add    %rcx,%rsi
mov    0x58(%rsp),%rbp
movsd  %xmm0,0x0(%rbp,%rsi,8)
imul   %rdi,%rax
mov    0x30(%rsp),%rsi
add    %rsi,%rax
movlpd %xmm1,0x0(%rbp,%rax,8)
add    %rsi,%rcx
movhpd %xmm1,0x0(%rbp,%rcx,8)
mov    %edx,%eax
cltd
idiv   %r13d
add    $0x1,%edx
add    $0x1,%r9
cmp    0x10(%rsp),%r9
je     161d <formk_+0x4dd>
cmpl   $0x0,0x8(%rsp)
jle    1560 <formk_+0x420>
mov    %edx,%eax
imul   (%rsp),%eax
cmpq   $0x0,0x28(%rsp)
je     1570 <formk_+0x430>
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rbx,%rdi,4),%esi
mov    (%rbx,%rdi,4),%ebp
lea    (%rsi,%r10,1),%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm1
add    %eax,%esi
movslq %esi,%rcx
mulsd  (%r14,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
lea    (%r10,%rbp,1),%ecx
movslq %ecx,%rcx
movsd  (%r14,%rcx,8),%xmm0
add    %eax,%ebp
movslq %ebp,%rcx
mulsd  (%r14,%rcx,8),%xmm0
addsd  %xmm1,%xmm0
lea    (%r11,%rdi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdi
cmp    $0x1,%rcx
jne    1500 <formk_+0x3c0>
testb  $0x1,0x20(%rsp)
jne    1580 <formk_+0x440>
jmp    159f <formk_+0x45f>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
jmp    159f <formk_+0x45f>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
testb  $0x1,0x20(%rsp)
je     159f <formk_+0x45f>
mov    -0x4(%rbx,%rdi,4),%edi
lea    (%rdi,%r10,1),%esi
movslq %esi,%rsi
movsd  (%r14,%rsi,8),%xmm1
add    %edi,%eax
cltq
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm1,%xmm0
mov    0x60(%rsp),%rax
add    %r9,%rax
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%rcx
cmp    (%rsp),%ecx
jge    1480 <formk_+0x340>
mov    %edx,%edi
imul   (%rsp),%edi
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%r13
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm2
mov    (%rbx,%r13,4),%ecx
add    $0x1,%r13
lea    (%rcx,%r10,1),%esi
movslq %esi,%rsi
add    %edi,%ecx
movslq %ecx,%rcx
movsd  (%r15,%rsi,8),%xmm3
movsd  (%r15,%rcx,8),%xmm1
movhpd (%r14,%rcx,8),%xmm1
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
cmp    %r13,%r8
jne    15d0 <formk_+0x490>
addpd  %xmm2,%xmm1
mov    0x40(%rsp),%r13
jmp    1480 <formk_+0x340>
mov    0x130(%rsp),%eax
test   %eax,%eax
movsd  0xa0(%rsp),%xmm0
jle    1747 <formk_+0x607>
mov    0x1c(%rsp),%ecx
mov    %ecx,%r8d
imul   %eax,%r8d
add    %r13d,%r8d
mov    $0x1,%r9d
mov    0x48(%rsp),%rax
mov    %eax,%edx
jmp    168c <formk_+0x54c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm2,%xmm2
mov    %edx,%eax
cltd
idiv   %r13d
add    $0x1,%edx
lea    (%r8,%r9,1),%eax
cltq
mov    0x58(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
add    $0x1,%r9
cmp    0x10(%rsp),%r9
je     1747 <formk_+0x607>
cmpl   $0x0,0x8(%rsp)
jle    1660 <formk_+0x520>
mov    %edx,%eax
imul   (%rsp),%eax
cmpq   $0x0,0x28(%rsp)
je     1710 <formk_+0x5d0>
xorpd  %xmm2,%xmm2
mov    $0x1,%edi
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rbx,%rdi,4),%ecx
mov    (%rbx,%rdi,4),%esi
lea    (%rcx,%rax,1),%ebp
movslq %ebp,%rbp
movsd  (%r15,%rbp,8),%xmm1
add    %r10d,%ecx
movslq %ecx,%rcx
mulsd  (%r14,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
lea    (%rsi,%rax,1),%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm2
add    %r10d,%esi
movslq %esi,%rcx
mulsd  (%r14,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
lea    (%r11,%rdi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdi
cmp    $0x1,%rcx
jne    16b0 <formk_+0x570>
testb  $0x1,0x20(%rsp)
je     1664 <formk_+0x524>
jmp    1724 <formk_+0x5e4>
xchg   %ax,%ax
xorpd  %xmm2,%xmm2
mov    $0x1,%edi
testb  $0x1,0x20(%rsp)
je     1664 <formk_+0x524>
mov    -0x4(%rbx,%rdi,4),%ecx
add    %ecx,%eax
cltq
movsd  (%r15,%rax,8),%xmm1
add    %r10d,%ecx
movslq %ecx,%rax
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm1,%xmm2
jmp    1664 <formk_+0x524>
mov    0x48(%rsp),%rdi
mov    0x50(%rsp),%r8
test   %r8d,%r8d
jg     177a <formk_+0x63a>
jmp    1c11 <formk_+0xad1>
mov    (%r9),%edi
test   %r8d,%r8d
jg     177a <formk_+0x63a>
jmp    1c11 <formk_+0xad1>
movsd  0xa0(%rsp),%xmm0
test   %r8d,%r8d
jle    1c11 <formk_+0xad1>
mov    0xa8(%rsp),%rax
mov    (%rax),%ecx
mov    0x90(%rsp),%rax
movslq (%rax),%rdx
mov    %rcx,0x28(%rsp)
add    $0x1,%ecx
mov    %r8,0x50(%rsp)
lea    0x1(%r8),%eax
mov    %rax,0x30(%rsp)
add    $0xffffffffffffffff,%rcx
lea    (%r12,%rdx,4),%rbp
mov    (%rsp),%rsi
mov    %rdx,0x20(%rsp)
sub    %edx,%esi
mov    $0x2,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%r11d
mov    %edi,%edx
mov    0x38(%rsp),%r10
mov    %rdi,0x48(%rsp)
jmp    180a <formk_+0x6ca>
cs nopw 0x0(%rax,%rax,1)
mov    0x68(%rsp),%eax
cltd
mov    0x40(%rsp),%r9
idiv   %r9d
add    $0x1,%edx
add    $0x1,%r11
addq   $0x1,0x8(%rsp)
cmp    0x30(%rsp),%r11
mov    0x48(%rsp),%rdi
je     1970 <formk_+0x830>
mov    0x60(%rsp),%rax
add    %r11,%rax
mov    %rax,0x10(%rsp)
mov    %edx,0x68(%rsp)
mov    %edx,%r8d
imul   (%rsp),%r8d
mov    $0x1,%r13d
mov    %edi,%r9d
jmp    1892 <formk_+0x752>
xchg   %ax,%ax
mov    %r13,%rdx
imul   %r10,%rdx
add    %r11,%rdx
mov    0x58(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rdi,%rdx,8)
imul   %r10,%rax
add    0x10(%rsp),%rax
movsd  (%rdi,%rax,8),%xmm2
unpckhpd %xmm1,%xmm1
subsd  %xmm1,%xmm2
unpckhpd %xmm4,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm4,(%rdi,%rax,8)
mov    %r9d,%eax
cltd
idivl  0x40(%rsp)
mov    %edx,%r9d
add    $0x1,%r9d
add    $0x1,%r13
cmp    0x8(%rsp),%r13
je     17e0 <formk_+0x6a0>
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
cmpl   $0x0,0x28(%rsp)
jle    18f5 <formk_+0x7b5>
mov    %r9d,%eax
imul   (%rsp),%eax
xorpd  %xmm3,%xmm3
xor    %edx,%edx
xchg   %ax,%ax
movapd %xmm3,%xmm2
mov    (%r12,%rdx,4),%edi
lea    (%rdi,%r8,1),%ebx
movslq %ebx,%rbx
add    %eax,%edi
movsd  (%r14,%rbx,8),%xmm3
movhpd (%r15,%rbx,8),%xmm3
movslq %edi,%rdi
movsd  (%r14,%rdi,8),%xmm1
movhpd (%r15,%rdi,8),%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    18b0 <formk_+0x770>
addpd  %xmm2,%xmm1
mov    0x60(%rsp),%rax
add    %r13,%rax
mov    0x20(%rsp),%rdx
cmp    (%rsp),%edx
jg     1830 <formk_+0x6f0>
mov    %r9d,%edx
imul   (%rsp),%edx
xorpd  %xmm3,%xmm3
mov    $0xffffffffffffffff,%r10
nopl   (%rax)
movapd %xmm3,%xmm2
mov    0x0(%rbp,%r10,4),%edi
lea    (%rdi,%r8,1),%ebx
movslq %ebx,%rbx
add    %edx,%edi
movsd  (%r14,%rbx,8),%xmm3
movhpd (%r15,%rbx,8),%xmm3
movslq %edi,%rdi
movsd  (%r14,%rdi,8),%xmm4
movhpd (%r15,%rdi,8),%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm4,%xmm3
addpd  %xmm2,%xmm3
add    $0x1,%r10
cmp    %r10d,%esi
jne    1920 <formk_+0x7e0>
addpd  %xmm2,%xmm4
mov    0x38(%rsp),%r10
jmp    1830 <formk_+0x6f0>
mov    0x50(%rsp),%rax
test   %eax,%eax
mov    0x58(%rsp),%r13
jle    1c11 <formk_+0xad1>
add    %r9d,%eax
movslq 0x70(%rsp),%rcx
mov    %rcx,0x10(%rsp)
cltq
mov    %rax,0x70(%rsp)
mov    0xa8(%rsp),%rax
mov    (%rax),%ecx
mov    0x90(%rsp),%rax
movslq (%rax),%rsi
mov    %rcx,0x28(%rsp)
lea    0x1(%rcx),%eax
mov    %rax,0x20(%rsp)
lea    -0x1(%rax),%r10
mov    (%rsp),%rax
lea    0x1(%rax),%r8d
mov    %r8d,%eax
sub    %esi,%eax
mov    %eax,0x50(%rsp)
mov    %rsi,0x8(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x80(%rsp)
mov    %r10,%rax
mov    %r10,0x68(%rsp)
and    $0xfffffffffffffffe,%r10
neg    %r10
xorpd  %xmm4,%xmm4
mov    %edi,%edx
jmp    1a29 <formk_+0x8e9>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x78(%rsp),%eax
cltd
idiv   %r9d
add    $0x1,%edx
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%rax
cmp    0x70(%rsp),%rcx
mov    %rax,0x10(%rsp)
mov    0x48(%rsp),%rdi
jge    1c11 <formk_+0xad1>
mov    %edx,0x78(%rsp)
mov    %edx,%r11d
imul   (%rsp),%r11d
mov    $0x1,%ebx
mov    %rdi,%rdx
jmp    1a67 <formk_+0x927>
nop
addsd  %xmm3,%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
mov    %edx,%eax
cltd
idiv   %r9d
add    $0x1,%edx
add    $0x1,%rbx
cmp    0x30(%rsp),%rbx
je     1a00 <formk_+0x8c0>
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
cmpl   $0x0,0x28(%rsp)
jle    1b35 <formk_+0x9f5>
mov    %edx,%eax
imul   (%rsp),%eax
cmpl   $0x2,0x20(%rsp)
jne    1aa0 <formk_+0x960>
xorpd  %xmm2,%xmm2
mov    $0x1,%ebp
jmp    1b04 <formk_+0x9c4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm2,%xmm2
mov    $0x1,%ebp
nopl   0x0(%rax)
mov    -0x4(%r12,%rbp,4),%edi
mov    (%r12,%rbp,4),%r9d
lea    (%rdi,%r11,1),%r13d
movslq %r13d,%rsi
movsd  (%r15,%rsi,8),%xmm3
add    %eax,%edi
movslq %edi,%rsi
mulsd  (%r14,%rsi,8),%xmm3
addsd  %xmm2,%xmm3
lea    (%r9,%r11,1),%esi
movslq %esi,%rsi
movsd  (%r15,%rsi,8),%xmm2
add    %eax,%r9d
movslq %r9d,%rsi
mulsd  (%r14,%rsi,8),%xmm2
addsd  %xmm3,%xmm2
lea    (%r10,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rbp
cmp    $0x1,%rsi
jne    1ab0 <formk_+0x970>
testb  $0x1,0x68(%rsp)
mov    0x40(%rsp),%r9
mov    0x58(%rsp),%r13
je     1b35 <formk_+0x9f5>
mov    -0x4(%r12,%rbp,4),%esi
lea    (%rsi,%r11,1),%edi
movslq %edi,%rdi
movsd  (%r15,%rdi,8),%xmm3
add    %esi,%eax
cltq
mulsd  (%r14,%rax,8),%xmm3
addsd  %xmm3,%xmm2
mov    0x8(%rsp),%rax
cmp    (%rsp),%eax
jg     1bda <formk_+0xa9a>
mov    %edx,%eax
imul   (%rsp),%eax
xorpd  %xmm1,%xmm1
mov    0x8(%rsp),%rcx
mov    %rcx,%rdi
testb  $0x1,0x50(%rsp)
je     1b85 <formk_+0xa45>
mov    -0x4(%r12,%rcx,4),%esi
lea    (%rsi,%r11,1),%edi
movslq %edi,%rdi
movsd  (%r15,%rdi,8),%xmm1
add    %eax,%esi
movslq %esi,%rsi
mulsd  (%r14,%rsi,8),%xmm1
addsd  %xmm4,%xmm1
mov    0x80(%rsp),%rdi
cmp    (%rsp),%ecx
je     1bda <formk_+0xa9a>
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r12,%rdi,4),%esi
mov    (%r12,%rdi,4),%ebp
lea    (%rsi,%r11,1),%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm3
add    %eax,%esi
movslq %esi,%rcx
mulsd  (%r14,%rcx,8),%xmm3
addsd  %xmm1,%xmm3
lea    (%r11,%rbp,1),%ecx
movslq %ecx,%rcx
movsd  (%r15,%rcx,8),%xmm1
add    %eax,%ebp
movslq %ebp,%rcx
mulsd  (%r14,%rcx,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rdi
cmp    %edi,%r8d
jne    1b90 <formk_+0xa50>
mov    0x60(%rsp),%rax
lea    (%rbx,%rax,1),%rcx
mov    %rbx,%rax
imul   0x38(%rsp),%rax
mov    0x10(%rsp),%rsi
add    %rsi,%rax
movsd  0x0(%r13,%rax,8),%xmm3
cmp    %rcx,%rsi
jle    1a40 <formk_+0x900>
subsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
jmp    1a4c <formk_+0x90c>
mov    0x88(%rsp),%rax
mov    0x100(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,(%rsp)
mov    0x130(%rsp),%ebx
test   %ebx,%ebx
jle    1f49 <formk_+0xe09>
mov    0x40(%rsp),%rbp
mov    %rbp,%rax
not    %rax
shl    $0x3,%rax
add    0x128(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x130(%rsp),%r11d
lea    0x1(%r11),%eax
lea    0x2(%r11),%ecx
mov    %rcx,0x80(%rsp)
mov    0x38(%rsp),%r14
mov    0x88(%rsp),%r8
lea    -0x1(%r14,%r8,1),%rcx
mov    0x100(%rsp),%r10
lea    0x10(%r10,%rcx,8),%r13
lea    0x0(,%r14,8),%rsi
mov    0x108(%rsp),%rbx
lea    0x10(%rbx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
mov    0x60(%rsp),%rdi
lea    0x1(%rdi),%rcx
imul   %r14,%rcx
add    %rdi,%rcx
add    %r8,%rcx
add    $0xffffffffffffffff,%rcx
lea    0x10(%rbx,%rcx,8),%rcx
mov    %rcx,0x78(%rsp)
lea    -0x1(%rax),%r9
imul   %ebp,%eax
lea    (%r11,%rax,2),%ecx
add    $0x1,%ecx
mov    0x98(%rsp),%rax
add    $0x1,%rax
imul   %r14,%rax
add    %r8,%rax
add    $0xffffffffffffffff,%rax
lea    0x10(%r10,%rax,8),%rbp
lea    (%rsi,%rdi,8),%rax
lea    (%rax,%r8,8),%r10
add    $0x8,%r10
mov    %r14,%rdx
shl    $0x4,%rdx
lea    (%rdi,%r8,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rdx,0x90(%rsp)
lea    0x10(%rdx,%rax,8),%r12
lea    0x8(,%r14,8),%rax
mov    %rax,0x70(%rsp)
lea    (%rdi,%r14,1),%rax
mov    %ecx,%edx
lea    -0x1(%r8,%rax,1),%rax
mov    (%rsp),%rcx
lea    0x10(%rbx,%rax,8),%rbx
mov    $0x1,%r8d
movapd 0x12b9(%rip),%xmm3
movapd 0x12b1(%rip),%xmm1
mov    $0x2,%edi
xor    %r11d,%r11d
mov    %rbp,%r14
xor    %r15d,%r15d
nopl   (%rax)
mov    %rdi,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r15,0x8(%rsp)
and    $0xfffffffffffffffe,%r15
neg    %r15
mov    0x98(%rsp),%rax
lea    (%r8,%rax,1),%rdi
mov    0x60(%rsp),%rax
add    %r8,%rax
mov    %rax,0x68(%rsp)
imul   0x38(%rsp),%rdi
mov    %rdi,0x30(%rsp)
mov    $0xfffffffffffffff8,%rax
mov    %edx,0x10(%rsp)
mov    %edx,%edi
mov    0x78(%rsp),%rbx
mov    0x48(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%r11,1),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r13,%rax,1)
movsd  (%rbx,%r11,1),%xmm2
mulsd  %xmm0,%xmm2
movslq %edi,%rdi
movsd  %xmm2,(%rcx,%rdi,8)
add    $0x8,%rax
add    %rsi,%rdx
add    %rsi,%rbx
add    $0x1,%edi
cmp    %rax,%r11
jne    1dc0 <formk_+0xc80>
mov    %r8,%rdi
cmp    $0x2,%r8
jb     1e9a <formk_+0xd5a>
mov    $0x1,%r8d
cmpq   $0x1,0x8(%rsp)
mov    0x90(%rsp),%rcx
je     1e66 <formk_+0xd26>
mov    $0x1,%r8d
mov    0x108(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%r10,1),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,-0x8(%r14,%r8,8)
movsd  (%rax,%r12,1),%xmm2
xorpd  %xmm1,%xmm2
movlpd %xmm2,(%r14,%r8,8)
add    %rcx,%rax
lea    (%r15,%r8,1),%rdx
add    $0x2,%rdx
add    $0x2,%r8
cmp    $0x1,%rdx
jne    1e30 <formk_+0xcf0>
testb  $0x1,0x8(%rsp)
je     1e9a <formk_+0xd5a>
mov    %r8,%rax
imul   0x38(%rsp),%rax
add    0x68(%rsp),%rax
mov    0x58(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm2
xorpd  %xmm3,%xmm2
mov    0x30(%rsp),%rcx
add    %r8,%rcx
mov    (%rsp),%rax
movlpd %xmm2,(%rax,%rcx,8)
mov    0x28(%rsp),%rbx
mov    %rbx,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax),%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
add    %rsi,%rax
cmp    %rdx,%r9
jne    1eb0 <formk_+0xd70>
mov    %rdi,%r8
mov    %rdi,%rax
imul   0x60(%rsp),%rax
add    %rdi,%rax
mov    0x50(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
mov    0x1c(%rsp),%edx
mov    %edx,%eax
imul   %r8d,%eax
cltq
add    %rdi,%rax
mov    (%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
add    $0x1,%r8
mov    0x20(%rsp),%rdi
add    $0x1,%rdi
mov    0x8(%rsp),%r15
add    $0x1,%r15
add    %rsi,%r13
add    $0x8,%r11
mov    0x10(%rsp),%eax
add    %edx,%eax
mov    %eax,%edx
add    %rsi,%r14
add    $0x8,%r10
add    $0x8,%r12
mov    0x70(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
add    $0xffffffffffffffff,%r9
cmp    0x80(%rsp),%rdi
jne    1d60 <formk_+0xc20>
mov    0x100(%rsp),%r12
mov    %r12,%rdi
mov    0x1c(%rsp),%esi
mov    0x130(%rsp),%r15d
mov    %r15d,%edx
mov    0x140(%rsp),%rbx
mov    %rbx,%rcx
xor    %eax,%eax
call   1050 <dpofa_@plt>
mov    $0xffffffff,%eax
cmpl   $0x0,(%rbx)
jne    2165 <formk_+0x1025>
lea    (%r15,%r15,1),%ecx
lea    0x1(%r15),%eax
mov    %eax,0x30(%rsp)
mov    %ecx,0x10(%rsp)
cmp    %r15d,%ecx
mov    (%rsp),%rdi
jle    2131 <formk_+0xff1>
mov    0x40(%rsp),%rax
imul   0x30(%rsp),%eax
mov    %r15,%r14
lea    (%rax,%rax,1),%ebx
add    $0x1,%ebx
mov    %r14d,%ebp
mov    0x1c(%rsp),%r15d
mov    0x140(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ebx,%rbx
lea    (%rdi,%rbx,8),%rcx
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r14d,%edx
mov    $0x1,%r8d
mov    %r13,%r9
xor    %eax,%eax
call   1060 <dtrsl_@plt>
mov    (%rsp),%rdi
add    %r15d,%ebx
add    $0xffffffff,%ebp
jne    1fd0 <formk_+0xe90>
cmp    %r14d,0x10(%rsp)
mov    %r14,%r15
mov    0x38(%rsp),%rcx
jle    2131 <formk_+0xff1>
movslq %r15d,%rax
lea    0x1(%rax),%rsi
mov    0x10(%rsp),%edx
movslq %edx,%rbp
mov    %rbp,0x28(%rsp)
or     $0x1,%edx
mov    %edx,0x10(%rsp)
mov    %rsi,%rbp
imul   %rcx,%rbp
mov    %rbp,%rdx
shl    $0x20,%rdx
mov    %rdx,0x40(%rsp)
mov    %rcx,%rdx
shl    $0x20,%rdx
add    %rax,%rbp
mov    0x88(%rsp),%rax
add    %rbp,%rax
lea    (%r12,%rax,8),%rax
add    $0x8,%rax
mov    %rax,0x8(%rsp)
lea    0x8(,%rcx,8),%rax
mov    %rax,0x20(%rsp)
shl    $0x3,%rcx
mov    %r15d,%eax
mov    %r15d,0x38(%rsp)
jmp    20a7 <formk_+0xf67>
nopl   0x0(%rax)
mov    0x58(%rsp),%rsi
add    $0x1,%rsi
add    %rdx,0x40(%rsp)
mov    0x20(%rsp),%rax
add    %rax,0x8(%rsp)
addl   $0xffffffff,0x38(%rsp)
cmp    %esi,0x10(%rsp)
je     2131 <formk_+0xff1>
mov    %rsi,0x58(%rsp)
cmp    0x28(%rsp),%rsi
jg     2080 <formk_+0xf40>
mov    0x1c(%rsp),%eax
imul   0x58(%rsp),%eax
or     $0x1,%eax
cltq
lea    (%rdi,%rax,8),%rax
mov    %rax,0x60(%rsp)
mov    0x38(%rsp),%r14d
mov    0x8(%rsp),%r13
mov    0x40(%rsp),%r12
nopl   0x0(%rax)
mov    %rdx,%rbp
mov    %r12,%rdx
sar    $0x1d,%rdx
or     $0x8,%rdx
add    %rdi,%rdx
mov    %r15d,%edi
mov    0x60(%rsp),%rsi
xor    %eax,%eax
mov    %rcx,%rbx
call   1040 <ddot_@plt>
mov    %rbp,%rdx
mov    (%rsp),%rdi
mov    %rbx,%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x0(%r13),%xmm0
movsd  %xmm0,0x0(%r13)
add    %rbp,%r12
add    %rbx,%r13
add    $0xffffffff,%r14d
jne    20e0 <formk_+0xfa0>
jmp    2080 <formk_+0xf40>
mov    0x30(%rsp),%ecx
mov    %ecx,%eax
mov    0x1c(%rsp),%esi
imul   %esi,%eax
add    %ecx,%eax
cltq
lea    (%rdi,%rax,8),%rdi
mov    %r15d,%edx
mov    0x140(%rsp),%rbx
mov    %rbx,%rcx
xor    %eax,%eax
call   1050 <dpofa_@plt>
mov    $0xfffffffe,%eax
cmpl   $0x0,(%rbx)
je     2167 <formk_+0x1027>
mov    %eax,(%rbx)
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @formk_(i32 %0, i32* %1, i32* %2, i32* %3, i32* %4, i32* %5, i32* %6, i32* %7, double* %8, double* %9, i32 %10, double* %11, double* %12, double* %13, double %14, i32 %15, i32* %16, i32* %17) {
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca double*
%29 = alloca double*
%30 = alloca i32
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double
%35 = alloca i32
%36 = alloca i32*
%37 = alloca i32*
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
%51 = alloca i32
%52 = alloca i32
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
store i32 %0, i32* %20
store i32* %1, i32** %21
store i32* %2, i32** %22
store i32* %3, i32** %23
store i32* %4, i32** %24
store i32* %5, i32** %25
store i32* %6, i32** %26
store i32* %7, i32** %27
store double* %8, double** %28
store double* %9, double** %29
store i32 %10, i32* %30
store double* %11, double** %31
store double* %12, double** %32
store double* %13, double** %33
store double %14, double* %34
store i32 %15, i32* %35
store i32* %16, i32** %36
store i32* %17, i32** %37
%68 = load i32, i32* %30
%69 = mul nsw i32 %68, 2
store i32 %69, i32* %49
%70 = load i32*, i32** %25
%71 = getelementptr inbounds i32, i32* %70, i32 -1
store i32* %71, i32** %25
%72 = load i32*, i32** %22
%73 = getelementptr inbounds i32, i32* %72, i32 -1
store i32* %73, i32** %22
%74 = load i32, i32* %30
%75 = add nsw i32 1, %74
store i32 %75, i32* %42
%76 = load i32, i32* %42
%77 = load double*, double** %33
%78 = sext i32 %76 to i64
%79 = sub i64 0, %78
%80 = getelementptr inbounds double, double* %77, i64 %79
store double* %80, double** %33
%81 = load i32, i32* %20
%82 = add nsw i32 1, %81
store i32 %82, i32* %41
%83 = load i32, i32* %41
%84 = load double*, double** %32
%85 = sext i32 %83 to i64
%86 = sub i64 0, %85
%87 = getelementptr inbounds double, double* %84, i64 %86
store double* %87, double** %32
%88 = load i32, i32* %20
%89 = add nsw i32 1, %88
store i32 %89, i32* %40
%90 = load i32, i32* %40
%91 = load double*, double** %31
%92 = sext i32 %90 to i64
%93 = sub i64 0, %92
%94 = getelementptr inbounds double, double* %91, i64 %93
store double* %94, double** %31
%95 = load i32, i32* %49
%96 = add nsw i32 1, %95
store i32 %96, i32* %39
%97 = load i32, i32* %39
%98 = load double*, double** %29
%99 = sext i32 %97 to i64
%100 = sub i64 0, %99
%101 = getelementptr inbounds double, double* %98, i64 %100
store double* %101, double** %29
%102 = load i32, i32* %49
%103 = add nsw i32 1, %102
store i32 %103, i32* %38
%104 = load i32, i32* %38
%105 = load double*, double** %28
%106 = sext i32 %104 to i64
%107 = sub i64 0, %106
%108 = getelementptr inbounds double, double* %105, i64 %107
store double* %108, double** %28
%109 = load i32*, i32** %27
%110 = load i32, i32* %109
%111 = icmp ne i32 %110, 0
br i1 %111, label %112, label %441
112: ; preds = %18
%113 = load i32*, i32** %26
%114 = load i32, i32* %113
%115 = load i32, i32* %30
%116 = icmp sgt i32 %114, %115
br i1 %116, label %117, label %201
117: ; preds = %112
%118 = load i32, i32* %30
%119 = sub nsw i32 %118, 1
store i32 %119, i32* %43
store i32 1, i32* %53
br label %120
120: ; preds = %197, %117
%121 = load i32, i32* %53
%122 = load i32, i32* %43
%123 = icmp sle i32 %121, %122
br i1 %123, label %124, label %200
124: ; preds = %120
%125 = load i32, i32* %30
%126 = load i32, i32* %53
%127 = add nsw i32 %125, %126
store i32 %127, i32* %51
%128 = load i32, i32* %30
%129 = load i32, i32* %53
%130 = sub nsw i32 %128, %129
store i32 %130, i32* %44
%131 = load i32, i32* %44
%132 = load double*, double** %29
%133 = load i32, i32* %53
%134 = add nsw i32 %133, 1
%135 = load i32, i32* %53
%136 = add nsw i32 %135, 1
%137 = load i32, i32* %49
%138 = mul nsw i32 %136, %137
%139 = add nsw i32 %134, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %132, i64 %140
%142 = load double*, double** %29
%143 = load i32, i32* %53
%144 = load i32, i32* %53
%145 = load i32, i32* %49
%146 = mul nsw i32 %144, %145
%147 = add nsw i32 %143, %146
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %142, i64 %148
%150 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @dcopy_ to i32 (i32, double*, double*, ...)*)(i32 %131, double* %141, double* %149)
%151 = load i32, i32* %30
%152 = load i32, i32* %53
%153 = sub nsw i32 %151, %152
store i32 %153, i32* %44
%154 = load i32, i32* %44
%155 = load double*, double** %29
%156 = load i32, i32* %51
%157 = add nsw i32 %156, 1
%158 = load i32, i32* %51
%159 = add nsw i32 %158, 1
%160 = load i32, i32* %49
%161 = mul nsw i32 %159, %160
%162 = add nsw i32 %157, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %155, i64 %163
%165 = load double*, double** %29
%166 = load i32, i32* %51
%167 = load i32, i32* %51
%168 = load i32, i32* %49
%169 = mul nsw i32 %167, %168
%170 = add nsw i32 %166, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %165, i64 %171
%173 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @dcopy_ to i32 (i32, double*, double*, ...)*)(i32 %154, double* %164, double* %172)
%174 = load i32, i32* %30
%175 = sub nsw i32 %174, 1
store i32 %175, i32* %44
%176 = load i32, i32* %44
%177 = load double*, double** %29
%178 = load i32, i32* %30
%179 = add nsw i32 %178, 2
%180 = load i32, i32* %53
%181 = add nsw i32 %180, 1
%182 = load i32, i32* %49
%183 = mul nsw i32 %181, %182
%184 = add nsw i32 %179, %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %177, i64 %185
%187 = load double*, double** %29
%188 = load i32, i32* %30
%189 = add nsw i32 %188, 1
%190 = load i32, i32* %53
%191 = load i32, i32* %49
%192 = mul nsw i32 %190, %191
%193 = add nsw i32 %189, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %187, i64 %194
%196 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @dcopy_ to i32 (i32, double*, double*, ...)*)(i32 %176, double* %186, double* %195)
br label %197
197: ; preds = %124
%198 = load i32, i32* %53
%199 = add nsw i32 %198, 1
store i32 %199, i32* %53
br label %120
200: ; preds = %120
br label %201
201: ; preds = %200, %112
store i32 1, i32* %67
%202 = load i32*, i32** %21
%203 = load i32, i32* %202
store i32 %203, i32* %58
%204 = load i32*, i32** %21
%205 = load i32, i32* %204
%206 = add nsw i32 %205, 1
store i32 %206, i32* %66
%207 = load i32, i32* %20
store i32 %207, i32* %57
%208 = load i32, i32* %35
store i32 %208, i32* %52
%209 = load i32, i32* %30
%210 = load i32, i32* %35
%211 = add nsw i32 %209, %210
store i32 %211, i32* %50
%212 = load i32*, i32** %36
%213 = load i32, i32* %212
%214 = load i32, i32* %35
%215 = add nsw i32 %213, %214
%216 = sub nsw i32 %215, 1
store i32 %216, i32* %64
%217 = load i32, i32* %64
%218 = load i32, i32* %30
%219 = icmp sgt i32 %217, %218
br i1 %219, label %220, label %224
220: ; preds = %201
%221 = load i32, i32* %30
%222 = load i32, i32* %64
%223 = sub nsw i32 %222, %221
store i32 %223, i32* %64
br label %224
224: ; preds = %220, %201
%225 = load i32*, i32** %36
%226 = load i32, i32* %225
store i32 %226, i32* %65
store i32 1, i32* %53
br label %227
227: ; preds = %358, %224
%228 = load i32, i32* %53
%229 = load i32, i32* %35
%230 = icmp sle i32 %228, %229
br i1 %230, label %231, label %361
231: ; preds = %227
%232 = load i32, i32* %30
%233 = load i32, i32* %53
%234 = add nsw i32 %232, %233
store i32 %234, i32* %51
store double 0.000000e+00, double* %60
store double 0.000000e+00, double* %61
store double 0.000000e+00, double* %62
%235 = load i32, i32* %58
store i32 %235, i32* %44
%236 = load i32, i32* %67
store i32 %236, i32* %47
br label %237
237: ; preds = %267, %231
%238 = load i32, i32* %47
%239 = load i32, i32* %44
%240 = icmp sle i32 %238, %239
br i1 %240, label %241, label %270
241: ; preds = %237
%242 = load i32*, i32** %22
%243 = load i32, i32* %47
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %242, i64 %244
%246 = load i32, i32* %245
store i32 %246, i32* %48
%247 = load double*, double** %32
%248 = load i32, i32* %48
%249 = load i32, i32* %64
%250 = load i32, i32* %20
%251 = mul nsw i32 %249, %250
%252 = add nsw i32 %248, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %247, i64 %253
%255 = load double, double* %254
%256 = load double*, double** %32
%257 = load i32, i32* %48
%258 = load i32, i32* %65
%259 = load i32, i32* %20
%260 = mul nsw i32 %258, %259
%261 = add nsw i32 %257, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %256, i64 %262
%264 = load double, double* %263
%265 = load double, double* %60
%266 = call double @llvm.fmuladd.f64(double %255, double %264, double %265)
store double %266, double* %60
br label %267
267: ; preds = %241
%268 = load i32, i32* %47
%269 = add nsw i32 %268, 1
store i32 %269, i32* %47
br label %237
270: ; preds = %237
%271 = load i32, i32* %57
store i32 %271, i32* %44
%272 = load i32, i32* %66
store i32 %272, i32* %47
br label %273
273: ; preds = %323, %270
%274 = load i32, i32* %47
%275 = load i32, i32* %44
%276 = icmp sle i32 %274, %275
br i1 %276, label %277, label %326
277: ; preds = %273
%278 = load i32*, i32** %22
%279 = load i32, i32* %47
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32, i32* %278, i64 %280
%282 = load i32, i32* %281
store i32 %282, i32* %48
%283 = load double*, double** %31
%284 = load i32, i32* %48
%285 = load i32, i32* %64
%286 = load i32, i32* %20
%287 = mul nsw i32 %285, %286
%288 = add nsw i32 %284, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %283, i64 %289
%291 = load double, double* %290
%292 = load double*, double** %31
%293 = load i32, i32* %48
%294 = load i32, i32* %65
%295 = load i32, i32* %20
%296 = mul nsw i32 %294, %295
%297 = add nsw i32 %293, %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %292, i64 %298
%300 = load double, double* %299
%301 = load double, double* %61
%302 = call double @llvm.fmuladd.f64(double %291, double %300, double %301)
store double %302, double* %61
%303 = load double*, double** %31
%304 = load i32, i32* %48
%305 = load i32, i32* %64
%306 = load i32, i32* %20
%307 = mul nsw i32 %305, %306
%308 = add nsw i32 %304, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %303, i64 %309
%311 = load double, double* %310
%312 = load double*, double** %32
%313 = load i32, i32* %48
%314 = load i32, i32* %65
%315 = load i32, i32* %20
%316 = mul nsw i32 %314, %315
%317 = add nsw i32 %313, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %312, i64 %318
%320 = load double, double* %319
%321 = load double, double* %62
%322 = call double @llvm.fmuladd.f64(double %311, double %320, double %321)
store double %322, double* %62
br label %323
323: ; preds = %277
%324 = load i32, i32* %47
%325 = add nsw i32 %324, 1
store i32 %325, i32* %47
br label %273
326: ; preds = %273
%327 = load double, double* %60
%328 = load double*, double** %29
%329 = load i32, i32* %52
%330 = load i32, i32* %53
%331 = load i32, i32* %49
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds double, double* %328, i64 %334
store double %327, double* %335
%336 = load double, double* %61
%337 = load double*, double** %29
%338 = load i32, i32* %50
%339 = load i32, i32* %51
%340 = load i32, i32* %49
%341 = mul nsw i32 %339, %340
%342 = add nsw i32 %338, %341
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %337, i64 %343
store double %336, double* %344
%345 = load double, double* %62
%346 = load double*, double** %29
%347 = load i32, i32* %50
%348 = load i32, i32* %53
%349 = load i32, i32* %49
%350 = mul nsw i32 %348, %349
%351 = add nsw i32 %347, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %346, i64 %352
store double %345, double* %353
%354 = load i32, i32* %65
%355 = load i32, i32* %30
%356 = srem i32 %354, %355
%357 = add nsw i32 %356, 1
store i32 %357, i32* %65
br label %358
358: ; preds = %326
%359 = load i32, i32* %53
%360 = add nsw i32 %359, 1
store i32 %360, i32* %53
br label %227
361: ; preds = %227
%362 = load i32, i32* %35
store i32 %362, i32* %53
%363 = load i32*, i32** %36
%364 = load i32, i32* %363
%365 = load i32, i32* %35
%366 = add nsw i32 %364, %365
%367 = sub nsw i32 %366, 1
store i32 %367, i32* %65
%368 = load i32, i32* %65
%369 = load i32, i32* %30
%370 = icmp sgt i32 %368, %369
br i1 %370, label %371, label %375
371: ; preds = %361
%372 = load i32, i32* %30
%373 = load i32, i32* %65
%374 = sub nsw i32 %373, %372
store i32 %374, i32* %65
br label %375
375: ; preds = %371, %361
%376 = load i32*, i32** %36
%377 = load i32, i32* %376
store i32 %377, i32* %64
store i32 1, i32* %46
br label %378
378: ; preds = %435, %375
%379 = load i32, i32* %46
%380 = load i32, i32* %35
%381 = icmp sle i32 %379, %380
br i1 %381, label %382, label %438
382: ; preds = %378
%383 = load i32, i32* %30
%384 = load i32, i32* %46
%385 = add nsw i32 %383, %384
store i32 %385, i32* %50
store double 0.000000e+00, double* %62
%386 = load i32, i32* %58
store i32 %386, i32* %44
%387 = load i32, i32* %67
store i32 %387, i32* %47
br label %388
388: ; preds = %418, %382
%389 = load i32, i32* %47
%390 = load i32, i32* %44
%391 = icmp sle i32 %389, %390
br i1 %391, label %392, label %421
392: ; preds = %388
%393 = load i32*, i32** %22
%394 = load i32, i32* %47
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
%397 = load i32, i32* %396
store i32 %397, i32* %48
%398 = load double*, double** %31
%399 = load i32, i32* %48
%400 = load i32, i32* %64
%401 = load i32, i32* %20
%402 = mul nsw i32 %400, %401
%403 = add nsw i32 %399, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %398, i64 %404
%406 = load double, double* %405
%407 = load double*, double** %32
%408 = load i32, i32* %48
%409 = load i32, i32* %65
%410 = load i32, i32* %20
%411 = mul nsw i32 %409, %410
%412 = add nsw i32 %408, %411
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %407, i64 %413
%415 = load double, double* %414
%416 = load double, double* %62
%417 = call double @llvm.fmuladd.f64(double %406, double %415, double %416)
store double %417, double* %62
br label %418
418: ; preds = %392
%419 = load i32, i32* %47
%420 = add nsw i32 %419, 1
store i32 %420, i32* %47
br label %388
421: ; preds = %388
%422 = load i32, i32* %64
%423 = load i32, i32* %30
%424 = srem i32 %422, %423
%425 = add nsw i32 %424, 1
store i32 %425, i32* %64
%426 = load double, double* %62
%427 = load double*, double** %29
%428 = load i32, i32* %50
%429 = load i32, i32* %53
%430 = load i32, i32* %49
%431 = mul nsw i32 %429, %430
%432 = add nsw i32 %428, %431
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %427, i64 %433
store double %426, double* %434
br label %435
435: ; preds = %421
%436 = load i32, i32* %46
%437 = add nsw i32 %436, 1
store i32 %437, i32* %46
br label %378
438: ; preds = %378
%439 = load i32, i32* %35
%440 = sub nsw i32 %439, 1
store i32 %440, i32* %59
br label %443
441: ; preds = %18
%442 = load i32, i32* %35
store i32 %442, i32* %59
br label %443
443: ; preds = %441, %438
%444 = load i32*, i32** %36
%445 = load i32, i32* %444
store i32 %445, i32* %64
store i32 1, i32* %52
br label %446
446: ; preds = %631, %443
%447 = load i32, i32* %52
%448 = load i32, i32* %59
%449 = icmp sle i32 %447, %448
br i1 %449, label %450, label %634
450: ; preds = %446
%451 = load i32, i32* %30
%452 = load i32, i32* %52
%453 = add nsw i32 %451, %452
store i32 %453, i32* %50
%454 = load i32*, i32** %36
%455 = load i32, i32* %454
store i32 %455, i32* %65
store i32 1, i32* %53
br label %456
456: ; preds = %623, %450
%457 = load i32, i32* %53
%458 = load i32, i32* %52
%459 = icmp sle i32 %457, %458
br i1 %459, label %460, label %626
460: ; preds = %456
%461 = load i32, i32* %30
%462 = load i32, i32* %53
%463 = add nsw i32 %461, %462
store i32 %463, i32* %51
store double 0.000000e+00, double* %60
store double 0.000000e+00, double* %61
store double 0.000000e+00, double* %62
store double 0.000000e+00, double* %63
%464 = load i32*, i32** %23
%465 = load i32, i32* %464
store i32 %465, i32* %45
store i32 1, i32* %47
br label %466
466: ; preds = %516, %460
%467 = load i32, i32* %47
%468 = load i32, i32* %45
%469 = icmp sle i32 %467, %468
br i1 %469, label %470, label %519
470: ; preds = %466
%471 = load i32*, i32** %25
%472 = load i32, i32* %47
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %471, i64 %473
%475 = load i32, i32* %474
store i32 %475, i32* %48
%476 = load double*, double** %32
%477 = load i32, i32* %48
%478 = load i32, i32* %64
%479 = load i32, i32* %20
%480 = mul nsw i32 %478, %479
%481 = add nsw i32 %477, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %476, i64 %482
%484 = load double, double* %483
%485 = load double*, double** %32
%486 = load i32, i32* %48
%487 = load i32, i32* %65
%488 = load i32, i32* %20
%489 = mul nsw i32 %487, %488
%490 = add nsw i32 %486, %489
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %485, i64 %491
%493 = load double, double* %492
%494 = load double, double* %60
%495 = call double @llvm.fmuladd.f64(double %484, double %493, double %494)
store double %495, double* %60
%496 = load double*, double** %31
%497 = load i32, i32* %48
%498 = load i32, i32* %64
%499 = load i32, i32* %20
%500 = mul nsw i32 %498, %499
%501 = add nsw i32 %497, %500
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds double, double* %496, i64 %502
%504 = load double, double* %503
%505 = load double*, double** %31
%506 = load i32, i32* %48
%507 = load i32, i32* %65
%508 = load i32, i32* %20
%509 = mul nsw i32 %507, %508
%510 = add nsw i32 %506, %509
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %505, i64 %511
%513 = load double, double* %512
%514 = load double, double* %61
%515 = call double @llvm.fmuladd.f64(double %504, double %513, double %514)
store double %515, double* %61
br label %516
516: ; preds = %470
%517 = load i32, i32* %47
%518 = add nsw i32 %517, 1
store i32 %518, i32* %47
br label %466
519: ; preds = %466
%520 = load i32, i32* %20
store i32 %520, i32* %45
%521 = load i32*, i32** %24
%522 = load i32, i32* %521
store i32 %522, i32* %47
br label %523
523: ; preds = %573, %519
%524 = load i32, i32* %47
%525 = load i32, i32* %45
%526 = icmp sle i32 %524, %525
br i1 %526, label %527, label %576
527: ; preds = %523
%528 = load i32*, i32** %25
%529 = load i32, i32* %47
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds i32, i32* %528, i64 %530
%532 = load i32, i32* %531
store i32 %532, i32* %48
%533 = load double*, double** %32
%534 = load i32, i32* %48
%535 = load i32, i32* %64
%536 = load i32, i32* %20
%537 = mul nsw i32 %535, %536
%538 = add nsw i32 %534, %537
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds double, double* %533, i64 %539
%541 = load double, double* %540
%542 = load double*, double** %32
%543 = load i32, i32* %48
%544 = load i32, i32* %65
%545 = load i32, i32* %20
%546 = mul nsw i32 %544, %545
%547 = add nsw i32 %543, %546
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double, double* %542, i64 %548
%550 = load double, double* %549
%551 = load double, double* %62
%552 = call double @llvm.fmuladd.f64(double %541, double %550, double %551)
store double %552, double* %62
%553 = load double*, double** %31
%554 = load i32, i32* %48
%555 = load i32, i32* %64
%556 = load i32, i32* %20
%557 = mul nsw i32 %555, %556
%558 = add nsw i32 %554, %557
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds double, double* %553, i64 %559
%561 = load double, double* %560
%562 = load double*, double** %31
%563 = load i32, i32* %48
%564 = load i32, i32* %65
%565 = load i32, i32* %20
%566 = mul nsw i32 %564, %565
%567 = add nsw i32 %563, %566
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds double, double* %562, i64 %568
%570 = load double, double* %569
%571 = load double, double* %63
%572 = call double @llvm.fmuladd.f64(double %561, double %570, double %571)
store double %572, double* %63
br label %573
573: ; preds = %527
%574 = load i32, i32* %47
%575 = add nsw i32 %574, 1
store i32 %575, i32* %47
br label %523
576: ; preds = %523
%577 = load double*, double** %29
%578 = load i32, i32* %52
%579 = load i32, i32* %53
%580 = load i32, i32* %49
%581 = mul nsw i32 %579, %580
%582 = add nsw i32 %578, %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds double, double* %577, i64 %583
%585 = load double, double* %584
%586 = load double, double* %60
%587 = fadd double %585, %586
%588 = load double, double* %62
%589 = fsub double %587, %588
%590 = load double*, double** %29
%591 = load i32, i32* %52
%592 = load i32, i32* %53
%593 = load i32, i32* %49
%594 = mul nsw i32 %592, %593
%595 = add nsw i32 %591, %594
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %590, i64 %596
store double %589, double* %597
%598 = load double*, double** %29
%599 = load i32, i32* %50
%600 = load i32, i32* %51
%601 = load i32, i32* %49
%602 = mul nsw i32 %600, %601
%603 = add nsw i32 %599, %602
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %598, i64 %604
%606 = load double, double* %605
%607 = load double, double* %61
%608 = fsub double %606, %607
%609 = load double, double* %63
%610 = fadd double %608, %609
%611 = load double*, double** %29
%612 = load i32, i32* %50
%613 = load i32, i32* %51
%614 = load i32, i32* %49
%615 = mul nsw i32 %613, %614
%616 = add nsw i32 %612, %615
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %611, i64 %617
store double %610, double* %618
%619 = load i32, i32* %65
%620 = load i32, i32* %30
%621 = srem i32 %619, %620
%622 = add nsw i32 %621, 1
store i32 %622, i32* %65
br label %623
623: ; preds = %576
%624 = load i32, i32* %53
%625 = add nsw i32 %624, 1
store i32 %625, i32* %53
br label %456
626: ; preds = %456
%627 = load i32, i32* %64
%628 = load i32, i32* %30
%629 = srem i32 %627, %628
%630 = add nsw i32 %629, 1
store i32 %630, i32* %64
br label %631
631: ; preds = %626
%632 = load i32, i32* %52
%633 = add nsw i32 %632, 1
store i32 %633, i32* %52
br label %446
634: ; preds = %446
%635 = load i32*, i32** %36
%636 = load i32, i32* %635
store i32 %636, i32* %64
%637 = load i32, i32* %30
%638 = load i32, i32* %59
%639 = add nsw i32 %637, %638
store i32 %639, i32* %43
%640 = load i32, i32* %30
%641 = add nsw i32 %640, 1
store i32 %641, i32* %50
br label %642
642: ; preds = %788, %634
%643 = load i32, i32* %50
%644 = load i32, i32* %43
%645 = icmp sle i32 %643, %644
br i1 %645, label %646, label %791
646: ; preds = %642
%647 = load i32*, i32** %36
%648 = load i32, i32* %647
store i32 %648, i32* %65
%649 = load i32, i32* %59
store i32 %649, i32* %44
store i32 1, i32* %53
br label %650
650: ; preds = %780, %646
%651 = load i32, i32* %53
%652 = load i32, i32* %44
%653 = icmp sle i32 %651, %652
br i1 %653, label %654, label %783
654: ; preds = %650
store double 0.000000e+00, double* %60
store double 0.000000e+00, double* %62
store i32 1, i32* %47
br label %655
655: ; preds = %686, %654
%656 = load i32, i32* %47
%657 = load i32*, i32** %23
%658 = load i32, i32* %657
%659 = icmp sle i32 %656, %658
br i1 %659, label %660, label %689
660: ; preds = %655
%661 = load i32*, i32** %25
%662 = load i32, i32* %47
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds i32, i32* %661, i64 %663
%665 = load i32, i32* %664
store i32 %665, i32* %48
%666 = load double*, double** %31
%667 = load i32, i32* %48
%668 = load i32, i32* %64
%669 = load i32, i32* %20
%670 = mul nsw i32 %668, %669
%671 = add nsw i32 %667, %670
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %666, i64 %672
%674 = load double, double* %673
%675 = load double*, double** %32
%676 = load i32, i32* %48
%677 = load i32, i32* %65
%678 = load i32, i32* %20
%679 = mul nsw i32 %677, %678
%680 = add nsw i32 %676, %679
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %675, i64 %681
%683 = load double, double* %682
%684 = load double, double* %60
%685 = call double @llvm.fmuladd.f64(double %674, double %683, double %684)
store double %685, double* %60
br label %686
686: ; preds = %660
%687 = load i32, i32* %47
%688 = add nsw i32 %687, 1
store i32 %688, i32* %47
br label %655
689: ; preds = %655
%690 = load i32*, i32** %24
%691 = load i32, i32* %690
store i32 %691, i32* %47
br label %692
692: ; preds = %722, %689
%693 = load i32, i32* %47
%694 = load i32, i32* %20
%695 = icmp sle i32 %693, %694
br i1 %695, label %696, label %725
696: ; preds = %692
%697 = load i32*, i32** %25
%698 = load i32, i32* %47
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds i32, i32* %697, i64 %699
%701 = load i32, i32* %700
store i32 %701, i32* %48
%702 = load double*, double** %31
%703 = load i32, i32* %48
%704 = load i32, i32* %64
%705 = load i32, i32* %20
%706 = mul nsw i32 %704, %705
%707 = add nsw i32 %703, %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %702, i64 %708
%710 = load double, double* %709
%711 = load double*, double** %32
%712 = load i32, i32* %48
%713 = load i32, i32* %65
%714 = load i32, i32* %20
%715 = mul nsw i32 %713, %714
%716 = add nsw i32 %712, %715
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %711, i64 %717
%719 = load double, double* %718
%720 = load double, double* %62
%721 = call double @llvm.fmuladd.f64(double %710, double %719, double %720)
store double %721, double* %62
br label %722
722: ; preds = %696
%723 = load i32, i32* %47
%724 = add nsw i32 %723, 1
store i32 %724, i32* %47
br label %692
725: ; preds = %692
%726 = load i32, i32* %50
%727 = load i32, i32* %53
%728 = load i32, i32* %30
%729 = add nsw i32 %727, %728
%730 = icmp sle i32 %726, %729
br i1 %730, label %731, label %753
731: ; preds = %725
%732 = load double*, double** %29
%733 = load i32, i32* %50
%734 = load i32, i32* %53
%735 = load i32, i32* %49
%736 = mul nsw i32 %734, %735
%737 = add nsw i32 %733, %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds double, double* %732, i64 %738
%740 = load double, double* %739
%741 = load double, double* %60
%742 = fadd double %740, %741
%743 = load double, double* %62
%744 = fsub double %742, %743
%745 = load double*, double** %29
%746 = load i32, i32* %50
%747 = load i32, i32* %53
%748 = load i32, i32* %49
%749 = mul nsw i32 %747, %748
%750 = add nsw i32 %746, %749
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds double, double* %745, i64 %751
store double %744, double* %752
br label %775
753: ; preds = %725
%754 = load double*, double** %29
%755 = load i32, i32* %50
%756 = load i32, i32* %53
%757 = load i32, i32* %49
%758 = mul nsw i32 %756, %757
%759 = add nsw i32 %755, %758
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds double, double* %754, i64 %760
%762 = load double, double* %761
%763 = load double, double* %60
%764 = fsub double %762, %763
%765 = load double, double* %62
%766 = fadd double %764, %765
%767 = load double*, double** %29
%768 = load i32, i32* %50
%769 = load i32, i32* %53
%770 = load i32, i32* %49
%771 = mul nsw i32 %769, %770
%772 = add nsw i32 %768, %771
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds double, double* %767, i64 %773
store double %766, double* %774
br label %775
775: ; preds = %753, %731
%776 = load i32, i32* %65
%777 = load i32, i32* %30
%778 = srem i32 %776, %777
%779 = add nsw i32 %778, 1
store i32 %779, i32* %65
br label %780
780: ; preds = %775
%781 = load i32, i32* %53
%782 = add nsw i32 %781, 1
store i32 %782, i32* %53
br label %650
783: ; preds = %650
%784 = load i32, i32* %64
%785 = load i32, i32* %30
%786 = srem i32 %784, %785
%787 = add nsw i32 %786, 1
store i32 %787, i32* %64
br label %788
788: ; preds = %783
%789 = load i32, i32* %50
%790 = add nsw i32 %789, 1
store i32 %790, i32* %50
br label %642
791: ; preds = %642
store i32 1, i32* %52
br label %792
792: ; preds = %930, %791
%793 = load i32, i32* %52
%794 = load i32, i32* %35
%795 = icmp sle i32 %793, %794
br i1 %795, label %796, label %933
796: ; preds = %792
%797 = load i32, i32* %35
%798 = load i32, i32* %52
%799 = add nsw i32 %797, %798
store i32 %799, i32* %50
%800 = load i32, i32* %30
%801 = load i32, i32* %52
%802 = add nsw i32 %800, %801
store i32 %802, i32* %54
store i32 1, i32* %53
br label %803
803: ; preds = %852, %796
%804 = load i32, i32* %53
%805 = load i32, i32* %52
%806 = icmp sle i32 %804, %805
br i1 %806, label %807, label %855
807: ; preds = %803
%808 = load i32, i32* %35
%809 = load i32, i32* %53
%810 = add nsw i32 %808, %809
store i32 %810, i32* %51
%811 = load i32, i32* %30
%812 = load i32, i32* %53
%813 = add nsw i32 %811, %812
store i32 %813, i32* %55
%814 = load double*, double** %29
%815 = load i32, i32* %52
%816 = load i32, i32* %53
%817 = load i32, i32* %49
%818 = mul nsw i32 %816, %817
%819 = add nsw i32 %815, %818
%820 = sext i32 %819 to i64
%821 = getelementptr inbounds double, double* %814, i64 %820
%822 = load double, double* %821
%823 = load double, double* %34
%824 = fdiv double %822, %823
%825 = load double*, double** %28
%826 = load i32, i32* %53
%827 = load i32, i32* %52
%828 = load i32, i32* %49
%829 = mul nsw i32 %827, %828
%830 = add nsw i32 %826, %829
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds double, double* %825, i64 %831
store double %824, double* %832
%833 = load double*, double** %29
%834 = load i32, i32* %54
%835 = load i32, i32* %55
%836 = load i32, i32* %49
%837 = mul nsw i32 %835, %836
%838 = add nsw i32 %834, %837
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds double, double* %833, i64 %839
%841 = load double, double* %840
%842 = load double, double* %34
%843 = fmul double %841, %842
%844 = load double*, double** %28
%845 = load i32, i32* %51
%846 = load i32, i32* %50
%847 = load i32, i32* %49
%848 = mul nsw i32 %846, %847
%849 = add nsw i32 %845, %848
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds double, double* %844, i64 %850
store double %843, double* %851
br label %852
852: ; preds = %807
%853 = load i32, i32* %53
%854 = add nsw i32 %853, 1
store i32 %854, i32* %53
br label %803
855: ; preds = %803
store i32 1, i32* %53
br label %856
856: ; preds = %880, %855
%857 = load i32, i32* %53
%858 = load i32, i32* %52
%859 = sub nsw i32 %858, 1
%860 = icmp sle i32 %857, %859
br i1 %860, label %861, label %883
861: ; preds = %856
%862 = load double*, double** %29
%863 = load i32, i32* %54
%864 = load i32, i32* %53
%865 = load i32, i32* %49
%866 = mul nsw i32 %864, %865
%867 = add nsw i32 %863, %866
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %862, i64 %868
%870 = load double, double* %869
%871 = fneg double %870
%872 = load double*, double** %28
%873 = load i32, i32* %53
%874 = load i32, i32* %50
%875 = load i32, i32* %49
%876 = mul nsw i32 %874, %875
%877 = add nsw i32 %873, %876
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds double, double* %872, i64 %878
store double %871, double* %879
br label %880
880: ; preds = %861
%881 = load i32, i32* %53
%882 = add nsw i32 %881, 1
store i32 %882, i32* %53
br label %856
883: ; preds = %856
%884 = load i32, i32* %52
store i32 %884, i32* %53
br label %885
885: ; preds = %907, %883
%886 = load i32, i32* %53
%887 = load i32, i32* %35
%888 = icmp sle i32 %886, %887
br i1 %888, label %889, label %910
889: ; preds = %885
%890 = load double*, double** %29
%891 = load i32, i32* %54
%892 = load i32, i32* %53
%893 = load i32, i32* %49
%894 = mul nsw i32 %892, %893
%895 = add nsw i32 %891, %894
%896 = sext i32 %895 to i64
%897 = getelementptr inbounds double, double* %890, i64 %896
%898 = load double, double* %897
%899 = load double*, double** %28
%900 = load i32, i32* %53
%901 = load i32, i32* %50
%902 = load i32, i32* %49
%903 = mul nsw i32 %901, %902
%904 = add nsw i32 %900, %903
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds double, double* %899, i64 %905
store double %898, double* %906
br label %907
907: ; preds = %889
%908 = load i32, i32* %53
%909 = add nsw i32 %908, 1
store i32 %909, i32* %53
br label %885
910: ; preds = %885
%911 = load double*, double** %33
%912 = load i32, i32* %52
%913 = load i32, i32* %52
%914 = load i32, i32* %30
%915 = mul nsw i32 %913, %914
%916 = add nsw i32 %912, %915
%917 = sext i32 %916 to i64
%918 = getelementptr inbounds double, double* %911, i64 %917
%919 = load double, double* %918
%920 = load double*, double** %28
%921 = load i32, i32* %52
%922 = load i32, i32* %52
%923 = load i32, i32* %49
%924 = mul nsw i32 %922, %923
%925 = add nsw i32 %921, %924
%926 = sext i32 %925 to i64
%927 = getelementptr inbounds double, double* %920, i64 %926
%928 = load double, double* %927
%929 = fadd double %928, %919
store double %929, double* %927
br label %930
930: ; preds = %910
%931 = load i32, i32* %52
%932 = add nsw i32 %931, 1
store i32 %932, i32* %52
br label %792
933: ; preds = %792
%934 = load double*, double** %28
%935 = load i32, i32* %38
%936 = sext i32 %935 to i64
%937 = getelementptr inbounds double, double* %934, i64 %936
%938 = load i32, i32* %49
%939 = load i32, i32* %35
%940 = load i32*, i32** %37
%941 = call i32 (double*, i32, i32, i32*, ...) bitcast (i32 (...)* @dpofa_ to i32 (double*, i32, i32, i32*, ...)*)(double* %937, i32 %938, i32 %939, i32* %940)
%942 = load i32*, i32** %37
%943 = load i32, i32* %942
%944 = icmp ne i32 %943, 0
br i1 %944, label %945, label %947
945: ; preds = %933
%946 = load i32*, i32** %37
store i32 -1, i32* %946
store i32 0, i32* %19
br label %1044
947: ; preds = %933
%948 = load i32, i32* %35
%949 = shl i32 %948, 1
store i32 %949, i32* %56
%950 = load i32, i32* %35
%951 = add nsw i32 %950, 1
store i32 %951, i32* %51
br label %952
952: ; preds = %972, %947
%953 = load i32, i32* %51
%954 = load i32, i32* %56
%955 = icmp sle i32 %953, %954
br i1 %955, label %956, label %975
956: ; preds = %952
%957 = load double*, double** %28
%958 = load i32, i32* %38
%959 = sext i32 %958 to i64
%960 = getelementptr inbounds double, double* %957, i64 %959
%961 = load i32, i32* %49
%962 = load i32, i32* %35
%963 = load double*, double** %28
%964 = load i32, i32* %51
%965 = load i32, i32* %49
%966 = mul nsw i32 %964, %965
%967 = add nsw i32 %966, 1
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds double, double* %963, i64 %968
%970 = load i32*, i32** %37
%971 = call i32 (double*, i32, i32, double*, i32, i32*, ...) bitcast (i32 (...)* @dtrsl_ to i32 (double*, i32, i32, double*, i32, i32*, ...)*)(double* %960, i32 %961, i32 %962, double* %969, i32 1, i32* %970)
br label %972
972: ; preds = %956
%973 = load i32, i32* %51
%974 = add nsw i32 %973, 1
store i32 %974, i32* %51
br label %952
975: ; preds = %952
%976 = load i32, i32* %35
%977 = add nsw i32 %976, 1
store i32 %977, i32* %50
br label %978
978: ; preds = %1020, %975
%979 = load i32, i32* %50
%980 = load i32, i32* %56
%981 = icmp sle i32 %979, %980
br i1 %981, label %982, label %1023
982: ; preds = %978
%983 = load i32, i32* %50
store i32 %983, i32* %51
br label %984
984: ; preds = %1016, %982
%985 = load i32, i32* %51
%986 = load i32, i32* %56
%987 = icmp sle i32 %985, %986
br i1 %987, label %988, label %1019
988: ; preds = %984
%989 = load i32, i32* %35
%990 = load double*, double** %28
%991 = load i32, i32* %50
%992 = load i32, i32* %49
%993 = mul nsw i32 %991, %992
%994 = add nsw i32 %993, 1
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds double, double* %990, i64 %995
%997 = load double*, double** %28
%998 = load i32, i32* %51
%999 = load i32, i32* %49
%1000 = mul nsw i32 %998, %999
%1001 = add nsw i32 %1000, 1
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %997, i64 %1002
%1004 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @ddot_ to i32 (i32, double*, double*, ...)*)(i32 %989, double* %996, double* %1003)
%1005 = sitofp i32 %1004 to double
%1006 = load double*, double** %28
%1007 = load i32, i32* %50
%1008 = load i32, i32* %51
%1009 = load i32, i32* %49
%1010 = mul nsw i32 %1008, %1009
%1011 = add nsw i32 %1007, %1010
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1006, i64 %1012
%1014 = load double, double* %1013
%1015 = fadd double %1014, %1005
store double %1015, double* %1013
br label %1016
1016: ; preds = %988
%1017 = load i32, i32* %51
%1018 = add nsw i32 %1017, 1
store i32 %1018, i32* %51
br label %984
1019: ; preds = %984
br label %1020
1020: ; preds = %1019
%1021 = load i32, i32* %50
%1022 = add nsw i32 %1021, 1
store i32 %1022, i32* %50
br label %978
1023: ; preds = %978
%1024 = load double*, double** %28
%1025 = load i32, i32* %35
%1026 = add nsw i32 %1025, 1
%1027 = load i32, i32* %35
%1028 = add nsw i32 %1027, 1
%1029 = load i32, i32* %49
%1030 = mul nsw i32 %1028, %1029
%1031 = add nsw i32 %1026, %1030
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds double, double* %1024, i64 %1032
%1034 = load i32, i32* %49
%1035 = load i32, i32* %35
%1036 = load i32*, i32** %37
%1037 = call i32 (double*, i32, i32, i32*, ...) bitcast (i32 (...)* @dpofa_ to i32 (double*, i32, i32, i32*, ...)*)(double* %1033, i32 %1034, i32 %1035, i32* %1036)
%1038 = load i32*, i32** %37
%1039 = load i32, i32* %1038
%1040 = icmp ne i32 %1039, 0
br i1 %1040, label %1041, label %1043
1041: ; preds = %1023
%1042 = load i32*, i32** %37
store i32 -2, i32* %1042
store i32 0, i32* %19
br label %1044
1043: ; preds = %1023
store i32 0, i32* %19
br label %1044
1044: ; preds = %1043, %1041, %945
%1045 = load i32, i32* %19
ret i32 %1045
}

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