#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 */
double HUGE_VAL;
int acos(int);
int cos(double);
int fabs(double);
double log(double);
int /*<<< orphan*/ printf(char *, ...);
int sin(double);
double sqrt(float);
void estimate_sigma_2D_kinship(int n, int m, double *xi, double *yi, double *zi,
                               double **Mdij, int *sgi, float ***corrlij,
                               float **corrlc, int ploidy, int Stat, int JKest,
                               float density, float dwidth) {
  int i, j, l, cneighb, niter, backiter, linit, lterm;
  double dij, logd;
  double SPvdlog, Sdlog, SSdlog, Svlog, SSvlog, val;
  int npairslog;
  double SSDvlog, SSDdlog, SPDvdlog, b, Nb[101];
  double dijmin, sigmaest[101], meansigma, meanNb, sigmasq, minNb, maxNb,
      minsigma, maxsigma;
  int converge = 0, nJK;
  printf("\n\nEstimating dispersal distance for a 2D population at "
         "drift-dispersal equilibrium assuming an effective density = %G",
         density);
  printf("\nIter\t#pairs\tNb\tsigma");
  linit = lterm = 0;
  if (JKest)
    linit = -m;
  if (m == 1)
    linit = lterm = 1;
  cneighb = 1;
  for (l = linit; l <= lterm; l++) {
    dijmin = sigmaest[0] = 0.;
    niter = 0;
    do {
      npairslog = 0;
      Sdlog = Svlog = SSdlog = SSvlog = SPvdlog = 0.;
      niter++;
      for (i = 1; i <= n; i++) {
        for (j = i + 1; j <= n; j++)
          if (corrlij[l][i][j] != (float)HUGE_VAL) {
            val = corrlij[l][i][j];
            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 (Mdij[0][0] <= 0 && (sgi[i] == sgi[j])) {
              dij = -1.;
              cneighb = 2;
            }
            if (dij > 0. && dij >= dijmin &&
                (dij <= (dwidth * dijmin) || dijmin == 0)) {
              logd = log(dij);
              npairslog++;
              Svlog += val;
              SSvlog += val * val;
              Sdlog += logd;
              SSdlog += logd * logd;
              SPvdlog += logd * val;
            }
          }
      }
      if (npairslog) {
        SSDvlog = SSvlog - Svlog * Svlog / npairslog;
        if (SSDvlog < 0.000000001)
          SSDvlog = 0.;
        SSDdlog = SSdlog - Sdlog * Sdlog / npairslog;
        if (SSDdlog < 0.000000001)
          SSDdlog = 0.;
        if (SSDdlog && SSDvlog) {
          SPDvdlog = SPvdlog - Svlog * Sdlog / npairslog;
          b = SPDvdlog / SSDdlog;
        } else
          b = HUGE_VAL;
      } else
        b = HUGE_VAL;
      Nb[niter] = HUGE_VAL;
      sigmaest[niter] = HUGE_VAL;
      if (Stat == 1 || Stat == 2 || Stat == 11) {
        if (b < 0. && b != HUGE_VAL) {
          Nb[niter] = (corrlc[l][cneighb] - 1.) / b;
          sigmasq = Nb[niter] / (2 * ploidy * 3.1415 * (double)density);
          sigmaest[niter] = sqrt(sigmasq);
          dijmin = sigmaest[niter];
        } else
          sigmaest[niter] = Nb[niter] = HUGE_VAL;
      }
      if (Stat == 4) {
        if (b > 0. && b != HUGE_VAL) {
          Nb[niter] = 1. / b;
          sigmasq = Nb[niter] / (2 * ploidy * 3.1415 * (double)density);
          sigmaest[niter] = sqrt(sigmasq);
          dijmin = sigmaest[niter];
        } else
          sigmaest[niter] = Nb[niter] = HUGE_VAL;
      }
      if (l >= 0)
        printf("\n%i\t%i\t%G\t%G", niter, npairslog, Nb[niter],
               sigmaest[niter]);
      if (sigmaest[niter] != HUGE_VAL) {
        if (fabs((sigmaest[niter] - sigmaest[niter - 1]) / sigmaest[niter]) <
            0.01)
          converge = 1;
        else
          converge = 0;
      }
    } while (sigmaest[niter] != HUGE_VAL && converge == 0 && niter < 100);
    corrlc[l][-21] = corrlc[l][-22] = corrlc[l][-23] = (float)Nb[niter];
    corrlc[l][-25] = corrlc[l][-26] = corrlc[l][-27] = (float)sigmaest[niter];
    corrlc[l][-24] = (float)npairslog;
    if (niter == 100) {
      backiter = 1;
      meansigma = minsigma = maxsigma = sigmaest[niter];
      meanNb = minNb = maxNb = Nb[niter];
      while ((sigmaest[niter] != sigmaest[niter - backiter]) &&
             backiter < 100) {
        meansigma += sigmaest[niter - backiter];
        meanNb += Nb[niter - backiter];
        if (sigmaest[niter - backiter] < minsigma)
          minsigma = sigmaest[niter - backiter];
        if (sigmaest[niter - backiter] > maxsigma)
          maxsigma = sigmaest[niter - backiter];
        if (Nb[niter - backiter] < minNb)
          minNb = Nb[niter - backiter];
        if (Nb[niter - backiter] > maxNb)
          maxNb = Nb[niter - backiter];
        backiter++;
      }
      corrlc[l][-21] = (float)meanNb / backiter;
      corrlc[l][-22] = (float)minNb;
      corrlc[l][-23] = (float)maxNb;
      corrlc[l][-25] = (float)meansigma / backiter;
      corrlc[l][-26] = (float)minsigma;
      corrlc[l][-27] = (float)maxsigma;
    }
  }
  if (JKest) {
    converge = 1;
    for (l = 1; l <= m; l++)
      if (corrlc[-l][-21] == (float)HUGE_VAL) {
        converge = 0;
        break;
      }
    if (converge) {
      nJK = m;
      corrlc[m + 1][-21] = corrlc[m + 2][-21] = corrlc[m + 1][-25] =
          corrlc[m + 2][-25] = 0.;
      for (l = 1; l <= m; l++)
        if (corrlc[-l][-21] != (float)HUGE_VAL) {
          corrlc[l][-21] = (float)(nJK * fabs((double)corrlc[0][-21]) -
                                   (nJK - 1) * fabs((double)corrlc[-l][-21]));
          corrlc[m + 1][-21] += corrlc[l][-21];
          corrlc[l][-25] = (float)(nJK * fabs((double)corrlc[0][-25]) -
                                   (nJK - 1) * fabs((double)corrlc[-l][-25]));
          corrlc[m + 1][-25] += corrlc[l][-25];
        }
      corrlc[m + 1][-21] /= nJK;
      corrlc[m + 1][-25] /= nJK;
      for (l = 1; l <= m; l++)
        if (corrlc[-l][-21] != (float)HUGE_VAL) {
          corrlc[m + 2][-21] += (corrlc[l][-21] - corrlc[m + 1][-21]) *
                                (corrlc[l][-21] - corrlc[m + 1][-21]);
          corrlc[m + 2][-25] += (corrlc[l][-25] - corrlc[m + 1][-25]) *
                                (corrlc[l][-25] - corrlc[m + 1][-25]);
        }
      corrlc[m + 2][-21] = (float)sqrt((corrlc[m + 2][-21] / (nJK - 1)) / nJK);
      corrlc[m + 2][-25] = (float)sqrt((corrlc[m + 2][-25] / (nJK - 1)) / nJK);
    } else
      corrlc[m + 1][-21] = corrlc[m + 2][-21] = corrlc[m + 1][-25] =
          corrlc[m + 2][-25] = (float)HUGE_VAL;
  } else
    corrlc[m + 1][-21] = corrlc[m + 2][-21] = corrlc[m + 1][-25] =
        corrlc[m + 2][-25] = (float)HUGE_VAL;
}


x86 assembly (clang, -O0):
<estimate_sigma_2D_kinship>:
push   %rbp
mov    %rsp,%rbp
sub    $0x780,%rsp
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movl   $0x0,-0x74c(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1e5e(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1ec6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x0,0x38(%rbp)
je     11ff <estimate_sigma_2D_kinship+0x8f>
xor    %eax,%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x1,-0x8(%rbp)
jne    1217 <estimate_sigma_2D_kinship+0xa7>
movl   $0x1,-0x50(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1f99 <estimate_sigma_2D_kinship+0xe29>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x710(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x3e8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x94(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1764 <estimate_sigma_2D_kinship+0x5f4>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1751 <estimate_sigma_2D_kinship+0x5e1>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x3d11(%rip),%rax
movsd  (%rax),%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12f3 <estimate_sigma_2D_kinship+0x183>
jp     12f3 <estimate_sigma_2D_kinship+0x183>
jmp    173e <estimate_sigma_2D_kinship+0x5ce>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1ce1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13a5 <estimate_sigma_2D_kinship+0x235>
jp     13a5 <estimate_sigma_2D_kinship+0x235>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3c8d(%rip),%rax
movsd  (%rax),%xmm1
cvtsd2ss %xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    137c <estimate_sigma_2D_kinship+0x20c>
jp     137c <estimate_sigma_2D_kinship+0x20c>
jmp    139b <estimate_sigma_2D_kinship+0x22b>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    13a0 <estimate_sigma_2D_kinship+0x230>
jmp    1743 <estimate_sigma_2D_kinship+0x5d3>
jmp    154c <estimate_sigma_2D_kinship+0x3dc>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1c68(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1489 <estimate_sigma_2D_kinship+0x319>
jp     1489 <estimate_sigma_2D_kinship+0x319>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <sin@plt>
mov    %eax,-0x760(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <sin@plt>
mov    %eax,%ecx
mov    -0x760(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x758(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <cos@plt>
mov    %eax,-0x75c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1070 <cos@plt>
mov    %eax,%ecx
mov    -0x75c(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x754(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
call   1070 <cos@plt>
mov    -0x758(%rbp),%edi
mov    %eax,%ecx
mov    -0x754(%rbp),%eax
imul   %ecx,%eax
add    %eax,%edi
call   1040 <acos@plt>
imul   $0x18e3,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1547 <estimate_sigma_2D_kinship+0x3d7>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
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
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,-0x58(%rbp)
jmp    154c <estimate_sigma_2D_kinship+0x3dc>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movsd  (%rax),%xmm0
movsd  0x1ab1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1574 <estimate_sigma_2D_kinship+0x404>
jp     1574 <estimate_sigma_2D_kinship+0x404>
jmp    15f3 <estimate_sigma_2D_kinship+0x483>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15ee <estimate_sigma_2D_kinship+0x47e>
jp     15ee <estimate_sigma_2D_kinship+0x47e>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15ee <estimate_sigma_2D_kinship+0x47e>
jp     15ee <estimate_sigma_2D_kinship+0x47e>
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    15ee <estimate_sigma_2D_kinship+0x47e>
jp     15ee <estimate_sigma_2D_kinship+0x47e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    15f3 <estimate_sigma_2D_kinship+0x483>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jb     1637 <estimate_sigma_2D_kinship+0x4c7>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1637 <estimate_sigma_2D_kinship+0x4c7>
movsd  0x19f5(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x2,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1739 <estimate_sigma_2D_kinship+0x5c9>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x3e8(%rbp),%xmm0
ff
jb     1739 <estimate_sigma_2D_kinship+0x5c9>
movsd  -0x58(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x3e8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    1697 <estimate_sigma_2D_kinship+0x527>
movsd  -0x3e8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1739 <estimate_sigma_2D_kinship+0x5c9>
jp     1739 <estimate_sigma_2D_kinship+0x5c9>
movsd  -0x58(%rbp),%xmm0
call   1080 <log@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    173e <estimate_sigma_2D_kinship+0x5ce>
jmp    1743 <estimate_sigma_2D_kinship+0x5d3>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a7 <estimate_sigma_2D_kinship+0x137>
jmp    1756 <estimate_sigma_2D_kinship+0x5e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1292 <estimate_sigma_2D_kinship+0x122>
cmpl   $0x0,-0x94(%rbp)
je     18a0 <estimate_sigma_2D_kinship+0x730>
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
cvtsi2sdl -0x94(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x185d(%rip),%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    17bc <estimate_sigma_2D_kinship+0x64c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
cvtsi2sdl -0x94(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x1815(%rip),%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jbe    1804 <estimate_sigma_2D_kinship+0x694>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1824 <estimate_sigma_2D_kinship+0x6b4>
jp     1824 <estimate_sigma_2D_kinship+0x6b4>
jmp    1888 <estimate_sigma_2D_kinship+0x718>
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1844 <estimate_sigma_2D_kinship+0x6d4>
jp     1844 <estimate_sigma_2D_kinship+0x6d4>
jmp    1888 <estimate_sigma_2D_kinship+0x718>
movsd  -0x68(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
cvtsi2sdl -0x94(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    189b <estimate_sigma_2D_kinship+0x72b>
mov    0x3759(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    18b3 <estimate_sigma_2D_kinship+0x743>
mov    0x3741(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x372e(%rip),%rax
movsd  (%rax),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
mov    0x3716(%rip),%rax
movsd  (%rax),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x710(%rbp,%rax,8)
ff ff
cmpl   $0x1,0x30(%rbp)
je     1901 <estimate_sigma_2D_kinship+0x791>
cmpl   $0x2,0x30(%rbp)
je     1901 <estimate_sigma_2D_kinship+0x791>
cmpl   $0xb,0x30(%rbp)
jne    1a0e <estimate_sigma_2D_kinship+0x89e>
xorps  %xmm0,%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    19e4 <estimate_sigma_2D_kinship+0x874>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x36c7(%rip),%rax
ucomisd (%rax),%xmm0
jne    1936 <estimate_sigma_2D_kinship+0x7c6>
jp     1936 <estimate_sigma_2D_kinship+0x7c6>
jmp    19e4 <estimate_sigma_2D_kinship+0x874>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16b9(%rip),%xmm1
subsd  %xmm1,%xmm0
divsd  -0xb8(%rbp),%xmm0
ff
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
mov    0x28(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm1
movsd  0x1679(%rip),%xmm2
mulsd  %xmm2,%xmm1
movss  -0x2c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x728(%rbp)
ff
movsd  -0x728(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1090 <sqrt@plt>
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x710(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e8(%rbp)
ff
jmp    1a09 <estimate_sigma_2D_kinship+0x899>
mov    0x35fd(%rip),%rax
movsd  (%rax),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x710(%rbp,%rax,8)
ff ff
jmp    1a0e <estimate_sigma_2D_kinship+0x89e>
cmpl   $0x4,0x30(%rbp)
jne    1b0c <estimate_sigma_2D_kinship+0x99c>
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ae2 <estimate_sigma_2D_kinship+0x972>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x35ac(%rip),%rax
ucomisd (%rax),%xmm0
jne    1a51 <estimate_sigma_2D_kinship+0x8e1>
jp     1a51 <estimate_sigma_2D_kinship+0x8e1>
jmp    1ae2 <estimate_sigma_2D_kinship+0x972>
movsd  0x15b7(%rip),%xmm0
divsd  -0xb8(%rbp),%xmm0
ff
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
mov    0x28(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm1
movsd  0x157b(%rip),%xmm2
mulsd  %xmm2,%xmm1
movss  -0x2c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x728(%rbp)
ff
movsd  -0x728(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
call   1090 <sqrt@plt>
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x710(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x3e8(%rbp)
ff
jmp    1b07 <estimate_sigma_2D_kinship+0x997>
mov    0x34ff(%rip),%rax
movsd  (%rax),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x3e0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x710(%rbp,%rax,8)
ff ff
jmp    1b0c <estimate_sigma_2D_kinship+0x99c>
cmpl   $0x0,-0x3c(%rbp)
jl     1b47 <estimate_sigma_2D_kinship+0x9d7>
mov    -0x44(%rbp),%esi
mov    -0x94(%rbp),%edx
movslq -0x44(%rbp),%rax
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm1
ff ff
lea    0x1574(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
mov    0x348d(%rip),%rax
ucomisd (%rax),%xmm0
jne    1b70 <estimate_sigma_2D_kinship+0xa00>
jp     1b70 <estimate_sigma_2D_kinship+0xa00>
jmp    1bd4 <estimate_sigma_2D_kinship+0xa64>
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
cltq
subsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movslq -0x44(%rbp),%rax
divsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
call   1050 <fabs@plt>
cvtsi2sd %eax,%xmm1
movsd  0x146c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bc5 <estimate_sigma_2D_kinship+0xa55>
movl   $0x1,-0x74c(%rbp)
jmp    1bcf <estimate_sigma_2D_kinship+0xa5f>
movl   $0x0,-0x74c(%rbp)
jmp    1bd4 <estimate_sigma_2D_kinship+0xa64>
jmp    1bd9 <estimate_sigma_2D_kinship+0xa69>
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
xor    %eax,%eax
mov    0x33f9(%rip),%rcx
ucomisd (%rcx),%xmm0
mov    %al,-0x761(%rbp)
jne    1c0a <estimate_sigma_2D_kinship+0xa9a>
jp     1c0a <estimate_sigma_2D_kinship+0xa9a>
jmp    1c2c <estimate_sigma_2D_kinship+0xabc>
xor    %eax,%eax
cmpl   $0x0,-0x74c(%rbp)
mov    %al,-0x761(%rbp)
jne    1c2c <estimate_sigma_2D_kinship+0xabc>
cmpl   $0x64,-0x44(%rbp)
setl   %al
mov    %al,-0x761(%rbp)
mov    -0x761(%rbp),%al
test   $0x1,%al
jne    124d <estimate_sigma_2D_kinship+0xdd>
movslq -0x44(%rbp),%rax
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x5c(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x58(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x6c(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x68(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
cvtsi2ssl -0x94(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x60(%rax)
cmpl   $0x64,-0x44(%rbp)
jne    1f86 <estimate_sigma_2D_kinship+0xe16>
movl   $0x1,-0x48(%rbp)
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x748(%rbp)
movsd  %xmm0,-0x740(%rbp)
ff
movsd  %xmm0,-0x718(%rbp)
ff
movslq -0x44(%rbp),%rax
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x738(%rbp)
ff
movsd  %xmm0,-0x730(%rbp)
ff
movsd  %xmm0,-0x720(%rbp)
ff
movslq -0x44(%rbp),%rax
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
movslq %eax,%rcx
xor    %eax,%eax
ucomisd -0x710(%rbp,%rcx,8),%xmm0
ff ff
mov    %al,-0x762(%rbp)
jne    1d6e <estimate_sigma_2D_kinship+0xbfe>
jp     1d6e <estimate_sigma_2D_kinship+0xbfe>
jmp    1d7b <estimate_sigma_2D_kinship+0xc0b>
cmpl   $0x64,-0x48(%rbp)
setl   %al
mov    %al,-0x762(%rbp)
mov    -0x762(%rbp),%al
test   $0x1,%al
jne    1d8e <estimate_sigma_2D_kinship+0xc1e>
jmp    1ec6 <estimate_sigma_2D_kinship+0xd56>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x718(%rbp),%xmm0
ff
movsd  %xmm0,-0x718(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x720(%rbp),%xmm0
ff
movsd  %xmm0,-0x720(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x710(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x740(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e0c <estimate_sigma_2D_kinship+0xc9c>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x740(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x748(%rbp),%xmm0
ff
jbe    1e44 <estimate_sigma_2D_kinship+0xcd4>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x710(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x748(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x3e0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x730(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e80 <estimate_sigma_2D_kinship+0xd10>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x730(%rbp)
ff
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x738(%rbp),%xmm0
ff
jbe    1eb8 <estimate_sigma_2D_kinship+0xd48>
mov    -0x44(%rbp),%eax
sub    -0x48(%rbp),%eax
cltq
movsd  -0x3e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x738(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1d36 <estimate_sigma_2D_kinship+0xbc6>
movsd  -0x720(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
cvtsi2ssl -0x48(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
movsd  -0x730(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x58(%rax)
movsd  -0x738(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x5c(%rax)
movsd  -0x718(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
cvtsi2ssl -0x48(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
movsd  -0x740(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x68(%rax)
movsd  -0x748(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x6c(%rax)
jmp    1f8b <estimate_sigma_2D_kinship+0xe1b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1224 <estimate_sigma_2D_kinship+0xb4>
cmpl   $0x0,0x38(%rbp)
je     24f6 <estimate_sigma_2D_kinship+0x1386>
movl   $0x1,-0x74c(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2015 <estimate_sigma_2D_kinship+0xea5>
mov    0x20(%rbp),%rax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    0x300c(%rip),%rax
movsd  (%rax),%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2002 <estimate_sigma_2D_kinship+0xe92>
jp     2002 <estimate_sigma_2D_kinship+0xe92>
movl   $0x0,-0x74c(%rbp)
jmp    2015 <estimate_sigma_2D_kinship+0xea5>
jmp    2007 <estimate_sigma_2D_kinship+0xe97>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fb4 <estimate_sigma_2D_kinship+0xe44>
cmpl   $0x0,-0x74c(%rbp)
je     248a <estimate_sigma_2D_kinship+0x131a>
mov    -0x8(%rbp),%eax
mov    %eax,-0x750(%rbp)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2253 <estimate_sigma_2D_kinship+0x10e3>
mov    0x20(%rbp),%rax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    0x2f2a(%rip),%rax
movsd  (%rax),%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    20da <estimate_sigma_2D_kinship+0xf6a>
jp     20da <estimate_sigma_2D_kinship+0xf6a>
jmp    2240 <estimate_sigma_2D_kinship+0x10d0>
mov    -0x750(%rbp),%eax
mov    %eax,-0x77c(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movss  -0x54(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    %eax,%ecx
mov    -0x77c(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x774(%rbp)
mov    -0x750(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x778(%rbp)
mov    0x20(%rbp),%rax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    -0x778(%rbp),%ecx
mov    %eax,%edx
mov    -0x774(%rbp),%eax
imul   %edx,%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
addss  -0x54(%rax),%xmm0
movss  %xmm0,-0x54(%rax)
mov    -0x750(%rbp),%eax
mov    %eax,-0x770(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%rax
movss  -0x64(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    %eax,%ecx
mov    -0x770(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x768(%rbp)
mov    -0x750(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x76c(%rbp)
mov    0x20(%rbp),%rax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    -0x76c(%rbp),%ecx
mov    %eax,%edx
mov    -0x768(%rbp),%eax
imul   %edx,%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
addss  -0x64(%rax),%xmm0
movss  %xmm0,-0x64(%rax)
jmp    2245 <estimate_sigma_2D_kinship+0x10d5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2096 <estimate_sigma_2D_kinship+0xf26>
cvtsi2ssl -0x750(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rax)
cvtsi2ssl -0x750(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     23e1 <estimate_sigma_2D_kinship+0x1271>
mov    0x20(%rbp),%rax
xor    %ecx,%ecx
sub    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    0x2d18(%rip),%rax
movsd  (%rax),%xmm1
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    22ec <estimate_sigma_2D_kinship+0x117c>
jp     22ec <estimate_sigma_2D_kinship+0x117c>
jmp    23ce <estimate_sigma_2D_kinship+0x125e>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
subss  -0x54(%rax),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm2
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
subss  -0x54(%rax),%xmm2
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
subss  -0x64(%rax),%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm2
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
subss  -0x64(%rax),%xmm2
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rax)
jmp    23d3 <estimate_sigma_2D_kinship+0x1263>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    22a8 <estimate_sigma_2D_kinship+0x1138>
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x54(%rax),%xmm0
mov    -0x750(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x750(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  -0x64(%rax),%xmm0
mov    -0x750(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x750(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
jmp    24f1 <estimate_sigma_2D_kinship+0x1381>
mov    0x2b57(%rip),%rax
movsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
jmp    255d <estimate_sigma_2D_kinship+0x13ed>
mov    0x2aeb(%rip),%rax
movsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x64(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
mov    0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,-0x54(%rax)
add    $0x780,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<estimate_sigma_2D_kinship>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x748,%rsp
movss  %xmm1,0x10(%rsp)
mov    %r9,%r13
mov    %r8,0x98(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,%rbx
mov    %esi,%r14d
mov    %rdi,0x88(%rsp)
mov    0x7a8(%rsp),%r15d
cvtss2sd %xmm0,%xmm0
lea    0xe78(%rip),%rdi
movsd  %xmm0,(%rsp)
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xedb(%rip),%rdi
xor    %r12d,%r12d
xor    %eax,%eax
call   1030 <printf@plt>
mov    %r14d,%eax
neg    %eax
test   %r15d,%r15d
cmove  %r15d,%eax
xor    %ecx,%ecx
cmp    $0x1,%r14d
sete   %cl
mov    %r14,0x40(%rsp)
cmove  %r14d,%eax
cmp    %ecx,%eax
jle    1262 <estimate_sigma_2D_kinship+0xf2>
cmpl   $0x0,0x7a8(%rsp)
je     1b62 <estimate_sigma_2D_kinship+0x9f2>
mov    0x40(%rsp),%r8
test   %r8d,%r8d
mov    0x790(%rsp),%rbx
jle    1ba1 <estimate_sigma_2D_kinship+0xa31>
mov    0x2dc6(%rip),%rax
movsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%r8),%ecx
mov    %rcx,%rax
neg    %rax
mov    $0xffffffffffffffff,%rdx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,8),%rsi
movss  -0x54(%rsi),%xmm1
ucomiss %xmm0,%xmm1
jne    1254 <estimate_sigma_2D_kinship+0xe4>
jnp    1dca <estimate_sigma_2D_kinship+0xc5a>
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rax
jne    1240 <estimate_sigma_2D_kinship+0xd0>
jmp    1ba5 <estimate_sigma_2D_kinship+0xa35>
mov    0x798(%rsp),%ecx
mov    0x788(%rsp),%r15
xor    %edx,%edx
cmpl   $0x1,0x40(%rsp)
sete   %dl
add    %ecx,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0xd74(%rip),%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0xb8(%rsp)
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x80(%rsp)
mov    0x88(%rsp),%rcx
lea    0x1(%rcx),%esi
mov    %rsi,0xc8(%rsp)
movslq %ecx,%rcx
cltq
mov    %rax,0x28(%rsp)
add    $0x1,%edx
mov    %edx,0x6c(%rsp)
mov    %rcx,0xc0(%rsp)
lea    -0x1(%rcx),%edi
movl   $0x1,0x3c(%rsp)
mov    0x2cfd(%rip),%rsi
xorpd  %xmm6,%xmm6
movsd  0xd11(%rip),%xmm7
mov    %rdi,0x58(%rsp)
mov    %r13,0xe0(%rsp)
jmp    1366 <estimate_sigma_2D_kinship+0x1f6>
mov    $0x1,%eax
movaps %xmm4,%xmm2
movaps %xmm4,%xmm5
movaps %xmm0,%xmm8
movaps %xmm0,%xmm1
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
divss  %xmm3,%xmm1
movss  %xmm1,-0x54(%r8)
movss  %xmm8,-0x58(%r8)
movss  %xmm0,-0x5c(%r8)
divss  %xmm3,%xmm5
movss  %xmm5,-0x64(%r8)
movss  %xmm2,-0x68(%r8)
movss  %xmm4,-0x6c(%r8)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    %ecx,0x6c(%rsp)
je     11f7 <estimate_sigma_2D_kinship+0x87>
movq   $0x0,0xf0(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
xorpd  %xmm4,%xmm4
mov    %r12d,%eax
mov    %r12d,0x48(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x50(%rsp),%rax
lea    0x1(%rax),%rbp
cmpl   $0x0,0x88(%rsp)
jle    17d0 <estimate_sigma_2D_kinship+0x660>
mov    %rbp,0x90(%rsp)
movapd %xmm4,%xmm0
mulsd  0xb8(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x70(%rsp)
xorpd  %xmm5,%xmm5
xor    %r12d,%r12d
mov    $0x1,%ebp
movl   $0x0,0x4c(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,(%rsp)
mov    0x28(%rsp),%r14
movsd  %xmm4,0x30(%rsp)
jmp    1422 <estimate_sigma_2D_kinship+0x2b2>
nopl   0x0(%rax)
mov    0xd8(%rsp),%r12
add    $0x1,%r12
mov    0xd0(%rsp),%rbp
cmp    0xc8(%rsp),%rbp
je     1720 <estimate_sigma_2D_kinship+0x5b0>
lea    0x1(%rbp),%rax
mov    %rax,0xd0(%rsp)
cmp    0xc0(%rsp),%rbp
mov    %r12,0xd8(%rsp)
jl     1459 <estimate_sigma_2D_kinship+0x2e9>
jmp    1400 <estimate_sigma_2D_kinship+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r12
cmp    %r12d,%edi
je     1400 <estimate_sigma_2D_kinship+0x290>
mov    (%r15,%r14,8),%rax
mov    (%rax,%rbp,8),%rax
movss  0x8(%rax,%r12,4),%xmm3
movsd  (%rsi),%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
ucomiss %xmm1,%xmm3
jne    147a <estimate_sigma_2D_kinship+0x30a>
jnp    1450 <estimate_sigma_2D_kinship+0x2e0>
mov    0x0(%r13),%rax
movsd  (%rax),%xmm0
ucomisd %xmm7,%xmm0
jne    14b0 <estimate_sigma_2D_kinship+0x340>
jp     14b0 <estimate_sigma_2D_kinship+0x340>
mov    0x0(%r13,%rbp,8),%rax
movsd  0x10(%rax,%r12,8),%xmm0
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15c5 <estimate_sigma_2D_kinship+0x455>
jp     15c5 <estimate_sigma_2D_kinship+0x455>
jmp    1450 <estimate_sigma_2D_kinship+0x2e0>
nopl   0x0(%rax)
movss  %xmm3,0xa0(%rsp)
movapd %xmm5,0x10(%rsp)
ucomisd 0xb49(%rip),%xmm0
movsd  (%rbx,%rbp,8),%xmm0
jne    154c <estimate_sigma_2D_kinship+0x3dc>
jp     154c <estimate_sigma_2D_kinship+0x3dc>
call   1060 <sin@plt>
mov    %eax,%r14d
movsd  0x10(%rbx,%r12,8),%xmm0
call   1060 <sin@plt>
imul   %eax,%r14d
movsd  (%rbx,%rbp,8),%xmm0
call   1070 <cos@plt>
mov    %r15,%r13
mov    %eax,%r15d
movsd  0x10(%rbx,%r12,8),%xmm0
call   1070 <cos@plt>
imul   %eax,%r15d
mov    0x60(%rsp),%rax
movsd  0x10(%rax,%r12,8),%xmm0
subsd  (%rax,%rbp,8),%xmm0
call   1070 <cos@plt>
imul   %eax,%r15d
add    %r14d,%r15d
mov    0x28(%rsp),%r14
mov    %r15d,%edi
mov    %r13,%r15
mov    0xe0(%rsp),%r13
call   1040 <acos@plt>
imul   $0x18e3,%eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
jmp    1598 <estimate_sigma_2D_kinship+0x428>
subsd  0x10(%rbx,%r12,8),%xmm0
mov    0x60(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
subsd  0x10(%rax,%r12,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x98(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
subsd  0x10(%rax,%r12,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   1090 <sqrt@plt>
mov    0x58(%rsp),%rdi
mov    0x2a44(%rip),%rsi
xorpd  %xmm6,%xmm6
movsd  0xa58(%rip),%xmm7
movsd  0x30(%rsp),%xmm4
movapd 0x10(%rsp),%xmm5
movss  0xa0(%rsp),%xmm3
mov    0x0(%r13),%rax
movsd  (%rax),%xmm1
ucomisd %xmm7,%xmm1
jne    15d5 <estimate_sigma_2D_kinship+0x465>
jnp    1620 <estimate_sigma_2D_kinship+0x4b0>
movsd  (%rbx,%rbp,8),%xmm2
ucomisd 0x10(%rbx,%r12,8),%xmm2
jne    1620 <estimate_sigma_2D_kinship+0x4b0>
jp     1620 <estimate_sigma_2D_kinship+0x4b0>
mov    0x60(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm2
ucomisd 0x10(%rax,%r12,8),%xmm2
jne    1620 <estimate_sigma_2D_kinship+0x4b0>
jp     1620 <estimate_sigma_2D_kinship+0x4b0>
mov    0x98(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm2
ucomisd 0x10(%rax,%r12,8),%xmm2
jne    1620 <estimate_sigma_2D_kinship+0x4b0>
jp     1620 <estimate_sigma_2D_kinship+0x4b0>
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm1,%xmm6
jb     1658 <estimate_sigma_2D_kinship+0x4e8>
mov    0x780(%rsp),%rcx
mov    (%rcx,%rbp,4),%eax
movsd  0x9d7(%rip),%xmm1
cmp    0x8(%rcx,%r12,4),%eax
je     1644 <estimate_sigma_2D_kinship+0x4d4>
movapd %xmm0,%xmm1
mov    0x3c(%rsp),%eax
mov    $0x2,%ecx
cmove  %ecx,%eax
mov    %eax,0x3c(%rsp)
movapd %xmm1,%xmm0
ucomisd %xmm6,%xmm4
setnp  %cl
sete   %al
movsd  0xe8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
setae  %dl
ucomisd %xmm6,%xmm0
jbe    1450 <estimate_sigma_2D_kinship+0x2e0>
ucomisd %xmm4,%xmm0
jb     1450 <estimate_sigma_2D_kinship+0x2e0>
and    %cl,%al
or     %dl,%al
je     1450 <estimate_sigma_2D_kinship+0x2e0>
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movaps %xmm1,0xa0(%rsp)
movapd %xmm5,0x10(%rsp)
call   1080 <log@plt>
movapd 0x10(%rsp),%xmm5
movsd  0x30(%rsp),%xmm4
movsd  0x94a(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    0x291f(%rip),%rsi
mov    0x58(%rsp),%rdi
addl   $0x1,0x4c(%rsp)
movapd %xmm0,%xmm1
movapd 0xa0(%rsp),%xmm3
unpcklpd %xmm3,%xmm1
movapd (%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,(%rsp)
mulpd  %xmm1,%xmm1
movapd 0x70(%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x70(%rsp)
mulsd  %xmm3,%xmm0
addsd  %xmm0,%xmm5
jmp    1450 <estimate_sigma_2D_kinship+0x2e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4c(%rsp),%r12d
test   %r12d,%r12d
je     17e0 <estimate_sigma_2D_kinship+0x670>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movapd (%rsp),%xmm1
mulpd  %xmm1,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movapd 0x70(%rsp),%xmm2
subpd  %xmm1,%xmm2
movapd %xmm2,%xmm3
movapd %xmm2,%xmm1
cmpltpd 0x8ba(%rip),%xmm1
movmskpd %xmm1,%eax
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
test   $0x2,%al
jne    177f <estimate_sigma_2D_kinship+0x60f>
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
xorpd  %xmm1,%xmm1
test   $0x1,%al
mov    0x7a0(%rsp),%r14d
mov    0x90(%rsp),%rbp
jne    179b <estimate_sigma_2D_kinship+0x62b>
movapd %xmm3,%xmm1
ucomisd %xmm8,%xmm1
jne    17a4 <estimate_sigma_2D_kinship+0x634>
jnp    17f9 <estimate_sigma_2D_kinship+0x689>
ucomisd %xmm6,%xmm2
jne    17ac <estimate_sigma_2D_kinship+0x63c>
jnp    17f9 <estimate_sigma_2D_kinship+0x689>
movapd (%rsp),%xmm3
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
mulsd  %xmm3,%xmm2
divsd  %xmm0,%xmm2
subsd  %xmm2,%xmm5
divsd  %xmm1,%xmm5
movsd  (%rsi),%xmm1
jmp    1801 <estimate_sigma_2D_kinship+0x691>
nop
mov    0x7a0(%rsp),%r14d
jmp    17f0 <estimate_sigma_2D_kinship+0x680>
nopw   0x0(%rax,%rax,1)
mov    0x7a0(%rsp),%r14d
mov    0x90(%rsp),%rbp
movsd  (%rsi),%xmm1
xor    %r12d,%r12d
jmp    17fd <estimate_sigma_2D_kinship+0x68d>
movsd  (%rsi),%xmm1
movapd %xmm1,%xmm5
movsd  %xmm1,0x420(%rsp,%rbp,8)
movsd  %xmm1,0xf0(%rsp,%rbp,8)
cmp    $0xb,%r14d
ja     18e0 <estimate_sigma_2D_kinship+0x770>
mov    $0x806,%eax
bt     %r14d,%eax
jae    18d0 <estimate_sigma_2D_kinship+0x760>
ucomisd %xmm5,%xmm6
jbe    18d0 <estimate_sigma_2D_kinship+0x760>
ucomisd %xmm1,%xmm5
movsd  %xmm1,(%rsp)
jne    1847 <estimate_sigma_2D_kinship+0x6d7>
jnp    18f0 <estimate_sigma_2D_kinship+0x780>
mov    0x790(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3c(%rsp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0x7a3(%rip),%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,0x420(%rsp,%rbp,8)
movsd  %xmm0,(%rsp)
divsd  0x80(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movapd %xmm5,0x10(%rsp)
call   1090 <sqrt@plt>
movapd 0x10(%rsp),%xmm5
movsd  0x763(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    0x2738(%rip),%rsi
movaps %xmm0,%xmm1
movsd  %xmm0,0xf0(%rsp,%rbp,8)
movaps %xmm0,%xmm4
cmp    $0x4,%r14d
je     18f6 <estimate_sigma_2D_kinship+0x786>
jmp    1967 <estimate_sigma_2D_kinship+0x7f7>
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,(%rsp)
cmp    $0x4,%r14d
je     18f6 <estimate_sigma_2D_kinship+0x786>
jmp    1967 <estimate_sigma_2D_kinship+0x7f7>
movsd  %xmm1,(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x4,%r14d
jne    1967 <estimate_sigma_2D_kinship+0x7f7>
ucomisd %xmm6,%xmm5
movsd  (%rsi),%xmm1
jbe    1950 <estimate_sigma_2D_kinship+0x7e0>
ucomisd %xmm1,%xmm5
jne    1908 <estimate_sigma_2D_kinship+0x798>
jnp    1950 <estimate_sigma_2D_kinship+0x7e0>
movapd %xmm7,%xmm0
divsd  %xmm5,%xmm0
movsd  %xmm0,0x420(%rsp,%rbp,8)
movsd  %xmm0,(%rsp)
divsd  0x80(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1090 <sqrt@plt>
xorpd  %xmm6,%xmm6
mov    0x26ad(%rip),%rsi
movaps %xmm0,%xmm1
movaps %xmm0,%xmm4
jmp    195e <estimate_sigma_2D_kinship+0x7ee>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm1,0x420(%rsp,%rbp,8)
movsd  %xmm1,(%rsp)
movsd  %xmm1,0xf0(%rsp,%rbp,8)
movsd  %xmm4,0x30(%rsp)
cmpq   $0x0,0x28(%rsp)
movsd  %xmm1,0x10(%rsp)
js     19a4 <estimate_sigma_2D_kinship+0x834>
lea    0x73a(%rip),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
movsd  (%rsp),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x10(%rsp),%xmm1
xorpd  %xmm6,%xmm6
mov    0x2644(%rip),%rsi
mov    %r12d,%r14d
movsd  (%rsi),%xmm0
ucomisd %xmm0,%xmm1
mov    0x48(%rsp),%ecx
jne    19b7 <estimate_sigma_2D_kinship+0x847>
jnp    19ee <estimate_sigma_2D_kinship+0x87e>
movapd %xmm1,%xmm0
mov    0x50(%rsp),%rax
subsd  0xf0(%rsp,%rax,8),%xmm0
divsd  %xmm1,%xmm0
call   1050 <fabs@plt>
movsd  0x10(%rsp),%xmm1
xorpd  %xmm6,%xmm6
mov    0x2605(%rip),%rsi
xor    %ecx,%ecx
test   %eax,%eax
setle  %cl
movsd  (%rsi),%xmm0
mov    %ecx,%r12d
ucomisd %xmm0,%xmm1
mov    0x58(%rsp),%rdi
movsd  0x606(%rip),%xmm7
movsd  0x30(%rsp),%xmm4
jne    1a0c <estimate_sigma_2D_kinship+0x89c>
jnp    1a2a <estimate_sigma_2D_kinship+0x8ba>
test   %r12d,%r12d
jne    1a2a <estimate_sigma_2D_kinship+0x8ba>
movl   $0x0,0x48(%rsp)
cmpq   $0x63,0x50(%rsp)
mov    %rbp,0x50(%rsp)
jb     1390 <estimate_sigma_2D_kinship+0x220>
movsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x790(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rax,%rcx,8),%r8
movss  %xmm0,-0x5c(%r8)
movss  %xmm0,-0x58(%r8)
movss  %xmm0,-0x54(%r8)
xorps  %xmm4,%xmm4
cvtsd2ss %xmm1,%xmm4
movss  %xmm4,-0x6c(%r8)
xorps  %xmm2,%xmm2
cvtsi2ss %r14d,%xmm2
movss  %xmm4,-0x68(%r8)
movss  %xmm4,-0x64(%r8)
movss  %xmm2,-0x60(%r8)
cmp    $0x64,%ebp
jne    134b <estimate_sigma_2D_kinship+0x1db>
movsd  0x408(%rsp),%xmm2
ucomisd %xmm2,%xmm1
jne    1a9b <estimate_sigma_2D_kinship+0x92b>
jnp    1306 <estimate_sigma_2D_kinship+0x196>
mov    $0x1,%ecx
xor    %edx,%edx
movapd %xmm1,%xmm3
movapd %xmm1,%xmm4
movsd  (%rsp),%xmm0
movapd %xmm0,%xmm5
movapd %xmm0,%xmm12
movapd %xmm1,%xmm11
nopl   (%rax)
movapd %xmm5,%xmm9
movsd  (%rsp),%xmm8
movapd %xmm4,%xmm5
movapd %xmm3,%xmm10
addsd  %xmm2,%xmm11
movsd  0x738(%rsp,%rdx,1),%xmm0
addsd  %xmm0,%xmm12
movapd %xmm2,%xmm4
minsd  %xmm5,%xmm4
movapd %xmm2,%xmm3
maxsd  %xmm10,%xmm3
movapd %xmm0,%xmm5
minsd  %xmm9,%xmm5
maxsd  %xmm8,%xmm0
movsd  %xmm0,(%rsp)
lea    0x1(%rcx),%rax
movsd  0x400(%rsp,%rdx,1),%xmm2
ucomisd %xmm2,%xmm1
jne    1b20 <estimate_sigma_2D_kinship+0x9b0>
jnp    1b2d <estimate_sigma_2D_kinship+0x9bd>
add    $0xfffffffffffffff8,%rdx
cmp    $0x63,%rcx
mov    %rax,%rcx
jb     1ac0 <estimate_sigma_2D_kinship+0x950>
xorps  %xmm1,%xmm1
cvtsd2ss %xmm12,%xmm1
xorps  %xmm8,%xmm8
cvtsd2ss %xmm5,%xmm8
movsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
xorps  %xmm5,%xmm5
cvtsd2ss %xmm11,%xmm5
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
xorps  %xmm4,%xmm4
cvtsd2ss %xmm3,%xmm4
jmp    1318 <estimate_sigma_2D_kinship+0x1a8>
mov    0x247f(%rip),%rax
movsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
movslq 0x40(%rsp),%rax
mov    0x790(%rsp),%rdx
mov    0x10(%rdx,%rax,8),%rcx
movss  %xmm0,-0x64(%rcx)
mov    0x8(%rdx,%rax,8),%rax
movss  %xmm0,-0x64(%rax)
movss  %xmm0,-0x54(%rcx)
movss  %xmm0,-0x54(%rax)
jmp    1e77 <estimate_sigma_2D_kinship+0xd07>
lea    0x1(%r8),%ecx
movslq %r8d,%rax
lea    0x2(%rax),%r14
mov    0x10(%rbx,%rax,8),%rdx
movl   $0x0,-0x64(%rdx)
movslq %ecx,%rax
mov    %rax,0x10(%rsp)
mov    (%rbx,%rax,8),%rax
movl   $0x0,-0x64(%rax)
movl   $0x0,-0x54(%rdx)
movl   $0x0,-0x54(%rax)
test   %r8d,%r8d
jle    1df2 <estimate_sigma_2D_kinship+0xc82>
mov    %r14,0x70(%rsp)
mov    %r8,%rbp
lea    -0x1(%r8),%edx
mov    %edx,(%rsp)
mov    %ecx,%r9d
mov    0x23ed(%rip),%rcx
movsd  (%rcx),%xmm0
lea    -0x8(%rbx),%r14
mov    $0x1,%r15d
mov    %r9,0x30(%rsp)
mov    0x40(%rsp),%r12
mov    (%rsp),%ebp
mov    0x10(%rsp),%r13
jmp    1c31 <estimate_sigma_2D_kinship+0xac1>
nopl   (%rax)
add    $0x1,%r15
add    $0xfffffffffffffff8,%r14
cmp    %r15,%r9
je     1d12 <estimate_sigma_2D_kinship+0xba2>
mov    (%r14),%rcx
movss  -0x54(%rcx),%xmm1
xorps  %xmm2,%xmm2
cvtsd2ss %xmm0,%xmm2
ucomiss %xmm2,%xmm1
jne    1c47 <estimate_sigma_2D_kinship+0xad7>
jnp    1c20 <estimate_sigma_2D_kinship+0xab0>
mov    (%rbx),%rax
movss  -0x54(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    %eax,%ebx
imul   %r12d,%ebx
mov    (%r14),%rax
movss  -0x54(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
imul   %ebp,%eax
sub    %eax,%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mov    0x790(%rsp),%rax
mov    (%rax,%r15,8),%rax
movss  %xmm0,-0x54(%rax)
mov    0x790(%rsp),%rax
mov    (%rax,%r13,8),%rax
addss  -0x54(%rax),%xmm0
movss  %xmm0,-0x54(%rax)
mov    0x790(%rsp),%rax
mov    (%rax),%rax
movss  -0x64(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    %eax,%ebx
imul   %r12d,%ebx
mov    (%r14),%rax
movss  -0x64(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <fabs@plt>
mov    0x30(%rsp),%r9
imul   %ebp,%eax
sub    %eax,%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mov    0x790(%rsp),%rbx
mov    (%rbx,%r15,8),%rax
movss  %xmm0,-0x64(%rax)
mov    (%rbx,%r13,8),%rax
addss  -0x64(%rax),%xmm0
movss  %xmm0,-0x64(%rax)
mov    0x22df(%rip),%rcx
movsd  (%rcx),%xmm0
jmp    1c20 <estimate_sigma_2D_kinship+0xab0>
movss  -0x64(%rax),%xmm0
movss  -0x54(%rax),%xmm1
mov    0x40(%rsp),%r8
xorps  %xmm2,%xmm2
cvtsi2ss %r8d,%xmm2
divss  %xmm2,%xmm1
movss  %xmm1,-0x54(%rax)
divss  %xmm2,%xmm0
movss  %xmm0,-0x64(%rax)
test   %r8d,%r8d
jle    1e16 <estimate_sigma_2D_kinship+0xca6>
mov    0x229d(%rip),%rcx
movsd  (%rcx),%xmm0
cvtsd2ss %xmm0,%xmm0
lea    -0x8(%rbx),%rcx
mov    $0x1,%edx
mov    0x70(%rsp),%r14
jmp    1d81 <estimate_sigma_2D_kinship+0xc11>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    $0xfffffffffffffff8,%rcx
cmp    %rdx,%r9
je     1e1b <estimate_sigma_2D_kinship+0xcab>
mov    (%rcx),%rsi
movss  -0x54(%rsi),%xmm1
ucomiss %xmm0,%xmm1
jne    1d90 <estimate_sigma_2D_kinship+0xc20>
jnp    1d70 <estimate_sigma_2D_kinship+0xc00>
mov    (%rbx,%rdx,8),%rsi
movss  -0x54(%rsi),%xmm1
subss  -0x54(%rax),%xmm1
mov    (%rbx,%r14,8),%rdi
mulss  %xmm1,%xmm1
addss  -0x54(%rdi),%xmm1
movss  %xmm1,-0x54(%rdi)
movss  -0x64(%rsi),%xmm1
subss  -0x64(%rax),%xmm1
mulss  %xmm1,%xmm1
addss  -0x64(%rdi),%xmm1
movss  %xmm1,-0x64(%rdi)
jmp    1d70 <estimate_sigma_2D_kinship+0xc00>
movslq %r8d,%rax
mov    0x10(%rbx,%rax,8),%rax
movss  %xmm0,-0x64(%rax)
movslq %ecx,%rcx
mov    (%rbx,%rcx,8),%rcx
movss  %xmm0,-0x64(%rcx)
movss  %xmm0,-0x54(%rax)
movss  %xmm0,-0x54(%rcx)
jmp    1e77 <estimate_sigma_2D_kinship+0xd07>
xorps  %xmm2,%xmm2
cvtsi2ss %r8d,%xmm2
xorps  %xmm0,%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,-0x54(%rax)
movss  -0x64(%rax),%xmm0
divss  %xmm2,%xmm0
movss  %xmm0,-0x64(%rax)
jmp    1e1b <estimate_sigma_2D_kinship+0xcab>
mov    0x70(%rsp),%r14
movss  %xmm2,(%rsp)
add    $0xffffffff,%r8d
xorps  %xmm1,%xmm1
cvtsi2ss %r8d,%xmm1
movss  %xmm1,0x10(%rsp)
mov    (%rbx,%r14,8),%rax
movss  -0x54(%rax),%xmm0
divss  %xmm1,%xmm0
divss  %xmm2,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    (%rbx,%r14,8),%rax
movss  %xmm0,-0x54(%rax)
movss  -0x64(%rax),%xmm0
divss  0x10(%rsp),%xmm0
divss  (%rsp),%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    (%rbx,%r14,8),%rax
movss  %xmm0,-0x64(%rax)
add    $0x748,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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