void UpdSnode(int m, int n, int s, double diaga[], double *a, int fira[],
              double diagb[], double *b, int firb[]) {
  int i, k, t, sze;
  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, *b00, *b1, *b0;
  for (i = 0; i + 1 < s; i += 2) {
    b00 = b + firb[i];
    b0 = b00 + 1;
    b1 = b + firb[i + 1];
    sze = m - i - 2;
    k = 0;
    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[0] / diaga[k + 0];
      rtemp2 = a2[0] / diaga[k + 1];
      rtemp3 = a3[0] / diaga[k + 2];
      rtemp4 = a4[0] / diaga[k + 3];
      diagb[i] -=
          rtemp1 * a1[0] + rtemp2 * a2[0] + rtemp3 * a3[0] + rtemp4 * a4[0];
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      rtemp5 = a1[0] / diaga[k + 0];
      rtemp6 = a2[0] / diaga[k + 1];
      rtemp7 = a3[0] / diaga[k + 2];
      rtemp8 = a4[0] / diaga[k + 3];
      b00[0] -=
          rtemp1 * a1[0] + rtemp2 * a2[0] + rtemp3 * a3[0] + rtemp4 * a4[0];
      diagb[i + 1] -=
          rtemp5 * a1[0] + rtemp6 * a2[0] + rtemp7 * a3[0] + rtemp8 * a4[0];
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      for (t = 0; t < sze; ++t) {
        b0[t] -=
            rtemp1 * a1[t] + rtemp2 * a2[t] + rtemp3 * a3[t] + rtemp4 * a4[t];
        b1[t] -=
            rtemp5 * a1[t] + rtemp6 * a2[t] + rtemp7 * a3[t] + rtemp8 * a4[t];
      }
    }
    for (; k + 1 < n; k += 2) {
      a1 = a + (fira[k + 0] + i);
      a2 = a + (fira[k + 1] + i);
      rtemp1 = a1[0] / diaga[k + 0];
      rtemp2 = a2[0] / diaga[k + 1];
      diagb[i] -= a1[0] * rtemp1 + a2[0] * rtemp2;
      ++a1;
      ++a2;
      rtemp5 = a1[0] / diaga[k + 0];
      rtemp6 = a2[0] / diaga[k + 1];
      b00[0] -= a1[0] * rtemp1 + a2[0] * rtemp2;
      diagb[i + 1] -= a1[0] * rtemp5 + a2[0] * rtemp6;
      ++a1;
      ++a2;
      for (t = 0; t < sze; ++t) {
        b0[t] -= a1[t] * rtemp1 + a2[t] * rtemp2;
        b1[t] -= a1[t] * rtemp5 + a2[t] * rtemp6;
      }
    }
    for (; k < n; ++k) {
      a1 = a + (fira[k + 0] + i);
      rtemp1 = a1[0] / diaga[k + 0];
      diagb[i] -= a1[0] * rtemp1;
      ++a1;
      rtemp5 = a1[0] / diaga[k + 0];
      diagb[i + 1] -= a1[0] * rtemp5;
      b00[0] -= a1[0] * rtemp1;
      ++a1;
      for (t = 0; t < sze; ++t) {
        b0[t] -= rtemp1 * a1[t];
        b1[t] -= rtemp5 * a1[t];
      }
    }
  }
  for (; i < s; ++i) {
    b0 = b + firb[i];
    sze = m - 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[i] -= 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[t] -= 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[i] -= 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[t] -= 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[i] -= 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[t] -= 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[i] -=
          rtemp1 * (*a1) + rtemp2 * (*a2) + rtemp3 * (*a3) + rtemp4 * (*a4);
      ++a1;
      ++a2;
      ++a3;
      ++a4;
      for (t = 0; t < sze; ++t)
        b0[t] -=
            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[i] -= rtemp1 * (*a1) + rtemp2 * (*a2);
      ++a1;
      ++a2;
      for (t = 0; t < sze; ++t)
        b0[t] -= rtemp1 * a1[t] + rtemp2 * a2[t];
    }
    for (; k < n; ++k) {
      a1 = a + (fira[k + 0] + i);
      rtemp1 = *a1 / diaga[k + 0];
      diagb[i] -= rtemp1 * (*a1);
      ++a1;
      for (t = 0; t < sze; ++t)
        b0[t] -= rtemp1 * a1[t];
    }
  }
}


x86 assembly (clang, -O0):
<UpdSnode>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
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)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
jge    1b7a <UpdSnode+0xa7a>
mov    0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x150(%rbp)
mov    0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x148(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0x3,%eax
cmp    -0x8(%rbp),%eax
jge    1681 <UpdSnode+0x581>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x68(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    166e <UpdSnode+0x56e>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x148(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    154a <UpdSnode+0x44a>
jmp    1673 <UpdSnode+0x573>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    11a8 <UpdSnode+0xa8>
jmp    1686 <UpdSnode+0x586>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jge    193b <UpdSnode+0x83b>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm2
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm2
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x60(%rbp),%xmm2
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1928 <UpdSnode+0x828>
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm2
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm2
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x148(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1878 <UpdSnode+0x778>
jmp    192d <UpdSnode+0x82d>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    1686 <UpdSnode+0x586>
jmp    1940 <UpdSnode+0x840>
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b67 <UpdSnode+0xa67>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%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    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%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    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0x140(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b54 <UpdSnode+0xa54>
movsd  -0x40(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x150(%rbp),%rax
movslq -0x34(%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)
movsd  -0x60(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x148(%rbp),%rax
movslq -0x34(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1aa8 <UpdSnode+0x9a8>
jmp    1b59 <UpdSnode+0xa59>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1940 <UpdSnode+0x840>
jmp    1b6c <UpdSnode+0xa6c>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    1133 <UpdSnode+0x33>
jmp    1b7f <UpdSnode+0xa7f>
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    371c <UpdSnode+0x261c>
mov    0x18(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x150(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0xf,%eax
cmp    -0x8(%rbp),%eax
jge    256d <UpdSnode+0x146d>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x110(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x118(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x120(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x128(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x130(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x138(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%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    -0x30(%rbp),%ecx
add    $0x4,%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    -0x30(%rbp),%ecx
add    $0x5,%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    -0x30(%rbp),%ecx
add    $0x6,%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    -0x30(%rbp),%ecx
add    $0x7,%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    -0x30(%rbp),%ecx
add    $0x8,%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    -0x30(%rbp),%ecx
add    $0x9,%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    -0x30(%rbp),%ecx
add    $0xa,%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    -0x30(%rbp),%ecx
add    $0xb,%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    -0x30(%rbp),%ecx
add    $0xc,%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    -0x30(%rbp),%ecx
add    $0xd,%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    -0x30(%rbp),%ecx
add    $0xe,%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    -0x30(%rbp),%ecx
add    $0xf,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x120(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x138(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
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)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    255a <UpdSnode+0x145a>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x118(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x120(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x128(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x138(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    234a <UpdSnode+0x124a>
jmp    255f <UpdSnode+0x145f>
mov    -0x30(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x30(%rbp)
jmp    1bbc <UpdSnode+0xabc>
jmp    2572 <UpdSnode+0x1472>
mov    -0x30(%rbp),%eax
add    $0xb,%eax
cmp    -0x8(%rbp),%eax
jge    2cbb <UpdSnode+0x1bbb>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x110(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0x118(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%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    -0x30(%rbp),%ecx
add    $0x4,%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    -0x30(%rbp),%ecx
add    $0x5,%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    -0x30(%rbp),%ecx
add    $0x6,%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    -0x30(%rbp),%ecx
add    $0x7,%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    -0x30(%rbp),%ecx
add    $0x8,%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    -0x30(%rbp),%ecx
add    $0x9,%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    -0x30(%rbp),%ecx
add    $0xa,%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    -0x30(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x108(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
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)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2ca8 <UpdSnode+0x1ba8>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    -0x100(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x108(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mov    -0x118(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2b18 <UpdSnode+0x1a18>
jmp    2cad <UpdSnode+0x1bad>
mov    -0x30(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x30(%rbp)
jmp    2572 <UpdSnode+0x1472>
jmp    2cc0 <UpdSnode+0x1bc0>
mov    -0x30(%rbp),%eax
add    $0x7,%eax
cmp    -0x8(%rbp),%eax
jge    31aa <UpdSnode+0x20aa>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%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    -0x30(%rbp),%ecx
add    $0x4,%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    -0x30(%rbp),%ecx
add    $0x5,%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    -0x30(%rbp),%ecx
add    $0x6,%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    -0x30(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
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)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3197 <UpdSnode+0x2097>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xe8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0xf0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
mov    -0xf8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3084 <UpdSnode+0x1f84>
jmp    319c <UpdSnode+0x209c>
mov    -0x30(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x30(%rbp)
jmp    2cc0 <UpdSnode+0x1bc0>
jmp    31af <UpdSnode+0x20af>
mov    -0x30(%rbp),%eax
add    $0x3,%eax
cmp    -0x8(%rbp),%eax
jge    3455 <UpdSnode+0x2355>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xd8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3442 <UpdSnode+0x2342>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0xd8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    33a3 <UpdSnode+0x22a3>
jmp    3447 <UpdSnode+0x2347>
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    31af <UpdSnode+0x20af>
jmp    345a <UpdSnode+0x235a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jge    35de <UpdSnode+0x24de>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    35cb <UpdSnode+0x24cb>
movsd  -0x40(%rbp),%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x150(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3566 <UpdSnode+0x2466>
jmp    35d0 <UpdSnode+0x24d0>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    345a <UpdSnode+0x235a>
jmp    35e3 <UpdSnode+0x24e3>
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    3709 <UpdSnode+0x2609>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%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,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm2
mov    0x10(%rbp),%rax
movslq -0x2c(%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    -0xc0(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    36f6 <UpdSnode+0x25f6>
movsd  -0x40(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x150(%rbp),%rax
movslq -0x34(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3693 <UpdSnode+0x2593>
jmp    36fb <UpdSnode+0x25fb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    35e3 <UpdSnode+0x24e3>
jmp    370e <UpdSnode+0x260e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b7f <UpdSnode+0xa7f>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<UpdSnode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,-0x58(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdi,0x90(%rsp)
xor    %r11d,%r11d
movslq %esi,%rax
mov    %rax,0xb0(%rsp)
mov    %edx,%eax
mov    %rax,0xa0(%rsp)
cmp    $0x2,%edx
mov    %esi,-0x7c(%rsp)
jl     1c34 <UpdSnode+0xb34>
mov    %edx,0x70(%rsp)
mov    0x118(%rsp),%rcx
lea    0x8(%rcx),%rax
mov    %rax,0x20(%rsp)
mov    0x90(%rsp),%rax
lea    -0x2(%rax),%edx
mov    -0x58(%rsp),%rax
lea    0x10(%rax),%rdi
mov    %rdi,-0x30(%rsp)
lea    0x20(%rax),%rdi
mov    %rdi,0x88(%rsp)
lea    0x18(%rcx),%rdi
mov    %rdi,0x80(%rsp)
add    $0x10,%rcx
mov    %rcx,0x78(%rsp)
add    $0x18,%rax
mov    %rax,0x68(%rsp)
mov    $0x1,%r8d
xor    %ecx,%ecx
movapd 0x2e4a(%rip),%xmm8
mov    %edx,0x58(%rsp)
mov    %edx,%r14d
xor    %r11d,%r11d
jmp    11f9 <UpdSnode+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%r11
mov    %r11,%rax
or     $0x1,%rax
add    $0x2,%r8
mov    0x40(%rsp),%rcx
add    $0x1,%ecx
add    $0xfffffffe,%r14d
cmp    0xa0(%rsp),%rax
jae    1c30 <UpdSnode+0xb30>
mov    %r14d,%r14d
mov    %r14d,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x78(%rsp)
mov    %rcx,0x40(%rsp)
lea    (%rcx,%rcx,1),%eax
mov    0x58(%rsp),%ecx
sub    %eax,%ecx
mov    %rcx,-0x68(%rsp)
mov    0x90(%rsp),%rax
sub    %r11d,%eax
mov    %eax,(%rsp)
movslq %r11d,%rax
mov    %rax,-0x20(%rsp)
mov    0x120(%rsp),%rax
movslq (%rax,%r11,4),%rdi
mov    0x118(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdx
mov    %rdx,-0x38(%rsp)
lea    0x8(%rcx,%rdi,8),%r15
movslq (%rax,%r8,4),%rdx
lea    (%rcx,%rdx,8),%r12
mov    $0x0,%r13d
cmp    $0x4,%esi
mov    %r8,-0x50(%rsp)
mov    %r11,0x10(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rdx,0x60(%rsp)
jl     1508 <UpdSnode+0x408>
mov    $0x3,%r8d
xor    %r13d,%r13d
jmp    12ad <UpdSnode+0x1ad>
nopl   0x0(%rax,%rax,1)
add    $0x4,%r13
mov    %r13,%rcx
or     $0x3,%rcx
add    $0x4,%r8
cmp    0xb0(%rsp),%rcx
jge    14f0 <UpdSnode+0x3f0>
mov    0x30(%rsp),%rbx
movslq (%rbx,%r13,4),%r9
mov    -0x20(%rsp),%rcx
add    %rcx,%r9
mov    %r13,%rdx
or     $0x1,%rdx
movslq (%rbx,%rdx,4),%r11
add    %rcx,%r11
mov    %r13,%rbp
or     $0x2,%rbp
movslq (%rbx,%rbp,4),%rdi
add    %rcx,%rdi
mov    -0x58(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
movapd %xmm0,%xmm9
mov    0x28(%rsp),%rsi
divsd  (%rsi,%r13,8),%xmm9
movslq (%rbx,%r8,4),%rbx
movsd  (%rax,%r11,8),%xmm5
movapd %xmm5,%xmm10
divsd  (%rsi,%rdx,8),%xmm10
add    %rcx,%rbx
movsd  (%rax,%rdi,8),%xmm6
movapd %xmm6,%xmm12
divsd  (%rsi,%rbp,8),%xmm12
movsd  (%rax,%rbx,8),%xmm7
movapd %xmm7,%xmm4
divsd  (%rsi,%r8,8),%xmm4
mulsd  %xmm10,%xmm5
mulsd  %xmm9,%xmm0
addsd  %xmm5,%xmm0
mulsd  %xmm12,%xmm6
addsd  %xmm0,%xmm6
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
mov    0x110(%rsp),%r10
mov    0x10(%rsp),%rcx
movsd  (%r10,%rcx,8),%xmm0
subsd  %xmm7,%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  0x8(%rax,%r11,8),%xmm11
movapd %xmm11,%xmm5
divsd  (%rsi,%rdx,8),%xmm5
movsd  0x8(%rax,%rdi,8),%xmm6
movapd %xmm6,%xmm2
divsd  (%rsi,%rbp,8),%xmm2
movsd  0x8(%rax,%r9,8),%xmm7
movapd %xmm7,%xmm1
divsd  (%rsi,%r13,8),%xmm1
movsd  0x8(%rax,%rbx,8),%xmm0
movapd %xmm0,%xmm3
divsd  (%rsi,%r8,8),%xmm3
mulsd  %xmm10,%xmm11
mulsd  %xmm9,%xmm7
addsd  %xmm11,%xmm7
mulsd  %xmm12,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm4,%xmm0
addsd  %xmm6,%xmm0
mov    -0x38(%rsp),%rcx
movsd  (%rcx),%xmm6
subsd  %xmm0,%xmm6
movsd  %xmm6,(%rcx)
movsd  0x8(%rax,%r11,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  0x8(%rax,%r9,8),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm0,%xmm6
movsd  0x8(%rax,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm6,%xmm0
movsd  0x8(%rax,%rbx,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm0,%xmm6
mov    -0x50(%rsp),%rax
movsd  (%r10,%rax,8),%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,(%r10,%rax,8)
cmpl   $0x3,(%rsp)
jl     1290 <UpdSnode+0x190>
mov    -0x30(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
lea    (%rax,%rdi,8),%rdi
lea    (%rax,%r11,8),%rcx
lea    (%rax,%r9,8),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm10,%xmm0
movsd  (%rsi,%rdx,8),%xmm6
mulsd  %xmm9,%xmm6
addsd  %xmm0,%xmm6
movsd  (%rdi,%rdx,8),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm6,%xmm0
movsd  (%rbx,%rdx,8),%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm0,%xmm6
movsd  (%r15,%rdx,8),%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  (%rsi,%rdx,8),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm0,%xmm6
movsd  (%rdi,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm6,%xmm0
movsd  (%rbx,%rdx,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm0,%xmm6
movsd  (%r12,%rdx,8),%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1450 <UpdSnode+0x350>
jmp    1290 <UpdSnode+0x190>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x7c(%rsp),%esi
mov    -0x50(%rsp),%r8
mov    0x10(%rsp),%r11
mov    0x38(%rsp),%rdi
mov    0x60(%rsp),%rdx
mov    %r13d,%eax
or     $0x1,%eax
cmp    %esi,%eax
jge    188a <UpdSnode+0x78a>
mov    %r13d,%r13d
mov    -0x68(%rsp),%rbp
lea    (%rdi,%rbp,1),%rcx
mov    0x20(%rsp),%r9
lea    (%r9,%rcx,8),%rbx
lea    (%rdx,%rbp,1),%rcx
mov    0x118(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    %rcx,-0x48(%rsp)
mov    %rdx,-0x60(%rsp)
cmp    %rdx,%r15
setb   %cl
mov    %rbx,-0x70(%rsp)
cmp    %rbx,%r12
setb   %dl
and    %cl,%dl
mov    %dl,0x48(%rsp)
and    $0xfffffffe,%ebp
mov    %rbp,0x18(%rsp)
lea    (%r9,%rdi,8),%rcx
mov    %rcx,-0x28(%rsp)
jmp    1592 <UpdSnode+0x492>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r13
mov    %r13d,%eax
or     $0x1,%eax
cmp    %esi,%eax
jge    1880 <UpdSnode+0x780>
mov    0x30(%rsp),%rdx
movslq (%rdx,%r13,4),%r9
mov    -0x20(%rsp),%rdi
lea    (%r9,%rdi,1),%rbx
mov    %eax,%ecx
movslq (%rdx,%rcx,4),%r10
lea    (%r10,%rdi,1),%rax
mov    -0x58(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm0
movapd %xmm0,%xmm1
mov    0x28(%rsp),%rbp
divsd  0x0(%rbp,%r13,8),%xmm1
movsd  (%rdx,%rax,8),%xmm3
movapd %xmm3,%xmm2
divsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
mov    0x110(%rsp),%rdi
movsd  (%rdi,%r11,8),%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,(%rdi,%r11,8)
movsd  0x8(%rdx,%rbx,8),%xmm0
movapd %xmm0,%xmm3
divsd  0x0(%rbp,%r13,8),%xmm3
movsd  0x8(%rdx,%rax,8),%xmm5
movapd %xmm5,%xmm4
divsd  0x0(%rbp,%rcx,8),%xmm4
mulsd  %xmm2,%xmm5
mulsd  %xmm1,%xmm0
addsd  %xmm5,%xmm0
mov    -0x38(%rsp),%rcx
movsd  (%rcx),%xmm5
subsd  %xmm0,%xmm5
movsd  %xmm5,(%rcx)
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  0x8(%rdx,%rbx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm0,%xmm5
movsd  (%rdi,%r8,8),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,(%rdi,%r8,8)
cmpl   $0x3,(%rsp)
jl     1580 <UpdSnode+0x480>
cmpl   $0x2,-0x68(%rsp)
jae    1710 <UpdSnode+0x610>
xor    %ecx,%ecx
lea    (%r12,%rcx,8),%rax
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    -0x20(%rsp),%rdi
lea    (%rdi,%rcx,1),%rbx
add    %rbx,%r10
mov    -0x30(%rsp),%rdi
lea    (%rdi,%r10,8),%rbp
add    %rbx,%r9
lea    (%rdi,%r9,8),%rdi
mov    %r14,%rbx
sub    %rcx,%rbx
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  (%rdi,%rcx,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm0,%xmm5
movsd  (%rdx,%rcx,8),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  (%rdi,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm0,%xmm5
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    16b0 <UpdSnode+0x5b0>
jmp    1580 <UpdSnode+0x480>
nopl   0x0(%rax,%rax,1)
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rbx,8),%rbp
add    $0x10,%rbp
lea    0x10(%rcx,%rax,8),%r11
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
lea    (%rcx,%rax,8),%rsi
cmp    %rdx,%r15
setb   %cl
mov    -0x70(%rsp),%rdi
cmp    %rdi,%rbp
setb   %r8b
and    %cl,%r8b
or     0x48(%rsp),%r8b
cmp    %rsi,%r15
setb   %cl
cmp    %rdi,%r11
setb   -0x8(%rsp)
cmp    %rdx,%r12
setb   %dl
mov    -0x60(%rsp),%rdi
cmp    %rdi,%rbp
setb   -0x40(%rsp)
cmp    %rsi,%r12
setb   %bpl
cmp    %rdi,%r11
setb   %r11b
test   %r8b,%r8b
jne    185f <UpdSnode+0x75f>
and    -0x8(%rsp),%cl
jne    185f <UpdSnode+0x75f>
and    -0x40(%rsp),%dl
mov    -0x7c(%rsp),%esi
mov    -0x50(%rsp),%r8
jne    1874 <UpdSnode+0x774>
mov    $0x0,%ecx
and    %r11b,%bpl
mov    0x10(%rsp),%r11
jne    1678 <UpdSnode+0x578>
movapd %xmm2,%xmm9
unpcklpd %xmm2,%xmm9
movapd %xmm1,%xmm10
unpcklpd %xmm1,%xmm10
movapd %xmm4,%xmm6
unpcklpd %xmm4,%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm3,%xmm7
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
lea    (%rcx,%rax,8),%rax
xor    %ebx,%ebx
mov    -0x78(%rsp),%rcx
nopl   0x0(%rax)
movupd (%rdx,%rbx,8),%xmm0
mulpd  %xmm10,%xmm0
movupd (%rax,%rbx,8),%xmm5
mulpd  %xmm9,%xmm5
addpd  %xmm0,%xmm5
movupd (%r15,%rbx,8),%xmm0
subpd  %xmm5,%xmm0
movupd %xmm0,(%r15,%rbx,8)
movupd (%rdx,%rbx,8),%xmm0
mulpd  %xmm7,%xmm0
movupd (%rax,%rbx,8),%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm0,%xmm5
movupd (%r12,%rbx,8),%xmm0
subpd  %xmm5,%xmm0
movupd %xmm0,(%r12,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    17f0 <UpdSnode+0x6f0>
mov    0x18(%rsp),%rax
mov    %rax,%rcx
cmp    -0x68(%rsp),%rax
je     1580 <UpdSnode+0x480>
jmp    1678 <UpdSnode+0x578>
xor    %ecx,%ecx
mov    -0x7c(%rsp),%esi
mov    0x10(%rsp),%r11
mov    -0x50(%rsp),%r8
jmp    1678 <UpdSnode+0x578>
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
jmp    1678 <UpdSnode+0x578>
mov    0x38(%rsp),%rdi
mov    0x60(%rsp),%rdx
cmp    %esi,%r13d
jge    11d0 <UpdSnode+0xd0>
mov    -0x78(%rsp),%rax
add    $0xfffffffffffffffe,%rax
mov    -0x68(%rsp),%rbp
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
shr    %rax
add    $0xfffffffffffffffe,%rcx
add    $0x1,%rax
mov    %rcx,-0x48(%rsp)
shr    %rcx
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x78(%rsp)
add    $0x1,%rcx
mov    %rcx,0x48(%rsp)
mov    %r13d,%r9d
lea    (%rdi,%rbp,1),%rax
mov    0x20(%rsp),%r10
lea    (%r10,%rax,8),%rbx
lea    (%rdx,%rbp,1),%rax
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    -0x30(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,-0x70(%rsp)
mov    %rcx,-0x40(%rsp)
cmp    %rcx,%r15
setb   %al
mov    %rbx,-0x28(%rsp)
cmp    %rbx,%r12
setb   %cl
and    %al,%cl
mov    %cl,-0x60(%rsp)
mov    %ebp,%eax
and    $0xfffffffe,%eax
mov    %rax,0x18(%rsp)
neg    %rbp
mov    %rbp,-0x8(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%rdx,8),%r13
lea    (%r10,%rdx,8),%rbx
lea    (%rcx,%rdi,8),%rdi
jmp    1962 <UpdSnode+0x862>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    %esi,%r9d
mov    0x10(%rsp),%r11
jge    11d0 <UpdSnode+0xd0>
mov    0x30(%rsp),%rcx
movslq (%rcx,%r9,4),%r10
add    -0x20(%rsp),%r10
mov    -0x58(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm0
movapd %xmm0,%xmm1
mov    0x28(%rsp),%rdx
divsd  (%rdx,%r9,8),%xmm1
mov    0x110(%rsp),%rbp
movsd  0x0(%rbp,%r11,8),%xmm2
mulsd  %xmm1,%xmm0
subsd  %xmm0,%xmm2
movsd  %xmm2,0x0(%rbp,%r11,8)
movsd  0x8(%rcx,%r10,8),%xmm0
movapd %xmm0,%xmm2
divsd  (%rdx,%r9,8),%xmm2
movsd  0x0(%rbp,%r8,8),%xmm3
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,0x0(%rbp,%r8,8)
mov    -0x38(%rsp),%rdx
movsd  (%rdx),%xmm0
movsd  0x8(%rcx,%r10,8),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm0
movsd  %xmm0,(%rdx)
cmpl   $0x3,(%rsp)
jl     1950 <UpdSnode+0x850>
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r10,8),%r11
add    $0x10,%r11
xorpd  %xmm8,%xmm1
xorpd  %xmm8,%xmm2
cmpl   $0x2,-0x68(%rsp)
jae    1ad0 <UpdSnode+0x9d0>
xor    %edx,%edx
mov    %rdx,%rcx
testb  $0x1,-0x68(%rsp)
je     1a56 <UpdSnode+0x956>
movsd  (%r11,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
movsd  (%r11,%rdx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    -0x8(%rsp),%rdx
je     1950 <UpdSnode+0x850>
mov    0x68(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
nopl   (%rax)
movsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  -0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rcx,8)
movsd  -0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    1a70 <UpdSnode+0x970>
jmp    1950 <UpdSnode+0x850>
mov    -0x70(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%r15
setb   %r8b
cmp    -0x28(%rsp),%r11
setb   %dl
and    %r8b,%dl
or     -0x60(%rsp),%dl
cmp    %rcx,%r12
setb   %cl
cmp    -0x40(%rsp),%r11
setb   %r8b
test   %dl,%dl
jne    1c15 <UpdSnode+0xb15>
mov    $0x0,%edx
and    %r8b,%cl
mov    -0x7c(%rsp),%esi
mov    -0x50(%rsp),%r8
jne    1a19 <UpdSnode+0x919>
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x0,-0x48(%rsp)
je     1c25 <UpdSnode+0xb25>
mov    0x88(%rsp),%rcx
lea    (%rcx,%r10,8),%rdx
mov    -0x78(%rsp),%rbp
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd -0x10(%rdx,%rcx,8),%xmm4
movupd -0x10(%rax,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%rax,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm4
movupd -0x10(%r13,%rcx,8),%xmm5
mulpd  %xmm0,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%r13,%rcx,8)
movupd (%rdx,%rcx,8),%xmm4
movupd (%rax,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rax,%rcx,8)
movupd (%rdx,%rcx,8),%xmm4
movupd 0x0(%r13,%rcx,8),%xmm5
mulpd  %xmm0,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,0x0(%r13,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1b50 <UpdSnode+0xa50>
testb  $0x1,0x48(%rsp)
je     1bfd <UpdSnode+0xafd>
movupd (%r11,%rcx,8),%xmm4
movupd (%r15,%rcx,8),%xmm5
mulpd  %xmm4,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm3,(%r15,%rcx,8)
movupd (%r11,%rcx,8),%xmm3
movupd (%r12,%rcx,8),%xmm4
mulpd  %xmm3,%xmm0
addpd  %xmm4,%xmm0
movupd %xmm0,(%r12,%rcx,8)
mov    0x18(%rsp),%rcx
mov    %rcx,%rdx
cmp    -0x68(%rsp),%rcx
je     1950 <UpdSnode+0x850>
jmp    1a19 <UpdSnode+0x919>
xor    %edx,%edx
mov    -0x7c(%rsp),%esi
mov    -0x50(%rsp),%r8
jmp    1a19 <UpdSnode+0x919>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    1bc9 <UpdSnode+0xac9>
jmp    1bfd <UpdSnode+0xafd>
mov    0x70(%rsp),%edx
cmp    %edx,%r11d
jge    348f <UpdSnode+0x238f>
mov    %r11d,%edx
not    %r11d
add    0x90(%rsp),%r11d
mov    -0x58(%rsp),%rax
lea    0x8(%rax),%rcx
mov    %rcx,-0x48(%rsp)
lea    0x18(%rax),%rcx
mov    %rcx,0xd0(%rsp)
mov    0x118(%rsp),%rcx
lea    0x10(%rcx),%rdi
mov    %rdi,0xc0(%rsp)
add    $0x38,%rax
mov    %rax,0xc8(%rsp)
lea    0x30(%rcx),%rax
mov    %rax,0xb8(%rsp)
xor    %edi,%edi
movapd 0x2364(%rip),%xmm10
mov    %r11d,%eax
mov    %r11d,0x54(%rsp)
mov    %r11,0x10(%rsp)
jmp    1cdc <UpdSnode+0xbdc>
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rdx
add    $0x1,%rdx
mov    0xa8(%rsp),%rdi
add    $0x1,%edi
addl   $0xffffffff,0x54(%rsp)
cmp    0xa0(%rsp),%rdx
mov    0x10(%rsp),%r11
je     348f <UpdSnode+0x238f>
mov    %edx,%eax
not    %eax
add    0x90(%rsp),%eax
mov    %eax,-0x40(%rsp)
mov    0x120(%rsp),%rax
mov    %rdx,-0x70(%rsp)
movslq (%rax,%rdx,4),%rcx
mov    0x118(%rsp),%rax
mov    %rcx,0x98(%rsp)
lea    (%rax,%rcx,8),%rax
mov    $0x0,%r14d
cmp    $0x10,%esi
mov    %rax,-0x78(%rsp)
mov    %rdi,0xa8(%rsp)
jl     228f <UpdSnode+0x118f>
movslq -0x40(%rsp),%rax
mov    %rax,-0x28(%rsp)
mov    $0xf,%ecx
xor    %r14d,%r14d
jmp    1d67 <UpdSnode+0xc67>
mov    -0x60(%rsp),%r14
add    $0x10,%r14
mov    %r14,%rax
or     $0xf,%rax
mov    0x48(%rsp),%rcx
add    $0x10,%rcx
cmp    0xb0(%rsp),%rax
jge    2270 <UpdSnode+0x1170>
mov    %rcx,0x48(%rsp)
mov    0x30(%rsp),%r13
movslq 0x0(%r13,%r14,4),%rax
mov    -0x70(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x68(%rsp)
mov    %r14,%rdx
or     $0x1,%rdx
movslq 0x0(%r13,%rdx,4),%rax
add    %rcx,%rax
mov    %r14,%r10
or     $0x2,%r10
movslq 0x0(%r13,%r10,4),%r9
add    %rcx,%r9
mov    %r14,%r11
or     $0x3,%r11
movslq 0x0(%r13,%r11,4),%rdi
add    %rcx,%rdi
mov    %r14,%rsi
or     $0x4,%rsi
mov    %rsi,-0x20(%rsp)
movslq 0x0(%r13,%rsi,4),%rsi
add    %rcx,%rsi
mov    %rsi,0x18(%rsp)
mov    %r14,%rsi
or     $0x5,%rsi
mov    %rsi,(%rsp)
movslq 0x0(%r13,%rsi,4),%r8
add    %rcx,%r8
mov    %r14,%r12
or     $0x6,%r12
movslq 0x0(%r13,%r12,4),%rsi
add    %rcx,%rsi
mov    %rsi,0x40(%rsp)
mov    %r14,%rbp
mov    %r14,%r15
or     $0x7,%r15
movslq 0x0(%r13,%r15,4),%r14
mov    -0x58(%rsp),%rbx
mov    %rax,0x88(%rsp)
movsd  (%rbx,%rax,8),%xmm11
movapd %xmm11,%xmm4
mov    0x28(%rsp),%rax
divsd  (%rax,%rdx,8),%xmm4
add    %rcx,%r14
mov    %rbp,%rdx
mov    %r9,0x58(%rsp)
movsd  (%rbx,%r9,8),%xmm1
movapd %xmm1,%xmm9
divsd  (%rax,%r10,8),%xmm9
or     $0x8,%rdx
movslq 0x0(%r13,%rdx,4),%r10
add    %rcx,%r10
mov    %rdi,0x20(%rsp)
movsd  (%rbx,%rdi,8),%xmm6
movapd %xmm6,%xmm10
divsd  (%rax,%r11,8),%xmm10
mov    %rbp,%rdi
or     $0x9,%rdi
mov    0x18(%rsp),%rsi
movsd  (%rbx,%rsi,8),%xmm5
movapd %xmm5,%xmm14
mov    -0x20(%rsp),%rsi
divsd  (%rax,%rsi,8),%xmm14
movslq 0x0(%r13,%rdi,4),%r11
add    %rcx,%r11
mov    %r8,0x80(%rsp)
movsd  (%rbx,%r8,8),%xmm2
movapd %xmm2,%xmm15
mov    (%rsp),%rsi
divsd  (%rax,%rsi,8),%xmm15
mov    %rbp,%r9
or     $0xa,%r9
mov    0x40(%rsp),%rsi
movsd  (%rbx,%rsi,8),%xmm3
movapd %xmm3,%xmm0
divsd  (%rax,%r12,8),%xmm0
movsd  %xmm0,0x60(%rsp)
movslq 0x0(%r13,%r9,4),%r8
add    %rcx,%r8
mov    %r14,0x78(%rsp)
movsd  (%rbx,%r14,8),%xmm8
movapd %xmm8,%xmm0
divsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,0x38(%rsp)
mov    %rbp,%r14
or     $0xb,%r14
mov    0x68(%rsp),%rsi
movsd  (%rbx,%rsi,8),%xmm7
movapd %xmm7,%xmm0
divsd  (%rax,%rbp,8),%xmm0
movsd  %xmm4,-0x20(%rsp)
mulsd  %xmm4,%xmm11
movsd  %xmm0,(%rsp)
mulsd  %xmm0,%xmm7
addsd  %xmm11,%xmm7
mov    %r10,0x70(%rsp)
movsd  (%rbx,%r10,8),%xmm4
movapd %xmm9,%xmm11
mulsd  %xmm9,%xmm1
addsd  %xmm7,%xmm1
movapd %xmm4,%xmm0
divsd  (%rax,%rdx,8),%xmm0
movslq 0x0(%r13,%r14,4),%r15
movapd %xmm10,%xmm12
mulsd  %xmm10,%xmm6
addsd  %xmm1,%xmm6
movsd  (%rbx,%r11,8),%xmm7
movapd %xmm14,%xmm13
mulsd  %xmm14,%xmm5
addsd  %xmm6,%xmm5
movapd %xmm7,%xmm1
divsd  (%rax,%rdi,8),%xmm1
add    %rcx,%r15
mov    %rbp,%rdx
movapd %xmm15,%xmm14
mulsd  %xmm15,%xmm2
addsd  %xmm5,%xmm2
movsd  (%rbx,%r8,8),%xmm5
movsd  0x60(%rsp),%xmm6
movapd %xmm6,%xmm15
mulsd  %xmm6,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm5,%xmm2
divsd  (%rax,%r9,8),%xmm2
or     $0xc,%rdx
movslq 0x0(%r13,%rdx,4),%r12
add    %rcx,%r12
movsd  0x38(%rsp),%xmm6
movapd %xmm6,%xmm9
mulsd  %xmm6,%xmm8
addsd  %xmm3,%xmm8
movsd  (%rbx,%r15,8),%xmm6
mulsd  %xmm0,%xmm4
addsd  %xmm8,%xmm4
movapd %xmm6,%xmm3
divsd  (%rax,%r14,8),%xmm3
mov    %rbp,%rdi
or     $0xd,%rdi
mulsd  %xmm1,%xmm7
addsd  %xmm4,%xmm7
movsd  (%rbx,%r12,8),%xmm4
mulsd  %xmm2,%xmm5
addsd  %xmm7,%xmm5
movapd %xmm4,%xmm7
divsd  (%rax,%rdx,8),%xmm7
movslq 0x0(%r13,%rdi,4),%rsi
add    %rcx,%rsi
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  (%rbx,%rsi,8),%xmm5
mulsd  %xmm7,%xmm4
addsd  %xmm6,%xmm4
movapd %xmm5,%xmm10
divsd  (%rax,%rdi,8),%xmm10
mov    %rbp,-0x60(%rsp)
or     $0xe,%rbp
movslq 0x0(%r13,%rbp,4),%rdi
add    %rcx,%rdi
mulsd  %xmm10,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rbx,%rdi,8),%xmm4
movapd %xmm4,%xmm6
divsd  (%rax,%rbp,8),%xmm6
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mov    0x48(%rsp),%rdx
movslq 0x0(%r13,%rdx,4),%rbp
add    %rcx,%rbp
movsd  (%rbx,%rbp,8),%xmm5
movapd %xmm5,%xmm8
divsd  (%rax,%rdx,8),%xmm8
mulsd  %xmm8,%xmm5
addsd  %xmm4,%xmm5
mov    0x110(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rax,%rcx,8)
cmpl   $0x0,-0x40(%rsp)
mov    -0x78(%rsp),%r13
jle    1d40 <UpdSnode+0xc40>
mov    -0x48(%rsp),%r9
lea    (%r9,%rbp,8),%rdx
lea    (%r9,%rdi,8),%rax
mov    %rax,-0x38(%rsp)
lea    (%r9,%rsi,8),%rax
mov    %rax,-0x68(%rsp)
lea    (%r9,%r12,8),%rax
mov    %rax,-0x50(%rsp)
lea    (%r9,%r15,8),%rax
mov    %rax,-0x30(%rsp)
lea    (%r9,%r8,8),%rax
mov    %rax,-0x8(%rsp)
lea    (%r9,%r11,8),%r14
mov    0x70(%rsp),%rax
lea    (%r9,%rax,8),%rcx
mov    0x78(%rsp),%rax
lea    (%r9,%rax,8),%rax
mov    0x40(%rsp),%rsi
lea    (%r9,%rsi,8),%rdi
mov    0x80(%rsp),%rsi
lea    (%r9,%rsi,8),%rbx
mov    0x18(%rsp),%rsi
lea    (%r9,%rsi,8),%rsi
mov    0x20(%rsp),%rbp
lea    (%r9,%rbp,8),%r10
mov    0x58(%rsp),%rbp
lea    (%r9,%rbp,8),%r11
mov    0x88(%rsp),%rbp
lea    (%r9,%rbp,8),%r8
mov    0x68(%rsp),%rbp
lea    (%r9,%rbp,8),%r9
mov    %rdx,%rbp
xor    %r12d,%r12d
movsd  (%r8,%r12,8),%xmm4
mulsd  -0x20(%rsp),%xmm4
movsd  (%r9,%r12,8),%xmm5
mulsd  (%rsp),%xmm5
addsd  %xmm4,%xmm5
movsd  (%r11,%r12,8),%xmm4
mulsd  %xmm11,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r10,%r12,8),%xmm5
mulsd  %xmm12,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rsi,%r12,8),%xmm4
mulsd  %xmm13,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rbx,%r12,8),%xmm5
mulsd  %xmm14,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rdi,%r12,8),%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rax,%r12,8),%xmm5
mulsd  %xmm9,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rcx,%r12,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r14,%r12,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
mov    -0x8(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
mov    -0x30(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
mov    -0x50(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm5,%xmm4
mov    -0x68(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm5
mulsd  %xmm10,%xmm5
addsd  %xmm4,%xmm5
mov    -0x38(%rsp),%r15
movsd  (%r15,%r12,8),%xmm4
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
movsd  0x0(%rbp,%r12,8),%xmm5
mulsd  %xmm8,%xmm5
addsd  %xmm4,%xmm5
movsd  0x0(%r13,%r12,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,0x0(%r13,%r12,8)
add    $0x1,%r12
cmp    -0x28(%rsp),%r12
jl     2140 <UpdSnode+0x1040>
jmp    1d40 <UpdSnode+0xc40>
nopw   0x0(%rax,%rax,1)
mov    -0x7c(%rsp),%esi
mov    0x10(%rsp),%r11
mov    0xa8(%rsp),%rdi
movapd 0x1d76(%rip),%xmm10
mov    -0x78(%rsp),%rax
mov    %r11d,%edx
sub    %edi,%edx
lea    0xb(%r14),%r11d
cmp    %esi,%r11d
jge    2640 <UpdSnode+0x1540>
mov    %edx,-0x60(%rsp)
movslq -0x40(%rsp),%rax
mov    %rax,-0x28(%rsp)
mov    %r14d,%r15d
jmp    22e0 <UpdSnode+0x11e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x20(%rsp),%rax
lea    0xc(%rax),%r14
mov    %eax,%r11d
add    $0x17,%r11d
mov    %r14,%r15
mov    -0x7c(%rsp),%esi
cmp    %esi,%r11d
jge    2650 <UpdSnode+0x1550>
mov    0x30(%rsp),%rdi
movslq (%rdi,%r15,4),%rax
mov    -0x70(%rsp),%rdx
add    %rdx,%rax
mov    %r15d,%ecx
or     $0x1,%ecx
mov    %rcx,-0x20(%rsp)
movslq (%rdi,%rcx,4),%rcx
add    %rdx,%rcx
mov    %r15d,%esi
or     $0x2,%esi
mov    %rsi,(%rsp)
movslq (%rdi,%rsi,4),%rsi
add    %rdx,%rsi
mov    %r15d,%r12d
or     $0x3,%r12d
movslq (%rdi,%r12,4),%r8
add    %rdx,%r8
movslq 0x10(%rdi,%r15,4),%r10
add    %rdx,%r10
movslq 0x14(%rdi,%r15,4),%r9
add    %rdx,%r9
movslq 0x18(%rdi,%r15,4),%r13
add    %rdx,%r13
movslq 0x1c(%rdi,%r15,4),%rbx
add    %rdx,%rbx
movslq 0x20(%rdi,%r15,4),%r14
mov    -0x58(%rsp),%rbp
mov    %rax,-0x38(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm9
mov    0x28(%rsp),%rax
divsd  (%rax,%r15,8),%xmm9
add    %rdx,%r14
mov    %rcx,-0x68(%rsp)
movsd  0x0(%rbp,%rcx,8),%xmm7
movapd %xmm7,%xmm8
mov    -0x20(%rsp),%rcx
divsd  (%rax,%rcx,8),%xmm8
movslq 0x24(%rdi,%r15,4),%rcx
mov    %rsi,-0x50(%rsp)
movsd  0x0(%rbp,%rsi,8),%xmm1
movapd %xmm1,%xmm10
mov    (%rsp),%rsi
divsd  (%rax,%rsi,8),%xmm10
add    %rdx,%rcx
mov    %r8,(%rsp)
movsd  0x0(%rbp,%r8,8),%xmm2
mov    %r13,%r8
mov    %rcx,%r13
movapd %xmm2,%xmm11
divsd  (%rax,%r12,8),%xmm11
movslq 0x28(%rdi,%r15,4),%r12
mov    %r10,-0x30(%rsp)
movsd  0x0(%rbp,%r10,8),%xmm14
movapd %xmm14,%xmm15
divsd  0x20(%rax,%r15,8),%xmm15
add    %rdx,%r12
mov    %r9,-0x8(%rsp)
movsd  0x0(%rbp,%r9,8),%xmm6
mov    %r14,%r9
movapd %xmm6,%xmm13
divsd  0x28(%rax,%r15,8),%xmm13
mov    %r11d,%ecx
movsd  0x0(%rbp,%r8,8),%xmm12
movsd  %xmm12,-0x20(%rsp)
divsd  0x30(%rax,%r15,8),%xmm12
mulsd  %xmm8,%xmm7
mulsd  %xmm9,%xmm0
addsd  %xmm7,%xmm0
movsd  0x0(%rbp,%rbx,8),%xmm3
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm3,%xmm7
divsd  0x38(%rax,%r15,8),%xmm7
movslq (%rdi,%rcx,4),%rdi
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movsd  0x0(%rbp,%r14,8),%xmm4
mulsd  %xmm15,%xmm14
addsd  %xmm2,%xmm14
movapd %xmm4,%xmm0
divsd  0x40(%rax,%r15,8),%xmm0
add    %rdx,%rdi
mulsd  %xmm13,%xmm6
addsd  %xmm14,%xmm6
movsd  0x0(%rbp,%r13,8),%xmm5
movsd  -0x20(%rsp),%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm1,%xmm2
movapd %xmm5,%xmm1
divsd  0x48(%rax,%r15,8),%xmm1
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  0x0(%rbp,%r12,8),%xmm6
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm2
mov    %r15,-0x20(%rsp)
divsd  0x50(%rax,%r15,8),%xmm2
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  0x0(%rbp,%rdi,8),%xmm4
mulsd  %xmm2,%xmm6
addsd  %xmm5,%xmm6
movapd %xmm4,%xmm3
divsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm4
addsd  %xmm6,%xmm4
mov    0x110(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,(%rax,%rdx,8)
cmpl   $0x0,-0x40(%rsp)
mov    -0x78(%rsp),%r11
mov    -0x28(%rsp),%r14
jle    22c0 <UpdSnode+0x11c0>
mov    -0x48(%rsp),%rsi
lea    (%rsi,%rdi,8),%r15
lea    (%rsi,%r12,8),%r12
lea    (%rsi,%r13,8),%r13
lea    (%rsi,%r9,8),%r9
lea    (%rsi,%rbx,8),%r10
lea    (%rsi,%r8,8),%r8
mov    -0x8(%rsp),%rax
lea    (%rsi,%rax,8),%rbp
mov    -0x30(%rsp),%rax
lea    (%rsi,%rax,8),%rcx
mov    (%rsp),%rax
lea    (%rsi,%rax,8),%rdi
mov    -0x50(%rsp),%rax
lea    (%rsi,%rax,8),%rdx
mov    -0x68(%rsp),%rax
lea    (%rsi,%rax,8),%rax
mov    -0x38(%rsp),%rbx
lea    (%rsi,%rbx,8),%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm4
mulsd  %xmm8,%xmm4
movsd  (%rbx,%rsi,8),%xmm5
mulsd  %xmm9,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rdx,%rsi,8),%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdi,%rsi,8),%xmm5
mulsd  %xmm11,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rcx,%rsi,8),%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm5,%xmm4
movsd  0x0(%rbp,%rsi,8),%xmm5
mulsd  %xmm13,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r8,%rsi,8),%xmm4
mulsd  %xmm12,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r10,%rsi,8),%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r9,%rsi,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
movsd  0x0(%r13,%rsi,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r12,%rsi,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%r15,%rsi,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r11,%rsi,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r11,%rsi,8)
add    $0x1,%rsi
cmp    %r14,%rsi
jl     2570 <UpdSnode+0x1470>
jmp    22c0 <UpdSnode+0x11c0>
nopl   0x0(%rax)
mov    -0x70(%rsp),%r11
jmp    2667 <UpdSnode+0x1567>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%r11
movapd 0x19a2(%rip),%xmm10
mov    -0x78(%rsp),%rax
mov    -0x60(%rsp),%edx
movslq 0x54(%rsp),%r10
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x58(%rsp)
movslq %edx,%r8
lea    0x7(%r14),%r15d
cmp    %esi,%r15d
mov    %r8,-0x68(%rsp)
mov    %r10,0x20(%rsp)
jge    2c98 <UpdSnode+0x1b98>
movslq -0x40(%rsp),%r9
mov    %r14d,%r14d
mov    0x98(%rsp),%rax
add    %r8,%rax
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x80(%rsp)
mov    -0x48(%rsp),%rax
lea    (%rax,%r8,8),%rax
mov    %rax,0x78(%rsp)
and    $0xfffffffffffffffe,%r8
mov    %r8,0x70(%rsp)
jmp    26f5 <UpdSnode+0x15f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x8(%r15),%r14
add    $0xf,%r15d
mov    -0x7c(%rsp),%esi
cmp    %esi,%r15d
jge    2c80 <UpdSnode+0x1b80>
mov    %r15d,%eax
mov    %r15d,%r8d
mov    %r14,%r15
mov    0x30(%rsp),%rdi
movslq (%rdi,%r14,4),%r13
add    %r11,%r13
mov    %r15d,%ecx
or     $0x1,%ecx
movslq (%rdi,%rcx,4),%rbx
add    %r11,%rbx
mov    %r15d,%edx
or     $0x2,%edx
movslq (%rdi,%rdx,4),%rax
add    %r11,%rax
mov    %r15d,%r10d
or     $0x3,%r10d
movslq (%rdi,%r10,4),%rsi
add    %r11,%rsi
mov    -0x58(%rsp),%rbp
mov    %rbx,-0x38(%rsp)
movsd  0x0(%rbp,%rbx,8),%xmm1
movapd %xmm1,%xmm8
mov    0x28(%rsp),%rbx
divsd  (%rbx,%rcx,8),%xmm8
movslq 0x10(%rdi,%r14,4),%rcx
add    %r11,%rcx
mov    %rax,-0x50(%rsp)
movsd  0x0(%rbp,%rax,8),%xmm2
movapd %xmm2,%xmm10
divsd  (%rbx,%rdx,8),%xmm10
movslq 0x14(%rdi,%r14,4),%rdx
movsd  0x0(%rbp,%r13,8),%xmm3
movapd %xmm3,%xmm9
divsd  (%rbx,%r14,8),%xmm9
add    %r11,%rdx
mov    %rsi,-0x30(%rsp)
movsd  0x0(%rbp,%rsi,8),%xmm4
movapd %xmm4,%xmm11
divsd  (%rbx,%r10,8),%xmm11
movslq (%rdi,%r8,4),%r10
mov    %rcx,-0x8(%rsp)
movsd  0x0(%rbp,%rcx,8),%xmm5
movapd %xmm5,%xmm12
divsd  0x20(%rbx,%r14,8),%xmm12
add    %r11,%r10
movsd  0x0(%rbp,%r10,8),%xmm6
movapd %xmm6,%xmm15
divsd  (%rbx,%r8,8),%xmm15
movslq 0x18(%rdi,%r14,4),%r14
movsd  0x0(%rbp,%rdx,8),%xmm7
movapd %xmm7,%xmm13
divsd  0x28(%rbx,%r15,8),%xmm13
add    %r11,%r14
movsd  0x0(%rbp,%r14,8),%xmm0
movapd %xmm0,%xmm14
divsd  0x30(%rbx,%r15,8),%xmm14
mulsd  %xmm8,%xmm1
mulsd  %xmm9,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm10,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm11,%xmm4
addsd  %xmm2,%xmm4
mulsd  %xmm12,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm13,%xmm7
addsd  %xmm5,%xmm7
mulsd  %xmm14,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm15,%xmm6
addsd  %xmm0,%xmm6
mov    0x110(%rsp),%rax
movsd  (%rax,%r11,8),%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,(%rax,%r11,8)
cmpl   $0x0,-0x40(%rsp)
jle    26e0 <UpdSnode+0x15e0>
cmpl   $0x2,-0x68(%rsp)
jae    2880 <UpdSnode+0x1780>
xor    %ecx,%ecx
mov    -0x78(%rsp),%r12
jmp    2b90 <UpdSnode+0x1a90>
nopw   0x0(%rax,%rax,1)
mov    -0x58(%rsp),%rdi
mov    -0x38(%rsp),%rax
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rsp)
mov    -0x50(%rsp),%r11
lea    0x8(%rdi,%r11,8),%rax
mov    %rax,(%rsp)
mov    -0x30(%rsp),%r12
lea    0x8(%rdi,%r12,8),%rax
mov    %rax,-0x60(%rsp)
mov    -0x8(%rsp),%rsi
lea    0x8(%rdi,%rsi,8),%rax
mov    %rax,0x18(%rsp)
lea    0x8(%rdi,%rdx,8),%rax
mov    %rax,0x40(%rsp)
lea    0x8(%rdi,%r14,8),%rax
mov    %rax,0x38(%rsp)
lea    0x8(%rdi,%r10,8),%r8
mov    %r13,%rbx
mov    0x78(%rsp),%r13
lea    0x0(,%r10,8),%rbp
add    %r13,%rbp
mov    -0x78(%rsp),%rax
cmp    %rbp,%rax
lea    0x0(%r13,%r14,8),%rbp
setb   0x48(%rsp)
mov    0x80(%rsp),%rcx
cmp    %rcx,%r8
setb   0x68(%rsp)
cmp    %rbp,%rax
mov    %rdx,-0x28(%rsp)
lea    0x0(%r13,%rdx,8),%rbp
setb   %dl
cmp    %rcx,0x38(%rsp)
setb   0x38(%rsp)
cmp    %rbp,%rax
lea    0x0(%r13,%rsi,8),%rsi
setb   %r8b
cmp    %rcx,0x40(%rsp)
setb   0x40(%rsp)
cmp    %rsi,%rax
lea    0x0(%r13,%r12,8),%rsi
setb   %r12b
cmp    %rcx,0x18(%rsp)
setb   0x18(%rsp)
cmp    %rsi,%rax
lea    0x0(%r13,%r11,8),%rsi
setb   %r11b
cmp    %rcx,-0x60(%rsp)
setb   0x60(%rsp)
cmp    %rsi,%rax
mov    -0x38(%rsp),%rsi
lea    0x0(%r13,%rsi,8),%rsi
setb   0x88(%rsp)
cmp    %rcx,(%rsp)
setb   (%rsp)
cmp    %rsi,%rax
lea    0x0(%r13,%rbx,8),%rsi
setb   %r13b
cmp    %rcx,-0x20(%rsp)
setb   -0x20(%rsp)
cmp    %rsi,%rax
mov    %rbx,-0x60(%rsp)
lea    0x8(%rdi,%rbx,8),%rbp
setb   %sil
cmp    %rcx,%rbp
setb   %al
mov    0x68(%rsp),%cl
test   %cl,0x48(%rsp)
jne    2c61 <UpdSnode+0x1b61>
and    0x38(%rsp),%dl
jne    2c61 <UpdSnode+0x1b61>
and    0x40(%rsp),%r8b
mov    -0x28(%rsp),%rdx
jne    2b7b <UpdSnode+0x1a7b>
and    0x18(%rsp),%r12b
jne    2b7b <UpdSnode+0x1a7b>
and    0x60(%rsp),%r11b
jne    2b7b <UpdSnode+0x1a7b>
mov    (%rsp),%cl
and    %cl,0x88(%rsp)
jne    2b7b <UpdSnode+0x1a7b>
and    -0x20(%rsp),%r13b
jne    2b7b <UpdSnode+0x1a7b>
mov    $0x0,%ecx
and    %al,%sil
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%r12
mov    -0x60(%rsp),%r13
jne    2b90 <UpdSnode+0x1a90>
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
movapd %xmm0,-0x20(%rsp)
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
movapd %xmm0,(%rsp)
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
movapd %xmm11,%xmm4
unpcklpd %xmm11,%xmm4
movapd %xmm12,%xmm5
unpcklpd %xmm12,%xmm5
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
movapd %xmm14,%xmm0
unpcklpd %xmm14,%xmm0
movapd %xmm15,%xmm6
unpcklpd %xmm15,%xmm6
mov    -0x48(%rsp),%rax
lea    (%rax,%r13,8),%rcx
mov    %rdx,%r8
mov    -0x38(%rsp),%rdx
lea    (%rax,%rdx,8),%rdx
mov    -0x50(%rsp),%rsi
lea    (%rax,%rsi,8),%rdi
mov    -0x30(%rsp),%rsi
lea    (%rax,%rsi,8),%rbp
mov    -0x8(%rsp),%rsi
lea    (%rax,%rsi,8),%rbx
lea    (%rax,%r8,8),%r11
lea    (%rax,%r14,8),%r8
lea    (%rax,%r10,8),%rax
xor    %esi,%esi
mov    0x58(%rsp),%r13
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rsi,8),%xmm1
mulpd  (%rsp),%xmm1
movupd (%rdx,%rsi,8),%xmm3
mulpd  -0x20(%rsp),%xmm3
addpd  %xmm1,%xmm3
movupd (%rdi,%rsi,8),%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm3,%xmm1
movupd 0x0(%rbp,%rsi,8),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movupd (%rbx,%rsi,8),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm3,%xmm1
movupd (%r11,%rsi,8),%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
movupd (%r8,%rsi,8),%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd (%rax,%rsi,8),%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movupd (%r12,%rsi,8),%xmm1
subpd  %xmm3,%xmm1
movupd %xmm1,(%r12,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r13
jne    2ad0 <UpdSnode+0x19d0>
mov    0x70(%rsp),%rax
mov    %rax,%rcx
cmp    -0x68(%rsp),%rax
mov    -0x70(%rsp),%r11
mov    -0x60(%rsp),%r13
mov    -0x28(%rsp),%rdx
je     26e0 <UpdSnode+0x15e0>
jmp    2b90 <UpdSnode+0x1a90>
xor    %ecx,%ecx
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%r12
mov    -0x60(%rsp),%r13
nopl   0x0(%rax)
mov    -0x48(%rsp),%rdi
lea    (%rdi,%r10,8),%r8
lea    (%rdi,%r14,8),%r10
lea    (%rdi,%rdx,8),%rbp
mov    -0x8(%rsp),%rax
lea    (%rdi,%rax,8),%rbx
mov    -0x30(%rsp),%rax
lea    (%rdi,%rax,8),%rsi
mov    -0x50(%rsp),%rax
lea    (%rdi,%rax,8),%rax
mov    -0x38(%rsp),%rdx
lea    (%rdi,%rdx,8),%rdx
lea    (%rdi,%r13,8),%rdi
nopl   0x0(%rax)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm8,%xmm0
movsd  (%rdi,%rcx,8),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm13,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r12,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %r9,%rcx
jl     2bd0 <UpdSnode+0x1ad0>
jmp    26e0 <UpdSnode+0x15e0>
xor    %ecx,%ecx
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%r12
mov    -0x60(%rsp),%r13
mov    -0x28(%rsp),%rdx
jmp    2b90 <UpdSnode+0x1a90>
nopl   0x0(%rax)
movapd 0x1377(%rip),%xmm10
mov    -0x78(%rsp),%rax
mov    -0x68(%rsp),%r8
mov    0x20(%rsp),%r10
mov    %r14d,%ecx
or     $0x3,%ecx
cmp    %esi,%ecx
jge    2fd5 <UpdSnode+0x1ed5>
movslq -0x40(%rsp),%r13
mov    %r14d,%r14d
mov    0x98(%rsp),%rdx
add    %r8,%rdx
mov    0x118(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,(%rsp)
mov    -0x48(%rsp),%rdx
lea    (%rdx,%r8,8),%rdx
mov    %rdx,-0x38(%rsp)
and    $0xfffffffffffffffe,%r8
mov    %r8,-0x50(%rsp)
jmp    2d0b <UpdSnode+0x1c0b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x60(%rsp),%r14
add    $0x4,%r14
mov    %r14d,%ecx
or     $0x3,%ecx
mov    -0x7c(%rsp),%esi
cmp    %esi,%ecx
jge    2fd0 <UpdSnode+0x1ed0>
mov    0x30(%rsp),%rdi
movslq (%rdi,%r14,4),%r12
add    %r11,%r12
mov    %r14d,%edx
or     $0x1,%edx
movslq (%rdi,%rdx,4),%r8
add    %r11,%r8
mov    %r14d,%esi
or     $0x2,%esi
movslq (%rdi,%rsi,4),%r9
add    %r11,%r9
mov    -0x58(%rsp),%rbp
movsd  0x0(%rbp,%r12,8),%xmm4
movapd %xmm4,%xmm0
mov    0x28(%rsp),%rbx
mov    %r14,-0x60(%rsp)
divsd  (%rbx,%r14,8),%xmm0
mov    %ecx,%ecx
movsd  0x0(%rbp,%r8,8),%xmm5
movapd %xmm5,%xmm1
divsd  (%rbx,%rdx,8),%xmm1
movslq (%rdi,%rcx,4),%r15
movsd  0x0(%rbp,%r9,8),%xmm6
movapd %xmm6,%xmm2
divsd  (%rbx,%rsi,8),%xmm2
add    %r11,%r15
movsd  0x0(%rbp,%r15,8),%xmm7
movapd %xmm7,%xmm3
divsd  (%rbx,%rcx,8),%xmm3
mulsd  %xmm1,%xmm5
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm3,%xmm7
addsd  %xmm6,%xmm7
mov    0x110(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm4
subsd  %xmm7,%xmm4
movsd  %xmm4,(%rcx,%r11,8)
cmpl   $0x0,-0x40(%rsp)
jle    2cf0 <UpdSnode+0x1bf0>
cmpl   $0x2,-0x68(%rsp)
jae    2e60 <UpdSnode+0x1d60>
xor    %ecx,%ecx
mov    -0x48(%rsp),%rbp
lea    0x0(,%r15,8),%rdx
add    %rbp,%rdx
lea    0x0(,%r9,8),%rdi
add    %rbp,%rdi
lea    0x0(,%r8,8),%rsi
add    %rbp,%rsi
lea    0x0(%rbp,%r12,8),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm4
mulsd  %xmm1,%xmm4
movsd  0x0(%rbp,%rcx,8),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rdi,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rax,%rcx,8),%xmm4
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %r13,%rcx
jl     2e10 <UpdSnode+0x1d10>
jmp    2cf0 <UpdSnode+0x1bf0>
nopl   (%rax)
mov    -0x58(%rsp),%r14
lea    (%r14,%r8,8),%rsi
add    $0x8,%rsi
lea    0x8(%r14,%r9,8),%rdx
lea    (%r14,%r15,8),%rcx
add    $0x8,%rcx
mov    -0x38(%rsp),%r11
lea    (%r11,%r15,8),%rdi
cmp    %rdi,%rax
lea    (%r11,%r9,8),%rdi
setb   -0x20(%rsp)
mov    (%rsp),%rbp
cmp    %rbp,%rcx
setb   %r10b
cmp    %rdi,%rax
lea    (%r11,%r8,8),%rdi
setb   %cl
cmp    %rbp,%rdx
setb   %bl
cmp    %rdi,%rax
lea    (%r11,%r12,8),%rdi
setb   %dl
cmp    %rbp,%rsi
setb   %r11b
cmp    %rdi,%rax
lea    0x8(%r14,%r12,8),%rdi
setb   %sil
cmp    %rbp,%rdi
setb   %dil
test   %r10b,-0x20(%rsp)
jne    2fb1 <UpdSnode+0x1eb1>
and    %bl,%cl
jne    2fb1 <UpdSnode+0x1eb1>
and    %r11b,%dl
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%rax
mov    0x20(%rsp),%r10
mov    0x58(%rsp),%rbx
jne    2dd4 <UpdSnode+0x1cd4>
mov    $0x0,%ecx
and    %dil,%sil
jne    2dd6 <UpdSnode+0x1cd6>
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
movapd %xmm3,%xmm7
unpcklpd %xmm3,%xmm7
mov    -0x48(%rsp),%rsi
lea    (%rsi,%r12,8),%rcx
lea    (%rsi,%r8,8),%rdx
lea    (%rsi,%r9,8),%rdi
lea    (%rsi,%r15,8),%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rbp,8),%xmm4
mulpd  %xmm9,%xmm4
movupd (%rdx,%rbp,8),%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm4,%xmm5
movupd (%rdi,%rbp,8),%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
movupd (%rsi,%rbp,8),%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm4,%xmm5
movupd (%rax,%rbp,8),%xmm4
subpd  %xmm5,%xmm4
movupd %xmm4,(%rax,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rbx
jne    2f50 <UpdSnode+0x1e50>
mov    -0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    -0x68(%rsp),%rdx
je     2cf0 <UpdSnode+0x1bf0>
jmp    2dd6 <UpdSnode+0x1cd6>
xor    %ecx,%ecx
mov    -0x70(%rsp),%r11
mov    -0x78(%rsp),%rax
mov    0x20(%rsp),%r10
jmp    2dd6 <UpdSnode+0x1cd6>
nopw   0x0(%rax,%rax,1)
mov    -0x68(%rsp),%r8
mov    %r14d,%ecx
or     $0x1,%ecx
cmp    %esi,%ecx
jge    3230 <UpdSnode+0x2130>
and    $0xfffffffffffffffc,%r10
movslq -0x40(%rsp),%rbp
mov    %r14d,%r14d
mov    0x98(%rsp),%rbx
lea    (%rbx,%r8,1),%rdx
mov    0x118(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
mov    %rdx,-0x20(%rsp)
mov    -0x48(%rsp),%rdx
lea    (%rdx,%r8,8),%rdx
mov    %rdx,(%rsp)
mov    %r8,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rsp)
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
jmp    3052 <UpdSnode+0x1f52>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%r14
mov    %r14d,%ecx
or     $0x1,%ecx
cmp    %esi,%ecx
jge    3230 <UpdSnode+0x2130>
mov    0x30(%rsp),%rdx
movslq (%rdx,%r14,4),%r12
add    %r11,%r12
mov    %ecx,%ecx
movslq (%rdx,%rcx,4),%r13
mov    -0x58(%rsp),%rdx
movsd  (%rdx,%r12,8),%xmm2
movapd %xmm2,%xmm0
mov    0x28(%rsp),%rdi
divsd  (%rdi,%r14,8),%xmm0
add    %r11,%r13
movsd  (%rdx,%r13,8),%xmm3
movapd %xmm3,%xmm1
divsd  (%rdi,%rcx,8),%xmm1
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
mov    0x110(%rsp),%rcx
movsd  (%rcx,%r11,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%r11,8)
cmpl   $0x0,-0x40(%rsp)
jle    3040 <UpdSnode+0x1f40>
cmp    $0x4,%r8d
jae    30d0 <UpdSnode+0x1fd0>
xor    %ecx,%ecx
jmp    31e0 <UpdSnode+0x20e0>
nopl   0x0(%rax,%rax,1)
mov    %r10,%r9
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r12,8),%r8
add    $0x8,%r8
lea    0x8(%rcx,%r13,8),%rdx
mov    (%rsp),%rcx
lea    (%rcx,%r13,8),%rdi
lea    (%rcx,%r12,8),%rcx
cmp    %rdi,%rax
setb   %r11b
mov    -0x20(%rsp),%rsi
cmp    %rsi,%rdx
setb   %r15b
cmp    %rcx,%rax
setb   %dl
cmp    %rsi,%r8
setb   %dil
test   %r15b,%r11b
jne    31c8 <UpdSnode+0x20c8>
mov    $0x0,%ecx
and    %dil,%dl
mov    -0x7c(%rsp),%esi
mov    -0x70(%rsp),%r11
mov    -0x68(%rsp),%r8
mov    %r9,%r10
jne    31e0 <UpdSnode+0x20e0>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
mov    0xd0(%rsp),%rdx
lea    (%rdx,%r12,8),%rcx
lea    (%rdx,%r13,8),%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdi,8),%xmm4
movupd (%rcx,%rdi,8),%xmm5
movupd -0x10(%rdx,%rdi,8),%xmm6
movupd (%rdx,%rdi,8),%xmm7
mulpd  %xmm2,%xmm6
mulpd  %xmm2,%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
movupd -0x10(%rbx,%rdi,8),%xmm6
subpd  %xmm4,%xmm6
movupd (%rbx,%rdi,8),%xmm4
subpd  %xmm5,%xmm4
movupd %xmm6,-0x10(%rbx,%rdi,8)
movupd %xmm4,(%rbx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r10
jne    3160 <UpdSnode+0x2060>
mov    -0x38(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r8,%rdx
je     3040 <UpdSnode+0x1f40>
jmp    31e0 <UpdSnode+0x20e0>
xor    %ecx,%ecx
mov    -0x7c(%rsp),%esi
mov    -0x70(%rsp),%r11
mov    -0x68(%rsp),%r8
mov    %r9,%r10
nopl   0x0(%rax,%rax,1)
mov    -0x48(%rsp),%rdi
lea    (%rdi,%r13,8),%rdx
lea    (%rdi,%r12,8),%rdi
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  (%rdi,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  (%rax,%rcx,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rbp,%rcx
jl     31f0 <UpdSnode+0x20f0>
jmp    3040 <UpdSnode+0x1f40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %esi,%r14d
jge    1cb0 <UpdSnode+0xbb0>
mov    0x54(%rsp),%eax
and    $0xfffffffc,%eax
mov    %r14,%rcx
movslq %eax,%r15
add    $0xfffffffffffffffc,%r15
mov    %r8d,%eax
and    $0xfffffffc,%eax
shr    $0x2,%r15
movslq %eax,%r10
add    $0xfffffffffffffffc,%r10
add    $0x1,%r15
mov    %r10,%r14
shr    $0x2,%r14
and    $0xfffffffffffffffe,%r15
add    $0x1,%r14
movslq -0x40(%rsp),%rbx
mov    %ecx,%r9d
mov    0x98(%rsp),%rdx
lea    (%rdx,%r8,1),%rax
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,8),%r11
mov    -0x48(%rsp),%rax
lea    (%rax,%r8,8),%r12
mov    %r8,%r13
and    $0xfffffffffffffffc,%r13
mov    0xb8(%rsp),%rax
lea    (%rax,%rdx,8),%rbp
jmp    32bd <UpdSnode+0x21bd>
nopl   0x0(%rax)
add    $0x1,%r9
cmp    %esi,%r9d
jge    1cb0 <UpdSnode+0xbb0>
mov    0x30(%rsp),%rax
movslq (%rax,%r9,4),%rax
mov    -0x70(%rsp),%rdx
add    %rdx,%rax
mov    -0x58(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
movapd %xmm1,%xmm0
xorpd  %xmm10,%xmm0
mov    0x28(%rsp),%rcx
divsd  (%rcx,%r9,8),%xmm0
mulsd  %xmm0,%xmm1
mov    0x110(%rsp),%rcx
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
cmpl   $0x0,-0x40(%rsp)
jle    32b0 <UpdSnode+0x21b0>
cmp    $0x4,%r8d
jae    3320 <UpdSnode+0x2220>
xor    %ecx,%ecx
mov    -0x78(%rsp),%rdi
jmp    3450 <UpdSnode+0x2350>
nopl   0x0(%rax,%rax,1)
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
add    $0x8,%r8
lea    (%r12,%rax,8),%rcx
cmp    %rcx,-0x78(%rsp)
jae    3352 <UpdSnode+0x2252>
cmp    %r11,%r8
jae    3352 <UpdSnode+0x2252>
xor    %ecx,%ecx
mov    -0x7c(%rsp),%esi
mov    -0x78(%rsp),%rdi
mov    -0x68(%rsp),%r8
jmp    3450 <UpdSnode+0x2350>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
test   %r10,%r10
je     3481 <UpdSnode+0x2381>
mov    0xc8(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    %r15,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rdi,%rdx,8),%xmm2
movupd -0x20(%rdi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rbp,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rbp,%rdx,8),%xmm2
movupd -0x10(%rbp,%rdx,8),%xmm5
movupd 0x0(%rbp,%rdx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rbp,%rdx,8)
movupd %xmm3,-0x20(%rbp,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm2
movupd (%rdi,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rbp,%rdx,8)
movupd %xmm3,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    3380 <UpdSnode+0x2280>
test   $0x1,%r14b
je     342f <UpdSnode+0x232f>
movupd (%r8,%rdx,8),%xmm2
movupd 0x10(%r8,%rdx,8),%xmm3
mov    -0x78(%rsp),%rcx
movupd (%rcx,%rdx,8),%xmm4
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm3,0x10(%rcx,%rdx,8)
mov    %r13,%rcx
mov    -0x68(%rsp),%r8
cmp    %r8,%r13
mov    -0x7c(%rsp),%esi
mov    -0x78(%rsp),%rdi
je     32b0 <UpdSnode+0x21b0>
nopl   0x0(%rax)
mov    -0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rbx,%rcx
jl     3460 <UpdSnode+0x2360>
jmp    32b0 <UpdSnode+0x21b0>
xor    %edx,%edx
test   $0x1,%r14b
jne    33f7 <UpdSnode+0x22f7>
jmp    342f <UpdSnode+0x232f>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @UpdSnode(i32 %0, i32 %1, i32 %2, double* %3, double* %4, i32* %5, double* %6, double* %7, i32* %8) {
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32*
%16 = alloca double*
%17 = alloca double*
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%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*
store i32 %0, i32* %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store double* %3, double** %13
store double* %4, double** %14
store i32* %5, i32** %15
store double* %6, double** %16
store double* %7, double** %17
store i32* %8, i32** %18
store i32 0, i32* %19
br label %58
58: ; preds = %678, %9
%59 = load i32, i32* %19
%60 = add nsw i32 %59, 1
%61 = load i32, i32* %12
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %681
63: ; preds = %58
%64 = load double*, double** %17
%65 = load i32*, i32** %18
%66 = load i32, i32* %19
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
%69 = load i32, i32* %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %64, i64 %70
store double* %71, double** %55
%72 = load double*, double** %55
%73 = getelementptr inbounds double, double* %72, i64 1
store double* %73, double** %57
%74 = load double*, double** %17
%75 = load i32*, i32** %18
%76 = load i32, i32* %19
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i32, i32* %75, i64 %78
%80 = load i32, i32* %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %74, i64 %81
store double* %82, double** %56
%83 = load i32, i32* %10
%84 = load i32, i32* %19
%85 = sub nsw i32 %83, %84
%86 = sub nsw i32 %85, 2
store i32 %86, i32* %22
store i32 0, i32* %20
br label %87
87: ; preds = %387, %63
%88 = load i32, i32* %20
%89 = add nsw i32 %88, 3
%90 = load i32, i32* %11
%91 = icmp slt i32 %89, %90
br i1 %91, label %92, label %390
92: ; preds = %87
%93 = load double*, double** %14
%94 = load i32*, i32** %15
%95 = load i32, i32* %20
%96 = add nsw i32 %95, 0
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %94, i64 %97
%99 = load i32, i32* %98
%100 = load i32, i32* %19
%101 = add nsw i32 %99, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %93, i64 %102
store double* %103, double** %39
%104 = load double*, double** %14
%105 = load i32*, i32** %15
%106 = load i32, i32* %20
%107 = add nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %105, i64 %108
%110 = load i32, i32* %109
%111 = load i32, i32* %19
%112 = add nsw i32 %110, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %104, i64 %113
store double* %114, double** %40
%115 = load double*, double** %14
%116 = load i32*, i32** %15
%117 = load i32, i32* %20
%118 = add nsw i32 %117, 2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %116, i64 %119
%121 = load i32, i32* %120
%122 = load i32, i32* %19
%123 = add nsw i32 %121, %122
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double, double* %115, i64 %124
store double* %125, double** %41
%126 = load double*, double** %14
%127 = load i32*, i32** %15
%128 = load i32, i32* %20
%129 = add nsw i32 %128, 3
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i32, i32* %127, i64 %130
%132 = load i32, i32* %131
%133 = load i32, i32* %19
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %126, i64 %135
store double* %136, double** %42
%137 = load double*, double** %39
%138 = getelementptr inbounds double, double* %137, i64 0
%139 = load double, double* %138
%140 = load double*, double** %13
%141 = load i32, i32* %20
%142 = add nsw i32 %141, 0
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %140, i64 %143
%145 = load double, double* %144
%146 = fdiv double %139, %145
store double %146, double* %23
%147 = load double*, double** %40
%148 = getelementptr inbounds double, double* %147, i64 0
%149 = load double, double* %148
%150 = load double*, double** %13
%151 = load i32, i32* %20
%152 = add nsw i32 %151, 1
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %150, i64 %153
%155 = load double, double* %154
%156 = fdiv double %149, %155
store double %156, double* %24
%157 = load double*, double** %41
%158 = getelementptr inbounds double, double* %157, i64 0
%159 = load double, double* %158
%160 = load double*, double** %13
%161 = load i32, i32* %20
%162 = add nsw i32 %161, 2
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double, double* %160, i64 %163
%165 = load double, double* %164
%166 = fdiv double %159, %165
store double %166, double* %25
%167 = load double*, double** %42
%168 = getelementptr inbounds double, double* %167, i64 0
%169 = load double, double* %168
%170 = load double*, double** %13
%171 = load i32, i32* %20
%172 = add nsw i32 %171, 3
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %170, i64 %173
%175 = load double, double* %174
%176 = fdiv double %169, %175
store double %176, double* %26
%177 = load double, double* %23
%178 = load double*, double** %39
%179 = getelementptr inbounds double, double* %178, i64 0
%180 = load double, double* %179
%181 = load double, double* %24
%182 = load double*, double** %40
%183 = getelementptr inbounds double, double* %182, i64 0
%184 = load double, double* %183
%185 = fmul double %181, %184
%186 = call double @llvm.fmuladd.f64(double %177, double %180, double %185)
%187 = load double, double* %25
%188 = load double*, double** %41
%189 = getelementptr inbounds double, double* %188, i64 0
%190 = load double, double* %189
%191 = call double @llvm.fmuladd.f64(double %187, double %190, double %186)
%192 = load double, double* %26
%193 = load double*, double** %42
%194 = getelementptr inbounds double, double* %193, i64 0
%195 = load double, double* %194
%196 = call double @llvm.fmuladd.f64(double %192, double %195, double %191)
%197 = load double*, double** %16
%198 = load i32, i32* %19
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %197, i64 %199
%201 = load double, double* %200
%202 = fsub double %201, %196
store double %202, double* %200
%203 = load double*, double** %39
%204 = getelementptr inbounds double, double* %203, i32 1
store double* %204, double** %39
%205 = load double*, double** %40
%206 = getelementptr inbounds double, double* %205, i32 1
store double* %206, double** %40
%207 = load double*, double** %41
%208 = getelementptr inbounds double, double* %207, i32 1
store double* %208, double** %41
%209 = load double*, double** %42
%210 = getelementptr inbounds double, double* %209, i32 1
store double* %210, double** %42
%211 = load double*, double** %39
%212 = getelementptr inbounds double, double* %211, i64 0
%213 = load double, double* %212
%214 = load double*, double** %13
%215 = load i32, i32* %20
%216 = add nsw i32 %215, 0
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %214, i64 %217
%219 = load double, double* %218
%220 = fdiv double %213, %219
store double %220, double* %27
%221 = load double*, double** %40
%222 = getelementptr inbounds double, double* %221, i64 0
%223 = load double, double* %222
%224 = load double*, double** %13
%225 = load i32, i32* %20
%226 = add nsw i32 %225, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %224, i64 %227
%229 = load double, double* %228
%230 = fdiv double %223, %229
store double %230, double* %28
%231 = load double*, double** %41
%232 = getelementptr inbounds double, double* %231, i64 0
%233 = load double, double* %232
%234 = load double*, double** %13
%235 = load i32, i32* %20
%236 = add nsw i32 %235, 2
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds double, double* %234, i64 %237
%239 = load double, double* %238
%240 = fdiv double %233, %239
store double %240, double* %29
%241 = load double*, double** %42
%242 = getelementptr inbounds double, double* %241, i64 0
%243 = load double, double* %242
%244 = load double*, double** %13
%245 = load i32, i32* %20
%246 = add nsw i32 %245, 3
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %244, i64 %247
%249 = load double, double* %248
%250 = fdiv double %243, %249
store double %250, double* %30
%251 = load double, double* %23
%252 = load double*, double** %39
%253 = getelementptr inbounds double, double* %252, i64 0
%254 = load double, double* %253
%255 = load double, double* %24
%256 = load double*, double** %40
%257 = getelementptr inbounds double, double* %256, i64 0
%258 = load double, double* %257
%259 = fmul double %255, %258
%260 = call double @llvm.fmuladd.f64(double %251, double %254, double %259)
%261 = load double, double* %25
%262 = load double*, double** %41
%263 = getelementptr inbounds double, double* %262, i64 0
%264 = load double, double* %263
%265 = call double @llvm.fmuladd.f64(double %261, double %264, double %260)
%266 = load double, double* %26
%267 = load double*, double** %42
%268 = getelementptr inbounds double, double* %267, i64 0
%269 = load double, double* %268
%270 = call double @llvm.fmuladd.f64(double %266, double %269, double %265)
%271 = load double*, double** %55
%272 = getelementptr inbounds double, double* %271, i64 0
%273 = load double, double* %272
%274 = fsub double %273, %270
store double %274, double* %272
%275 = load double, double* %27
%276 = load double*, double** %39
%277 = getelementptr inbounds double, double* %276, i64 0
%278 = load double, double* %277
%279 = load double, double* %28
%280 = load double*, double** %40
%281 = getelementptr inbounds double, double* %280, i64 0
%282 = load double, double* %281
%283 = fmul double %279, %282
%284 = call double @llvm.fmuladd.f64(double %275, double %278, double %283)
%285 = load double, double* %29
%286 = load double*, double** %41
%287 = getelementptr inbounds double, double* %286, i64 0
%288 = load double, double* %287
%289 = call double @llvm.fmuladd.f64(double %285, double %288, double %284)
%290 = load double, double* %30
%291 = load double*, double** %42
%292 = getelementptr inbounds double, double* %291, i64 0
%293 = load double, double* %292
%294 = call double @llvm.fmuladd.f64(double %290, double %293, double %289)
%295 = load double*, double** %16
%296 = load i32, i32* %19
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double, double* %295, i64 %298
%300 = load double, double* %299
%301 = fsub double %300, %294
store double %301, double* %299
%302 = load double*, double** %39
%303 = getelementptr inbounds double, double* %302, i32 1
store double* %303, double** %39
%304 = load double*, double** %40
%305 = getelementptr inbounds double, double* %304, i32 1
store double* %305, double** %40
%306 = load double*, double** %41
%307 = getelementptr inbounds double, double* %306, i32 1
store double* %307, double** %41
%308 = load double*, double** %42
%309 = getelementptr inbounds double, double* %308, i32 1
store double* %309, double** %42
store i32 0, i32* %21
br label %310
310: ; preds = %383, %92
%311 = load i32, i32* %21
%312 = load i32, i32* %22
%313 = icmp slt i32 %311, %312
br i1 %313, label %314, label %386
314: ; preds = %310
%315 = load double, double* %23
%316 = load double*, double** %39
%317 = load i32, i32* %21
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = load double, double* %24
%322 = load double*, double** %40
%323 = load i32, i32* %21
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds double, double* %322, i64 %324
%326 = load double, double* %325
%327 = fmul double %321, %326
%328 = call double @llvm.fmuladd.f64(double %315, double %320, double %327)
%329 = load double, double* %25
%330 = load double*, double** %41
%331 = load i32, i32* %21
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double, double* %330, i64 %332
%334 = load double, double* %333
%335 = call double @llvm.fmuladd.f64(double %329, double %334, double %328)
%336 = load double, double* %26
%337 = load double*, double** %42
%338 = load i32, i32* %21
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds double, double* %337, i64 %339
%341 = load double, double* %340
%342 = call double @llvm.fmuladd.f64(double %336, double %341, double %335)
%343 = load double*, double** %57
%344 = load i32, i32* %21
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %343, i64 %345
%347 = load double, double* %346
%348 = fsub double %347, %342
store double %348, double* %346
%349 = load double, double* %27
%350 = load double*, double** %39
%351 = load i32, i32* %21
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %350, i64 %352
%354 = load double, double* %353
%355 = load double, double* %28
%356 = load double*, double** %40
%357 = load i32, i32* %21
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load double, double* %359
%361 = fmul double %355, %360
%362 = call double @llvm.fmuladd.f64(double %349, double %354, double %361)
%363 = load double, double* %29
%364 = load double*, double** %41
%365 = load i32, i32* %21
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %364, i64 %366
%368 = load double, double* %367
%369 = call double @llvm.fmuladd.f64(double %363, double %368, double %362)
%370 = load double, double* %30
%371 = load double*, double** %42
%372 = load i32, i32* %21
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
%376 = call double @llvm.fmuladd.f64(double %370, double %375, double %369)
%377 = load double*, double** %56
%378 = load i32, i32* %21
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = fsub double %381, %376
store double %382, double* %380
br label %383
383: ; preds = %314
%384 = load i32, i32* %21
%385 = add nsw i32 %384, 1
store i32 %385, i32* %21
br label %310
386: ; preds = %310
br label %387
387: ; preds = %386
%388 = load i32, i32* %20
%389 = add nsw i32 %388, 4
store i32 %389, i32* %20
br label %87
390: ; preds = %87
br label %391
391: ; preds = %563, %390
%392 = load i32, i32* %20
%393 = add nsw i32 %392, 1
%394 = load i32, i32* %11
%395 = icmp slt i32 %393, %394
br i1 %395, label %396, label %566
396: ; preds = %391
%397 = load double*, double** %14
%398 = load i32*, i32** %15
%399 = load i32, i32* %20
%400 = add nsw i32 %399, 0
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds i32, i32* %398, i64 %401
%403 = load i32, i32* %402
%404 = load i32, i32* %19
%405 = add nsw i32 %403, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %397, i64 %406
store double* %407, double** %39
%408 = load double*, double** %14
%409 = load i32*, i32** %15
%410 = load i32, i32* %20
%411 = add nsw i32 %410, 1
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i32, i32* %409, i64 %412
%414 = load i32, i32* %413
%415 = load i32, i32* %19
%416 = add nsw i32 %414, %415
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %408, i64 %417
store double* %418, double** %40
%419 = load double*, double** %39
%420 = getelementptr inbounds double, double* %419, i64 0
%421 = load double, double* %420
%422 = load double*, double** %13
%423 = load i32, i32* %20
%424 = add nsw i32 %423, 0
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds double, double* %422, i64 %425
%427 = load double, double* %426
%428 = fdiv double %421, %427
store double %428, double* %23
%429 = load double*, double** %40
%430 = getelementptr inbounds double, double* %429, i64 0
%431 = load double, double* %430
%432 = load double*, double** %13
%433 = load i32, i32* %20
%434 = add nsw i32 %433, 1
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %432, i64 %435
%437 = load double, double* %436
%438 = fdiv double %431, %437
store double %438, double* %24
%439 = load double*, double** %39
%440 = getelementptr inbounds double, double* %439, i64 0
%441 = load double, double* %440
%442 = load double, double* %23
%443 = load double*, double** %40
%444 = getelementptr inbounds double, double* %443, i64 0
%445 = load double, double* %444
%446 = load double, double* %24
%447 = fmul double %445, %446
%448 = call double @llvm.fmuladd.f64(double %441, double %442, double %447)
%449 = load double*, double** %16
%450 = load i32, i32* %19
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %449, i64 %451
%453 = load double, double* %452
%454 = fsub double %453, %448
store double %454, double* %452
%455 = load double*, double** %39
%456 = getelementptr inbounds double, double* %455, i32 1
store double* %456, double** %39
%457 = load double*, double** %40
%458 = getelementptr inbounds double, double* %457, i32 1
store double* %458, double** %40
%459 = load double*, double** %39
%460 = getelementptr inbounds double, double* %459, i64 0
%461 = load double, double* %460
%462 = load double*, double** %13
%463 = load i32, i32* %20
%464 = add nsw i32 %463, 0
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %462, i64 %465
%467 = load double, double* %466
%468 = fdiv double %461, %467
store double %468, double* %27
%469 = load double*, double** %40
%470 = getelementptr inbounds double, double* %469, i64 0
%471 = load double, double* %470
%472 = load double*, double** %13
%473 = load i32, i32* %20
%474 = add nsw i32 %473, 1
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds double, double* %472, i64 %475
%477 = load double, double* %476
%478 = fdiv double %471, %477
store double %478, double* %28
%479 = load double*, double** %39
%480 = getelementptr inbounds double, double* %479, i64 0
%481 = load double, double* %480
%482 = load double, double* %23
%483 = load double*, double** %40
%484 = getelementptr inbounds double, double* %483, i64 0
%485 = load double, double* %484
%486 = load double, double* %24
%487 = fmul double %485, %486
%488 = call double @llvm.fmuladd.f64(double %481, double %482, double %487)
%489 = load double*, double** %55
%490 = getelementptr inbounds double, double* %489, i64 0
%491 = load double, double* %490
%492 = fsub double %491, %488
store double %492, double* %490
%493 = load double*, double** %39
%494 = getelementptr inbounds double, double* %493, i64 0
%495 = load double, double* %494
%496 = load double, double* %27
%497 = load double*, double** %40
%498 = getelementptr inbounds double, double* %497, i64 0
%499 = load double, double* %498
%500 = load double, double* %28
%501 = fmul double %499, %500
%502 = call double @llvm.fmuladd.f64(double %495, double %496, double %501)
%503 = load double*, double** %16
%504 = load i32, i32* %19
%505 = add nsw i32 %504, 1
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds double, double* %503, i64 %506
%508 = load double, double* %507
%509 = fsub double %508, %502
store double %509, double* %507
%510 = load double*, double** %39
%511 = getelementptr inbounds double, double* %510, i32 1
store double* %511, double** %39
%512 = load double*, double** %40
%513 = getelementptr inbounds double, double* %512, i32 1
store double* %513, double** %40
store i32 0, i32* %21
br label %514
514: ; preds = %559, %396
%515 = load i32, i32* %21
%516 = load i32, i32* %22
%517 = icmp slt i32 %515, %516
br i1 %517, label %518, label %562
518: ; preds = %514
%519 = load double*, double** %39
%520 = load i32, i32* %21
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double, double* %23
%525 = load double*, double** %40
%526 = load i32, i32* %21
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double, double* %525, i64 %527
%529 = load double, double* %528
%530 = load double, double* %24
%531 = fmul double %529, %530
%532 = call double @llvm.fmuladd.f64(double %523, double %524, double %531)
%533 = load double*, double** %57
%534 = load i32, i32* %21
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %533, i64 %535
%537 = load double, double* %536
%538 = fsub double %537, %532
store double %538, double* %536
%539 = load double*, double** %39
%540 = load i32, i32* %21
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %539, i64 %541
%543 = load double, double* %542
%544 = load double, double* %27
%545 = load double*, double** %40
%546 = load i32, i32* %21
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %545, i64 %547
%549 = load double, double* %548
%550 = load double, double* %28
%551 = fmul double %549, %550
%552 = call double @llvm.fmuladd.f64(double %543, double %544, double %551)
%553 = load double*, double** %56
%554 = load i32, i32* %21
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %553, i64 %555
%557 = load double, double* %556
%558 = fsub double %557, %552
store double %558, double* %556
br label %559
559: ; preds = %518
%560 = load i32, i32* %21
%561 = add nsw i32 %560, 1
store i32 %561, i32* %21
br label %514
562: ; preds = %514
br label %563
563: ; preds = %562
%564 = load i32, i32* %20
%565 = add nsw i32 %564, 2
store i32 %565, i32* %20
br label %391
566: ; preds = %391
br label %567
567: ; preds = %674, %566
%568 = load i32, i32* %20
%569 = load i32, i32* %11
%570 = icmp slt i32 %568, %569
br i1 %570, label %571, label %677
571: ; preds = %567
%572 = load double*, double** %14
%573 = load i32*, i32** %15
%574 = load i32, i32* %20
%575 = add nsw i32 %574, 0
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds i32, i32* %573, i64 %576
%578 = load i32, i32* %577
%579 = load i32, i32* %19
%580 = add nsw i32 %578, %579
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds double, double* %572, i64 %581
store double* %582, double** %39
%583 = load double*, double** %39
%584 = getelementptr inbounds double, double* %583, i64 0
%585 = load double, double* %584
%586 = load double*, double** %13
%587 = load i32, i32* %20
%588 = add nsw i32 %587, 0
%589 = sext i32 %588 to i64
%590 = getelementptr inbounds double, double* %586, i64 %589
%591 = load double, double* %590
%592 = fdiv double %585, %591
store double %592, double* %23
%593 = load double*, double** %39
%594 = getelementptr inbounds double, double* %593, i64 0
%595 = load double, double* %594
%596 = load double, double* %23
%597 = load double*, double** %16
%598 = load i32, i32* %19
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %597, i64 %599
%601 = load double, double* %600
%602 = fneg double %595
%603 = call double @llvm.fmuladd.f64(double %602, double %596, double %601)
store double %603, double* %600
%604 = load double*, double** %39
%605 = getelementptr inbounds double, double* %604, i32 1
store double* %605, double** %39
%606 = load double*, double** %39
%607 = getelementptr inbounds double, double* %606, i64 0
%608 = load double, double* %607
%609 = load double*, double** %13
%610 = load i32, i32* %20
%611 = add nsw i32 %610, 0
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %609, i64 %612
%614 = load double, double* %613
%615 = fdiv double %608, %614
store double %615, double* %27
%616 = load double*, double** %39
%617 = getelementptr inbounds double, double* %616, i64 0
%618 = load double, double* %617
%619 = load double, double* %27
%620 = load double*, double** %16
%621 = load i32, i32* %19
%622 = add nsw i32 %621, 1
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds double, double* %620, i64 %623
%625 = load double, double* %624
%626 = fneg double %618
%627 = call double @llvm.fmuladd.f64(double %626, double %619, double %625)
store double %627, double* %624
%628 = load double*, double** %39
%629 = getelementptr inbounds double, double* %628, i64 0
%630 = load double, double* %629
%631 = load double, double* %23
%632 = load double*, double** %55
%633 = getelementptr inbounds double, double* %632, i64 0
%634 = load double, double* %633
%635 = fneg double %630
%636 = call double @llvm.fmuladd.f64(double %635, double %631, double %634)
store double %636, double* %633
%637 = load double*, double** %39
%638 = getelementptr inbounds double, double* %637, i32 1
store double* %638, double** %39
store i32 0, i32* %21
br label %639
639: ; preds = %670, %571
%640 = load i32, i32* %21
%641 = load i32, i32* %22
%642 = icmp slt i32 %640, %641
br i1 %642, label %643, label %673
643: ; preds = %639
%644 = load double, double* %23
%645 = load double*, double** %39
%646 = load i32, i32* %21
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %645, i64 %647
%649 = load double, double* %648
%650 = load double*, double** %57
%651 = load i32, i32* %21
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %650, i64 %652
%654 = load double, double* %653
%655 = fneg double %644
%656 = call double @llvm.fmuladd.f64(double %655, double %649, double %654)
store double %656, double* %653
%657 = load double, double* %27
%658 = load double*, double** %39
%659 = load i32, i32* %21
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %658, i64 %660
%662 = load double, double* %661
%663 = load double*, double** %56
%664 = load i32, i32* %21
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
%667 = load double, double* %666
%668 = fneg double %657
%669 = call double @llvm.fmuladd.f64(double %668, double %662, double %667)
store double %669, double* %666
br label %670
670: ; preds = %643
%671 = load i32, i32* %21
%672 = add nsw i32 %671, 1
store i32 %672, i32* %21
br label %639
673: ; preds = %639
br label %674
674: ; preds = %673
%675 = load i32, i32* %20
%676 = add nsw i32 %675, 1
store i32 %676, i32* %20
br label %567
677: ; preds = %567
br label %678
678: ; preds = %677
%679 = load i32, i32* %19
%680 = add nsw i32 %679, 2
store i32 %680, i32* %19
br label %58
681: ; preds = %58
br label %682
682: ; preds = %2303, %681
%683 = load i32, i32* %19
%684 = load i32, i32* %12
%685 = icmp slt i32 %683, %684
br i1 %685, label %686, label %2306
686: ; preds = %682
%687 = load double*, double** %17
%688 = load i32*, i32** %18
%689 = load i32, i32* %19
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds i32, i32* %688, i64 %690
%692 = load i32, i32* %691
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds double, double* %687, i64 %693
store double* %694, double** %57
%695 = load i32, i32* %10
%696 = load i32, i32* %19
%697 = sub nsw i32 %695, %696
%698 = sub nsw i32 %697, 1
store i32 %698, i32* %22
store i32 0, i32* %20
br label %699
699: ; preds = %1254, %686
%700 = load i32, i32* %20
%701 = add nsw i32 %700, 15
%702 = load i32, i32* %11
%703 = icmp slt i32 %701, %702
br i1 %703, label %704, label %1257
704: ; preds = %699
%705 = load double*, double** %14
%706 = load i32*, i32** %15
%707 = load i32, i32* %20
%708 = add nsw i32 %707, 0
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds i32, i32* %706, i64 %709
%711 = load i32, i32* %710
%712 = load i32, i32* %19
%713 = add nsw i32 %711, %712
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds double, double* %705, i64 %714
store double* %715, double** %39
%716 = load double*, double** %14
%717 = load i32*, i32** %15
%718 = load i32, i32* %20
%719 = add nsw i32 %718, 1
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds i32, i32* %717, i64 %720
%722 = load i32, i32* %721
%723 = load i32, i32* %19
%724 = add nsw i32 %722, %723
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds double, double* %716, i64 %725
store double* %726, double** %40
%727 = load double*, double** %14
%728 = load i32*, i32** %15
%729 = load i32, i32* %20
%730 = add nsw i32 %729, 2
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds i32, i32* %728, i64 %731
%733 = load i32, i32* %732
%734 = load i32, i32* %19
%735 = add nsw i32 %733, %734
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds double, double* %727, i64 %736
store double* %737, double** %41
%738 = load double*, double** %14
%739 = load i32*, i32** %15
%740 = load i32, i32* %20
%741 = add nsw i32 %740, 3
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds i32, i32* %739, i64 %742
%744 = load i32, i32* %743
%745 = load i32, i32* %19
%746 = add nsw i32 %744, %745
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds double, double* %738, i64 %747
store double* %748, double** %42
%749 = load double*, double** %14
%750 = load i32*, i32** %15
%751 = load i32, i32* %20
%752 = add nsw i32 %751, 4
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds i32, i32* %750, i64 %753
%755 = load i32, i32* %754
%756 = load i32, i32* %19
%757 = add nsw i32 %755, %756
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds double, double* %749, i64 %758
store double* %759, double** %43
%760 = load double*, double** %14
%761 = load i32*, i32** %15
%762 = load i32, i32* %20
%763 = add nsw i32 %762, 5
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds i32, i32* %761, i64 %764
%766 = load i32, i32* %765
%767 = load i32, i32* %19
%768 = add nsw i32 %766, %767
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds double, double* %760, i64 %769
store double* %770, double** %44
%771 = load double*, double** %14
%772 = load i32*, i32** %15
%773 = load i32, i32* %20
%774 = add nsw i32 %773, 6
%775 = sext i32 %774 to i64
%776 = getelementptr inbounds i32, i32* %772, i64 %775
%777 = load i32, i32* %776
%778 = load i32, i32* %19
%779 = add nsw i32 %777, %778
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds double, double* %771, i64 %780
store double* %781, double** %45
%782 = load double*, double** %14
%783 = load i32*, i32** %15
%784 = load i32, i32* %20
%785 = add nsw i32 %784, 7
%786 = sext i32 %785 to i64
%787 = getelementptr inbounds i32, i32* %783, i64 %786
%788 = load i32, i32* %787
%789 = load i32, i32* %19
%790 = add nsw i32 %788, %789
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds double, double* %782, i64 %791
store double* %792, double** %46
%793 = load double*, double** %14
%794 = load i32*, i32** %15
%795 = load i32, i32* %20
%796 = add nsw i32 %795, 8
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds i32, i32* %794, i64 %797
%799 = load i32, i32* %798
%800 = load i32, i32* %19
%801 = add nsw i32 %799, %800
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds double, double* %793, i64 %802
store double* %803, double** %47
%804 = load double*, double** %14
%805 = load i32*, i32** %15
%806 = load i32, i32* %20
%807 = add nsw i32 %806, 9
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds i32, i32* %805, i64 %808
%810 = load i32, i32* %809
%811 = load i32, i32* %19
%812 = add nsw i32 %810, %811
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds double, double* %804, i64 %813
store double* %814, double** %48
%815 = load double*, double** %14
%816 = load i32*, i32** %15
%817 = load i32, i32* %20
%818 = add nsw i32 %817, 10
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds i32, i32* %816, i64 %819
%821 = load i32, i32* %820
%822 = load i32, i32* %19
%823 = add nsw i32 %821, %822
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds double, double* %815, i64 %824
store double* %825, double** %49
%826 = load double*, double** %14
%827 = load i32*, i32** %15
%828 = load i32, i32* %20
%829 = add nsw i32 %828, 11
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds i32, i32* %827, i64 %830
%832 = load i32, i32* %831
%833 = load i32, i32* %19
%834 = add nsw i32 %832, %833
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds double, double* %826, i64 %835
store double* %836, double** %50
%837 = load double*, double** %14
%838 = load i32*, i32** %15
%839 = load i32, i32* %20
%840 = add nsw i32 %839, 12
%841 = sext i32 %840 to i64
%842 = getelementptr inbounds i32, i32* %838, i64 %841
%843 = load i32, i32* %842
%844 = load i32, i32* %19
%845 = add nsw i32 %843, %844
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %837, i64 %846
store double* %847, double** %51
%848 = load double*, double** %14
%849 = load i32*, i32** %15
%850 = load i32, i32* %20
%851 = add nsw i32 %850, 13
%852 = sext i32 %851 to i64
%853 = getelementptr inbounds i32, i32* %849, i64 %852
%854 = load i32, i32* %853
%855 = load i32, i32* %19
%856 = add nsw i32 %854, %855
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds double, double* %848, i64 %857
store double* %858, double** %52
%859 = load double*, double** %14
%860 = load i32*, i32** %15
%861 = load i32, i32* %20
%862 = add nsw i32 %861, 14
%863 = sext i32 %862 to i64
%864 = getelementptr inbounds i32, i32* %860, i64 %863
%865 = load i32, i32* %864
%866 = load i32, i32* %19
%867 = add nsw i32 %865, %866
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %859, i64 %868
store double* %869, double** %53
%870 = load double*, double** %14
%871 = load i32*, i32** %15
%872 = load i32, i32* %20
%873 = add nsw i32 %872, 15
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds i32, i32* %871, i64 %874
%876 = load i32, i32* %875
%877 = load i32, i32* %19
%878 = add nsw i32 %876, %877
%879 = sext i32 %878 to i64
%880 = getelementptr inbounds double, double* %870, i64 %879
store double* %880, double** %54
%881 = load double*, double** %39
%882 = load double, double* %881
%883 = load double*, double** %13
%884 = load i32, i32* %20
%885 = add nsw i32 %884, 0
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %883, i64 %886
%888 = load double, double* %887
%889 = fdiv double %882, %888
store double %889, double* %23
%890 = load double*, double** %40
%891 = load double, double* %890
%892 = load double*, double** %13
%893 = load i32, i32* %20
%894 = add nsw i32 %893, 1
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds double, double* %892, i64 %895
%897 = load double, double* %896
%898 = fdiv double %891, %897
store double %898, double* %24
%899 = load double*, double** %41
%900 = load double, double* %899
%901 = load double*, double** %13
%902 = load i32, i32* %20
%903 = add nsw i32 %902, 2
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds double, double* %901, i64 %904
%906 = load double, double* %905
%907 = fdiv double %900, %906
store double %907, double* %25
%908 = load double*, double** %42
%909 = load double, double* %908
%910 = load double*, double** %13
%911 = load i32, i32* %20
%912 = add nsw i32 %911, 3
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds double, double* %910, i64 %913
%915 = load double, double* %914
%916 = fdiv double %909, %915
store double %916, double* %26
%917 = load double*, double** %43
%918 = load double, double* %917
%919 = load double*, double** %13
%920 = load i32, i32* %20
%921 = add nsw i32 %920, 4
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds double, double* %919, i64 %922
%924 = load double, double* %923
%925 = fdiv double %918, %924
store double %925, double* %27
%926 = load double*, double** %44
%927 = load double, double* %926
%928 = load double*, double** %13
%929 = load i32, i32* %20
%930 = add nsw i32 %929, 5
%931 = sext i32 %930 to i64
%932 = getelementptr inbounds double, double* %928, i64 %931
%933 = load double, double* %932
%934 = fdiv double %927, %933
store double %934, double* %28
%935 = load double*, double** %45
%936 = load double, double* %935
%937 = load double*, double** %13
%938 = load i32, i32* %20
%939 = add nsw i32 %938, 6
%940 = sext i32 %939 to i64
%941 = getelementptr inbounds double, double* %937, i64 %940
%942 = load double, double* %941
%943 = fdiv double %936, %942
store double %943, double* %29
%944 = load double*, double** %46
%945 = load double, double* %944
%946 = load double*, double** %13
%947 = load i32, i32* %20
%948 = add nsw i32 %947, 7
%949 = sext i32 %948 to i64
%950 = getelementptr inbounds double, double* %946, i64 %949
%951 = load double, double* %950
%952 = fdiv double %945, %951
store double %952, double* %30
%953 = load double*, double** %47
%954 = load double, double* %953
%955 = load double*, double** %13
%956 = load i32, i32* %20
%957 = add nsw i32 %956, 8
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds double, double* %955, i64 %958
%960 = load double, double* %959
%961 = fdiv double %954, %960
store double %961, double* %31
%962 = load double*, double** %48
%963 = load double, double* %962
%964 = load double*, double** %13
%965 = load i32, i32* %20
%966 = add nsw i32 %965, 9
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds double, double* %964, i64 %967
%969 = load double, double* %968
%970 = fdiv double %963, %969
store double %970, double* %32
%971 = load double*, double** %49
%972 = load double, double* %971
%973 = load double*, double** %13
%974 = load i32, i32* %20
%975 = add nsw i32 %974, 10
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds double, double* %973, i64 %976
%978 = load double, double* %977
%979 = fdiv double %972, %978
store double %979, double* %33
%980 = load double*, double** %50
%981 = load double, double* %980
%982 = load double*, double** %13
%983 = load i32, i32* %20
%984 = add nsw i32 %983, 11
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds double, double* %982, i64 %985
%987 = load double, double* %986
%988 = fdiv double %981, %987
store double %988, double* %34
%989 = load double*, double** %51
%990 = load double, double* %989
%991 = load double*, double** %13
%992 = load i32, i32* %20
%993 = add nsw i32 %992, 12
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %991, i64 %994
%996 = load double, double* %995
%997 = fdiv double %990, %996
store double %997, double* %35
%998 = load double*, double** %52
%999 = load double, double* %998
%1000 = load double*, double** %13
%1001 = load i32, i32* %20
%1002 = add nsw i32 %1001, 13
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds double, double* %1000, i64 %1003
%1005 = load double, double* %1004
%1006 = fdiv double %999, %1005
store double %1006, double* %36
%1007 = load double*, double** %53
%1008 = load double, double* %1007
%1009 = load double*, double** %13
%1010 = load i32, i32* %20
%1011 = add nsw i32 %1010, 14
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds double, double* %1009, i64 %1012
%1014 = load double, double* %1013
%1015 = fdiv double %1008, %1014
store double %1015, double* %37
%1016 = load double*, double** %54
%1017 = load double, double* %1016
%1018 = load double*, double** %13
%1019 = load i32, i32* %20
%1020 = add nsw i32 %1019, 15
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds double, double* %1018, i64 %1021
%1023 = load double, double* %1022
%1024 = fdiv double %1017, %1023
store double %1024, double* %38
%1025 = load double, double* %23
%1026 = load double*, double** %39
%1027 = load double, double* %1026
%1028 = load double, double* %24
%1029 = load double*, double** %40
%1030 = load double, double* %1029
%1031 = fmul double %1028, %1030
%1032 = call double @llvm.fmuladd.f64(double %1025, double %1027, double %1031)
%1033 = load double, double* %25
%1034 = load double*, double** %41
%1035 = load double, double* %1034
%1036 = call double @llvm.fmuladd.f64(double %1033, double %1035, double %1032)
%1037 = load double, double* %26
%1038 = load double*, double** %42
%1039 = load double, double* %1038
%1040 = call double @llvm.fmuladd.f64(double %1037, double %1039, double %1036)
%1041 = load double, double* %27
%1042 = load double*, double** %43
%1043 = load double, double* %1042
%1044 = call double @llvm.fmuladd.f64(double %1041, double %1043, double %1040)
%1045 = load double, double* %28
%1046 = load double*, double** %44
%1047 = load double, double* %1046
%1048 = call double @llvm.fmuladd.f64(double %1045, double %1047, double %1044)
%1049 = load double, double* %29
%1050 = load double*, double** %45
%1051 = load double, double* %1050
%1052 = call double @llvm.fmuladd.f64(double %1049, double %1051, double %1048)
%1053 = load double, double* %30
%1054 = load double*, double** %46
%1055 = load double, double* %1054
%1056 = call double @llvm.fmuladd.f64(double %1053, double %1055, double %1052)
%1057 = load double, double* %31
%1058 = load double*, double** %47
%1059 = load double, double* %1058
%1060 = call double @llvm.fmuladd.f64(double %1057, double %1059, double %1056)
%1061 = load double, double* %32
%1062 = load double*, double** %48
%1063 = load double, double* %1062
%1064 = call double @llvm.fmuladd.f64(double %1061, double %1063, double %1060)
%1065 = load double, double* %33
%1066 = load double*, double** %49
%1067 = load double, double* %1066
%1068 = call double @llvm.fmuladd.f64(double %1065, double %1067, double %1064)
%1069 = load double, double* %34
%1070 = load double*, double** %50
%1071 = load double, double* %1070
%1072 = call double @llvm.fmuladd.f64(double %1069, double %1071, double %1068)
%1073 = load double, double* %35
%1074 = load double*, double** %51
%1075 = load double, double* %1074
%1076 = call double @llvm.fmuladd.f64(double %1073, double %1075, double %1072)
%1077 = load double, double* %36
%1078 = load double*, double** %52
%1079 = load double, double* %1078
%1080 = call double @llvm.fmuladd.f64(double %1077, double %1079, double %1076)
%1081 = load double, double* %37
%1082 = load double*, double** %53
%1083 = load double, double* %1082
%1084 = call double @llvm.fmuladd.f64(double %1081, double %1083, double %1080)
%1085 = load double, double* %38
%1086 = load double*, double** %54
%1087 = load double, double* %1086
%1088 = call double @llvm.fmuladd.f64(double %1085, double %1087, double %1084)
%1089 = load double*, double** %16
%1090 = load i32, i32* %19
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds double, double* %1089, i64 %1091
%1093 = load double, double* %1092
%1094 = fsub double %1093, %1088
store double %1094, double* %1092
%1095 = load double*, double** %39
%1096 = getelementptr inbounds double, double* %1095, i32 1
store double* %1096, double** %39
%1097 = load double*, double** %40
%1098 = getelementptr inbounds double, double* %1097, i32 1
store double* %1098, double** %40
%1099 = load double*, double** %41
%1100 = getelementptr inbounds double, double* %1099, i32 1
store double* %1100, double** %41
%1101 = load double*, double** %42
%1102 = getelementptr inbounds double, double* %1101, i32 1
store double* %1102, double** %42
%1103 = load double*, double** %43
%1104 = getelementptr inbounds double, double* %1103, i32 1
store double* %1104, double** %43
%1105 = load double*, double** %44
%1106 = getelementptr inbounds double, double* %1105, i32 1
store double* %1106, double** %44
%1107 = load double*, double** %45
%1108 = getelementptr inbounds double, double* %1107, i32 1
store double* %1108, double** %45
%1109 = load double*, double** %46
%1110 = getelementptr inbounds double, double* %1109, i32 1
store double* %1110, double** %46
%1111 = load double*, double** %47
%1112 = getelementptr inbounds double, double* %1111, i32 1
store double* %1112, double** %47
%1113 = load double*, double** %48
%1114 = getelementptr inbounds double, double* %1113, i32 1
store double* %1114, double** %48
%1115 = load double*, double** %49
%1116 = getelementptr inbounds double, double* %1115, i32 1
store double* %1116, double** %49
%1117 = load double*, double** %50
%1118 = getelementptr inbounds double, double* %1117, i32 1
store double* %1118, double** %50
%1119 = load double*, double** %51
%1120 = getelementptr inbounds double, double* %1119, i32 1
store double* %1120, double** %51
%1121 = load double*, double** %52
%1122 = getelementptr inbounds double, double* %1121, i32 1
store double* %1122, double** %52
%1123 = load double*, double** %53
%1124 = getelementptr inbounds double, double* %1123, i32 1
store double* %1124, double** %53
%1125 = load double*, double** %54
%1126 = getelementptr inbounds double, double* %1125, i32 1
store double* %1126, double** %54
store i32 0, i32* %21
br label %1127
1127: ; preds = %1250, %704
%1128 = load i32, i32* %21
%1129 = load i32, i32* %22
%1130 = icmp slt i32 %1128, %1129
br i1 %1130, label %1131, label %1253
1131: ; preds = %1127
%1132 = load double, double* %23
%1133 = load double*, double** %39
%1134 = load i32, i32* %21
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds double, double* %1133, i64 %1135
%1137 = load double, double* %1136
%1138 = load double, double* %24
%1139 = load double*, double** %40
%1140 = load i32, i32* %21
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds double, double* %1139, i64 %1141
%1143 = load double, double* %1142
%1144 = fmul double %1138, %1143
%1145 = call double @llvm.fmuladd.f64(double %1132, double %1137, double %1144)
%1146 = load double, double* %25
%1147 = load double*, double** %41
%1148 = load i32, i32* %21
%1149 = sext i32 %1148 to i64
%1150 = getelementptr inbounds double, double* %1147, i64 %1149
%1151 = load double, double* %1150
%1152 = call double @llvm.fmuladd.f64(double %1146, double %1151, double %1145)
%1153 = load double, double* %26
%1154 = load double*, double** %42
%1155 = load i32, i32* %21
%1156 = sext i32 %1155 to i64
%1157 = getelementptr inbounds double, double* %1154, i64 %1156
%1158 = load double, double* %1157
%1159 = call double @llvm.fmuladd.f64(double %1153, double %1158, double %1152)
%1160 = load double, double* %27
%1161 = load double*, double** %43
%1162 = load i32, i32* %21
%1163 = sext i32 %1162 to i64
%1164 = getelementptr inbounds double, double* %1161, i64 %1163
%1165 = load double, double* %1164
%1166 = call double @llvm.fmuladd.f64(double %1160, double %1165, double %1159)
%1167 = load double, double* %28
%1168 = load double*, double** %44
%1169 = load i32, i32* %21
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds double, double* %1168, i64 %1170
%1172 = load double, double* %1171
%1173 = call double @llvm.fmuladd.f64(double %1167, double %1172, double %1166)
%1174 = load double, double* %29
%1175 = load double*, double** %45
%1176 = load i32, i32* %21
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds double, double* %1175, i64 %1177
%1179 = load double, double* %1178
%1180 = call double @llvm.fmuladd.f64(double %1174, double %1179, double %1173)
%1181 = load double, double* %30
%1182 = load double*, double** %46
%1183 = load i32, i32* %21
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds double, double* %1182, i64 %1184
%1186 = load double, double* %1185
%1187 = call double @llvm.fmuladd.f64(double %1181, double %1186, double %1180)
%1188 = load double, double* %31
%1189 = load double*, double** %47
%1190 = load i32, i32* %21
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds double, double* %1189, i64 %1191
%1193 = load double, double* %1192
%1194 = call double @llvm.fmuladd.f64(double %1188, double %1193, double %1187)
%1195 = load double, double* %32
%1196 = load double*, double** %48
%1197 = load i32, i32* %21
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds double, double* %1196, i64 %1198
%1200 = load double, double* %1199
%1201 = call double @llvm.fmuladd.f64(double %1195, double %1200, double %1194)
%1202 = load double, double* %33
%1203 = load double*, double** %49
%1204 = load i32, i32* %21
%1205 = sext i32 %1204 to i64
%1206 = getelementptr inbounds double, double* %1203, i64 %1205
%1207 = load double, double* %1206
%1208 = call double @llvm.fmuladd.f64(double %1202, double %1207, double %1201)
%1209 = load double, double* %34
%1210 = load double*, double** %50
%1211 = load i32, i32* %21
%1212 = sext i32 %1211 to i64
%1213 = getelementptr inbounds double, double* %1210, i64 %1212
%1214 = load double, double* %1213
%1215 = call double @llvm.fmuladd.f64(double %1209, double %1214, double %1208)
%1216 = load double, double* %35
%1217 = load double*, double** %51
%1218 = load i32, i32* %21
%1219 = sext i32 %1218 to i64
%1220 = getelementptr inbounds double, double* %1217, i64 %1219
%1221 = load double, double* %1220
%1222 = call double @llvm.fmuladd.f64(double %1216, double %1221, double %1215)
%1223 = load double, double* %36
%1224 = load double*, double** %52
%1225 = load i32, i32* %21
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds double, double* %1224, i64 %1226
%1228 = load double, double* %1227
%1229 = call double @llvm.fmuladd.f64(double %1223, double %1228, double %1222)
%1230 = load double, double* %37
%1231 = load double*, double** %53
%1232 = load i32, i32* %21
%1233 = sext i32 %1232 to i64
%1234 = getelementptr inbounds double, double* %1231, i64 %1233
%1235 = load double, double* %1234
%1236 = call double @llvm.fmuladd.f64(double %1230, double %1235, double %1229)
%1237 = load double, double* %38
%1238 = load double*, double** %54
%1239 = load i32, i32* %21
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds double, double* %1238, i64 %1240
%1242 = load double, double* %1241
%1243 = call double @llvm.fmuladd.f64(double %1237, double %1242, double %1236)
%1244 = load double*, double** %57
%1245 = load i32, i32* %21
%1246 = sext i32 %1245 to i64
%1247 = getelementptr inbounds double, double* %1244, i64 %1246
%1248 = load double, double* %1247
%1249 = fsub double %1248, %1243
store double %1249, double* %1247
br label %1250
1250: ; preds = %1131
%1251 = load i32, i32* %21
%1252 = add nsw i32 %1251, 1
store i32 %1252, i32* %21
br label %1127
1253: ; preds = %1127
br label %1254
1254: ; preds = %1253
%1255 = load i32, i32* %20
%1256 = add nsw i32 %1255, 16
store i32 %1256, i32* %20
br label %699
1257: ; preds = %699
br label %1258
1258: ; preds = %1681, %1257
%1259 = load i32, i32* %20
%1260 = add nsw i32 %1259, 11
%1261 = load i32, i32* %11
%1262 = icmp slt i32 %1260, %1261
br i1 %1262, label %1263, label %1684
1263: ; preds = %1258
%1264 = load double*, double** %14
%1265 = load i32*, i32** %15
%1266 = load i32, i32* %20
%1267 = add nsw i32 %1266, 0
%1268 = sext i32 %1267 to i64
%1269 = getelementptr inbounds i32, i32* %1265, i64 %1268
%1270 = load i32, i32* %1269
%1271 = load i32, i32* %19
%1272 = add nsw i32 %1270, %1271
%1273 = sext i32 %1272 to i64
%1274 = getelementptr inbounds double, double* %1264, i64 %1273
store double* %1274, double** %39
%1275 = load double*, double** %14
%1276 = load i32*, i32** %15
%1277 = load i32, i32* %20
%1278 = add nsw i32 %1277, 1
%1279 = sext i32 %1278 to i64
%1280 = getelementptr inbounds i32, i32* %1276, i64 %1279
%1281 = load i32, i32* %1280
%1282 = load i32, i32* %19
%1283 = add nsw i32 %1281, %1282
%1284 = sext i32 %1283 to i64
%1285 = getelementptr inbounds double, double* %1275, i64 %1284
store double* %1285, double** %40
%1286 = load double*, double** %14
%1287 = load i32*, i32** %15
%1288 = load i32, i32* %20
%1289 = add nsw i32 %1288, 2
%1290 = sext i32 %1289 to i64
%1291 = getelementptr inbounds i32, i32* %1287, i64 %1290
%1292 = load i32, i32* %1291
%1293 = load i32, i32* %19
%1294 = add nsw i32 %1292, %1293
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds double, double* %1286, i64 %1295
store double* %1296, double** %41
%1297 = load double*, double** %14
%1298 = load i32*, i32** %15
%1299 = load i32, i32* %20
%1300 = add nsw i32 %1299, 3
%1301 = sext i32 %1300 to i64
%1302 = getelementptr inbounds i32, i32* %1298, i64 %1301
%1303 = load i32, i32* %1302
%1304 = load i32, i32* %19
%1305 = add nsw i32 %1303, %1304
%1306 = sext i32 %1305 to i64
%1307 = getelementptr inbounds double, double* %1297, i64 %1306
store double* %1307, double** %42
%1308 = load double*, double** %14
%1309 = load i32*, i32** %15
%1310 = load i32, i32* %20
%1311 = add nsw i32 %1310, 4
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds i32, i32* %1309, i64 %1312
%1314 = load i32, i32* %1313
%1315 = load i32, i32* %19
%1316 = add nsw i32 %1314, %1315
%1317 = sext i32 %1316 to i64
%1318 = getelementptr inbounds double, double* %1308, i64 %1317
store double* %1318, double** %43
%1319 = load double*, double** %14
%1320 = load i32*, i32** %15
%1321 = load i32, i32* %20
%1322 = add nsw i32 %1321, 5
%1323 = sext i32 %1322 to i64
%1324 = getelementptr inbounds i32, i32* %1320, i64 %1323
%1325 = load i32, i32* %1324
%1326 = load i32, i32* %19
%1327 = add nsw i32 %1325, %1326
%1328 = sext i32 %1327 to i64
%1329 = getelementptr inbounds double, double* %1319, i64 %1328
store double* %1329, double** %44
%1330 = load double*, double** %14
%1331 = load i32*, i32** %15
%1332 = load i32, i32* %20
%1333 = add nsw i32 %1332, 6
%1334 = sext i32 %1333 to i64
%1335 = getelementptr inbounds i32, i32* %1331, i64 %1334
%1336 = load i32, i32* %1335
%1337 = load i32, i32* %19
%1338 = add nsw i32 %1336, %1337
%1339 = sext i32 %1338 to i64
%1340 = getelementptr inbounds double, double* %1330, i64 %1339
store double* %1340, double** %45
%1341 = load double*, double** %14
%1342 = load i32*, i32** %15
%1343 = load i32, i32* %20
%1344 = add nsw i32 %1343, 7
%1345 = sext i32 %1344 to i64
%1346 = getelementptr inbounds i32, i32* %1342, i64 %1345
%1347 = load i32, i32* %1346
%1348 = load i32, i32* %19
%1349 = add nsw i32 %1347, %1348
%1350 = sext i32 %1349 to i64
%1351 = getelementptr inbounds double, double* %1341, i64 %1350
store double* %1351, double** %46
%1352 = load double*, double** %14
%1353 = load i32*, i32** %15
%1354 = load i32, i32* %20
%1355 = add nsw i32 %1354, 8
%1356 = sext i32 %1355 to i64
%1357 = getelementptr inbounds i32, i32* %1353, i64 %1356
%1358 = load i32, i32* %1357
%1359 = load i32, i32* %19
%1360 = add nsw i32 %1358, %1359
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds double, double* %1352, i64 %1361
store double* %1362, double** %47
%1363 = load double*, double** %14
%1364 = load i32*, i32** %15
%1365 = load i32, i32* %20
%1366 = add nsw i32 %1365, 9
%1367 = sext i32 %1366 to i64
%1368 = getelementptr inbounds i32, i32* %1364, i64 %1367
%1369 = load i32, i32* %1368
%1370 = load i32, i32* %19
%1371 = add nsw i32 %1369, %1370
%1372 = sext i32 %1371 to i64
%1373 = getelementptr inbounds double, double* %1363, i64 %1372
store double* %1373, double** %48
%1374 = load double*, double** %14
%1375 = load i32*, i32** %15
%1376 = load i32, i32* %20
%1377 = add nsw i32 %1376, 10
%1378 = sext i32 %1377 to i64
%1379 = getelementptr inbounds i32, i32* %1375, i64 %1378
%1380 = load i32, i32* %1379
%1381 = load i32, i32* %19
%1382 = add nsw i32 %1380, %1381
%1383 = sext i32 %1382 to i64
%1384 = getelementptr inbounds double, double* %1374, i64 %1383
store double* %1384, double** %49
%1385 = load double*, double** %14
%1386 = load i32*, i32** %15
%1387 = load i32, i32* %20
%1388 = add nsw i32 %1387, 11
%1389 = sext i32 %1388 to i64
%1390 = getelementptr inbounds i32, i32* %1386, i64 %1389
%1391 = load i32, i32* %1390
%1392 = load i32, i32* %19
%1393 = add nsw i32 %1391, %1392
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds double, double* %1385, i64 %1394
store double* %1395, double** %50
%1396 = load double*, double** %39
%1397 = load double, double* %1396
%1398 = load double*, double** %13
%1399 = load i32, i32* %20
%1400 = add nsw i32 %1399, 0
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds double, double* %1398, i64 %1401
%1403 = load double, double* %1402
%1404 = fdiv double %1397, %1403
store double %1404, double* %23
%1405 = load double*, double** %40
%1406 = load double, double* %1405
%1407 = load double*, double** %13
%1408 = load i32, i32* %20
%1409 = add nsw i32 %1408, 1
%1410 = sext i32 %1409 to i64
%1411 = getelementptr inbounds double, double* %1407, i64 %1410
%1412 = load double, double* %1411
%1413 = fdiv double %1406, %1412
store double %1413, double* %24
%1414 = load double*, double** %41
%1415 = load double, double* %1414
%1416 = load double*, double** %13
%1417 = load i32, i32* %20
%1418 = add nsw i32 %1417, 2
%1419 = sext i32 %1418 to i64
%1420 = getelementptr inbounds double, double* %1416, i64 %1419
%1421 = load double, double* %1420
%1422 = fdiv double %1415, %1421
store double %1422, double* %25
%1423 = load double*, double** %42
%1424 = load double, double* %1423
%1425 = load double*, double** %13
%1426 = load i32, i32* %20
%1427 = add nsw i32 %1426, 3
%1428 = sext i32 %1427 to i64
%1429 = getelementptr inbounds double, double* %1425, i64 %1428
%1430 = load double, double* %1429
%1431 = fdiv double %1424, %1430
store double %1431, double* %26
%1432 = load double*, double** %43
%1433 = load double, double* %1432
%1434 = load double*, double** %13
%1435 = load i32, i32* %20
%1436 = add nsw i32 %1435, 4
%1437 = sext i32 %1436 to i64
%1438 = getelementptr inbounds double, double* %1434, i64 %1437
%1439 = load double, double* %1438
%1440 = fdiv double %1433, %1439
store double %1440, double* %27
%1441 = load double*, double** %44
%1442 = load double, double* %1441
%1443 = load double*, double** %13
%1444 = load i32, i32* %20
%1445 = add nsw i32 %1444, 5
%1446 = sext i32 %1445 to i64
%1447 = getelementptr inbounds double, double* %1443, i64 %1446
%1448 = load double, double* %1447
%1449 = fdiv double %1442, %1448
store double %1449, double* %28
%1450 = load double*, double** %45
%1451 = load double, double* %1450
%1452 = load double*, double** %13
%1453 = load i32, i32* %20
%1454 = add nsw i32 %1453, 6
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds double, double* %1452, i64 %1455
%1457 = load double, double* %1456
%1458 = fdiv double %1451, %1457
store double %1458, double* %29
%1459 = load double*, double** %46
%1460 = load double, double* %1459
%1461 = load double*, double** %13
%1462 = load i32, i32* %20
%1463 = add nsw i32 %1462, 7
%1464 = sext i32 %1463 to i64
%1465 = getelementptr inbounds double, double* %1461, i64 %1464
%1466 = load double, double* %1465
%1467 = fdiv double %1460, %1466
store double %1467, double* %30
%1468 = load double*, double** %47
%1469 = load double, double* %1468
%1470 = load double*, double** %13
%1471 = load i32, i32* %20
%1472 = add nsw i32 %1471, 8
%1473 = sext i32 %1472 to i64
%1474 = getelementptr inbounds double, double* %1470, i64 %1473
%1475 = load double, double* %1474
%1476 = fdiv double %1469, %1475
store double %1476, double* %31
%1477 = load double*, double** %48
%1478 = load double, double* %1477
%1479 = load double*, double** %13
%1480 = load i32, i32* %20
%1481 = add nsw i32 %1480, 9
%1482 = sext i32 %1481 to i64
%1483 = getelementptr inbounds double, double* %1479, i64 %1482
%1484 = load double, double* %1483
%1485 = fdiv double %1478, %1484
store double %1485, double* %32
%1486 = load double*, double** %49
%1487 = load double, double* %1486
%1488 = load double*, double** %13
%1489 = load i32, i32* %20
%1490 = add nsw i32 %1489, 10
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds double, double* %1488, i64 %1491
%1493 = load double, double* %1492
%1494 = fdiv double %1487, %1493
store double %1494, double* %33
%1495 = load double*, double** %50
%1496 = load double, double* %1495
%1497 = load double*, double** %13
%1498 = load i32, i32* %20
%1499 = add nsw i32 %1498, 11
%1500 = sext i32 %1499 to i64
%1501 = getelementptr inbounds double, double* %1497, i64 %1500
%1502 = load double, double* %1501
%1503 = fdiv double %1496, %1502
store double %1503, double* %34
%1504 = load double, double* %23
%1505 = load double*, double** %39
%1506 = load double, double* %1505
%1507 = load double, double* %24
%1508 = load double*, double** %40
%1509 = load double, double* %1508
%1510 = fmul double %1507, %1509
%1511 = call double @llvm.fmuladd.f64(double %1504, double %1506, double %1510)
%1512 = load double, double* %25
%1513 = load double*, double** %41
%1514 = load double, double* %1513
%1515 = call double @llvm.fmuladd.f64(double %1512, double %1514, double %1511)
%1516 = load double, double* %26
%1517 = load double*, double** %42
%1518 = load double, double* %1517
%1519 = call double @llvm.fmuladd.f64(double %1516, double %1518, double %1515)
%1520 = load double, double* %27
%1521 = load double*, double** %43
%1522 = load double, double* %1521
%1523 = call double @llvm.fmuladd.f64(double %1520, double %1522, double %1519)
%1524 = load double, double* %28
%1525 = load double*, double** %44
%1526 = load double, double* %1525
%1527 = call double @llvm.fmuladd.f64(double %1524, double %1526, double %1523)
%1528 = load double, double* %29
%1529 = load double*, double** %45
%1530 = load double, double* %1529
%1531 = call double @llvm.fmuladd.f64(double %1528, double %1530, double %1527)
%1532 = load double, double* %30
%1533 = load double*, double** %46
%1534 = load double, double* %1533
%1535 = call double @llvm.fmuladd.f64(double %1532, double %1534, double %1531)
%1536 = load double, double* %31
%1537 = load double*, double** %47
%1538 = load double, double* %1537
%1539 = call double @llvm.fmuladd.f64(double %1536, double %1538, double %1535)
%1540 = load double, double* %32
%1541 = load double*, double** %48
%1542 = load double, double* %1541
%1543 = call double @llvm.fmuladd.f64(double %1540, double %1542, double %1539)
%1544 = load double, double* %33
%1545 = load double*, double** %49
%1546 = load double, double* %1545
%1547 = call double @llvm.fmuladd.f64(double %1544, double %1546, double %1543)
%1548 = load double, double* %34
%1549 = load double*, double** %50
%1550 = load double, double* %1549
%1551 = call double @llvm.fmuladd.f64(double %1548, double %1550, double %1547)
%1552 = load double*, double** %16
%1553 = load i32, i32* %19
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds double, double* %1552, i64 %1554
%1556 = load double, double* %1555
%1557 = fsub double %1556, %1551
store double %1557, double* %1555
%1558 = load double*, double** %39
%1559 = getelementptr inbounds double, double* %1558, i32 1
store double* %1559, double** %39
%1560 = load double*, double** %40
%1561 = getelementptr inbounds double, double* %1560, i32 1
store double* %1561, double** %40
%1562 = load double*, double** %41
%1563 = getelementptr inbounds double, double* %1562, i32 1
store double* %1563, double** %41
%1564 = load double*, double** %42
%1565 = getelementptr inbounds double, double* %1564, i32 1
store double* %1565, double** %42
%1566 = load double*, double** %43
%1567 = getelementptr inbounds double, double* %1566, i32 1
store double* %1567, double** %43
%1568 = load double*, double** %44
%1569 = getelementptr inbounds double, double* %1568, i32 1
store double* %1569, double** %44
%1570 = load double*, double** %45
%1571 = getelementptr inbounds double, double* %1570, i32 1
store double* %1571, double** %45
%1572 = load double*, double** %46
%1573 = getelementptr inbounds double, double* %1572, i32 1
store double* %1573, double** %46
%1574 = load double*, double** %47
%1575 = getelementptr inbounds double, double* %1574, i32 1
store double* %1575, double** %47
%1576 = load double*, double** %48
%1577 = getelementptr inbounds double, double* %1576, i32 1
store double* %1577, double** %48
%1578 = load double*, double** %49
%1579 = getelementptr inbounds double, double* %1578, i32 1
store double* %1579, double** %49
%1580 = load double*, double** %50
%1581 = getelementptr inbounds double, double* %1580, i32 1
store double* %1581, double** %50
store i32 0, i32* %21
br label %1582
1582: ; preds = %1677, %1263
%1583 = load i32, i32* %21
%1584 = load i32, i32* %22
%1585 = icmp slt i32 %1583, %1584
br i1 %1585, label %1586, label %1680
1586: ; preds = %1582
%1587 = load double, double* %23
%1588 = load double*, double** %39
%1589 = load i32, i32* %21
%1590 = sext i32 %1589 to i64
%1591 = getelementptr inbounds double, double* %1588, i64 %1590
%1592 = load double, double* %1591
%1593 = load double, double* %24
%1594 = load double*, double** %40
%1595 = load i32, i32* %21
%1596 = sext i32 %1595 to i64
%1597 = getelementptr inbounds double, double* %1594, i64 %1596
%1598 = load double, double* %1597
%1599 = fmul double %1593, %1598
%1600 = call double @llvm.fmuladd.f64(double %1587, double %1592, double %1599)
%1601 = load double, double* %25
%1602 = load double*, double** %41
%1603 = load i32, i32* %21
%1604 = sext i32 %1603 to i64
%1605 = getelementptr inbounds double, double* %1602, i64 %1604
%1606 = load double, double* %1605
%1607 = call double @llvm.fmuladd.f64(double %1601, double %1606, double %1600)
%1608 = load double, double* %26
%1609 = load double*, double** %42
%1610 = load i32, i32* %21
%1611 = sext i32 %1610 to i64
%1612 = getelementptr inbounds double, double* %1609, i64 %1611
%1613 = load double, double* %1612
%1614 = call double @llvm.fmuladd.f64(double %1608, double %1613, double %1607)
%1615 = load double, double* %27
%1616 = load double*, double** %43
%1617 = load i32, i32* %21
%1618 = sext i32 %1617 to i64
%1619 = getelementptr inbounds double, double* %1616, i64 %1618
%1620 = load double, double* %1619
%1621 = call double @llvm.fmuladd.f64(double %1615, double %1620, double %1614)
%1622 = load double, double* %28
%1623 = load double*, double** %44
%1624 = load i32, i32* %21
%1625 = sext i32 %1624 to i64
%1626 = getelementptr inbounds double, double* %1623, i64 %1625
%1627 = load double, double* %1626
%1628 = call double @llvm.fmuladd.f64(double %1622, double %1627, double %1621)
%1629 = load double, double* %29
%1630 = load double*, double** %45
%1631 = load i32, i32* %21
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds double, double* %1630, i64 %1632
%1634 = load double, double* %1633
%1635 = call double @llvm.fmuladd.f64(double %1629, double %1634, double %1628)
%1636 = load double, double* %30
%1637 = load double*, double** %46
%1638 = load i32, i32* %21
%1639 = sext i32 %1638 to i64
%1640 = getelementptr inbounds double, double* %1637, i64 %1639
%1641 = load double, double* %1640
%1642 = call double @llvm.fmuladd.f64(double %1636, double %1641, double %1635)
%1643 = load double, double* %31
%1644 = load double*, double** %47
%1645 = load i32, i32* %21
%1646 = sext i32 %1645 to i64
%1647 = getelementptr inbounds double, double* %1644, i64 %1646
%1648 = load double, double* %1647
%1649 = call double @llvm.fmuladd.f64(double %1643, double %1648, double %1642)
%1650 = load double, double* %32
%1651 = load double*, double** %48
%1652 = load i32, i32* %21
%1653 = sext i32 %1652 to i64
%1654 = getelementptr inbounds double, double* %1651, i64 %1653
%1655 = load double, double* %1654
%1656 = call double @llvm.fmuladd.f64(double %1650, double %1655, double %1649)
%1657 = load double, double* %33
%1658 = load double*, double** %49
%1659 = load i32, i32* %21
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds double, double* %1658, i64 %1660
%1662 = load double, double* %1661
%1663 = call double @llvm.fmuladd.f64(double %1657, double %1662, double %1656)
%1664 = load double, double* %34
%1665 = load double*, double** %50
%1666 = load i32, i32* %21
%1667 = sext i32 %1666 to i64
%1668 = getelementptr inbounds double, double* %1665, i64 %1667
%1669 = load double, double* %1668
%1670 = call double @llvm.fmuladd.f64(double %1664, double %1669, double %1663)
%1671 = load double*, double** %57
%1672 = load i32, i32* %21
%1673 = sext i32 %1672 to i64
%1674 = getelementptr inbounds double, double* %1671, i64 %1673
%1675 = load double, double* %1674
%1676 = fsub double %1675, %1670
store double %1676, double* %1674
br label %1677
1677: ; preds = %1586
%1678 = load i32, i32* %21
%1679 = add nsw i32 %1678, 1
store i32 %1679, i32* %21
br label %1582
1680: ; preds = %1582
br label %1681
1681: ; preds = %1680
%1682 = load i32, i32* %20
%1683 = add nsw i32 %1682, 12
store i32 %1683, i32* %20
br label %1258
1684: ; preds = %1258
br label %1685
1685: ; preds = %1976, %1684
%1686 = load i32, i32* %20
%1687 = add nsw i32 %1686, 7
%1688 = load i32, i32* %11
%1689 = icmp slt i32 %1687, %1688
br i1 %1689, label %1690, label %1979
1690: ; preds = %1685
%1691 = load double*, double** %14
%1692 = load i32*, i32** %15
%1693 = load i32, i32* %20
%1694 = add nsw i32 %1693, 0
%1695 = sext i32 %1694 to i64
%1696 = getelementptr inbounds i32, i32* %1692, i64 %1695
%1697 = load i32, i32* %1696
%1698 = load i32, i32* %19
%1699 = add nsw i32 %1697, %1698
%1700 = sext i32 %1699 to i64
%1701 = getelementptr inbounds double, double* %1691, i64 %1700
store double* %1701, double** %39
%1702 = load double*, double** %14
%1703 = load i32*, i32** %15
%1704 = load i32, i32* %20
%1705 = add nsw i32 %1704, 1
%1706 = sext i32 %1705 to i64
%1707 = getelementptr inbounds i32, i32* %1703, i64 %1706
%1708 = load i32, i32* %1707
%1709 = load i32, i32* %19
%1710 = add nsw i32 %1708, %1709
%1711 = sext i32 %1710 to i64
%1712 = getelementptr inbounds double, double* %1702, i64 %1711
store double* %1712, double** %40
%1713 = load double*, double** %14
%1714 = load i32*, i32** %15
%1715 = load i32, i32* %20
%1716 = add nsw i32 %1715, 2
%1717 = sext i32 %1716 to i64
%1718 = getelementptr inbounds i32, i32* %1714, i64 %1717
%1719 = load i32, i32* %1718
%1720 = load i32, i32* %19
%1721 = add nsw i32 %1719, %1720
%1722 = sext i32 %1721 to i64
%1723 = getelementptr inbounds double, double* %1713, i64 %1722
store double* %1723, double** %41
%1724 = load double*, double** %14
%1725 = load i32*, i32** %15
%1726 = load i32, i32* %20
%1727 = add nsw i32 %1726, 3
%1728 = sext i32 %1727 to i64
%1729 = getelementptr inbounds i32, i32* %1725, i64 %1728
%1730 = load i32, i32* %1729
%1731 = load i32, i32* %19
%1732 = add nsw i32 %1730, %1731
%1733 = sext i32 %1732 to i64
%1734 = getelementptr inbounds double, double* %1724, i64 %1733
store double* %1734, double** %42
%1735 = load double*, double** %14
%1736 = load i32*, i32** %15
%1737 = load i32, i32* %20
%1738 = add nsw i32 %1737, 4
%1739 = sext i32 %1738 to i64
%1740 = getelementptr inbounds i32, i32* %1736, i64 %1739
%1741 = load i32, i32* %1740
%1742 = load i32, i32* %19
%1743 = add nsw i32 %1741, %1742
%1744 = sext i32 %1743 to i64
%1745 = getelementptr inbounds double, double* %1735, i64 %1744
store double* %1745, double** %43
%1746 = load double*, double** %14
%1747 = load i32*, i32** %15
%1748 = load i32, i32* %20
%1749 = add nsw i32 %1748, 5
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds i32, i32* %1747, i64 %1750
%1752 = load i32, i32* %1751
%1753 = load i32, i32* %19
%1754 = add nsw i32 %1752, %1753
%1755 = sext i32 %1754 to i64
%1756 = getelementptr inbounds double, double* %1746, i64 %1755
store double* %1756, double** %44
%1757 = load double*, double** %14
%1758 = load i32*, i32** %15
%1759 = load i32, i32* %20
%1760 = add nsw i32 %1759, 6
%1761 = sext i32 %1760 to i64
%1762 = getelementptr inbounds i32, i32* %1758, i64 %1761
%1763 = load i32, i32* %1762
%1764 = load i32, i32* %19
%1765 = add nsw i32 %1763, %1764
%1766 = sext i32 %1765 to i64
%1767 = getelementptr inbounds double, double* %1757, i64 %1766
store double* %1767, double** %45
%1768 = load double*, double** %14
%1769 = load i32*, i32** %15
%1770 = load i32, i32* %20
%1771 = add nsw i32 %1770, 7
%1772 = sext i32 %1771 to i64
%1773 = getelementptr inbounds i32, i32* %1769, i64 %1772
%1774 = load i32, i32* %1773
%1775 = load i32, i32* %19
%1776 = add nsw i32 %1774, %1775
%1777 = sext i32 %1776 to i64
%1778 = getelementptr inbounds double, double* %1768, i64 %1777
store double* %1778, double** %46
%1779 = load double*, double** %39
%1780 = load double, double* %1779
%1781 = load double*, double** %13
%1782 = load i32, i32* %20
%1783 = add nsw i32 %1782, 0
%1784 = sext i32 %1783 to i64
%1785 = getelementptr inbounds double, double* %1781, i64 %1784
%1786 = load double, double* %1785
%1787 = fdiv double %1780, %1786
store double %1787, double* %23
%1788 = load double*, double** %40
%1789 = load double, double* %1788
%1790 = load double*, double** %13
%1791 = load i32, i32* %20
%1792 = add nsw i32 %1791, 1
%1793 = sext i32 %1792 to i64
%1794 = getelementptr inbounds double, double* %1790, i64 %1793
%1795 = load double, double* %1794
%1796 = fdiv double %1789, %1795
store double %1796, double* %24
%1797 = load double*, double** %41
%1798 = load double, double* %1797
%1799 = load double*, double** %13
%1800 = load i32, i32* %20
%1801 = add nsw i32 %1800, 2
%1802 = sext i32 %1801 to i64
%1803 = getelementptr inbounds double, double* %1799, i64 %1802
%1804 = load double, double* %1803
%1805 = fdiv double %1798, %1804
store double %1805, double* %25
%1806 = load double*, double** %42
%1807 = load double, double* %1806
%1808 = load double*, double** %13
%1809 = load i32, i32* %20
%1810 = add nsw i32 %1809, 3
%1811 = sext i32 %1810 to i64
%1812 = getelementptr inbounds double, double* %1808, i64 %1811
%1813 = load double, double* %1812
%1814 = fdiv double %1807, %1813
store double %1814, double* %26
%1815 = load double*, double** %43
%1816 = load double, double* %1815
%1817 = load double*, double** %13
%1818 = load i32, i32* %20
%1819 = add nsw i32 %1818, 4
%1820 = sext i32 %1819 to i64
%1821 = getelementptr inbounds double, double* %1817, i64 %1820
%1822 = load double, double* %1821
%1823 = fdiv double %1816, %1822
store double %1823, double* %27
%1824 = load double*, double** %44
%1825 = load double, double* %1824
%1826 = load double*, double** %13
%1827 = load i32, i32* %20
%1828 = add nsw i32 %1827, 5
%1829 = sext i32 %1828 to i64
%1830 = getelementptr inbounds double, double* %1826, i64 %1829
%1831 = load double, double* %1830
%1832 = fdiv double %1825, %1831
store double %1832, double* %28
%1833 = load double*, double** %45
%1834 = load double, double* %1833
%1835 = load double*, double** %13
%1836 = load i32, i32* %20
%1837 = add nsw i32 %1836, 6
%1838 = sext i32 %1837 to i64
%1839 = getelementptr inbounds double, double* %1835, i64 %1838
%1840 = load double, double* %1839
%1841 = fdiv double %1834, %1840
store double %1841, double* %29
%1842 = load double*, double** %46
%1843 = load double, double* %1842
%1844 = load double*, double** %13
%1845 = load i32, i32* %20
%1846 = add nsw i32 %1845, 7
%1847 = sext i32 %1846 to i64
%1848 = getelementptr inbounds double, double* %1844, i64 %1847
%1849 = load double, double* %1848
%1850 = fdiv double %1843, %1849
store double %1850, double* %30
%1851 = load double, double* %23
%1852 = load double*, double** %39
%1853 = load double, double* %1852
%1854 = load double, double* %24
%1855 = load double*, double** %40
%1856 = load double, double* %1855
%1857 = fmul double %1854, %1856
%1858 = call double @llvm.fmuladd.f64(double %1851, double %1853, double %1857)
%1859 = load double, double* %25
%1860 = load double*, double** %41
%1861 = load double, double* %1860
%1862 = call double @llvm.fmuladd.f64(double %1859, double %1861, double %1858)
%1863 = load double, double* %26
%1864 = load double*, double** %42
%1865 = load double, double* %1864
%1866 = call double @llvm.fmuladd.f64(double %1863, double %1865, double %1862)
%1867 = load double, double* %27
%1868 = load double*, double** %43
%1869 = load double, double* %1868
%1870 = call double @llvm.fmuladd.f64(double %1867, double %1869, double %1866)
%1871 = load double, double* %28
%1872 = load double*, double** %44
%1873 = load double, double* %1872
%1874 = call double @llvm.fmuladd.f64(double %1871, double %1873, double %1870)
%1875 = load double, double* %29
%1876 = load double*, double** %45
%1877 = load double, double* %1876
%1878 = call double @llvm.fmuladd.f64(double %1875, double %1877, double %1874)
%1879 = load double, double* %30
%1880 = load double*, double** %46
%1881 = load double, double* %1880
%1882 = call double @llvm.fmuladd.f64(double %1879, double %1881, double %1878)
%1883 = load double*, double** %16
%1884 = load i32, i32* %19
%1885 = sext i32 %1884 to i64
%1886 = getelementptr inbounds double, double* %1883, i64 %1885
%1887 = load double, double* %1886
%1888 = fsub double %1887, %1882
store double %1888, double* %1886
%1889 = load double*, double** %39
%1890 = getelementptr inbounds double, double* %1889, i32 1
store double* %1890, double** %39
%1891 = load double*, double** %40
%1892 = getelementptr inbounds double, double* %1891, i32 1
store double* %1892, double** %40
%1893 = load double*, double** %41
%1894 = getelementptr inbounds double, double* %1893, i32 1
store double* %1894, double** %41
%1895 = load double*, double** %42
%1896 = getelementptr inbounds double, double* %1895, i32 1
store double* %1896, double** %42
%1897 = load double*, double** %43
%1898 = getelementptr inbounds double, double* %1897, i32 1
store double* %1898, double** %43
%1899 = load double*, double** %44
%1900 = getelementptr inbounds double, double* %1899, i32 1
store double* %1900, double** %44
%1901 = load double*, double** %45
%1902 = getelementptr inbounds double, double* %1901, i32 1
store double* %1902, double** %45
%1903 = load double*, double** %46
%1904 = getelementptr inbounds double, double* %1903, i32 1
store double* %1904, double** %46
store i32 0, i32* %21
br label %1905
1905: ; preds = %1972, %1690
%1906 = load i32, i32* %21
%1907 = load i32, i32* %22
%1908 = icmp slt i32 %1906, %1907
br i1 %1908, label %1909, label %1975
1909: ; preds = %1905
%1910 = load double, double* %23
%1911 = load double*, double** %39
%1912 = load i32, i32* %21
%1913 = sext i32 %1912 to i64
%1914 = getelementptr inbounds double, double* %1911, i64 %1913
%1915 = load double, double* %1914
%1916 = load double, double* %24
%1917 = load double*, double** %40
%1918 = load i32, i32* %21
%1919 = sext i32 %1918 to i64
%1920 = getelementptr inbounds double, double* %1917, i64 %1919
%1921 = load double, double* %1920
%1922 = fmul double %1916, %1921
%1923 = call double @llvm.fmuladd.f64(double %1910, double %1915, double %1922)
%1924 = load double, double* %25
%1925 = load double*, double** %41
%1926 = load i32, i32* %21
%1927 = sext i32 %1926 to i64
%1928 = getelementptr inbounds double, double* %1925, i64 %1927
%1929 = load double, double* %1928
%1930 = call double @llvm.fmuladd.f64(double %1924, double %1929, double %1923)
%1931 = load double, double* %26
%1932 = load double*, double** %42
%1933 = load i32, i32* %21
%1934 = sext i32 %1933 to i64
%1935 = getelementptr inbounds double, double* %1932, i64 %1934
%1936 = load double, double* %1935
%1937 = call double @llvm.fmuladd.f64(double %1931, double %1936, double %1930)
%1938 = load double, double* %27
%1939 = load double*, double** %43
%1940 = load i32, i32* %21
%1941 = sext i32 %1940 to i64
%1942 = getelementptr inbounds double, double* %1939, i64 %1941
%1943 = load double, double* %1942
%1944 = call double @llvm.fmuladd.f64(double %1938, double %1943, double %1937)
%1945 = load double, double* %28
%1946 = load double*, double** %44
%1947 = load i32, i32* %21
%1948 = sext i32 %1947 to i64
%1949 = getelementptr inbounds double, double* %1946, i64 %1948
%1950 = load double, double* %1949
%1951 = call double @llvm.fmuladd.f64(double %1945, double %1950, double %1944)
%1952 = load double, double* %29
%1953 = load double*, double** %45
%1954 = load i32, i32* %21
%1955 = sext i32 %1954 to i64
%1956 = getelementptr inbounds double, double* %1953, i64 %1955
%1957 = load double, double* %1956
%1958 = call double @llvm.fmuladd.f64(double %1952, double %1957, double %1951)
%1959 = load double, double* %30
%1960 = load double*, double** %46
%1961 = load i32, i32* %21
%1962 = sext i32 %1961 to i64
%1963 = getelementptr inbounds double, double* %1960, i64 %1962
%1964 = load double, double* %1963
%1965 = call double @llvm.fmuladd.f64(double %1959, double %1964, double %1958)
%1966 = load double*, double** %57
%1967 = load i32, i32* %21
%1968 = sext i32 %1967 to i64
%1969 = getelementptr inbounds double, double* %1966, i64 %1968
%1970 = load double, double* %1969
%1971 = fsub double %1970, %1965
store double %1971, double* %1969
br label %1972
1972: ; preds = %1909
%1973 = load i32, i32* %21
%1974 = add nsw i32 %1973, 1
store i32 %1974, i32* %21
br label %1905
1975: ; preds = %1905
br label %1976
1976: ; preds = %1975
%1977 = load i32, i32* %20
%1978 = add nsw i32 %1977, 8
store i32 %1978, i32* %20
br label %1685
1979: ; preds = %1685
br label %1980
1980: ; preds = %2139, %1979
%1981 = load i32, i32* %20
%1982 = add nsw i32 %1981, 3
%1983 = load i32, i32* %11
%1984 = icmp slt i32 %1982, %1983
br i1 %1984, label %1985, label %2142
1985: ; preds = %1980
%1986 = load double*, double** %14
%1987 = load i32*, i32** %15
%1988 = load i32, i32* %20
%1989 = add nsw i32 %1988, 0
%1990 = sext i32 %1989 to i64
%1991 = getelementptr inbounds i32, i32* %1987, i64 %1990
%1992 = load i32, i32* %1991
%1993 = load i32, i32* %19
%1994 = add nsw i32 %1992, %1993
%1995 = sext i32 %1994 to i64
%1996 = getelementptr inbounds double, double* %1986, i64 %1995
store double* %1996, double** %39
%1997 = load double*, double** %14
%1998 = load i32*, i32** %15
%1999 = load i32, i32* %20
%2000 = add nsw i32 %1999, 1
%2001 = sext i32 %2000 to i64
%2002 = getelementptr inbounds i32, i32* %1998, i64 %2001
%2003 = load i32, i32* %2002
%2004 = load i32, i32* %19
%2005 = add nsw i32 %2003, %2004
%2006 = sext i32 %2005 to i64
%2007 = getelementptr inbounds double, double* %1997, i64 %2006
store double* %2007, double** %40
%2008 = load double*, double** %14
%2009 = load i32*, i32** %15
%2010 = load i32, i32* %20
%2011 = add nsw i32 %2010, 2
%2012 = sext i32 %2011 to i64
%2013 = getelementptr inbounds i32, i32* %2009, i64 %2012
%2014 = load i32, i32* %2013
%2015 = load i32, i32* %19
%2016 = add nsw i32 %2014, %2015
%2017 = sext i32 %2016 to i64
%2018 = getelementptr inbounds double, double* %2008, i64 %2017
store double* %2018, double** %41
%2019 = load double*, double** %14
%2020 = load i32*, i32** %15
%2021 = load i32, i32* %20
%2022 = add nsw i32 %2021, 3
%2023 = sext i32 %2022 to i64
%2024 = getelementptr inbounds i32, i32* %2020, i64 %2023
%2025 = load i32, i32* %2024
%2026 = load i32, i32* %19
%2027 = add nsw i32 %2025, %2026
%2028 = sext i32 %2027 to i64
%2029 = getelementptr inbounds double, double* %2019, i64 %2028
store double* %2029, double** %42
%2030 = load double*, double** %39
%2031 = load double, double* %2030
%2032 = load double*, double** %13
%2033 = load i32, i32* %20
%2034 = add nsw i32 %2033, 0
%2035 = sext i32 %2034 to i64
%2036 = getelementptr inbounds double, double* %2032, i64 %2035
%2037 = load double, double* %2036
%2038 = fdiv double %2031, %2037
store double %2038, double* %23
%2039 = load double*, double** %40
%2040 = load double, double* %2039
%2041 = load double*, double** %13
%2042 = load i32, i32* %20
%2043 = add nsw i32 %2042, 1
%2044 = sext i32 %2043 to i64
%2045 = getelementptr inbounds double, double* %2041, i64 %2044
%2046 = load double, double* %2045
%2047 = fdiv double %2040, %2046
store double %2047, double* %24
%2048 = load double*, double** %41
%2049 = load double, double* %2048
%2050 = load double*, double** %13
%2051 = load i32, i32* %20
%2052 = add nsw i32 %2051, 2
%2053 = sext i32 %2052 to i64
%2054 = getelementptr inbounds double, double* %2050, i64 %2053
%2055 = load double, double* %2054
%2056 = fdiv double %2049, %2055
store double %2056, double* %25
%2057 = load double*, double** %42
%2058 = load double, double* %2057
%2059 = load double*, double** %13
%2060 = load i32, i32* %20
%2061 = add nsw i32 %2060, 3
%2062 = sext i32 %2061 to i64
%2063 = getelementptr inbounds double, double* %2059, i64 %2062
%2064 = load double, double* %2063
%2065 = fdiv double %2058, %2064
store double %2065, double* %26
%2066 = load double, double* %23
%2067 = load double*, double** %39
%2068 = load double, double* %2067
%2069 = load double, double* %24
%2070 = load double*, double** %40
%2071 = load double, double* %2070
%2072 = fmul double %2069, %2071
%2073 = call double @llvm.fmuladd.f64(double %2066, double %2068, double %2072)
%2074 = load double, double* %25
%2075 = load double*, double** %41
%2076 = load double, double* %2075
%2077 = call double @llvm.fmuladd.f64(double %2074, double %2076, double %2073)
%2078 = load double, double* %26
%2079 = load double*, double** %42
%2080 = load double, double* %2079
%2081 = call double @llvm.fmuladd.f64(double %2078, double %2080, double %2077)
%2082 = load double*, double** %16
%2083 = load i32, i32* %19
%2084 = sext i32 %2083 to i64
%2085 = getelementptr inbounds double, double* %2082, i64 %2084
%2086 = load double, double* %2085
%2087 = fsub double %2086, %2081
store double %2087, double* %2085
%2088 = load double*, double** %39
%2089 = getelementptr inbounds double, double* %2088, i32 1
store double* %2089, double** %39
%2090 = load double*, double** %40
%2091 = getelementptr inbounds double, double* %2090, i32 1
store double* %2091, double** %40
%2092 = load double*, double** %41
%2093 = getelementptr inbounds double, double* %2092, i32 1
store double* %2093, double** %41
%2094 = load double*, double** %42
%2095 = getelementptr inbounds double, double* %2094, i32 1
store double* %2095, double** %42
store i32 0, i32* %21
br label %2096
2096: ; preds = %2135, %1985
%2097 = load i32, i32* %21
%2098 = load i32, i32* %22
%2099 = icmp slt i32 %2097, %2098
br i1 %2099, label %2100, label %2138
2100: ; preds = %2096
%2101 = load double, double* %23
%2102 = load double*, double** %39
%2103 = load i32, i32* %21
%2104 = sext i32 %2103 to i64
%2105 = getelementptr inbounds double, double* %2102, i64 %2104
%2106 = load double, double* %2105
%2107 = load double, double* %24
%2108 = load double*, double** %40
%2109 = load i32, i32* %21
%2110 = sext i32 %2109 to i64
%2111 = getelementptr inbounds double, double* %2108, i64 %2110
%2112 = load double, double* %2111
%2113 = fmul double %2107, %2112
%2114 = call double @llvm.fmuladd.f64(double %2101, double %2106, double %2113)
%2115 = load double, double* %25
%2116 = load double*, double** %41
%2117 = load i32, i32* %21
%2118 = sext i32 %2117 to i64
%2119 = getelementptr inbounds double, double* %2116, i64 %2118
%2120 = load double, double* %2119
%2121 = call double @llvm.fmuladd.f64(double %2115, double %2120, double %2114)
%2122 = load double, double* %26
%2123 = load double*, double** %42
%2124 = load i32, i32* %21
%2125 = sext i32 %2124 to i64
%2126 = getelementptr inbounds double, double* %2123, i64 %2125
%2127 = load double, double* %2126
%2128 = call double @llvm.fmuladd.f64(double %2122, double %2127, double %2121)
%2129 = load double*, double** %57
%2130 = load i32, i32* %21
%2131 = sext i32 %2130 to i64
%2132 = getelementptr inbounds double, double* %2129, i64 %2131
%2133 = load double, double* %2132
%2134 = fsub double %2133, %2128
store double %2134, double* %2132
br label %2135
2135: ; preds = %2100
%2136 = load i32, i32* %21
%2137 = add nsw i32 %2136, 1
store i32 %2137, i32* %21
br label %2096
2138: ; preds = %2096
br label %2139
2139: ; preds = %2138
%2140 = load i32, i32* %20
%2141 = add nsw i32 %2140, 4
store i32 %2141, i32* %20
br label %1980
2142: ; preds = %1980
br label %2143
2143: ; preds = %2236, %2142
%2144 = load i32, i32* %20
%2145 = add nsw i32 %2144, 1
%2146 = load i32, i32* %11
%2147 = icmp slt i32 %2145, %2146
br i1 %2147, label %2148, label %2239
2148: ; preds = %2143
%2149 = load double*, double** %14
%2150 = load i32*, i32** %15
%2151 = load i32, i32* %20
%2152 = add nsw i32 %2151, 0
%2153 = sext i32 %2152 to i64
%2154 = getelementptr inbounds i32, i32* %2150, i64 %2153
%2155 = load i32, i32* %2154
%2156 = load i32, i32* %19
%2157 = add nsw i32 %2155, %2156
%2158 = sext i32 %2157 to i64
%2159 = getelementptr inbounds double, double* %2149, i64 %2158
store double* %2159, double** %39
%2160 = load double*, double** %14
%2161 = load i32*, i32** %15
%2162 = load i32, i32* %20
%2163 = add nsw i32 %2162, 1
%2164 = sext i32 %2163 to i64
%2165 = getelementptr inbounds i32, i32* %2161, i64 %2164
%2166 = load i32, i32* %2165
%2167 = load i32, i32* %19
%2168 = add nsw i32 %2166, %2167
%2169 = sext i32 %2168 to i64
%2170 = getelementptr inbounds double, double* %2160, i64 %2169
store double* %2170, double** %40
%2171 = load double*, double** %39
%2172 = load double, double* %2171
%2173 = load double*, double** %13
%2174 = load i32, i32* %20
%2175 = add nsw i32 %2174, 0
%2176 = sext i32 %2175 to i64
%2177 = getelementptr inbounds double, double* %2173, i64 %2176
%2178 = load double, double* %2177
%2179 = fdiv double %2172, %2178
store double %2179, double* %23
%2180 = load double*, double** %40
%2181 = load double, double* %2180
%2182 = load double*, double** %13
%2183 = load i32, i32* %20
%2184 = add nsw i32 %2183, 1
%2185 = sext i32 %2184 to i64
%2186 = getelementptr inbounds double, double* %2182, i64 %2185
%2187 = load double, double* %2186
%2188 = fdiv double %2181, %2187
store double %2188, double* %24
%2189 = load double, double* %23
%2190 = load double*, double** %39
%2191 = load double, double* %2190
%2192 = load double, double* %24
%2193 = load double*, double** %40
%2194 = load double, double* %2193
%2195 = fmul double %2192, %2194
%2196 = call double @llvm.fmuladd.f64(double %2189, double %2191, double %2195)
%2197 = load double*, double** %16
%2198 = load i32, i32* %19
%2199 = sext i32 %2198 to i64
%2200 = getelementptr inbounds double, double* %2197, i64 %2199
%2201 = load double, double* %2200
%2202 = fsub double %2201, %2196
store double %2202, double* %2200
%2203 = load double*, double** %39
%2204 = getelementptr inbounds double, double* %2203, i32 1
store double* %2204, double** %39
%2205 = load double*, double** %40
%2206 = getelementptr inbounds double, double* %2205, i32 1
store double* %2206, double** %40
store i32 0, i32* %21
br label %2207
2207: ; preds = %2232, %2148
%2208 = load i32, i32* %21
%2209 = load i32, i32* %22
%2210 = icmp slt i32 %2208, %2209
br i1 %2210, label %2211, label %2235
2211: ; preds = %2207
%2212 = load double, double* %23
%2213 = load double*, double** %39
%2214 = load i32, i32* %21
%2215 = sext i32 %2214 to i64
%2216 = getelementptr inbounds double, double* %2213, i64 %2215
%2217 = load double, double* %2216
%2218 = load double, double* %24
%2219 = load double*, double** %40
%2220 = load i32, i32* %21
%2221 = sext i32 %2220 to i64
%2222 = getelementptr inbounds double, double* %2219, i64 %2221
%2223 = load double, double* %2222
%2224 = fmul double %2218, %2223
%2225 = call double @llvm.fmuladd.f64(double %2212, double %2217, double %2224)
%2226 = load double*, double** %57
%2227 = load i32, i32* %21
%2228 = sext i32 %2227 to i64
%2229 = getelementptr inbounds double, double* %2226, i64 %2228
%2230 = load double, double* %2229
%2231 = fsub double %2230, %2225
store double %2231, double* %2229
br label %2232
2232: ; preds = %2211
%2233 = load i32, i32* %21
%2234 = add nsw i32 %2233, 1
store i32 %2234, i32* %21
br label %2207
2235: ; preds = %2207
br label %2236
2236: ; preds = %2235
%2237 = load i32, i32* %20
%2238 = add nsw i32 %2237, 2
store i32 %2238, i32* %20
br label %2143
2239: ; preds = %2143
br label %2240
2240: ; preds = %2299, %2239
%2241 = load i32, i32* %20
%2242 = load i32, i32* %11
%2243 = icmp slt i32 %2241, %2242
br i1 %2243, label %2244, label %2302
2244: ; preds = %2240
%2245 = load double*, double** %14
%2246 = load i32*, i32** %15
%2247 = load i32, i32* %20
%2248 = add nsw i32 %2247, 0
%2249 = sext i32 %2248 to i64
%2250 = getelementptr inbounds i32, i32* %2246, i64 %2249
%2251 = load i32, i32* %2250
%2252 = load i32, i32* %19
%2253 = add nsw i32 %2251, %2252
%2254 = sext i32 %2253 to i64
%2255 = getelementptr inbounds double, double* %2245, i64 %2254
store double* %2255, double** %39
%2256 = load double*, double** %39
%2257 = load double, double* %2256
%2258 = load double*, double** %13
%2259 = load i32, i32* %20
%2260 = add nsw i32 %2259, 0
%2261 = sext i32 %2260 to i64
%2262 = getelementptr inbounds double, double* %2258, i64 %2261
%2263 = load double, double* %2262
%2264 = fdiv double %2257, %2263
store double %2264, double* %23
%2265 = load double, double* %23
%2266 = load double*, double** %39
%2267 = load double, double* %2266
%2268 = load double*, double** %16
%2269 = load i32, i32* %19
%2270 = sext i32 %2269 to i64
%2271 = getelementptr inbounds double, double* %2268, i64 %2270
%2272 = load double, double* %2271
%2273 = fneg double %2265
%2274 = call double @llvm.fmuladd.f64(double %2273, double %2267, double %2272)
store double %2274, double* %2271
%2275 = load double*, double** %39
%2276 = getelementptr inbounds double, double* %2275, i32 1
store double* %2276, double** %39
store i32 0, i32* %21
br label %2277
2277: ; preds = %2295, %2244
%2278 = load i32, i32* %21
%2279 = load i32, i32* %22
%2280 = icmp slt i32 %2278, %2279
br i1 %2280, label %2281, label %2298
2281: ; preds = %2277
%2282 = load double, double* %23
%2283 = load double*, double** %39
%2284 = load i32, i32* %21
%2285 = sext i32 %2284 to i64
%2286 = getelementptr inbounds double, double* %2283, i64 %2285
%2287 = load double, double* %2286
%2288 = load double*, double** %57
%2289 = load i32, i32* %21
%2290 = sext i32 %2289 to i64
%2291 = getelementptr inbounds double, double* %2288, i64 %2290
%2292 = load double, double* %2291
%2293 = fneg double %2282
%2294 = call double @llvm.fmuladd.f64(double %2293, double %2287, double %2292)
store double %2294, double* %2291
br label %2295
2295: ; preds = %2281
%2296 = load i32, i32* %21
%2297 = add nsw i32 %2296, 1
store i32 %2297, i32* %21
br label %2277
2298: ; preds = %2277
br label %2299
2299: ; preds = %2298
%2300 = load i32, i32* %20
%2301 = add nsw i32 %2300, 1
store i32 %2301, i32* %20
br label %2240
2302: ; preds = %2240
br label %2303
2303: ; preds = %2302
%2304 = load i32, i32* %19
%2305 = add nsw i32 %2304, 1
store i32 %2305, i32* %19
br label %682
2306: ; preds = %682
ret void
}

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