void UpdSnodes(int m, int n, int s, double diaga[], double *a, int fira[],
               double diagb[], double *b, int firb[], int subb[]) {
  int i, j, k, t, u, sze, delay, *ls;
  double rtemp1, rtemp2, rtemp3, rtemp4, rtemp5, rtemp6, rtemp7, rtemp8, rtemp9,
      rtemp10, rtemp11, rtemp12, rtemp13, rtemp14, rtemp15, rtemp16, *a1, *a2,
      *a3, *a4, *a5, *a6, *a7, *a8, *a9, *a10, *a11, *a12, *a13, *a14, *a15,
      *a16, *b0;
  if (m < s)
    exit(0);
  if (m == 0 || n == 0)
    return;
  for (i = 0; i < s; ++i) {
    j = subb[i];
    u = j - subb[0];
    b0 = b + firb[u];
    delay = j + 1;
    sze = m - i - 1;
    ls = subb + i + 1;
    k = 0;
    for (; k + 15 < n; k += 16) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      a3 = a + (fira[k + 2] + i);
      a4 = a + (fira[k + 3] + i);
      a5 = a + (fira[k + 4] + i);
      a6 = a + (fira[k + 5] + i);
      a7 = a + (fira[k + 6] + i);
      a8 = a + (fira[k + 7] + i);
      a9 = a + (fira[k + 8] + i);
      a10 = a + (fira[k + 9] + i);
      a11 = a + (fira[k + 10] + i);
      a12 = a + (fira[k + 11] + i);
      a13 = a + (fira[k + 12] + i);
      a14 = a + (fira[k + 13] + i);
      a15 = a + (fira[k + 14] + i);
      a16 = a + (fira[k + 15] + i);
      rtemp1 = *a1 / diaga[k + 0];
      rtemp2 = *a2 / diaga[k + 1];
      rtemp3 = *a3 / diaga[k + 2];
      rtemp4 = *a4 / diaga[k + 3];
      rtemp5 = *a5 / diaga[k + 4];
      rtemp6 = *a6 / diaga[k + 5];
      rtemp7 = *a7 / diaga[k + 6];
      rtemp8 = *a8 / diaga[k + 7];
      rtemp9 = *a9 / diaga[k + 8];
      rtemp10 = *a10 / diaga[k + 9];
      rtemp11 = *a11 / diaga[k + 10];
      rtemp12 = *a12 / diaga[k + 11];
      rtemp13 = *a13 / diaga[k + 12];
      rtemp14 = *a14 / diaga[k + 13];
      rtemp15 = *a15 / diaga[k + 14];
      rtemp16 = *a16 / diaga[k + 15];
      diagb[u] -= rtemp1 * (*a1) + rtemp2 * (*a2) + rtemp3 * (*a3) +
                  rtemp4 * (*a4) + rtemp5 * (*a5) + rtemp6 * (*a6) +
                  rtemp7 * (*a7) + rtemp8 * (*a8) + rtemp9 * (*a9) +
                  rtemp10 * (*a10) + rtemp11 * (*a11) + rtemp12 * (*a12) +
                  rtemp13 * (*a13) + rtemp14 * (*a14) + rtemp15 * (*a15) +
                  rtemp16 * (*a16);
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      ++a5;
      ++a6;
      ++a7;
      ++a8;
      ++a9;
      ++a10;
      ++a11;
      ++a12;
      ++a13;
      ++a14;
      ++a15;
      ++a16;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -=
            rtemp1 * a1[t] + rtemp2 * a2[t] + rtemp3 * a3[t] + rtemp4 * a4[t] +
            rtemp5 * a5[t] + rtemp6 * a6[t] + rtemp7 * a7[t] + rtemp8 * a8[t] +
            rtemp9 * a9[t] + rtemp10 * a10[t] + rtemp11 * a11[t] +
            rtemp12 * a12[t] + rtemp13 * a13[t] + rtemp14 * a14[t] +
            rtemp15 * a15[t] + rtemp16 * a16[t];
    }
    for (; k + 11 < n; k += 12) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      a3 = a + (fira[k + 2] + i);
      a4 = a + (fira[k + 3] + i);
      a5 = a + (fira[k + 4] + i);
      a6 = a + (fira[k + 5] + i);
      a7 = a + (fira[k + 6] + i);
      a8 = a + (fira[k + 7] + i);
      a9 = a + (fira[k + 8] + i);
      a10 = a + (fira[k + 9] + i);
      a11 = a + (fira[k + 10] + i);
      a12 = a + (fira[k + 11] + i);
      rtemp1 = *a1 / diaga[k + 0];
      rtemp2 = *a2 / diaga[k + 1];
      rtemp3 = *a3 / diaga[k + 2];
      rtemp4 = *a4 / diaga[k + 3];
      rtemp5 = *a5 / diaga[k + 4];
      rtemp6 = *a6 / diaga[k + 5];
      rtemp7 = *a7 / diaga[k + 6];
      rtemp8 = *a8 / diaga[k + 7];
      rtemp9 = *a9 / diaga[k + 8];
      rtemp10 = *a10 / diaga[k + 9];
      rtemp11 = *a11 / diaga[k + 10];
      rtemp12 = *a12 / diaga[k + 11];
      diagb[u] -= rtemp1 * (*a1) + rtemp2 * (*a2) + rtemp3 * (*a3) +
                  rtemp4 * (*a4) + rtemp5 * (*a5) + rtemp6 * (*a6) +
                  rtemp7 * (*a7) + rtemp8 * (*a8) + rtemp9 * (*a9) +
                  rtemp10 * (*a10) + rtemp11 * (*a11) + rtemp12 * (*a12);
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      ++a5;
      ++a6;
      ++a7;
      ++a8;
      ++a9;
      ++a10;
      ++a11;
      ++a12;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -= rtemp1 * a1[t] + rtemp2 * a2[t] + rtemp3 * a3[t] +
                             rtemp4 * a4[t] + rtemp5 * a5[t] + rtemp6 * a6[t] +
                             rtemp7 * a7[t] + rtemp8 * a8[t] + rtemp9 * a9[t] +
                             rtemp10 * a10[t] + rtemp11 * a11[t] +
                             rtemp12 * a12[t];
    }
    for (; k + 7 < n; k += 8) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      a3 = a + (fira[k + 2] + i);
      a4 = a + (fira[k + 3] + i);
      a5 = a + (fira[k + 4] + i);
      a6 = a + (fira[k + 5] + i);
      a7 = a + (fira[k + 6] + i);
      a8 = a + (fira[k + 7] + i);
      rtemp1 = *a1 / diaga[k + 0];
      rtemp2 = *a2 / diaga[k + 1];
      rtemp3 = *a3 / diaga[k + 2];
      rtemp4 = *a4 / diaga[k + 3];
      rtemp5 = *a5 / diaga[k + 4];
      rtemp6 = *a6 / diaga[k + 5];
      rtemp7 = *a7 / diaga[k + 6];
      rtemp8 = *a8 / diaga[k + 7];
      diagb[u] -= rtemp1 * (*a1) + rtemp2 * (*a2) + rtemp3 * (*a3) +
                  rtemp4 * (*a4) + rtemp5 * (*a5) + rtemp6 * (*a6) +
                  rtemp7 * (*a7) + rtemp8 * (*a8);
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      ++a5;
      ++a6;
      ++a7;
      ++a8;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -= rtemp1 * a1[t] + rtemp2 * a2[t] + rtemp3 * a3[t] +
                             rtemp4 * a4[t] + rtemp5 * a5[t] + rtemp6 * a6[t] +
                             rtemp7 * a7[t] + rtemp8 * a8[t];
    }
    for (; k + 3 < n; k += 4) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      a3 = a + (fira[k + 2] + i);
      a4 = a + (fira[k + 3] + i);
      rtemp1 = *a1 / diaga[k + 0];
      rtemp2 = *a2 / diaga[k + 1];
      rtemp3 = *a3 / diaga[k + 2];
      rtemp4 = *a4 / diaga[k + 3];
      diagb[u] -=
          rtemp1 * (*a1) + rtemp2 * (*a2) + rtemp3 * (*a3) + rtemp4 * (*a4);
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -=
            rtemp1 * a1[t] + rtemp2 * a2[t] + rtemp3 * a3[t] + rtemp4 * a4[t];
    }
    for (; k + 1 < n; k += 2) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      rtemp1 = *a1 / diaga[k + 0];
      rtemp2 = *a2 / diaga[k + 1];
      diagb[u] -= rtemp1 * (*a1) + rtemp2 * (*a2);
      ++a1;
      ++a2;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -= rtemp1 * a1[t] + rtemp2 * a2[t];
    }
    for (; k < n; ++k) {
      a1 = a + (fira[k + 0] + i);
      rtemp1 = *a1 / diaga[k + 0];
      diagb[u] -= rtemp1 * (*a1);
      ++a1;
      for (t = 0; t < sze; ++t)
        b0[ls[t] - delay] -= rtemp1 * a1[t];
    }
  }
}


x86 assembly (clang, -O0):
<UpdSnodes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1153 <UpdSnodes+0x43>
xor    %edi,%edi
call   1030 <exit@plt>
cmpl   $0x0,-0x4(%rbp)
je     1167 <UpdSnodes+0x57>
cmpl   $0x0,-0x8(%rbp)
jne    116c <UpdSnodes+0x5c>
jmp    2de0 <UpdSnodes+0x1cd0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2de0 <UpdSnodes+0x1cd0>
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x28(%rbp),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x158(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0xf,%eax
cmp    -0x8(%rbp),%eax
jge    1bc3 <UpdSnodes+0xab3>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x9,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xa,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xb,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xc,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x138(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xd,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x140(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xe,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x148(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xf,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x150(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x120(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x130(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x138(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xd,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x148(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xe,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x150(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x120(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x130(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x138(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x150(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x100(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x100(%rbp)
mov    -0x108(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x108(%rbp)
mov    -0x110(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x110(%rbp)
mov    -0x118(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x118(%rbp)
mov    -0x120(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x120(%rbp)
mov    -0x128(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x128(%rbp)
mov    -0x130(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x130(%rbp)
mov    -0x138(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x138(%rbp)
mov    -0x140(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x140(%rbp)
mov    -0x148(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x148(%rbp)
mov    -0x150(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x150(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1bb0 <UpdSnodes+0xaa0>
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x110(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x120(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x128(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x130(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x138(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x140(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x148(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x150(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    198a <UpdSnodes+0x87a>
jmp    1bb5 <UpdSnodes+0xaa5>
mov    -0x34(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x34(%rbp)
jmp    11ea <UpdSnodes+0xda>
jmp    1bc8 <UpdSnodes+0xab8>
mov    -0x34(%rbp),%eax
add    $0xb,%eax
cmp    -0x8(%rbp),%eax
jge    2339 <UpdSnodes+0x1229>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x8,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x9,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xa,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0xb,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x120(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x130(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x120(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x130(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x100(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x100(%rbp)
mov    -0x108(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x108(%rbp)
mov    -0x110(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x110(%rbp)
mov    -0x118(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x118(%rbp)
mov    -0x120(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x120(%rbp)
mov    -0x128(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x128(%rbp)
mov    -0x130(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x130(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2326 <UpdSnodes+0x1216>
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x110(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x120(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x128(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x130(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2180 <UpdSnodes+0x1070>
jmp    232b <UpdSnodes+0x121b>
mov    -0x34(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x34(%rbp)
jmp    1bc8 <UpdSnodes+0xab8>
jmp    233e <UpdSnodes+0x122e>
mov    -0x34(%rbp),%eax
add    $0x7,%eax
cmp    -0x8(%rbp),%eax
jge    2847 <UpdSnodes+0x1737>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x4,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x5,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x6,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x7,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf8(%rbp)
mov    -0x100(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x100(%rbp)
mov    -0x108(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x108(%rbp)
mov    -0x110(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x110(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2834 <UpdSnodes+0x1724>
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm1
mov    -0x100(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x108(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x110(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    270e <UpdSnodes+0x15fe>
jmp    2839 <UpdSnodes+0x1729>
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    233e <UpdSnodes+0x122e>
jmp    284c <UpdSnodes+0x173c>
mov    -0x34(%rbp),%eax
add    $0x3,%eax
cmp    -0x8(%rbp),%eax
jge    2aff <UpdSnodes+0x19ef>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xf0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xf0(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2aec <UpdSnodes+0x19dc>
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2a40 <UpdSnodes+0x1930>
jmp    2af1 <UpdSnodes+0x19e1>
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    284c <UpdSnodes+0x173c>
jmp    2b04 <UpdSnodes+0x19f4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jge    2c95 <UpdSnodes+0x1b85>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xe0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xe0(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2c82 <UpdSnodes+0x1b72>
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2c10 <UpdSnodes+0x1b00>
jmp    2c87 <UpdSnodes+0x1b77>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    2b04 <UpdSnodes+0x19f4>
jmp    2c9a <UpdSnodes+0x1b8a>
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2dcd <UpdSnodes+0x1cbd>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x0,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2dba <UpdSnodes+0x1caa>
movsd  -0x58(%rbp),%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x158(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2d4a <UpdSnodes+0x1c3a>
jmp    2dbf <UpdSnodes+0x1caf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2c9a <UpdSnodes+0x1b8a>
jmp    2dd2 <UpdSnodes+0x1cc2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1173 <UpdSnodes+0x63>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<UpdSnodes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x60(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,0x58(%rsp)
cmp    %edx,%edi
jl     23ad <UpdSnodes+0x129d>
test   %edi,%edi
je     239b <UpdSnodes+0x128b>
mov    %esi,%r15d
test   %esi,%esi
je     239b <UpdSnodes+0x128b>
test   %edx,%edx
jle    239b <UpdSnodes+0x128b>
mov    0x198(%rsp),%rax
mov    (%rax),%ecx
movslq %r15d,%rsi
mov    %rsi,0xd8(%rsp)
mov    %edx,%edx
mov    %rdx,0xc8(%rsp)
lea    0x4(%rax),%rdx
lea    -0x1(%rdi),%esi
mov    0x28(%rsp),%rax
lea    0x8(%rax),%rbp
add    $0x10,%rax
mov    %rax,0x90(%rsp)
xor    %ebx,%ebx
movapd 0x1e67(%rip),%xmm8
mov    %rbp,0xa0(%rsp)
mov    %rbp,0x98(%rsp)
mov    %esi,0xac(%rsp)
mov    %rdx,0xc0(%rsp)
mov    %rdx,%r13
mov    %ecx,0xb0(%rsp)
mov    %ecx,%eax
mov    %r15d,0x54(%rsp)
mov    %rdi,0xd0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %esi,0xb4(%rsp)
mov    %esi,%ecx
mov    %rcx,0x78(%rsp)
lea    0x0(,%rcx,4),%rcx
mov    %rcx,0x88(%rsp)
movslq %eax,%rdx
sub    0xb0(%rsp),%eax
add    $0x1,%rdx
mov    %rbx,0x40(%rsp)
mov    %ebx,%ecx
not    %ecx
add    %edi,%ecx
mov    %ecx,0xc(%rsp)
movslq %eax,%rcx
mov    0x190(%rsp),%rax
mov    %rcx,0x68(%rsp)
movslq (%rax,%rcx,4),%rax
mov    0x188(%rsp),%rcx
lea    (%rcx,%rax,8),%r10
mov    $0x0,%r12d
cmp    $0x10,%r15d
mov    %r13,0x18(%rsp)
jl     183b <UpdSnodes+0x72b>
mov    %rdx,0x80(%rsp)
mov    $0xf,%ecx
xor    %r12d,%r12d
jmp    129d <UpdSnodes+0x18d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x140(%rsp),%r12
add    $0x10,%r12
mov    %r12,%rax
or     $0xf,%rax
mov    0xb8(%rsp),%rcx
add    $0x10,%rcx
cmp    0xd8(%rsp),%rax
jge    1820 <UpdSnodes+0x710>
mov    %rcx,0xb8(%rsp)
mov    0x60(%rsp),%r9
mov    (%r9,%r12,4),%eax
mov    0x40(%rsp),%rdx
add    %edx,%eax
mov    %eax,0x10(%rsp)
mov    %r12,%r15
or     $0x1,%r15
mov    (%r9,%r15,4),%r8d
add    %edx,%r8d
mov    %r12,%rdi
or     $0x2,%rdi
mov    (%r9,%rdi,4),%eax
add    %edx,%eax
mov    %eax,0x20(%rsp)
mov    %r12,%r11
or     $0x3,%r11
mov    (%r9,%r11,4),%eax
add    %edx,%eax
mov    %eax,0x38(%rsp)
mov    %r12,%rbp
or     $0x4,%rbp
mov    (%r9,%rbp,4),%eax
add    %edx,%eax
mov    %eax,0x30(%rsp)
mov    %r12,%rbx
or     $0x5,%rbx
mov    (%r9,%rbx,4),%eax
add    %edx,%eax
mov    %eax,0x48(%rsp)
mov    %r12,%rsi
or     $0x6,%rsi
mov    %r12,%r14
mov    (%r9,%rsi,4),%eax
add    %edx,%eax
mov    %eax,0x70(%rsp)
or     $0x7,%r12
mov    (%r9,%r12,4),%r13d
add    %edx,%r13d
movslq %r8d,%rax
mov    0x28(%rsp),%r8
mov    %rax,0x120(%rsp)
movsd  (%r8,%rax,8),%xmm9
movapd %xmm9,%xmm0
mov    0x58(%rsp),%rcx
divsd  (%rcx,%r15,8),%xmm0
movapd %xmm0,%xmm12
movsd  %xmm0,0x138(%rsp)
mov    %r14,%r15
or     $0x8,%r15
movslq 0x20(%rsp),%rax
mov    %rax,0x118(%rsp)
movsd  (%r8,%rax,8),%xmm7
movapd %xmm7,%xmm10
divsd  (%rcx,%rdi,8),%xmm10
mov    (%r9,%r15,4),%edi
movslq 0x38(%rsp),%rax
mov    %rax,0x110(%rsp)
movsd  (%r8,%rax,8),%xmm2
movapd %xmm2,%xmm11
divsd  (%rcx,%r11,8),%xmm11
add    %edx,%edi
mov    %r14,%rax
or     $0x9,%rax
movslq 0x30(%rsp),%r11
mov    %r11,0x108(%rsp)
movsd  (%r8,%r11,8),%xmm6
movapd %xmm6,%xmm8
divsd  (%rcx,%rbp,8),%xmm8
mov    (%r9,%rax,4),%r11d
add    %edx,%r11d
movslq 0x48(%rsp),%rbp
mov    %rbp,0x100(%rsp)
movsd  (%r8,%rbp,8),%xmm3
movapd %xmm3,%xmm0
divsd  (%rcx,%rbx,8),%xmm0
movapd %xmm0,%xmm15
mov    %r14,%rbx
movslq 0x70(%rsp),%rbp
mov    %rbp,0xf8(%rsp)
movsd  (%r8,%rbp,8),%xmm4
movapd %xmm4,%xmm0
divsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,0x128(%rsp)
or     $0xa,%rbx
mov    (%r9,%rbx,4),%esi
add    %edx,%esi
movslq %r13d,%rbp
mov    %rbp,0xe8(%rsp)
movsd  (%r8,%rbp,8),%xmm5
movapd %xmm5,%xmm0
divsd  (%rcx,%r12,8),%xmm0
movsd  %xmm0,0x130(%rsp)
mov    %r14,%r12
movslq 0x10(%rsp),%rbp
movslq %edi,%rdi
mov    %rbp,0xf0(%rsp)
movsd  (%r8,%rbp,8),%xmm0
movapd %xmm0,%xmm1
divsd  (%rcx,%r14,8),%xmm1
mulsd  %xmm12,%xmm9
movsd  %xmm1,0x20(%rsp)
mulsd  %xmm1,%xmm0
addsd  %xmm9,%xmm0
mov    %rdi,0xe0(%rsp)
movsd  (%r8,%rdi,8),%xmm1
movsd  %xmm10,0x10(%rsp)
mulsd  %xmm10,%xmm7
addsd  %xmm0,%xmm7
movapd %xmm1,%xmm0
divsd  (%rcx,%r15,8),%xmm0
or     $0xb,%r12
mov    (%r9,%r12,4),%edi
add    %edx,%edi
movslq %r11d,%r13
movapd %xmm11,%xmm13
mulsd  %xmm11,%xmm2
addsd  %xmm7,%xmm2
movsd  (%r8,%r13,8),%xmm7
movapd %xmm8,%xmm14
mulsd  %xmm8,%xmm6
addsd  %xmm2,%xmm6
movapd %xmm7,%xmm2
divsd  (%rcx,%rax,8),%xmm2
mov    %r14,%rax
or     $0xc,%rax
movslq %esi,%r11
movapd %xmm15,%xmm8
mulsd  %xmm15,%xmm3
addsd  %xmm6,%xmm3
movsd  (%r8,%r11,8),%xmm6
movsd  0x128(%rsp),%xmm8
movapd %xmm8,%xmm9
mulsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm3
divsd  (%rcx,%rbx,8),%xmm3
mov    (%r9,%rax,4),%esi
add    %edx,%esi
movslq %edi,%r15
movsd  0x130(%rsp),%xmm8
movapd %xmm8,%xmm12
mulsd  %xmm8,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r8,%r15,8),%xmm4
mulsd  %xmm0,%xmm1
addsd  %xmm5,%xmm1
movapd %xmm4,%xmm10
divsd  (%rcx,%r12,8),%xmm10
mov    %r14,%rbx
or     $0xd,%rbx
movslq %esi,%r12
mulsd  %xmm2,%xmm7
addsd  %xmm1,%xmm7
movsd  (%r8,%r12,8),%xmm1
mulsd  %xmm3,%xmm6
addsd  %xmm7,%xmm6
movapd %xmm1,%xmm5
divsd  (%rcx,%rax,8),%xmm5
mov    (%r9,%rbx,4),%eax
add    %edx,%eax
movslq %eax,%rdi
mulsd  %xmm10,%xmm4
addsd  %xmm6,%xmm4
movsd  (%r8,%rdi,8),%xmm6
movapd %xmm6,%xmm11
divsd  (%rcx,%rbx,8),%xmm11
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
mov    %r14,0x140(%rsp)
or     $0xe,%r14
mov    (%r9,%r14,4),%esi
add    %edx,%esi
movslq %esi,%rbx
mulsd  %xmm11,%xmm6
addsd  %xmm1,%xmm6
movsd  (%r8,%rbx,8),%xmm1
movapd %xmm1,%xmm7
divsd  (%rcx,%r14,8),%xmm7
mulsd  %xmm7,%xmm1
addsd  %xmm6,%xmm1
movsd  0x138(%rsp),%xmm6
mov    0xb8(%rsp),%rbp
mov    (%r9,%rbp,4),%eax
add    %edx,%eax
movslq %eax,%rsi
movsd  (%r8,%rsi,8),%xmm4
movapd %xmm4,%xmm8
divsd  (%rcx,%rbp,8),%xmm8
mulsd  %xmm8,%xmm4
addsd  %xmm1,%xmm4
mov    0x180(%rsp),%rax
mov    0x68(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
cmpl   $0x0,0xc(%rsp)
jle    1270 <UpdSnodes+0x160>
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rsi,8),%rax
mov    %rax,0x38(%rsp)
lea    (%rdx,%rbx,8),%rax
mov    %rax,0x30(%rsp)
lea    (%rdx,%rdi,8),%rax
mov    %rax,0x48(%rsp)
lea    (%rdx,%r12,8),%rax
mov    %rax,0x70(%rsp)
lea    (%rdx,%r15,8),%r15
lea    (%rdx,%r11,8),%r12
lea    (%rdx,%r13,8),%r11
mov    0xe0(%rsp),%rax
lea    (%rdx,%rax,8),%rbx
mov    0xe8(%rsp),%rax
lea    (%rdx,%rax,8),%r9
mov    0xf8(%rsp),%rax
lea    (%rdx,%rax,8),%rcx
mov    0x100(%rsp),%rax
lea    (%rdx,%rax,8),%r8
mov    0x108(%rsp),%rax
lea    (%rdx,%rax,8),%r14
mov    0x110(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    0x118(%rsp),%rsi
lea    (%rdx,%rsi,8),%r13
mov    0x120(%rsp),%rsi
lea    (%rdx,%rsi,8),%rbp
mov    0xf0(%rsp),%rsi
lea    (%rdx,%rsi,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rsi,2),%xmm1
mulsd  %xmm6,%xmm1
movsd  (%rdx,%rsi,2),%xmm4
mulsd  0x20(%rsp),%xmm4
addsd  %xmm1,%xmm4
movsd  0x0(%r13,%rsi,2),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm4,%xmm1
movsd  (%rax,%rsi,2),%xmm4
mulsd  %xmm13,%xmm4
addsd  %xmm1,%xmm4
movsd  (%r14,%rsi,2),%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm4,%xmm1
movsd  (%r8,%rsi,2),%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm1,%xmm4
movsd  (%rcx,%rsi,2),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm4,%xmm1
movsd  (%r9,%rsi,2),%xmm4
mulsd  %xmm12,%xmm4
addsd  %xmm1,%xmm4
movsd  (%rbx,%rsi,2),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm4,%xmm1
movsd  (%r11,%rsi,2),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm1,%xmm4
movsd  (%r12,%rsi,2),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
movsd  (%r15,%rsi,2),%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm1,%xmm4
mov    0x70(%rsp),%rdi
movsd  (%rdi,%rsi,2),%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
mov    0x48(%rsp),%rdi
movsd  (%rdi,%rsi,2),%xmm4
mulsd  %xmm11,%xmm4
addsd  %xmm1,%xmm4
mov    0x30(%rsp),%rdi
movsd  (%rdi,%rsi,2),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
mov    0x38(%rsp),%rdi
movsd  (%rdi,%rsi,2),%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm1,%xmm4
mov    0x18(%rsp),%rdi
movslq (%rdi,%rsi,1),%rdi
sub    0x80(%rsp),%rdi
movsd  (%r10,%rdi,8),%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,(%r10,%rdi,8)
add    $0x4,%rsi
cmp    %rsi,0x88(%rsp)
jne    16f0 <UpdSnodes+0x5e0>
jmp    1270 <UpdSnodes+0x160>
nopl   (%rax)
mov    0x54(%rsp),%r15d
movapd 0x17d2(%rip),%xmm8
mov    0x18(%rsp),%r13
mov    0x80(%rsp),%rdx
lea    0xb(%r12),%r11d
movslq %edx,%r14
cmp    %r15d,%r11d
mov    %r14,0x20(%rsp)
jge    1c33 <UpdSnodes+0xb23>
mov    %r12d,%edx
jmp    1881 <UpdSnodes+0x771>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
lea    0xc(%rax),%r12
mov    %eax,%r11d
add    $0x17,%r11d
mov    %r12,%rdx
mov    0x54(%rsp),%r15d
cmp    %r15d,%r11d
jge    1c20 <UpdSnodes+0xb10>
mov    0x60(%rsp),%rsi
mov    (%rsi,%rdx,4),%eax
mov    0x40(%rsp),%r9
add    %r9d,%eax
mov    %eax,0x10(%rsp)
mov    %edx,%r13d
or     $0x1,%r13d
mov    (%rsi,%r13,4),%eax
add    %r9d,%eax
mov    %edx,%ebx
or     $0x2,%ebx
mov    (%rsi,%rbx,4),%ecx
add    %r9d,%ecx
mov    %ecx,0x38(%rsp)
mov    %edx,%edi
or     $0x3,%edi
mov    (%rsi,%rdi,4),%ecx
add    %r9d,%ecx
mov    %ecx,0x48(%rsp)
mov    0x10(%rsi,%rdx,4),%ecx
add    %r9d,%ecx
mov    %ecx,0x30(%rsp)
mov    0x14(%rsi,%rdx,4),%r15d
add    %r9d,%r15d
mov    0x18(%rsi,%rdx,4),%r12d
add    %r9d,%r12d
mov    0x1c(%rsi,%rdx,4),%r14d
add    %r9d,%r14d
mov    0x20(%rsi,%rdx,4),%ebp
add    %r9d,%ebp
cltq
mov    0x28(%rsp),%rcx
mov    %rax,0x70(%rsp)
movsd  (%rcx,%rax,8),%xmm3
movapd %xmm3,%xmm9
mov    0x58(%rsp),%r8
divsd  (%r8,%r13,8),%xmm9
mov    0x24(%rsi,%rdx,4),%eax
add    %r9d,%eax
movslq 0x38(%rsp),%r13
mov    %r13,0x80(%rsp)
movsd  (%rcx,%r13,8),%xmm0
movapd %xmm0,%xmm8
divsd  (%r8,%rbx,8),%xmm8
mov    0x28(%rsi,%rdx,4),%ebx
add    %r9d,%ebx
mov    %r11d,%r11d
movslq 0x48(%rsp),%r13
mov    %r13,0x48(%rsp)
movsd  (%rcx,%r13,8),%xmm14
movapd %xmm14,%xmm10
divsd  (%r8,%rdi,8),%xmm10
mov    (%rsi,%r11,4),%edi
add    %r9d,%edi
movslq 0x10(%rsp),%r9
movslq 0x30(%rsp),%r13
movslq %r15d,%rsi
movslq %r12d,%r12
movsd  (%rcx,%r9,8),%xmm7
movapd %xmm7,%xmm11
divsd  (%r8,%rdx,8),%xmm11
movslq %r14d,%r15
movsd  (%rcx,%r13,8),%xmm2
movapd %xmm2,%xmm15
divsd  0x20(%r8,%rdx,8),%xmm15
movslq %ebp,%rbp
mov    %rsi,0x30(%rsp)
movsd  (%rcx,%rsi,8),%xmm1
movapd %xmm1,%xmm13
divsd  0x28(%r8,%rdx,8),%xmm13
cltq
movsd  (%rcx,%r12,8),%xmm6
movapd %xmm6,%xmm12
divsd  0x30(%r8,%rdx,8),%xmm12
mulsd  %xmm9,%xmm3
mulsd  %xmm11,%xmm7
addsd  %xmm3,%xmm7
movsd  (%rcx,%r15,8),%xmm3
mulsd  %xmm8,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm3,%xmm7
divsd  0x38(%r8,%rdx,8),%xmm7
movslq %ebx,%rsi
mulsd  %xmm10,%xmm14
addsd  %xmm0,%xmm14
movsd  (%rcx,%rbp,8),%xmm4
mulsd  %xmm15,%xmm2
addsd  %xmm14,%xmm2
movapd %xmm4,%xmm0
divsd  0x40(%r8,%rdx,8),%xmm0
movslq %edi,%rdi
mulsd  %xmm13,%xmm1
addsd  %xmm2,%xmm1
movsd  (%rcx,%rax,8),%xmm5
mulsd  %xmm12,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm5,%xmm1
divsd  0x48(%r8,%rdx,8),%xmm1
mulsd  %xmm7,%xmm3
addsd  %xmm6,%xmm3
movsd  (%rcx,%rsi,8),%xmm6
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm2
mov    %rdx,0x38(%rsp)
divsd  0x50(%r8,%rdx,8),%xmm2
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rcx,%rdi,8),%xmm4
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
movapd %xmm4,%xmm3
divsd  (%r8,%r11,8),%xmm3
mulsd  %xmm3,%xmm4
addsd  %xmm6,%xmm4
mov    0x180(%rsp),%rcx
mov    0x68(%rsp),%rbx
movsd  (%rcx,%rbx,8),%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,(%rcx,%rbx,8)
cmpl   $0x0,0xc(%rsp)
mov    0x20(%rsp),%r8
jle    1860 <UpdSnodes+0x750>
mov    %r13,%rdx
mov    0xa0(%rsp),%r13
lea    0x0(,%rdi,8),%rcx
add    %r13,%rcx
mov    %rcx,0x10(%rsp)
mov    %r9,%rdi
lea    0x0(%r13,%rsi,8),%r9
lea    0x0(%r13,%rax,8),%r11
lea    0x0(%r13,%rbp,8),%r14
lea    0x0(%r13,%r15,8),%r15
lea    0x0(%r13,%r12,8),%r12
mov    0x30(%rsp),%rax
lea    0x0(%r13,%rax,8),%rbx
lea    0x0(%r13,%rdx,8),%rdx
mov    0x48(%rsp),%rax
lea    0x0(%r13,%rax,8),%rax
mov    0x80(%rsp),%rcx
lea    0x0(%r13,%rcx,8),%rcx
mov    0x70(%rsp),%rsi
lea    0x0(,%rsi,8),%rbp
add    %r13,%rbp
lea    0x0(,%rdi,8),%rsi
add    %r13,%rsi
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r13,2),%xmm4
mulsd  %xmm9,%xmm4
movsd  (%rsi,%r13,2),%xmm5
mulsd  %xmm11,%xmm5
movsd  (%rcx,%r13,2),%xmm6
addsd  %xmm4,%xmm5
mulsd  %xmm8,%xmm6
movsd  (%rax,%r13,2),%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm5,%xmm6
addsd  %xmm6,%xmm4
movsd  (%rdx,%r13,2),%xmm5
mulsd  %xmm15,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rbx,%r13,2),%xmm4
mulsd  %xmm13,%xmm4
movsd  (%r12,%r13,2),%xmm6
addsd  %xmm5,%xmm4
mulsd  %xmm12,%xmm6
movsd  (%r15,%r13,2),%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm4,%xmm6
addsd  %xmm6,%xmm5
movsd  (%r14,%r13,2),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r11,%r13,2),%xmm5
mulsd  %xmm1,%xmm5
movsd  (%r9,%r13,2),%xmm6
addsd  %xmm4,%xmm5
mulsd  %xmm2,%xmm6
mov    0x10(%rsp),%rdi
movsd  (%rdi,%r13,2),%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm5,%xmm6
mov    0x18(%rsp),%rdi
movslq (%rdi,%r13,1),%rdi
sub    %r8,%rdi
movsd  (%r10,%rdi,8),%xmm5
addsd  %xmm6,%xmm4
subsd  %xmm4,%xmm5
movsd  %xmm5,(%r10,%rdi,8)
add    $0x4,%r13
cmp    %r13,0x88(%rsp)
jne    1b30 <UpdSnodes+0xa20>
jmp    1860 <UpdSnodes+0x750>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x13d7(%rip),%xmm8
mov    0x18(%rsp),%r13
mov    0x20(%rsp),%r14
lea    0x7(%r12),%ecx
movslq 0x40(%rsp),%r8
cmp    %r15d,%ecx
mov    %r8,0x10(%rsp)
jge    1ee0 <UpdSnodes+0xdd0>
mov    %r12d,%r14d
jmp    1c6b <UpdSnodes+0xb5b>
lea    0x8(%r14),%r12
mov    %r14d,%ecx
add    $0xf,%ecx
mov    %r12,%r14
mov    0x54(%rsp),%r15d
cmp    %r15d,%ecx
jge    1ef0 <UpdSnodes+0xde0>
mov    0x60(%rsp),%rbp
mov    0x0(%rbp,%r14,4),%r15d
mov    0x40(%rsp),%r11
add    %r11d,%r15d
mov    %r14d,%ebx
or     $0x1,%ebx
mov    0x0(%rbp,%rbx,4),%edx
add    %r11d,%edx
mov    %r14d,%esi
or     $0x2,%esi
mov    0x0(%rbp,%rsi,4),%r8d
add    %r11d,%r8d
mov    %r14d,%edi
or     $0x3,%edi
mov    0x0(%rbp,%rdi,4),%r12d
add    %r11d,%r12d
movslq %edx,%rax
mov    0x28(%rsp),%rdx
mov    %rax,0x38(%rsp)
movsd  (%rdx,%rax,8),%xmm9
movapd %xmm9,%xmm12
mov    0x58(%rsp),%rax
divsd  (%rax,%rbx,8),%xmm12
mov    0x10(%rbp,%r14,4),%r9d
add    %r11d,%r9d
mov    %ecx,%ecx
movslq %r8d,%rbx
mov    %rbx,0x30(%rsp)
movsd  (%rdx,%rbx,8),%xmm1
movapd %xmm1,%xmm10
divsd  (%rax,%rsi,8),%xmm10
movslq 0x0(%rbp,%rcx,4),%r8
movslq %r12d,%r12
movsd  (%rdx,%r12,8),%xmm11
movapd %xmm11,%xmm2
divsd  (%rax,%rdi,8),%xmm2
mov    0x10(%rsp),%rsi
add    %r8,%rsi
movsd  (%rdx,%rsi,8),%xmm8
mov    0x14(%rbp,%r14,4),%edi
add    %r11d,%edi
movapd %xmm8,%xmm3
divsd  (%rax,%rcx,8),%xmm3
mov    0x18(%rbp,%r14,4),%ebx
add    %r11d,%ebx
movslq %r15d,%rbp
movsd  (%rdx,%rbp,8),%xmm0
movapd %xmm0,%xmm4
divsd  (%rax,%r14,8),%xmm4
movslq %r9d,%rsi
movsd  (%rdx,%rsi,8),%xmm13
movapd %xmm13,%xmm5
divsd  0x20(%rax,%r14,8),%xmm5
movslq %edi,%rdi
movsd  (%rdx,%rdi,8),%xmm14
movapd %xmm14,%xmm6
divsd  0x28(%rax,%r14,8),%xmm6
movslq %ebx,%rbx
movsd  (%rdx,%rbx,8),%xmm15
movapd %xmm15,%xmm7
divsd  0x30(%rax,%r14,8),%xmm7
mulsd  %xmm12,%xmm9
mulsd  %xmm4,%xmm0
addsd  %xmm9,%xmm0
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm11
addsd  %xmm1,%xmm11
mulsd  %xmm5,%xmm13
addsd  %xmm11,%xmm13
mulsd  %xmm6,%xmm14
addsd  %xmm13,%xmm14
mulsd  %xmm7,%xmm15
addsd  %xmm14,%xmm15
mulsd  %xmm3,%xmm8
addsd  %xmm15,%xmm8
mov    0x180(%rsp),%rax
mov    0x68(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm8,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,0xc(%rsp)
mov    0x18(%rsp),%r9
mov    0x88(%rsp),%r11
mov    0x20(%rsp),%r13
jle    1c50 <UpdSnodes+0xb40>
mov    0x98(%rsp),%rax
lea    (%rax,%r8,8),%r15
mov    0xa0(%rsp),%rcx
mov    %r12,%rax
lea    (%rcx,%rbx,8),%r12
lea    (%rcx,%rdi,8),%r8
lea    (%rcx,%rsi,8),%rbx
lea    (%rcx,%rax,8),%rax
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
mov    0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdi
lea    (%rcx,%rbp,8),%rcx
xor    %edx,%edx
nopl   (%rax)
movsd  (%rdi,%rdx,2),%xmm0
mulsd  %xmm12,%xmm0
movsd  (%rcx,%rdx,2),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%rdx,2),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rax,%rdx,2),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%rdx,2),%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r8,%rdx,2),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r12,%rdx,2),%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r15,%rdx,2),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movslq (%r9,%rdx,1),%rbp
sub    %r13,%rbp
movsd  (%r10,%rbp,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%rbp,8)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1e40 <UpdSnodes+0xd30>
jmp    1c50 <UpdSnodes+0xb40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x78(%rsp),%r11
jmp    1f0d <UpdSnodes+0xdfd>
nopw   0x0(%rax,%rax,1)
movapd 0x1107(%rip),%xmm8
mov    0x18(%rsp),%r13
mov    0x78(%rsp),%r11
mov    0x20(%rsp),%r14
mov    0x10(%rsp),%r8
and    $0xfffffffe,%r11d
mov    0xac(%rsp),%eax
sub    0x40(%rsp),%eax
mov    %rax,0x18(%rsp)
mov    %r12d,%edx
or     $0x3,%edx
cmp    %r15d,%edx
jge    20aa <UpdSnodes+0xf9a>
mov    %r11,0x78(%rsp)
mov    %r12d,%r12d
jmp    1f5b <UpdSnodes+0xe4b>
nopw   0x0(%rax,%rax,1)
mov    %r8,%r12
add    $0x4,%r12
mov    %r12d,%edx
or     $0x3,%edx
cmp    %r15d,%edx
mov    0x10(%rsp),%r8
jge    20a0 <UpdSnodes+0xf90>
mov    0x60(%rsp),%rax
movslq (%rax,%r12,4),%r9
lea    (%r9,%r8,1),%rdi
mov    %r12d,%ebp
or     $0x1,%ebp
movslq (%rax,%rbp,4),%r11
lea    (%r11,%r8,1),%rbx
mov    0x28(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm4
mov    %r12d,%esi
or     $0x2,%esi
movsd  (%rcx,%rbx,8),%xmm5
movslq (%rax,%rsi,4),%r14
movapd %xmm5,%xmm0
mov    0x58(%rsp),%rdi
divsd  (%rdi,%rbp,8),%xmm0
lea    (%r14,%r8,1),%rbp
mov    %edx,%ebx
movsd  (%rcx,%rbp,8),%xmm6
movslq (%rax,%rbx,4),%rdx
movapd %xmm6,%xmm1
divsd  (%rdi,%rsi,8),%xmm1
lea    (%rdx,%r8,1),%rsi
movsd  (%rcx,%rsi,8),%xmm7
movapd %xmm7,%xmm2
divsd  (%rdi,%rbx,8),%xmm2
movapd %xmm4,%xmm3
mov    %r12,%r8
divsd  (%rdi,%r12,8),%xmm3
mulsd  %xmm0,%xmm5
mulsd  %xmm3,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm1,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm2,%xmm7
addsd  %xmm6,%xmm7
mov    0x180(%rsp),%rax
mov    0x68(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm4
subsd  %xmm7,%xmm4
movsd  %xmm4,(%rax,%rcx,8)
cmpl   $0x0,0xc(%rsp)
mov    0x88(%rsp),%rbx
mov    0x20(%rsp),%r12
jle    1f40 <UpdSnodes+0xe30>
mov    0x98(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
lea    (%rax,%r14,8),%rdi
lea    (%rax,%r11,8),%rcx
lea    (%rax,%r9,8),%rax
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rcx,%rbp,2),%xmm4
mulsd  %xmm0,%xmm4
movsd  (%rax,%rbp,2),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rdi,%rbp,2),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdx,%rbp,2),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movslq 0x0(%r13,%rbp,1),%rsi
sub    %r12,%rsi
movsd  (%r10,%rsi,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r10,%rsi,8)
add    $0x4,%rbp
cmp    %rbp,%rbx
jne    2040 <UpdSnodes+0xf30>
jmp    1f40 <UpdSnodes+0xe30>
cs nopw 0x0(%rax,%rax,1)
mov    0x78(%rsp),%r11
mov    0x20(%rsp),%r14
mov    0xc0(%rsp),%rax
mov    0x40(%rsp),%rcx
lea    (%rax,%rcx,4),%r9
mov    %r12d,%edx
or     $0x1,%edx
cmp    %r15d,%edx
jge    2240 <UpdSnodes+0x1130>
mov    %r12d,%r12d
jmp    20e3 <UpdSnodes+0xfd3>
nop
add    $0x2,%r12
mov    %r12d,%edx
or     $0x1,%edx
cmp    %r15d,%edx
jge    2240 <UpdSnodes+0x1130>
mov    0x60(%rsp),%rbp
movslq 0x0(%rbp,%r12,4),%rdi
lea    (%rdi,%r8,1),%rcx
mov    %edx,%esi
movslq 0x0(%rbp,%rsi,4),%rbx
mov    0x28(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm2
movapd %xmm2,%xmm0
mov    0x58(%rsp),%rax
divsd  (%rax,%r12,8),%xmm0
lea    (%rbx,%r8,1),%rdx
movsd  0x0(%rbp,%rdx,8),%xmm3
movapd %xmm3,%xmm1
divsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
mov    0x180(%rsp),%rax
mov    0x68(%rsp),%rsi
movsd  (%rax,%rsi,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rsi,8)
cmpl   $0x0,0xc(%rsp)
jle    20d0 <UpdSnodes+0xfc0>
cmpl   $0x1,0x18(%rsp)
jne    2170 <UpdSnodes+0x1060>
xor    %edi,%edi
jmp    21f8 <UpdSnodes+0x10e8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x90(%rsp),%rax
lea    (%rax,%rdi,8),%rbp
lea    (%rax,%rbx,8),%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  -0x8(%rbp,%rdi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movslq 0x0(%r13,%rdi,4),%rsi
sub    %r14,%rsi
movsd  (%r10,%rsi,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%r10,%rsi,8)
movsd  (%rbx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rdi,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movslq 0x4(%r13,%rdi,4),%rsi
sub    %r14,%rsi
movsd  (%r10,%rsi,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%r10,%rsi,8)
add    $0x2,%rdi
cmp    %rdi,%r11
jne    2190 <UpdSnodes+0x1080>
testb  $0x1,0x18(%rsp)
je     20d0 <UpdSnodes+0xfc0>
mov    0x28(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%rdx,8),%rdx
mulsd  0x8(%rdx,%rdi,8),%xmm1
mulsd  0x8(%rcx,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movslq (%r9,%rdi,4),%rcx
sub    %r14,%rcx
movsd  (%r10,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rcx,8)
jmp    20d0 <UpdSnodes+0xfc0>
nopl   0x0(%rax)
cmp    %r15d,%r12d
jge    2350 <UpdSnodes+0x1240>
mov    %r12d,%ecx
jmp    225d <UpdSnodes+0x114d>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %r15d,%ecx
jge    2350 <UpdSnodes+0x1240>
mov    0x60(%rsp),%rdx
movslq (%rdx,%rcx,4),%rdi
lea    (%rdi,%r8,1),%rdx
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm1
movapd %xmm1,%xmm0
xorpd  %xmm8,%xmm0
mov    0x58(%rsp),%rsi
divsd  (%rsi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm1
mov    0x180(%rsp),%rax
mov    0x68(%rsp),%rsi
addsd  (%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rax,%rsi,8)
cmpl   $0x0,0xc(%rsp)
jle    2250 <UpdSnodes+0x1140>
cmpl   $0x1,0x18(%rsp)
jne    22c0 <UpdSnodes+0x11b0>
xor    %edi,%edi
jmp    2315 <UpdSnodes+0x1205>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x90(%rsp),%rax
lea    (%rax,%rdi,8),%rbp
xor    %edi,%edi
xchg   %ax,%ax
movslq 0x0(%r13,%rdi,4),%rsi
sub    %r14,%rsi
movsd  -0x8(%rbp,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r10,%rsi,8),%xmm1
movsd  %xmm1,(%r10,%rsi,8)
movslq 0x4(%r13,%rdi,4),%rsi
sub    %r14,%rsi
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r10,%rsi,8),%xmm1
movsd  %xmm1,(%r10,%rsi,8)
add    $0x2,%rdi
cmp    %rdi,%r11
jne    22d0 <UpdSnodes+0x11c0>
testb  $0x1,0x18(%rsp)
je     2250 <UpdSnodes+0x1140>
mov    0x28(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
movslq (%r9,%rdi,4),%rsi
mulsd  0x8(%rdx,%rdi,8),%xmm0
sub    %r14,%rsi
addsd  (%r10,%rsi,8),%xmm0
movsd  %xmm0,(%r10,%rsi,8)
jmp    2250 <UpdSnodes+0x1140>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rbx
add    $0x1,%rbx
cmp    0xc8(%rsp),%rbx
mov    0xd0(%rsp),%rdi
je     239b <UpdSnodes+0x128b>
mov    0x198(%rsp),%rax
mov    (%rax,%rbx,4),%eax
add    $0x4,%r13
mov    0xb4(%rsp),%esi
add    $0xffffffff,%esi
addq   $0x8,0x98(%rsp)
addq   $0x8,0x90(%rsp)
jmp    11e0 <UpdSnodes+0xd0>
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
call   1030 <exit@plt>

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

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