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 i, j, jj, j2, k, kk, l, m, dirblock, ist, dir, node1, index, dirind,
      dirdep, nt1, nt2;
  double dist, nn, coefdep;
  dirblock = 0;
  for (jj = nslavmpc[2 * (*islavnodeentry - 1)];
       jj < nslavmpc[2 * (*islavnodeentry - 1) + 1]; jj++) {
    if (islavmpc[2 * jj + 1] == 1) {
      dirblock = 1;
    }
  }
  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]);
    nt2 = sqrt(t[3] * t[3] + t[4] * t[4] + t[5] * 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]);
    }
  }
  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    $0x90,%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)
movl   $0x0,-0x54(%rbp)
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,-0x3c(%rbp)
mov    -0x3c(%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    1247 <trafontspcmpc+0x127>
mov    0x88(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1234 <trafontspcmpc+0x114>
movl   $0x1,-0x54(%rbp)
jmp    1239 <trafontspcmpc+0x119>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11eb <trafontspcmpc+0xcb>
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,-0x3c(%rbp)
mov    -0x3c(%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    14d1 <trafontspcmpc+0x3b1>
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    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    0x18(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1309 <trafontspcmpc+0x1e9>
mov    -0x3c(%rbp),%esi
mov    -0x58(%rbp),%edx
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%r8d
lea    0xd06(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xce2(%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,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x80(%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  -0x80(%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  -0x80(%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,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1260 <trafontspcmpc+0x140>
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,-0x3c(%rbp)
mov    -0x3c(%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    18fa <trafontspcmpc+0x7da>
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    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    0x40(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    15fa <trafontspcmpc+0x4da>
mov    -0x3c(%rbp),%esi
mov    -0x58(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x60(%rbp),%r8d
movsd  -0x90(%rbp),%xmm0
ff
lea    0xa32(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    15ff <trafontspcmpc+0x4df>
cmpl   $0x0,-0x64(%rbp)
je     16ad <trafontspcmpc+0x58d>
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0xd0(%rbp),%rcx
cmp    (%rcx),%eax
jne    166e <trafontspcmpc+0x54e>
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    16a8 <trafontspcmpc+0x588>
mov    -0x64(%rbp),%esi
lea    0x9a9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    15ff <trafontspcmpc+0x4df>
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,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
cvtsi2sdl -0x70(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
cvtsi2sdl -0x70(%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,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x80(%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  -0x80(%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  -0x80(%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,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ed <trafontspcmpc+0x3cd>
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     1970 <trafontspcmpc+0x850>
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    1e18 <trafontspcmpc+0xcf8>
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,-0x48(%rbp)
cmpl   $0x6,-0x48(%rbp)
jge    1a89 <trafontspcmpc+0x969>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a57 <trafontspcmpc+0x937>
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,-0x3c(%rbp)
mov    -0x3c(%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    1c97 <trafontspcmpc+0xb77>
mov    0x88(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    0x40(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
mov    -0x58(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x64(%rbp)
je     1c5c <trafontspcmpc+0xb3c>
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    0xd0(%rbp),%rcx
cmp    (%rcx),%eax
jne    1c3e <trafontspcmpc+0xb1e>
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x90(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x90(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    1b42 <trafontspcmpc+0xa22>
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x6c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aa5 <trafontspcmpc+0x985>
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,-0x88(%rbp)
ff
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,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x20(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x74(%rbp)
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1e13 <trafontspcmpc+0xcf3>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x29a(%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    0x280(%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    0x266(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
jmp    1e18 <trafontspcmpc+0xcf8>
mov    0xc8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1ea1 <trafontspcmpc+0xd81>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
lea    0x20c(%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    0x1f2(%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    0x1d8(%rip),%rdi
mov    $0x3,%al
call   1030 <printf@plt>
add    $0x90,%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 i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca double
%81 = alloca double
%82 = 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
store i32 0, i32* %71
%83 = load i32*, i32** %52
%84 = load i32*, i32** %36
%85 = load i32, i32* %84
%86 = sub nsw i32 %85, 1
%87 = mul nsw i32 2, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %83, i64 %88
%90 = load i32, i32* %89
store i32 %90, i32* %65
br label %91
91: ; preds = %114, %31
%92 = load i32, i32* %65
%93 = load i32*, i32** %52
%94 = load i32*, i32** %36
%95 = load i32, i32* %94
%96 = sub nsw i32 %95, 1
%97 = mul nsw i32 2, %96
%98 = add nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %93, i64 %99
%101 = load i32, i32* %100
%102 = icmp slt i32 %92, %101
br i1 %102, label %103, label %117
103: ; preds = %91
%104 = load i32*, i32** %53
%105 = load i32, i32* %65
%106 = mul nsw i32 2, %105
%107 = add nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %104, i64 %108
%110 = load i32, i32* %109
%111 = icmp eq i32 %110, 1
br i1 %111, label %112, label %113
112: ; preds = %103
store i32 1, i32* %71
br label %113
113: ; preds = %112, %103
br label %114
114: ; preds = %113
%115 = load i32, i32* %65
%116 = add nsw i32 %115, 1
store i32 %116, i32* %65
br label %91
117: ; preds = %91
%118 = load i32*, i32** %49
%119 = load i32*, i32** %36
%120 = load i32, i32* %119
%121 = sub nsw i32 %120, 1
%122 = mul nsw i32 2, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %118, i64 %123
%125 = load i32, i32* %124
store i32 %125, i32* %65
br label %126
126: ; preds = %275, %117
%127 = load i32, i32* %65
%128 = load i32*, i32** %49
%129 = load i32*, i32** %36
%130 = load i32, i32* %129
%131 = sub nsw i32 %130, 1
%132 = mul nsw i32 2, %131
%133 = add nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %128, i64 %134
%136 = load i32, i32* %135
%137 = icmp slt i32 %127, %136
br i1 %137, label %138, label %278
138: ; preds = %126
%139 = load double*, double** %33
%140 = getelementptr inbounds double, double* %139, i64 0
store double 0.000000e+00, double* %140
%141 = load double*, double** %33
%142 = getelementptr inbounds double, double* %141, i64 1
store double 0.000000e+00, double* %142
%143 = load double*, double** %33
%144 = getelementptr inbounds double, double* %143, i64 2
store double 0.000000e+00, double* %144
%145 = load i32*, i32** %50
%146 = load i32, i32* %65
%147 = mul nsw i32 2, %146
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %145, i64 %148
%150 = load i32, i32* %149
store i32 %150, i32* %72
%151 = load i32*, i32** %38
%152 = load i32, i32* %72
%153 = sub nsw i32 %152, 1
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %151, i64 %154
%156 = load i32, i32* %155
store i32 %156, i32* %73
%157 = load i32*, i32** %39
%158 = load i32, i32* %72
%159 = sub nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %157, i64 %160
%162 = load i32, i32* %161
store i32 %162, i32* %74
%163 = load i32*, i32** %61
%164 = load i32, i32* %163
%165 = icmp eq i32 %164, 1
br i1 %165, label %166, label %172
166: ; preds = %138
%167 = load i32, i32* %65
%168 = load i32, i32* %72
%169 = load i32, i32* %73
%170 = load i32, i32* %74
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), i32 %167, i32 %168, i32 %169, i32 %170)
br label %172
172: ; preds = %166, %138
%173 = load double*, double** %33
%174 = load i32, i32* %73
%175 = sub nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %173, i64 %176
store double 1.000000e+00, double* %177
%178 = load double*, double** %33
%179 = getelementptr inbounds double, double* %178, i64 0
%180 = load double, double* %179
%181 = load double*, double** %32
%182 = getelementptr inbounds double, double* %181, i64 0
%183 = load double, double* %182
%184 = load double*, double** %33
%185 = getelementptr inbounds double, double* %184, i64 1
%186 = load double, double* %185
%187 = load double*, double** %32
%188 = getelementptr inbounds double, double* %187, i64 1
%189 = load double, double* %188
%190 = fmul double %186, %189
%191 = call double @llvm.fmuladd.f64(double %180, double %183, double %190)
%192 = load double*, double** %33
%193 = getelementptr inbounds double, double* %192, i64 2
%194 = load double, double* %193
%195 = load double*, double** %32
%196 = getelementptr inbounds double, double* %195, i64 2
%197 = load double, double* %196
%198 = call double @llvm.fmuladd.f64(double %194, double %197, double %191)
store double %198, double* %80
%199 = load double*, double** %32
%200 = getelementptr inbounds double, double* %199, i64 0
%201 = load double, double* %200
%202 = load double, double* %80
%203 = load double*, double** %33
%204 = getelementptr inbounds double, double* %203, i64 0
%205 = load double, double* %204
%206 = fneg double %202
%207 = call double @llvm.fmuladd.f64(double %206, double %205, double %201)
%208 = load double*, double** %32
%209 = getelementptr inbounds double, double* %208, i64 0
store double %207, double* %209
%210 = load double*, double** %32
%211 = getelementptr inbounds double, double* %210, i64 1
%212 = load double, double* %211
%213 = load double, double* %80
%214 = load double*, double** %33
%215 = getelementptr inbounds double, double* %214, i64 1
%216 = load double, double* %215
%217 = fneg double %213
%218 = call double @llvm.fmuladd.f64(double %217, double %216, double %212)
%219 = load double*, double** %32
%220 = getelementptr inbounds double, double* %219, i64 1
store double %218, double* %220
%221 = load double*, double** %32
%222 = getelementptr inbounds double, double* %221, i64 2
%223 = load double, double* %222
%224 = load double, double* %80
%225 = load double*, double** %33
%226 = getelementptr inbounds double, double* %225, i64 2
%227 = load double, double* %226
%228 = fneg double %224
%229 = call double @llvm.fmuladd.f64(double %228, double %227, double %223)
%230 = load double*, double** %32
%231 = getelementptr inbounds double, double* %230, i64 2
store double %229, double* %231
%232 = load double*, double** %32
%233 = getelementptr inbounds double, double* %232, i64 0
%234 = load double, double* %233
%235 = load double*, double** %32
%236 = getelementptr inbounds double, double* %235, i64 0
%237 = load double, double* %236
%238 = load double*, double** %32
%239 = getelementptr inbounds double, double* %238, i64 1
%240 = load double, double* %239
%241 = load double*, double** %32
%242 = getelementptr inbounds double, double* %241, i64 1
%243 = load double, double* %242
%244 = fmul double %240, %243
%245 = call double @llvm.fmuladd.f64(double %234, double %237, double %244)
%246 = load double*, double** %32
%247 = getelementptr inbounds double, double* %246, i64 2
%248 = load double, double* %247
%249 = load double*, double** %32
%250 = getelementptr inbounds double, double* %249, i64 2
%251 = load double, double* %250
%252 = call double @llvm.fmuladd.f64(double %248, double %251, double %245)
%253 = call double @sqrt(double %252)
store double %253, double* %81
%254 = load double*, double** %32
%255 = getelementptr inbounds double, double* %254, i64 0
%256 = load double, double* %255
%257 = load double, double* %81
%258 = fdiv double %256, %257
%259 = load double*, double** %32
%260 = getelementptr inbounds double, double* %259, i64 0
store double %258, double* %260
%261 = load double*, double** %32
%262 = getelementptr inbounds double, double* %261, i64 1
%263 = load double, double* %262
%264 = load double, double* %81
%265 = fdiv double %263, %264
%266 = load double*, double** %32
%267 = getelementptr inbounds double, double* %266, i64 1
store double %265, double* %267
%268 = load double*, double** %32
%269 = getelementptr inbounds double, double* %268, i64 2
%270 = load double, double* %269
%271 = load double, double* %81
%272 = fdiv double %270, %271
%273 = load double*, double** %32
%274 = getelementptr inbounds double, double* %273, i64 2
store double %272, double* %274
br label %275
275: ; preds = %172
%276 = load i32, i32* %65
%277 = add nsw i32 %276, 1
store i32 %277, i32* %65
br label %126
278: ; preds = %126
%279 = load i32*, i32** %52
%280 = load i32*, i32** %36
%281 = load i32, i32* %280
%282 = sub nsw i32 %281, 1
%283 = mul nsw i32 2, %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32, i32* %279, i64 %284
%286 = load i32, i32* %285
store i32 %286, i32* %65
br label %287
287: ; preds = %554, %278
%288 = load i32, i32* %65
%289 = load i32*, i32** %52
%290 = load i32*, i32** %36
%291 = load i32, i32* %290
%292 = sub nsw i32 %291, 1
%293 = mul nsw i32 2, %292
%294 = add nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %289, i64 %295
%297 = load i32, i32* %296
%298 = icmp slt i32 %288, %297
br i1 %298, label %299, label %557
299: ; preds = %287
%300 = load double*, double** %33
%301 = getelementptr inbounds double, double* %300, i64 0
store double 0.000000e+00, double* %301
%302 = load double*, double** %33
%303 = getelementptr inbounds double, double* %302, i64 1
store double 0.000000e+00, double* %303
%304 = load double*, double** %33
%305 = getelementptr inbounds double, double* %304, i64 2
store double 0.000000e+00, double* %305
%306 = load i32*, i32** %53
%307 = load i32, i32* %65
%308 = mul nsw i32 2, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %306, i64 %309
%311 = load i32, i32* %310
store i32 %311, i32* %72
%312 = load i32*, i32** %43
%313 = load i32, i32* %72
%314 = sub nsw i32 %313, 1
%315 = mul nsw i32 3, %314
%316 = add nsw i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %312, i64 %317
%319 = load i32, i32* %318
store i32 %319, i32* %77
%320 = load double*, double** %44
%321 = load i32, i32* %72
%322 = sub nsw i32 %321, 1
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %320, i64 %323
%325 = load double, double* %324
store double %325, double* %82
%326 = load i32*, i32** %43
%327 = load i32, i32* %72
%328 = sub nsw i32 %327, 1
%329 = mul nsw i32 3, %328
%330 = add nsw i32 %329, 2
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32, i32* %326, i64 %331
%333 = load i32, i32* %332
store i32 %333, i32* %75
%334 = load i32*, i32** %43
%335 = load i32, i32* %72
%336 = sub nsw i32 %335, 1
%337 = mul nsw i32 3, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %334, i64 %338
%340 = load i32, i32* %339
store i32 %340, i32* %74
%341 = load double, double* %82
%342 = load double*, double** %33
%343 = load i32, i32* %77
%344 = sub nsw i32 %343, 1
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds double, double* %342, i64 %345
store double %341, double* %346
%347 = load i32*, i32** %61
%348 = load i32, i32* %347
%349 = icmp eq i32 %348, 1
br i1 %349, label %350, label %357
350: ; preds = %299
%351 = load i32, i32* %65
%352 = load i32, i32* %72
%353 = load i32, i32* %77
%354 = load i32, i32* %74
%355 = load double, double* %82
%356 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i32 %351, i32 %352, i32 %353, i32 %354, double %355)
br label %357
357: ; preds = %350, %299
br label %358
358: ; preds = %408, %357
%359 = load i32, i32* %75
%360 = icmp ne i32 %359, 0
br i1 %360, label %361, label %409
361: ; preds = %358
%362 = load i32*, i32** %43
%363 = load i32, i32* %75
%364 = sub nsw i32 %363, 1
%365 = mul nsw i32 3, %364
%366 = add nsw i32 %365, 1
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32, i32* %362, i64 %367
%369 = load i32, i32* %368
store i32 %369, i32* %76
%370 = load i32*, i32** %43
%371 = load i32, i32* %75
%372 = sub nsw i32 %371, 1
%373 = mul nsw i32 3, %372
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %370, i64 %374
%376 = load i32, i32* %375
store i32 %376, i32* %74
%377 = load i32, i32* %74
%378 = load i32*, i32** %62
%379 = load i32, i32* %378
%380 = icmp eq i32 %377, %379
br i1 %380, label %381, label %393
381: ; preds = %361
%382 = load double*, double** %44
%383 = load i32, i32* %75
%384 = sub nsw i32 %383, 1
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds double, double* %382, i64 %385
%387 = load double, double* %386
%388 = load double*, double** %33
%389 = load i32, i32* %76
%390 = sub nsw i32 %389, 1
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %388, i64 %391
store double %387, double* %392
br label %393
393: ; preds = %381, %361
%394 = load i32*, i32** %43
%395 = load i32, i32* %75
%396 = sub nsw i32 %395, 1
%397 = mul nsw i32 3, %396
%398 = add nsw i32 %397, 2
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i32, i32* %394, i64 %399
%401 = load i32, i32* %400
store i32 %401, i32* %75
%402 = load i32*, i32** %61
%403 = load i32, i32* %402
%404 = icmp eq i32 %403, 1
br i1 %404, label %405, label %408
405: ; preds = %393
%406 = load i32, i32* %75
%407 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i32 %406)
br label %408
408: ; preds = %405, %393
br label %358
409: ; preds = %358
%410 = load double*, double** %33
%411 = getelementptr inbounds double, double* %410, i64 0
%412 = load double, double* %411
%413 = load double*, double** %33
%414 = getelementptr inbounds double, double* %413, i64 0
%415 = load double, double* %414
%416 = load double*, double** %33
%417 = getelementptr inbounds double, double* %416, i64 1
%418 = load double, double* %417
%419 = load double*, double** %33
%420 = getelementptr inbounds double, double* %419, i64 1
%421 = load double, double* %420
%422 = fmul double %418, %421
%423 = call double @llvm.fmuladd.f64(double %412, double %415, double %422)
%424 = load double*, double** %33
%425 = getelementptr inbounds double, double* %424, i64 2
%426 = load double, double* %425
%427 = load double*, double** %33
%428 = getelementptr inbounds double, double* %427, i64 2
%429 = load double, double* %428
%430 = call double @llvm.fmuladd.f64(double %426, double %429, double %423)
%431 = call double @sqrt(double %430)
%432 = fptosi double %431 to i32
store i32 %432, i32* %78
%433 = load double*, double** %33
%434 = getelementptr inbounds double, double* %433, i64 0
%435 = load double, double* %434
%436 = load i32, i32* %78
%437 = sitofp i32 %436 to double
%438 = fdiv double %435, %437
%439 = load double*, double** %33
%440 = getelementptr inbounds double, double* %439, i64 0
store double %438, double* %440
%441 = load double*, double** %33
%442 = getelementptr inbounds double, double* %441, i64 1
%443 = load double, double* %442
%444 = load i32, i32* %78
%445 = sitofp i32 %444 to double
%446 = fdiv double %443, %445
%447 = load double*, double** %33
%448 = getelementptr inbounds double, double* %447, i64 1
store double %446, double* %448
%449 = load double*, double** %33
%450 = getelementptr inbounds double, double* %449, i64 2
%451 = load double, double* %450
%452 = load i32, i32* %78
%453 = sitofp i32 %452 to double
%454 = fdiv double %451, %453
%455 = load double*, double** %33
%456 = getelementptr inbounds double, double* %455, i64 2
store double %454, double* %456
%457 = load double*, double** %33
%458 = getelementptr inbounds double, double* %457, i64 0
%459 = load double, double* %458
%460 = load double*, double** %32
%461 = getelementptr inbounds double, double* %460, i64 0
%462 = load double, double* %461
%463 = load double*, double** %33
%464 = getelementptr inbounds double, double* %463, i64 1
%465 = load double, double* %464
%466 = load double*, double** %32
%467 = getelementptr inbounds double, double* %466, i64 1
%468 = load double, double* %467
%469 = fmul double %465, %468
%470 = call double @llvm.fmuladd.f64(double %459, double %462, double %469)
%471 = load double*, double** %33
%472 = getelementptr inbounds double, double* %471, i64 2
%473 = load double, double* %472
%474 = load double*, double** %32
%475 = getelementptr inbounds double, double* %474, i64 2
%476 = load double, double* %475
%477 = call double @llvm.fmuladd.f64(double %473, double %476, double %470)
store double %477, double* %80
%478 = load double*, double** %32
%479 = getelementptr inbounds double, double* %478, i64 0
%480 = load double, double* %479
%481 = load double, double* %80
%482 = load double*, double** %33
%483 = getelementptr inbounds double, double* %482, i64 0
%484 = load double, double* %483
%485 = fneg double %481
%486 = call double @llvm.fmuladd.f64(double %485, double %484, double %480)
%487 = load double*, double** %32
%488 = getelementptr inbounds double, double* %487, i64 0
store double %486, double* %488
%489 = load double*, double** %32
%490 = getelementptr inbounds double, double* %489, i64 1
%491 = load double, double* %490
%492 = load double, double* %80
%493 = load double*, double** %33
%494 = getelementptr inbounds double, double* %493, i64 1
%495 = load double, double* %494
%496 = fneg double %492
%497 = call double @llvm.fmuladd.f64(double %496, double %495, double %491)
%498 = load double*, double** %32
%499 = getelementptr inbounds double, double* %498, i64 1
store double %497, double* %499
%500 = load double*, double** %32
%501 = getelementptr inbounds double, double* %500, i64 2
%502 = load double, double* %501
%503 = load double, double* %80
%504 = load double*, double** %33
%505 = getelementptr inbounds double, double* %504, i64 2
%506 = load double, double* %505
%507 = fneg double %503
%508 = call double @llvm.fmuladd.f64(double %507, double %506, double %502)
%509 = load double*, double** %32
%510 = getelementptr inbounds double, double* %509, i64 2
store double %508, double* %510
%511 = load double*, double** %32
%512 = getelementptr inbounds double, double* %511, i64 0
%513 = load double, double* %512
%514 = load double*, double** %32
%515 = getelementptr inbounds double, double* %514, i64 0
%516 = load double, double* %515
%517 = load double*, double** %32
%518 = getelementptr inbounds double, double* %517, i64 1
%519 = load double, double* %518
%520 = load double*, double** %32
%521 = getelementptr inbounds double, double* %520, i64 1
%522 = load double, double* %521
%523 = fmul double %519, %522
%524 = call double @llvm.fmuladd.f64(double %513, double %516, double %523)
%525 = load double*, double** %32
%526 = getelementptr inbounds double, double* %525, i64 2
%527 = load double, double* %526
%528 = load double*, double** %32
%529 = getelementptr inbounds double, double* %528, i64 2
%530 = load double, double* %529
%531 = call double @llvm.fmuladd.f64(double %527, double %530, double %524)
%532 = call double @sqrt(double %531)
store double %532, double* %81
%533 = load double*, double** %32
%534 = getelementptr inbounds double, double* %533, i64 0
%535 = load double, double* %534
%536 = load double, double* %81
%537 = fdiv double %535, %536
%538 = load double*, double** %32
%539 = getelementptr inbounds double, double* %538, i64 0
store double %537, double* %539
%540 = load double*, double** %32
%541 = getelementptr inbounds double, double* %540, i64 1
%542 = load double, double* %541
%543 = load double, double* %81
%544 = fdiv double %542, %543
%545 = load double*, double** %32
%546 = getelementptr inbounds double, double* %545, i64 1
store double %544, double* %546
%547 = load double*, double** %32
%548 = getelementptr inbounds double, double* %547, i64 2
%549 = load double, double* %548
%550 = load double, double* %81
%551 = fdiv double %549, %550
%552 = load double*, double** %32
%553 = getelementptr inbounds double, double* %552, i64 2
store double %551, double* %553
br label %554
554: ; preds = %409
%555 = load i32, i32* %65
%556 = add nsw i32 %555, 1
store i32 %556, i32* %65
br label %287
557: ; preds = %287
%558 = load i32*, i32** %49
%559 = load i32*, i32** %36
%560 = load i32, i32* %559
%561 = sub nsw i32 %560, 1
%562 = mul nsw i32 2, %561
%563 = add nsw i32 %562, 1
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds i32, i32* %558, i64 %564
%566 = load i32, i32* %565
%567 = load i32*, i32** %49
%568 = load i32*, i32** %36
%569 = load i32, i32* %568
%570 = sub nsw i32 %569, 1
%571 = mul nsw i32 2, %570
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds i32, i32* %567, i64 %572
%574 = load i32, i32* %573
%575 = sub nsw i32 %566, %574
%576 = icmp sgt i32 %575, 0
br i1 %576, label %597, label %577
577: ; preds = %557
%578 = load i32*, i32** %52
%579 = load i32*, i32** %36
%580 = load i32, i32* %579
%581 = sub nsw i32 %580, 1
%582 = mul nsw i32 2, %581
%583 = add nsw i32 %582, 1
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds i32, i32* %578, i64 %584
%586 = load i32, i32* %585
%587 = load i32*, i32** %52
%588 = load i32*, i32** %36
%589 = load i32, i32* %588
%590 = sub nsw i32 %589, 1
%591 = mul nsw i32 2, %590
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds i32, i32* %587, i64 %592
%594 = load i32, i32* %593
%595 = sub nsw i32 %586, %594
%596 = icmp sgt i32 %595, 0
br i1 %596, label %597, label %931
597: ; preds = %577, %557
%598 = load double*, double** %32
%599 = getelementptr inbounds double, double* %598, i64 1
%600 = load double, double* %599
%601 = load double*, double** %33
%602 = getelementptr inbounds double, double* %601, i64 2
%603 = load double, double* %602
%604 = load double*, double** %32
%605 = getelementptr inbounds double, double* %604, i64 2
%606 = load double, double* %605
%607 = load double*, double** %33
%608 = getelementptr inbounds double, double* %607, i64 1
%609 = load double, double* %608
%610 = fmul double %606, %609
%611 = fneg double %610
%612 = call double @llvm.fmuladd.f64(double %600, double %603, double %611)
%613 = load double*, double** %33
%614 = getelementptr inbounds double, double* %613, i64 3
store double %612, double* %614
%615 = load double*, double** %32
%616 = getelementptr inbounds double, double* %615, i64 2
%617 = load double, double* %616
%618 = load double*, double** %33
%619 = getelementptr inbounds double, double* %618, i64 0
%620 = load double, double* %619
%621 = load double*, double** %32
%622 = getelementptr inbounds double, double* %621, i64 0
%623 = load double, double* %622
%624 = load double*, double** %33
%625 = getelementptr inbounds double, double* %624, i64 2
%626 = load double, double* %625
%627 = fmul double %623, %626
%628 = fneg double %627
%629 = call double @llvm.fmuladd.f64(double %617, double %620, double %628)
%630 = load double*, double** %33
%631 = getelementptr inbounds double, double* %630, i64 4
store double %629, double* %631
%632 = load double*, double** %32
%633 = getelementptr inbounds double, double* %632, i64 0
%634 = load double, double* %633
%635 = load double*, double** %33
%636 = getelementptr inbounds double, double* %635, i64 1
%637 = load double, double* %636
%638 = load double*, double** %32
%639 = getelementptr inbounds double, double* %638, i64 1
%640 = load double, double* %639
%641 = load double*, double** %33
%642 = getelementptr inbounds double, double* %641, i64 0
%643 = load double, double* %642
%644 = fmul double %640, %643
%645 = fneg double %644
%646 = call double @llvm.fmuladd.f64(double %634, double %637, double %645)
%647 = load double*, double** %33
%648 = getelementptr inbounds double, double* %647, i64 5
store double %646, double* %648
store i32 0, i32* %68
br label %649
649: ; preds = %662, %597
%650 = load i32, i32* %68
%651 = icmp slt i32 %650, 6
br i1 %651, label %652, label %665
652: ; preds = %649
%653 = load double*, double** %33
%654 = load i32, i32* %68
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double, double* %653, i64 %655
%657 = load double, double* %656
%658 = load double*, double** %35
%659 = load i32, i32* %68
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double, double* %658, i64 %660
store double %657, double* %661
br label %662
662: ; preds = %652
%663 = load i32, i32* %68
%664 = add nsw i32 %663, 1
store i32 %664, i32* %68
br label %649
665: ; preds = %649
%666 = load i32*, i32** %52
%667 = load i32*, i32** %36
%668 = load i32, i32* %667
%669 = sub nsw i32 %668, 1
%670 = mul nsw i32 2, %669
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds i32, i32* %666, i64 %671
%673 = load i32, i32* %672
store i32 %673, i32* %65
br label %674
674: ; preds = %824, %665
%675 = load i32, i32* %65
%676 = load i32*, i32** %52
%677 = load i32*, i32** %36
%678 = load i32, i32* %677
%679 = sub nsw i32 %678, 1
%680 = mul nsw i32 2, %679
%681 = add nsw i32 %680, 1
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds i32, i32* %676, i64 %682
%684 = load i32, i32* %683
%685 = icmp slt i32 %675, %684
br i1 %685, label %686, label %827
686: ; preds = %674
%687 = load i32*, i32** %53
%688 = load i32, i32* %65
%689 = mul nsw i32 2, %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds i32, i32* %687, i64 %690
%692 = load i32, i32* %691
store i32 %692, i32* %72
%693 = load i32*, i32** %43
%694 = load i32, i32* %72
%695 = sub nsw i32 %694, 1
%696 = mul nsw i32 3, %695
%697 = add nsw i32 %696, 1
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i32, i32* %693, i64 %698
%700 = load i32, i32* %699
store i32 %700, i32* %77
%701 = load double*, double** %44
%702 = load i32, i32* %72
%703 = sub nsw i32 %702, 1
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds double, double* %701, i64 %704
%706 = load double, double* %705
store double %706, double* %82
%707 = load i32*, i32** %43
%708 = load i32, i32* %72
%709 = sub nsw i32 %708, 1
%710 = mul nsw i32 3, %709
%711 = add nsw i32 %710, 2
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds i32, i32* %707, i64 %712
%714 = load i32, i32* %713
store i32 %714, i32* %75
%715 = load i32*, i32** %43
%716 = load i32, i32* %72
%717 = sub nsw i32 %716, 1
%718 = mul nsw i32 3, %717
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds i32, i32* %715, i64 %719
%721 = load i32, i32* %720
store i32 %721, i32* %74
br label %722
722: ; preds = %803, %686
%723 = load i32, i32* %75
%724 = icmp ne i32 %723, 0
br i1 %724, label %725, label %812
725: ; preds = %722
%726 = load i32*, i32** %43
%727 = load i32, i32* %75
%728 = sub nsw i32 %727, 1
%729 = mul nsw i32 3, %728
%730 = add nsw i32 %729, 1
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds i32, i32* %726, i64 %731
%733 = load i32, i32* %732
store i32 %733, i32* %76
%734 = load i32*, i32** %43
%735 = load i32, i32* %75
%736 = sub nsw i32 %735, 1
%737 = mul nsw i32 3, %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds i32, i32* %734, i64 %738
%740 = load i32, i32* %739
store i32 %740, i32* %74
%741 = load i32, i32* %74
%742 = load i32*, i32** %62
%743 = load i32, i32* %742
%744 = icmp eq i32 %741, %743
br i1 %744, label %745, label %803
745: ; preds = %725
%746 = load double*, double** %33
%747 = load i32, i32* %76
%748 = sub nsw i32 %747, 1
%749 = add nsw i32 %748, 3
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double, double* %746, i64 %750
%752 = load double, double* %751
%753 = load double*, double** %44
%754 = load i32, i32* %75
%755 = sub nsw i32 %754, 1
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds double, double* %753, i64 %756
%758 = load double, double* %757
%759 = load double*, double** %33
%760 = load i32, i32* %77
%761 = sub nsw i32 %760, 1
%762 = add nsw i32 %761, 3
%763 = sext i32 %762 to i64
%764 = getelementptr inbounds double, double* %759, i64 %763
%765 = load double, double* %764
%766 = fmul double %758, %765
%767 = load double, double* %82
%768 = fdiv double %766, %767
%769 = fsub double %752, %768
%770 = load double*, double** %33
%771 = load i32, i32* %76
%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 %769, double* %775
%776 = load double*, double** %32
%777 = load i32, i32* %76
%778 = sub nsw i32 %777, 1
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double, double* %776, i64 %779
%781 = load double, double* %780
%782 = load double*, double** %44
%783 = load i32, i32* %75
%784 = sub nsw i32 %783, 1
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %782, i64 %785
%787 = load double, double* %786
%788 = load double*, double** %32
%789 = load i32, i32* %77
%790 = sub nsw i32 %789, 1
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds double, double* %788, i64 %791
%793 = load double, double* %792
%794 = fmul double %787, %793
%795 = load double, double* %82
%796 = fdiv double %794, %795
%797 = fsub double %781, %796
%798 = load double*, double** %32
%799 = load i32, i32* %76
%800 = sub nsw i32 %799, 1
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds double, double* %798, i64 %801
store double %797, double* %802
br label %803
803: ; preds = %745, %725
%804 = load i32*, i32** %43
%805 = load i32, i32* %75
%806 = sub nsw i32 %805, 1
%807 = mul nsw i32 3, %806
%808 = add nsw i32 %807, 2
%809 = sext i32 %808 to i64
%810 = getelementptr inbounds i32, i32* %804, i64 %809
%811 = load i32, i32* %810
store i32 %811, i32* %75
br label %722
812: ; preds = %722
%813 = load double*, double** %33
%814 = load i32, i32* %77
%815 = sub nsw i32 %814, 1
%816 = add nsw i32 %815, 3
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds double, double* %813, i64 %817
store double 0.000000e+00, double* %818
%819 = load double*, double** %32
%820 = load i32, i32* %77
%821 = sub nsw i32 %820, 1
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds double, double* %819, i64 %822
store double 0.000000e+00, double* %823
br label %824
824: ; preds = %812
%825 = load i32, i32* %65
%826 = add nsw i32 %825, 1
store i32 %826, i32* %65
br label %674
827: ; preds = %674
%828 = load double*, double** %32
%829 = getelementptr inbounds double, double* %828, i64 0
%830 = load double, double* %829
%831 = load double*, double** %32
%832 = getelementptr inbounds double, double* %831, i64 0
%833 = load double, double* %832
%834 = load double*, double** %32
%835 = getelementptr inbounds double, double* %834, i64 1
%836 = load double, double* %835
%837 = load double*, double** %32
%838 = getelementptr inbounds double, double* %837, i64 1
%839 = load double, double* %838
%840 = fmul double %836, %839
%841 = call double @llvm.fmuladd.f64(double %830, double %833, double %840)
%842 = load double*, double** %32
%843 = getelementptr inbounds double, double* %842, i64 2
%844 = load double, double* %843
%845 = load double*, double** %32
%846 = getelementptr inbounds double, double* %845, i64 2
%847 = load double, double* %846
%848 = call double @llvm.fmuladd.f64(double %844, double %847, double %841)
%849 = call double @sqrt(double %848)
store double %849, double* %81
%850 = load double*, double** %33
%851 = getelementptr inbounds double, double* %850, i64 0
%852 = load double, double* %851
%853 = load double*, double** %33
%854 = getelementptr inbounds double, double* %853, i64 0
%855 = load double, double* %854
%856 = load double*, double** %33
%857 = getelementptr inbounds double, double* %856, i64 1
%858 = load double, double* %857
%859 = load double*, double** %33
%860 = getelementptr inbounds double, double* %859, i64 1
%861 = load double, double* %860
%862 = fmul double %858, %861
%863 = call double @llvm.fmuladd.f64(double %852, double %855, double %862)
%864 = load double*, double** %33
%865 = getelementptr inbounds double, double* %864, i64 2
%866 = load double, double* %865
%867 = load double*, double** %33
%868 = getelementptr inbounds double, double* %867, i64 2
%869 = load double, double* %868
%870 = call double @llvm.fmuladd.f64(double %866, double %869, double %863)
%871 = call double @sqrt(double %870)
%872 = fptosi double %871 to i32
store i32 %872, i32* %78
%873 = load double*, double** %33
%874 = getelementptr inbounds double, double* %873, i64 3
%875 = load double, double* %874
%876 = load double*, double** %33
%877 = getelementptr inbounds double, double* %876, i64 3
%878 = load double, double* %877
%879 = load double*, double** %33
%880 = getelementptr inbounds double, double* %879, i64 4
%881 = load double, double* %880
%882 = load double*, double** %33
%883 = getelementptr inbounds double, double* %882, i64 4
%884 = load double, double* %883
%885 = fmul double %881, %884
%886 = call double @llvm.fmuladd.f64(double %875, double %878, double %885)
%887 = load double*, double** %33
%888 = getelementptr inbounds double, double* %887, i64 5
%889 = load double, double* %888
%890 = load double*, double** %33
%891 = getelementptr inbounds double, double* %890, i64 5
%892 = load double, double* %891
%893 = call double @llvm.fmuladd.f64(double %889, double %892, double %886)
%894 = call double @sqrt(double %893)
%895 = fptosi double %894 to i32
store i32 %895, i32* %79
%896 = load i32*, i32** %61
%897 = load i32, i32* %896
%898 = icmp eq i32 %897, 1
br i1 %898, label %899, label %930
899: ; preds = %827
%900 = load double*, double** %32
%901 = getelementptr inbounds double, double* %900, i64 0
%902 = load double, double* %901
%903 = load double*, double** %32
%904 = getelementptr inbounds double, double* %903, i64 1
%905 = load double, double* %904
%906 = load double*, double** %32
%907 = getelementptr inbounds double, double* %906, i64 2
%908 = load double, double* %907
%909 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), double %902, double %905, double %908)
%910 = load double*, double** %33
%911 = getelementptr inbounds double, double* %910, i64 0
%912 = load double, double* %911
%913 = load double*, double** %33
%914 = getelementptr inbounds double, double* %913, i64 1
%915 = load double, double* %914
%916 = load double*, double** %33
%917 = getelementptr inbounds double, double* %916, i64 2
%918 = load double, double* %917
%919 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %912, double %915, double %918)
%920 = load double*, double** %33
%921 = getelementptr inbounds double, double* %920, i64 3
%922 = load double, double* %921
%923 = load double*, double** %33
%924 = getelementptr inbounds double, double* %923, i64 4
%925 = load double, double* %924
%926 = load double*, double** %33
%927 = getelementptr inbounds double, double* %926, i64 5
%928 = load double, double* %927
%929 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %922, double %925, double %928)
br label %930
930: ; preds = %899, %827
br label %931
931: ; preds = %930, %577
%932 = load i32*, i32** %61
%933 = load i32, i32* %932
%934 = icmp eq i32 %933, 1
br i1 %934, label %935, label %966
935: ; preds = %931
%936 = load double*, double** %32
%937 = getelementptr inbounds double, double* %936, i64 0
%938 = load double, double* %937
%939 = load double*, double** %32
%940 = getelementptr inbounds double, double* %939, i64 1
%941 = load double, double* %940
%942 = load double*, double** %32
%943 = getelementptr inbounds double, double* %942, i64 2
%944 = load double, double* %943
%945 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.3, i64 0, i64 0), double %938, double %941, double %944)
%946 = load double*, double** %33
%947 = getelementptr inbounds double, double* %946, i64 0
%948 = load double, double* %947
%949 = load double*, double** %33
%950 = getelementptr inbounds double, double* %949, i64 1
%951 = load double, double* %950
%952 = load double*, double** %33
%953 = getelementptr inbounds double, double* %952, i64 2
%954 = load double, double* %953
%955 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.4, i64 0, i64 0), double %948, double %951, double %954)
%956 = load double*, double** %33
%957 = getelementptr inbounds double, double* %956, i64 3
%958 = load double, double* %957
%959 = load double*, double** %33
%960 = getelementptr inbounds double, double* %959, i64 4
%961 = load double, double* %960
%962 = load double*, double** %33
%963 = getelementptr inbounds double, double* %962, i64 5
%964 = load double, double* %963
%965 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0), double %958, double %961, double %964)
br label %966
966: ; preds = %935, %931
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
}