#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ HUGE_VAL;
int acos(int);
int cos(double);
double *dvector(int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_imatrix(int **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
int **imatrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
double log(double);
int /*<<< orphan*/ shellsortd(int, double *);
int sin(double);
double sqr(int);
int sqrt(float);
void checkdist(int n, int *nc, double *maxc, double *xi, double *yi, double *zi,
               double **Mdij, int Nsg, int *sgi, int *cati, int StatType,
               int TypeComp, double *mdc, double *mlndc, int *npc,
               float **indexpartic) {
  int i, j, c;
  int add_classSup = 0;
  double dij, lndij, dmax;
  double sumd[102 + 3], sumlnd[102 + 3];
  int np, nplnc[102 + 3];
  int **participic;
  int p;
  double *distp;
  if ((*nc) < 0) {
    (*nc) = -(*nc);
    distp = dvector(0, (n * (n - 1)) / 2);
    p = 1;
    for (i = 1; i < n; i++)
      for (j = i + 1; j <= n; j++) {
        if (TypeComp == 1)
          if (cati[i] != cati[j])
            continue;
        if (TypeComp == 2)
          if (cati[i] == cati[j])
            continue;
        if (StatType == 1 && Mdij[0][0] <= 0)
          if (sgi[i] == sgi[j])
            continue;
        if (Mdij[0][0] == 1.) {
          if (Mdij[i][j] != (float)HUGE_VAL)
            dij = Mdij[i][j];
          else
            continue;
        } else if (Mdij[0][0] == -1.)
          dij = acos(sin(xi[i]) * sin(xi[j]) +
                     cos(xi[i]) * cos(xi[j]) * cos(yi[j] - yi[i])) *
                6371;
        else
          dij = sqrt((xi[i] - xi[j]) * (xi[i] - xi[j]) +
                     (yi[i] - yi[j]) * (yi[i] - yi[j]) +
                     (zi[i] - zi[j]) * (zi[i] - zi[j]));
        if (Mdij[0][0] != 1.)
          if ((xi[i] == xi[j]) && (yi[i] == yi[j]) && (zi[i] == zi[j]))
            dij = 0.;
        distp[p++] = dij;
      }
    p--;
    shellsortd(p, distp);
    if (Nsg > 1 && StatType == 1) {
      maxc[1] = -1.;
      (*nc)++;
      for (c = 2; c <= (*nc); c++)
        maxc[c] = distp[(int)(p * (c - 1) / ((*nc) - 1))];
    } else
      for (c = 1; c <= (*nc); c++)
        maxc[c] = distp[(int)(p * c / (*nc))];
    maxc[(*nc)] *= 1.0001;
    free_dvector(distp, 0, (n * (n - 1)) / 2);
  }
  for (c = 0; c < 102 + 3; c++) {
    sumd[c] = sumlnd[c] = 0.0F;
    nplnc[c] = 0;
  }
  for (c = 0; c <= (*nc) + 1; c++) {
    npc[c] = 0;
  }
  dmax = 0.0F;
  participic = imatrix(0, n, 0, (*nc) + 1);
  for (i = 0; i <= n; i++)
    for (c = 0; c <= (*nc) + 1; c++)
      participic[i][c] = 0;
  for (i = 1; i < n; i++) {
    for (j = (i + 1); j <= n; j++) {
      if (TypeComp == 1)
        if (cati[i] != cati[j])
          continue;
      if (TypeComp == 2)
        if (cati[i] == cati[j])
          continue;
      if (Mdij[0][0] == 1.) {
        if (Mdij[i][j] != (float)HUGE_VAL)
          dij = Mdij[i][j];
        else
          continue;
      } else if (Mdij[0][0] == -1.)
        dij = acos(sin(xi[i]) * sin(xi[j]) +
                   cos(xi[i]) * cos(xi[j]) * cos(yi[j] - yi[i])) *
              6371;
      else
        dij = sqrt((xi[i] - xi[j]) * (xi[i] - xi[j]) +
                   (yi[i] - yi[j]) * (yi[i] - yi[j]) +
                   (zi[i] - zi[j]) * (zi[i] - zi[j]));
      if (Mdij[0][0] != 1.)
        if ((xi[i] == xi[j]) && (yi[i] == yi[j]) && (zi[i] == zi[j]))
          dij = 0.;
      if ((dij > maxc[(*nc)]) && (add_classSup == 0)) {
        (*nc)++;
        add_classSup = 1;
      }
      if (dij > dmax) {
        dmax = dij * 1.000001;
        if (add_classSup)
          maxc[(*nc)] = dmax;
      }
      if (StatType == 1 && (sgi[i] == sgi[j]) && Mdij[0][0] <= 0)
        c = 1;
      else {
        c = 1;
        while (dij > maxc[c] && c <= (*nc))
          c++;
      }
      npc[c]++;
      sumd[c] += dij;
      if (dij > 0.) {
        lndij = log(dij);
        nplnc[c]++;
        sumlnd[c] += lndij;
      }
      participic[i][c]++;
      participic[j][c]++;
    }
  }
  npc[(*nc) + 1] = 0;
  for (c = 1; c <= (*nc); c++) {
    if (npc[c])
      mdc[c] = sumd[c] / (double)npc[c];
    else
      mdc[c] = (float)HUGE_VAL;
    if (nplnc[c])
      mlndc[c] = sumlnd[c] / (double)nplnc[c];
    else
      mlndc[c] = (float)HUGE_VAL;
    npc[(*nc) + 1] += npc[c];
  }
  mdc[0] = mlndc[0] = (float)HUGE_VAL;
  for (c = 1; c <= (*nc); c++)
    if (npc[c]) {
      indexpartic[c][0] = indexpartic[c][1] = 0.;
      for (i = 1; i <= n; i++) {
        if (participic[i][c])
          indexpartic[c][0]++;
        indexpartic[c][1] +=
            (float)(sqr(participic[i][c] - (2. * npc[c] / (double)n)) /
                    (double)(n - 1));
      }
      indexpartic[c][0] /= n;
      indexpartic[c][1] =
          (float)(sqrt(indexpartic[c][1]) / (2. * npc[c] / (double)n));
    }
  indexpartic[0][0] = 1.;
  indexpartic[0][1] = 0.;
  free_imatrix(participic, 0, n, 0, (*nc) + 1);
}


x86 assembly (clang, -O0):
<checkdist>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8f0,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1799 <checkdist+0x5e9>
mov    -0x10(%rbp),%rax
xor    %ecx,%ecx
sub    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
xor    %edi,%edi
call   1080 <dvector@plt>
mov    %rax,-0x8b8(%rbp)
movl   $0x1,-0x8ac(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1631 <checkdist+0x481>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     161e <checkdist+0x46e>
cmpl   $0x1,0x38(%rbp)
jne    129f <checkdist+0xef>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     129a <checkdist+0xea>
jmp    1610 <checkdist+0x460>
jmp    129f <checkdist+0xef>
cmpl   $0x2,0x38(%rbp)
jne    12cf <checkdist+0x11f>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    12ca <checkdist+0x11a>
jmp    1610 <checkdist+0x460>
jmp    12cf <checkdist+0x11f>
cmpl   $0x1,0x30(%rbp)
jne    1313 <checkdist+0x163>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jb     1313 <checkdist+0x163>
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    130e <checkdist+0x15e>
jmp    1610 <checkdist+0x460>
jmp    1313 <checkdist+0x163>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1cf2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1399 <checkdist+0x1e9>
jp     1399 <checkdist+0x1e9>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3c96(%rip),%rax
cvtsi2ssq (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1370 <checkdist+0x1c0>
jp     1370 <checkdist+0x1c0>
jmp    138f <checkdist+0x1df>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1394 <checkdist+0x1e4>
jmp    1610 <checkdist+0x460>
jmp    1544 <checkdist+0x394>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1c54(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    147d <checkdist+0x2cd>
jp     147d <checkdist+0x2cd>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sin@plt>
mov    %eax,-0x8c8(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sin@plt>
mov    %eax,%ecx
mov    -0x8c8(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8c0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    %eax,-0x8c4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    %eax,%ecx
mov    -0x8c4(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8bc(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    -0x8c0(%rbp),%edi
mov    %eax,%ecx
mov    -0x8bc(%rbp),%eax
imul   %ecx,%eax
add    %eax,%edi
call   1040 <acos@plt>
imul   $0x18e3,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    153f <checkdist+0x38f>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10d0 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1544 <checkdist+0x394>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1ac1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    156c <checkdist+0x3bc>
jp     156c <checkdist+0x3bc>
jmp    15eb <checkdist+0x43b>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15e6 <checkdist+0x436>
jp     15e6 <checkdist+0x436>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15e6 <checkdist+0x436>
jp     15e6 <checkdist+0x436>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15e6 <checkdist+0x436>
jp     15e6 <checkdist+0x436>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    15eb <checkdist+0x43b>
movsd  -0x48(%rbp),%xmm0
mov    -0x8b8(%rbp),%rax
mov    -0x8ac(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x8ac(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1263 <checkdist+0xb3>
jmp    1623 <checkdist+0x473>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    124e <checkdist+0x9e>
mov    -0x8ac(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8ac(%rbp)
mov    -0x8ac(%rbp),%edi
mov    -0x8b8(%rbp),%rsi
call   1090 <shellsortd@plt>
cmpl   $0x1,0x18(%rbp)
jle    16f2 <checkdist+0x542>
cmpl   $0x1,0x30(%rbp)
jne    16f2 <checkdist+0x542>
mov    -0x18(%rbp),%rax
movsd  0x198e(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     16ed <checkdist+0x53d>
mov    -0x8b8(%rbp),%rax
mov    %rax,-0x8d0(%rbp)
mov    -0x8ac(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x8d0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1689 <checkdist+0x4d9>
jmp    1758 <checkdist+0x5a8>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1753 <checkdist+0x5a3>
mov    -0x8b8(%rbp),%rax
mov    %rax,-0x8d8(%rbp)
mov    -0x8ac(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cltd
idivl  (%rcx)
mov    %eax,%ecx
mov    -0x8d8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16f9 <checkdist+0x549>
jmp    1758 <checkdist+0x5a8>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq (%rcx),%rcx
movsd  0x189d(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8b8(%rbp),%rdi
mov    -0x4(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
xor    %esi,%esi
call   10b0 <free_dvector@plt>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x69,-0x3c(%rbp)
jge    17e7 <checkdist+0x637>
movslq -0x3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x6f0(%rbp,%rax,8)
ff ff
movslq -0x3c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
movslq -0x3c(%rbp),%rax
movl   $0x0,-0x8a0(%rbp,%rax,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17a0 <checkdist+0x5f0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     181f <checkdist+0x66f>
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17ee <checkdist+0x63e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1030 <imatrix@plt>
mov    %rax,-0x8a8(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18ac <checkdist+0x6fc>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1899 <checkdist+0x6e9>
mov    -0x8a8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    185d <checkdist+0x6ad>
jmp    189e <checkdist+0x6ee>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    184a <checkdist+0x69a>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1e04 <checkdist+0xc54>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1df1 <checkdist+0xc41>
cmpl   $0x1,0x38(%rbp)
jne    1904 <checkdist+0x754>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     18ff <checkdist+0x74f>
jmp    1de3 <checkdist+0xc33>
jmp    1904 <checkdist+0x754>
cmpl   $0x2,0x38(%rbp)
jne    1934 <checkdist+0x784>
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    192f <checkdist+0x77f>
jmp    1de3 <checkdist+0xc33>
jmp    1934 <checkdist+0x784>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x16d1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    19ba <checkdist+0x80a>
jp     19ba <checkdist+0x80a>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3675(%rip),%rax
cvtsi2ssq (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1991 <checkdist+0x7e1>
jp     1991 <checkdist+0x7e1>
jmp    19b0 <checkdist+0x800>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    19b5 <checkdist+0x805>
jmp    1de3 <checkdist+0xc33>
jmp    1b65 <checkdist+0x9b5>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1633(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1a9e <checkdist+0x8ee>
jp     1a9e <checkdist+0x8ee>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sin@plt>
mov    %eax,-0x8e8(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1050 <sin@plt>
mov    %eax,%ecx
mov    -0x8e8(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8e0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    %eax,-0x8e4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    %eax,%ecx
mov    -0x8e4(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x8dc(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   10a0 <cos@plt>
mov    -0x8e0(%rbp),%edi
mov    %eax,%ecx
mov    -0x8dc(%rbp),%eax
imul   %ecx,%eax
add    %eax,%edi
call   1040 <acos@plt>
imul   $0x18e3,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1b60 <checkdist+0x9b0>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10d0 <sqrt@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1b65 <checkdist+0x9b5>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x14a0(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1b8d <checkdist+0x9dd>
jp     1b8d <checkdist+0x9dd>
jmp    1c0c <checkdist+0xa5c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1c07 <checkdist+0xa57>
jp     1c07 <checkdist+0xa57>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1c07 <checkdist+0xa57>
jp     1c07 <checkdist+0xa57>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1c07 <checkdist+0xa57>
jp     1c07 <checkdist+0xa57>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1c0c <checkdist+0xa5c>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq (%rcx),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1c43 <checkdist+0xa93>
cmpl   $0x0,-0x40(%rbp)
jne    1c43 <checkdist+0xa93>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movl   $0x1,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    1c89 <checkdist+0xad9>
movsd  0x13c5(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     1c84 <checkdist+0xad4>
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c89 <checkdist+0xad9>
cmpl   $0x1,0x30(%rbp)
jne    1ccf <checkdist+0xb1f>
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1ccf <checkdist+0xb1f>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jb     1ccf <checkdist+0xb1f>
movl   $0x1,-0x3c(%rbp)
jmp    1d2e <checkdist+0xb7e>
movl   $0x1,-0x3c(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x8e9(%rbp)
jbe    1d08 <checkdist+0xb58>
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
setle  %al
mov    %al,-0x8e9(%rbp)
mov    -0x8e9(%rbp),%al
test   $0x1,%al
jne    1d1b <checkdist+0xb6b>
jmp    1d29 <checkdist+0xb79>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1cd6 <checkdist+0xb26>
jmp    1d2e <checkdist+0xb7e>
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
movsd  -0x48(%rbp),%xmm0
movslq -0x3c(%rbp),%rax
addsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3a0(%rbp,%rax,8)
ff ff
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1dab <checkdist+0xbfb>
movsd  -0x48(%rbp),%xmm0
call   10c0 <log@plt>
movsd  %xmm0,-0x50(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x8a0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x8a0(%rbp,%rax,4)
movsd  -0x50(%rbp),%xmm0
movslq -0x3c(%rbp),%rax
addsd  -0x6f0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x6f0(%rbp,%rax,8)
ff ff
mov    -0x8a8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8a8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18c8 <checkdist+0x718>
jmp    1df6 <checkdist+0xc46>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18b3 <checkdist+0x703>
mov    0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1f1e <checkdist+0xd6e>
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1e73 <checkdist+0xcc3>
movslq -0x3c(%rbp),%rax
movsd  -0x3a0(%rbp,%rax,8),%xmm0
ff ff
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
divsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e90 <checkdist+0xce0>
mov    0x316e(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x3c(%rbp),%rax
cmpl   $0x0,-0x8a0(%rbp,%rax,4)
je     1ed2 <checkdist+0xd22>
movslq -0x3c(%rbp),%rax
movsd  -0x6f0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x3c(%rbp),%rax
cvtsi2sdl -0x8a0(%rbp,%rax,4),%xmm1
ff ff
divsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1eef <checkdist+0xd3f>
mov    0x310f(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1e22 <checkdist+0xc72>
mov    0x30c3(%rip),%rax
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x40(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     20db <checkdist+0xf2b>
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     20c8 <checkdist+0xf18>
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2056 <checkdist+0xea6>
mov    -0x8a8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1fd9 <checkdist+0xe29>
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x1057(%rip),%xmm0
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x8a8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
movsd  0x100a(%rip),%xmm1
mulsd  %xmm2,%xmm1
cvtsi2sdl -0x4(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqr@plt>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f94 <checkdist+0xde4>
cvtsi2ssl -0x4(%rbp),%xmm1
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
call   10d0 <sqrt@plt>
cvtsi2sd %eax,%xmm0
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
movsd  0xf6e(%rip),%xmm1
mulsd  %xmm2,%xmm1
cvtsi2sdl -0x4(%rbp),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
jmp    20cd <checkdist+0xf1d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1f45 <checkdist+0xd95>
mov    0x58(%rbp),%rax
mov    (%rax),%rax
movss  0xf3e(%rip),%xmm0
movss  %xmm0,(%rax)
mov    0x58(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
mov    -0x8a8(%rbp),%rdi
mov    -0x4(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%r8d
add    $0x1,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1070 <free_imatrix@plt>
add    $0x8f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkdist>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8f8,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0x58(%rsp)
mov    %rcx,0x68(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,%r12
mov    %edi,%r14d
mov    0x978(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x970(%rsp),%r15
mov    0x968(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x960(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x958(%rsp),%eax
mov    %eax,0x4(%rsp)
mov    0x950(%rsp),%eax
mov    %eax,0x44(%rsp)
mov    0x948(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x940(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x930(%rsp),%rax
mov    %rax,0x30(%rsp)
mov    (%rsi),%ebx
test   %ebx,%ebx
mov    %r14,0x10(%rsp)
mov    %rsi,0x60(%rsp)
mov    %r15,0x50(%rsp)
jns    1714 <checkdist+0x554>
mov    0x938(%rsp),%eax
mov    %eax,0x80(%rsp)
neg    %ebx
mov    %ebx,(%r12)
lea    -0x1(%r14),%eax
imul   %r14d,%eax
mov    %eax,%esi
shr    $0x1f,%esi
add    %eax,%esi
sar    %esi
xor    %edi,%edi
mov    %esi,0x48(%rsp)
call   1090 <dvector@plt>
mov    %rax,%rbx
mov    $0x1,%ebp
cmp    $0x2,%r14d
mov    0x68(%rsp),%r14
mov    0x4(%rsp),%ecx
mov    0x30(%rsp),%rsi
mov    %rax,0x8(%rsp)
jl     152d <checkdist+0x36d>
mov    0x10(%rsp),%eax
mov    %rax,0x70(%rsp)
lea    -0x1(%rax),%r12
mov    $0x1,%ebp
mov    $0x1,%r13d
xor    %r15d,%r15d
movsd  0xd0c(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    1319 <checkdist+0x159>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r15
add    $0x1,%r15
mov    0x18(%rsp),%r13
cmp    0x70(%rsp),%r13
je     152d <checkdist+0x36d>
lea    0x1(%r13),%rax
mov    %rax,0x18(%rsp)
mov    %r15,0x28(%rsp)
jmp    1344 <checkdist+0x184>
nopl   0x0(%rax)
movslq %ebp,%rax
add    $0x1,%ebp
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%r15
cmp    %r15,%r12
je     1300 <checkdist+0x140>
cmp    $0x2,%ecx
je     1360 <checkdist+0x1a0>
cmp    $0x1,%ecx
jne    1370 <checkdist+0x1b0>
mov    0x38(%rsp),%rdx
mov    (%rdx,%r13,4),%eax
cmp    0x8(%rdx,%r15,4),%eax
jne    133b <checkdist+0x17b>
jmp    1370 <checkdist+0x1b0>
mov    0x38(%rsp),%rdx
mov    (%rdx,%r13,4),%eax
cmp    0x8(%rdx,%r15,4),%eax
je     133b <checkdist+0x17b>
mov    (%rsi),%rax
movsd  (%rax),%xmm0
cmpl   $0x1,0x44(%rsp)
jne    1397 <checkdist+0x1d7>
ucomisd %xmm0,%xmm3
jb     1397 <checkdist+0x1d7>
mov    0xa0(%rsp),%rdx
mov    (%rdx,%r13,4),%eax
cmp    0x8(%rdx,%r15,4),%eax
je     133b <checkdist+0x17b>
ucomisd %xmm2,%xmm0
jne    13d2 <checkdist+0x212>
jp     13d2 <checkdist+0x212>
mov    (%rsi,%r13,8),%rax
mov    0x2c3e(%rip),%rdx
xorps  %xmm1,%xmm1
cvtsi2ssq (%rdx),%xmm1
movsd  0x10(%rax,%r15,8),%xmm0
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14bc <checkdist+0x2fc>
jp     14bc <checkdist+0x2fc>
jmp    133b <checkdist+0x17b>
ucomisd 0xc2e(%rip),%xmm0
movsd  (%r14,%r13,8),%xmm0
jne    1455 <checkdist+0x295>
jp     1455 <checkdist+0x295>
call   1060 <sin@plt>
mov    %eax,%ebx
movsd  0x10(%r14,%r15,8),%xmm0
call   1060 <sin@plt>
imul   %eax,%ebx
movsd  (%r14,%r13,8),%xmm0
call   10b0 <cos@plt>
mov    %eax,%r14d
mov    0x68(%rsp),%rax
movsd  0x10(%rax,%r15,8),%xmm0
call   10b0 <cos@plt>
imul   %eax,%r14d
mov    0x58(%rsp),%rax
movsd  0x10(%rax,%r15,8),%xmm0
subsd  (%rax,%r13,8),%xmm0
call   10b0 <cos@plt>
imul   %eax,%r14d
add    %ebx,%r14d
mov    0x8(%rsp),%rbx
mov    %r14d,%edi
mov    0x68(%rsp),%r14
call   1040 <acos@plt>
imul   $0x18e3,%eax,%eax
jmp    14a0 <checkdist+0x2e0>
subsd  0x10(%r14,%r15,8),%xmm0
mov    0x58(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
subsd  0x10(%rax,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x78(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
subsd  0x10(%rax,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   10e0 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x4(%rsp),%ecx
mov    0x30(%rsp),%rsi
movsd  0xb48(%rip),%xmm2
xorpd  %xmm3,%xmm3
mov    (%rsi),%rax
movsd  (%rax),%xmm1
ucomisd %xmm2,%xmm1
jne    14cf <checkdist+0x30f>
jnp    1330 <checkdist+0x170>
movsd  (%r14,%r13,8),%xmm1
ucomisd 0x10(%r14,%r15,8),%xmm1
jne    1330 <checkdist+0x170>
jp     1330 <checkdist+0x170>
mov    0x58(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
ucomisd 0x10(%rax,%r15,8),%xmm1
jne    1330 <checkdist+0x170>
jp     1330 <checkdist+0x170>
mov    0x78(%rsp),%rax
movsd  (%rax,%r13,8),%xmm1
ucomisd 0x10(%rax,%r15,8),%xmm1
jne    1330 <checkdist+0x170>
jp     1330 <checkdist+0x170>
xorpd  %xmm0,%xmm0
jmp    1330 <checkdist+0x170>
mov    %rbp,%r13
add    $0xffffffff,%ebp
mov    %ebp,%edi
mov    %rbx,%rsi
call   10a0 <shellsortd@plt>
cmpl   $0x2,0x80(%rsp)
02
jl     1617 <checkdist+0x457>
cmpl   $0x1,0x44(%rsp)
jne    1617 <checkdist+0x457>
movabs $0xbff0000000000000,%rax
mov    0x20(%rsp),%r14
mov    %rax,0x8(%r14)
mov    0x60(%rsp),%r12
mov    (%r12),%r11d
lea    0x1(%r11),%r8d
mov    %r8d,(%r12)
test   %r11d,%r11d
jle    16b9 <checkdist+0x4f9>
lea    0x2(%r11),%r9d
mov    $0x2,%edi
cmp    $0x3,%r9d
je     15ef <checkdist+0x42f>
mov    %rbx,%r15
lea    -0x2(%r9),%r10
lea    -0x2(%r13,%r13,1),%ebx
and    $0xfffffffffffffffe,%r10
neg    %r10
mov    $0x2,%edi
mov    %ebp,%ecx
mov    %ebx,%esi
xchg   %ax,%ax
mov    %ecx,%eax
cltd
idiv   %r11d
cltq
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
mov    %esi,%eax
cltd
idiv   %r11d
cltq
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdi,8)
add    %ebx,%esi
add    %ebx,%ecx
lea    (%r10,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x2,%rax
jne    15b0 <checkdist+0x3f0>
test   $0x1,%r9b
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r15
mov    0x48(%rsp),%r13d
je     16b2 <checkdist+0x4f2>
lea    -0x1(%rdi),%eax
imul   %ebp,%eax
cltd
idiv   %r11d
jmp    16d3 <checkdist+0x513>
mov    0x60(%rsp),%r12
mov    (%r12),%r8d
test   %r8d,%r8d
jle    16b9 <checkdist+0x4f9>
mov    0x48(%rsp),%r10d
mov    $0x1,%edi
cmp    $0x1,%r8d
mov    0x20(%rsp),%r11
je     169f <checkdist+0x4df>
mov    %rbx,%r14
lea    -0x2(%r13,%r13,1),%ebx
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
neg    %r9
mov    $0x1,%edi
mov    %ebx,%ecx
mov    %ebp,%esi
nopl   0x0(%rax)
mov    %esi,%eax
cltd
idiv   %r8d
cltq
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rdi,8)
mov    %ecx,%eax
cltd
idiv   %r8d
cltq
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%r11,%rdi,8)
add    %ebx,%esi
add    %ebx,%ecx
lea    (%r9,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
jne    1660 <checkdist+0x4a0>
test   $0x1,%r8b
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r15
mov    %r10d,%r13d
jne    16ca <checkdist+0x50a>
mov    0x8(%rsp),%rbx
jmp    16e9 <checkdist+0x529>
mov    0x10(%rsp),%r14
mov    0x50(%rsp),%r15
mov    0x48(%rsp),%r13d
jmp    16e9 <checkdist+0x529>
imul   %edi,%ebp
mov    %ebp,%eax
cltd
idiv   %r8d
cltq
mov    0x8(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%rdi,8)
movslq %r8d,%rax
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x912(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   10c0 <free_dvector@plt>
mov    (%r12),%ebx
lea    0x260(%rsp),%rdi
mov    $0x348,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x5b0(%rsp),%rdi
mov    $0x348,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0xb0(%rsp),%rdi
mov    $0x1a4,%edx
xor    %esi,%esi
call   1050 <memset@plt>
cmp    $0xffffffff,%ebx
jl     1776 <checkdist+0x5b6>
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
movl   $0x0,0x4(%r15,%rax,4)
movslq (%r12),%rbx
add    $0x1,%rax
cmp    %rbx,%rax
jle    1760 <checkdist+0x5a0>
add    $0x1,%ebx
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebx,%ecx
call   1030 <imatrix@plt>
mov    %rax,0x8(%rsp)
test   %r14d,%r14d
mov    0x4(%rsp),%r8d
mov    0x20(%rsp),%rbp
mov    0x30(%rsp),%r9
js     1c6a <checkdist+0xaaa>
mov    0x10(%rsp),%rbx
lea    0x1(%rbx),%r14d
mov    (%r12),%ecx
test   %ebx,%ebx
je     1847 <checkdist+0x687>
mov    %r14d,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
jmp    17d9 <checkdist+0x619>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rax
cmp    %rdx,%rax
je     1849 <checkdist+0x689>
cmp    $0xffffffff,%ecx
jl     1805 <checkdist+0x645>
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,8),%rsi
mov    $0xffffffffffffffff,%rdi
xchg   %ax,%ax
movl   $0x0,0x4(%rsi,%rdi,4)
movslq (%r12),%rcx
add    $0x1,%rdi
cmp    %rcx,%rdi
jle    17f0 <checkdist+0x630>
cmp    $0xffffffff,%ecx
jl     17d0 <checkdist+0x610>
lea    0x0(,%rax,8),%rcx
or     $0x8,%rcx
mov    0x8(%rsp),%rsi
mov    (%rsi,%rcx,1),%rsi
mov    $0xffffffffffffffff,%rdi
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,0x4(%rsi,%rdi,4)
movslq (%r12),%rcx
add    $0x1,%rdi
cmp    %rcx,%rdi
jle    1830 <checkdist+0x670>
jmp    17d0 <checkdist+0x610>
xor    %eax,%eax
test   $0x1,%r14b
je     1885 <checkdist+0x6c5>
cmp    $0xffffffff,%ecx
jl     1885 <checkdist+0x6c5>
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    $0xffffffffffffffff,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,0x4(%rax,%rcx,4)
movslq (%r12),%rdx
add    $0x1,%rcx
cmp    %rdx,%rcx
jle    1870 <checkdist+0x6b0>
cmp    $0x2,%ebx
jl     1c6a <checkdist+0xaaa>
mov    0x10(%rsp),%eax
mov    %rax,0xa8(%rsp)
mov    $0x2,%r13d
mov    $0x1,%r15d
movsd  0x752(%rip),%xmm2
xorpd  %xmm3,%xmm3
movl   $0x0,0x18(%rsp)
mov    %r14,0x70(%rsp)
jmp    18ef <checkdist+0x72f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%r13
add    $0x1,%r13
mov    0x48(%rsp),%r15
cmp    0xa8(%rsp),%r15
je     1c6a <checkdist+0xaaa>
lea    0x1(%r15),%rax
mov    %rax,0x48(%rsp)
mov    %r13,0x80(%rsp)
jmp    192e <checkdist+0x76e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rcx
mov    (%rcx,%r15,8),%rax
addl   $0x1,(%rax,%rbx,4)
mov    (%rcx,%r13,8),%rax
addl   $0x1,(%rax,%rbx,4)
add    $0x1,%r13
cmp    %r14,%r13
je     18d0 <checkdist+0x710>
cmp    $0x2,%r8d
je     1950 <checkdist+0x790>
cmp    $0x1,%r8d
jne    195f <checkdist+0x79f>
mov    0x38(%rsp),%rcx
mov    (%rcx,%r15,4),%eax
cmp    (%rcx,%r13,4),%eax
jne    1925 <checkdist+0x765>
jmp    195f <checkdist+0x79f>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rcx
mov    (%rcx,%r15,4),%eax
cmp    (%rcx,%r13,4),%eax
je     1925 <checkdist+0x765>
mov    (%r9),%rax
movsd  (%rax),%xmm0
ucomisd %xmm2,%xmm0
jne    19a0 <checkdist+0x7e0>
jp     19a0 <checkdist+0x7e0>
mov    (%r9,%r15,8),%rax
mov    0x266f(%rip),%rcx
xorps  %xmm1,%xmm1
cvtsi2ssq (%rcx),%xmm1
movsd  (%rax,%r13,8),%xmm0
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1aaa <checkdist+0x8ea>
jp     1aaa <checkdist+0x8ea>
jmp    1925 <checkdist+0x765>
nopl   (%rax)
ucomisd 0x660(%rip),%xmm0
mov    0x68(%rsp),%r14
movsd  (%r14,%r15,8),%xmm0
movsd  %xmm3,0x28(%rsp)
jne    1a39 <checkdist+0x879>
jp     1a39 <checkdist+0x879>
call   1060 <sin@plt>
mov    %eax,%ebx
movsd  (%r14,%r13,8),%xmm0
call   1060 <sin@plt>
imul   %eax,%ebx
movsd  (%r14,%r15,8),%xmm0
call   10b0 <cos@plt>
mov    %eax,%r12d
movsd  (%r14,%r13,8),%xmm0
call   10b0 <cos@plt>
imul   %eax,%r12d
mov    0x58(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
subsd  (%rax,%r15,8),%xmm0
call   10b0 <cos@plt>
imul   %eax,%r12d
add    %ebx,%r12d
mov    %r12d,%edi
mov    0x60(%rsp),%r12
call   1040 <acos@plt>
movsd  0x28(%rsp),%xmm3
movsd  0x5d9(%rip),%xmm2
mov    0x30(%rsp),%r9
mov    0x4(%rsp),%r8d
imul   $0x18e3,%eax,%eax
jmp    1a99 <checkdist+0x8d9>
subsd  (%r14,%r13,8),%xmm0
mov    0x58(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
subsd  (%rax,%r13,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x78(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
subsd  (%rax,%r13,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   10e0 <sqrt@plt>
movsd  0x28(%rsp),%xmm3
movsd  0x571(%rip),%xmm2
mov    0x30(%rsp),%r9
mov    0x4(%rsp),%r8d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x20(%rsp),%rbp
mov    0x70(%rsp),%r14
mov    (%r9),%rax
movsd  (%rax),%xmm1
ucomisd %xmm2,%xmm1
jne    1ab9 <checkdist+0x8f9>
jnp    1b00 <checkdist+0x940>
mov    0x68(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm1
ucomisd (%rcx,%r13,8),%xmm1
jne    1b00 <checkdist+0x940>
jp     1b00 <checkdist+0x940>
mov    0x58(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm1
ucomisd (%rcx,%r13,8),%xmm1
jne    1b00 <checkdist+0x940>
jp     1b00 <checkdist+0x940>
mov    0x78(%rsp),%rcx
movsd  (%rcx,%r15,8),%xmm1
ucomisd (%rcx,%r13,8),%xmm1
jne    1b00 <checkdist+0x940>
jp     1b00 <checkdist+0x940>
xorpd  %xmm0,%xmm0
nopl   0x0(%rax)
mov    (%r12),%ecx
movslq %ecx,%rdx
ucomisd 0x0(%rbp,%rdx,8),%xmm0
jbe    1b50 <checkdist+0x990>
cmpl   $0x0,0x18(%rsp)
jne    1b50 <checkdist+0x990>
add    $0x1,%rdx
mov    %edx,(%r12)
movl   $0x1,0x18(%rsp)
ucomisd %xmm3,%xmm0
jbe    1b78 <checkdist+0x9b8>
movapd %xmm0,%xmm3
mulsd  0x4e0(%rip),%xmm3
movl   $0x1,0x18(%rsp)
mov    %edx,%ecx
jmp    1b69 <checkdist+0x9a9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd %xmm3,%xmm0
jbe    1b7a <checkdist+0x9ba>
movapd %xmm0,%xmm3
mulsd  0x4b6(%rip),%xmm3
cmpl   $0x0,0x18(%rsp)
je     1ba4 <checkdist+0x9e4>
movsd  %xmm3,0x0(%rbp,%rdx,8)
cmpl   $0x1,0x44(%rsp)
je     1b81 <checkdist+0x9c1>
jmp    1bc0 <checkdist+0xa00>
mov    %edx,%ecx
cmpl   $0x1,0x44(%rsp)
jne    1bc0 <checkdist+0xa00>
mov    0xa0(%rsp),%rsi
mov    (%rsi,%r15,4),%edx
cmp    (%rsi,%r13,4),%edx
jne    1bc0 <checkdist+0xa00>
mov    $0x1,%edx
xorpd  %xmm1,%xmm1
ucomisd (%rax),%xmm1
jb     1bc0 <checkdist+0xa00>
jmp    1bf9 <checkdist+0xa39>
movl   $0x0,0x18(%rsp)
cmpl   $0x1,0x44(%rsp)
je     1b81 <checkdist+0x9c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x1,%edx
ucomisd 0x8(%rbp),%xmm0
jbe    1bf9 <checkdist+0xa39>
test   %ecx,%ecx
mov    $0x0,%eax
cmovle %eax,%ecx
lea    0x1(%rcx),%edx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
cmp    %rax,%rcx
je     1bf9 <checkdist+0xa39>
lea    0x1(%rax),%rsi
ucomisd 0x10(%rbp,%rax,8),%xmm0
mov    %rsi,%rax
ja     1be0 <checkdist+0xa20>
add    $0x1,%esi
mov    %esi,%edx
mov    %edx,%ebx
mov    0x50(%rsp),%rax
addl   $0x1,(%rax,%rbx,4)
movsd  0x5b0(%rsp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x5b0(%rsp,%rbx,8)
ucomisd 0x3fe(%rip),%xmm0
jbe    1910 <checkdist+0x750>
movsd  %xmm3,0x28(%rsp)
call   10d0 <log@plt>
movsd  0x28(%rsp),%xmm3
movsd  0x3bf(%rip),%xmm2
mov    0x30(%rsp),%r9
mov    0x4(%rsp),%r8d
addl   $0x1,0xb0(%rsp,%rbx,4)
01
addsd  0x260(%rsp,%rbx,8),%xmm0
movsd  %xmm0,0x260(%rsp,%rbx,8)
jmp    1910 <checkdist+0x750>
movslq (%r12),%rax
mov    0x50(%rsp),%r13
movl   $0x0,0x4(%r13,%rax,4)
mov    0x2365(%rip),%rax
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
mov    (%r12),%r8d
cvtss2sd %xmm0,%xmm0
test   %r8d,%r8d
jle    1e7c <checkdist+0xcbc>
xor    %ecx,%ecx
mov    0x10(%rsp),%r15
mov    0x98(%rsp),%r12
mov    0x90(%rsp),%rdi
mov    0x88(%rsp),%rbp
jmp    1cdf <checkdist+0xb1f>
nopl   (%rax)
movsd  %xmm1,0x8(%rbp,%rcx,8)
movslq %r8d,%rsi
add    %edx,0x4(%r13,%rsi,4)
mov    0x60(%rsp),%rdx
movslq (%rdx),%r8
add    $0x1,%rcx
cmp    %r8,%rcx
jge    1d29 <checkdist+0xb69>
mov    0x4(%r13,%rcx,4),%edx
movaps %xmm0,%xmm1
test   %edx,%edx
je     1cff <checkdist+0xb3f>
movsd  0x5b8(%rsp,%rcx,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %edx,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
mov    0xb4(%rsp,%rcx,4),%esi
movaps %xmm0,%xmm1
test   %esi,%esi
je     1cc0 <checkdist+0xb00>
movsd  0x268(%rsp,%rcx,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
divsd  %xmm2,%xmm1
jmp    1cc0 <checkdist+0xb00>
xorps  %xmm0,%xmm0
cvtsi2ssq (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  %xmm0,(%rdi)
test   %r8d,%r8d
jle    1ea1 <checkdist+0xce1>
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,0x38(%rsp)
lea    -0x1(%r15),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
movss  %xmm0,0x18(%rsp)
lea    0x1(%r15),%r14d
mov    $0x1,%ebp
jmp    1dda <checkdist+0xc1a>
nop
movss  (%rax),%xmm1
divss  0x18(%rsp),%xmm1
movss  %xmm1,(%rax)
call   10e0 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x0(%r13,%rbp,4),%xmm1
addsd  %xmm1,%xmm1
divsd  0x38(%rsp),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r12,%rbp,8),%rax
movss  %xmm0,0x4(%rax)
mov    0x60(%rsp),%rax
mov    (%rax),%r8d
lea    0x1(%rbp),%rax
movslq %r8d,%rcx
cmp    %rcx,%rbp
mov    %rax,%rbp
jge    1ea1 <checkdist+0xce1>
cmpl   $0x0,0x0(%r13,%rbp,4)
je     1dc7 <checkdist+0xc07>
mov    (%r12,%rbp,8),%rax
movq   $0x0,(%rax)
test   %r15d,%r15d
jle    1e70 <checkdist+0xcb0>
mov    $0x1,%ebx
jmp    1e4d <checkdist+0xc8d>
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x0(%r13,%rbp,4),%xmm1
addsd  %xmm1,%xmm1
divsd  0x38(%rsp),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1070 <sqr@plt>
divsd  0x28(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    (%r12,%rbp,8),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
add    $0x1,%rbx
cmp    %rbx,%r14
je     1d80 <checkdist+0xbc0>
mov    0x8(%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    (%rcx,%rbp,4),%ecx
test   %ecx,%ecx
je     1e00 <checkdist+0xc40>
movss  (%rax),%xmm0
addss  0x1bf(%rip),%xmm0
movss  %xmm0,(%rax)
jmp    1e00 <checkdist+0xc40>
nop
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
jmp    1d84 <checkdist+0xbc4>
mov    0x88(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x90(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rsp),%r15
mov    0x98(%rsp),%r12
mov    (%r12),%rax
movq   $0x3f800000,(%rax)
add    $0x1,%r8d
mov    0x8(%rsp),%rdi
xor    %esi,%esi
mov    %r15d,%edx
xor    %ecx,%ecx
add    $0x8f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <free_imatrix@plt>

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

LLVM IR (-O2):
@HUGE_VAL = global i64 0
define void @checkdist(i32 %0, i32* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, double** nocapture %6, i32 %7, i32* nocapture %8, i32* nocapture %9, i32 %10, i32 %11, double* nocapture writeonly %12, double* nocapture writeonly %13, i32* nocapture %14, float** nocapture %15) {
%17 = alloca [105 x double]
%18 = bitcast [105 x double]* %17 to i8*
%19 = alloca [105 x double]
%20 = bitcast [105 x double]* %19 to i8*
%21 = alloca [105 x i32]
%22 = bitcast [105 x i32]* %21 to i8*
%23 = load i32, i32* %1
%24 = icmp slt i32 %23, 0
br i1 %24, label %25, label %260
25: ; preds = %16
%26 = sub nsw i32 0, %23
store i32 %26, i32* %1
%27 = add nsw i32 %0, -1
%28 = mul nsw i32 %27, %0
%29 = sdiv i32 %28, 2
%30 = tail call double* @dvector(i32 0, i32 %29)
%31 = icmp sgt i32 %0, 1
br i1 %31, label %32, label %156
32: ; preds = %25
%33 = icmp ne i32 %10, 1
%34 = add nuw i32 %0, 1
%35 = zext i32 %0 to i64
%36 = zext i32 %34 to i64
br label %40
37: ; preds = %152
%38 = add nuw nsw i64 %42, 1
%39 = icmp eq i64 %44, %35
br i1 %39, label %156, label %40
40: ; preds = %37, %32
%41 = phi i64 [ 1, %32 ], [ %44, %37 ]
%42 = phi i64 [ 2, %32 ], [ %38, %37 ]
%43 = phi i32 [ 1, %32 ], [ %153, %37 ]
%44 = add nuw nsw i64 %41, 1
%45 = getelementptr inbounds i32, i32* %9, i64 %41
%46 = getelementptr inbounds i32, i32* %8, i64 %41
%47 = getelementptr inbounds double, double* %3, i64 %41
%48 = getelementptr inbounds double, double* %4, i64 %41
%49 = getelementptr inbounds double, double* %5, i64 %41
%50 = getelementptr inbounds double*, double** %6, i64 %41
br label %51
51: ; preds = %40, %152
%52 = phi i64 [ %42, %40 ], [ %154, %152 ]
%53 = phi i32 [ %43, %40 ], [ %153, %152 ]
switch i32 %11, label %64 [
i32 1, label %54
i32 2, label %59
]
54: ; preds = %51
%55 = load i32, i32* %45
%56 = getelementptr inbounds i32, i32* %9, i64 %52
%57 = load i32, i32* %56
%58 = icmp eq i32 %55, %57
br i1 %58, label %64, label %152
59: ; preds = %51
%60 = load i32, i32* %45
%61 = getelementptr inbounds i32, i32* %9, i64 %52
%62 = load i32, i32* %61
%63 = icmp eq i32 %60, %62
br i1 %63, label %152, label %64
64: ; preds = %54, %51, %59
%65 = load double*, double** %6
%66 = load double, double* %65
%67 = fcmp ugt double %66, 0.000000e+00
%68 = select i1 %33, i1 true, i1 %67
br i1 %68, label %74, label %69
69: ; preds = %64
%70 = load i32, i32* %46
%71 = getelementptr inbounds i32, i32* %8, i64 %52
%72 = load i32, i32* %71
%73 = icmp eq i32 %70, %72
br i1 %73, label %152, label %74
74: ; preds = %64, %69
%75 = fcmp oeq double %66, 1.000000e+00
br i1 %75, label %76, label %84
76: ; preds = %74
%77 = load double*, double** %50
%78 = getelementptr inbounds double, double* %77, i64 %52
%79 = load double, double* %78
%80 = load i64, i64* @HUGE_VAL
%81 = sitofp i64 %80 to float
%82 = fpext float %81 to double
%83 = fcmp une double %79, %82
br i1 %83, label %126, label %152
84: ; preds = %74
%85 = fcmp oeq double %66, -1.000000e+00
%86 = load double, double* %47
br i1 %85, label %87, label %108
87: ; preds = %84
%88 = tail call i32 @sin(double %86)
%89 = getelementptr inbounds double, double* %3, i64 %52
%90 = load double, double* %89
%91 = tail call i32 @sin(double %90)
%92 = mul nsw i32 %91, %88
%93 = load double, double* %47
%94 = tail call i32 @cos(double %93)
%95 = load double, double* %89
%96 = tail call i32 @cos(double %95)
%97 = mul nsw i32 %96, %94
%98 = getelementptr inbounds double, double* %4, i64 %52
%99 = load double, double* %98
%100 = load double, double* %48
%101 = fsub double %99, %100
%102 = tail call i32 @cos(double %101)
%103 = mul nsw i32 %97, %102
%104 = add nsw i32 %103, %92
%105 = tail call i32 @acos(i32 %104)
%106 = mul nsw i32 %105, 6371
%107 = sitofp i32 %106 to double
br label %126
108: ; preds = %84
%109 = getelementptr inbounds double, double* %3, i64 %52
%110 = load double, double* %109
%111 = fsub double %86, %110
%112 = load double, double* %48
%113 = getelementptr inbounds double, double* %4, i64 %52
%114 = load double, double* %113
%115 = fsub double %112, %114
%116 = fmul double %115, %115
%117 = tail call double @llvm.fmuladd.f64(double %111, double %111, double %116)
%118 = load double, double* %49
%119 = getelementptr inbounds double, double* %5, i64 %52
%120 = load double, double* %119
%121 = fsub double %118, %120
%122 = tail call double @llvm.fmuladd.f64(double %121, double %121, double %117)
%123 = fptrunc double %122 to float
%124 = tail call i32 @sqrt(float %123)
%125 = sitofp i32 %124 to double
br label %126
126: ; preds = %76, %87, %108
%127 = phi double [ %107, %87 ], [ %125, %108 ], [ %79, %76 ]
%128 = load double*, double** %6
%129 = load double, double* %128
%130 = fcmp une double %129, 1.000000e+00
br i1 %130, label %131, label %147
131: ; preds = %126
%132 = load double, double* %47
%133 = getelementptr inbounds double, double* %3, i64 %52
%134 = load double, double* %133
%135 = fcmp oeq double %132, %134
br i1 %135, label %136, label %147
136: ; preds = %131
%137 = load double, double* %48
%138 = getelementptr inbounds double, double* %4, i64 %52
%139 = load double, double* %138
%140 = fcmp oeq double %137, %139
br i1 %140, label %141, label %147
141: ; preds = %136
%142 = load double, double* %49
%143 = getelementptr inbounds double, double* %5, i64 %52
%144 = load double, double* %143
%145 = fcmp oeq double %142, %144
br i1 %145, label %146, label %147
146: ; preds = %141
br label %147
147: ; preds = %131, %136, %141, %146, %126
%148 = phi double [ 0.000000e+00, %146 ], [ %127, %141 ], [ %127, %136 ], [ %127, %131 ], [ %127, %126 ]
%149 = add nsw i32 %53, 1
%150 = sext i32 %53 to i64
%151 = getelementptr inbounds double, double* %30, i64 %150
store double %148, double* %151
br label %152
152: ; preds = %76, %69, %59, %54, %147
%153 = phi i32 [ %53, %54 ], [ %53, %59 ], [ %53, %69 ], [ %149, %147 ], [ %53, %76 ]
%154 = add nuw nsw i64 %52, 1
%155 = icmp eq i64 %154, %36
br i1 %155, label %37, label %51
156: ; preds = %37, %25
%157 = phi i32 [ 1, %25 ], [ %153, %37 ]
%158 = add nsw i32 %157, -1
%159 = tail call i32 @shellsortd(i32 %158, double* %30)
%160 = icmp sgt i32 %7, 1
%161 = icmp eq i32 %10, 1
%162 = and i1 %160, %161
br i1 %162, label %172, label %163
163: ; preds = %156
%164 = load i32, i32* %1
%165 = icmp slt i32 %164, 1
br i1 %165, label %252, label %166
166: ; preds = %163
%167 = zext i32 %164 to i64
%168 = and i64 %167, 1
%169 = icmp eq i32 %164, 1
br i1 %169, label %241, label %170
170: ; preds = %166
%171 = and i64 %167, 4294967294
br label %208
172: ; preds = %156
%173 = getelementptr inbounds double, double* %2, i64 1
store double -1.000000e+00, double* %173
%174 = load i32, i32* %1
%175 = add nsw i32 %174, 1
store i32 %175, i32* %1
%176 = icmp slt i32 %174, 1
br i1 %176, label %252, label %177
177: ; preds = %172
%178 = add i32 %174, 2
%179 = zext i32 %178 to i64
%180 = and i64 %179, 1
%181 = icmp eq i32 %178, 3
br i1 %181, label %229, label %182
182: ; preds = %177
%183 = add nsw i64 %179, -2
%184 = and i64 %183, -2
br label %185
185: ; preds = %185, %182
%186 = phi i64 [ 2, %182 ], [ %205, %185 ]
%187 = phi i64 [ 0, %182 ], [ %206, %185 ]
%188 = trunc i64 %186 to i32
%189 = add i32 %188, -1
%190 = mul i32 %189, %158
%191 = sdiv i32 %190, %174
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %30, i64 %192
%194 = load double, double* %193
%195 = getelementptr inbounds double, double* %2, i64 %186
store double %194, double* %195
%196 = or i64 %186, 1
%197 = trunc i64 %196 to i32
%198 = add nsw i32 %197, -1
%199 = mul i32 %198, %158
%200 = sdiv i32 %199, %174
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %30, i64 %201
%203 = load double, double* %202
%204 = getelementptr inbounds double, double* %2, i64 %196
store double %203, double* %204
%205 = add nuw nsw i64 %186, 2
%206 = add i64 %187, 2
%207 = icmp eq i64 %206, %184
br i1 %207, label %229, label %185
208: ; preds = %208, %170
%209 = phi i64 [ 1, %170 ], [ %226, %208 ]
%210 = phi i64 [ 0, %170 ], [ %227, %208 ]
%211 = trunc i64 %209 to i32
%212 = mul i32 %158, %211
%213 = sdiv i32 %212, %164
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds double, double* %30, i64 %214
%216 = load double, double* %215
%217 = getelementptr inbounds double, double* %2, i64 %209
store double %216, double* %217
%218 = add nuw nsw i64 %209, 1
%219 = trunc i64 %218 to i32
%220 = mul i32 %158, %219
%221 = sdiv i32 %220, %164
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds double, double* %30, i64 %222
%224 = load double, double* %223
%225 = getelementptr inbounds double, double* %2, i64 %218
store double %224, double* %225
%226 = add nuw nsw i64 %209, 2
%227 = add i64 %210, 2
%228 = icmp eq i64 %227, %171
br i1 %228, label %241, label %208
229: ; preds = %185, %177
%230 = phi i64 [ 2, %177 ], [ %205, %185 ]
%231 = icmp eq i64 %180, 0
br i1 %231, label %252, label %232
232: ; preds = %229
%233 = trunc i64 %230 to i32
%234 = add i32 %233, -1
%235 = mul i32 %234, %158
%236 = sdiv i32 %235, %174
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds double, double* %30, i64 %237
%239 = load double, double* %238
%240 = getelementptr inbounds double, double* %2, i64 %230
store double %239, double* %240
br label %252
241: ; preds = %208, %166
%242 = phi i64 [ 1, %166 ], [ %226, %208 ]
%243 = icmp eq i64 %168, 0
br i1 %243, label %252, label %244
244: ; preds = %241
%245 = trunc i64 %242 to i32
%246 = mul i32 %158, %245
%247 = sdiv i32 %246, %164
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double, double* %30, i64 %248
%250 = load double, double* %249
%251 = getelementptr inbounds double, double* %2, i64 %242
store double %250, double* %251
br label %252
252: ; preds = %244, %241, %232, %229, %163, %172
%253 = phi i32 [ %164, %163 ], [ %175, %172 ], [ %175, %229 ], [ %175, %232 ], [ %164, %241 ], [ %164, %244 ]
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds double, double* %2, i64 %254
%256 = load double, double* %255
%257 = fmul double %256, 1.000100e+00
store double %257, double* %255
%258 = tail call i32 @free_dvector(double* %30, i32 0, i32 %29)
%259 = load i32, i32* %1
br label %260
260: ; preds = %252, %16
%261 = phi i32 [ %259, %252 ], [ %23, %16 ]
%262 = icmp slt i32 %261, -1
br i1 %262, label %270, label %263
263: ; preds = %260, %263
%264 = phi i64 [ %266, %263 ], [ 0, %260 ]
%265 = getelementptr inbounds i32, i32* %14, i64 %264
store i32 0, i32* %265
%266 = add nuw nsw i64 %264, 1
%267 = load i32, i32* %1
%268 = sext i32 %267 to i64
%269 = icmp sgt i64 %264, %268
br i1 %269, label %270, label %263
270: ; preds = %263, %260
%271 = phi i32 [ %261, %260 ], [ %267, %263 ]
%272 = add nsw i32 %271, 1
%273 = tail call i32** @imatrix(i32 0, i32 %0, i32 0, i32 %272)
%274 = icmp slt i32 %0, 0
br i1 %274, label %533, label %275
275: ; preds = %270
%276 = add nuw i32 %0, 1
%277 = zext i32 %276 to i64
%278 = load i32, i32* %1
%279 = and i64 %277, 1
%280 = icmp eq i32 %0, 0
br i1 %280, label %291, label %281
281: ; preds = %275
%282 = and i64 %277, 4294967294
br label %283
283: ; preds = %336, %281
%284 = phi i32 [ %278, %281 ], [ %337, %336 ]
%285 = phi i64 [ 0, %281 ], [ %338, %336 ]
%286 = phi i64 [ 0, %281 ], [ %339, %336 ]
%287 = icmp slt i32 %284, -1
br i1 %287, label %322, label %288
288: ; preds = %283
%289 = getelementptr inbounds i32*, i32** %273, i64 %285
%290 = load i32*, i32** %289
br label %315
291: ; preds = %336, %275
%292 = phi i32 [ %278, %275 ], [ %337, %336 ]
%293 = phi i64 [ 0, %275 ], [ %338, %336 ]
%294 = icmp eq i64 %279, 0
%295 = icmp slt i32 %292, -1
%296 = select i1 %294, i1 true, i1 %295
br i1 %296, label %307, label %297
297: ; preds = %291
%298 = getelementptr inbounds i32*, i32** %273, i64 %293
%299 = load i32*, i32** %298
br label %300
300: ; preds = %300, %297
%301 = phi i64 [ 0, %297 ], [ %303, %300 ]
%302 = getelementptr inbounds i32, i32* %299, i64 %301
store i32 0, i32* %302
%303 = add nuw nsw i64 %301, 1
%304 = load i32, i32* %1
%305 = sext i32 %304 to i64
%306 = icmp sgt i64 %301, %305
br i1 %306, label %307, label %300
307: ; preds = %300, %291
%308 = icmp sgt i32 %0, 1
br i1 %308, label %309, label %533
309: ; preds = %307
%310 = icmp eq i32 %10, 1
%311 = getelementptr inbounds double, double* %2, i64 1
%312 = add nuw i32 %0, 1
%313 = zext i32 %0 to i64
%314 = zext i32 %312 to i64
br label %344
315: ; preds = %288, %315
%316 = phi i64 [ 0, %288 ], [ %318, %315 ]
%317 = getelementptr inbounds i32, i32* %290, i64 %316
store i32 0, i32* %317
%318 = add nuw nsw i64 %316, 1
%319 = load i32, i32* %1
%320 = sext i32 %319 to i64
%321 = icmp sgt i64 %316, %320
br i1 %321, label %322, label %315
322: ; preds = %315, %283
%323 = phi i32 [ %284, %283 ], [ %319, %315 ]
%324 = icmp slt i32 %323, -1
br i1 %324, label %336, label %325
325: ; preds = %322
%326 = or i64 %285, 1
%327 = getelementptr inbounds i32*, i32** %273, i64 %326
%328 = load i32*, i32** %327
br label %329
329: ; preds = %329, %325
%330 = phi i64 [ 0, %325 ], [ %332, %329 ]
%331 = getelementptr inbounds i32, i32* %328, i64 %330
store i32 0, i32* %331
%332 = add nuw nsw i64 %330, 1
%333 = load i32, i32* %1
%334 = sext i32 %333 to i64
%335 = icmp sgt i64 %330, %334
br i1 %335, label %336, label %329
336: ; preds = %329, %322
%337 = phi i32 [ %323, %322 ], [ %333, %329 ]
%338 = add nuw nsw i64 %285, 2
%339 = add i64 %286, 2
%340 = icmp eq i64 %339, %282
br i1 %340, label %291, label %283
341: ; preds = %528
%342 = add nuw nsw i64 %346, 1
%343 = icmp eq i64 %349, %313
br i1 %343, label %533, label %344
344: ; preds = %341, %309
%345 = phi i64 [ 1, %309 ], [ %349, %341 ]
%346 = phi i64 [ 2, %309 ], [ %342, %341 ]
%347 = phi double [ 0.000000e+00, %309 ], [ %530, %341 ]
%348 = phi i32 [ 0, %309 ], [ %529, %341 ]
%349 = add nuw nsw i64 %345, 1
%350 = getelementptr inbounds i32, i32* %9, i64 %345
%351 = getelementptr inbounds double, double* %3, i64 %345
%352 = getelementptr inbounds double, double* %4, i64 %345
%353 = getelementptr inbounds double, double* %5, i64 %345
%354 = getelementptr inbounds double*, double** %6, i64 %345
%355 = getelementptr inbounds i32, i32* %8, i64 %345
%356 = getelementptr inbounds i32*, i32** %273, i64 %345
br label %357
357: ; preds = %344, %528
%358 = phi i64 [ %346, %344 ], [ %531, %528 ]
%359 = phi double [ %347, %344 ], [ %530, %528 ]
%360 = phi i32 [ %348, %344 ], [ %529, %528 ]
switch i32 %11, label %371 [
i32 1, label %361
i32 2, label %366
]
361: ; preds = %357
%362 = load i32, i32* %350
%363 = getelementptr inbounds i32, i32* %9, i64 %358
%364 = load i32, i32* %363
%365 = icmp eq i32 %362, %364
br i1 %365, label %371, label %528
366: ; preds = %357
%367 = load i32, i32* %350
%368 = getelementptr inbounds i32, i32* %9, i64 %358
%369 = load i32, i32* %368
%370 = icmp eq i32 %367, %369
br i1 %370, label %528, label %371
371: ; preds = %361, %357, %366
%372 = load double*, double** %6
%373 = load double, double* %372
%374 = fcmp oeq double %373, 1.000000e+00
br i1 %374, label %375, label %383
375: ; preds = %371
%376 = load double*, double** %354
%377 = getelementptr inbounds double, double* %376, i64 %358
%378 = load double, double* %377
%379 = load i64, i64* @HUGE_VAL
%380 = sitofp i64 %379 to float
%381 = fpext float %380 to double
%382 = fcmp une double %378, %381
br i1 %382, label %425, label %528
383: ; preds = %371
%384 = fcmp oeq double %373, -1.000000e+00
%385 = load double, double* %351
br i1 %384, label %386, label %407
386: ; preds = %383
%387 = tail call i32 @sin(double %385)
%388 = getelementptr inbounds double, double* %3, i64 %358
%389 = load double, double* %388
%390 = tail call i32 @sin(double %389)
%391 = mul nsw i32 %390, %387
%392 = load double, double* %351
%393 = tail call i32 @cos(double %392)
%394 = load double, double* %388
%395 = tail call i32 @cos(double %394)
%396 = mul nsw i32 %395, %393
%397 = getelementptr inbounds double, double* %4, i64 %358
%398 = load double, double* %397
%399 = load double, double* %352
%400 = fsub double %398, %399
%401 = tail call i32 @cos(double %400)
%402 = mul nsw i32 %396, %401
%403 = add nsw i32 %402, %391
%404 = tail call i32 @acos(i32 %403)
%405 = mul nsw i32 %404, 6371
%406 = sitofp i32 %405 to double
br label %425
407: ; preds = %383
%408 = getelementptr inbounds double, double* %3, i64 %358
%409 = load double, double* %408
%410 = fsub double %385, %409
%411 = load double, double* %352
%412 = getelementptr inbounds double, double* %4, i64 %358
%413 = load double, double* %412
%414 = fsub double %411, %413
%415 = fmul double %414, %414
%416 = tail call double @llvm.fmuladd.f64(double %410, double %410, double %415)
%417 = load double, double* %353
%418 = getelementptr inbounds double, double* %5, i64 %358
%419 = load double, double* %418
%420 = fsub double %417, %419
%421 = tail call double @llvm.fmuladd.f64(double %420, double %420, double %416)
%422 = fptrunc double %421 to float
%423 = tail call i32 @sqrt(float %422)
%424 = sitofp i32 %423 to double
br label %425
425: ; preds = %375, %386, %407
%426 = phi double [ %406, %386 ], [ %424, %407 ], [ %378, %375 ]
%427 = load double*, double** %6
%428 = load double, double* %427
%429 = fcmp une double %428, 1.000000e+00
br i1 %429, label %430, label %446
430: ; preds = %425
%431 = load double, double* %351
%432 = getelementptr inbounds double, double* %3, i64 %358
%433 = load double, double* %432
%434 = fcmp oeq double %431, %433
br i1 %434, label %435, label %446
435: ; preds = %430
%436 = load double, double* %352
%437 = getelementptr inbounds double, double* %4, i64 %358
%438 = load double, double* %437
%439 = fcmp oeq double %436, %438
br i1 %439, label %440, label %446
440: ; preds = %435
%441 = load double, double* %353
%442 = getelementptr inbounds double, double* %5, i64 %358
%443 = load double, double* %442
%444 = fcmp oeq double %441, %443
br i1 %444, label %445, label %446
445: ; preds = %440
br label %446
446: ; preds = %430, %435, %440, %445, %425
%447 = phi double [ 0.000000e+00, %445 ], [ %426, %440 ], [ %426, %435 ], [ %426, %430 ], [ %426, %425 ]
%448 = load i32, i32* %1
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %2, i64 %449
%451 = load double, double* %450
%452 = fcmp ogt double %447, %451
%453 = icmp eq i32 %360, 0
%454 = select i1 %452, i1 %453, i1 false
br i1 %454, label %457, label %455
455: ; preds = %446
%456 = fcmp ogt double %447, %359
br i1 %456, label %463, label %471
457: ; preds = %446
%458 = add nsw i32 %448, 1
store i32 %458, i32* %1
%459 = fcmp ogt double %447, %359
br i1 %459, label %460, label %471
460: ; preds = %457
%461 = fmul double %447, 0x3FF000010C6F7A0B
%462 = sext i32 %458 to i64
br label %465
463: ; preds = %455
%464 = fmul double %447, 0x3FF000010C6F7A0B
br i1 %453, label %471, label %465
465: ; preds = %460, %463
%466 = phi i64 [ %462, %460 ], [ %449, %463 ]
%467 = phi i32 [ %458, %460 ], [ %448, %463 ]
%468 = phi double [ %461, %460 ], [ %464, %463 ]
%469 = phi i32 [ 1, %460 ], [ %360, %463 ]
%470 = getelementptr inbounds double, double* %2, i64 %466
store double %468, double* %470
br label %471
471: ; preds = %457, %463, %465, %455
%472 = phi i32 [ %467, %465 ], [ %448, %463 ], [ %448, %455 ], [ %458, %457 ]
%473 = phi i32 [ %469, %465 ], [ 0, %463 ], [ %360, %455 ], [ 1, %457 ]
%474 = phi double [ %468, %465 ], [ %464, %463 ], [ %359, %455 ], [ %359, %457 ]
br i1 %310, label %475, label %483
475: ; preds = %471
%476 = load i32, i32* %355
%477 = getelementptr inbounds i32, i32* %8, i64 %358
%478 = load i32, i32* %477
%479 = icmp eq i32 %476, %478
br i1 %479, label %480, label %483
480: ; preds = %475
%481 = load double, double* %427
%482 = fcmp ugt double %481, 0.000000e+00
br i1 %482, label %483, label %500
483: ; preds = %480, %475, %471
%484 = load double, double* %311
%485 = fcmp ogt double %447, %484
br i1 %485, label %486, label %500
486: ; preds = %483
%487 = call i32 @llvm.smax.i32(i32 %472, i32 0)
%488 = add nuw i32 %487, 1
%489 = zext i32 %488 to i64
br label %490
490: ; preds = %486, %493
%491 = phi i64 [ 1, %486 ], [ %494, %493 ]
%492 = icmp eq i64 %491, %489
br i1 %492, label %500, label %493
493: ; preds = %490
%494 = add nuw nsw i64 %491, 1
%495 = getelementptr inbounds double, double* %2, i64 %494
%496 = load double, double* %495
%497 = fcmp ogt double %447, %496
br i1 %497, label %490, label %498
498: ; preds = %493
%499 = trunc i64 %494 to i32
br label %500
500: ; preds = %490, %498, %483, %480
%501 = phi i32 [ 1, %480 ], [ 1, %483 ], [ %499, %498 ], [ %488, %490 ]
%502 = zext i32 %501 to i64
%503 = getelementptr inbounds i32, i32* %14, i64 %502
%504 = load i32, i32* %503
%505 = add nsw i32 %504, 1
store i32 %505, i32* %503
%506 = getelementptr inbounds [105 x double], [105 x double]* %17, i64 0, i64 %502
%507 = load double, double* %506
%508 = fadd double %447, %507
store double %508, double* %506
%509 = fcmp ogt double %447, 0.000000e+00
br i1 %509, label %510, label %518
510: ; preds = %500
%511 = tail call double @log(double %447)
%512 = getelementptr inbounds [105 x i32], [105 x i32]* %21, i64 0, i64 %502
%513 = load i32, i32* %512
%514 = add nsw i32 %513, 1
store i32 %514, i32* %512
%515 = getelementptr inbounds [105 x double], [105 x double]* %19, i64 0, i64 %502
%516 = load double, double* %515
%517 = fadd double %511, %516
store double %517, double* %515
br label %518
518: ; preds = %510, %500
%519 = load i32*, i32** %356
%520 = getelementptr inbounds i32, i32* %519, i64 %502
%521 = load i32, i32* %520
%522 = add nsw i32 %521, 1
store i32 %522, i32* %520
%523 = getelementptr inbounds i32*, i32** %273, i64 %358
%524 = load i32*, i32** %523
%525 = getelementptr inbounds i32, i32* %524, i64 %502
%526 = load i32, i32* %525
%527 = add nsw i32 %526, 1
store i32 %527, i32* %525
br label %528
528: ; preds = %375, %366, %361, %518
%529 = phi i32 [ %360, %361 ], [ %360, %366 ], [ %473, %518 ], [ %360, %375 ]
%530 = phi double [ %359, %361 ], [ %359, %366 ], [ %474, %518 ], [ %359, %375 ]
%531 = add nuw nsw i64 %358, 1
%532 = icmp eq i64 %531, %314
br i1 %532, label %341, label %357
533: ; preds = %341, %270, %307
%534 = load i32, i32* %1
%535 = add nsw i32 %534, 1
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32, i32* %14, i64 %536
store i32 0, i32* %537
%538 = load i32, i32* %1
%539 = icmp slt i32 %538, 1
%540 = load i64, i64* @HUGE_VAL
%541 = sitofp i64 %540 to float
%542 = fpext float %541 to double
br i1 %539, label %543, label %544
543: ; preds = %533
store double %542, double* %13
store double %542, double* %12
br label %652
544: ; preds = %533, %566
%545 = phi i64 [ %574, %566 ], [ 1, %533 ]
%546 = phi i32 [ %575, %566 ], [ %538, %533 ]
%547 = getelementptr inbounds i32, i32* %14, i64 %545
%548 = load i32, i32* %547
%549 = icmp eq i32 %548, 0
br i1 %549, label %555, label %550
550: ; preds = %544
%551 = getelementptr inbounds [105 x double], [105 x double]* %17, i64 0, i64 %545
%552 = load double, double* %551
%553 = sitofp i32 %548 to double
%554 = fdiv double %552, %553
br label %555
555: ; preds = %544, %550
%556 = phi double [ %554, %550 ], [ %542, %544 ]
%557 = getelementptr inbounds double, double* %12, i64 %545
store double %556, double* %557
%558 = getelementptr inbounds [105 x i32], [105 x i32]* %21, i64 0, i64 %545
%559 = load i32, i32* %558
%560 = icmp eq i32 %559, 0
br i1 %560, label %566, label %561
561: ; preds = %555
%562 = getelementptr inbounds [105 x double], [105 x double]* %19, i64 0, i64 %545
%563 = load double, double* %562
%564 = sitofp i32 %559 to double
%565 = fdiv double %563, %564
br label %566
566: ; preds = %555, %561
%567 = phi double [ %565, %561 ], [ %542, %555 ]
%568 = getelementptr inbounds double, double* %13, i64 %545
store double %567, double* %568
%569 = add nsw i32 %546, 1
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i32, i32* %14, i64 %570
%572 = load i32, i32* %571
%573 = add nsw i32 %572, %548
store i32 %573, i32* %571
%574 = add nuw nsw i64 %545, 1
%575 = load i32, i32* %1
%576 = sext i32 %575 to i64
%577 = icmp slt i64 %545, %576
br i1 %577, label %544, label %578
578: ; preds = %566
%579 = load i64, i64* @HUGE_VAL
%580 = sitofp i64 %579 to float
%581 = fpext float %580 to double
store double %581, double* %13
store double %581, double* %12
%582 = icmp slt i32 %575, 1
br i1 %582, label %652, label %583
583: ; preds = %578
%584 = icmp slt i32 %0, 1
%585 = sitofp i32 %0 to double
%586 = add nsw i32 %0, -1
%587 = sitofp i32 %586 to double
%588 = sitofp i32 %0 to float
%589 = add i32 %0, 1
%590 = zext i32 %589 to i64
br label %591
591: ; preds = %583, %647
%592 = phi i32 [ %575, %583 ], [ %648, %647 ]
%593 = phi i64 [ 1, %583 ], [ %649, %647 ]
%594 = getelementptr inbounds i32, i32* %14, i64 %593
%595 = load i32, i32* %594
%596 = icmp eq i32 %595, 0
br i1 %596, label %647, label %597
597: ; preds = %591
%598 = getelementptr inbounds float*, float** %15, i64 %593
%599 = load float*, float** %598
%600 = getelementptr inbounds float, float* %599, i64 1
store float 0.000000e+00, float* %600
store float 0.000000e+00, float* %599
br i1 %584, label %631, label %601
601: ; preds = %597, %612
%602 = phi float* [ %623, %612 ], [ %599, %597 ]
%603 = phi i64 [ %627, %612 ], [ 1, %597 ]
%604 = getelementptr inbounds i32*, i32** %273, i64 %603
%605 = load i32*, i32** %604
%606 = getelementptr inbounds i32, i32* %605, i64 %593
%607 = load i32, i32* %606
%608 = icmp eq i32 %607, 0
br i1 %608, label %612, label %609
609: ; preds = %601
%610 = load float, float* %602
%611 = fadd float %610, 1.000000e+00
store float %611, float* %602
br label %612
612: ; preds = %609, %601
%613 = sitofp i32 %607 to double
%614 = load i32, i32* %594
%615 = sitofp i32 %614 to double
%616 = fmul double %615, 2.000000e+00
%617 = fdiv double %616, %585
%618 = fsub double %613, %617
%619 = fptosi double %618 to i32
%620 = tail call double @sqr(i32 %619)
%621 = fdiv double %620, %587
%622 = fptrunc double %621 to float
%623 = load float*, float** %598
%624 = getelementptr inbounds float, float* %623, i64 1
%625 = load float, float* %624
%626 = fadd float %625, %622
store float %626, float* %624
%627 = add nuw nsw i64 %603, 1
%628 = icmp eq i64 %627, %590
br i1 %628, label %629, label %601
629: ; preds = %612
%630 = load float, float* %623
br label %631
631: ; preds = %629, %597
%632 = phi float [ %626, %629 ], [ 0.000000e+00, %597 ]
%633 = phi float [ %630, %629 ], [ 0.000000e+00, %597 ]
%634 = phi float* [ %623, %629 ], [ %599, %597 ]
%635 = fdiv float %633, %588
store float %635, float* %634
%636 = tail call i32 @sqrt(float %632)
%637 = sitofp i32 %636 to double
%638 = load i32, i32* %594
%639 = sitofp i32 %638 to double
%640 = fmul double %639, 2.000000e+00
%641 = fdiv double %640, %585
%642 = fdiv double %637, %641
%643 = fptrunc double %642 to float
%644 = load float*, float** %598
%645 = getelementptr inbounds float, float* %644, i64 1
store float %643, float* %645
%646 = load i32, i32* %1
br label %647
647: ; preds = %591, %631
%648 = phi i32 [ %592, %591 ], [ %646, %631 ]
%649 = add nuw nsw i64 %593, 1
%650 = sext i32 %648 to i64
%651 = icmp slt i64 %593, %650
br i1 %651, label %591, label %652
652: ; preds = %647, %543, %578
%653 = phi i32 [ %575, %578 ], [ %538, %543 ], [ %648, %647 ]
%654 = load float*, float** %15
store float 1.000000e+00, float* %654
%655 = getelementptr inbounds float, float* %654, i64 1
store float 0.000000e+00, float* %655
%656 = add nsw i32 %653, 1
%657 = tail call i32 @free_imatrix(i32** %273, i32 0, i32 %0, i32 0, i32 %656)
ret void
}