int jtinvit_(int *nm, int *n, double *d, double *e, double *e2, int *m,
             double *w, int *ind, double *z, int *ierr, double *rv1,
             double *rv2, double *rv3, double *rv4, double *rv6) {
  static double machep = 1.25e-15;
  int z_dim1, z_offset, i1, i2, i3;
  double d1, d2;
  double sqrt(double);
  static double norm;
  static int i, j, p, q, r, s;
  static double u, v, order;
  static int group;
  static double x0, x1;
  static int ii, jj, ip;
  static double uk, xu;
  static int tag, its;
  static double eps2, eps3, eps4;
  static double rtem;
  --rv6;
  --rv4;
  --rv3;
  --rv2;
  --rv1;
  --e2;
  --e;
  --d;
  z_dim1 = *nm;
  z_offset = z_dim1 + 1;
  z -= z_offset;
  --ind;
  --w;
  *ierr = 0;
  if (*m == 0) {
    goto L1001;
  }
  tag = 0;
  order = 1. - e2[1];
  q = 0;
L100:
  p = q + 1;
  i1 = *n;
  for (q = p; q <= i1; ++q) {
    if (q == *n) {
      goto L140;
    }
    if (e2[q + 1] == 0.) {
      goto L140;
    }
  }
L140:
  ++tag;
  s = 0;
  i1 = *m;
  for (r = 1; r <= i1; ++r) {
    if (ind[r] != tag) {
      goto L920;
    }
    its = 1;
    x1 = w[r];
    if (s != 0) {
      goto L510;
    }
    xu = 1.;
    if (p != q) {
      goto L490;
    }
    rv6[p] = 1.;
    goto L870;
  L490:
    norm = (d1 = d[p], ((d1) >= 0 ? (d1) : -(d1)));
    ip = p + 1;
    i2 = q;
    for (i = ip; i <= i2; ++i) {
      norm = norm + (d1 = d[i], ((d1) >= 0 ? (d1) : -(d1))) +
             (d2 = e[i], ((d2) >= 0 ? (d2) : -(d2)));
    }
    eps2 = norm * .001;
    eps3 = machep * norm;
    uk = (double)(q - p + 1);
    eps4 = uk * eps3;
    uk = eps4 / sqrt(uk);
    s = p;
  L505:
    group = 0;
    goto L520;
  L510:
    if ((d1 = x1 - x0, ((d1) >= 0 ? (d1) : -(d1))) >= eps2) {
      goto L505;
    }
    ++group;
    if (order * (x1 - x0) <= 0.) {
      x1 = x0 + order * eps3;
    }
  L520:
    v = 0.;
    i2 = q;
    for (i = p; i <= i2; ++i) {
      rv6[i] = uk;
      if (i == p) {
        goto L560;
      }
      if ((d1 = e[i], ((d1) >= 0 ? (d1) : -(d1))) < ((u) >= 0 ? (u) : -(u))) {
        goto L540;
      }
      xu = u / e[i];
      rv4[i] = xu;
      rv1[i - 1] = e[i];
      rv2[i - 1] = d[i] - x1;
      rv3[i - 1] = 0.;
      if (i != q) {
        rv3[i - 1] = e[i + 1];
      }
      u = v - xu * rv2[i - 1];
      v = -xu * rv3[i - 1];
      goto L580;
    L540:
      xu = e[i] / u;
      rv4[i] = xu;
      rv1[i - 1] = u;
      rv2[i - 1] = v;
      rv3[i - 1] = 0.;
    L560:
      u = d[i] - x1 - xu * v;
      if (i != q) {
        v = e[i + 1];
      }
    L580:;
    }
    if (u == 0.) {
      u = eps3;
    }
    rv1[q] = u;
    rv2[q] = 0.;
    rv3[q] = 0.;
  L600:
    i2 = q;
    for (ii = p; ii <= i2; ++ii) {
      i = p + q - ii;
      rtem = rv6[i] - u * rv2[i] - v * rv3[i];
      rv6[i] = (rtem) / rv1[i];
      v = u;
      u = rv6[i];
    }
    if (group == 0) {
      goto L700;
    }
    j = r;
    i2 = group;
    for (jj = 1; jj <= i2; ++jj) {
    L630:
      --j;
      if (ind[j] != tag) {
        goto L630;
      }
      xu = 0.;
      i3 = q;
      for (i = p; i <= i3; ++i) {
        xu += rv6[i] * z[i + j * z_dim1];
      }
      i3 = q;
      for (i = p; i <= i3; ++i) {
        rv6[i] -= xu * z[i + j * z_dim1];
      }
    }
  L700:
    norm = 0.;
    i2 = q;
    for (i = p; i <= i2; ++i) {
      norm += (d1 = rv6[i], ((d1) >= 0 ? (d1) : -(d1)));
    }
    if (norm >= 1.) {
      goto L840;
    }
    if (its == 5) {
      goto L830;
    }
    if (norm != 0.) {
      goto L740;
    }
    rv6[s] = eps4;
    ++s;
    if (s > q) {
      s = p;
    }
    goto L780;
  L740:
    xu = eps4 / norm;
    i2 = q;
    for (i = p; i <= i2; ++i) {
      rv6[i] *= xu;
    }
  L780:
    i2 = q;
    for (i = ip; i <= i2; ++i) {
      u = rv6[i];
      if (rv1[i - 1] != e[i]) {
        goto L800;
      }
      u = rv6[i - 1];
      rv6[i - 1] = rv6[i];
    L800:
      rv6[i] = u - rv4[i] * rv6[i - 1];
    }
    ++its;
    goto L600;
  L830:
    *ierr = -r;
    xu = 0.;
    goto L870;
  L840:
    u = 0.;
    i2 = q;
    for (i = p; i <= i2; ++i) {
      d1 = rv6[i];
      u += d1 * d1;
    }
    xu = 1. / sqrt(u);
  L870:
    i2 = *n;
    for (i = 1; i <= i2; ++i) {
      z[i + r * z_dim1] = 0.;
    }
    i2 = q;
    for (i = p; i <= i2; ++i) {
      z[i + r * z_dim1] = rv6[i] * xu;
    }
    x0 = x1;
  L920:;
  }
  if (q < *n) {
    goto L100;
  }
L1001:
  return 0;
}


x86 assembly (clang, -O0):
<jtinvit_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    0x20(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%rbp)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1217 <jtinvit_+0x107>
jmp    229d <jtinvit_+0x118d>
movl   $0x0,0x3e87(%rip)
mov    -0x28(%rbp),%rax
movsd  0x1dd3(%rip),%xmm0
subsd  0x8(%rax),%xmm0
movsd  %xmm0,0x3e2e(%rip)
movl   $0x0,0x3e08(%rip)
mov    0x3e02(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3df5(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    0x3de6(%rip),%eax
mov    %eax,0x3de4(%rip)
mov    0x3dde(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     12d4 <jtinvit_+0x1c4>
mov    0x3dcf(%rip),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    128e <jtinvit_+0x17e>
jmp    12d9 <jtinvit_+0x1c9>
mov    -0x28(%rbp),%rax
mov    0x3db4(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12bb <jtinvit_+0x1ab>
jp     12bb <jtinvit_+0x1ab>
jmp    12d9 <jtinvit_+0x1c9>
jmp    12c0 <jtinvit_+0x1b0>
mov    0x3d86(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3d7d(%rip)
jmp    1268 <jtinvit_+0x158>
jmp    12d9 <jtinvit_+0x1c9>
mov    0x3dc9(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3dc0(%rip)
movl   $0x0,0x3d62(%rip)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x3d4b(%rip)
mov    0x3d45(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     2281 <jtinvit_+0x1171>
mov    0x18(%rbp),%rax
movslq 0x3d31(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3d80(%rip),%eax
je     1333 <jtinvit_+0x223>
jmp    2268 <jtinvit_+0x1158>
movl   $0x1,0x3d6f(%rip)
mov    0x10(%rbp),%rax
movslq 0x3d08(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d2b(%rip)
cmpl   $0x0,0x3cf8(%rip)
je     1367 <jtinvit_+0x257>
jmp    15ec <jtinvit_+0x4dc>
movsd  0x1c91(%rip),%xmm0
movsd  %xmm0,0x3d29(%rip)
mov    0x3ccb(%rip),%eax
cmp    0x3cc9(%rip),%eax
je     138e <jtinvit_+0x27e>
jmp    13ab <jtinvit_+0x29b>
mov    0x50(%rbp),%rax
movslq 0x3caf(%rip),%rcx
movsd  0x1c5f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2193 <jtinvit_+0x1083>
mov    -0x18(%rbp),%rax
movslq 0x3c92(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     13e1 <jtinvit_+0x2d1>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1402 <jtinvit_+0x2f2>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,0x3c29(%rip)
mov    0x3c33(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3c72(%rip)
mov    0x3c28(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x3c63(%rip),%eax
mov    %eax,0x3c0d(%rip)
mov    0x3c07(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     153a <jtinvit_+0x42a>
movsd  0x3bee(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
movslq 0x3be6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1485 <jtinvit_+0x375>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    14a6 <jtinvit_+0x396>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movslq 0x3b7c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14ef <jtinvit_+0x3df>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1510 <jtinvit_+0x400>
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3b12(%rip)
mov    0x3b14(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3b0b(%rip)
jmp    1433 <jtinvit_+0x323>
movsd  0x1ac6(%rip),%xmm0
mulsd  0x3aee(%rip),%xmm0
movsd  %xmm0,0x3b5e(%rip)
movsd  0x3ace(%rip),%xmm0
mulsd  0x3ad6(%rip),%xmm0
movsd  %xmm0,0x3b4e(%rip)
mov    0x3adc(%rip),%eax
sub    0x3ad2(%rip),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x3b13(%rip)
movsd  0x3b0b(%rip),%xmm0
mulsd  0x3b23(%rip),%xmm0
movsd  %xmm0,0x3b23(%rip)
movsd  0x3b1b(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x3ae3(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3ac7(%rip)
mov    0x3a71(%rip),%eax
mov    %eax,0x3a77(%rip)
movl   $0x0,0x3a89(%rip)
jmp    16c9 <jtinvit_+0x5b9>
movsd  0x3a8c(%rip),%xmm0
subsd  0x3a7c(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1625 <jtinvit_+0x515>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1649 <jtinvit_+0x539>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd 0x3a57(%rip),%xmm0
jb     1664 <jtinvit_+0x554>
jmp    15dd <jtinvit_+0x4cd>
mov    0x3a06(%rip),%eax
add    $0x1,%eax
mov    %eax,0x39fd(%rip)
movsd  0x39ed(%rip),%xmm1
movsd  0x39fd(%rip),%xmm0
subsd  0x39ed(%rip),%xmm0
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     16c4 <jtinvit_+0x5b4>
movsd  0x39d4(%rip),%xmm1
movsd  0x39bc(%rip),%xmm0
movsd  0x3a04(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x39bc(%rip)
jmp    16c9 <jtinvit_+0x5b9>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x398c(%rip)
mov    0x3972(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x3965(%rip),%eax
mov    %eax,0x3957(%rip)
mov    0x3951(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1a95 <jtinvit_+0x985>
movsd  0x3998(%rip),%xmm0
mov    0x50(%rbp),%rax
movslq 0x3935(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x392a(%rip),%eax
cmp    0x392c(%rip),%eax
jne    1727 <jtinvit_+0x617>
jmp    19f9 <jtinvit_+0x8e9>
mov    -0x20(%rbp),%rax
movslq 0x390e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1760 <jtinvit_+0x650>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    1784 <jtinvit_+0x674>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x38bc(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     17be <jtinvit_+0x6ae>
movsd  0x38a7(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    17e5 <jtinvit_+0x6d5>
movsd  0x3892(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1804 <jtinvit_+0x6f4>
jmp    196f <jtinvit_+0x85f>
movsd  0x384c(%rip),%xmm0
mov    -0x20(%rbp),%rax
movslq 0x3829(%rip),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x387c(%rip)
movsd  0x3874(%rip),%xmm0
mov    0x48(%rbp),%rax
movslq 0x3809(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq 0x37f9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x37ea(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq 0x37d4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  0x3807(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x37bd(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    0x37a8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3794(%rip),%eax
cmp    0x379a(%rip),%eax
je     18e2 <jtinvit_+0x7d2>
mov    -0x20(%rbp),%rax
mov    0x377e(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    0x3769(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3776(%rip),%xmm1
movsd  0x37ae(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x3744(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x372a(%rip)
movsd  0x376a(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x40(%rbp),%rax
mov    0x36e9(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x36f6(%rip)
jmp    1a7c <jtinvit_+0x96c>
mov    -0x20(%rbp),%rax
movslq 0x36c6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  0x36d1(%rip),%xmm0
movsd  %xmm0,0x3711(%rip)
movsd  0x3709(%rip),%xmm0
mov    0x48(%rbp),%rax
movslq 0x369e(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x36a9(%rip),%xmm0
mov    0x30(%rbp),%rax
mov    0x3687(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3694(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x366a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    0x3655(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq 0x363c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  0x366f(%rip),%xmm1
movsd  0x3687(%rip),%xmm0
movsd  0x363f(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3610(%rip)
mov    0x35f2(%rip),%eax
cmp    0x35f8(%rip),%eax
je     1a77 <jtinvit_+0x967>
mov    -0x20(%rbp),%rax
mov    0x35dc(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35e9(%rip)
jmp    1a7c <jtinvit_+0x96c>
jmp    1a81 <jtinvit_+0x971>
mov    0x35b9(%rip),%eax
add    $0x1,%eax
mov    %eax,0x35b0(%rip)
jmp    16e9 <jtinvit_+0x5d9>
movsd  0x35bb(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ac0 <jtinvit_+0x9b0>
jp     1ac0 <jtinvit_+0x9b0>
movsd  0x3600(%rip),%xmm0
movsd  %xmm0,0x3598(%rip)
movsd  0x3590(%rip),%xmm0
mov    0x30(%rbp),%rax
movslq 0x3579(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
movslq 0x3569(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq 0x3556(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3548(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x353b(%rip),%eax
mov    %eax,0x3575(%rip)
mov    0x356f(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1c24 <jtinvit_+0xb14>
mov    0x3520(%rip),%eax
add    0x351e(%rip),%eax
sub    0x3554(%rip),%eax
mov    %eax,0x3506(%rip)
mov    0x50(%rbp),%rax
movslq 0x34fb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x3506(%rip),%xmm1
mov    0x38(%rbp),%rax
movslq 0x34e3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x34d7(%rip),%xmm0
mov    0x40(%rbp),%rax
movslq 0x34ac(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3508(%rip)
movsd  0x3500(%rip),%xmm0
mov    0x30(%rbp),%rax
movslq 0x346d(%rip),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq 0x345d(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3468(%rip),%xmm0
movsd  %xmm0,0x3468(%rip)
mov    0x50(%rbp),%rax
movslq 0x343d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3448(%rip)
mov    0x3472(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3469(%rip)
jmp    1b13 <jtinvit_+0xa03>
cmpl   $0x0,0x3445(%rip)
jne    1c36 <jtinvit_+0xb26>
jmp    1dd0 <jtinvit_+0xcc0>
mov    0x3414(%rip),%eax
mov    %eax,0x3402(%rip)
mov    0x3428(%rip),%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,0x3437(%rip)
mov    0x3431(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1dcb <jtinvit_+0xcbb>
jmp    1c69 <jtinvit_+0xb59>
mov    0x33d5(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x33cc(%rip)
mov    0x18(%rbp),%rax
movslq 0x33c1(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x341c(%rip),%eax
je     1c97 <jtinvit_+0xb87>
jmp    1c69 <jtinvit_+0xb59>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x33fe(%rip)
mov    0x33a4(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x3397(%rip),%eax
mov    %eax,0x3389(%rip)
mov    0x3383(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1d20 <jtinvit_+0xc10>
mov    0x50(%rbp),%rax
movslq 0x336f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x3360(%rip),%ecx
mov    0x335e(%rip),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x33a4(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3394(%rip)
mov    0x332e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3325(%rip)
jmp    1cb7 <jtinvit_+0xba7>
mov    0x3326(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x3319(%rip),%eax
mov    %eax,0x330b(%rip)
mov    0x3305(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1db2 <jtinvit_+0xca2>
movsd  0x3354(%rip),%xmm0
mov    0x20(%rbp),%rax
mov    0x32ea(%rip),%ecx
mov    0x32e8(%rip),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
movslq 0x32cb(%rip),%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    0x329c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3293(%rip)
jmp    1d35 <jtinvit_+0xc25>
jmp    1db7 <jtinvit_+0xca7>
mov    0x32cf(%rip),%eax
add    $0x1,%eax
mov    %eax,0x32c6(%rip)
jmp    1c55 <jtinvit_+0xb45>
jmp    1dd0 <jtinvit_+0xcc0>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x325d(%rip)
mov    0x326b(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x325e(%rip),%eax
mov    %eax,0x3250(%rip)
mov    0x324a(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1e88 <jtinvit_+0xd78>
mov    0x50(%rbp),%rax
movslq 0x3236(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1e38 <jtinvit_+0xd28>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1e5c <jtinvit_+0xd4c>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  0x31cc(%rip),%xmm0
movsd  %xmm0,0x31c4(%rip)
mov    0x31c6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x31bd(%rip)
jmp    1df0 <jtinvit_+0xce0>
movsd  0x31a8(%rip),%xmm0
movsd  0x1168(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1ea7 <jtinvit_+0xd97>
jmp    20f5 <jtinvit_+0xfe5>
cmpl   $0x5,0x31fe(%rip)
jne    1eb9 <jtinvit_+0xda9>
jmp    20d7 <jtinvit_+0xfc7>
movsd  0x3177(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ed9 <jtinvit_+0xdc9>
jp     1ed9 <jtinvit_+0xdc9>
jmp    1ede <jtinvit_+0xdce>
jmp    1f28 <jtinvit_+0xe18>
movsd  0x31da(%rip),%xmm0
mov    0x50(%rbp),%rax
movslq 0x3163(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3158(%rip),%eax
add    $0x1,%eax
mov    %eax,0x314f(%rip)
mov    0x3149(%rip),%eax
cmp    0x313b(%rip),%eax
jle    1f23 <jtinvit_+0xe13>
mov    0x312b(%rip),%eax
mov    %eax,0x3131(%rip)
jmp    1f9a <jtinvit_+0xe8a>
movsd  0x3190(%rip),%xmm0
divsd  0x3100(%rip),%xmm0
movsd  %xmm0,0x3160(%rip)
mov    0x3106(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x30f9(%rip),%eax
mov    %eax,0x30eb(%rip)
mov    0x30e5(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     1f95 <jtinvit_+0xe85>
movsd  0x3134(%rip),%xmm0
mov    0x50(%rbp),%rax
movslq 0x30c9(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30b9(%rip),%eax
add    $0x1,%eax
mov    %eax,0x30b0(%rip)
jmp    1f55 <jtinvit_+0xe45>
jmp    1f9a <jtinvit_+0xe8a>
mov    0x30ac(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x30e7(%rip),%eax
mov    %eax,0x3091(%rip)
mov    0x308b(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     20c3 <jtinvit_+0xfb3>
mov    0x50(%rbp),%rax
movslq 0x3077(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3082(%rip)
mov    0x30(%rbp),%rax
mov    0x3060(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq 0x304a(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    200c <jtinvit_+0xefc>
jp     200c <jtinvit_+0xefc>
jmp    2011 <jtinvit_+0xf01>
jmp    2053 <jtinvit_+0xf43>
mov    0x50(%rbp),%rax
mov    0x3025(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x302a(%rip)
mov    0x50(%rbp),%rax
movslq 0x3007(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x2ff8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2ffd(%rip),%xmm1
mov    0x48(%rbp),%rax
movslq 0x2fda(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x2fcb(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq 0x2f96(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2f8b(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2f82(%rip)
jmp    1faf <jtinvit_+0xe9f>
mov    0x2fe3(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2fda(%rip)
jmp    1afe <jtinvit_+0x9ee>
xor    %ecx,%ecx
sub    0x2f71(%rip),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2fb0(%rip)
jmp    2193 <jtinvit_+0x1083>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2f58(%rip)
mov    0x2f46(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x2f39(%rip),%eax
mov    %eax,0x2f2b(%rip)
mov    0x2f25(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     216f <jtinvit_+0x105f>
mov    0x50(%rbp),%rax
movslq 0x2f11(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  0x2f0d(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2efd(%rip)
mov    0x2edf(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ed6(%rip)
jmp    2115 <jtinvit_+0x1005>
movsd  0x2ee1(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe79(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2f0d(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,0x2e9a(%rip)
mov    0x2e94(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     21ea <jtinvit_+0x10da>
mov    0x20(%rbp),%rax
mov    0x2e81(%rip),%ecx
mov    0x2e8b(%rip),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e64(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e5b(%rip)
jmp    21a6 <jtinvit_+0x1096>
mov    0x2e5c(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    0x2e4f(%rip),%eax
mov    %eax,0x2e41(%rip)
mov    0x2e3b(%rip),%eax
cmp    -0x40(%rbp),%eax
jg     2258 <jtinvit_+0x1148>
mov    0x50(%rbp),%rax
movslq 0x2e27(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x2e7a(%rip),%xmm0
mov    0x20(%rbp),%rax
mov    0x2e10(%rip),%ecx
mov    0x2e1a(%rip),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2df6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ded(%rip)
jmp    21ff <jtinvit_+0x10ef>
movsd  0x2e20(%rip),%xmm0
movsd  %xmm0,0x2e10(%rip)
jmp    226d <jtinvit_+0x115d>
mov    0x2ddd(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2dd4(%rip)
jmp    1305 <jtinvit_+0x1f5>
mov    0x2dc5(%rip),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    2298 <jtinvit_+0x1188>
jmp    1244 <jtinvit_+0x134>
jmp    229d <jtinvit_+0x118d>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jtinvit_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %rcx,0x28(%rsp)
mov    %rdx,0x68(%rsp)
mov    %rsi,0xa8(%rsp)
mov    0x1b8(%rsp),%rax
movslq (%rdi),%r14
movl   $0x0,(%rax)
mov    %r9,0xf8(%rsp)
cmpl   $0x0,(%r9)
je     25cc <jtinvit_+0x14ac>
mov    0x1e0(%rsp),%rbp
mov    0x1d8(%rsp),%r11
mov    0x1d0(%rsp),%r9
mov    0x1c8(%rsp),%r10
mov    0x1c0(%rsp),%rdx
mov    0x1b0(%rsp),%rax
mov    0x1a8(%rsp),%rsi
mov    %r14,%rcx
not    %rcx
lea    (%rax,%rcx,8),%rcx
movsd  0x1e4f(%rip),%xmm10
movapd %xmm10,%xmm0
subsd  (%r8),%xmm0
movsd  %xmm0,0x3e8d(%rip)
mov    0xa8(%rsp),%rax
mov    (%rax),%ebx
lea    -0x8(%rbp),%rax
mov    %rax,0xa0(%rsp)
mov    0x28(%rsp),%rax
lea    0x8(%rax),%rdi
mov    %rdi,0x118(%rsp)
lea    -0x8(%rdx),%rdi
mov    %rdi,0x110(%rsp)
lea    -0x8(%r10),%rdi
mov    %rdi,0x108(%rsp)
xorpd  %xmm11,%xmm11
movapd 0x1e10(%rip),%xmm12
movapd 0x1e07(%rip),%xmm13
lea    -0x8(%r9),%rdi
mov    %rdi,0x100(%rsp)
lea    -0x8(%rsi),%r10
lea    0x28(%rbp),%rsi
mov    %rsi,0x98(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x130(%rsp)
mov    %rcx,%rax
lea    -0x8(%r11),%rcx
mov    %rcx,0x128(%rsp)
lea    -0x10(%rdx),%rcx
mov    %rcx,0x120(%rsp)
xor    %r15d,%r15d
xor    %ecx,%ecx
mov    %r8,0xf0(%rsp)
mov    %r10,0xe8(%rsp)
mov    %rax,0x78(%rsp)
jmp    1298 <jtinvit_+0x178>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rbx
cmp    %ebx,%edi
mov    %rdi,%rcx
mov    0xf0(%rsp),%r8
jge    25cc <jtinvit_+0x14ac>
mov    %rcx,%rdi
add    $0x1,%ecx
mov    %ecx,0x3d94(%rip)
mov    %rcx,%r9
movslq %ecx,%rdx
movslq %ebx,%rsi
cmp    %edx,%esi
mov    %edx,%ecx
cmovg  %esi,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %rsi,%rdx
jge    12e0 <jtinvit_+0x1c0>
movsd  (%r8,%rdx,8),%xmm0
add    $0x1,%rdx
add    $0x1,%edi
ucomisd %xmm11,%xmm0
jne    12c0 <jtinvit_+0x1a0>
jp     12c0 <jtinvit_+0x1a0>
jmp    12e2 <jtinvit_+0x1c2>
nopl   (%rax)
mov    %ecx,%edi
mov    %edi,0x3d54(%rip)
add    $0x1,%r15d
mov    %r15d,0x3d95(%rip)
movl   $0x0,0x3d47(%rip)
mov    0xf8(%rsp),%rcx
mov    (%rcx),%edx
movl   $0x1,0x3d2f(%rip)
test   %edx,%edx
mov    %rbx,0x50(%rsp)
jle    1280 <jtinvit_+0x160>
mov    $0x1,%r13d
mov    %edx,0x90(%rsp)
mov    %r9,%rbx
jmp    1371 <jtinvit_+0x251>
movsd  0x3d30(%rip),%xmm0
movsd  %xmm0,0x3d20(%rip)
xorpd  %xmm11,%xmm11
movapd 0x1cd2(%rip),%xmm12
mov    0x90(%rsp),%edx
mov    %r8,%rdi
mov    %r12,%rbx
lea    0x1(%r13),%ecx
mov    %ecx,0x3cdb(%rip)
cmp    %edx,%r13d
mov    %ecx,%r13d
jge    1280 <jtinvit_+0x160>
movslq %r13d,%rcx
mov    0x1a8(%rsp),%rax
cmp    %r15d,-0x4(%rax,%rcx,4)
jne    135b <jtinvit_+0x23b>
movl   $0x1,0x3cff(%rip)
mov    0x1a0(%rsp),%rax
movsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3cc5(%rip)
mov    0x3c9b(%rip),%eax
test   %eax,%eax
je     1432 <jtinvit_+0x312>
movsd  0x3ca7(%rip),%xmm1
subsd  %xmm1,%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm12,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm0,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm0,%xmm4
andnpd %xmm2,%xmm3
orpd   %xmm4,%xmm3
ucomisd 0x3ca9(%rip),%xmm3
jae    1459 <jtinvit_+0x339>
mov    0x3c69(%rip),%ecx
add    $0x1,%ecx
mov    %ecx,0x50(%rsp)
mov    %ecx,0x3c5c(%rip)
movsd  0x3c4c(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm0,%xmm11
jb     1423 <jtinvit_+0x303>
mulsd  0x3c81(%rip),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x3c45(%rip)
mov    0x28(%rsp),%r13
mov    0x68(%rsp),%r12
jmp    1699 <jtinvit_+0x579>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,0x3c3d(%rip)
cmp    %ebx,%edi
jne    1468 <jtinvit_+0x348>
movslq %edi,%rax
mov    %rcx,-0x8(%rbp,%rax,8)
movapd %xmm10,%xmm3
jmp    2344 <jtinvit_+0x1224>
mov    0x28(%rsp),%r13
mov    0x68(%rsp),%r12
jmp    1687 <jtinvit_+0x567>
movslq %ebx,%rdx
mov    0x68(%rsp),%r12
movsd  -0x8(%r12,%rdx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm12,%xmm2
xorpd  %xmm0,%xmm0
cmplesd %xmm1,%xmm0
andpd  %xmm0,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
lea    0x1(%rbx),%eax
mov    %eax,0x3bd2(%rip)
mov    %edi,%ecx
sub    %ebx,%ecx
jle    14bb <jtinvit_+0x39b>
test   $0x1,%cl
jne    14c9 <jtinvit_+0x3a9>
add    $0x1,%rdx
mov    0x28(%rsp),%r13
cmp    %eax,%edi
jne    152f <jtinvit_+0x40f>
jmp    15ef <jtinvit_+0x4cf>
movapd %xmm0,%xmm4
mov    0x28(%rsp),%r13
jmp    15ef <jtinvit_+0x4cf>
movsd  (%r12,%rdx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
addsd  %xmm3,%xmm0
mov    0x28(%rsp),%r13
movsd  0x0(%r13,%rdx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm4,%xmm4
cmplesd %xmm1,%xmm4
andpd  %xmm4,%xmm1
andnpd %xmm2,%xmm4
orpd   %xmm1,%xmm4
addsd  %xmm0,%xmm4
add    $0x2,%rdx
movapd %xmm4,%xmm0
cmp    %eax,%edi
je     15ef <jtinvit_+0x4cf>
add    $0x1,%edi
mov    %edi,%eax
movapd %xmm0,%xmm4
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rdx,8),%xmm1
movsd  (%r12,%rdx,8),%xmm0
movapd %xmm1,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm1,%xmm3
addsd  %xmm4,%xmm3
movsd  -0x8(%r13,%rdx,8),%xmm2
movsd  0x0(%r13,%rdx,8),%xmm1
movapd %xmm2,%xmm4
xorpd  %xmm13,%xmm4
xorpd  %xmm5,%xmm5
cmplesd %xmm2,%xmm5
andpd  %xmm5,%xmm2
andnpd %xmm4,%xmm5
orpd   %xmm2,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm0,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm1,%xmm0
xorpd  %xmm13,%xmm0
xorpd  %xmm4,%xmm4
cmplesd %xmm1,%xmm4
andpd  %xmm4,%xmm1
andnpd %xmm0,%xmm4
orpd   %xmm1,%xmm4
addsd  %xmm3,%xmm4
add    $0x2,%rdx
cmp    %edx,%eax
jne    1540 <jtinvit_+0x420>
movapd %xmm4,%xmm0
mulsd  0x1a0d(%rip),%xmm0
movsd  %xmm0,0x3a8d(%rip)
mulsd  0x1a05(%rip),%xmm4
movsd  %xmm4,0x3a85(%rip)
add    $0x1,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  %xmm0,%xmm4
movsd  %xmm4,0x3a77(%rip)
ucomisd %xmm11,%xmm0
jb     1636 <jtinvit_+0x516>
sqrtsd %xmm0,%xmm0
jmp    1667 <jtinvit_+0x547>
movapd %xmm4,0x50(%rsp)
call   1040 <sqrt@plt>
movapd 0x50(%rsp),%xmm4
movapd 0x19d0(%rip),%xmm13
movapd 0x19c7(%rip),%xmm12
xorpd  %xmm11,%xmm11
movsd  0x1999(%rip),%xmm10
divsd  %xmm0,%xmm4
movsd  %xmm4,0x3a05(%rip)
mov    0x39bf(%rip),%eax
mov    %eax,0x39c5(%rip)
mov    0x39b7(%rip),%edi
mov    %eax,%ebx
movl   $0x0,0x39c7(%rip)
movl   $0x0,0x50(%rsp)
mov    %edi,%ecx
movslq %edi,%rdx
movslq %ebx,%rsi
sub    %ebx,%ecx
mov    %rcx,0x20(%rsp)
mov    %rdi,0x18(%rsp)
mov    %rbx,0x38(%rsp)
mov    %rsi,0x8(%rsp)
mov    %eax,0x48(%rsp)
mov    %rdx,0x88(%rsp)
jge    16e0 <jtinvit_+0x5c0>
xorpd  %xmm9,%xmm9
movsd  0x3976(%rip),%xmm1
jmp    1740 <jtinvit_+0x620>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x398f(%rip),%xmm8
movsd  0x3977(%rip),%xmm3
lea    0x1(%rdi),%r8d
xorpd  %xmm9,%xmm9
movsd  0x397e(%rip),%xmm4
mulsd  %xmm9,%xmm4
movsd  %xmm8,-0x8(%rbp,%rsi,8)
movsd  -0x8(%r12,%rsi,8),%xmm1
subsd  %xmm3,%xmm1
subsd  %xmm4,%xmm1
movsd  %xmm1,0x3923(%rip)
mov    %edi,%r15d
sub    %esi,%r15d
je     1734 <jtinvit_+0x614>
movsd  0x0(%r13,%rsi,8),%xmm9
lea    0x1(%rbx),%ecx
cmp    %ecx,%r8d
jne    216c <jtinvit_+0x104c>
ucomisd %xmm11,%xmm1
jne    1759 <jtinvit_+0x639>
jp     1759 <jtinvit_+0x639>
movsd  0x3947(%rip),%xmm1
movsd  %xmm1,0x38ef(%rip)
mov    0x1c0(%rsp),%r8
mov    0x88(%rsp),%r10
movsd  %xmm1,-0x8(%r8,%r10,8)
mov    0x1c8(%rsp),%r13
movq   $0x0,-0x8(%r13,%r10,8)
mov    0x1d0(%rsp),%r9
movq   $0x0,-0x8(%r9,%r10,8)
mov    0x38f4(%rip),%eax
mov    %eax,0x14(%rsp)
mov    0x389e(%rip),%ecx
mov    %ecx,0x44(%rsp)
mov    0x38db(%rip),%r15d
movsd  0x38ea(%rip),%xmm8
movslq 0x38b3(%rip),%rax
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%ebx
mov    0x20(%rsp),%r10
lea    0x1(%r10),%r11
mov    0xa0(%rsp),%r12
mov    0x8(%rsp),%rdi
lea    (%r12,%rdi,8),%rcx
mov    %rcx,0x158(%rsp)
lea    (%rdi,%r10,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x148(%rsp)
mov    %ebx,%esi
sub    %edi,%esi
mov    %r11,0xd8(%rsp)
movabs $0x1fffffffc,%rcx
and    %rcx,%r11
lea    -0x4(%r11),%rdx
mov    %rdx,0xc8(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %esi,0x94(%rsp)
and    $0x3,%esi
mov    %esi,0x4c(%rsp)
mov    %rdx,%rcx
mov    %rdx,0xc0(%rsp)
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdx
mov    %rdx,0xb0(%rsp)
mov    %ebx,%ecx
sub    %eax,%ecx
mov    %rcx,0x138(%rsp)
mov    0x78(%rsp),%rcx
lea    (%rcx,%r10,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x150(%rsp)
mov    %r11,0xd0(%rsp)
lea    (%r11,%rdi,1),%rdx
mov    %rdx,0xb8(%rsp)
lea    -0x1(%rdi),%r10d
mov    0x98(%rsp),%rsi
lea    (%rsi,%rdi,8),%r11
mov    0x14(%rsp),%esi
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0x140(%rsp)
lea    (%r12,%rax,8),%rcx
mov    %rcx,0x80(%rsp)
mov    0x130(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x70(%rsp)
mov    0x128(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x88(%rsp)
mov    0x120(%rsp),%rcx
mov    %rax,0xe0(%rsp)
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x160(%rsp)
mov    %r10d,0x34(%rsp)
jmp    1925 <jtinvit_+0x805>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm1,0x3730(%rip)
mov    0x14(%rsp),%esi
add    $0x1,%esi
mov    %esi,0x3767(%rip)
mov    0x18(%rsp),%rdx
cmp    0x38(%rsp),%edx
mov    %esi,0x14(%rsp)
jl     198b <jtinvit_+0x86b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm9,%xmm3
movapd %xmm1,%xmm9
movslq %edx,%rdx
movsd  -0x8(%rbp,%rdx,8),%xmm1
movsd  -0x8(%r13,%rdx,8),%xmm4
mulsd  %xmm9,%xmm4
mulsd  -0x8(%r9,%rdx,8),%xmm3
subsd  %xmm4,%xmm1
subsd  %xmm3,%xmm1
divsd  -0x8(%r8,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rdx,8)
add    $0xffffffff,%edx
cmp    %edx,%r10d
jne    1940 <jtinvit_+0x820>
movsd  %xmm1,0x36bd(%rip)
cmpl   $0x0,0x50(%rsp)
mov    0x78(%rsp),%r12
mov    0x18(%rsp),%rax
mov    0x38(%rsp),%r8
mov    0xe8(%rsp),%r10
jle    1cb0 <jtinvit_+0xb90>
mov    $0x1,%r13d
mov    0x44(%rsp),%r9d
jmp    19d2 <jtinvit_+0x8b2>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r13),%ecx
cmp    0x50(%rsp),%r13d
mov    %ecx,%r13d
je     1cb0 <jtinvit_+0xb90>
movslq %r9d,%rdx
lea    (%r10,%rdx,4),%rcx
imul   %r14d,%edx
nopl   (%rax)
add    $0xffffffff,%r9d
sub    %r14d,%edx
lea    -0x4(%rcx),%rsi
cmp    %r15d,(%rcx)
mov    %rsi,%rcx
jne    19e0 <jtinvit_+0x8c0>
cmp    %r8d,%eax
jl     19c0 <jtinvit_+0x8a0>
movslq %edx,%rsi
mov    0x4c(%rsp),%ecx
test   %ecx,%ecx
je     1a31 <jtinvit_+0x911>
lea    (%r12,%rsi,8),%rdi
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%rdx
movsd  -0x8(%rbp,%rdx,8),%xmm4
mulsd  (%rdi,%rdx,8),%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rdx
add    $0xffffffff,%ecx
jne    1a10 <jtinvit_+0x8f0>
cmpl   $0x3,0x20(%rsp)
jae    1a41 <jtinvit_+0x921>
jmp    1a97 <jtinvit_+0x977>
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%rdx
cmpl   $0x3,0x20(%rsp)
jb     1a97 <jtinvit_+0x977>
lea    (%r12,%rsi,8),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbp,%rdx,8),%xmm0
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  (%rdi,%rdx,8),%xmm0
mulsd  0x8(%rdi,%rdx,8),%xmm2
addsd  %xmm3,%xmm0
movsd  0x8(%rbp,%rdx,8),%xmm4
mulsd  0x10(%rdi,%rdx,8),%xmm4
addsd  %xmm0,%xmm2
movsd  0x10(%rbp,%rdx,8),%xmm3
mulsd  0x18(%rdi,%rdx,8),%xmm3
addsd  %xmm2,%xmm4
addsd  %xmm4,%xmm3
add    $0x4,%rdx
cmp    %edx,%ebx
jne    1a50 <jtinvit_+0x930>
cmp    %r8d,%eax
jl     19c0 <jtinvit_+0x8a0>
xorpd  %xmm12,%xmm3
mov    0x8(%rsp),%rdi
cmpl   $0x3,0x20(%rsp)
jb     1c20 <jtinvit_+0xb00>
mov    0x8(%rsp),%rcx
add    %rsi,%rcx
mov    0x150(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
cmp    %rdx,0x158(%rsp)
jae    1aea <jtinvit_+0x9ca>
lea    (%r12,%rcx,8),%rcx
mov    0x8(%rsp),%rdi
cmp    0x148(%rsp),%rcx
jb     1c20 <jtinvit_+0xb00>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0xc8(%rsp)
je     1b9d <jtinvit_+0xa7d>
mov    0x140(%rsp),%rax
lea    (%rax,%rsi,8),%r8
mov    0xb0(%rsp),%r10
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd (%r8,%rdx,8),%xmm5
movupd 0x10(%r8,%rdx,8),%xmm6
mulpd  %xmm4,%xmm5
movupd -0x30(%r11,%rdx,8),%xmm7
addpd  %xmm5,%xmm7
movupd -0x20(%r11,%rdx,8),%xmm5
movupd -0x10(%r11,%rdx,8),%xmm2
movupd (%r11,%rdx,8),%xmm0
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm7,-0x30(%r11,%rdx,8)
movupd %xmm6,-0x20(%r11,%rdx,8)
movupd 0x20(%r8,%rdx,8),%xmm5
movupd 0x30(%r8,%rdx,8),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm0,%xmm6
movupd %xmm5,-0x10(%r11,%rdx,8)
movupd %xmm6,(%r11,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r10
jne    1b20 <jtinvit_+0xa00>
jmp    1b9f <jtinvit_+0xa7f>
xor    %edx,%edx
testb  $0x1,0xc0(%rsp)
01
mov    0xe8(%rsp),%r10
mov    0x18(%rsp),%rax
mov    0x38(%rsp),%r8
je     1bf9 <jtinvit_+0xad9>
add    0x8(%rsp),%rdx
lea    (%rdx,%rsi,1),%rcx
movupd (%r12,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm2
movupd -0x8(%rbp,%rdx,8),%xmm5
movupd 0x8(%rbp,%rdx,8),%xmm6
mulpd  %xmm4,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm4,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm0,-0x8(%rbp,%rdx,8)
movupd %xmm2,0x8(%rbp,%rdx,8)
mov    0xb8(%rsp),%rdi
mov    0xd0(%rsp),%rcx
cmp    %rcx,0xd8(%rsp)
je     19c0 <jtinvit_+0x8a0>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ecx
sub    %edi,%ecx
test   $0x1,%cl
jne    1c36 <jtinvit_+0xb16>
mov    %rdi,%rdx
cmp    %edi,%eax
je     19c0 <jtinvit_+0x8a0>
jmp    1c5f <jtinvit_+0xb3f>
lea    (%rdi,%rsi,1),%rcx
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  -0x8(%rbp,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdi,8)
mov    %rdi,%rdx
add    $0x1,%rdx
cmp    %edi,%eax
je     19c0 <jtinvit_+0x8a0>
lea    (%r12,%rsi,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  -0x8(%rbp,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbp,%rdx,8)
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%ebx
jne    1c70 <jtinvit_+0xb50>
jmp    19c0 <jtinvit_+0x8a0>
nopl   0x0(%rax,%rax,1)
cmp    %r8d,%eax
jge    1cf0 <jtinvit_+0xbd0>
mov    0x14(%rsp),%ecx
cmp    $0x5,%ecx
mov    0x1d0(%rsp),%r9
mov    0x1c8(%rsp),%r13
mov    0x1c0(%rsp),%r8
mov    0x34(%rsp),%r10d
mov    0x80(%rsp),%rdi
jne    1e80 <jtinvit_+0xd60>
jmp    2090 <jtinvit_+0xf70>
nopl   0x0(%rax)
testb  $0x3,0x94(%rsp)
03
mov    0x4c(%rsp),%ecx
xorpd  %xmm3,%xmm3
je     1f36 <jtinvit_+0xe16>
mov    %ecx,%edx
mov    0x8(%rsp),%rsi
mov    0x1d0(%rsp),%r9
mov    0x1c8(%rsp),%r13
mov    0x1c0(%rsp),%r8
mov    0x34(%rsp),%r10d
mov    0x80(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rsi,8),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm12,%xmm2
xorpd  %xmm4,%xmm4
cmplesd %xmm0,%xmm4
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
addsd  %xmm4,%xmm3
add    $0x1,%rsi
add    $0xffffffff,%edx
jne    1d40 <jtinvit_+0xc20>
cmpl   $0x3,0x20(%rsp)
jb     1e2c <jtinvit_+0xd0c>
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rsi,8),%xmm0
movsd  0x0(%rbp,%rsi,8),%xmm2
movapd %xmm0,%xmm4
xorpd  %xmm13,%xmm4
xorpd  %xmm5,%xmm5
cmplesd %xmm0,%xmm5
andpd  %xmm5,%xmm0
andnpd %xmm4,%xmm5
orpd   %xmm0,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm2,%xmm0
xorpd  %xmm13,%xmm0
xorpd  %xmm3,%xmm3
cmplesd %xmm2,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
addsd  %xmm5,%xmm3
movsd  0x8(%rbp,%rsi,8),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm4,%xmm4
cmplesd %xmm0,%xmm4
andpd  %xmm4,%xmm0
andnpd %xmm2,%xmm4
orpd   %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbp,%rsi,8),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm13,%xmm2
xorpd  %xmm3,%xmm3
cmplesd %xmm0,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
addsd  %xmm4,%xmm3
add    $0x4,%rsi
cmp    %esi,%ebx
jne    1d80 <jtinvit_+0xc60>
ucomisd %xmm10,%xmm3
jae    20b4 <jtinvit_+0xf94>
mov    0x14(%rsp),%ecx
cmp    $0x5,%ecx
je     2090 <jtinvit_+0xf70>
ucomisd %xmm11,%xmm3
jne    1e4d <jtinvit_+0xd2d>
jnp    1e80 <jtinvit_+0xd60>
movapd %xmm8,%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,0x3222(%rip)
mov    0x38(%rsp),%rcx
cmp    %ecx,0x18(%rsp)
jge    1f70 <jtinvit_+0xe50>
mov    0x18(%rsp),%rdx
jmp    1ea5 <jtinvit_+0xd85>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x48(%rsp),%rcx
movsd  %xmm8,-0x8(%rbp,%rcx,8)
lea    0x1(%rcx),%esi
mov    0x18(%rsp),%rdx
cmp    %edx,%ecx
cmovge 0x38(%rsp),%esi
mov    %esi,0x48(%rsp)
mov    %esi,0x319f(%rip)
mov    0x70(%rsp),%rsi
cmp    %edx,0xe0(%rsp)
jg     1918 <jtinvit_+0x7f8>
mov    0xe0(%rsp),%rcx
movsd  -0x10(%rbp,%rcx,8),%xmm3
xor    %edx,%edx
mov    0x138(%rsp),%rcx
jmp    1f0b <jtinvit_+0xdeb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
movapd %xmm1,%xmm3
mov    0x88(%rsp),%r12
mulsd  (%r12,%rdx,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rdi,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%ecx
je     1910 <jtinvit_+0x7f0>
movsd  (%rdi,%rdx,8),%xmm1
mov    0x160(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
ucomisd (%rsi,%rdx,8),%xmm0
jne    1ee0 <jtinvit_+0xdc0>
jp     1ee0 <jtinvit_+0xdc0>
movsd  %xmm1,-0x8(%rdi,%rdx,8)
movapd %xmm1,%xmm4
movapd %xmm3,%xmm1
jmp    1ee8 <jtinvit_+0xdc8>
mov    0x8(%rsp),%rsi
mov    0x1d0(%rsp),%r9
mov    0x1c8(%rsp),%r13
mov    0x1c0(%rsp),%r8
mov    0x34(%rsp),%r10d
mov    0x80(%rsp),%rdi
cmpl   $0x3,0x20(%rsp)
jae    1d80 <jtinvit_+0xc60>
jmp    1e2c <jtinvit_+0xd0c>
mov    0x8(%rsp),%rcx
cmpl   $0x3,0x20(%rsp)
mov    0x70(%rsp),%rsi
jb     2060 <jtinvit_+0xf40>
movapd %xmm4,%xmm3
unpcklpd %xmm4,%xmm3
cmpq   $0x0,0xc8(%rsp)
je     2002 <jtinvit_+0xee2>
mov    0xb0(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x30(%r11,%rdx,8),%xmm0
movupd -0x20(%r11,%rdx,8),%xmm2
movupd -0x10(%r11,%rdx,8),%xmm5
movupd (%r11,%rdx,8),%xmm6
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm2
movupd %xmm0,-0x30(%r11,%rdx,8)
movupd %xmm2,-0x20(%r11,%rdx,8)
mulpd  %xmm3,%xmm5
mulpd  %xmm3,%xmm6
movupd %xmm5,-0x10(%r11,%rdx,8)
movupd %xmm6,(%r11,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1fb0 <jtinvit_+0xe90>
jmp    2004 <jtinvit_+0xee4>
xor    %edx,%edx
testb  $0x1,0xc0(%rsp)
mov    0x70(%rsp),%rsi
je     2038 <jtinvit_+0xf18>
add    0x8(%rsp),%rdx
movupd -0x8(%rbp,%rdx,8),%xmm0
movupd 0x8(%rbp,%rdx,8),%xmm2
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm2
movupd %xmm0,-0x8(%rbp,%rdx,8)
movupd %xmm2,0x8(%rbp,%rdx,8)
mov    0xb8(%rsp),%rcx
mov    0xd0(%rsp),%rdx
cmp    %rdx,0xd8(%rsp)
je     2078 <jtinvit_+0xf58>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rcx,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,-0x8(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%ebx
jne    2060 <jtinvit_+0xf40>
mov    0x18(%rsp),%rdx
cmp    %edx,0xe0(%rsp)
jg     1918 <jtinvit_+0x7f8>
jmp    1eb7 <jtinvit_+0xd97>
nop
mov    0x44(%rsp),%ecx
neg    %ecx
mov    0x1b8(%rsp),%rax
mov    %ecx,(%rax)
movq   $0x0,0x2fd5(%rip)
xorpd  %xmm3,%xmm3
jmp    2344 <jtinvit_+0x1224>
movq   $0x0,0x2f89(%rip)
xorpd  %xmm0,%xmm0
mov    0x18(%rsp),%rax
sub    0x38(%rsp),%eax
jl     2158 <jtinvit_+0x1038>
add    $0x1,%eax
xorpd  %xmm0,%xmm0
test   $0x3,%al
je     24ce <jtinvit_+0x13ae>
mov    0x8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0xffffffff,%ecx
jne    20f0 <jtinvit_+0xfd0>
cmpl   $0x3,0x20(%rsp)
jb     2150 <jtinvit_+0x1030>
xchg   %ax,%ax
movsd  -0x8(%rbp,%rax,8),%xmm1
movsd  0x0(%rbp,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x10(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %eax,%ebx
jne    2110 <jtinvit_+0xff0>
movsd  %xmm0,0x2ef0(%rip)
ucomisd %xmm11,%xmm0
jb     2315 <jtinvit_+0x11f5>
sqrtsd %xmm0,%xmm0
jmp    232c <jtinvit_+0x120c>
mov    0x118(%rsp),%rax
lea    (%rax,%rsi,8),%rbx
mov    %rsi,%r13
not    %r13
add    %rdx,%r13
lea    0x0(,%rsi,8),%r9
add    %rbp,%r9
lea    (%r12,%rsi,8),%rdx
mov    0x1d8(%rsp),%rcx
lea    (%rcx,%rsi,8),%r11
mov    0x110(%rsp),%rax
lea    (%rax,%rsi,8),%r12
mov    0x108(%rsp),%rax
lea    (%rax,%rsi,8),%rdi
mov    0x100(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
xor    %r8d,%r8d
jmp    220a <jtinvit_+0x10ea>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm9,%xmm0
movapd %xmm1,%xmm2
mulsd  (%rdi,%r8,8),%xmm1
xorpd  %xmm12,%xmm2
subsd  %xmm1,%xmm0
movsd  %xmm0,0x2e58(%rip)
mulsd  %xmm4,%xmm2
movapd %xmm0,%xmm1
movapd %xmm2,%xmm9
add    $0x1,%r8
cmp    %r8d,%r15d
je     1740 <jtinvit_+0x620>
movsd  %xmm8,(%r9,%r8,8)
movsd  -0x8(%rbx,%r8,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm13,%xmm5
xorpd  %xmm6,%xmm6
cmplesd %xmm4,%xmm6
movapd %xmm6,%xmm7
andpd  %xmm4,%xmm7
andnpd %xmm5,%xmm6
orpd   %xmm7,%xmm6
movapd %xmm1,%xmm5
xorpd  %xmm13,%xmm5
xorpd  %xmm7,%xmm7
cmplesd %xmm1,%xmm7
movapd %xmm7,%xmm2
andnpd %xmm5,%xmm2
andpd  %xmm1,%xmm7
orpd   %xmm2,%xmm7
ucomisd %xmm6,%xmm7
jbe    22c0 <jtinvit_+0x11a0>
divsd  %xmm1,%xmm4
movsd  %xmm4,0x2e13(%rip)
movsd  %xmm4,(%r11,%r8,8)
movsd  %xmm1,(%r12,%r8,8)
movsd  %xmm9,(%rdi,%r8,8)
movq   $0x0,(%rsi,%r8,8)
movsd  (%rdx,%r8,8),%xmm1
subsd  %xmm3,%xmm1
mulsd  %xmm9,%xmm4
subsd  %xmm4,%xmm1
movsd  %xmm1,0x2da6(%rip)
cmp    %r8,%r13
je     21fd <jtinvit_+0x10dd>
movsd  (%rbx,%r8,8),%xmm9
jmp    21fd <jtinvit_+0x10dd>
cs nopw 0x0(%rax,%rax,1)
divsd  %xmm4,%xmm1
movsd  %xmm1,0x2db4(%rip)
movsd  %xmm1,(%r11,%r8,8)
movsd  -0x8(%rbx,%r8,8),%xmm2
movsd  %xmm2,(%r12,%r8,8)
movsd  (%rdx,%r8,8),%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rdi,%r8,8)
movq   $0x0,(%rsi,%r8,8)
xorpd  %xmm4,%xmm4
cmp    %r8,%r13
je     21d0 <jtinvit_+0x10b0>
movsd  (%rbx,%r8,8),%xmm4
movsd  %xmm4,(%rsi,%r8,8)
jmp    21d0 <jtinvit_+0x10b0>
call   1040 <sqrt@plt>
movapd 0xcfd(%rip),%xmm13
movsd  0xcd4(%rip),%xmm10
movapd %xmm10,%xmm3
divsd  %xmm0,%xmm3
movsd  %xmm3,0x2d43(%rip)
mov    0x2d44(%rip),%r15d
mov    0xa8(%rsp),%rax
mov    (%rax),%ebx
test   %ebx,%ebx
jle    2397 <jtinvit_+0x1277>
movslq 0x2ce7(%rip),%rax
imul   %r14,%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
add    $0x8,%rdi
lea    0x0(,%rbx,8),%rdx
xor    %esi,%esi
movapd %xmm3,0x50(%rsp)
call   1030 <memset@plt>
movapd 0x50(%rsp),%xmm3
movapd 0xc92(%rip),%xmm13
movsd  0xc69(%rip),%xmm10
mov    %rbx,0x50(%rsp)
mov    0x2c99(%rip),%r10d
mov    0x2c8f(%rip),%eax
mov    %r10,%r8
mov    0x2c8d(%rip),%r13d
mov    %rax,%r12
sub    %eax,%r10d
mov    0x78(%rsp),%rax
jl     1330 <jtinvit_+0x210>
movslq %r12d,%rsi
mov    %r13d,%ecx
imul   %r14d,%ecx
movslq %ecx,%r9
cmp    $0x3,%r10d
jb     2530 <jtinvit_+0x1410>
lea    (%rsi,%r9,1),%rcx
lea    (%rax,%rcx,8),%rbx
lea    (%rsi,%r10,1),%rdx
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
cmp    %rdx,%rbx
jae    2417 <jtinvit_+0x12f7>
add    %r10,%rcx
lea    (%rax,%rcx,8),%rcx
add    $0x8,%rcx
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
cmp    %rcx,%rdx
jb     2530 <jtinvit_+0x1410>
mov    %r9,0x8(%rsp)
add    $0x1,%r10
mov    %r10,%rdx
movabs $0x1fffffffc,%rcx
and    %rcx,%rdx
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
mov    %rdx,0x20(%rsp)
lea    -0x4(%rdx),%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     24e3 <jtinvit_+0x13c3>
mov    %r11,%rdx
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdx
mov    0x98(%rsp),%rcx
lea    (%rcx,%rsi,8),%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%r9,%rdi,8),%xmm1
movupd -0x20(%r9,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rbx,%rdi,8)
movupd %xmm2,0x10(%rbx,%rdi,8)
movupd -0x10(%r9,%rdi,8),%xmm1
movupd (%r9,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rbx,%rdi,8)
movupd %xmm2,0x30(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    2480 <jtinvit_+0x1360>
jmp    24e5 <jtinvit_+0x13c5>
mov    0x8(%rsp),%rax
cmpl   $0x3,0x20(%rsp)
jae    2110 <jtinvit_+0xff0>
jmp    2150 <jtinvit_+0x1030>
xor    %edi,%edi
test   $0x1,%r11b
mov    0x8(%rsp),%r9
je     2515 <jtinvit_+0x13f5>
add    %rsi,%rdi
movupd -0x8(%rbp,%rdi,8),%xmm1
movupd 0x8(%rbp,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
add    %r9,%rdi
movupd %xmm1,(%rax,%rdi,8)
movupd %xmm2,0x10(%rax,%rdi,8)
mov    0x20(%rsp),%rcx
cmp    %rcx,%r10
je     1330 <jtinvit_+0x210>
add    %rcx,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rcx
lea    0x1(%r8),%ebx
mov    %ebx,%edi
sub    %esi,%edi
mov    %ecx,%edx
sub    %esi,%edx
and    $0x3,%edi
je     2568 <jtinvit_+0x1448>
lea    (%rax,%r9,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffff,%edi
jne    2550 <jtinvit_+0x1430>
cmp    $0x3,%edx
jb     1330 <jtinvit_+0x210>
mov    %ebx,%edx
lea    (%rax,%r9,8),%rdi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
movsd  0x0(%rbp,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%rdi,%rsi,8)
movsd  0x8(%rbp,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%rdi,%rsi,8)
movsd  0x10(%rbp,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x18(%rdi,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%edx
jne    2580 <jtinvit_+0x1460>
jmp    1330 <jtinvit_+0x210>
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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