void trafontspcmpc(double *n, double *t, double *n2, double *that,
                   int *islavnodeentry, int *nboun, int *ndirboun,
                   int *nodeboun, double *xboun, int *nmpc, int *ipompc,
                   int *nodempc, double *coefmpc, int *ikboun, int *ilboun,
                   int *ikmpc, int *ilmpc, int *nslavspc, int *islavspc,
                   int *nsspc, int *nslavmpc, int *islavmpc, int *nsmpc,
                   int *nmastspc, int *imastspc, int *nmspc, int *nmastmpc,
                   int *imastmpc, int *nmmpc, int *debug, int *node) {
  int jj, kk, ist, dir, node1, index, dirind, dirdep, nt1;
  double dist, nn, coefdep;
  for (jj = nslavspc[2 * (*islavnodeentry - 1)];
       jj < nslavspc[2 * (*islavnodeentry - 1) + 1]; jj++) {
    t[0] = 0;
    t[1] = 0;
    t[2] = 0;
    ist = islavspc[2 * jj];
    dir = ndirboun[ist - 1];
    node1 = nodeboun[ist - 1];
    if (*debug == 1) {
      printf("jj %"
             "d"
             " ist %"
             "d"
             " dir %"
             "d"
             " node %"
             "d"
             "\n",
             jj, ist, dir, node1);
    }
    t[dir - 1] = 1.0;
    dist = t[0] * n[0] + t[1] * n[1] + t[2] * n[2];
    n[0] = n[0] - dist * t[0];
    n[1] = n[1] - dist * t[1];
    n[2] = n[2] - dist * t[2];
    nn = sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
    n[0] = n[0] / nn;
    n[1] = n[1] / nn;
    n[2] = n[2] / nn;
  }
  for (jj = nslavmpc[2 * (*islavnodeentry - 1)];
       jj < nslavmpc[2 * (*islavnodeentry - 1) + 1]; jj++) {
    t[0] = 0;
    t[1] = 0;
    t[2] = 0;
    ist = islavmpc[2 * jj];
    dirdep = nodempc[3 * (ist - 1) + 1];
    coefdep = coefmpc[ist - 1];
    index = nodempc[3 * (ist - 1) + 2];
    node1 = nodempc[3 * (ist - 1)];
    t[dirdep - 1] = coefdep;
    if (*debug == 1) {
      printf("jj %"
             "d"
             " ist %"
             "d"
             " dir %"
             "d"
             " node %"
             "d"
             " coef %e\n",
             jj, ist, dirdep, node1, coefdep);
    }
    while (index != 0) {
      dirind = nodempc[3 * (index - 1) + 1];
      node1 = nodempc[3 * (index - 1)];
      if (node1 == *node)
        t[dirind - 1] = coefmpc[index - 1];
      index = nodempc[3 * (index - 1) + 2];
      if (*debug == 1) {
        printf("index %"
               "d"
               " \n",
               index);
      }
    }
    nt1 = sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
    t[0] = t[0] / nt1;
    t[1] = t[1] / nt1;
    t[2] = t[2] / nt1;
    dist = t[0] * n[0] + t[1] * n[1] + t[2] * n[2];
    n[0] = n[0] - dist * t[0];
    n[1] = n[1] - dist * t[1];
    n[2] = n[2] - dist * t[2];
    nn = sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
    n[0] = n[0] / nn;
    n[1] = n[1] / nn;
    n[2] = n[2] / nn;
  }
  if (nslavspc[2 * (*islavnodeentry - 1) + 1] -
              nslavspc[2 * (*islavnodeentry - 1)] >
          0 ||
      nslavmpc[2 * (*islavnodeentry - 1) + 1] -
              nslavmpc[2 * (*islavnodeentry - 1)] >
          0) {
    t[3] = n[1] * t[2] - n[2] * t[1];
    t[4] = n[2] * t[0] - n[0] * t[2];
    t[5] = n[0] * t[1] - n[1] * t[0];
    for (kk = 0; kk < 6; kk++) {
      that[kk] = t[kk];
    }
    for (jj = nslavmpc[2 * (*islavnodeentry - 1)];
         jj < nslavmpc[2 * (*islavnodeentry - 1) + 1]; jj++) {
      ist = islavmpc[2 * jj];
      dirdep = nodempc[3 * (ist - 1) + 1];
      coefdep = coefmpc[ist - 1];
      index = nodempc[3 * (ist - 1) + 2];
      node1 = nodempc[3 * (ist - 1)];
      while (index != 0) {
        dirind = nodempc[3 * (index - 1) + 1];
        node1 = nodempc[3 * (index - 1)];
        if (node1 == *node) {
          t[dirind - 1 + 3] = t[dirind - 1 + 3] -
                              coefmpc[index - 1] * t[dirdep - 1 + 3] / coefdep;
          n[dirind - 1] =
              n[dirind - 1] - coefmpc[index - 1] * n[dirdep - 1] / coefdep;
        }
        index = nodempc[3 * (index - 1) + 2];
      }
      t[dirdep - 1 + 3] = 0.0;
      n[dirdep - 1] = 0.0;
    }
    nn = sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);
    nt1 = sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
    if (*debug == 1) {
      printf("n= %e %e %e \n", n[0], n[1], n[2]);
      printf("t1= %e %e %e \n", t[0], t[1], t[2]);
      printf("t2= %e %e %e \n", t[3], t[4], t[5]);
    }
  }
  if (*debug == 1) {
    printf("n= %e %e %e \n", n[0], n[1], n[2]);
    printf("t1= %e %e %e \n", t[0], t[1], t[2]);
    printf("t2= %e %e %e \n", t[3], t[4], t[5]);
  }
  return;
}


x86 assembly (clang, -O0):
<trafontspcmpc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0xd0(%rbp),%rax
mov    0xc8(%rbp),%rax
mov    0xc0(%rbp),%rax
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
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    0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x68(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1443 <trafontspcmpc+0x323>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1287 <trafontspcmpc+0x167>
mov    -0x34(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x40(%rbp),%ecx
mov    -0x44(%rbp),%r8d
lea    0xd88(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xd64(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11de <trafontspcmpc+0xbe>
mov    0x80(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x80(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1857 <trafontspcmpc+0x737>
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
mov    0x88(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1563 <trafontspcmpc+0x443>
mov    -0x34(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x50(%rbp),%ecx
mov    -0x44(%rbp),%r8d
movsd  -0x70(%rbp),%xmm0
lea    0xac9(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    1568 <trafontspcmpc+0x448>
cmpl   $0x0,-0x48(%rbp)
je     1616 <trafontspcmpc+0x4f6>
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0xd0(%rbp),%rcx
cmp    (%rcx),%eax
jne    15d7 <trafontspcmpc+0x4b7>
mov    0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1611 <trafontspcmpc+0x4f1>
mov    -0x48(%rbp),%esi
lea    0xa40(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1568 <trafontspcmpc+0x448>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    145f <trafontspcmpc+0x33f>
mov    0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x68(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
shl    $0x1,%edx
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
cmp    $0x0,%eax
jg     18cd <trafontspcmpc+0x7ad>
mov    0x80(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x80(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
shl    $0x1,%edx
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
cmp    $0x0,%eax
jle    1d17 <trafontspcmpc+0xbf7>
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movl   $0x0,-0x38(%rbp)
cmpl   $0x6,-0x38(%rbp)
jge    19e6 <trafontspcmpc+0x8c6>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19b4 <trafontspcmpc+0x894>
mov    0x80(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x80(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    (%rdx),%edx
sub    $0x1,%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1beb <trafontspcmpc+0xacb>
mov    0x88(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     1bb0 <trafontspcmpc+0xa90>
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0xd0(%rbp),%rcx
cmp    (%rcx),%eax
jne    1b92 <trafontspcmpc+0xa72>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x70(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x70(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
jmp    1a9c <trafontspcmpc+0x97c>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a02 <trafontspcmpc+0x8e2>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x54(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1d12 <trafontspcmpc+0xbf2>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x39b(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x381(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
lea    0x367(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
jmp    1d17 <trafontspcmpc+0xbf7>
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1da0 <trafontspcmpc+0xc80>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x30d(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x2f3(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
lea    0x2d9(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trafontspcmpc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,0x38(%rsp)
mov    %rsi,%r15
mov    %rdi,%r14
mov    0x150(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    0x148(%rsp),%rbx
mov    0x108(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x100(%rsp),%rax
mov    %rax,(%rsp)
mov    0xe8(%rsp),%rsi
mov    0xc0(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0xb8(%rsp),%r12
mov    %r8,0x28(%rsp)
mov    (%r8),%eax
lea    -0x2(%rax,%rax,1),%ecx
movslq %ecx,%rcx
movslq (%rsi,%rcx,4),%r13
lea    (%rax,%rax,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
mov    %rsi,0x18(%rsp)
cmp    (%rsi,%rdx,4),%r13d
jge    1335 <trafontspcmpc+0x215>
mov    %rbx,0x10(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0x48(%rsp)
lea    0x0(%r13,%r13,1),%ebx
jmp    1244 <trafontspcmpc+0x124>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1040 <sqrt@plt>
movupd (%r14),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,(%r14)
movsd  0x10(%r14),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14)
add    $0x1,%r13
mov    0x28(%rsp),%rax
mov    (%rax),%eax
lea    (%rax,%rax,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rdx
mov    0x18(%rsp),%rcx
movslq (%rcx,%rdx,4),%rcx
add    $0x2,%ebx
cmp    %rcx,%r13
jge    1339 <trafontspcmpc+0x219>
movslq %ebx,%rax
xorps  %xmm0,%xmm0
movups %xmm0,(%r15)
movq   $0x0,0x10(%r15)
mov    0x50(%rsp),%rcx
movslq (%rcx,%rax,4),%rdx
mov    0x48(%rsp),%rax
movslq -0x4(%rax,%rdx,4),%rbp
mov    0x10(%rsp),%rax
cmpl   $0x1,(%rax)
jne    1290 <trafontspcmpc+0x170>
mov    0x40(%rsp),%rax
mov    -0x4(%rax,%rdx,4),%r8d
lea    0xd94(%rip),%rdi
mov    %r13d,%esi
mov    %ebp,%ecx
xor    %eax,%eax
call   1030 <printf@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x8(%r15,%rbp,8)
movsd  (%r15),%xmm3
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm2
movsd  0x8(%r15),%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm3,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
movsd  0x10(%r14),%xmm0
movsd  0x10(%r15),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm5,%xmm3
subsd  %xmm3,%xmm1
movsd  %xmm1,(%r14)
movsd  0x8(%r15),%xmm3
mulsd  %xmm5,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x8(%r14)
mulsd  0x10(%r15),%xmm5
subsd  %xmm5,%xmm0
movsd  %xmm0,0x10(%r14)
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xcea(%rip),%xmm0
jb     11f0 <trafontspcmpc+0xd0>
sqrtsd %xmm0,%xmm0
jmp    11f5 <trafontspcmpc+0xd5>
add    %eax,%eax
jmp    1346 <trafontspcmpc+0x226>
add    %eax,%eax
lea    -0x2(%rax),%ecx
movslq %ecx,%rcx
mov    0x10(%rsp),%rbx
mov    (%rsp),%rdi
movslq (%rdi,%rcx,4),%r13
mov    (%rdi,%rdx,4),%ecx
cmp    %ecx,%r13d
jl     13b0 <trafontspcmpc+0x290>
jmp    1576 <trafontspcmpc+0x456>
nopl   0x0(%rax,%rax,1)
call   1040 <sqrt@plt>
movupd (%r14),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,(%r14)
movsd  0x10(%r14),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14)
add    $0x1,%r13
mov    0x28(%rsp),%rax
mov    (%rax),%eax
lea    (%rax,%rax,1),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rdx
mov    (%rsp),%rcx
movslq (%rcx,%rdx,4),%rcx
cmp    %rcx,%r13
jge    1570 <trafontspcmpc+0x450>
lea    0x0(%r13,%r13,1),%eax
cltq
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r15)
movq   $0x0,0x10(%r15)
mov    0x20(%rsp),%rcx
movslq (%rcx,%rax,4),%rdx
lea    -0x1(%rdx),%rax
lea    (%rax,%rax,2),%rsi
movslq 0x4(%r12,%rsi,4),%rcx
cltq
mov    0x8(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm0
movslq %esi,%rax
mov    (%r12,%rax,4),%r8d
mov    0x8(%r12,%rax,4),%ebp
movsd  %xmm0,-0x8(%r15,%rcx,8)
cmpl   $0x1,(%rbx)
jne    1469 <trafontspcmpc+0x349>
lea    0xc2c(%rip),%rdi
mov    %r13d,%esi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    1469 <trafontspcmpc+0x349>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffff,%ebp
lea    0x0(%rbp,%rbp,2),%eax
cltq
mov    (%r12,%rax,4),%ecx
mov    0x30(%rsp),%rdx
cmp    (%rdx),%ecx
jne    144f <trafontspcmpc+0x32f>
movslq 0x4(%r12,%rax,4),%rcx
movslq %ebp,%rdx
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rcx,8)
mov    0x8(%r12,%rax,4),%ebp
cmpl   $0x1,(%rbx)
jne    1469 <trafontspcmpc+0x349>
lea    0xbfa(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1030 <printf@plt>
test   %ebp,%ebp
jne    1420 <trafontspcmpc+0x300>
movsd  (%r15),%xmm1
movsd  0x8(%r15),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x10(%r15),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xb76(%rip),%xmm0
jb     14b0 <trafontspcmpc+0x390>
sqrtsd %xmm0,%xmm0
jmp    14b5 <trafontspcmpc+0x395>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   1040 <sqrt@plt>
cvttpd2dq %xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
movupd (%r15),%xmm4
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
divpd  %xmm1,%xmm4
movupd %xmm4,(%r15)
movsd  0x10(%r15),%xmm3
divsd  %xmm0,%xmm3
movsd  %xmm3,0x10(%r15)
movsd  (%r14),%xmm1
movsd  0x8(%r14),%xmm2
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm4,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm0,%xmm5
movsd  0x10(%r14),%xmm0
mulsd  %xmm0,%xmm3
addsd  %xmm5,%xmm3
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm1
movsd  %xmm1,(%r14)
movsd  0x8(%r15),%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%r14)
mulsd  0x10(%r15),%xmm3
subsd  %xmm3,%xmm0
movsd  %xmm0,0x10(%r14)
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd 0xaaf(%rip),%xmm0
jb     1360 <trafontspcmpc+0x240>
sqrtsd %xmm0,%xmm0
jmp    1365 <trafontspcmpc+0x245>
add    %eax,%eax
mov    (%rsp),%rdi
add    $0xfffffffe,%eax
mov    0x18(%rsp),%rbp
mov    0x0(%rbp,%rdx,4),%edx
movslq %eax,%rsi
mov    (%rdi,%rsi,4),%eax
cmp    0x0(%rbp,%rsi,4),%edx
jg     15a0 <trafontspcmpc+0x480>
cmp    %eax,%ecx
jg     15a0 <trafontspcmpc+0x480>
cmpl   $0x1,(%rbx)
je     17bc <trafontspcmpc+0x69c>
jmp    1828 <trafontspcmpc+0x708>
movsd  0x10(%r15),%xmm0
movsd  (%r15),%xmm1
movsd  0x8(%r15),%xmm2
movsd  0x10(%r14),%xmm3
mulsd  %xmm2,%xmm3
movsd  0x8(%r14),%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,0x18(%r15)
mulsd  (%r14),%xmm0
movsd  0x10(%r14),%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,0x20(%r15)
movsd  0x8(%r14),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%r14),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x28(%r15)
mov    0x38(%rsp),%rdx
movsd  %xmm1,(%rdx)
movsd  0x8(%r15),%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  0x10(%r15),%xmm0
movsd  %xmm0,0x10(%rdx)
movsd  0x18(%r15),%xmm0
movsd  %xmm0,0x18(%rdx)
movsd  0x20(%r15),%xmm0
movsd  %xmm0,0x20(%rdx)
movsd  0x28(%r15),%xmm0
movsd  %xmm0,0x28(%rdx)
cmp    %ecx,%eax
jge    1750 <trafontspcmpc+0x630>
movslq %eax,%r10
movslq %ecx,%r8
jmp    168b <trafontspcmpc+0x56b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r11),%ecx
add    $0x2,%r11
movslq %ecx,%rsi
mov    %r11,%r9
movq   $0x0,(%r15,%r9,8)
movq   $0x0,(%r14,%rsi,8)
add    $0x1,%r10
cmp    %r8,%r10
je     1750 <trafontspcmpc+0x630>
lea    (%r10,%r10,1),%ecx
movslq %ecx,%rcx
mov    0x20(%rsp),%rax
movslq (%rax,%rcx,4),%rsi
add    $0xffffffffffffffff,%rsi
lea    (%rsi,%rsi,2),%rcx
movslq 0x4(%r12,%rcx,4),%r11
movslq %ecx,%rcx
mov    0x8(%r12,%rcx,4),%ecx
test   %ecx,%ecx
je     1660 <trafontspcmpc+0x540>
movslq %esi,%rsi
mov    0x8(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm0
mov    0x30(%rsp),%rax
mov    (%rax),%ebp
lea    -0x1(%r11),%esi
lea    0x2(%r11),%r9
movslq %esi,%rsi
jmp    16e9 <trafontspcmpc+0x5c9>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%r12,%rdi,4),%ecx
test   %ecx,%ecx
je     166e <trafontspcmpc+0x54e>
add    $0xffffffff,%ecx
lea    (%rcx,%rcx,2),%edi
movslq %edi,%rdi
cmp    %ebp,(%r12,%rdi,4)
jne    16e0 <trafontspcmpc+0x5c0>
movslq 0x4(%r12,%rdi,4),%rax
movsd  0x10(%r15,%rax,8),%xmm1
movslq %ecx,%rcx
mov    %rbx,%rdx
mov    0x8(%rsp),%rbx
movsd  (%rbx,%rcx,8),%xmm2
mulsd  0x10(%r15,%r11,8),%xmm2
divsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%r15,%rax,8)
movsd  (%rbx,%rcx,8),%xmm1
mov    %rdx,%rbx
mulsd  (%r14,%rsi,8),%xmm1
movsd  -0x8(%r14,%rax,8),%xmm2
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%r14,%rax,8)
jmp    16e0 <trafontspcmpc+0x5c0>
cmpl   $0x1,(%rbx)
jne    1828 <trafontspcmpc+0x708>
movsd  (%r14),%xmm0
movsd  0x8(%r14),%xmm1
movsd  0x10(%r14),%xmm2
lea    0x8f4(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  (%r15),%xmm0
movsd  0x8(%r15),%xmm1
movsd  0x10(%r15),%xmm2
lea    0x8e3(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  0x18(%r15),%xmm0
movsd  0x20(%r15),%xmm1
movsd  0x28(%r15),%xmm2
lea    0x8d2(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
cmpl   $0x1,(%rbx)
jne    1828 <trafontspcmpc+0x708>
movsd  (%r14),%xmm0
movsd  0x8(%r14),%xmm1
movsd  0x10(%r14),%xmm2
lea    0x891(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  (%r15),%xmm0
movsd  0x8(%r15),%xmm1
movsd  0x10(%r15),%xmm2
lea    0x880(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
movsd  0x18(%r15),%xmm0
movsd  0x20(%r15),%xmm1
movsd  0x28(%r15),%xmm2
lea    0x86f(%rip),%rdi
mov    $0x3,%al
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [29 x i8] c"jj %d ist %d dir %d node %d\0A\00"
@.str.1 = [37 x i8] c"jj %d ist %d dir %d node %d coef %e\0A\00"
@.str.2 = [11 x i8] c"index %d \0A\00"
@.str.3 = [14 x i8] c"n= %e %e %e \0A\00"
@.str.4 = [15 x i8] c"t1= %e %e %e \0A\00"
@.str.5 = [15 x i8] c"t2= %e %e %e \0A\00"
define void @trafontspcmpc(double* %0, double* %1, double* nocapture readnone %2, double* nocapture writeonly %3, i32* nocapture %4, i32* nocapture readnone %5, i32* nocapture %6, i32* nocapture %7, double* nocapture readnone %8, i32* nocapture readnone %9, i32* nocapture readnone %10, i32* nocapture %11, double* nocapture %12, i32* nocapture readnone %13, i32* nocapture readnone %14, i32* nocapture readnone %15, i32* nocapture readnone %16, i32* nocapture %17, i32* nocapture %18, i32* nocapture readnone %19, i32* nocapture %20, i32* nocapture %21, i32* nocapture readnone %22, i32* nocapture readnone %23, i32* nocapture readnone %24, i32* nocapture readnone %25, i32* nocapture readnone %26, i32* nocapture readnone %27, i32* nocapture readnone %28, i32* nocapture %29, i32* nocapture %30) {
%32 = load i32, i32* %4
%33 = shl i32 %32, 1
%34 = add i32 %33, -2
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %17, i64 %35
%37 = load i32, i32* %36
%38 = add i32 %33, -1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %17, i64 %39
%41 = load i32, i32* %40
%42 = icmp slt i32 %37, %41
br i1 %42, label %43, label %110
43: ; preds = %31
%44 = getelementptr inbounds double, double* %1, i64 1
%45 = getelementptr inbounds double, double* %1, i64 2
%46 = getelementptr inbounds double, double* %0, i64 1
%47 = getelementptr inbounds double, double* %0, i64 2
%48 = sext i32 %37 to i64
%49 = bitcast double* %1 to i8*
%50 = bitcast double* %0 to <2 x double>*
%51 = bitcast double* %0 to <2 x double>*
br label %52
52: ; preds = %43, %69
%53 = phi i64 [ %48, %43 ], [ %98, %69 ]
%54 = trunc i64 %53 to i32
%55 = shl nsw i32 %54, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %18, i64 %56
%58 = load i32, i32* %57
%59 = add nsw i32 %58, -1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %6, i64 %60
%62 = load i32, i32* %61
%63 = load i32, i32* %29
%64 = icmp eq i32 %63, 1
br i1 %64, label %65, label %69
65: ; preds = %52
%66 = getelementptr inbounds i32, i32* %7, i64 %60
%67 = load i32, i32* %66
%68 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), i32 %54, i32 %58, i32 %62, i32 %67)
br label %69
69: ; preds = %65, %52
%70 = add nsw i32 %62, -1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds double, double* %1, i64 %71
store double 1.000000e+00, double* %72
%73 = load double, double* %1
%74 = load double, double* %0
%75 = load double, double* %44
%76 = load double, double* %46
%77 = fmul double %75, %76
%78 = tail call double @llvm.fmuladd.f64(double %73, double %74, double %77)
%79 = load double, double* %45
%80 = load double, double* %47
%81 = tail call double @llvm.fmuladd.f64(double %79, double %80, double %78)
%82 = fneg double %81
%83 = tail call double @llvm.fmuladd.f64(double %82, double %73, double %74)
store double %83, double* %0
%84 = load double, double* %44
%85 = tail call double @llvm.fmuladd.f64(double %82, double %84, double %76)
store double %85, double* %46
%86 = load double, double* %45
%87 = tail call double @llvm.fmuladd.f64(double %82, double %86, double %80)
store double %87, double* %47
%88 = fmul double %85, %85
%89 = tail call double @llvm.fmuladd.f64(double %83, double %83, double %88)
%90 = tail call double @llvm.fmuladd.f64(double %87, double %87, double %89)
%91 = tail call double @sqrt(double %90)
%92 = load <2 x double>, <2 x double>* %50
%93 = insertelement <2 x double> poison, double %91, i64 0
%94 = shufflevector <2 x double> %93, <2 x double> poison, <2 x i32> zeroinitializer
%95 = fdiv <2 x double> %92, %94
store <2 x double> %95, <2 x double>* %51
%96 = load double, double* %47
%97 = fdiv double %96, %91
store double %97, double* %47
%98 = add nsw i64 %53, 1
%99 = load i32, i32* %4
%100 = shl i32 %99, 1
%101 = add i32 %100, -1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %17, i64 %102
%104 = load i32, i32* %103
%105 = sext i32 %104 to i64
%106 = icmp slt i64 %98, %105
br i1 %106, label %52, label %107
107: ; preds = %69
%108 = add i32 %100, -2
%109 = sext i32 %108 to i64
br label %110
110: ; preds = %107, %31
%111 = phi i32 [ %100, %107 ], [ %33, %31 ]
%112 = phi i64 [ %109, %107 ], [ %35, %31 ]
%113 = phi i64 [ %102, %107 ], [ %39, %31 ]
%114 = getelementptr inbounds i32, i32* %20, i64 %112
%115 = load i32, i32* %114
%116 = getelementptr inbounds i32, i32* %20, i64 %113
%117 = load i32, i32* %116
%118 = icmp slt i32 %115, %117
br i1 %118, label %119, label %242
119: ; preds = %110
%120 = getelementptr inbounds double, double* %1, i64 1
%121 = getelementptr inbounds double, double* %1, i64 2
%122 = getelementptr inbounds double, double* %0, i64 1
%123 = getelementptr inbounds double, double* %0, i64 2
%124 = sext i32 %115 to i64
%125 = bitcast double* %1 to i8*
%126 = bitcast double* %1 to <2 x double>*
%127 = bitcast double* %1 to <2 x double>*
%128 = bitcast double* %0 to <2 x double>*
%129 = bitcast double* %0 to <2 x double>*
br label %130
130: ; preds = %119, %193
%131 = phi i64 [ %124, %119 ], [ %233, %193 ]
%132 = trunc i64 %131 to i32
%133 = shl nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %21, i64 %134
%136 = load i32, i32* %135
%137 = add nsw i32 %136, -1
%138 = mul nsw i32 %137, 3
%139 = add nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %11, i64 %140
%142 = load i32, i32* %141
%143 = sext i32 %137 to i64
%144 = getelementptr inbounds double, double* %12, i64 %143
%145 = load double, double* %144
%146 = add nsw i32 %138, 2
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %11, i64 %147
%149 = load i32, i32* %148
%150 = sext i32 %138 to i64
%151 = getelementptr inbounds i32, i32* %11, i64 %150
%152 = load i32, i32* %151
%153 = add nsw i32 %142, -1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double, double* %1, i64 %154
store double %145, double* %155
%156 = load i32, i32* %29
%157 = icmp eq i32 %156, 1
br i1 %157, label %158, label %160
158: ; preds = %130
%159 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i32 %132, i32 %136, i32 %142, i32 %152, double %145)
br label %160
160: ; preds = %158, %130
%161 = icmp eq i32 %149, 0
br i1 %161, label %193, label %162
162: ; preds = %160, %191
%163 = phi i32 [ %186, %191 ], [ %149, %160 ]
%164 = add nsw i32 %163, -1
%165 = mul nsw i32 %164, 3
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %11, i64 %166
%168 = load i32, i32* %167
%169 = load i32, i32* %30
%170 = icmp eq i32 %168, %169
br i1 %170, label %171, label %182
171: ; preds = %162
%172 = add nsw i32 %165, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32, i32* %11, i64 %173
%175 = load i32, i32* %174
%176 = sext i32 %164 to i64
%177 = getelementptr inbounds double, double* %12, i64 %176
%178 = load double, double* %177
%179 = add nsw i32 %175, -1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %1, i64 %180
store double %178, double* %181
br label %182
182: ; preds = %171, %162
%183 = add nsw i32 %165, 2
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32, i32* %11, i64 %184
%186 = load i32, i32* %185
%187 = load i32, i32* %29
%188 = icmp eq i32 %187, 1
br i1 %188, label %189, label %191
189: ; preds = %182
%190 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i32 %186)
br label %191
191: ; preds = %189, %182
%192 = icmp eq i32 %186, 0
br i1 %192, label %193, label %162
193: ; preds = %191, %160
%194 = load double, double* %1
%195 = load double, double* %120
%196 = fmul double %195, %195
%197 = tail call double @llvm.fmuladd.f64(double %194, double %194, double %196)
%198 = load double, double* %121
%199 = tail call double @llvm.fmuladd.f64(double %198, double %198, double %197)
%200 = tail call double @sqrt(double %199)
%201 = fptosi double %200 to i32
%202 = sitofp i32 %201 to double
%203 = load <2 x double>, <2 x double>* %126
%204 = insertelement <2 x double> poison, double %202, i64 0
%205 = shufflevector <2 x double> %204, <2 x double> poison, <2 x i32> zeroinitializer
%206 = fdiv <2 x double> %203, %205
store <2 x double> %206, <2 x double>* %127
%207 = load double, double* %121
%208 = fdiv double %207, %202
store double %208, double* %121
%209 = load double, double* %0
%210 = load double, double* %122
%211 = extractelement <2 x double> %206, i64 1
%212 = fmul double %211, %210
%213 = extractelement <2 x double> %206, i64 0
%214 = tail call double @llvm.fmuladd.f64(double %213, double %209, double %212)
%215 = load double, double* %123
%216 = tail call double @llvm.fmuladd.f64(double %208, double %215, double %214)
%217 = fneg double %216
%218 = tail call double @llvm.fmuladd.f64(double %217, double %213, double %209)
store double %218, double* %0
%219 = load double, double* %120
%220 = tail call double @llvm.fmuladd.f64(double %217, double %219, double %210)
store double %220, double* %122
%221 = load double, double* %121
%222 = tail call double @llvm.fmuladd.f64(double %217, double %221, double %215)
store double %222, double* %123
%223 = fmul double %220, %220
%224 = tail call double @llvm.fmuladd.f64(double %218, double %218, double %223)
%225 = tail call double @llvm.fmuladd.f64(double %222, double %222, double %224)
%226 = tail call double @sqrt(double %225)
%227 = load <2 x double>, <2 x double>* %128
%228 = insertelement <2 x double> poison, double %226, i64 0
%229 = shufflevector <2 x double> %228, <2 x double> poison, <2 x i32> zeroinitializer
%230 = fdiv <2 x double> %227, %229
store <2 x double> %230, <2 x double>* %129
%231 = load double, double* %123
%232 = fdiv double %231, %226
store double %232, double* %123
%233 = add nsw i64 %131, 1
%234 = load i32, i32* %4
%235 = shl i32 %234, 1
%236 = add i32 %235, -1
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i32, i32* %20, i64 %237
%239 = load i32, i32* %238
%240 = sext i32 %239 to i64
%241 = icmp slt i64 %233, %240
br i1 %241, label %130, label %242
242: ; preds = %193, %110
%243 = phi i32 [ %111, %110 ], [ %235, %193 ]
%244 = phi i64 [ %113, %110 ], [ %237, %193 ]
%245 = phi i32 [ %117, %110 ], [ %239, %193 ]
%246 = add i32 %243, -2
%247 = getelementptr inbounds i32, i32* %17, i64 %244
%248 = load i32, i32* %247
%249 = sext i32 %246 to i64
%250 = getelementptr inbounds i32, i32* %17, i64 %249
%251 = load i32, i32* %250
%252 = icmp sgt i32 %248, %251
%253 = getelementptr inbounds i32, i32* %20, i64 %249
%254 = load i32, i32* %253
%255 = icmp sgt i32 %245, %254
%256 = select i1 %252, i1 true, i1 %255
br i1 %256, label %257, label %393
257: ; preds = %242
%258 = getelementptr inbounds double, double* %0, i64 1
%259 = load double, double* %258
%260 = getelementptr inbounds double, double* %1, i64 2
%261 = load double, double* %260
%262 = getelementptr inbounds double, double* %0, i64 2
%263 = load double, double* %262
%264 = getelementptr inbounds double, double* %1, i64 1
%265 = load double, double* %264
%266 = fneg double %263
%267 = fmul double %265, %266
%268 = tail call double @llvm.fmuladd.f64(double %259, double %261, double %267)
%269 = getelementptr inbounds double, double* %1, i64 3
store double %268, double* %269
%270 = load double, double* %262
%271 = load double, double* %1
%272 = load double, double* %0
%273 = fneg double %272
%274 = fmul double %261, %273
%275 = tail call double @llvm.fmuladd.f64(double %270, double %271, double %274)
%276 = getelementptr inbounds double, double* %1, i64 4
store double %275, double* %276
%277 = load double, double* %0
%278 = load double, double* %258
%279 = fneg double %278
%280 = fmul double %271, %279
%281 = tail call double @llvm.fmuladd.f64(double %277, double %265, double %280)
%282 = getelementptr inbounds double, double* %1, i64 5
store double %281, double* %282
store double %271, double* %3
%283 = load double, double* %264
%284 = getelementptr inbounds double, double* %3, i64 1
store double %283, double* %284
%285 = load double, double* %260
%286 = getelementptr inbounds double, double* %3, i64 2
store double %285, double* %286
%287 = load double, double* %269
%288 = getelementptr inbounds double, double* %3, i64 3
store double %287, double* %288
%289 = load double, double* %276
%290 = getelementptr inbounds double, double* %3, i64 4
store double %289, double* %290
%291 = load double, double* %282
%292 = getelementptr inbounds double, double* %3, i64 5
store double %291, double* %292
%293 = icmp slt i32 %254, %245
br i1 %293, label %294, label %377
294: ; preds = %257
%295 = sext i32 %254 to i64
%296 = sext i32 %245 to i64
br label %297
297: ; preds = %294, %370
%298 = phi i64 [ %295, %294 ], [ %375, %370 ]
%299 = trunc i64 %298 to i32
%300 = shl nsw i32 %299, 1
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i32, i32* %21, i64 %301
%303 = load i32, i32* %302
%304 = add nsw i32 %303, -1
%305 = mul nsw i32 %304, 3
%306 = add nsw i32 %305, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i32, i32* %11, i64 %307
%309 = load i32, i32* %308
%310 = sext i32 %304 to i64
%311 = getelementptr inbounds double, double* %12, i64 %310
%312 = load double, double* %311
%313 = add nsw i32 %305, 2
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %11, i64 %314
%316 = load i32, i32* %315
%317 = icmp eq i32 %316, 0
br i1 %317, label %318, label %323
318: ; preds = %297
%319 = add nsw i32 %309, -1
%320 = add nsw i32 %309, 2
%321 = sext i32 %320 to i64
%322 = sext i32 %319 to i64
br label %370
323: ; preds = %297
%324 = load i32, i32* %30
%325 = add nsw i32 %309, -1
%326 = add nsw i32 %309, 2
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %1, i64 %327
%329 = sext i32 %325 to i64
%330 = getelementptr inbounds double, double* %0, i64 %329
br label %331
331: ; preds = %323, %364
%332 = phi i32 [ %316, %323 ], [ %368, %364 ]
%333 = add nsw i32 %332, -1
%334 = mul nsw i32 %333, 3
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %11, i64 %335
%337 = load i32, i32* %336
%338 = icmp eq i32 %337, %324
br i1 %338, label %339, label %364
339: ; preds = %331
%340 = add nsw i32 %334, 1
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %11, i64 %341
%343 = load i32, i32* %342
%344 = add nsw i32 %343, -1
%345 = add nsw i32 %343, 2
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds double, double* %1, i64 %346
%348 = load double, double* %347
%349 = sext i32 %333 to i64
%350 = getelementptr inbounds double, double* %12, i64 %349
%351 = load double, double* %350
%352 = load double, double* %328
%353 = fmul double %351, %352
%354 = fdiv double %353, %312
%355 = fsub double %348, %354
store double %355, double* %347
%356 = sext i32 %344 to i64
%357 = getelementptr inbounds double, double* %0, i64 %356
%358 = load double, double* %357
%359 = load double, double* %350
%360 = load double, double* %330
%361 = fmul double %359, %360
%362 = fdiv double %361, %312
%363 = fsub double %358, %362
store double %363, double* %357
br label %364
364: ; preds = %339, %331
%365 = add nsw i32 %334, 2
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds i32, i32* %11, i64 %366
%368 = load i32, i32* %367
%369 = icmp eq i32 %368, 0
br i1 %369, label %370, label %331
370: ; preds = %364, %318
%371 = phi i64 [ %322, %318 ], [ %329, %364 ]
%372 = phi i64 [ %321, %318 ], [ %327, %364 ]
%373 = getelementptr inbounds double, double* %1, i64 %372
store double 0.000000e+00, double* %373
%374 = getelementptr inbounds double, double* %0, i64 %371
store double 0.000000e+00, double* %374
%375 = add nsw i64 %298, 1
%376 = icmp eq i64 %375, %296
br i1 %376, label %377, label %297
377: ; preds = %370, %257
%378 = load i32, i32* %29
%379 = icmp eq i32 %378, 1
br i1 %379, label %380, label %416
380: ; preds = %377
%381 = load double, double* %0
%382 = load double, double* %258
%383 = load double, double* %262
%384 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), double %381, double %382, double %383)
%385 = load double, double* %1
%386 = load double, double* %264
%387 = load double, double* %260
%388 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %385, double %386, double %387)
%389 = load double, double* %269
%390 = load double, double* %276
%391 = load double, double* %282
%392 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %389, double %390, double %391)
br label %393
393: ; preds = %242, %380
%394 = load i32, i32* %29
%395 = icmp eq i32 %394, 1
br i1 %395, label %396, label %416
396: ; preds = %393
%397 = load double, double* %0
%398 = getelementptr inbounds double, double* %0, i64 1
%399 = load double, double* %398
%400 = getelementptr inbounds double, double* %0, i64 2
%401 = load double, double* %400
%402 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), double %397, double %399, double %401)
%403 = load double, double* %1
%404 = getelementptr inbounds double, double* %1, i64 1
%405 = load double, double* %404
%406 = getelementptr inbounds double, double* %1, i64 2
%407 = load double, double* %406
%408 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %403, double %405, double %407)
%409 = getelementptr inbounds double, double* %1, i64 3
%410 = load double, double* %409
%411 = getelementptr inbounds double, double* %1, i64 4
%412 = load double, double* %411
%413 = getelementptr inbounds double, double* %1, i64 5
%414 = load double, double* %413
%415 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %410, double %412, double %414)
br label %416
416: ; preds = %377, %396, %393
ret void
}