#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 */
float HUGE_VAL;
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free_ivector(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_matrix(float **, int /*<<< orphan*/, int,
                               int /*<<< orphan*/, int);
int ***i3tensor(int, int, int /*<<< orphan*/, int, int /*<<< orphan*/, int);
int *ivector(int /*<<< orphan*/, int);
float **matrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
void compute_allele_freq(int n, int Ncat, int *cati, int m, int ndigit,
                         int ploidy, int ***gilc, int *ploidyi, int *Nallelel,
                         int **allelesizela, float ***Mgdlaa, int alleledist,
                         float ***Pkla, int **Nallelekl, int **Nmissinggenotkl,
                         int **Nincompletegenotkl, int **Nvalgenkl,
                         float **Nnielsenkl, float **RA, int *K, float **Hokl,
                         float **Hekl, float **hTkl, float **vTkl, float **Dmkl,
                         float **Dwmkl, float **Masizekl, float **Vasizekl) {
  int i, l, a, a1, a2, k, k1, k2, npairs, nallelepairs;
  float Navalid, nvalidpop, **NvalidHokl, sumweight;
  float Sasize, SSasize;
  float **Jkl;
  int *Nik, ***Nkla;
  int maxnal;
  int N, Ns;
  double C;
  Nik = ivector(0, Ncat);
  for (k = 0; k <= Ncat; k++)
    Nik[k] = 0;
  for (i = 1; i <= n; i++) {
    Nik[0]++;
    if (Ncat) {
      if (cati[i] <= Ncat)
        Nik[cati[i]]++;
      else
        exit(133);
    }
  }
  maxnal = 0;
  for (l = 1; l <= m; l++)
    if (Nallelel[l] > maxnal)
      maxnal = Nallelel[l];
  Jkl = matrix(0, Ncat, 0, m);
  Nkla = i3tensor(-1, Ncat, 0, m, 0, maxnal);
  NvalidHokl = matrix(0, Ncat, 0, m);
  for (k = 0; k <= Ncat; k++)
    for (l = 0; l <= m; l++)
      Nvalgenkl[k][l] = Nmissinggenotkl[k][l] = Nincompletegenotkl[k][l] = 0;
  for (k = -1; k <= Ncat; k++)
    for (l = 0; l <= m; l++)
      for (a = 0; a <= Nallelel[l]; a++)
        Pkla[k][l][a] = Nkla[k][l][a] = 0;
  for (k = 0; k <= Ncat; k++)
    for (l = 0; l <= m; l++)
      NvalidHokl[k][l] = Hokl[k][l] = 0.;
  for (i = 1; i <= n; i++) {
    for (l = 1; l <= m; l++) {
      Navalid = (float)ploidyi[i];
      for (a = 0; a < ploidyi[i]; a++)
        if (gilc[i][l][a] == 0)
          Navalid--;
      if (Navalid) {
        for (a = 0; a < ploidyi[i]; a++)
          if (gilc[i][l][a]) {
            Nvalgenkl[0][l]++;
            if (Ncat)
              Nvalgenkl[cati[i]][l]++;
            Pkla[0][l][gilc[i][l][a]] += 1.0f / Navalid;
            Nkla[0][l][gilc[i][l][a]]++;
            if (Ncat >= 1) {
              Pkla[cati[i]][l][gilc[i][l][a]] += 1.0f / Navalid;
              Nkla[cati[i]][l][gilc[i][l][a]]++;
            }
          }
      } else {
        Pkla[0][l][0]++;
        Nmissinggenotkl[0][l]++;
        if (Ncat >= 1)
          Pkla[cati[i]][l][0]++;
      }
      if (Navalid > 0 && Navalid < ploidyi[i])
        Nincompletegenotkl[0][l]++;
      if (Ncat) {
        if (Navalid == 0)
          Nmissinggenotkl[cati[i]][l]++;
        if (Navalid > 0 && Navalid < ploidyi[i])
          Nincompletegenotkl[cati[i]][l]++;
      }
      if (Navalid > 1) {
        if (ploidyi[i] == 2) {
          if (gilc[i][l][0] != gilc[i][l][1]) {
            Hokl[0][l]++;
            if (Ncat)
              Hokl[cati[i]][l]++;
          }
        } else {
          for (a1 = 0; a1 < (ploidyi[i] - 1); a1++)
            if (gilc[i][l][a1] != 0)
              for (a2 = a1 + 1; a2 < ploidyi[i]; a2++)
                if (gilc[i][l][a2] != 0) {
                  if (gilc[i][l][a1] != gilc[i][l][a2]) {
                    Hokl[0][l] += 1 / (Navalid * (Navalid - 1) / 2.);
                    if (Ncat)
                      Hokl[cati[i]][l] += 1 / (Navalid * (Navalid - 1) / 2.);
                  }
                }
        }
        NvalidHokl[0][l]++;
        if (Ncat)
          NvalidHokl[cati[i]][l]++;
      }
    }
  }
  for (l = 1; l <= m; l++)
    for (a = 1; a <= Nallelel[l]; a++)
      for (k = 0; k <= Ncat; k++)
        Pkla[k][l][a] /= (Nik[k] - Pkla[k][l][0]);
  for (k = 0; k <= Ncat; k++) {
    NvalidHokl[k][0] = 0;
    for (l = 1; l <= m; l++) {
      if (NvalidHokl[k][l] > 0) {
        Hokl[k][l] /= NvalidHokl[k][l];
        Hokl[k][0] += Hokl[k][l];
        NvalidHokl[k][0]++;
      } else
        Hokl[k][l] = HUGE_VAL;
    }
    if (NvalidHokl[k][0] > 0)
      Hokl[k][0] /= NvalidHokl[k][0];
    else
      Hokl[k][0] = HUGE_VAL;
  }
  for (l = 1; l <= m; l++)
    for (k = 0; k <= Ncat; k++)
      Pkla[k][l][0] = (float)Nvalgenkl[k][l];
  for (k = 0; k <= Ncat; k++) {
    Nvalgenkl[k][0] = 2;
    for (l = 1; l <= m; l++)
      if (Nvalgenkl[k][l] < 2)
        Nvalgenkl[k][0] = 0;
  }
  for (l = 1; l <= m; l++) {
    nvalidpop = 0.;
    for (k = 1; k <= Ncat; k++)
      if (Nvalgenkl[k][l]) {
        nvalidpop++;
        for (a = 1; a <= Nallelel[l]; a++)
          Pkla[-1][l][a] += Pkla[k][l][a];
      }
    for (a = 1; a <= Nallelel[l]; a++)
      Pkla[-1][l][a] /= nvalidpop;
  }
  for (l = 0; l <= m; l++)
    for (k = 0; k <= Ncat; k++)
      Nallelekl[k][l] = 0;
  for (l = 1; l <= m; l++)
    for (a = 1; a <= Nallelel[l]; a++)
      for (k = 0; k <= Ncat; k++)
        if (Pkla[k][l][a])
          Nallelekl[k][l]++;
  if ((*K) == 0) {
    (*K) = n * ploidy;
    for (l = 1; l <= m; l++)
      for (k = 0; k <= Ncat; k++)
        if (Nvalgenkl[k][l] > 1 && Nvalgenkl[k][l] < (*K))
          (*K) = Nvalgenkl[k][l];
  }
  for (k = 0; k <= Ncat; k++) {
    RA[k][0] = 0.;
    for (l = 1; l <= m; l++) {
      if (Nvalgenkl[k][l] > (*K)) {
        N = Nvalgenkl[k][l];
        RA[k][l] = 0.;
        for (a = 1; a <= Nallelel[l]; a++) {
          Ns = Nkla[k][l][a];
          C = 1.;
          for (n = 0; n < (*K); n++)
            C *= (N - Ns - n) / (double)(N - n);
          RA[k][l] += (float)(1. - C);
        }
      } else if (Nvalgenkl[k][l] == (*K))
        RA[k][l] = Nallelekl[k][l];
      else
        RA[k][l] = HUGE_VAL;
      RA[k][0] += RA[k][l] / m;
    }
  }
  for (k = 0; k <= Ncat; k++)
    Hekl[k][0] = Nnielsenkl[k][0] = 0.;
  for (k = 0; k <= Ncat; k++)
    for (l = 1; l <= m; l++) {
      if (Nvalgenkl[k][l] > 1) {
        Jkl[k][l] = 0.;
        for (a = 1; a <= Nallelel[l]; a++)
          Jkl[k][l] += Pkla[k][l][a] * Pkla[k][l][a];
        Hekl[k][l] = 1.0f - Jkl[k][l];
        Hekl[k][l] *= (float)(Nvalgenkl[k][l] / (Nvalgenkl[k][l] - 1.0f));
        Nnielsenkl[k][l] = Nvalgenkl[k][l] * (Nvalgenkl[k][l] - 1.) /
                           (2. + (1. - Hekl[k][l]) * (Nvalgenkl[k][l] - 2.) *
                                     (Nvalgenkl[k][l] + 1.));
      } else
        Hekl[k][l] = Nnielsenkl[k][l] = HUGE_VAL;
      Hekl[k][0] += Hekl[k][l] / m;
      Nnielsenkl[k][0] += Nnielsenkl[k][l] / m;
    }
  for (l = 1; l <= m; l++) {
    for (k = 1; k <= Ncat; k++) {
      if (Nvalgenkl[k][l] > 1) {
        hTkl[k][l] = vTkl[k][l] = Dmkl[k][l] = Dwmkl[k][l] = sumweight = 0.0f;
        nallelepairs = 0;
        for (a1 = 1; a1 <= Nallelel[l]; a1++)
          if (Pkla[k][l][a1])
            for (a2 = 1; a2 <= Nallelel[l]; a2++) {
              if (a1 != a2)
                hTkl[k][l] += Pkla[k][l][a1] * Pkla[k][l][a2];
              if (alleledist) {
                vTkl[k][l] +=
                    Mgdlaa[l][a1][a2] * Pkla[k][l][a1] * Pkla[k][l][a2];
                if (a1 != a2 && Pkla[k][l][a1] && Pkla[k][l][a2]) {
                  nallelepairs++;
                  Dmkl[k][l] += Mgdlaa[l][a1][a2];
                  Dwmkl[k][l] +=
                      Mgdlaa[l][a1][a2] * Pkla[k][l][a1] * Pkla[k][l][a2];
                  sumweight += Pkla[k][l][a1] * Pkla[k][l][a2];
                }
              }
            }
        hTkl[k][l] *= (float)(Nvalgenkl[k][l] / (Nvalgenkl[k][l] - 1.));
        vTkl[k][l] *= (float)(Nvalgenkl[k][l] / (Nvalgenkl[k][l] - 1.));
        if (nallelepairs)
          Dmkl[k][l] /= nallelepairs;
        else
          Dmkl[k][l] = (float)HUGE_VAL;
        if (sumweight)
          Dwmkl[k][l] /= sumweight;
        else
          Dwmkl[k][l] = (float)HUGE_VAL;
      } else
        hTkl[k][l] = vTkl[k][l] = Dmkl[k][l] = Dwmkl[k][l] = (float)HUGE_VAL;
    }
    hTkl[0][l] = vTkl[0][l] = Dmkl[0][l] = Dwmkl[0][l] = 0.0f;
    npairs = 0;
    for (k1 = 1; k1 < Ncat; k1++)
      for (k2 = k1 + 1; k2 <= Ncat; k2++) {
        if (Nvalgenkl[k1][l] > 1 && Nvalgenkl[k2][l] > 1) {
          npairs++;
          for (a1 = 1; a1 <= Nallelel[l]; a1++)
            if (Pkla[k1][l][a1])
              for (a2 = 1; a2 <= Nallelel[l]; a2++)
                if (Pkla[k2][l][a2]) {
                  if (a1 != a2)
                    hTkl[0][l] += Pkla[k1][l][a1] * Pkla[k2][l][a2];
                  if (alleledist)
                    vTkl[0][l] +=
                        Mgdlaa[l][a1][a2] * Pkla[k1][l][a1] * Pkla[k2][l][a2];
                }
        }
      }
    if (npairs) {
      hTkl[0][l] /= npairs;
      vTkl[0][l] /= npairs;
    } else
      hTkl[0][l] = vTkl[0][l] = HUGE_VAL;
    nallelepairs = 0;
    sumweight = 0.0f;
    if (alleledist)
      for (a1 = 1; a1 <= Nallelel[l]; a1++)
        for (a2 = 1; a2 <= Nallelel[l]; a2++) {
          if (a1 != a2 && Pkla[-1][l][a1] && Pkla[-1][l][a2]) {
            nallelepairs++;
            Dmkl[0][l] += Mgdlaa[l][a1][a2];
            Dwmkl[0][l] +=
                Mgdlaa[l][a1][a2] * Pkla[-1][l][a1] * Pkla[-1][l][a2];
            sumweight += Pkla[-1][l][a1] * Pkla[-1][l][a2];
          }
        }
    if (nallelepairs)
      Dmkl[0][l] /= nallelepairs;
    else
      Dmkl[0][l] = (float)HUGE_VAL;
    if (sumweight)
      Dwmkl[0][l] /= sumweight;
    else
      Dwmkl[0][l] = (float)HUGE_VAL;
  }
  for (k = 0; k <= Ncat; k++) {
    hTkl[k][0] = vTkl[k][0] = Dmkl[k][0] = Dwmkl[k][0] = 0.0f;
    for (l = 1; l <= m; l++) {
      hTkl[k][0] += hTkl[k][l] / m;
      vTkl[k][0] += vTkl[k][l] / m;
      Dmkl[k][0] += Dmkl[k][l] / m;
      Dwmkl[k][0] += Dwmkl[k][l] / m;
    }
  }
  for (k = 0; k <= Ncat; k++)
    Masizekl[k][0] = Vasizekl[k][0] = (float)0.;
  for (l = 1; l <= m; l++) {
    for (k = 0; k <= Ncat; k++) {
      if (Nvalgenkl[k][l] > 1) {
        Sasize = SSasize = 0.;
        for (a = 1; a <= Nallelel[l]; a++) {
          Sasize += Pkla[k][l][a] * allelesizela[l][a];
          SSasize += Pkla[k][l][a] * allelesizela[l][a] * allelesizela[l][a];
        }
        Masizekl[k][l] = Sasize;
        Vasizekl[k][l] =
            (float)((SSasize - Sasize * Sasize) *
                    ((double)Nvalgenkl[k][l] / (Nvalgenkl[k][l] - 1.)));
      } else
        Masizekl[k][l] = Vasizekl[k][l] = HUGE_VAL;
      Masizekl[k][0] += Masizekl[k][l] / m;
      Vasizekl[k][0] += Vasizekl[k][l] / m;
    }
  }
  free_matrix(Jkl, 0, Ncat, 0, m);
  free_ivector(Nik, 0, Ncat);
}


x86 assembly (clang, -O0):
<compute_allele_freq>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
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    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0x8(%rbp),%esi
xor    %edi,%edi
call   1070 <ivector@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     122d <compute_allele_freq+0xcd>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1204 <compute_allele_freq+0xa4>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     12a9 <compute_allele_freq+0x149>
mov    -0x78(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x0,-0x8(%rbp)
je     1296 <compute_allele_freq+0x136>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x8(%rbp),%eax
jg     1287 <compute_allele_freq+0x127>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1291 <compute_allele_freq+0x131>
mov    $0x85,%edi
call   1080 <exit@plt>
jmp    1296 <compute_allele_freq+0x136>
jmp    129b <compute_allele_freq+0x13b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1234 <compute_allele_freq+0xd4>
movl   $0x0,-0x84(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1301 <compute_allele_freq+0x1a1>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x84(%rbp),%eax
jle    12ee <compute_allele_freq+0x18e>
mov    0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
jmp    12f3 <compute_allele_freq+0x193>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12ba <compute_allele_freq+0x15a>
mov    -0x8(%rbp),%esi
mov    -0x14(%rbp),%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1050 <matrix@plt>
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%esi
mov    -0x14(%rbp),%ecx
mov    -0x84(%rbp),%r9d
mov    $0xffffffff,%edi
xor    %r8d,%r8d
mov    %r8d,%edx
call   1040 <i3tensor@plt>
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%esi
mov    -0x14(%rbp),%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1050 <matrix@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13d4 <compute_allele_freq+0x274>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     13c1 <compute_allele_freq+0x261>
mov    0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1362 <compute_allele_freq+0x202>
jmp    13c6 <compute_allele_freq+0x266>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    134f <compute_allele_freq+0x1ef>
movl   $0xffffffff,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1488 <compute_allele_freq+0x328>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1475 <compute_allele_freq+0x315>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1462 <compute_allele_freq+0x302>
mov    -0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1401 <compute_allele_freq+0x2a1>
jmp    1467 <compute_allele_freq+0x307>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13ee <compute_allele_freq+0x28e>
jmp    147a <compute_allele_freq+0x31a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13db <compute_allele_freq+0x27b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1502 <compute_allele_freq+0x3a2>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14ef <compute_allele_freq+0x38f>
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14a2 <compute_allele_freq+0x342>
jmp    14f4 <compute_allele_freq+0x394>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    148f <compute_allele_freq+0x32f>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1b9d <compute_allele_freq+0xa3d>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1b8a <compute_allele_freq+0xa2a>
mov    0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    159c <compute_allele_freq+0x43c>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1589 <compute_allele_freq+0x429>
movss  0x2a95(%rip),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    158e <compute_allele_freq+0x42e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1541 <compute_allele_freq+0x3e1>
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    15b8 <compute_allele_freq+0x458>
jp     15b8 <compute_allele_freq+0x458>
jmp    1761 <compute_allele_freq+0x601>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    175c <compute_allele_freq+0x5fc>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1749 <compute_allele_freq+0x5e9>
mov    0x60(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x8(%rbp)
je     1634 <compute_allele_freq+0x4d4>
mov    0x60(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
movss  0x29d4(%rip),%xmm0
divss  -0x48(%rbp),%xmm0
mov    0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x8(%rbp)
jl     1744 <compute_allele_freq+0x5e4>
movss  0x2954(%rip),%xmm0
divss  -0x48(%rbp),%xmm0
mov    0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1749 <compute_allele_freq+0x5e9>
jmp    174e <compute_allele_freq+0x5ee>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15bf <compute_allele_freq+0x45f>
jmp    17cf <compute_allele_freq+0x66f>
mov    0x40(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x2898(%rip),%xmm0
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0x50(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x8(%rbp)
jl     17ca <compute_allele_freq+0x66a>
mov    0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x284e(%rip),%xmm0
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
jmp    17cf <compute_allele_freq+0x66f>
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    180f <compute_allele_freq+0x6af>
movss  -0x48(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    180f <compute_allele_freq+0x6af>
mov    0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x8(%rbp)
je     18a3 <compute_allele_freq+0x743>
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1851 <compute_allele_freq+0x6f1>
jp     1851 <compute_allele_freq+0x6f1>
mov    0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    189e <compute_allele_freq+0x73e>
movss  -0x48(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    189e <compute_allele_freq+0x73e>
mov    0x58(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    18a3 <compute_allele_freq+0x743>
movss  -0x48(%rbp),%xmm0
movss  0x2760(%rip),%xmm1
ucomiss %xmm1,%xmm0
jbe    1b77 <compute_allele_freq+0xa17>
mov    0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jne    195f <compute_allele_freq+0x7ff>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
je     195a <compute_allele_freq+0x7fa>
mov    0x80(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  0x26fc(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x8(%rbp)
je     1955 <compute_allele_freq+0x7f5>
mov    0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  0x26c5(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    195a <compute_allele_freq+0x7fa>
jmp    1b21 <compute_allele_freq+0x9c1>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b1c <compute_allele_freq+0x9bc>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1b09 <compute_allele_freq+0x9a9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1b04 <compute_allele_freq+0x9a4>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1af1 <compute_allele_freq+0x991>
mov    0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     1aec <compute_allele_freq+0x98c>
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
movss  0x25e2(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x25c6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x25b2(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x80(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x8(%rbp)
je     1ae7 <compute_allele_freq+0x987>
movss  -0x48(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
movss  0x257e(%rip),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2562(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x254e(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1aec <compute_allele_freq+0x98c>
jmp    1af1 <compute_allele_freq+0x991>
jmp    1af6 <compute_allele_freq+0x996>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19aa <compute_allele_freq+0x84a>
jmp    1b09 <compute_allele_freq+0x9a9>
jmp    1b0e <compute_allele_freq+0x9ae>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1966 <compute_allele_freq+0x806>
jmp    1b21 <compute_allele_freq+0x9c1>
mov    -0x58(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  0x24dc(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x8(%rbp)
je     1b72 <compute_allele_freq+0xa12>
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  0x24a8(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1b77 <compute_allele_freq+0xa17>
jmp    1b7c <compute_allele_freq+0xa1c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    151c <compute_allele_freq+0x3bc>
jmp    1b8f <compute_allele_freq+0xa2f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1509 <compute_allele_freq+0x3a9>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1c5d <compute_allele_freq+0xafd>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1c4a <compute_allele_freq+0xaea>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1c37 <compute_allele_freq+0xad7>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
subss  (%rax),%xmm1
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bd2 <compute_allele_freq+0xa72>
jmp    1c3c <compute_allele_freq+0xadc>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1bb7 <compute_allele_freq+0xa57>
jmp    1c4f <compute_allele_freq+0xaef>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ba4 <compute_allele_freq+0xa44>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1df0 <compute_allele_freq+0xc90>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1d73 <compute_allele_freq+0xc13>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1d3d <compute_allele_freq+0xbdd>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x22e0(%rip),%xmm0
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
jmp    1d60 <compute_allele_freq+0xc00>
mov    0x42a4(%rip),%rax
movss  (%rax),%xmm0
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1d65 <compute_allele_freq+0xc05>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c8a <compute_allele_freq+0xb2a>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1dbf <compute_allele_freq+0xc5f>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm1
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    1ddd <compute_allele_freq+0xc7d>
mov    0x4222(%rip),%rax
movss  (%rax),%xmm0
mov    0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
jmp    1de2 <compute_allele_freq+0xc82>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c64 <compute_allele_freq+0xb04>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1e64 <compute_allele_freq+0xd04>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1e51 <compute_allele_freq+0xcf1>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e0a <compute_allele_freq+0xcaa>
jmp    1e56 <compute_allele_freq+0xcf6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1df7 <compute_allele_freq+0xc97>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1eee <compute_allele_freq+0xd8e>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x2,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1edb <compute_allele_freq+0xd7b>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jge    1ec8 <compute_allele_freq+0xd68>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x0,(%rax)
jmp    1ecd <compute_allele_freq+0xd6d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1e90 <compute_allele_freq+0xd30>
jmp    1ee0 <compute_allele_freq+0xd80>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e6b <compute_allele_freq+0xd0b>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     2027 <compute_allele_freq+0xec7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1fc4 <compute_allele_freq+0xe64>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1fb1 <compute_allele_freq+0xe51>
movss  0x20d2(%rip),%xmm0
addss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1fac <compute_allele_freq+0xe4c>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1f4f <compute_allele_freq+0xdef>
jmp    1fb1 <compute_allele_freq+0xe51>
jmp    1fb6 <compute_allele_freq+0xe56>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f10 <compute_allele_freq+0xdb0>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2014 <compute_allele_freq+0xeb4>
movss  -0x4c(%rbp),%xmm1
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1fcb <compute_allele_freq+0xe6b>
jmp    2019 <compute_allele_freq+0xeb9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ef5 <compute_allele_freq+0xd95>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     2085 <compute_allele_freq+0xf25>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2072 <compute_allele_freq+0xf12>
mov    0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2041 <compute_allele_freq+0xee1>
jmp    2077 <compute_allele_freq+0xf17>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    202e <compute_allele_freq+0xece>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     214c <compute_allele_freq+0xfec>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2139 <compute_allele_freq+0xfd9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2126 <compute_allele_freq+0xfc6>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    20fa <compute_allele_freq+0xf9a>
jp     20fa <compute_allele_freq+0xf9a>
jmp    2113 <compute_allele_freq+0xfb3>
mov    0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    2118 <compute_allele_freq+0xfb8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20ba <compute_allele_freq+0xf5a>
jmp    212b <compute_allele_freq+0xfcb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    209f <compute_allele_freq+0xf3f>
jmp    213e <compute_allele_freq+0xfde>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    208c <compute_allele_freq+0xf2c>
mov    0x78(%rbp),%rax
cmpl   $0x0,(%rax)
jne    2209 <compute_allele_freq+0x10a9>
mov    -0x4(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     2204 <compute_allele_freq+0x10a4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     21f1 <compute_allele_freq+0x1091>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    21de <compute_allele_freq+0x107e>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x78(%rbp),%rcx
cmp    (%rcx),%eax
jge    21de <compute_allele_freq+0x107e>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
jmp    21e3 <compute_allele_freq+0x1083>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2180 <compute_allele_freq+0x1020>
jmp    21f6 <compute_allele_freq+0x1096>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    216d <compute_allele_freq+0x100d>
jmp    2209 <compute_allele_freq+0x10a9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     243d <compute_allele_freq+0x12dd>
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     242a <compute_allele_freq+0x12ca>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x78(%rbp),%rcx
cmp    (%rcx),%eax
jle    2377 <compute_allele_freq+0x1217>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2372 <compute_allele_freq+0x1212>
mov    -0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
movsd  0x1d2a(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
mov    0x78(%rbp),%rcx
cmp    (%rcx),%eax
jge    2336 <compute_allele_freq+0x11d6>
mov    -0x88(%rbp),%eax
sub    -0x8c(%rbp),%eax
sub    -0x4(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x88(%rbp),%eax
sub    -0x4(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    22e5 <compute_allele_freq+0x1185>
movsd  0x1cc2(%rip),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    2299 <compute_allele_freq+0x1139>
jmp    23ea <compute_allele_freq+0x128a>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x78(%rbp),%rcx
cmp    (%rcx),%eax
jne    23c5 <compute_allele_freq+0x1265>
mov    0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    23e5 <compute_allele_freq+0x1285>
mov    0x3c1c(%rip),%rax
movss  (%rax),%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    23ea <compute_allele_freq+0x128a>
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2236 <compute_allele_freq+0x10d6>
jmp    242f <compute_allele_freq+0x12cf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2210 <compute_allele_freq+0x10b0>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2487 <compute_allele_freq+0x1327>
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2444 <compute_allele_freq+0x12e4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     278d <compute_allele_freq+0x162d>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     277a <compute_allele_freq+0x161a>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    26ca <compute_allele_freq+0x156a>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2564 <compute_allele_freq+0x1404>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    24e6 <compute_allele_freq+0x1386>
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  0x1a94(%rip),%xmm0
subss  (%rax,%rcx,4),%xmm0
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
movss  0x1a45(%rip),%xmm2
subss  %xmm2,%xmm1
divss  %xmm1,%xmm0
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  0x19de(%rip),%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x19b2(%rip),%xmm1
subsd  %xmm2,%xmm1
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
movsd  0x1999(%rip),%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
movsd  0x196c(%rip),%xmm3
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1964(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2702 <compute_allele_freq+0x15a2>
mov    0x3917(%rip),%rax
movss  (%rax),%xmm0
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    24a1 <compute_allele_freq+0x1341>
jmp    277f <compute_allele_freq+0x161f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    248e <compute_allele_freq+0x132e>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     330b <compute_allele_freq+0x21ab>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2d4d <compute_allele_freq+0x1bed>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    2ccf <compute_allele_freq+0x1b6f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2b52 <compute_allele_freq+0x19f2>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2897 <compute_allele_freq+0x1737>
jp     2897 <compute_allele_freq+0x1737>
jmp    2b3f <compute_allele_freq+0x19df>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2b3a <compute_allele_freq+0x19da>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     291d <compute_allele_freq+0x17bd>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,0x38(%rbp)
je     2b27 <compute_allele_freq+0x19c7>
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     2b22 <compute_allele_freq+0x19c2>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    29e3 <compute_allele_freq+0x1883>
jp     29e3 <compute_allele_freq+0x1883>
jmp    2b22 <compute_allele_freq+0x19c2>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2a17 <compute_allele_freq+0x18b7>
jp     2a17 <compute_allele_freq+0x18b7>
jmp    2b22 <compute_allele_freq+0x19c2>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    2b27 <compute_allele_freq+0x19c7>
jmp    2b2c <compute_allele_freq+0x19cc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    289e <compute_allele_freq+0x173e>
jmp    2b3f <compute_allele_freq+0x19df>
jmp    2b44 <compute_allele_freq+0x19e4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    284f <compute_allele_freq+0x16ef>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  0x147c(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
movsd  0x1421(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x44(%rbp)
je     2c3d <compute_allele_freq+0x1add>
cvtsi2ssl -0x44(%rbp),%xmm1
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    2c60 <compute_allele_freq+0x1b00>
mov    0x33a4(%rip),%rax
movss  (%rax),%xmm0
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2c7c <compute_allele_freq+0x1b1c>
jp     2c7c <compute_allele_freq+0x1b1c>
jmp    2ca7 <compute_allele_freq+0x1b47>
movss  -0x5c(%rbp),%xmm1
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    2cca <compute_allele_freq+0x1b6a>
mov    0x333a(%rip),%rax
movss  (%rax),%xmm0
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2d3a <compute_allele_freq+0x1bda>
mov    0x3312(%rip),%rax
movss  (%rax),%xmm0
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    2d3f <compute_allele_freq+0x1bdf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    27a7 <compute_allele_freq+0x1647>
mov    0xa8(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0xa0(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x98(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x90(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2ff1 <compute_allele_freq+0x1e91>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2fde <compute_allele_freq+0x1e7e>
mov    0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    2fcb <compute_allele_freq+0x1e6b>
mov    0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    2fcb <compute_allele_freq+0x1e6b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2fc6 <compute_allele_freq+0x1e66>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2e60 <compute_allele_freq+0x1d00>
jp     2e60 <compute_allele_freq+0x1d00>
jmp    2fb3 <compute_allele_freq+0x1e53>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     2fae <compute_allele_freq+0x1e4e>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2eaf <compute_allele_freq+0x1d4f>
jp     2eaf <compute_allele_freq+0x1d4f>
jmp    2f9b <compute_allele_freq+0x1e3b>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     2f15 <compute_allele_freq+0x1db5>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x90(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,0x38(%rbp)
je     2f96 <compute_allele_freq+0x1e36>
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x98(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    2f9b <compute_allele_freq+0x1e3b>
jmp    2fa0 <compute_allele_freq+0x1e40>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2e67 <compute_allele_freq+0x1d07>
jmp    2fb3 <compute_allele_freq+0x1e53>
jmp    2fb8 <compute_allele_freq+0x1e58>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2e18 <compute_allele_freq+0x1cb8>
jmp    2fcb <compute_allele_freq+0x1e6b>
jmp    2fd0 <compute_allele_freq+0x1e70>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2dc8 <compute_allele_freq+0x1c68>
jmp    2fe3 <compute_allele_freq+0x1e83>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2db3 <compute_allele_freq+0x1c53>
cmpl   $0x0,-0x40(%rbp)
je     3042 <compute_allele_freq+0x1ee2>
cvtsi2ssl -0x40(%rbp),%xmm1
mov    0x90(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl -0x40(%rbp),%xmm1
mov    0x98(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    3073 <compute_allele_freq+0x1f13>
mov    0x2f9f(%rip),%rax
movss  (%rax),%xmm0
mov    0x98(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x90(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpl   $0x0,0x38(%rbp)
je     324a <compute_allele_freq+0x20ea>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     3245 <compute_allele_freq+0x20e5>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     3232 <compute_allele_freq+0x20d2>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     321f <compute_allele_freq+0x20bf>
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    30fe <compute_allele_freq+0x1f9e>
jp     30fe <compute_allele_freq+0x1f9e>
jmp    321f <compute_allele_freq+0x20bf>
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    312e <compute_allele_freq+0x1fce>
jp     312e <compute_allele_freq+0x1fce>
jmp    321f <compute_allele_freq+0x20bf>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0xa0(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0xa8(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x40(%rbp),%rax
mov    -0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    3224 <compute_allele_freq+0x20c4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    30ae <compute_allele_freq+0x1f4e>
jmp    3237 <compute_allele_freq+0x20d7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    3093 <compute_allele_freq+0x1f33>
jmp    324a <compute_allele_freq+0x20ea>
cmpl   $0x0,-0x44(%rbp)
je     327a <compute_allele_freq+0x211a>
cvtsi2ssl -0x44(%rbp),%xmm1
mov    0xa0(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    3298 <compute_allele_freq+0x2138>
mov    0x2d67(%rip),%rax
movss  (%rax),%xmm0
mov    0xa0(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    32b4 <compute_allele_freq+0x2154>
jp     32b4 <compute_allele_freq+0x2154>
jmp    32da <compute_allele_freq+0x217a>
movss  -0x5c(%rbp),%xmm1
mov    0xa8(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    32f8 <compute_allele_freq+0x2198>
mov    0x2d07(%rip),%rax
movss  (%rax),%xmm0
mov    0xa8(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    32fd <compute_allele_freq+0x219d>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2794 <compute_allele_freq+0x1634>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     348a <compute_allele_freq+0x232a>
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     3477 <compute_allele_freq+0x2317>
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0x98(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0xa0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0xa8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    337d <compute_allele_freq+0x221d>
jmp    347c <compute_allele_freq+0x231c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3312 <compute_allele_freq+0x21b2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     34d7 <compute_allele_freq+0x2377>
mov    0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    3491 <compute_allele_freq+0x2331>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     3761 <compute_allele_freq+0x2601>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     374e <compute_allele_freq+0x25ee>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    3695 <compute_allele_freq+0x2535>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     35f1 <compute_allele_freq+0x2491>
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm1
mulss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
cvtsi2ssl (%rax,%rcx,4),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    352e <compute_allele_freq+0x23ce>
movss  -0x60(%rbp),%xmm0
mov    0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x64(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
movsd  0x998(%rip),%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    36d0 <compute_allele_freq+0x2570>
mov    0x294c(%rip),%rax
movss  (%rax),%xmm0
mov    0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0xb0(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    34f1 <compute_allele_freq+0x2391>
jmp    3753 <compute_allele_freq+0x25f3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    34de <compute_allele_freq+0x237e>
mov    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%edx
mov    -0x14(%rbp),%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1030 <free_matrix@plt>
mov    -0x78(%rbp),%rdi
mov    -0x8(%rbp),%edx
xor    %esi,%esi
call   1060 <free_ivector@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_allele_freq>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9d,0x84(%rsp)
mov    %rcx,(%rsp)
mov    %rdx,%r13
mov    %esi,%r12d
mov    %rdi,0x58(%rsp)
mov    0x1f8(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x1f0(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x1e8(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x1d8(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x1c8(%rsp),%rax
mov    %rax,0xe8(%rsp)
mov    0x1c0(%rsp),%r14
mov    0x1b8(%rsp),%rax
mov    %rax,0xd0(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x198(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x188(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    0x178(%rsp),%r15d
mov    0x170(%rsp),%rax
mov    %rax,0xc8(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0x38(%rsp)
xor    %edi,%edi
call   1080 <ivector@plt>
mov    %rax,%rdi
mov    %r12d,%ebx
test   %r12d,%r12d
mov    %rax,0xb0(%rsp)
js     1301 <compute_allele_freq+0x191>
lea    0x4(,%rbx,4),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    0xb0(%rsp),%rdi
mov    %rbx,0x78(%rsp)
cmpl   $0x0,0x58(%rsp)
mov    0x10(%rsp),%rbx
jle    1359 <compute_allele_freq+0x1e9>
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    $0x1,%ecx
jmp    133d <compute_allele_freq+0x1cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addl   $0x1,(%rdi,%rdx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1359 <compute_allele_freq+0x1e9>
addl   $0x1,(%rdi)
test   %r12d,%r12d
je     1334 <compute_allele_freq+0x1c4>
movslq 0x0(%r13,%rcx,4),%rdx
cmp    %r12d,%edx
jle    1330 <compute_allele_freq+0x1c0>
mov    $0x85,%edi
call   1090 <exit@plt>
mov    (%rsp),%rcx
test   %ecx,%ecx
jle    1374 <compute_allele_freq+0x204>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    137b <compute_allele_freq+0x20b>
xor    %ebp,%ebp
mov    $0x1,%ecx
jmp    14cd <compute_allele_freq+0x35d>
xor    %ebp,%ebp
jmp    14f1 <compute_allele_freq+0x381>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     389b <compute_allele_freq+0x272b>
mov    %rdx,%rdi
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu 0x4(%rbx,%rsi,4),%xmm2
movdqu 0x14(%rbx,%rsi,4),%xmm3
movdqu 0x24(%rbx,%rsi,4),%xmm4
movdqu 0x34(%rbx,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    13c0 <compute_allele_freq+0x250>
test   $0x1,%dl
je     147a <compute_allele_freq+0x30a>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu (%rbx,%rsi,1),%xmm2
movdqu 0x10(%rbx,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ebp
cmp    %rcx,%rax
je     14f1 <compute_allele_freq+0x381>
or     $0x1,%rcx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
cmp    %ebp,%edx
cmovg  %edx,%ebp
add    $0x1,%rcx
cmp    %rcx,%rax
jne    14e0 <compute_allele_freq+0x370>
xor    %edi,%edi
mov    %r12d,%esi
xor    %edx,%edx
mov    (%rsp),%rbx
mov    %ebx,%ecx
call   1060 <matrix@plt>
mov    %rax,0xd8(%rsp)
mov    $0xffffffff,%edi
mov    %r12d,%esi
xor    %edx,%edx
mov    %ebx,%ecx
xor    %r8d,%r8d
mov    %ebp,%r9d
call   1050 <i3tensor@plt>
mov    %rax,0x48(%rsp)
xor    %edi,%edi
mov    %r12d,%esi
xor    %edx,%edx
mov    %ebx,%ecx
call   1060 <matrix@plt>
mov    %rax,0x28(%rsp)
test   %r12d,%r12d
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r10
js     17d3 <compute_allele_freq+0x663>
mov    (%rsp),%rax
lea    0x1(%rax),%ecx
lea    0x1(%r12),%edx
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rax,0x108(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x100(%rsp)
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0xf8(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rsi
mov    %rsi,0xf0(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x68(%rsp)
xor    %edi,%edi
pxor   %xmm0,%xmm0
mov    %rdx,0x60(%rsp)
jmp    15cd <compute_allele_freq+0x45d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rdx,%rdi
je     17d3 <compute_allele_freq+0x663>
cmpl   $0x0,(%rsp)
js     15c0 <compute_allele_freq+0x450>
mov    0x70(%rsp),%rax
mov    (%rax,%rdi,8),%rsi
mov    0x40(%rsp),%rax
mov    (%rax,%rdi,8),%rbx
mov    (%r9,%rdi,8),%r8
cmp    $0x8,%ecx
jae    1600 <compute_allele_freq+0x490>
xor    %ebp,%ebp
jmp    1740 <compute_allele_freq+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsi,%rcx,4),%rax
lea    (%rbx,%rcx,4),%rbp
lea    (%r8,%rcx,4),%rdx
cmp    %rbp,%rsi
setb   %r9b
cmp    %rax,%rbx
setb   %r10b
cmp    %rdx,%rsi
setb   %r11b
cmp    %rax,%r8
setb   0x30(%rsp)
cmp    %rdx,%rbx
setb   %al
cmp    %rbp,%r8
setb   %dl
test   %r10b,%r9b
jne    1727 <compute_allele_freq+0x5b7>
and    0x30(%rsp),%r11b
jne    1727 <compute_allele_freq+0x5b7>
mov    $0x0,%ebp
and    %dl,%al
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x60(%rsp),%rdx
jne    1740 <compute_allele_freq+0x5d0>
cmpq   $0x0,0x100(%rsp)
je     17bd <compute_allele_freq+0x64d>
mov    0xf0(%rsp),%rax
xor    %r9d,%r9d
nop
movdqu %xmm0,(%rsi,%r9,4)
movdqu %xmm0,0x10(%rsi,%r9,4)
movdqu %xmm0,(%rbx,%r9,4)
movdqu %xmm0,0x10(%rbx,%r9,4)
movdqu %xmm0,(%r8,%r9,4)
movdqu %xmm0,0x10(%r8,%r9,4)
movdqu %xmm0,0x20(%rsi,%r9,4)
movdqu %xmm0,0x30(%rsi,%r9,4)
movdqu %xmm0,0x20(%rbx,%r9,4)
movdqu %xmm0,0x30(%rbx,%r9,4)
movdqu %xmm0,0x20(%r8,%r9,4)
movdqu %xmm0,0x30(%r8,%r9,4)
add    $0x10,%r9
add    $0xfffffffffffffffe,%rax
jne    1680 <compute_allele_freq+0x510>
testb  $0x1,0xf8(%rsp)
01
je     170c <compute_allele_freq+0x59c>
movdqu %xmm0,(%rsi,%r9,4)
movdqu %xmm0,0x10(%rsi,%r9,4)
movdqu %xmm0,(%rbx,%r9,4)
movdqu %xmm0,0x10(%rbx,%r9,4)
movdqu %xmm0,(%r8,%r9,4)
movdqu %xmm0,0x10(%r8,%r9,4)
mov    0x108(%rsp),%rax
mov    %rax,%rbp
cmp    %rcx,%rax
mov    0x8(%rsp),%r9
je     15c0 <compute_allele_freq+0x450>
jmp    1740 <compute_allele_freq+0x5d0>
xor    %ebp,%ebp
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x60(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
test   $0x1,%cl
je     1765 <compute_allele_freq+0x5f5>
movl   $0x0,(%rsi,%rbp,4)
movl   $0x0,(%rbx,%rbp,4)
movl   $0x0,(%r8,%rbp,4)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x68(%rsp),%rbp
je     15c0 <compute_allele_freq+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,(%rsi,%rax,4)
movl   $0x0,(%rbx,%rax,4)
movl   $0x0,(%r8,%rax,4)
movl   $0x0,0x4(%rsi,%rax,4)
movl   $0x0,0x4(%rbx,%rax,4)
movl   $0x0,0x4(%r8,%rax,4)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1780 <compute_allele_freq+0x610>
jmp    15c0 <compute_allele_freq+0x450>
xor    %r9d,%r9d
testb  $0x1,0xf8(%rsp)
01
jne    16e5 <compute_allele_freq+0x575>
jmp    170c <compute_allele_freq+0x59c>
cmp    $0xffffffff,%r12d
mov    0x10(%rsp),%rcx
jge    27d6 <compute_allele_freq+0x1666>
test   %r12d,%r12d
js     1a11 <compute_allele_freq+0x8a1>
mov    (%rsp),%rax
lea    0x1(%rax),%ecx
lea    0x1(%r12),%edx
mov    %ecx,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rax
mov    %rax,0x30(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rax,%rsi
mov    %rsi,0x60(%rsp)
mov    %eax,%ebx
and    $0x3,%ebx
mov    %ecx,%r10d
and    $0x3,%r10d
mov    %rbx,0x68(%rsp)
shl    $0x5,%rbx
xor    %esi,%esi
pxor   %xmm0,%xmm0
jmp    185d <compute_allele_freq+0x6ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %rdx,%rsi
je     1a11 <compute_allele_freq+0x8a1>
cmpl   $0x0,(%rsp)
js     1850 <compute_allele_freq+0x6e0>
mov    (%r14,%rsi,8),%r8
mov    0x28(%rsp),%rax
mov    (%rax,%rsi,8),%r9
cmp    $0x8,%ecx
jb     188f <compute_allele_freq+0x71f>
lea    (%r9,%rcx,4),%rax
cmp    %rax,%r8
jae    1924 <compute_allele_freq+0x7b4>
lea    (%r8,%rcx,4),%rax
cmp    %rax,%r9
jae    1924 <compute_allele_freq+0x7b4>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %rcx,%rax
test   %r10,%r10
je     18ca <compute_allele_freq+0x75a>
mov    %r10,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%r8,%rbp,4)
movl   $0x0,(%r9,%rbp,4)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    18b0 <compute_allele_freq+0x740>
cmp    $0x3,%rax
jb     1850 <compute_allele_freq+0x6e0>
movl   $0x0,(%r8,%rbp,4)
movl   $0x0,(%r9,%rbp,4)
movl   $0x0,0x4(%r8,%rbp,4)
movl   $0x0,0x4(%r9,%rbp,4)
movl   $0x0,0x8(%r8,%rbp,4)
movl   $0x0,0x8(%r9,%rbp,4)
movl   $0x0,0xc(%r8,%rbp,4)
movl   $0x0,0xc(%r9,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    18d0 <compute_allele_freq+0x760>
jmp    1850 <compute_allele_freq+0x6e0>
cmpq   $0x18,0x30(%rsp)
jae    1933 <compute_allele_freq+0x7c3>
xor    %eax,%eax
jmp    19b8 <compute_allele_freq+0x848>
mov    0x60(%rsp),%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,(%r8,%rax,4)
movdqu %xmm0,0x10(%r8,%rax,4)
movdqu %xmm0,(%r9,%rax,4)
movdqu %xmm0,0x10(%r9,%rax,4)
movdqu %xmm0,0x20(%r8,%rax,4)
movdqu %xmm0,0x30(%r8,%rax,4)
movdqu %xmm0,0x20(%r9,%rax,4)
movdqu %xmm0,0x30(%r9,%rax,4)
movdqu %xmm0,0x40(%r8,%rax,4)
movdqu %xmm0,0x50(%r8,%rax,4)
movdqu %xmm0,0x40(%r9,%rax,4)
movdqu %xmm0,0x50(%r9,%rax,4)
movdqu %xmm0,0x60(%r8,%rax,4)
movdqu %xmm0,0x70(%r8,%rax,4)
movdqu %xmm0,0x60(%r9,%rax,4)
movdqu %xmm0,0x70(%r9,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rbp
jne    1940 <compute_allele_freq+0x7d0>
cmpq   $0x0,0x68(%rsp)
je     1a00 <compute_allele_freq+0x890>
lea    (%r9,%rax,4),%rbp
add    $0x10,%rbp
lea    (%r8,%rax,4),%rax
add    $0x10,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rax,%rdi,1)
movdqu %xmm0,(%rax,%rdi,1)
movdqu %xmm0,-0x10(%rbp,%rdi,1)
movdqu %xmm0,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    19e0 <compute_allele_freq+0x870>
mov    %r11,%rbp
cmp    %rcx,%r11
je     1850 <compute_allele_freq+0x6e0>
jmp    1891 <compute_allele_freq+0x721>
cmpl   $0x0,0x58(%rsp)
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x48(%rsp),%r8
mov    0x18(%rsp),%r10
jle    1f0d <compute_allele_freq+0xd9d>
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,0x30(%rsp)
mov    0x58(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x68(%rsp)
mov    $0x1,%esi
pxor   %xmm0,%xmm0
movss  0x25aa(%rip),%xmm1
movss  0x259e(%rip),%xmm2
movsd  0x259e(%rip),%xmm3
movsd  0x259e(%rip),%xmm4
jmp    1a8f <compute_allele_freq+0x91f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
cmp    0x68(%rsp),%rsi
je     1f0d <compute_allele_freq+0xd9d>
cmpl   $0x0,(%rsp)
jle    1a80 <compute_allele_freq+0x910>
mov    $0x1,%edi
jmp    1b24 <compute_allele_freq+0x9b4>
mov    (%r14),%rax
movss  (%rax,%rdi,4),%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,(%rax,%rdi,4)
mov    0x28(%rsp),%rcx
test   %r12d,%r12d
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x48(%rsp),%r8
mov    0x18(%rsp),%r10
je     1b04 <compute_allele_freq+0x994>
movslq 0x0(%r13,%rsi,4),%rcx
mov    (%r14,%rcx,8),%rax
movss  (%rax,%rdi,4),%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,(%rax,%rdi,4)
mov    0x28(%rsp),%rax
mov    (%rax),%rax
movss  (%rax,%rdi,4),%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,(%rax,%rdi,4)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
mov    (%rcx),%rax
movss  (%rax,%rdi,4),%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    0x30(%rsp),%rdi
je     1a80 <compute_allele_freq+0x910>
mov    (%r10,%rsi,4),%r10d
xorps  %xmm5,%xmm5
cvtsi2ss %r10d,%xmm5
test   %r10d,%r10d
jle    1c60 <compute_allele_freq+0xaf0>
mov    0x38(%rsp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rdi,8),%rcx
lea    -0x1(%r10),%rax
mov    %r10d,%ebx
and    $0x3,%ebx
cmp    $0x3,%rax
jae    1c80 <compute_allele_freq+0xb10>
xor    %edx,%edx
movaps %xmm5,%xmm6
test   %rbx,%rbx
je     1b90 <compute_allele_freq+0xa20>
lea    (%rcx,%rdx,4),%rcx
xor    %edx,%edx
movaps %xmm5,%xmm6
jmp    1b7c <compute_allele_freq+0xa0c>
nop
add    $0x1,%rdx
movaps %xmm6,%xmm5
cmp    %rdx,%rbx
je     1b90 <compute_allele_freq+0xa20>
cmpl   $0x0,(%rcx,%rdx,4)
addss  %xmm2,%xmm6
je     1b70 <compute_allele_freq+0xa00>
movaps %xmm5,%xmm6
jmp    1b70 <compute_allele_freq+0xa00>
nopl   0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm6
jne    1b9b <compute_allele_freq+0xa2b>
jnp    1d00 <compute_allele_freq+0xb90>
test   %r10d,%r10d
jle    1d66 <compute_allele_freq+0xbf6>
mov    0x38(%rsp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rdi,8),%rcx
movaps %xmm1,%xmm5
divss  %xmm6,%xmm5
xor    %edx,%edx
mov    0x18(%rsp),%r10
jmp    1be1 <compute_allele_freq+0xa71>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq (%r10,%rsi,4),%rax
cmp    %rax,%rdx
jge    1cf0 <compute_allele_freq+0xb80>
cmpl   $0x0,(%rcx,%rdx,4)
je     1bd0 <compute_allele_freq+0xa60>
mov    (%r9),%rax
addl   $0x1,(%rax,%rdi,4)
test   %r12d,%r12d
je     1c00 <compute_allele_freq+0xa90>
movslq 0x0(%r13,%rsi,4),%rax
mov    (%r9,%rax,8),%rax
addl   $0x1,(%rax,%rdi,4)
mov    (%r11),%rax
mov    (%rax,%rdi,8),%rax
movslq (%rcx,%rdx,4),%rbp
movss  (%rax,%rbp,4),%xmm7
addss  %xmm5,%xmm7
movss  %xmm7,(%rax,%rbp,4)
mov    (%r8),%rax
mov    (%rax,%rdi,8),%rax
addl   $0x1,(%rax,%rbp,4)
test   %r12d,%r12d
jle    1bd0 <compute_allele_freq+0xa60>
movslq 0x0(%r13,%rsi,4),%rax
mov    (%r11,%rax,8),%rbp
mov    0x0(%rbp,%rdi,8),%rbp
movslq (%rcx,%rdx,4),%rbx
movss  0x0(%rbp,%rbx,4),%xmm7
addss  %xmm5,%xmm7
movss  %xmm7,0x0(%rbp,%rbx,4)
mov    (%r8,%rax,8),%rax
mov    (%rax,%rdi,8),%rax
addl   $0x1,(%rax,%rbx,4)
jmp    1bd0 <compute_allele_freq+0xa60>
nopl   0x0(%rax)
test   %r10,%r10
mov    0x18(%rsp),%r10
jne    1d45 <compute_allele_freq+0xbd5>
jmp    1d08 <compute_allele_freq+0xb98>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
xor    %edx,%edx
jmp    1c9d <compute_allele_freq+0xb2d>
nopw   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    %rdx,%rbp
je     1b5c <compute_allele_freq+0x9ec>
cmpl   $0x0,(%rcx,%rdx,4)
je     1cc0 <compute_allele_freq+0xb50>
cmpl   $0x0,0x4(%rcx,%rdx,4)
je     1ccb <compute_allele_freq+0xb5b>
cmpl   $0x0,0x8(%rcx,%rdx,4)
je     1cd6 <compute_allele_freq+0xb66>
cmpl   $0x0,0xc(%rcx,%rdx,4)
jne    1c90 <compute_allele_freq+0xb20>
jmp    1ce1 <compute_allele_freq+0xb71>
nopw   0x0(%rax,%rax,1)
addss  %xmm2,%xmm5
cmpl   $0x0,0x4(%rcx,%rdx,4)
jne    1caa <compute_allele_freq+0xb3a>
addss  %xmm2,%xmm5
cmpl   $0x0,0x8(%rcx,%rdx,4)
jne    1cb1 <compute_allele_freq+0xb41>
addss  %xmm2,%xmm5
cmpl   $0x0,0xc(%rcx,%rdx,4)
jne    1c90 <compute_allele_freq+0xb20>
addss  %xmm2,%xmm5
jmp    1c90 <compute_allele_freq+0xb20>
nopw   0x0(%rax,%rax,1)
movaps %xmm6,%xmm5
ucomiss %xmm0,%xmm5
ja     1d4a <compute_allele_freq+0xbda>
jmp    1d80 <compute_allele_freq+0xc10>
nopl   (%rax)
movaps %xmm6,%xmm5
mov    0x18(%rsp),%r10
mov    (%r11),%rax
mov    (%rax,%rdi,8),%rax
movss  (%rax),%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,(%rax)
mov    0x40(%rsp),%rax
mov    (%rax),%rax
addl   $0x1,(%rax,%rdi,4)
test   %r12d,%r12d
jle    1d45 <compute_allele_freq+0xbd5>
movslq 0x0(%r13,%rsi,4),%rax
mov    (%r11,%rax,8),%rax
mov    (%rax,%rdi,8),%rax
movss  (%rax),%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,(%rax)
ucomiss %xmm0,%xmm5
jbe    1d80 <compute_allele_freq+0xc10>
xorps  %xmm6,%xmm6
cvtsi2ssl (%r10,%rsi,4),%xmm6
ucomiss %xmm5,%xmm6
jbe    1d80 <compute_allele_freq+0xc10>
mov    0x70(%rsp),%rax
mov    (%rax),%rax
addl   $0x1,(%rax,%rdi,4)
jmp    1d80 <compute_allele_freq+0xc10>
movaps %xmm6,%xmm5
mov    0x18(%rsp),%r10
ucomiss %xmm0,%xmm5
ja     1d4a <compute_allele_freq+0xbda>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r12d,%r12d
je     1dd0 <compute_allele_freq+0xc60>
ucomiss %xmm0,%xmm5
jne    1d9e <compute_allele_freq+0xc2e>
jp     1d9e <compute_allele_freq+0xc2e>
movslq 0x0(%r13,%rsi,4),%rax
mov    0x40(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
addl   $0x1,(%rax,%rdi,4)
ucomiss %xmm0,%xmm5
jbe    1dd0 <compute_allele_freq+0xc60>
xorps  %xmm6,%xmm6
cvtsi2ssl (%r10,%rsi,4),%xmm6
ucomiss %xmm5,%xmm6
jbe    1dd0 <compute_allele_freq+0xc60>
movslq 0x0(%r13,%rsi,4),%rax
mov    0x70(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
addl   $0x1,(%rax,%rdi,4)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
ucomiss %xmm1,%xmm5
jbe    1b15 <compute_allele_freq+0x9a5>
mov    (%r10,%rsi,4),%r10d
cmp    $0x2,%r10
jne    1e00 <compute_allele_freq+0xc90>
mov    0x38(%rsp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rdi,8),%rax
mov    (%rax),%ecx
cmp    0x4(%rax),%ecx
jne    1a9f <compute_allele_freq+0x92f>
jmp    1ed0 <compute_allele_freq+0xd60>
cmp    $0x2,%r10d
jl     1ed0 <compute_allele_freq+0xd60>
lea    -0x1(%r10),%r11d
mov    0x38(%rsp),%rax
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rdi,8),%rcx
movaps %xmm5,%xmm6
addss  %xmm2,%xmm6
mulss  %xmm5,%xmm6
cvtss2sd %xmm6,%xmm6
mulsd  %xmm3,%xmm6
movapd %xmm4,%xmm5
divsd  %xmm6,%xmm5
mov    %r10,%rdx
mov    %rcx,%rbx
xor    %ebp,%ebp
jmp    1e51 <compute_allele_freq+0xce1>
add    $0x4,%rbx
add    $0xffffffffffffffff,%rdx
cmp    %r11,%rbp
je     1ed0 <compute_allele_freq+0xd60>
mov    (%rcx,%rbp,4),%r8d
add    $0x1,%rbp
test   %r8d,%r8d
je     1e40 <compute_allele_freq+0xcd0>
cmp    %r10,%rbp
jae    1e40 <compute_allele_freq+0xcd0>
mov    $0x1,%r9d
jmp    1e79 <compute_allele_freq+0xd09>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    %r9,%rdx
je     1e40 <compute_allele_freq+0xcd0>
mov    (%rbx,%r9,4),%eax
test   %eax,%eax
je     1e70 <compute_allele_freq+0xd00>
cmp    %eax,%r8d
je     1e70 <compute_allele_freq+0xd00>
mov    (%r14),%rax
movss  (%rax,%rdi,4),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm5,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,(%rax,%rdi,4)
test   %r12d,%r12d
je     1e70 <compute_allele_freq+0xd00>
movslq 0x0(%r13,%rsi,4),%rax
mov    (%r14,%rax,8),%rax
movss  (%rax,%rdi,4),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm5,%xmm6
cvtsd2ss %xmm6,%xmm6
movss  %xmm6,(%rax,%rdi,4)
jmp    1e70 <compute_allele_freq+0xd00>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%rax
mov    (%rax),%rax
movss  (%rax,%rdi,4),%xmm5
addss  %xmm1,%xmm5
movss  %xmm5,(%rax,%rdi,4)
test   %r12d,%r12d
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x48(%rsp),%r8
mov    0x18(%rsp),%r10
je     1b15 <compute_allele_freq+0x9a5>
movslq 0x0(%r13,%rsi,4),%rcx
jmp    1afb <compute_allele_freq+0x98b>
cmpl   $0x0,(%rsp)
mov    0xb0(%rsp),%rdx
mov    0x50(%rsp),%r13
jle    1f9d <compute_allele_freq+0xe2d>
lea    0x1(%r12),%ecx
mov    (%rsp),%rax
lea    0x1(%rax),%r8d
mov    $0x1,%esi
jmp    1f49 <compute_allele_freq+0xdd9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
cmp    %r8,%rsi
je     1f9d <compute_allele_freq+0xe2d>
mov    0x10(%rsp),%rax
mov    (%rax,%rsi,4),%edi
test   %edi,%edi
jle    1f40 <compute_allele_freq+0xdd0>
add    $0x1,%rdi
mov    $0x1,%eax
jmp    1f69 <compute_allele_freq+0xdf9>
add    $0x1,%rax
cmp    %rdi,%rax
je     1f40 <compute_allele_freq+0xdd0>
test   %r12d,%r12d
js     1f60 <compute_allele_freq+0xdf0>
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
cvtsi2ssl (%rdx,%rbp,4),%xmm0
mov    (%r11,%rbp,8),%rbx
mov    (%rbx,%rsi,8),%rbx
subss  (%rbx),%xmm0
movss  (%rbx,%rax,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1f70 <compute_allele_freq+0xe00>
jmp    1f60 <compute_allele_freq+0xdf0>
test   %r12d,%r12d
js     2083 <compute_allele_freq+0xf13>
mov    (%rsp),%rax
lea    0x1(%rax),%ecx
lea    0x1(%r12),%edx
xor    %esi,%esi
mov    0x402d(%rip),%rdi
pxor   %xmm0,%xmm0
movss  0x203d(%rip),%xmm1
jmp    1fe9 <compute_allele_freq+0xe79>
nopl   0x0(%rax)
movss  (%rdi),%xmm2
mov    (%r14,%rsi,8),%rax
movss  %xmm2,(%rax)
add    $0x1,%rsi
cmp    %rdx,%rsi
je     2083 <compute_allele_freq+0xf13>
mov    0x28(%rsp),%rax
mov    (%rax,%rsi,8),%rbp
movl   $0x0,0x0(%rbp)
cmpl   $0x0,(%rsp)
jle    1fd0 <compute_allele_freq+0xe60>
mov    $0x1,%eax
jmp    2026 <compute_allele_freq+0xeb6>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdi),%xmm2
mov    (%r14,%rsi,8),%rbx
movss  %xmm2,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
je     2060 <compute_allele_freq+0xef0>
movss  0x0(%rbp,%rax,4),%xmm2
ucomiss %xmm0,%xmm2
jbe    2010 <compute_allele_freq+0xea0>
mov    (%r14,%rsi,8),%rbx
movss  (%rbx,%rax,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rbx,%rax,4)
addss  (%rbx),%xmm3
movss  %xmm3,(%rbx)
movss  0x0(%rbp),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x0(%rbp)
jmp    201d <compute_allele_freq+0xead>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp),%xmm2
ucomiss %xmm0,%xmm2
jbe    1fd0 <compute_allele_freq+0xe60>
mov    (%r14,%rsi,8),%rax
movss  (%rax),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rax)
jmp    1fdc <compute_allele_freq+0xe6c>
cmpl   $0x0,(%rsp)
mov    0x78(%rsp),%r14
jle    2144 <compute_allele_freq+0xfd4>
lea    0x1(%r12),%eax
mov    (%rsp),%rcx
add    $0x1,%ecx
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    $0x1,%esi
jmp    20bd <compute_allele_freq+0xf4d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %rcx,%rsi
je     2144 <compute_allele_freq+0xfd4>
test   %r12d,%r12d
js     20b0 <compute_allele_freq+0xf40>
je     2120 <compute_allele_freq+0xfb0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%r9,%rdi,8),%rbp
xorps  %xmm0,%xmm0
cvtsi2ssl 0x0(%rbp,%rsi,4),%xmm0
mov    (%r11,%rdi,8),%rbp
mov    0x0(%rbp,%rsi,8),%rbp
movss  %xmm0,0x0(%rbp)
mov    0x8(%r9,%rdi,8),%rbp
xorps  %xmm0,%xmm0
cvtsi2ssl 0x0(%rbp,%rsi,4),%xmm0
mov    0x8(%r11,%rdi,8),%rbp
mov    0x0(%rbp,%rsi,8),%rbp
movss  %xmm0,0x0(%rbp)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    20d0 <compute_allele_freq+0xf60>
test   $0x1,%al
je     20b0 <compute_allele_freq+0xf40>
jmp    2126 <compute_allele_freq+0xfb6>
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
test   $0x1,%al
je     20b0 <compute_allele_freq+0xf40>
mov    (%r9,%rdi,8),%rbp
xorps  %xmm0,%xmm0
cvtsi2ssl 0x0(%rbp,%rsi,4),%xmm0
mov    (%r11,%rdi,8),%rdi
mov    (%rdi,%rsi,8),%rdi
movss  %xmm0,(%rdi)
jmp    20b0 <compute_allele_freq+0xf40>
test   %r12d,%r12d
js     224c <compute_allele_freq+0x10dc>
mov    (%rsp),%rax
lea    0x1(%rax),%r8d
lea    0x1(%r12),%ecx
lea    -0x1(%r8),%rdx
add    $0xfffffffffffffffe,%r8
mov    %edx,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
jmp    217d <compute_allele_freq+0x100d>
nop
add    $0x1,%rdi
cmp    %rcx,%rdi
je     224c <compute_allele_freq+0x10dc>
mov    (%r9,%rdi,8),%rbp
movl   $0x2,0x0(%rbp)
cmpl   $0x0,(%rsp)
jle    2170 <compute_allele_freq+0x1000>
mov    $0x1,%ebx
cmp    $0x3,%r8
jb     2214 <compute_allele_freq+0x10a4>
xor    %ebx,%ebx
jmp    21a9 <compute_allele_freq+0x1039>
nopl   (%rax)
add    $0x4,%rbx
cmp    %rbx,%rdx
je     2210 <compute_allele_freq+0x10a0>
cmpl   $0x1,0x4(%rbp,%rbx,4)
jg     21e0 <compute_allele_freq+0x1070>
movl   $0x0,0x0(%rbp)
cmpl   $0x1,0x8(%rbp,%rbx,4)
jle    21e7 <compute_allele_freq+0x1077>
cmpl   $0x1,0xc(%rbp,%rbx,4)
jg     21f5 <compute_allele_freq+0x1085>
movl   $0x0,0x0(%rbp)
cmpl   $0x1,0x10(%rbp,%rbx,4)
jg     21a0 <compute_allele_freq+0x1030>
jmp    21fc <compute_allele_freq+0x108c>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x1,0x8(%rbp,%rbx,4)
jg     21be <compute_allele_freq+0x104e>
movl   $0x0,0x0(%rbp)
cmpl   $0x1,0xc(%rbp,%rbx,4)
jle    21c5 <compute_allele_freq+0x1055>
cmpl   $0x1,0x10(%rbp,%rbx,4)
jg     21a0 <compute_allele_freq+0x1030>
movl   $0x0,0x0(%rbp)
jmp    21a0 <compute_allele_freq+0x1030>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
test   %rsi,%rsi
je     2170 <compute_allele_freq+0x1000>
lea    0x0(,%rbx,4),%rbx
add    %rbp,%rbx
xor    %eax,%eax
jmp    223d <compute_allele_freq+0x10cd>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%rsi
je     2170 <compute_allele_freq+0x1000>
cmpl   $0x1,(%rbx,%rax,4)
jg     2230 <compute_allele_freq+0x10c0>
movl   $0x0,0x0(%rbp)
jmp    2230 <compute_allele_freq+0x10c0>
cmpl   $0x0,(%rsp)
jle    2586 <compute_allele_freq+0x1416>
lea    0x1(%r12),%r9d
mov    (%rsp),%rax
lea    0x1(%rax),%r8d
mov    $0x1,%r10d
movss  0x1d93(%rip),%xmm0
jmp    228d <compute_allele_freq+0x111d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
cmp    %r8,%r10
je     2586 <compute_allele_freq+0x1416>
pxor   %xmm1,%xmm1
test   %r12d,%r12d
jle    24c0 <compute_allele_freq+0x1350>
mov    $0x1,%esi
jmp    22c2 <compute_allele_freq+0x1152>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x78(%rsp),%r14
add    $0x1,%rsi
cmp    %r9,%rsi
je     24c0 <compute_allele_freq+0x1350>
mov    0x8(%rsp),%rax
mov    (%rax,%rsi,8),%rax
cmpl   $0x0,(%rax,%r10,4)
je     22b5 <compute_allele_freq+0x1145>
addss  %xmm0,%xmm1
mov    0x10(%rsp),%rax
mov    (%rax,%r10,4),%r14d
test   %r14d,%r14d
jle    22b0 <compute_allele_freq+0x1140>
mov    (%r11,%rsi,8),%rax
mov    (%rax,%r10,8),%rdi
mov    -0x8(%r11),%rax
mov    (%rax,%r10,8),%rbp
lea    0x1(%r14),%rbx
mov    $0x1,%ecx
cmp    $0x8,%r14
jb     2400 <compute_allele_freq+0x1290>
lea    0x4(%rbp),%rax
lea    (%rdi,%rbx,4),%rdx
cmp    %rdx,%rax
jae    232c <compute_allele_freq+0x11bc>
lea    0x0(,%rbx,4),%rax
add    %rbp,%rax
lea    0x4(%rdi),%rdx
cmp    %rax,%rdx
jb     2400 <compute_allele_freq+0x1290>
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     24a5 <compute_allele_freq+0x1335>
mov    %r11,%rax
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x4(%rdi,%rdx,4),%xmm2
movups 0x14(%rdi,%rdx,4),%xmm3
movups 0x4(%rbp,%rdx,4),%xmm4
addps  %xmm2,%xmm4
movups 0x14(%rbp,%rdx,4),%xmm2
addps  %xmm3,%xmm2
movups 0x24(%rbp,%rdx,4),%xmm3
movups 0x34(%rbp,%rdx,4),%xmm5
movups %xmm4,0x4(%rbp,%rdx,4)
movups %xmm2,0x14(%rbp,%rdx,4)
movups 0x24(%rdi,%rdx,4),%xmm2
addps  %xmm3,%xmm2
movups 0x34(%rdi,%rdx,4),%xmm3
addps  %xmm5,%xmm3
movups %xmm2,0x24(%rbp,%rdx,4)
movups %xmm3,0x34(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    2360 <compute_allele_freq+0x11f0>
test   $0x1,%r11b
je     23e3 <compute_allele_freq+0x1273>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rdi,%rdx,1),%xmm2
movups 0x10(%rdi,%rdx,1),%xmm3
movups 0x0(%rbp,%rdx,1),%xmm4
addps  %xmm2,%xmm4
movups 0x10(%rbp,%rdx,1),%xmm2
addps  %xmm3,%xmm2
movups %xmm4,0x0(%rbp,%rdx,1)
movups %xmm2,0x10(%rbp,%rdx,1)
cmp    %rcx,%r14
mov    0x20(%rsp),%r11
je     22b0 <compute_allele_freq+0x1140>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%edx
sub    %ecx,%edx
mov    %rcx,%rax
not    %rax
add    %rbx,%rax
and    $0x3,%rdx
mov    0x78(%rsp),%r14
je     243b <compute_allele_freq+0x12cb>
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm2
addss  0x0(%rbp,%rcx,4),%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    2420 <compute_allele_freq+0x12b0>
cmp    $0x3,%rax
jb     22b5 <compute_allele_freq+0x1145>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdi,%rcx,4),%xmm2
addss  0x0(%rbp,%rcx,4),%xmm2
movss  %xmm2,0x0(%rbp,%rcx,4)
movss  0x4(%rdi,%rcx,4),%xmm2
addss  0x4(%rbp,%rcx,4),%xmm2
movss  %xmm2,0x4(%rbp,%rcx,4)
movss  0x8(%rdi,%rcx,4),%xmm2
addss  0x8(%rbp,%rcx,4),%xmm2
movss  %xmm2,0x8(%rbp,%rcx,4)
movss  0xc(%rdi,%rcx,4),%xmm2
addss  0xc(%rbp,%rcx,4),%xmm2
movss  %xmm2,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    2450 <compute_allele_freq+0x12e0>
jmp    22b5 <compute_allele_freq+0x1145>
xor    %edx,%edx
test   $0x1,%r11b
jne    23b8 <compute_allele_freq+0x1248>
jmp    23e3 <compute_allele_freq+0x1273>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    (%rax,%r10,4),%eax
test   %eax,%eax
jle    2280 <compute_allele_freq+0x1110>
mov    -0x8(%r11),%rcx
mov    (%rcx,%r10,8),%rcx
mov    $0x1,%esi
cmp    $0x4,%rax
jb     255a <compute_allele_freq+0x13ea>
mov    %eax,%esi
and    $0xfffffffc,%esi
movaps %xmm1,%xmm2
shufps $0x0,%xmm1,%xmm2
lea    -0x4(%rsi),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     257c <compute_allele_freq+0x140c>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
nopl   (%rax)
movups 0x4(%rcx,%rdi,4),%xmm3
movups 0x14(%rcx,%rdi,4),%xmm4
divps  %xmm2,%xmm3
movups %xmm3,0x4(%rcx,%rdi,4)
divps  %xmm2,%xmm4
movups %xmm4,0x14(%rcx,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    2510 <compute_allele_freq+0x13a0>
test   $0x1,%bpl
je     254d <compute_allele_freq+0x13dd>
shl    $0x2,%rdi
or     $0x4,%rdi
movups (%rcx,%rdi,1),%xmm3
divps  %xmm2,%xmm3
movups %xmm3,(%rcx,%rdi,1)
cmp    %rsi,%rax
je     2280 <compute_allele_freq+0x1110>
or     $0x1,%rsi
add    $0x1,%rax
xchg   %ax,%ax
movss  (%rcx,%rsi,4),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    2560 <compute_allele_freq+0x13f0>
jmp    2280 <compute_allele_freq+0x1110>
xor    %edi,%edi
test   $0x1,%bpl
jne    253a <compute_allele_freq+0x13ca>
jmp    254d <compute_allele_freq+0x13dd>
cmpl   $0x0,(%rsp)
js     2639 <compute_allele_freq+0x14c9>
lea    0x1(%r14),%rax
mov    (%rsp),%rcx
add    $0x1,%ecx
mov    %eax,%edx
and    $0x3,%edx
and    $0xfffffffc,%eax
xor    %esi,%esi
jmp    25bd <compute_allele_freq+0x144d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %rcx,%rsi
je     2639 <compute_allele_freq+0x14c9>
test   %r12d,%r12d
js     25b0 <compute_allele_freq+0x1440>
xor    %edi,%edi
cmp    $0x3,%r14d
jb     260d <compute_allele_freq+0x149d>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rdi,8),%rbp
movl   $0x0,0x0(%rbp,%rsi,4)
mov    0x8(%r13,%rdi,8),%rbp
movl   $0x0,0x0(%rbp,%rsi,4)
mov    0x10(%r13,%rdi,8),%rbp
movl   $0x0,0x0(%rbp,%rsi,4)
mov    0x18(%r13,%rdi,8),%rbp
movl   $0x0,0x0(%rbp,%rsi,4)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    25d0 <compute_allele_freq+0x1460>
test   %rdx,%rdx
je     25b0 <compute_allele_freq+0x1440>
lea    0x0(,%rdi,8),%rdi
add    %r13,%rdi
xor    %ebp,%ebp
nop
mov    (%rdi,%rbp,8),%rbx
movl   $0x0,(%rbx,%rsi,4)
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    2620 <compute_allele_freq+0x14b0>
jmp    25b0 <compute_allele_freq+0x1440>
mov    (%rsp),%rcx
test   %ecx,%ecx
jle    285f <compute_allele_freq+0x16ef>
lea    0x1(%r14),%rax
lea    0x1(%rcx),%r8d
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    $0x1,%esi
pxor   %xmm0,%xmm0
mov    0x8(%rsp),%r9
jmp    267d <compute_allele_freq+0x150d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %r8,%rsi
je     2726 <compute_allele_freq+0x15b6>
mov    0x10(%rsp),%rcx
mov    (%rcx,%rsi,4),%ebp
test   %ebp,%ebp
jle    2670 <compute_allele_freq+0x1500>
mov    $0x1,%edi
jmp    26a7 <compute_allele_freq+0x1537>
mov    0x10(%rsp),%rcx
mov    (%rcx,%rsi,4),%ebp
lea    0x1(%rdi),%rbx
movslq %ebp,%rcx
cmp    %rcx,%rdi
mov    %rbx,%rdi
jge    2670 <compute_allele_freq+0x1500>
test   %r12d,%r12d
js     2698 <compute_allele_freq+0x1528>
xor    %ebp,%ebp
test   %r14,%r14
jne    26e9 <compute_allele_freq+0x1579>
test   $0x1,%al
je     2690 <compute_allele_freq+0x1520>
mov    (%r11,%rbp,8),%rbx
mov    (%rbx,%rsi,8),%rbx
movss  (%rbx,%rdi,4),%xmm1
ucomiss %xmm0,%xmm1
jne    26cb <compute_allele_freq+0x155b>
jnp    2690 <compute_allele_freq+0x1520>
mov    0x0(%r13,%rbp,8),%rbp
addl   $0x1,0x0(%rbp,%rsi,4)
jmp    2690 <compute_allele_freq+0x1520>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rbp
cmp    %rbp,%rdx
je     26b3 <compute_allele_freq+0x1543>
mov    (%r11,%rbp,8),%rbx
mov    (%rbx,%rsi,8),%rbx
movss  (%rbx,%rdi,4),%xmm1
ucomiss %xmm0,%xmm1
jne    26fd <compute_allele_freq+0x158d>
jnp    2706 <compute_allele_freq+0x1596>
mov    0x0(%r13,%rbp,8),%rbx
addl   $0x1,(%rbx,%rsi,4)
mov    0x8(%r11,%rbp,8),%rbx
mov    (%rbx,%rsi,8),%rbx
movss  (%rbx,%rdi,4),%xmm1
ucomiss %xmm0,%xmm1
jne    271b <compute_allele_freq+0x15ab>
jnp    26e0 <compute_allele_freq+0x1570>
mov    0x8(%r13,%rbp,8),%rbx
addl   $0x1,(%rbx,%rsi,4)
jmp    26e0 <compute_allele_freq+0x1570>
mov    0xd0(%rsp),%r10
mov    (%r10),%esi
test   %esi,%esi
jne    287b <compute_allele_freq+0x170b>
mov    0x84(%rsp),%esi
imul   0x58(%rsp),%esi
mov    %esi,(%r10)
cmpl   $0x0,(%rsp)
jle    287b <compute_allele_freq+0x170b>
mov    %eax,%edx
and    $0xfffffffe,%edx
mov    $0x1,%edi
jmp    276d <compute_allele_freq+0x15fd>
xchg   %ax,%ax
add    $0x1,%rdi
cmp    %r8,%rdi
je     287b <compute_allele_freq+0x170b>
test   %r12d,%r12d
js     2760 <compute_allele_freq+0x15f0>
xor    %ebp,%ebp
test   %r14,%r14
jne    27a9 <compute_allele_freq+0x1639>
test   $0x1,%al
je     2760 <compute_allele_freq+0x15f0>
mov    (%r9,%rbp,8),%rcx
mov    (%rcx,%rdi,4),%ebp
cmp    $0x2,%ebp
jl     2760 <compute_allele_freq+0x15f0>
cmp    %esi,%ebp
jge    2760 <compute_allele_freq+0x15f0>
mov    %ebp,(%r10)
mov    %ebp,%esi
jmp    2760 <compute_allele_freq+0x15f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rbp
cmp    %rbp,%rdx
je     2779 <compute_allele_freq+0x1609>
mov    (%r9,%rbp,8),%rcx
mov    (%rcx,%rdi,4),%ebx
cmp    $0x2,%ebx
jl     27be <compute_allele_freq+0x164e>
cmp    %esi,%ebx
jge    27be <compute_allele_freq+0x164e>
mov    %ebx,(%r10)
mov    %ebx,%esi
mov    0x8(%r9,%rbp,8),%rcx
mov    (%rcx,%rdi,4),%ebx
cmp    $0x2,%ebx
jl     27a0 <compute_allele_freq+0x1630>
cmp    %esi,%ebx
jge    27a0 <compute_allele_freq+0x1630>
mov    %ebx,(%r10)
mov    %ebx,%esi
jmp    27a0 <compute_allele_freq+0x1630>
mov    (%rsp),%rax
lea    0x1(%rax),%r9d
lea    0x1(%r12),%r8d
mov    $0xffffffffffffffff,%rsi
jmp    27fd <compute_allele_freq+0x168d>
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %r8,%rsi
je     17e2 <compute_allele_freq+0x672>
cmpl   $0x0,(%rsp)
js     27f0 <compute_allele_freq+0x1680>
xor    %eax,%eax
jmp    2819 <compute_allele_freq+0x16a9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r9,%rax
je     27f0 <compute_allele_freq+0x1680>
cmpl   $0x0,(%rcx,%rax,4)
js     2810 <compute_allele_freq+0x16a0>
mov    0x48(%rsp),%rdx
mov    (%rdx,%rsi,8),%rdi
mov    (%rdi,%rax,8),%rdi
mov    (%r10,%rsi,8),%rbp
mov    0x0(%rbp,%rax,8),%rbp
mov    $0xffffffffffffffff,%rbx
nopl   0x0(%rax)
movl   $0x0,0x4(%rdi,%rbx,4)
movl   $0x0,0x4(%rbp,%rbx,4)
movslq (%rcx,%rax,4),%rdx
add    $0x1,%rbx
cmp    %rdx,%rbx
jl     2840 <compute_allele_freq+0x16d0>
jmp    2810 <compute_allele_freq+0x16a0>
mov    0xd0(%rsp),%rax
mov    (%rax),%esi
test   %esi,%esi
jne    287b <compute_allele_freq+0x170b>
mov    0x84(%rsp),%esi
imul   0x58(%rsp),%esi
mov    %esi,(%rax)
test   %r12d,%r12d
js     2dbd <compute_allele_freq+0x1c4d>
mov    (%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
lea    0x1(%rax),%ebp
lea    0x1(%r12),%edx
mov    %esi,%edi
and    $0xfffffffe,%edi
xor    %ecx,%ecx
movsd  0x176a(%rip),%xmm1
mov    0x8(%rsp),%r8
mov    0x10(%rsp),%rbx
mov    0x48(%rsp),%r9
mov    %rbp,0x30(%rsp)
mov    %rdx,0x40(%rsp)
jmp    28e2 <compute_allele_freq+0x1772>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
mov    0x40(%rsp),%rdx
cmp    %rdx,%rcx
je     2acd <compute_allele_freq+0x195d>
mov    0xb8(%rsp),%rax
mov    (%rax,%rcx,8),%rax
movl   $0x0,(%rax)
cmpl   $0x0,(%rsp)
jle    28d0 <compute_allele_freq+0x1760>
mov    (%r8,%rcx,8),%rdx
mov    %rdx,0x38(%rsp)
mov    $0x1,%edx
pxor   %xmm2,%xmm2
mov    %rcx,0x28(%rsp)
mov    %rax,0x18(%rsp)
jmp    295c <compute_allele_freq+0x17ec>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
movss  %xmm3,(%rax,%rdx,4)
mov    0x8(%rsp),%r8
mov    0x10(%rsp),%rbx
mov    0x48(%rsp),%r9
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%rcx
divss  %xmm0,%xmm3
addss  %xmm3,%xmm2
movss  %xmm2,(%rax)
add    $0x1,%rdx
cmp    %rbp,%rdx
je     28d0 <compute_allele_freq+0x1760>
mov    0x38(%rsp),%rax
mov    (%rax,%rdx,4),%r13d
cmp    %esi,%r13d
jle    2a80 <compute_allele_freq+0x1910>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax,%rdx,4)
mov    (%rbx,%rdx,4),%ebp
test   %ebp,%ebp
jle    2aba <compute_allele_freq+0x194a>
mov    (%r9,%rcx,8),%rcx
mov    (%rcx,%rdx,8),%rax
add    $0x1,%rbp
pxor   %xmm3,%xmm3
mov    $0x1,%ecx
jmp    29c0 <compute_allele_freq+0x1850>
nopl   0x0(%rax)
movapd %xmm1,%xmm5
subsd  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtsd2ss %xmm5,%xmm4
addss  %xmm4,%xmm3
add    $0x1,%rcx
cmp    %rbp,%rcx
je     2920 <compute_allele_freq+0x17b0>
movapd %xmm1,%xmm4
test   %esi,%esi
jle    29a0 <compute_allele_freq+0x1830>
xor    %r8d,%r8d
mov    (%rax,%rcx,4),%r9d
movapd %xmm1,%xmm4
cmp    $0x1,%esi
je     2a38 <compute_allele_freq+0x18c8>
mov    %r13d,%r10d
sub    %r9d,%r10d
xor    %r8d,%r8d
mov    %r13d,%r11d
movapd %xmm1,%xmm4
nopl   0x0(%rax,%rax,1)
xorps  %xmm5,%xmm5
cvtsi2sd %r10d,%xmm5
xorps  %xmm6,%xmm6
cvtsi2sd %r11d,%xmm6
divsd  %xmm6,%xmm5
mulsd  %xmm4,%xmm5
lea    -0x1(%r10),%r14d
xorps  %xmm4,%xmm4
cvtsi2sd %r14d,%xmm4
lea    -0x1(%r11),%ebx
xorps  %xmm6,%xmm6
cvtsi2sd %ebx,%xmm6
divsd  %xmm6,%xmm4
mulsd  %xmm5,%xmm4
add    $0x2,%r8d
add    $0xfffffffe,%r10d
add    $0xfffffffe,%r11d
cmp    %r8d,%edi
jne    29f0 <compute_allele_freq+0x1880>
test   $0x1,%sil
je     29a0 <compute_allele_freq+0x1830>
add    %r8d,%r9d
mov    %rax,%rbx
mov    %r13d,%eax
sub    %r9d,%eax
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
mov    %r13d,%eax
sub    %r8d,%eax
xorps  %xmm6,%xmm6
cvtsi2sd %eax,%xmm6
mov    %rbx,%rax
divsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm4
jmp    29a0 <compute_allele_freq+0x1830>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
jne    2aa0 <compute_allele_freq+0x1930>
mov    0x50(%rsp),%rax
mov    (%rax,%rcx,8),%rax
xorps  %xmm3,%xmm3
cvtsi2ssl (%rax,%rdx,4),%xmm3
jmp    2aab <compute_allele_freq+0x193b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x3541(%rip),%rax
movss  (%rax),%xmm3
mov    0x18(%rsp),%rax
movss  %xmm3,(%rax,%rdx,4)
jmp    2943 <compute_allele_freq+0x17d3>
pxor   %xmm3,%xmm3
mov    0x30(%rsp),%rbp
mov    0x18(%rsp),%rax
jmp    2943 <compute_allele_freq+0x17d3>
test   %r12d,%r12d
mov    0xe8(%rsp),%r10
mov    0xe0(%rsp),%r13
js     2dbd <compute_allele_freq+0x1c4d>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    2af9 <compute_allele_freq+0x1989>
xor    %ecx,%ecx
jmp    2b60 <compute_allele_freq+0x19f0>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
xchg   %ax,%ax
mov    0x0(%r13,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    (%r10,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x8(%r13,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x8(%r10,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x10(%r13,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x10(%r10,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x18(%r13,%rcx,8),%rsi
movl   $0x0,(%rsi)
mov    0x18(%r10,%rcx,8),%rsi
movl   $0x0,(%rsi)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    2b00 <compute_allele_freq+0x1990>
test   %rax,%rax
je     2b9d <compute_allele_freq+0x1a2d>
lea    (%r10,%rcx,8),%rdx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    (%rcx,%rsi,8),%rdi
movl   $0x0,(%rdi)
mov    (%rdx,%rsi,8),%rdi
movl   $0x0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    2b80 <compute_allele_freq+0x1a10>
test   %r12d,%r12d
js     2dbd <compute_allele_freq+0x1c4d>
xor    %r14d,%r14d
movss  0x1452(%rip),%xmm10
movss  0x1445(%rip),%xmm8
movsd  0x1454(%rip),%xmm9
movsd  0x1444(%rip),%xmm3
movsd  0x144c(%rip),%xmm5
movsd  0x144c(%rip),%xmm6
jmp    2bef <compute_allele_freq+0x1a7f>
xchg   %ax,%ax
add    $0x1,%r14
cmp    0x40(%rsp),%r14
je     2dbd <compute_allele_freq+0x1c4d>
cmpl   $0x0,(%rsp)
jle    2be0 <compute_allele_freq+0x1a70>
mov    0x8(%rsp),%rax
mov    (%rax,%r14,8),%r11
mov    (%r10,%r14,8),%r8
mov    0x0(%r13,%r14,8),%r9
mov    $0x1,%ecx
jmp    2c5a <compute_allele_freq+0x1aea>
xchg   %ax,%ax
mov    0x33d1(%rip),%rax
movss  (%rax),%xmm7
movss  %xmm7,(%r9,%rcx,4)
mov    %r8,%rax
movss  %xmm7,(%rax,%rcx,4)
movss  (%r8,%rcx,4),%xmm1
divss  %xmm0,%xmm1
addss  (%r8),%xmm1
movss  %xmm1,(%r8)
movss  (%r9,%rcx,4),%xmm1
divss  %xmm0,%xmm1
addss  (%r9),%xmm1
movss  %xmm1,(%r9)
add    $0x1,%rcx
cmp    %rbp,%rcx
je     2be0 <compute_allele_freq+0x1a70>
mov    (%r11,%rcx,4),%edx
cmp    $0x2,%edx
jl     2c10 <compute_allele_freq+0x1aa0>
mov    0xd8(%rsp),%rax
mov    (%rax,%r14,8),%rax
movl   $0x0,(%rax,%rcx,4)
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,4),%edi
test   %edi,%edi
jle    2cb0 <compute_allele_freq+0x1b40>
mov    0x20(%rsp),%rsi
mov    (%rsi,%r14,8),%rsi
mov    (%rsi,%rcx,8),%rsi
lea    -0x1(%rdi),%rbx
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x3,%rbx
jae    2cb8 <compute_allele_freq+0x1b48>
mov    $0x1,%ebx
xorps  %xmm7,%xmm7
test   %rbp,%rbp
jne    2d1e <compute_allele_freq+0x1bae>
jmp    2d4b <compute_allele_freq+0x1bdb>
xorps  %xmm7,%xmm7
jmp    2d4b <compute_allele_freq+0x1bdb>
and    $0xfffffffc,%edi
xorps  %xmm7,%xmm7
xor    %ebx,%ebx
movss  0x4(%rsi,%rbx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,(%rax,%rcx,4)
movss  0x8(%rsi,%rbx,4),%xmm7
mulss  %xmm7,%xmm7
addss  %xmm2,%xmm7
movss  %xmm7,(%rax,%rcx,4)
movss  0xc(%rsi,%rbx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,(%rax,%rcx,4)
movss  0x10(%rsi,%rbx,4),%xmm7
mulss  %xmm7,%xmm7
addss  %xmm2,%xmm7
movss  %xmm7,(%rax,%rcx,4)
add    $0x4,%rbx
cmp    %rbx,%rdi
jne    2cc0 <compute_allele_freq+0x1b50>
add    $0x1,%rbx
test   %rbp,%rbp
je     2d4b <compute_allele_freq+0x1bdb>
lea    (%rsi,%rbx,4),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsi,%rdi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm7
movss  %xmm7,(%rax,%rcx,4)
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    2d30 <compute_allele_freq+0x1bc0>
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
movaps %xmm10,%xmm1
subss  %xmm7,%xmm1
movaps %xmm2,%xmm7
addss  %xmm8,%xmm7
divss  %xmm7,%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%r8,%rcx,4)
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm1,%xmm7
addsd  %xmm9,%xmm7
mulsd  %xmm1,%xmm7
cvtss2sd %xmm2,%xmm2
movapd %xmm3,%xmm4
subsd  %xmm2,%xmm4
movapd %xmm1,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm6,%xmm1
divsd  %xmm1,%xmm7
cvtsd2ss %xmm7,%xmm7
mov    %r9,%rax
mov    0x30(%rsp),%rbp
jmp    2c24 <compute_allele_freq+0x1ab4>
mov    %r12,0x50(%rsp)
cmpl   $0x0,(%rsp)
mov    0x8(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r8
mov    0xc0(%rsp),%r14
jle    3493 <compute_allele_freq+0x2323>
mov    (%r14),%rax
mov    %rax,0x30(%rsp)
mov    0xa8(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x38(%rsp)
mov    0xa0(%rsp),%rax
mov    (%rax),%rdx
mov    0x98(%rsp),%rax
mov    (%rax),%r12
mov    0x50(%rsp),%rax
lea    0x1(%rax),%esi
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,0xb8(%rsp)
mov    $0x1,%ebp
xorps  %xmm0,%xmm0
movsd  0x11e0(%rip),%xmm1
mov    %rsi,0x48(%rsp)
jmp    2e67 <compute_allele_freq+0x1cf7>
nop
mov    0x31a1(%rip),%rax
movss  (%rax),%xmm3
mov    0x30(%rsp),%rax
movss  %xmm3,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    0xb8(%rsp),%rbp
je     3493 <compute_allele_freq+0x2323>
cmpl   $0x0,0x50(%rsp)
jle    3140 <compute_allele_freq+0x1fd0>
mov    $0x1,%ebx
jmp    2ed4 <compute_allele_freq+0x1d64>
nopl   0x0(%rax)
mov    0x3161(%rip),%rax
movss  (%rax),%xmm2
mov    (%r14,%rbx,8),%rax
movss  %xmm2,(%rax,%rbp,4)
mov    0xa8(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm2,(%rax,%rbp,4)
mov    0xa0(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm2,(%rax,%rbp,4)
mov    0x98(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movss  %xmm2,(%rax,%rbp,4)
add    $0x1,%rbx
cmp    %rsi,%rbx
je     3140 <compute_allele_freq+0x1fd0>
mov    (%r9,%rbx,8),%rax
mov    (%rax,%rbp,4),%r13d
cmp    $0x2,%r13d
jl     2e80 <compute_allele_freq+0x1d10>
mov    (%r14,%rbx,8),%rax
mov    %rax,0x28(%rsp)
movl   $0x0,(%rax,%rbp,4)
mov    0xa8(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movl   $0x0,(%rax,%rbp,4)
mov    0xa0(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdi
movl   $0x0,(%rdi,%rbp,4)
mov    0x98(%rsp),%rcx
mov    (%rcx,%rbx,8),%r9
movl   $0x0,(%r9,%rbp,4)
mov    (%r8,%rbp,4),%r10d
test   %r10d,%r10d
jle    3094 <compute_allele_freq+0x1f24>
mov    %r13d,0x70(%rsp)
mov    %rbx,0x40(%rsp)
mov    (%r11,%rbx,8),%rcx
mov    (%rcx,%rbp,8),%r11
lea    0x1(%r10),%rcx
mov    %rcx,0x18(%rsp)
xor    %r13d,%r13d
pxor   %xmm2,%xmm2
mov    $0x1,%ebx
xor    %r8d,%r8d
mov    0x28(%rsp),%rsi
jmp    2f83 <compute_allele_freq+0x1e13>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r13
cmp    0x18(%rsp),%rbx
je     3070 <compute_allele_freq+0x1f00>
movss  (%r11,%rbx,4),%xmm3
ucomiss %xmm0,%xmm3
jne    2f90 <compute_allele_freq+0x1e20>
jnp    2f70 <compute_allele_freq+0x1e00>
xor    %r14d,%r14d
jmp    2fa9 <compute_allele_freq+0x1e39>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
cmp    %r14,%r10
je     2f70 <compute_allele_freq+0x1e00>
cmp    %r14,%r13
je     2fc7 <compute_allele_freq+0x1e57>
movss  (%r11,%rbx,4),%xmm3
mulss  0x4(%r11,%r14,4),%xmm3
addss  (%r9,%rbp,4),%xmm3
movss  %xmm3,(%r9,%rbp,4)
test   %r15d,%r15d
je     2fa0 <compute_allele_freq+0x1e30>
mov    0xc8(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    (%rcx,%rbx,8),%rcx
movss  0x4(%rcx,%r14,4),%xmm3
mulss  (%r11,%rbx,4),%xmm3
mulss  0x4(%r11,%r14,4),%xmm3
addss  (%rdi,%rbp,4),%xmm3
movss  %xmm3,(%rdi,%rbp,4)
cmp    %r14,%r13
je     2fa0 <compute_allele_freq+0x1e30>
movss  (%r11,%rbx,4),%xmm3
ucomiss %xmm0,%xmm3
jne    300c <compute_allele_freq+0x1e9c>
jnp    2fa0 <compute_allele_freq+0x1e30>
movss  0x4(%r11,%r14,4),%xmm3
ucomiss %xmm0,%xmm3
jne    301a <compute_allele_freq+0x1eaa>
jnp    2fa0 <compute_allele_freq+0x1e30>
movss  0x4(%rcx,%r14,4),%xmm3
addss  (%rax,%rbp,4),%xmm3
movss  %xmm3,(%rax,%rbp,4)
movss  0x4(%rcx,%r14,4),%xmm3
mulss  (%r11,%rbx,4),%xmm3
mulss  0x4(%r11,%r14,4),%xmm3
add    $0x1,%r8d
addss  (%rsi,%rbp,4),%xmm3
movss  %xmm3,(%rsi,%rbp,4)
movss  (%r11,%rbx,4),%xmm3
mulss  0x4(%r11,%r14,4),%xmm3
addss  %xmm3,%xmm2
jmp    2fa0 <compute_allele_freq+0x1e30>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   (%r9,%rbp,4),%xmm3
mov    0x20(%rsp),%r11
mov    0xc0(%rsp),%r14
mov    0x48(%rsp),%rsi
mov    0x40(%rsp),%rbx
mov    0x70(%rsp),%r13d
jmp    309f <compute_allele_freq+0x1f2f>
xor    %r8d,%r8d
pxor   %xmm3,%xmm3
pxor   %xmm2,%xmm2
xorps  %xmm4,%xmm4
cvtsi2sd %r13d,%xmm4
movapd %xmm4,%xmm5
addsd  %xmm1,%xmm5
divsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
mulss  %xmm4,%xmm3
movss  %xmm3,(%r9,%rbp,4)
mulss  (%rdi,%rbp,4),%xmm4
movss  %xmm4,(%rdi,%rbp,4)
test   %r8d,%r8d
je     30e3 <compute_allele_freq+0x1f73>
xorps  %xmm4,%xmm4
cvtsi2ss %r8d,%xmm4
movss  (%rax,%rbp,4),%xmm3
divss  %xmm4,%xmm3
jmp    30ee <compute_allele_freq+0x1f7e>
mov    0x2efe(%rip),%rcx
movss  (%rcx),%xmm3
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
movss  %xmm3,(%rax,%rbp,4)
ucomiss %xmm0,%xmm2
jne    3104 <compute_allele_freq+0x1f94>
jnp    311c <compute_allele_freq+0x1fac>
mov    0x28(%rsp),%rax
movss  (%rax,%rbp,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rax,%rbp,4)
jmp    2ec7 <compute_allele_freq+0x1d57>
mov    0x2ec5(%rip),%rax
movss  (%rax),%xmm2
mov    0x28(%rsp),%rax
jmp    2ec2 <compute_allele_freq+0x1d52>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rax
movl   $0x0,(%rax,%rbp,4)
mov    0x38(%rsp),%rax
movl   $0x0,(%rax,%rbp,4)
movl   $0x0,(%rdx,%rbp,4)
movl   $0x0,(%r12,%rbp,4)
cmpl   $0x2,0x50(%rsp)
jl     3310 <compute_allele_freq+0x21a0>
xor    %r11d,%r11d
mov    $0x2,%ecx
mov    $0x1,%eax
jmp    31a9 <compute_allele_freq+0x2039>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    0x40(%rsp),%rax
cmp    0x78(%rsp),%rax
je     32d0 <compute_allele_freq+0x2160>
mov    %rax,%rdi
add    $0x1,%rax
mov    %rax,0x40(%rsp)
mov    %rdi,0x18(%rsp)
mov    (%r9,%rdi,8),%rax
mov    (%rax,%rbp,4),%r14d
mov    %rcx,0x28(%rsp)
jmp    31e9 <compute_allele_freq+0x2079>
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
mov    0x48(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rsi,%rcx
je     3190 <compute_allele_freq+0x2020>
cmp    $0x2,%r14d
jl     31e0 <compute_allele_freq+0x2070>
mov    (%r9,%rcx,8),%rax
cmpl   $0x2,(%rax,%rbp,4)
jl     31e0 <compute_allele_freq+0x2070>
add    $0x1,%r11d
mov    (%r8,%rbp,4),%edi
test   %edi,%edi
jle    31e0 <compute_allele_freq+0x2070>
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%rsi
mov    (%rax,%rsi,8),%rax
mov    (%rax,%rbp,8),%rax
lea    0x1(%rdi),%r13
mov    $0x1,%ebx
xor    %r8d,%r8d
jmp    323d <compute_allele_freq+0x20cd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1,%r8
cmp    %r13,%rbx
je     31c9 <compute_allele_freq+0x2059>
movss  (%rax,%rbx,4),%xmm2
ucomiss %xmm0,%xmm2
jne    3249 <compute_allele_freq+0x20d9>
jnp    3230 <compute_allele_freq+0x20c0>
mov    0x20(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
mov    (%rsi,%rbp,8),%r9
xor    %r10d,%r10d
jmp    3269 <compute_allele_freq+0x20f9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r10,%rdi
je     3230 <compute_allele_freq+0x20c0>
movss  0x4(%r9,%r10,4),%xmm2
ucomiss %xmm0,%xmm2
jne    3277 <compute_allele_freq+0x2107>
jnp    3260 <compute_allele_freq+0x20f0>
cmp    %r10,%r8
je     328d <compute_allele_freq+0x211d>
mulss  (%rax,%rbx,4),%xmm2
addss  (%r12,%rbp,4),%xmm2
movss  %xmm2,(%r12,%rbp,4)
test   %r15d,%r15d
je     3260 <compute_allele_freq+0x20f0>
mov    0xc8(%rsp),%rsi
mov    (%rsi,%rbp,8),%rsi
mov    (%rsi,%rbx,8),%rsi
movss  0x4(%rsi,%r10,4),%xmm2
mulss  (%rax,%rbx,4),%xmm2
mulss  0x4(%r9,%r10,4),%xmm2
addss  (%rdx,%rbp,4),%xmm2
movss  %xmm2,(%rdx,%rbp,4)
jmp    3260 <compute_allele_freq+0x20f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r11d,%r11d
mov    0xc0(%rsp),%r14
je     3310 <compute_allele_freq+0x21a0>
xorps  %xmm2,%xmm2
cvtsi2ss %r11d,%xmm2
movss  (%r12,%rbp,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%r12,%rbp,4)
movss  (%rdx,%rbp,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rdx,%rbp,4)
jmp    3326 <compute_allele_freq+0x21b6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x2cd1(%rip),%rax
movss  (%rax),%xmm2
movss  %xmm2,(%rdx,%rbp,4)
movss  %xmm2,(%r12,%rbp,4)
xorps  %xmm2,%xmm2
test   %r15d,%r15d
je     3440 <compute_allele_freq+0x22d0>
mov    (%r8,%rbp,4),%r10d
test   %r10d,%r10d
mov    0x20(%rsp),%r11
jle    3460 <compute_allele_freq+0x22f0>
lea    0x1(%r10),%r8
xor    %r13d,%r13d
xorps  %xmm2,%xmm2
mov    $0x1,%ebx
xor    %r9d,%r9d
jmp    3371 <compute_allele_freq+0x2201>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r13
cmp    %r8,%rbx
je     3410 <compute_allele_freq+0x22a0>
xor    %ecx,%ecx
jmp    3389 <compute_allele_freq+0x2219>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
cmp    %rcx,%r10
je     3360 <compute_allele_freq+0x21f0>
cmp    %rcx,%r13
je     3380 <compute_allele_freq+0x2210>
mov    -0x8(%r11),%rax
mov    (%rax,%rbp,8),%rax
movss  (%rax,%rbx,4),%xmm3
ucomiss %xmm0,%xmm3
jne    33a2 <compute_allele_freq+0x2232>
jnp    3380 <compute_allele_freq+0x2210>
movss  0x4(%rax,%rcx,4),%xmm3
ucomiss %xmm0,%xmm3
jne    33af <compute_allele_freq+0x223f>
jnp    3380 <compute_allele_freq+0x2210>
mov    0xc8(%rsp),%rsi
mov    (%rsi,%rbp,8),%rsi
mov    (%rsi,%rbx,8),%rsi
movss  0x4(%rsi,%rcx,4),%xmm3
mov    0x38(%rsp),%rdi
addss  (%rdi,%rbp,4),%xmm3
movss  %xmm3,(%rdi,%rbp,4)
movss  0x4(%rsi,%rcx,4),%xmm3
mov    0x30(%rsp),%rsi
mulss  (%rax,%rbx,4),%xmm3
mulss  0x4(%rax,%rcx,4),%xmm3
add    $0x1,%r9d
addss  (%rsi,%rbp,4),%xmm3
movss  %xmm3,(%rsi,%rbp,4)
movss  (%rax,%rbx,4),%xmm3
mulss  0x4(%rax,%rcx,4),%xmm3
addss  %xmm3,%xmm2
jmp    3380 <compute_allele_freq+0x2210>
nopl   0x0(%rax)
test   %r9d,%r9d
mov    0x48(%rsp),%rsi
je     3447 <compute_allele_freq+0x22d7>
xorps  %xmm4,%xmm4
cvtsi2ss %r9d,%xmm4
mov    0x38(%rsp),%rax
movss  (%rax,%rbp,4),%xmm3
divss  %xmm4,%xmm3
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
jmp    346b <compute_allele_freq+0x22fb>
nopl   0x0(%rax)
mov    0x20(%rsp),%r11
jmp    3460 <compute_allele_freq+0x22f0>
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x2b81(%rip),%rax
movss  (%rax),%xmm3
mov    0x38(%rsp),%rax
movss  %xmm3,(%rax,%rbp,4)
ucomiss %xmm0,%xmm2
jne    3480 <compute_allele_freq+0x2310>
jnp    2e40 <compute_allele_freq+0x1cd0>
mov    0x30(%rsp),%rax
movss  (%rax,%rbp,4),%xmm3
divss  %xmm2,%xmm3
jmp    2e50 <compute_allele_freq+0x1ce0>
mov    0x50(%rsp),%r15
test   %r15d,%r15d
mov    (%rsp),%r8
js     365d <compute_allele_freq+0x24ed>
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
lea    0x1(%r8),%eax
lea    0x1(%r15),%r9d
lea    -0x8(,%rax,4),%rcx
ff
xor    %edx,%edx
jmp    34dd <compute_allele_freq+0x236d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r9,%rdx
je     358d <compute_allele_freq+0x241d>
mov    (%r14,%rdx,8),%rsi
movl   $0x0,(%rsi)
mov    0xa8(%rsp),%rax
mov    (%rax,%rdx,8),%rdi
movl   $0x0,(%rdi)
mov    0xa0(%rsp),%rax
mov    (%rax,%rdx,8),%rbp
movl   $0x0,0x0(%rbp)
mov    0x98(%rsp),%rax
mov    (%rax,%rdx,8),%rbx
movl   $0x0,(%rbx)
test   %r8d,%r8d
jle    34d0 <compute_allele_freq+0x2360>
pxor   %xmm1,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movss  0x4(%rbx,%rax,1),%xmm2
divss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rbx)
movss  0x4(%rbp,%rax,1),%xmm1
divss  %xmm0,%xmm1
addss  0x0(%rbp),%xmm1
movss  %xmm1,0x0(%rbp)
movss  0x4(%rdi,%rax,1),%xmm1
divss  %xmm0,%xmm1
addss  (%rdi),%xmm1
movss  %xmm1,(%rdi)
movss  0x4(%rsi,%rax,1),%xmm1
divss  %xmm0,%xmm1
addss  (%rsi),%xmm1
movss  %xmm1,(%rsi)
cmp    %rax,%rcx
je     34d0 <compute_allele_freq+0x2360>
movd   (%rbx),%xmm1
add    $0x4,%rax
jmp    3530 <compute_allele_freq+0x23c0>
test   %r15d,%r15d
js     365d <compute_allele_freq+0x24ed>
lea    -0x1(%r9),%rax
mov    %r9d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    35aa <compute_allele_freq+0x243a>
xor    %edx,%edx
jmp    361f <compute_allele_freq+0x24af>
and    $0xfffffffc,%r9d
xor    %edx,%edx
mov    0x88(%rsp),%rsi
mov    0x90(%rsp),%rdi
mov    (%rsi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    (%rdi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x8(%rsi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x8(%rdi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x10(%rsi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x10(%rdi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x18(%rsi,%rdx,8),%rax
movl   $0x0,(%rax)
mov    0x18(%rdi,%rdx,8),%rax
movl   $0x0,(%rax)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    35c0 <compute_allele_freq+0x2450>
test   %rcx,%rcx
je     365d <compute_allele_freq+0x24ed>
mov    0x90(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x88(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
xor    %esi,%esi
xchg   %ax,%ax
mov    (%rdx,%rsi,8),%rdi
movl   $0x0,(%rdi)
mov    (%rax,%rsi,8),%rdi
movl   $0x0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    3640 <compute_allele_freq+0x24d0>
test   %r8d,%r8d
mov    0x88(%rsp),%rsi
jle    3864 <compute_allele_freq+0x26f4>
xorps  %xmm0,%xmm0
cvtsi2ss %r8d,%xmm0
lea    0x1(%r15),%r10d
lea    0x1(%r8),%r12d
mov    $0x1,%edx
movsd  0x98d(%rip),%xmm1
mov    0x2956(%rip),%r9
jmp    36ad <compute_allele_freq+0x253d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %r12,%rdx
je     3864 <compute_allele_freq+0x26f4>
test   %r15d,%r15d
js     36a0 <compute_allele_freq+0x2530>
xor    %edi,%edi
jmp    3705 <compute_allele_freq+0x2595>
cs nopw 0x0(%rax,%rax,1)
movss  (%r9),%xmm2
mov    (%rsi,%rdi,8),%rcx
movss  %xmm2,(%rcx,%rdx,4)
mov    0x90(%rsp),%rax
mov    (%rax,%rdi,8),%rax
movss  %xmm2,(%rax,%rdx,4)
divss  %xmm0,%xmm2
addss  (%rax),%xmm2
movss  %xmm2,(%rax)
movss  (%rcx,%rdx,4),%xmm2
divss  %xmm0,%xmm2
addss  (%rcx),%xmm2
movss  %xmm2,(%rcx)
add    $0x1,%rdi
cmp    %r10,%rdi
je     36a0 <compute_allele_freq+0x2530>
mov    0x8(%rsp),%rax
mov    (%rax,%rdi,8),%rax
mov    (%rax,%rdx,4),%r14d
cmp    $0x2,%r14d
jl     36c0 <compute_allele_freq+0x2550>
mov    0x10(%rsp),%rax
mov    (%rax,%rdx,4),%r11d
test   %r11d,%r11d
jle    375d <compute_allele_freq+0x25ed>
mov    0x20(%rsp),%rax
mov    (%rax,%rdi,8),%rax
mov    (%rax,%rdx,8),%rcx
mov    0x110(%rsp),%rax
mov    (%rax,%rdx,8),%rsi
cmp    $0x1,%r11d
jne    3766 <compute_allele_freq+0x25f6>
pxor   %xmm3,%xmm3
mov    $0x1,%eax
test   $0x1,%r11b
jne    37e2 <compute_allele_freq+0x2672>
jmp    3803 <compute_allele_freq+0x2693>
pxor   %xmm2,%xmm2
jmp    3803 <compute_allele_freq+0x2693>
mov    %r11d,%ebx
and    $0xfffffffe,%ebx
neg    %rbx
pxor   %xmm3,%xmm3
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
xorps  %xmm4,%xmm4
cvtsi2ssl (%rsi,%rax,4),%xmm4
movss  (%rcx,%rax,4),%xmm2
movss  0x4(%rcx,%rax,4),%xmm5
movaps %xmm2,%xmm6
mulss  %xmm4,%xmm6
unpcklps %xmm6,%xmm2
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
xorps  %xmm2,%xmm2
cvtsi2ssl 0x4(%rsi,%rax,4),%xmm2
movaps %xmm5,%xmm3
mulss  %xmm2,%xmm3
unpcklps %xmm3,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm5,%xmm2
movaps %xmm2,%xmm3
addps  %xmm4,%xmm3
lea    (%rbx,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
cmp    $0x1,%rbp
jne    3780 <compute_allele_freq+0x2610>
addps  %xmm4,%xmm2
test   $0x1,%r11b
je     3803 <compute_allele_freq+0x2693>
movss  (%rcx,%rax,4),%xmm4
xorps  %xmm2,%xmm2
cvtsi2ssl (%rsi,%rax,4),%xmm2
movaps %xmm4,%xmm5
mulss  %xmm2,%xmm5
unpcklps %xmm5,%xmm4
shufps $0x0,%xmm2,%xmm2
mulps  %xmm4,%xmm2
addps  %xmm3,%xmm2
mov    0x90(%rsp),%rax
mov    (%rax,%rdi,8),%rax
movss  %xmm2,(%rax,%rdx,4)
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
mulss  %xmm2,%xmm2
subss  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
xorps  %xmm3,%xmm3
cvtsi2sd %r14d,%xmm3
movapd %xmm3,%xmm4
addsd  %xmm1,%xmm4
divsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
mov    0x88(%rsp),%rsi
mov    (%rsi,%rdi,8),%rcx
movss  %xmm2,(%rcx,%rdx,4)
movss  (%rax,%rdx,4),%xmm2
jmp    36df <compute_allele_freq+0x256f>
mov    0xd8(%rsp),%rdi
xor    %esi,%esi
mov    %r15d,%edx
xor    %ecx,%ecx
call   1030 <free_matrix@plt>
mov    0xb0(%rsp),%rdi
xor    %esi,%esi
mov    %r15d,%edx
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <free_ivector@plt>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    1437 <compute_allele_freq+0x2c7>
jmp    147a <compute_allele_freq+0x30a>

LLVM IR (-O0):
@HUGE_VAL = global float 0.000000e+00
define void @compute_allele_freq(i32 %0, i32 %1, i32* %2, i32 %3, i32 %4, i32 %5, i32*** %6, i32* %7, i32* %8, i32** %9, float*** %10, i32 %11, float*** %12, i32** %13, i32** %14, i32** %15, i32** %16, float** %17, float** %18, i32* %19, float** %20, float** %21, float** %22, float** %23, float** %24, float** %25, float** %26, float** %27) {
%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 i32*
%38 = alloca i32**
%39 = alloca float***
%40 = alloca i32
%41 = alloca float***
%42 = alloca i32**
%43 = alloca i32**
%44 = alloca i32**
%45 = alloca i32**
%46 = alloca float**
%47 = alloca float**
%48 = alloca i32*
%49 = alloca float**
%50 = alloca float**
%51 = alloca float**
%52 = alloca float**
%53 = alloca float**
%54 = alloca float**
%55 = alloca float**
%56 = alloca float**
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca i32
%61 = alloca i32
%62 = alloca i32
%63 = alloca i32
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca float
%68 = alloca float
%69 = alloca float**
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float**
%74 = alloca i32*
%75 = alloca i32***
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca double
store i32 %0, i32* %29
store i32 %1, i32* %30
store i32* %2, i32** %31
store i32 %3, i32* %32
store i32 %4, i32* %33
store i32 %5, i32* %34
store i32*** %6, i32**** %35
store i32* %7, i32** %36
store i32* %8, i32** %37
store i32** %9, i32*** %38
store float*** %10, float**** %39
store i32 %11, i32* %40
store float*** %12, float**** %41
store i32** %13, i32*** %42
store i32** %14, i32*** %43
store i32** %15, i32*** %44
store i32** %16, i32*** %45
store float** %17, float*** %46
store float** %18, float*** %47
store i32* %19, i32** %48
store float** %20, float*** %49
store float** %21, float*** %50
store float** %22, float*** %51
store float** %23, float*** %52
store float** %24, float*** %53
store float** %25, float*** %54
store float** %26, float*** %55
store float** %27, float*** %56
%80 = load i32, i32* %30
%81 = call i32* @ivector(i32 0, i32 %80)
store i32* %81, i32** %74
store i32 0, i32* %62
br label %82
82: ; preds = %91, %28
%83 = load i32, i32* %62
%84 = load i32, i32* %30
%85 = icmp sle i32 %83, %84
br i1 %85, label %86, label %94
86: ; preds = %82
%87 = load i32*, i32** %74
%88 = load i32, i32* %62
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
store i32 0, i32* %90
br label %91
91: ; preds = %86
%92 = load i32, i32* %62
%93 = add nsw i32 %92, 1
store i32 %93, i32* %62
br label %82
94: ; preds = %82
store i32 1, i32* %57
br label %95
95: ; preds = %129, %94
%96 = load i32, i32* %57
%97 = load i32, i32* %29
%98 = icmp sle i32 %96, %97
br i1 %98, label %99, label %132
99: ; preds = %95
%100 = load i32*, i32** %74
%101 = getelementptr inbounds i32, i32* %100, i64 0
%102 = load i32, i32* %101
%103 = add nsw i32 %102, 1
store i32 %103, i32* %101
%104 = load i32, i32* %30
%105 = icmp ne i32 %104, 0
br i1 %105, label %106, label %128
106: ; preds = %99
%107 = load i32*, i32** %31
%108 = load i32, i32* %57
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
%112 = load i32, i32* %30
%113 = icmp sle i32 %111, %112
br i1 %113, label %114, label %125
114: ; preds = %106
%115 = load i32*, i32** %74
%116 = load i32*, i32** %31
%117 = load i32, i32* %57
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %116, i64 %118
%120 = load i32, i32* %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %115, i64 %121
%123 = load i32, i32* %122
%124 = add nsw i32 %123, 1
store i32 %124, i32* %122
br label %127
125: ; preds = %106
%126 = call i32 @exit(i32 133)
unreachable
127: ; preds = %114
br label %128
128: ; preds = %127, %99
br label %129
129: ; preds = %128
%130 = load i32, i32* %57
%131 = add nsw i32 %130, 1
store i32 %131, i32* %57
br label %95
132: ; preds = %95
store i32 0, i32* %76
store i32 1, i32* %58
br label %133
133: ; preds = %152, %132
%134 = load i32, i32* %58
%135 = load i32, i32* %32
%136 = icmp sle i32 %134, %135
br i1 %136, label %137, label %155
137: ; preds = %133
%138 = load i32*, i32** %37
%139 = load i32, i32* %58
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %138, i64 %140
%142 = load i32, i32* %141
%143 = load i32, i32* %76
%144 = icmp sgt i32 %142, %143
br i1 %144, label %145, label %151
145: ; preds = %137
%146 = load i32*, i32** %37
%147 = load i32, i32* %58
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
%150 = load i32, i32* %149
store i32 %150, i32* %76
br label %151
151: ; preds = %145, %137
br label %152
152: ; preds = %151
%153 = load i32, i32* %58
%154 = add nsw i32 %153, 1
store i32 %154, i32* %58
br label %133
155: ; preds = %133
%156 = load i32, i32* %30
%157 = load i32, i32* %32
%158 = call float** @matrix(i32 0, i32 %156, i32 0, i32 %157)
store float** %158, float*** %73
%159 = load i32, i32* %30
%160 = load i32, i32* %32
%161 = load i32, i32* %76
%162 = call i32*** @i3tensor(i32 -1, i32 %159, i32 0, i32 %160, i32 0, i32 %161)
store i32*** %162, i32**** %75
%163 = load i32, i32* %30
%164 = load i32, i32* %32
%165 = call float** @matrix(i32 0, i32 %163, i32 0, i32 %164)
store float** %165, float*** %69
store i32 0, i32* %62
br label %166
166: ; preds = %204, %155
%167 = load i32, i32* %62
%168 = load i32, i32* %30
%169 = icmp sle i32 %167, %168
br i1 %169, label %170, label %207
170: ; preds = %166
store i32 0, i32* %58
br label %171
171: ; preds = %200, %170
%172 = load i32, i32* %58
%173 = load i32, i32* %32
%174 = icmp sle i32 %172, %173
br i1 %174, label %175, label %203
175: ; preds = %171
%176 = load i32**, i32*** %44
%177 = load i32, i32* %62
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i32*, i32** %176, i64 %178
%180 = load i32*, i32** %179
%181 = load i32, i32* %58
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %180, i64 %182
store i32 0, i32* %183
%184 = load i32**, i32*** %43
%185 = load i32, i32* %62
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32*, i32** %184, i64 %186
%188 = load i32*, i32** %187
%189 = load i32, i32* %58
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %188, i64 %190
store i32 0, i32* %191
%192 = load i32**, i32*** %45
%193 = load i32, i32* %62
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32*, i32** %192, i64 %194
%196 = load i32*, i32** %195
%197 = load i32, i32* %58
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
store i32 0, i32* %199
br label %200
200: ; preds = %175
%201 = load i32, i32* %58
%202 = add nsw i32 %201, 1
store i32 %202, i32* %58
br label %171
203: ; preds = %171
br label %204
204: ; preds = %203
%205 = load i32, i32* %62
%206 = add nsw i32 %205, 1
store i32 %206, i32* %62
br label %166
207: ; preds = %166
store i32 -1, i32* %62
br label %208
208: ; preds = %259, %207
%209 = load i32, i32* %62
%210 = load i32, i32* %30
%211 = icmp sle i32 %209, %210
br i1 %211, label %212, label %262
212: ; preds = %208
store i32 0, i32* %58
br label %213
213: ; preds = %255, %212
%214 = load i32, i32* %58
%215 = load i32, i32* %32
%216 = icmp sle i32 %214, %215
br i1 %216, label %217, label %258
217: ; preds = %213
store i32 0, i32* %59
br label %218
218: ; preds = %251, %217
%219 = load i32, i32* %59
%220 = load i32*, i32** %37
%221 = load i32, i32* %58
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %220, i64 %222
%224 = load i32, i32* %223
%225 = icmp sle i32 %219, %224
br i1 %225, label %226, label %254
226: ; preds = %218
%227 = load i32***, i32**** %75
%228 = load i32, i32* %62
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i32**, i32*** %227, i64 %229
%231 = load i32**, i32*** %230
%232 = load i32, i32* %58
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32*, i32** %231, i64 %233
%235 = load i32*, i32** %234
%236 = load i32, i32* %59
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds i32, i32* %235, i64 %237
store i32 0, i32* %238
%239 = load float***, float**** %41
%240 = load i32, i32* %62
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float**, float*** %239, i64 %241
%243 = load float**, float*** %242
%244 = load i32, i32* %58
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float*, float** %243, i64 %245
%247 = load float*, float** %246
%248 = load i32, i32* %59
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %247, i64 %249
store float 0.000000e+00, float* %250
br label %251
251: ; preds = %226
%252 = load i32, i32* %59
%253 = add nsw i32 %252, 1
store i32 %253, i32* %59
br label %218
254: ; preds = %218
br label %255
255: ; preds = %254
%256 = load i32, i32* %58
%257 = add nsw i32 %256, 1
store i32 %257, i32* %58
br label %213
258: ; preds = %213
br label %259
259: ; preds = %258
%260 = load i32, i32* %62
%261 = add nsw i32 %260, 1
store i32 %261, i32* %62
br label %208
262: ; preds = %208
store i32 0, i32* %62
br label %263
263: ; preds = %293, %262
%264 = load i32, i32* %62
%265 = load i32, i32* %30
%266 = icmp sle i32 %264, %265
br i1 %266, label %267, label %296
267: ; preds = %263
store i32 0, i32* %58
br label %268
268: ; preds = %289, %267
%269 = load i32, i32* %58
%270 = load i32, i32* %32
%271 = icmp sle i32 %269, %270
br i1 %271, label %272, label %292
272: ; preds = %268
%273 = load float**, float*** %49
%274 = load i32, i32* %62
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float*, float** %273, i64 %275
%277 = load float*, float** %276
%278 = load i32, i32* %58
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %277, i64 %279
store float 0.000000e+00, float* %280
%281 = load float**, float*** %69
%282 = load i32, i32* %62
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds float*, float** %281, i64 %283
%285 = load float*, float** %284
%286 = load i32, i32* %58
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
store float 0.000000e+00, float* %288
br label %289
289: ; preds = %272
%290 = load i32, i32* %58
%291 = add nsw i32 %290, 1
store i32 %291, i32* %58
br label %268
292: ; preds = %268
br label %293
293: ; preds = %292
%294 = load i32, i32* %62
%295 = add nsw i32 %294, 1
store i32 %295, i32* %62
br label %263
296: ; preds = %263
store i32 1, i32* %57
br label %297
297: ; preds = %856, %296
%298 = load i32, i32* %57
%299 = load i32, i32* %29
%300 = icmp sle i32 %298, %299
br i1 %300, label %301, label %859
301: ; preds = %297
store i32 1, i32* %58
br label %302
302: ; preds = %852, %301
%303 = load i32, i32* %58
%304 = load i32, i32* %32
%305 = icmp sle i32 %303, %304
br i1 %305, label %306, label %855
306: ; preds = %302
%307 = load i32*, i32** %36
%308 = load i32, i32* %57
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %307, i64 %309
%311 = load i32, i32* %310
%312 = sitofp i32 %311 to float
store float %312, float* %67
store i32 0, i32* %59
br label %313
313: ; preds = %340, %306
%314 = load i32, i32* %59
%315 = load i32*, i32** %36
%316 = load i32, i32* %57
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %315, i64 %317
%319 = load i32, i32* %318
%320 = icmp slt i32 %314, %319
br i1 %320, label %321, label %343
321: ; preds = %313
%322 = load i32***, i32**** %35
%323 = load i32, i32* %57
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i32**, i32*** %322, i64 %324
%326 = load i32**, i32*** %325
%327 = load i32, i32* %58
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32*, i32** %326, i64 %328
%330 = load i32*, i32** %329
%331 = load i32, i32* %59
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i32, i32* %330, i64 %332
%334 = load i32, i32* %333
%335 = icmp eq i32 %334, 0
br i1 %335, label %336, label %339
336: ; preds = %321
%337 = load float, float* %67
%338 = fadd float %337, -1.000000e+00
store float %338, float* %67
br label %339
339: ; preds = %336, %321
br label %340
340: ; preds = %339
%341 = load i32, i32* %59
%342 = add nsw i32 %341, 1
store i32 %342, i32* %59
br label %313
343: ; preds = %313
%344 = load float, float* %67
%345 = fcmp une float %344, 0.000000e+00
br i1 %345, label %346, label %518
346: ; preds = %343
store i32 0, i32* %59
br label %347
347: ; preds = %514, %346
%348 = load i32, i32* %59
%349 = load i32*, i32** %36
%350 = load i32, i32* %57
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %349, i64 %351
%353 = load i32, i32* %352
%354 = icmp slt i32 %348, %353
br i1 %354, label %355, label %517
355: ; preds = %347
%356 = load i32***, i32**** %35
%357 = load i32, i32* %57
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32**, i32*** %356, i64 %358
%360 = load i32**, i32*** %359
%361 = load i32, i32* %58
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i32*, i32** %360, i64 %362
%364 = load i32*, i32** %363
%365 = load i32, i32* %59
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds i32, i32* %364, i64 %366
%368 = load i32, i32* %367
%369 = icmp ne i32 %368, 0
br i1 %369, label %370, label %513
370: ; preds = %355
%371 = load i32**, i32*** %45
%372 = getelementptr inbounds i32*, i32** %371, i64 0
%373 = load i32*, i32** %372
%374 = load i32, i32* %58
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %373, i64 %375
%377 = load i32, i32* %376
%378 = add nsw i32 %377, 1
store i32 %378, i32* %376
%379 = load i32, i32* %30
%380 = icmp ne i32 %379, 0
br i1 %380, label %381, label %396
381: ; preds = %370
%382 = load i32**, i32*** %45
%383 = load i32*, i32** %31
%384 = load i32, i32* %57
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i32, i32* %383, i64 %385
%387 = load i32, i32* %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds i32*, i32** %382, i64 %388
%390 = load i32*, i32** %389
%391 = load i32, i32* %58
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds i32, i32* %390, i64 %392
%394 = load i32, i32* %393
%395 = add nsw i32 %394, 1
store i32 %395, i32* %393
br label %396
396: ; preds = %381, %370
%397 = load float, float* %67
%398 = fdiv float 1.000000e+00, %397
%399 = load float***, float**** %41
%400 = getelementptr inbounds float**, float*** %399, i64 0
%401 = load float**, float*** %400
%402 = load i32, i32* %58
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds float*, float** %401, i64 %403
%405 = load float*, float** %404
%406 = load i32***, i32**** %35
%407 = load i32, i32* %57
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32**, i32*** %406, i64 %408
%410 = load i32**, i32*** %409
%411 = load i32, i32* %58
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i32*, i32** %410, i64 %412
%414 = load i32*, i32** %413
%415 = load i32, i32* %59
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds i32, i32* %414, i64 %416
%418 = load i32, i32* %417
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds float, float* %405, i64 %419
%421 = load float, float* %420
%422 = fadd float %421, %398
store float %422, float* %420
%423 = load i32***, i32**** %75
%424 = getelementptr inbounds i32**, i32*** %423, i64 0
%425 = load i32**, i32*** %424
%426 = load i32, i32* %58
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i32*, i32** %425, i64 %427
%429 = load i32*, i32** %428
%430 = load i32***, i32**** %35
%431 = load i32, i32* %57
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32**, i32*** %430, i64 %432
%434 = load i32**, i32*** %433
%435 = load i32, i32* %58
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds i32*, i32** %434, i64 %436
%438 = load i32*, i32** %437
%439 = load i32, i32* %59
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %438, i64 %440
%442 = load i32, i32* %441
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds i32, i32* %429, i64 %443
%445 = load i32, i32* %444
%446 = add nsw i32 %445, 1
store i32 %446, i32* %444
%447 = load i32, i32* %30
%448 = icmp sge i32 %447, 1
br i1 %448, label %449, label %512
449: ; preds = %396
%450 = load float, float* %67
%451 = fdiv float 1.000000e+00, %450
%452 = load float***, float**** %41
%453 = load i32*, i32** %31
%454 = load i32, i32* %57
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i32, i32* %453, i64 %455
%457 = load i32, i32* %456
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds float**, float*** %452, i64 %458
%460 = load float**, float*** %459
%461 = load i32, i32* %58
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds float*, float** %460, i64 %462
%464 = load float*, float** %463
%465 = load i32***, i32**** %35
%466 = load i32, i32* %57
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i32**, i32*** %465, i64 %467
%469 = load i32**, i32*** %468
%470 = load i32, i32* %58
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32*, i32** %469, i64 %471
%473 = load i32*, i32** %472
%474 = load i32, i32* %59
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds i32, i32* %473, i64 %475
%477 = load i32, i32* %476
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds float, float* %464, i64 %478
%480 = load float, float* %479
%481 = fadd float %480, %451
store float %481, float* %479
%482 = load i32***, i32**** %75
%483 = load i32*, i32** %31
%484 = load i32, i32* %57
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32, i32* %483, i64 %485
%487 = load i32, i32* %486
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds i32**, i32*** %482, i64 %488
%490 = load i32**, i32*** %489
%491 = load i32, i32* %58
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds i32*, i32** %490, i64 %492
%494 = load i32*, i32** %493
%495 = load i32***, i32**** %35
%496 = load i32, i32* %57
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds i32**, i32*** %495, i64 %497
%499 = load i32**, i32*** %498
%500 = load i32, i32* %58
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32*, i32** %499, i64 %501
%503 = load i32*, i32** %502
%504 = load i32, i32* %59
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %503, i64 %505
%507 = load i32, i32* %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds i32, i32* %494, i64 %508
%510 = load i32, i32* %509
%511 = add nsw i32 %510, 1
store i32 %511, i32* %509
br label %512
512: ; preds = %449, %396
br label %513
513: ; preds = %512, %355
br label %514
514: ; preds = %513
%515 = load i32, i32* %59
%516 = add nsw i32 %515, 1
store i32 %516, i32* %59
br label %347
517: ; preds = %347
br label %557
518: ; preds = %343
%519 = load float***, float**** %41
%520 = getelementptr inbounds float**, float*** %519, i64 0
%521 = load float**, float*** %520
%522 = load i32, i32* %58
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds float*, float** %521, i64 %523
%525 = load float*, float** %524
%526 = getelementptr inbounds float, float* %525, i64 0
%527 = load float, float* %526
%528 = fadd float %527, 1.000000e+00
store float %528, float* %526
%529 = load i32**, i32*** %43
%530 = getelementptr inbounds i32*, i32** %529, i64 0
%531 = load i32*, i32** %530
%532 = load i32, i32* %58
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i32, i32* %531, i64 %533
%535 = load i32, i32* %534
%536 = add nsw i32 %535, 1
store i32 %536, i32* %534
%537 = load i32, i32* %30
%538 = icmp sge i32 %537, 1
br i1 %538, label %539, label %556
539: ; preds = %518
%540 = load float***, float**** %41
%541 = load i32*, i32** %31
%542 = load i32, i32* %57
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds i32, i32* %541, i64 %543
%545 = load i32, i32* %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float**, float*** %540, i64 %546
%548 = load float**, float*** %547
%549 = load i32, i32* %58
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float*, float** %548, i64 %550
%552 = load float*, float** %551
%553 = getelementptr inbounds float, float* %552, i64 0
%554 = load float, float* %553
%555 = fadd float %554, 1.000000e+00
store float %555, float* %553
br label %556
556: ; preds = %539, %518
br label %557
557: ; preds = %556, %517
%558 = load float, float* %67
%559 = fcmp ogt float %558, 0.000000e+00
br i1 %559, label %560, label %578
560: ; preds = %557
%561 = load float, float* %67
%562 = load i32*, i32** %36
%563 = load i32, i32* %57
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds i32, i32* %562, i64 %564
%566 = load i32, i32* %565
%567 = sitofp i32 %566 to float
%568 = fcmp olt float %561, %567
br i1 %568, label %569, label %578
569: ; preds = %560
%570 = load i32**, i32*** %44
%571 = getelementptr inbounds i32*, i32** %570, i64 0
%572 = load i32*, i32** %571
%573 = load i32, i32* %58
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds i32, i32* %572, i64 %574
%576 = load i32, i32* %575
%577 = add nsw i32 %576, 1
store i32 %577, i32* %575
br label %578
578: ; preds = %569, %560, %557
%579 = load i32, i32* %30
%580 = icmp ne i32 %579, 0
br i1 %580, label %581, label %627
581: ; preds = %578
%582 = load float, float* %67
%583 = fcmp oeq float %582, 0.000000e+00
br i1 %583, label %584, label %599
584: ; preds = %581
%585 = load i32**, i32*** %43
%586 = load i32*, i32** %31
%587 = load i32, i32* %57
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds i32, i32* %586, i64 %588
%590 = load i32, i32* %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds i32*, i32** %585, i64 %591
%593 = load i32*, i32** %592
%594 = load i32, i32* %58
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds i32, i32* %593, i64 %595
%597 = load i32, i32* %596
%598 = add nsw i32 %597, 1
store i32 %598, i32* %596
br label %599
599: ; preds = %584, %581
%600 = load float, float* %67
%601 = fcmp ogt float %600, 0.000000e+00
br i1 %601, label %602, label %626
602: ; preds = %599
%603 = load float, float* %67
%604 = load i32*, i32** %36
%605 = load i32, i32* %57
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %604, i64 %606
%608 = load i32, i32* %607
%609 = sitofp i32 %608 to float
%610 = fcmp olt float %603, %609
br i1 %610, label %611, label %626
611: ; preds = %602
%612 = load i32**, i32*** %44
%613 = load i32*, i32** %31
%614 = load i32, i32* %57
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds i32, i32* %613, i64 %615
%617 = load i32, i32* %616
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i32*, i32** %612, i64 %618
%620 = load i32*, i32** %619
%621 = load i32, i32* %58
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds i32, i32* %620, i64 %622
%624 = load i32, i32* %623
%625 = add nsw i32 %624, 1
store i32 %625, i32* %623
br label %626
626: ; preds = %611, %602, %599
br label %627
627: ; preds = %626, %578
%628 = load float, float* %67
%629 = fcmp ogt float %628, 1.000000e+00
br i1 %629, label %630, label %851
630: ; preds = %627
%631 = load i32*, i32** %36
%632 = load i32, i32* %57
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds i32, i32* %631, i64 %633
%635 = load i32, i32* %634
%636 = icmp eq i32 %635, 2
br i1 %636, label %637, label %689
637: ; preds = %630
%638 = load i32***, i32**** %35
%639 = load i32, i32* %57
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds i32**, i32*** %638, i64 %640
%642 = load i32**, i32*** %641
%643 = load i32, i32* %58
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i32*, i32** %642, i64 %644
%646 = load i32*, i32** %645
%647 = getelementptr inbounds i32, i32* %646, i64 0
%648 = load i32, i32* %647
%649 = load i32***, i32**** %35
%650 = load i32, i32* %57
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds i32**, i32*** %649, i64 %651
%653 = load i32**, i32*** %652
%654 = load i32, i32* %58
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds i32*, i32** %653, i64 %655
%657 = load i32*, i32** %656
%658 = getelementptr inbounds i32, i32* %657, i64 1
%659 = load i32, i32* %658
%660 = icmp ne i32 %648, %659
br i1 %660, label %661, label %688
661: ; preds = %637
%662 = load float**, float*** %49
%663 = getelementptr inbounds float*, float** %662, i64 0
%664 = load float*, float** %663
%665 = load i32, i32* %58
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds float, float* %664, i64 %666
%668 = load float, float* %667
%669 = fadd float %668, 1.000000e+00
store float %669, float* %667
%670 = load i32, i32* %30
%671 = icmp ne i32 %670, 0
br i1 %671, label %672, label %687
672: ; preds = %661
%673 = load float**, float*** %49
%674 = load i32*, i32** %31
%675 = load i32, i32* %57
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds i32, i32* %674, i64 %676
%678 = load i32, i32* %677
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds float*, float** %673, i64 %679
%681 = load float*, float** %680
%682 = load i32, i32* %58
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds float, float* %681, i64 %683
%685 = load float, float* %684
%686 = fadd float %685, 1.000000e+00
store float %686, float* %684
br label %687
687: ; preds = %672, %661
br label %688
688: ; preds = %687, %637
br label %824
689: ; preds = %630
store i32 0, i32* %60
br label %690
690: ; preds = %820, %689
%691 = load i32, i32* %60
%692 = load i32*, i32** %36
%693 = load i32, i32* %57
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i32, i32* %692, i64 %694
%696 = load i32, i32* %695
%697 = sub nsw i32 %696, 1
%698 = icmp slt i32 %691, %697
br i1 %698, label %699, label %823
699: ; preds = %690
%700 = load i32***, i32**** %35
%701 = load i32, i32* %57
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds i32**, i32*** %700, i64 %702
%704 = load i32**, i32*** %703
%705 = load i32, i32* %58
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds i32*, i32** %704, i64 %706
%708 = load i32*, i32** %707
%709 = load i32, i32* %60
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds i32, i32* %708, i64 %710
%712 = load i32, i32* %711
%713 = icmp ne i32 %712, 0
br i1 %713, label %714, label %819
714: ; preds = %699
%715 = load i32, i32* %60
%716 = add nsw i32 %715, 1
store i32 %716, i32* %61
br label %717
717: ; preds = %815, %714
%718 = load i32, i32* %61
%719 = load i32*, i32** %36
%720 = load i32, i32* %57
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds i32, i32* %719, i64 %721
%723 = load i32, i32* %722
%724 = icmp slt i32 %718, %723
br i1 %724, label %725, label %818
725: ; preds = %717
%726 = load i32***, i32**** %35
%727 = load i32, i32* %57
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i32**, i32*** %726, i64 %728
%730 = load i32**, i32*** %729
%731 = load i32, i32* %58
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds i32*, i32** %730, i64 %732
%734 = load i32*, i32** %733
%735 = load i32, i32* %61
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds i32, i32* %734, i64 %736
%738 = load i32, i32* %737
%739 = icmp ne i32 %738, 0
br i1 %739, label %740, label %814
740: ; preds = %725
%741 = load i32***, i32**** %35
%742 = load i32, i32* %57
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds i32**, i32*** %741, i64 %743
%745 = load i32**, i32*** %744
%746 = load i32, i32* %58
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds i32*, i32** %745, i64 %747
%749 = load i32*, i32** %748
%750 = load i32, i32* %60
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds i32, i32* %749, i64 %751
%753 = load i32, i32* %752
%754 = load i32***, i32**** %35
%755 = load i32, i32* %57
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i32**, i32*** %754, i64 %756
%758 = load i32**, i32*** %757
%759 = load i32, i32* %58
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds i32*, i32** %758, i64 %760
%762 = load i32*, i32** %761
%763 = load i32, i32* %61
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds i32, i32* %762, i64 %764
%766 = load i32, i32* %765
%767 = icmp ne i32 %753, %766
br i1 %767, label %768, label %813
768: ; preds = %740
%769 = load float, float* %67
%770 = load float, float* %67
%771 = fsub float %770, 1.000000e+00
%772 = fmul float %769, %771
%773 = fpext float %772 to double
%774 = fdiv double %773, 2.000000e+00
%775 = fdiv double 1.000000e+00, %774
%776 = load float**, float*** %49
%777 = getelementptr inbounds float*, float** %776, i64 0
%778 = load float*, float** %777
%779 = load i32, i32* %58
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds float, float* %778, i64 %780
%782 = load float, float* %781
%783 = fpext float %782 to double
%784 = fadd double %783, %775
%785 = fptrunc double %784 to float
store float %785, float* %781
%786 = load i32, i32* %30
%787 = icmp ne i32 %786, 0
br i1 %787, label %788, label %812
788: ; preds = %768
%789 = load float, float* %67
%790 = load float, float* %67
%791 = fsub float %790, 1.000000e+00
%792 = fmul float %789, %791
%793 = fpext float %792 to double
%794 = fdiv double %793, 2.000000e+00
%795 = fdiv double 1.000000e+00, %794
%796 = load float**, float*** %49
%797 = load i32*, i32** %31
%798 = load i32, i32* %57
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds i32, i32* %797, i64 %799
%801 = load i32, i32* %800
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds float*, float** %796, i64 %802
%804 = load float*, float** %803
%805 = load i32, i32* %58
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds float, float* %804, i64 %806
%808 = load float, float* %807
%809 = fpext float %808 to double
%810 = fadd double %809, %795
%811 = fptrunc double %810 to float
store float %811, float* %807
br label %812
812: ; preds = %788, %768
br label %813
813: ; preds = %812, %740
br label %814
814: ; preds = %813, %725
br label %815
815: ; preds = %814
%816 = load i32, i32* %61
%817 = add nsw i32 %816, 1
store i32 %817, i32* %61
br label %717
818: ; preds = %717
br label %819
819: ; preds = %818, %699
br label %820
820: ; preds = %819
%821 = load i32, i32* %60
%822 = add nsw i32 %821, 1
store i32 %822, i32* %60
br label %690
823: ; preds = %690
br label %824
824: ; preds = %823, %688
%825 = load float**, float*** %69
%826 = getelementptr inbounds float*, float** %825, i64 0
%827 = load float*, float** %826
%828 = load i32, i32* %58
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds float, float* %827, i64 %829
%831 = load float, float* %830
%832 = fadd float %831, 1.000000e+00
store float %832, float* %830
%833 = load i32, i32* %30
%834 = icmp ne i32 %833, 0
br i1 %834, label %835, label %850
835: ; preds = %824
%836 = load float**, float*** %69
%837 = load i32*, i32** %31
%838 = load i32, i32* %57
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds i32, i32* %837, i64 %839
%841 = load i32, i32* %840
%842 = sext i32 %841 to i64
%843 = getelementptr inbounds float*, float** %836, i64 %842
%844 = load float*, float** %843
%845 = load i32, i32* %58
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds float, float* %844, i64 %846
%848 = load float, float* %847
%849 = fadd float %848, 1.000000e+00
store float %849, float* %847
br label %850
850: ; preds = %835, %824
br label %851
851: ; preds = %850, %627
br label %852
852: ; preds = %851
%853 = load i32, i32* %58
%854 = add nsw i32 %853, 1
store i32 %854, i32* %58
br label %302
855: ; preds = %302
br label %856
856: ; preds = %855
%857 = load i32, i32* %57
%858 = add nsw i32 %857, 1
store i32 %858, i32* %57
br label %297
859: ; preds = %297
store i32 1, i32* %58
br label %860
860: ; preds = %919, %859
%861 = load i32, i32* %58
%862 = load i32, i32* %32
%863 = icmp sle i32 %861, %862
br i1 %863, label %864, label %922
864: ; preds = %860
store i32 1, i32* %59
br label %865
865: ; preds = %915, %864
%866 = load i32, i32* %59
%867 = load i32*, i32** %37
%868 = load i32, i32* %58
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds i32, i32* %867, i64 %869
%871 = load i32, i32* %870
%872 = icmp sle i32 %866, %871
br i1 %872, label %873, label %918
873: ; preds = %865
store i32 0, i32* %62
br label %874
874: ; preds = %911, %873
%875 = load i32, i32* %62
%876 = load i32, i32* %30
%877 = icmp sle i32 %875, %876
br i1 %877, label %878, label %914
878: ; preds = %874
%879 = load i32*, i32** %74
%880 = load i32, i32* %62
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds i32, i32* %879, i64 %881
%883 = load i32, i32* %882
%884 = sitofp i32 %883 to float
%885 = load float***, float**** %41
%886 = load i32, i32* %62
%887 = sext i32 %886 to i64
%888 = getelementptr inbounds float**, float*** %885, i64 %887
%889 = load float**, float*** %888
%890 = load i32, i32* %58
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds float*, float** %889, i64 %891
%893 = load float*, float** %892
%894 = getelementptr inbounds float, float* %893, i64 0
%895 = load float, float* %894
%896 = fsub float %884, %895
%897 = load float***, float**** %41
%898 = load i32, i32* %62
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds float**, float*** %897, i64 %899
%901 = load float**, float*** %900
%902 = load i32, i32* %58
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds float*, float** %901, i64 %903
%905 = load float*, float** %904
%906 = load i32, i32* %59
%907 = sext i32 %906 to i64
%908 = getelementptr inbounds float, float* %905, i64 %907
%909 = load float, float* %908
%910 = fdiv float %909, %896
store float %910, float* %908
br label %911
911: ; preds = %878
%912 = load i32, i32* %62
%913 = add nsw i32 %912, 1
store i32 %913, i32* %62
br label %874
914: ; preds = %874
br label %915
915: ; preds = %914
%916 = load i32, i32* %59
%917 = add nsw i32 %916, 1
store i32 %917, i32* %59
br label %865
918: ; preds = %865
br label %919
919: ; preds = %918
%920 = load i32, i32* %58
%921 = add nsw i32 %920, 1
store i32 %921, i32* %58
br label %860
922: ; preds = %860
store i32 0, i32* %62
br label %923
923: ; preds = %1042, %922
%924 = load i32, i32* %62
%925 = load i32, i32* %30
%926 = icmp sle i32 %924, %925
br i1 %926, label %927, label %1045
927: ; preds = %923
%928 = load float**, float*** %69
%929 = load i32, i32* %62
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds float*, float** %928, i64 %930
%932 = load float*, float** %931
%933 = getelementptr inbounds float, float* %932, i64 0
store float 0.000000e+00, float* %933
store i32 1, i32* %58
br label %934
934: ; preds = %1005, %927
%935 = load i32, i32* %58
%936 = load i32, i32* %32
%937 = icmp sle i32 %935, %936
br i1 %937, label %938, label %1008
938: ; preds = %934
%939 = load float**, float*** %69
%940 = load i32, i32* %62
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds float*, float** %939, i64 %941
%943 = load float*, float** %942
%944 = load i32, i32* %58
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds float, float* %943, i64 %945
%947 = load float, float* %946
%948 = fcmp ogt float %947, 0.000000e+00
br i1 %948, label %949, label %994
949: ; preds = %938
%950 = load float**, float*** %69
%951 = load i32, i32* %62
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds float*, float** %950, i64 %952
%954 = load float*, float** %953
%955 = load i32, i32* %58
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds float, float* %954, i64 %956
%958 = load float, float* %957
%959 = load float**, float*** %49
%960 = load i32, i32* %62
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds float*, float** %959, i64 %961
%963 = load float*, float** %962
%964 = load i32, i32* %58
%965 = sext i32 %964 to i64
%966 = getelementptr inbounds float, float* %963, i64 %965
%967 = load float, float* %966
%968 = fdiv float %967, %958
store float %968, float* %966
%969 = load float**, float*** %49
%970 = load i32, i32* %62
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds float*, float** %969, i64 %971
%973 = load float*, float** %972
%974 = load i32, i32* %58
%975 = sext i32 %974 to i64
%976 = getelementptr inbounds float, float* %973, i64 %975
%977 = load float, float* %976
%978 = load float**, float*** %49
%979 = load i32, i32* %62
%980 = sext i32 %979 to i64
%981 = getelementptr inbounds float*, float** %978, i64 %980
%982 = load float*, float** %981
%983 = getelementptr inbounds float, float* %982, i64 0
%984 = load float, float* %983
%985 = fadd float %984, %977
store float %985, float* %983
%986 = load float**, float*** %69
%987 = load i32, i32* %62
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds float*, float** %986, i64 %988
%990 = load float*, float** %989
%991 = getelementptr inbounds float, float* %990, i64 0
%992 = load float, float* %991
%993 = fadd float %992, 1.000000e+00
store float %993, float* %991
br label %1004
994: ; preds = %938
%995 = load float, float* @HUGE_VAL
%996 = load float**, float*** %49
%997 = load i32, i32* %62
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds float*, float** %996, i64 %998
%1000 = load float*, float** %999
%1001 = load i32, i32* %58
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds float, float* %1000, i64 %1002
store float %995, float* %1003
br label %1004
1004: ; preds = %994, %949
br label %1005
1005: ; preds = %1004
%1006 = load i32, i32* %58
%1007 = add nsw i32 %1006, 1
store i32 %1007, i32* %58
br label %934
1008: ; preds = %934
%1009 = load float**, float*** %69
%1010 = load i32, i32* %62
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds float*, float** %1009, i64 %1011
%1013 = load float*, float** %1012
%1014 = getelementptr inbounds float, float* %1013, i64 0
%1015 = load float, float* %1014
%1016 = fcmp ogt float %1015, 0.000000e+00
br i1 %1016, label %1017, label %1033
1017: ; preds = %1008
%1018 = load float**, float*** %69
%1019 = load i32, i32* %62
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds float*, float** %1018, i64 %1020
%1022 = load float*, float** %1021
%1023 = getelementptr inbounds float, float* %1022, i64 0
%1024 = load float, float* %1023
%1025 = load float**, float*** %49
%1026 = load i32, i32* %62
%1027 = sext i32 %1026 to i64
%1028 = getelementptr inbounds float*, float** %1025, i64 %1027
%1029 = load float*, float** %1028
%1030 = getelementptr inbounds float, float* %1029, i64 0
%1031 = load float, float* %1030
%1032 = fdiv float %1031, %1024
store float %1032, float* %1030
br label %1041
1033: ; preds = %1008
%1034 = load float, float* @HUGE_VAL
%1035 = load float**, float*** %49
%1036 = load i32, i32* %62
%1037 = sext i32 %1036 to i64
%1038 = getelementptr inbounds float*, float** %1035, i64 %1037
%1039 = load float*, float** %1038
%1040 = getelementptr inbounds float, float* %1039, i64 0
store float %1034, float* %1040
br label %1041
1041: ; preds = %1033, %1017
br label %1042
1042: ; preds = %1041
%1043 = load i32, i32* %62
%1044 = add nsw i32 %1043, 1
store i32 %1044, i32* %62
br label %923
1045: ; preds = %923
store i32 1, i32* %58
br label %1046
1046: ; preds = %1080, %1045
%1047 = load i32, i32* %58
%1048 = load i32, i32* %32
%1049 = icmp sle i32 %1047, %1048
br i1 %1049, label %1050, label %1083
1050: ; preds = %1046
store i32 0, i32* %62
br label %1051
1051: ; preds = %1076, %1050
%1052 = load i32, i32* %62
%1053 = load i32, i32* %30
%1054 = icmp sle i32 %1052, %1053
br i1 %1054, label %1055, label %1079
1055: ; preds = %1051
%1056 = load i32**, i32*** %45
%1057 = load i32, i32* %62
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds i32*, i32** %1056, i64 %1058
%1060 = load i32*, i32** %1059
%1061 = load i32, i32* %58
%1062 = sext i32 %1061 to i64
%1063 = getelementptr inbounds i32, i32* %1060, i64 %1062
%1064 = load i32, i32* %1063
%1065 = sitofp i32 %1064 to float
%1066 = load float***, float**** %41
%1067 = load i32, i32* %62
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds float**, float*** %1066, i64 %1068
%1070 = load float**, float*** %1069
%1071 = load i32, i32* %58
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds float*, float** %1070, i64 %1072
%1074 = load float*, float** %1073
%1075 = getelementptr inbounds float, float* %1074, i64 0
store float %1065, float* %1075
br label %1076
1076: ; preds = %1055
%1077 = load i32, i32* %62
%1078 = add nsw i32 %1077, 1
store i32 %1078, i32* %62
br label %1051
1079: ; preds = %1051
br label %1080
1080: ; preds = %1079
%1081 = load i32, i32* %58
%1082 = add nsw i32 %1081, 1
store i32 %1082, i32* %58
br label %1046
1083: ; preds = %1046
store i32 0, i32* %62
br label %1084
1084: ; preds = %1122, %1083
%1085 = load i32, i32* %62
%1086 = load i32, i32* %30
%1087 = icmp sle i32 %1085, %1086
br i1 %1087, label %1088, label %1125
1088: ; preds = %1084
%1089 = load i32**, i32*** %45
%1090 = load i32, i32* %62
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds i32*, i32** %1089, i64 %1091
%1093 = load i32*, i32** %1092
%1094 = getelementptr inbounds i32, i32* %1093, i64 0
store i32 2, i32* %1094
store i32 1, i32* %58
br label %1095
1095: ; preds = %1118, %1088
%1096 = load i32, i32* %58
%1097 = load i32, i32* %32
%1098 = icmp sle i32 %1096, %1097
br i1 %1098, label %1099, label %1121
1099: ; preds = %1095
%1100 = load i32**, i32*** %45
%1101 = load i32, i32* %62
%1102 = sext i32 %1101 to i64
%1103 = getelementptr inbounds i32*, i32** %1100, i64 %1102
%1104 = load i32*, i32** %1103
%1105 = load i32, i32* %58
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds i32, i32* %1104, i64 %1106
%1108 = load i32, i32* %1107
%1109 = icmp slt i32 %1108, 2
br i1 %1109, label %1110, label %1117
1110: ; preds = %1099
%1111 = load i32**, i32*** %45
%1112 = load i32, i32* %62
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds i32*, i32** %1111, i64 %1113
%1115 = load i32*, i32** %1114
%1116 = getelementptr inbounds i32, i32* %1115, i64 0
store i32 0, i32* %1116
br label %1117
1117: ; preds = %1110, %1099
br label %1118
1118: ; preds = %1117
%1119 = load i32, i32* %58
%1120 = add nsw i32 %1119, 1
store i32 %1120, i32* %58
br label %1095
1121: ; preds = %1095
br label %1122
1122: ; preds = %1121
%1123 = load i32, i32* %62
%1124 = add nsw i32 %1123, 1
store i32 %1124, i32* %62
br label %1084
1125: ; preds = %1084
store i32 1, i32* %58
br label %1126
1126: ; preds = %1218, %1125
%1127 = load i32, i32* %58
%1128 = load i32, i32* %32
%1129 = icmp sle i32 %1127, %1128
br i1 %1129, label %1130, label %1221
1130: ; preds = %1126
store float 0.000000e+00, float* %68
store i32 1, i32* %62
br label %1131
1131: ; preds = %1188, %1130
%1132 = load i32, i32* %62
%1133 = load i32, i32* %30
%1134 = icmp sle i32 %1132, %1133
br i1 %1134, label %1135, label %1191
1135: ; preds = %1131
%1136 = load i32**, i32*** %45
%1137 = load i32, i32* %62
%1138 = sext i32 %1137 to i64
%1139 = getelementptr inbounds i32*, i32** %1136, i64 %1138
%1140 = load i32*, i32** %1139
%1141 = load i32, i32* %58
%1142 = sext i32 %1141 to i64
%1143 = getelementptr inbounds i32, i32* %1140, i64 %1142
%1144 = load i32, i32* %1143
%1145 = icmp ne i32 %1144, 0
br i1 %1145, label %1146, label %1187
1146: ; preds = %1135
%1147 = load float, float* %68
%1148 = fadd float %1147, 1.000000e+00
store float %1148, float* %68
store i32 1, i32* %59
br label %1149
1149: ; preds = %1183, %1146
%1150 = load i32, i32* %59
%1151 = load i32*, i32** %37
%1152 = load i32, i32* %58
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds i32, i32* %1151, i64 %1153
%1155 = load i32, i32* %1154
%1156 = icmp sle i32 %1150, %1155
br i1 %1156, label %1157, label %1186
1157: ; preds = %1149
%1158 = load float***, float**** %41
%1159 = load i32, i32* %62
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds float**, float*** %1158, i64 %1160
%1162 = load float**, float*** %1161
%1163 = load i32, i32* %58
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds float*, float** %1162, i64 %1164
%1166 = load float*, float** %1165
%1167 = load i32, i32* %59
%1168 = sext i32 %1167 to i64
%1169 = getelementptr inbounds float, float* %1166, i64 %1168
%1170 = load float, float* %1169
%1171 = load float***, float**** %41
%1172 = getelementptr inbounds float**, float*** %1171, i64 -1
%1173 = load float**, float*** %1172
%1174 = load i32, i32* %58
%1175 = sext i32 %1174 to i64
%1176 = getelementptr inbounds float*, float** %1173, i64 %1175
%1177 = load float*, float** %1176
%1178 = load i32, i32* %59
%1179 = sext i32 %1178 to i64
%1180 = getelementptr inbounds float, float* %1177, i64 %1179
%1181 = load float, float* %1180
%1182 = fadd float %1181, %1170
store float %1182, float* %1180
br label %1183
1183: ; preds = %1157
%1184 = load i32, i32* %59
%1185 = add nsw i32 %1184, 1
store i32 %1185, i32* %59
br label %1149
1186: ; preds = %1149
br label %1187
1187: ; preds = %1186, %1135
br label %1188
1188: ; preds = %1187
%1189 = load i32, i32* %62
%1190 = add nsw i32 %1189, 1
store i32 %1190, i32* %62
br label %1131
1191: ; preds = %1131
store i32 1, i32* %59
br label %1192
1192: ; preds = %1214, %1191
%1193 = load i32, i32* %59
%1194 = load i32*, i32** %37
%1195 = load i32, i32* %58
%1196 = sext i32 %1195 to i64
%1197 = getelementptr inbounds i32, i32* %1194, i64 %1196
%1198 = load i32, i32* %1197
%1199 = icmp sle i32 %1193, %1198
br i1 %1199, label %1200, label %1217
1200: ; preds = %1192
%1201 = load float, float* %68
%1202 = load float***, float**** %41
%1203 = getelementptr inbounds float**, float*** %1202, i64 -1
%1204 = load float**, float*** %1203
%1205 = load i32, i32* %58
%1206 = sext i32 %1205 to i64
%1207 = getelementptr inbounds float*, float** %1204, i64 %1206
%1208 = load float*, float** %1207
%1209 = load i32, i32* %59
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds float, float* %1208, i64 %1210
%1212 = load float, float* %1211
%1213 = fdiv float %1212, %1201
store float %1213, float* %1211
br label %1214
1214: ; preds = %1200
%1215 = load i32, i32* %59
%1216 = add nsw i32 %1215, 1
store i32 %1216, i32* %59
br label %1192
1217: ; preds = %1192
br label %1218
1218: ; preds = %1217
%1219 = load i32, i32* %58
%1220 = add nsw i32 %1219, 1
store i32 %1220, i32* %58
br label %1126
1221: ; preds = %1126
store i32 0, i32* %58
br label %1222
1222: ; preds = %1244, %1221
%1223 = load i32, i32* %58
%1224 = load i32, i32* %32
%1225 = icmp sle i32 %1223, %1224
br i1 %1225, label %1226, label %1247
1226: ; preds = %1222
store i32 0, i32* %62
br label %1227
1227: ; preds = %1240, %1226
%1228 = load i32, i32* %62
%1229 = load i32, i32* %30
%1230 = icmp sle i32 %1228, %1229
br i1 %1230, label %1231, label %1243
1231: ; preds = %1227
%1232 = load i32**, i32*** %42
%1233 = load i32, i32* %62
%1234 = sext i32 %1233 to i64
%1235 = getelementptr inbounds i32*, i32** %1232, i64 %1234
%1236 = load i32*, i32** %1235
%1237 = load i32, i32* %58
%1238 = sext i32 %1237 to i64
%1239 = getelementptr inbounds i32, i32* %1236, i64 %1238
store i32 0, i32* %1239
br label %1240
1240: ; preds = %1231
%1241 = load i32, i32* %62
%1242 = add nsw i32 %1241, 1
store i32 %1242, i32* %62
br label %1227
1243: ; preds = %1227
br label %1244
1244: ; preds = %1243
%1245 = load i32, i32* %58
%1246 = add nsw i32 %1245, 1
store i32 %1246, i32* %58
br label %1222
1247: ; preds = %1222
store i32 1, i32* %58
br label %1248
1248: ; preds = %1301, %1247
%1249 = load i32, i32* %58
%1250 = load i32, i32* %32
%1251 = icmp sle i32 %1249, %1250
br i1 %1251, label %1252, label %1304
1252: ; preds = %1248
store i32 1, i32* %59
br label %1253
1253: ; preds = %1297, %1252
%1254 = load i32, i32* %59
%1255 = load i32*, i32** %37
%1256 = load i32, i32* %58
%1257 = sext i32 %1256 to i64
%1258 = getelementptr inbounds i32, i32* %1255, i64 %1257
%1259 = load i32, i32* %1258
%1260 = icmp sle i32 %1254, %1259
br i1 %1260, label %1261, label %1300
1261: ; preds = %1253
store i32 0, i32* %62
br label %1262
1262: ; preds = %1293, %1261
%1263 = load i32, i32* %62
%1264 = load i32, i32* %30
%1265 = icmp sle i32 %1263, %1264
br i1 %1265, label %1266, label %1296
1266: ; preds = %1262
%1267 = load float***, float**** %41
%1268 = load i32, i32* %62
%1269 = sext i32 %1268 to i64
%1270 = getelementptr inbounds float**, float*** %1267, i64 %1269
%1271 = load float**, float*** %1270
%1272 = load i32, i32* %58
%1273 = sext i32 %1272 to i64
%1274 = getelementptr inbounds float*, float** %1271, i64 %1273
%1275 = load float*, float** %1274
%1276 = load i32, i32* %59
%1277 = sext i32 %1276 to i64
%1278 = getelementptr inbounds float, float* %1275, i64 %1277
%1279 = load float, float* %1278
%1280 = fcmp une float %1279, 0.000000e+00
br i1 %1280, label %1281, label %1292
1281: ; preds = %1266
%1282 = load i32**, i32*** %42
%1283 = load i32, i32* %62
%1284 = sext i32 %1283 to i64
%1285 = getelementptr inbounds i32*, i32** %1282, i64 %1284
%1286 = load i32*, i32** %1285
%1287 = load i32, i32* %58
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds i32, i32* %1286, i64 %1288
%1290 = load i32, i32* %1289
%1291 = add nsw i32 %1290, 1
store i32 %1291, i32* %1289
br label %1292
1292: ; preds = %1281, %1266
br label %1293
1293: ; preds = %1292
%1294 = load i32, i32* %62
%1295 = add nsw i32 %1294, 1
store i32 %1295, i32* %62
br label %1262
1296: ; preds = %1262
br label %1297
1297: ; preds = %1296
%1298 = load i32, i32* %59
%1299 = add nsw i32 %1298, 1
store i32 %1299, i32* %59
br label %1253
1300: ; preds = %1253
br label %1301
1301: ; preds = %1300
%1302 = load i32, i32* %58
%1303 = add nsw i32 %1302, 1
store i32 %1303, i32* %58
br label %1248
1304: ; preds = %1248
%1305 = load i32*, i32** %48
%1306 = load i32, i32* %1305
%1307 = icmp eq i32 %1306, 0
br i1 %1307, label %1308, label %1366
1308: ; preds = %1304
%1309 = load i32, i32* %29
%1310 = load i32, i32* %34
%1311 = mul nsw i32 %1309, %1310
%1312 = load i32*, i32** %48
store i32 %1311, i32* %1312
store i32 1, i32* %58
br label %1313
1313: ; preds = %1362, %1308
%1314 = load i32, i32* %58
%1315 = load i32, i32* %32
%1316 = icmp sle i32 %1314, %1315
br i1 %1316, label %1317, label %1365
1317: ; preds = %1313
store i32 0, i32* %62
br label %1318
1318: ; preds = %1358, %1317
%1319 = load i32, i32* %62
%1320 = load i32, i32* %30
%1321 = icmp sle i32 %1319, %1320
br i1 %1321, label %1322, label %1361
1322: ; preds = %1318
%1323 = load i32**, i32*** %45
%1324 = load i32, i32* %62
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds i32*, i32** %1323, i64 %1325
%1327 = load i32*, i32** %1326
%1328 = load i32, i32* %58
%1329 = sext i32 %1328 to i64
%1330 = getelementptr inbounds i32, i32* %1327, i64 %1329
%1331 = load i32, i32* %1330
%1332 = icmp sgt i32 %1331, 1
br i1 %1332, label %1333, label %1357
1333: ; preds = %1322
%1334 = load i32**, i32*** %45
%1335 = load i32, i32* %62
%1336 = sext i32 %1335 to i64
%1337 = getelementptr inbounds i32*, i32** %1334, i64 %1336
%1338 = load i32*, i32** %1337
%1339 = load i32, i32* %58
%1340 = sext i32 %1339 to i64
%1341 = getelementptr inbounds i32, i32* %1338, i64 %1340
%1342 = load i32, i32* %1341
%1343 = load i32*, i32** %48
%1344 = load i32, i32* %1343
%1345 = icmp slt i32 %1342, %1344
br i1 %1345, label %1346, label %1357
1346: ; preds = %1333
%1347 = load i32**, i32*** %45
%1348 = load i32, i32* %62
%1349 = sext i32 %1348 to i64
%1350 = getelementptr inbounds i32*, i32** %1347, i64 %1349
%1351 = load i32*, i32** %1350
%1352 = load i32, i32* %58
%1353 = sext i32 %1352 to i64
%1354 = getelementptr inbounds i32, i32* %1351, i64 %1353
%1355 = load i32, i32* %1354
%1356 = load i32*, i32** %48
store i32 %1355, i32* %1356
br label %1357
1357: ; preds = %1346, %1333, %1322
br label %1358
1358: ; preds = %1357
%1359 = load i32, i32* %62
%1360 = add nsw i32 %1359, 1
store i32 %1360, i32* %62
br label %1318
1361: ; preds = %1318
br label %1362
1362: ; preds = %1361
%1363 = load i32, i32* %58
%1364 = add nsw i32 %1363, 1
store i32 %1364, i32* %58
br label %1313
1365: ; preds = %1313
br label %1366
1366: ; preds = %1365, %1304
store i32 0, i32* %62
br label %1367
1367: ; preds = %1543, %1366
%1368 = load i32, i32* %62
%1369 = load i32, i32* %30
%1370 = icmp sle i32 %1368, %1369
br i1 %1370, label %1371, label %1546
1371: ; preds = %1367
%1372 = load float**, float*** %47
%1373 = load i32, i32* %62
%1374 = sext i32 %1373 to i64
%1375 = getelementptr inbounds float*, float** %1372, i64 %1374
%1376 = load float*, float** %1375
%1377 = getelementptr inbounds float, float* %1376, i64 0
store float 0.000000e+00, float* %1377
store i32 1, i32* %58
br label %1378
1378: ; preds = %1539, %1371
%1379 = load i32, i32* %58
%1380 = load i32, i32* %32
%1381 = icmp sle i32 %1379, %1380
br i1 %1381, label %1382, label %1542
1382: ; preds = %1378
%1383 = load i32**, i32*** %45
%1384 = load i32, i32* %62
%1385 = sext i32 %1384 to i64
%1386 = getelementptr inbounds i32*, i32** %1383, i64 %1385
%1387 = load i32*, i32** %1386
%1388 = load i32, i32* %58
%1389 = sext i32 %1388 to i64
%1390 = getelementptr inbounds i32, i32* %1387, i64 %1389
%1391 = load i32, i32* %1390
%1392 = load i32*, i32** %48
%1393 = load i32, i32* %1392
%1394 = icmp sgt i32 %1391, %1393
br i1 %1394, label %1395, label %1475
1395: ; preds = %1382
%1396 = load i32**, i32*** %45
%1397 = load i32, i32* %62
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds i32*, i32** %1396, i64 %1398
%1400 = load i32*, i32** %1399
%1401 = load i32, i32* %58
%1402 = sext i32 %1401 to i64
%1403 = getelementptr inbounds i32, i32* %1400, i64 %1402
%1404 = load i32, i32* %1403
store i32 %1404, i32* %77
%1405 = load float**, float*** %47
%1406 = load i32, i32* %62
%1407 = sext i32 %1406 to i64
%1408 = getelementptr inbounds float*, float** %1405, i64 %1407
%1409 = load float*, float** %1408
%1410 = load i32, i32* %58
%1411 = sext i32 %1410 to i64
%1412 = getelementptr inbounds float, float* %1409, i64 %1411
store float 0.000000e+00, float* %1412
store i32 1, i32* %59
br label %1413
1413: ; preds = %1471, %1395
%1414 = load i32, i32* %59
%1415 = load i32*, i32** %37
%1416 = load i32, i32* %58
%1417 = sext i32 %1416 to i64
%1418 = getelementptr inbounds i32, i32* %1415, i64 %1417
%1419 = load i32, i32* %1418
%1420 = icmp sle i32 %1414, %1419
br i1 %1420, label %1421, label %1474
1421: ; preds = %1413
%1422 = load i32***, i32**** %75
%1423 = load i32, i32* %62
%1424 = sext i32 %1423 to i64
%1425 = getelementptr inbounds i32**, i32*** %1422, i64 %1424
%1426 = load i32**, i32*** %1425
%1427 = load i32, i32* %58
%1428 = sext i32 %1427 to i64
%1429 = getelementptr inbounds i32*, i32** %1426, i64 %1428
%1430 = load i32*, i32** %1429
%1431 = load i32, i32* %59
%1432 = sext i32 %1431 to i64
%1433 = getelementptr inbounds i32, i32* %1430, i64 %1432
%1434 = load i32, i32* %1433
store i32 %1434, i32* %78
store double 1.000000e+00, double* %79
store i32 0, i32* %29
br label %1435
1435: ; preds = %1454, %1421
%1436 = load i32, i32* %29
%1437 = load i32*, i32** %48
%1438 = load i32, i32* %1437
%1439 = icmp slt i32 %1436, %1438
br i1 %1439, label %1440, label %1457
1440: ; preds = %1435
%1441 = load i32, i32* %77
%1442 = load i32, i32* %78
%1443 = sub nsw i32 %1441, %1442
%1444 = load i32, i32* %29
%1445 = sub nsw i32 %1443, %1444
%1446 = sitofp i32 %1445 to double
%1447 = load i32, i32* %77
%1448 = load i32, i32* %29
%1449 = sub nsw i32 %1447, %1448
%1450 = sitofp i32 %1449 to double
%1451 = fdiv double %1446, %1450
%1452 = load double, double* %79
%1453 = fmul double %1452, %1451
store double %1453, double* %79
br label %1454
1454: ; preds = %1440
%1455 = load i32, i32* %29
%1456 = add nsw i32 %1455, 1
store i32 %1456, i32* %29
br label %1435
1457: ; preds = %1435
%1458 = load double, double* %79
%1459 = fsub double 1.000000e+00, %1458
%1460 = fptrunc double %1459 to float
%1461 = load float**, float*** %47
%1462 = load i32, i32* %62
%1463 = sext i32 %1462 to i64
%1464 = getelementptr inbounds float*, float** %1461, i64 %1463
%1465 = load float*, float** %1464
%1466 = load i32, i32* %58
%1467 = sext i32 %1466 to i64
%1468 = getelementptr inbounds float, float* %1465, i64 %1467
%1469 = load float, float* %1468
%1470 = fadd float %1469, %1460
store float %1470, float* %1468
br label %1471
1471: ; preds = %1457
%1472 = load i32, i32* %59
%1473 = add nsw i32 %1472, 1
store i32 %1473, i32* %59
br label %1413
1474: ; preds = %1413
br label %1518
1475: ; preds = %1382
%1476 = load i32**, i32*** %45
%1477 = load i32, i32* %62
%1478 = sext i32 %1477 to i64
%1479 = getelementptr inbounds i32*, i32** %1476, i64 %1478
%1480 = load i32*, i32** %1479
%1481 = load i32, i32* %58
%1482 = sext i32 %1481 to i64
%1483 = getelementptr inbounds i32, i32* %1480, i64 %1482
%1484 = load i32, i32* %1483
%1485 = load i32*, i32** %48
%1486 = load i32, i32* %1485
%1487 = icmp eq i32 %1484, %1486
br i1 %1487, label %1488, label %1507
1488: ; preds = %1475
%1489 = load i32**, i32*** %42
%1490 = load i32, i32* %62
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds i32*, i32** %1489, i64 %1491
%1493 = load i32*, i32** %1492
%1494 = load i32, i32* %58
%1495 = sext i32 %1494 to i64
%1496 = getelementptr inbounds i32, i32* %1493, i64 %1495
%1497 = load i32, i32* %1496
%1498 = sitofp i32 %1497 to float
%1499 = load float**, float*** %47
%1500 = load i32, i32* %62
%1501 = sext i32 %1500 to i64
%1502 = getelementptr inbounds float*, float** %1499, i64 %1501
%1503 = load float*, float** %1502
%1504 = load i32, i32* %58
%1505 = sext i32 %1504 to i64
%1506 = getelementptr inbounds float, float* %1503, i64 %1505
store float %1498, float* %1506
br label %1517
1507: ; preds = %1475
%1508 = load float, float* @HUGE_VAL
%1509 = load float**, float*** %47
%1510 = load i32, i32* %62
%1511 = sext i32 %1510 to i64
%1512 = getelementptr inbounds float*, float** %1509, i64 %1511
%1513 = load float*, float** %1512
%1514 = load i32, i32* %58
%1515 = sext i32 %1514 to i64
%1516 = getelementptr inbounds float, float* %1513, i64 %1515
store float %1508, float* %1516
br label %1517
1517: ; preds = %1507, %1488
br label %1518
1518: ; preds = %1517, %1474
%1519 = load float**, float*** %47
%1520 = load i32, i32* %62
%1521 = sext i32 %1520 to i64
%1522 = getelementptr inbounds float*, float** %1519, i64 %1521
%1523 = load float*, float** %1522
%1524 = load i32, i32* %58
%1525 = sext i32 %1524 to i64
%1526 = getelementptr inbounds float, float* %1523, i64 %1525
%1527 = load float, float* %1526
%1528 = load i32, i32* %32
%1529 = sitofp i32 %1528 to float
%1530 = fdiv float %1527, %1529
%1531 = load float**, float*** %47
%1532 = load i32, i32* %62
%1533 = sext i32 %1532 to i64
%1534 = getelementptr inbounds float*, float** %1531, i64 %1533
%1535 = load float*, float** %1534
%1536 = getelementptr inbounds float, float* %1535, i64 0
%1537 = load float, float* %1536
%1538 = fadd float %1537, %1530
store float %1538, float* %1536
br label %1539
1539: ; preds = %1518
%1540 = load i32, i32* %58
%1541 = add nsw i32 %1540, 1
store i32 %1541, i32* %58
br label %1378
1542: ; preds = %1378
br label %1543
1543: ; preds = %1542
%1544 = load i32, i32* %62
%1545 = add nsw i32 %1544, 1
store i32 %1545, i32* %62
br label %1367
1546: ; preds = %1367
store i32 0, i32* %62
br label %1547
1547: ; preds = %1564, %1546
%1548 = load i32, i32* %62
%1549 = load i32, i32* %30
%1550 = icmp sle i32 %1548, %1549
br i1 %1550, label %1551, label %1567
1551: ; preds = %1547
%1552 = load float**, float*** %46
%1553 = load i32, i32* %62
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds float*, float** %1552, i64 %1554
%1556 = load float*, float** %1555
%1557 = getelementptr inbounds float, float* %1556, i64 0
store float 0.000000e+00, float* %1557
%1558 = load float**, float*** %50
%1559 = load i32, i32* %62
%1560 = sext i32 %1559 to i64
%1561 = getelementptr inbounds float*, float** %1558, i64 %1560
%1562 = load float*, float** %1561
%1563 = getelementptr inbounds float, float* %1562, i64 0
store float 0.000000e+00, float* %1563
br label %1564
1564: ; preds = %1551
%1565 = load i32, i32* %62
%1566 = add nsw i32 %1565, 1
store i32 %1566, i32* %62
br label %1547
1567: ; preds = %1547
store i32 0, i32* %62
br label %1568
1568: ; preds = %1826, %1567
%1569 = load i32, i32* %62
%1570 = load i32, i32* %30
%1571 = icmp sle i32 %1569, %1570
br i1 %1571, label %1572, label %1829
1572: ; preds = %1568
store i32 1, i32* %58
br label %1573
1573: ; preds = %1822, %1572
%1574 = load i32, i32* %58
%1575 = load i32, i32* %32
%1576 = icmp sle i32 %1574, %1575
br i1 %1576, label %1577, label %1825
1577: ; preds = %1573
%1578 = load i32**, i32*** %45
%1579 = load i32, i32* %62
%1580 = sext i32 %1579 to i64
%1581 = getelementptr inbounds i32*, i32** %1578, i64 %1580
%1582 = load i32*, i32** %1581
%1583 = load i32, i32* %58
%1584 = sext i32 %1583 to i64
%1585 = getelementptr inbounds i32, i32* %1582, i64 %1584
%1586 = load i32, i32* %1585
%1587 = icmp sgt i32 %1586, 1
br i1 %1587, label %1588, label %1763
1588: ; preds = %1577
%1589 = load float**, float*** %73
%1590 = load i32, i32* %62
%1591 = sext i32 %1590 to i64
%1592 = getelementptr inbounds float*, float** %1589, i64 %1591
%1593 = load float*, float** %1592
%1594 = load i32, i32* %58
%1595 = sext i32 %1594 to i64
%1596 = getelementptr inbounds float, float* %1593, i64 %1595
store float 0.000000e+00, float* %1596
store i32 1, i32* %59
br label %1597
1597: ; preds = %1642, %1588
%1598 = load i32, i32* %59
%1599 = load i32*, i32** %37
%1600 = load i32, i32* %58
%1601 = sext i32 %1600 to i64
%1602 = getelementptr inbounds i32, i32* %1599, i64 %1601
%1603 = load i32, i32* %1602
%1604 = icmp sle i32 %1598, %1603
br i1 %1604, label %1605, label %1645
1605: ; preds = %1597
%1606 = load float***, float**** %41
%1607 = load i32, i32* %62
%1608 = sext i32 %1607 to i64
%1609 = getelementptr inbounds float**, float*** %1606, i64 %1608
%1610 = load float**, float*** %1609
%1611 = load i32, i32* %58
%1612 = sext i32 %1611 to i64
%1613 = getelementptr inbounds float*, float** %1610, i64 %1612
%1614 = load float*, float** %1613
%1615 = load i32, i32* %59
%1616 = sext i32 %1615 to i64
%1617 = getelementptr inbounds float, float* %1614, i64 %1616
%1618 = load float, float* %1617
%1619 = load float***, float**** %41
%1620 = load i32, i32* %62
%1621 = sext i32 %1620 to i64
%1622 = getelementptr inbounds float**, float*** %1619, i64 %1621
%1623 = load float**, float*** %1622
%1624 = load i32, i32* %58
%1625 = sext i32 %1624 to i64
%1626 = getelementptr inbounds float*, float** %1623, i64 %1625
%1627 = load float*, float** %1626
%1628 = load i32, i32* %59
%1629 = sext i32 %1628 to i64
%1630 = getelementptr inbounds float, float* %1627, i64 %1629
%1631 = load float, float* %1630
%1632 = load float**, float*** %73
%1633 = load i32, i32* %62
%1634 = sext i32 %1633 to i64
%1635 = getelementptr inbounds float*, float** %1632, i64 %1634
%1636 = load float*, float** %1635
%1637 = load i32, i32* %58
%1638 = sext i32 %1637 to i64
%1639 = getelementptr inbounds float, float* %1636, i64 %1638
%1640 = load float, float* %1639
%1641 = call float @llvm.fmuladd.f32(float %1618, float %1631, float %1640)
store float %1641, float* %1639
br label %1642
1642: ; preds = %1605
%1643 = load i32, i32* %59
%1644 = add nsw i32 %1643, 1
store i32 %1644, i32* %59
br label %1597
1645: ; preds = %1597
%1646 = load float**, float*** %73
%1647 = load i32, i32* %62
%1648 = sext i32 %1647 to i64
%1649 = getelementptr inbounds float*, float** %1646, i64 %1648
%1650 = load float*, float** %1649
%1651 = load i32, i32* %58
%1652 = sext i32 %1651 to i64
%1653 = getelementptr inbounds float, float* %1650, i64 %1652
%1654 = load float, float* %1653
%1655 = fsub float 1.000000e+00, %1654
%1656 = load float**, float*** %50
%1657 = load i32, i32* %62
%1658 = sext i32 %1657 to i64
%1659 = getelementptr inbounds float*, float** %1656, i64 %1658
%1660 = load float*, float** %1659
%1661 = load i32, i32* %58
%1662 = sext i32 %1661 to i64
%1663 = getelementptr inbounds float, float* %1660, i64 %1662
store float %1655, float* %1663
%1664 = load i32**, i32*** %45
%1665 = load i32, i32* %62
%1666 = sext i32 %1665 to i64
%1667 = getelementptr inbounds i32*, i32** %1664, i64 %1666
%1668 = load i32*, i32** %1667
%1669 = load i32, i32* %58
%1670 = sext i32 %1669 to i64
%1671 = getelementptr inbounds i32, i32* %1668, i64 %1670
%1672 = load i32, i32* %1671
%1673 = sitofp i32 %1672 to float
%1674 = load i32**, i32*** %45
%1675 = load i32, i32* %62
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds i32*, i32** %1674, i64 %1676
%1678 = load i32*, i32** %1677
%1679 = load i32, i32* %58
%1680 = sext i32 %1679 to i64
%1681 = getelementptr inbounds i32, i32* %1678, i64 %1680
%1682 = load i32, i32* %1681
%1683 = sitofp i32 %1682 to float
%1684 = fsub float %1683, 1.000000e+00
%1685 = fdiv float %1673, %1684
%1686 = load float**, float*** %50
%1687 = load i32, i32* %62
%1688 = sext i32 %1687 to i64
%1689 = getelementptr inbounds float*, float** %1686, i64 %1688
%1690 = load float*, float** %1689
%1691 = load i32, i32* %58
%1692 = sext i32 %1691 to i64
%1693 = getelementptr inbounds float, float* %1690, i64 %1692
%1694 = load float, float* %1693
%1695 = fmul float %1694, %1685
store float %1695, float* %1693
%1696 = load i32**, i32*** %45
%1697 = load i32, i32* %62
%1698 = sext i32 %1697 to i64
%1699 = getelementptr inbounds i32*, i32** %1696, i64 %1698
%1700 = load i32*, i32** %1699
%1701 = load i32, i32* %58
%1702 = sext i32 %1701 to i64
%1703 = getelementptr inbounds i32, i32* %1700, i64 %1702
%1704 = load i32, i32* %1703
%1705 = sitofp i32 %1704 to double
%1706 = load i32**, i32*** %45
%1707 = load i32, i32* %62
%1708 = sext i32 %1707 to i64
%1709 = getelementptr inbounds i32*, i32** %1706, i64 %1708
%1710 = load i32*, i32** %1709
%1711 = load i32, i32* %58
%1712 = sext i32 %1711 to i64
%1713 = getelementptr inbounds i32, i32* %1710, i64 %1712
%1714 = load i32, i32* %1713
%1715 = sitofp i32 %1714 to double
%1716 = fsub double %1715, 1.000000e+00
%1717 = fmul double %1705, %1716
%1718 = load float**, float*** %50
%1719 = load i32, i32* %62
%1720 = sext i32 %1719 to i64
%1721 = getelementptr inbounds float*, float** %1718, i64 %1720
%1722 = load float*, float** %1721
%1723 = load i32, i32* %58
%1724 = sext i32 %1723 to i64
%1725 = getelementptr inbounds float, float* %1722, i64 %1724
%1726 = load float, float* %1725
%1727 = fpext float %1726 to double
%1728 = fsub double 1.000000e+00, %1727
%1729 = load i32**, i32*** %45
%1730 = load i32, i32* %62
%1731 = sext i32 %1730 to i64
%1732 = getelementptr inbounds i32*, i32** %1729, i64 %1731
%1733 = load i32*, i32** %1732
%1734 = load i32, i32* %58
%1735 = sext i32 %1734 to i64
%1736 = getelementptr inbounds i32, i32* %1733, i64 %1735
%1737 = load i32, i32* %1736
%1738 = sitofp i32 %1737 to double
%1739 = fsub double %1738, 2.000000e+00
%1740 = fmul double %1728, %1739
%1741 = load i32**, i32*** %45
%1742 = load i32, i32* %62
%1743 = sext i32 %1742 to i64
%1744 = getelementptr inbounds i32*, i32** %1741, i64 %1743
%1745 = load i32*, i32** %1744
%1746 = load i32, i32* %58
%1747 = sext i32 %1746 to i64
%1748 = getelementptr inbounds i32, i32* %1745, i64 %1747
%1749 = load i32, i32* %1748
%1750 = sitofp i32 %1749 to double
%1751 = fadd double %1750, 1.000000e+00
%1752 = call double @llvm.fmuladd.f64(double %1740, double %1751, double 2.000000e+00)
%1753 = fdiv double %1717, %1752
%1754 = fptrunc double %1753 to float
%1755 = load float**, float*** %46
%1756 = load i32, i32* %62
%1757 = sext i32 %1756 to i64
%1758 = getelementptr inbounds float*, float** %1755, i64 %1757
%1759 = load float*, float** %1758
%1760 = load i32, i32* %58
%1761 = sext i32 %1760 to i64
%1762 = getelementptr inbounds float, float* %1759, i64 %1761
store float %1754, float* %1762
br label %1781
1763: ; preds = %1577
%1764 = load float, float* @HUGE_VAL
%1765 = load float**, float*** %46
%1766 = load i32, i32* %62
%1767 = sext i32 %1766 to i64
%1768 = getelementptr inbounds float*, float** %1765, i64 %1767
%1769 = load float*, float** %1768
%1770 = load i32, i32* %58
%1771 = sext i32 %1770 to i64
%1772 = getelementptr inbounds float, float* %1769, i64 %1771
store float %1764, float* %1772
%1773 = load float**, float*** %50
%1774 = load i32, i32* %62
%1775 = sext i32 %1774 to i64
%1776 = getelementptr inbounds float*, float** %1773, i64 %1775
%1777 = load float*, float** %1776
%1778 = load i32, i32* %58
%1779 = sext i32 %1778 to i64
%1780 = getelementptr inbounds float, float* %1777, i64 %1779
store float %1764, float* %1780
br label %1781
1781: ; preds = %1763, %1645
%1782 = load float**, float*** %50
%1783 = load i32, i32* %62
%1784 = sext i32 %1783 to i64
%1785 = getelementptr inbounds float*, float** %1782, i64 %1784
%1786 = load float*, float** %1785
%1787 = load i32, i32* %58
%1788 = sext i32 %1787 to i64
%1789 = getelementptr inbounds float, float* %1786, i64 %1788
%1790 = load float, float* %1789
%1791 = load i32, i32* %32
%1792 = sitofp i32 %1791 to float
%1793 = fdiv float %1790, %1792
%1794 = load float**, float*** %50
%1795 = load i32, i32* %62
%1796 = sext i32 %1795 to i64
%1797 = getelementptr inbounds float*, float** %1794, i64 %1796
%1798 = load float*, float** %1797
%1799 = getelementptr inbounds float, float* %1798, i64 0
%1800 = load float, float* %1799
%1801 = fadd float %1800, %1793
store float %1801, float* %1799
%1802 = load float**, float*** %46
%1803 = load i32, i32* %62
%1804 = sext i32 %1803 to i64
%1805 = getelementptr inbounds float*, float** %1802, i64 %1804
%1806 = load float*, float** %1805
%1807 = load i32, i32* %58
%1808 = sext i32 %1807 to i64
%1809 = getelementptr inbounds float, float* %1806, i64 %1808
%1810 = load float, float* %1809
%1811 = load i32, i32* %32
%1812 = sitofp i32 %1811 to float
%1813 = fdiv float %1810, %1812
%1814 = load float**, float*** %46
%1815 = load i32, i32* %62
%1816 = sext i32 %1815 to i64
%1817 = getelementptr inbounds float*, float** %1814, i64 %1816
%1818 = load float*, float** %1817
%1819 = getelementptr inbounds float, float* %1818, i64 0
%1820 = load float, float* %1819
%1821 = fadd float %1820, %1813
store float %1821, float* %1819
br label %1822
1822: ; preds = %1781
%1823 = load i32, i32* %58
%1824 = add nsw i32 %1823, 1
store i32 %1824, i32* %58
br label %1573
1825: ; preds = %1573
br label %1826
1826: ; preds = %1825
%1827 = load i32, i32* %62
%1828 = add nsw i32 %1827, 1
store i32 %1828, i32* %62
br label %1568
1829: ; preds = %1568
store i32 1, i32* %58
br label %1830
1830: ; preds = %2765, %1829
%1831 = load i32, i32* %58
%1832 = load i32, i32* %32
%1833 = icmp sle i32 %1831, %1832
br i1 %1833, label %1834, label %2768
1834: ; preds = %1830
store i32 1, i32* %62
br label %1835
1835: ; preds = %2310, %1834
%1836 = load i32, i32* %62
%1837 = load i32, i32* %30
%1838 = icmp sle i32 %1836, %1837
br i1 %1838, label %1839, label %2313
1839: ; preds = %1835
%1840 = load i32**, i32*** %45
%1841 = load i32, i32* %62
%1842 = sext i32 %1841 to i64
%1843 = getelementptr inbounds i32*, i32** %1840, i64 %1842
%1844 = load i32*, i32** %1843
%1845 = load i32, i32* %58
%1846 = sext i32 %1845 to i64
%1847 = getelementptr inbounds i32, i32* %1844, i64 %1846
%1848 = load i32, i32* %1847
%1849 = icmp sgt i32 %1848, 1
br i1 %1849, label %1850, label %2275
1850: ; preds = %1839
store float 0.000000e+00, float* %70
%1851 = load float**, float*** %54
%1852 = load i32, i32* %62
%1853 = sext i32 %1852 to i64
%1854 = getelementptr inbounds float*, float** %1851, i64 %1853
%1855 = load float*, float** %1854
%1856 = load i32, i32* %58
%1857 = sext i32 %1856 to i64
%1858 = getelementptr inbounds float, float* %1855, i64 %1857
store float 0.000000e+00, float* %1858
%1859 = load float**, float*** %53
%1860 = load i32, i32* %62
%1861 = sext i32 %1860 to i64
%1862 = getelementptr inbounds float*, float** %1859, i64 %1861
%1863 = load float*, float** %1862
%1864 = load i32, i32* %58
%1865 = sext i32 %1864 to i64
%1866 = getelementptr inbounds float, float* %1863, i64 %1865
store float 0.000000e+00, float* %1866
%1867 = load float**, float*** %52
%1868 = load i32, i32* %62
%1869 = sext i32 %1868 to i64
%1870 = getelementptr inbounds float*, float** %1867, i64 %1869
%1871 = load float*, float** %1870
%1872 = load i32, i32* %58
%1873 = sext i32 %1872 to i64
%1874 = getelementptr inbounds float, float* %1871, i64 %1873
store float 0.000000e+00, float* %1874
%1875 = load float**, float*** %51
%1876 = load i32, i32* %62
%1877 = sext i32 %1876 to i64
%1878 = getelementptr inbounds float*, float** %1875, i64 %1877
%1879 = load float*, float** %1878
%1880 = load i32, i32* %58
%1881 = sext i32 %1880 to i64
%1882 = getelementptr inbounds float, float* %1879, i64 %1881
store float 0.000000e+00, float* %1882
store i32 0, i32* %66
store i32 1, i32* %60
br label %1883
1883: ; preds = %2154, %1850
%1884 = load i32, i32* %60
%1885 = load i32*, i32** %37
%1886 = load i32, i32* %58
%1887 = sext i32 %1886 to i64
%1888 = getelementptr inbounds i32, i32* %1885, i64 %1887
%1889 = load i32, i32* %1888
%1890 = icmp sle i32 %1884, %1889
br i1 %1890, label %1891, label %2157
1891: ; preds = %1883
%1892 = load float***, float**** %41
%1893 = load i32, i32* %62
%1894 = sext i32 %1893 to i64
%1895 = getelementptr inbounds float**, float*** %1892, i64 %1894
%1896 = load float**, float*** %1895
%1897 = load i32, i32* %58
%1898 = sext i32 %1897 to i64
%1899 = getelementptr inbounds float*, float** %1896, i64 %1898
%1900 = load float*, float** %1899
%1901 = load i32, i32* %60
%1902 = sext i32 %1901 to i64
%1903 = getelementptr inbounds float, float* %1900, i64 %1902
%1904 = load float, float* %1903
%1905 = fcmp une float %1904, 0.000000e+00
br i1 %1905, label %1906, label %2153
1906: ; preds = %1891
store i32 1, i32* %61
br label %1907
1907: ; preds = %2149, %1906
%1908 = load i32, i32* %61
%1909 = load i32*, i32** %37
%1910 = load i32, i32* %58
%1911 = sext i32 %1910 to i64
%1912 = getelementptr inbounds i32, i32* %1909, i64 %1911
%1913 = load i32, i32* %1912
%1914 = icmp sle i32 %1908, %1913
br i1 %1914, label %1915, label %2152
1915: ; preds = %1907
%1916 = load i32, i32* %60
%1917 = load i32, i32* %61
%1918 = icmp ne i32 %1916, %1917
br i1 %1918, label %1919, label %1956
1919: ; preds = %1915
%1920 = load float***, float**** %41
%1921 = load i32, i32* %62
%1922 = sext i32 %1921 to i64
%1923 = getelementptr inbounds float**, float*** %1920, i64 %1922
%1924 = load float**, float*** %1923
%1925 = load i32, i32* %58
%1926 = sext i32 %1925 to i64
%1927 = getelementptr inbounds float*, float** %1924, i64 %1926
%1928 = load float*, float** %1927
%1929 = load i32, i32* %60
%1930 = sext i32 %1929 to i64
%1931 = getelementptr inbounds float, float* %1928, i64 %1930
%1932 = load float, float* %1931
%1933 = load float***, float**** %41
%1934 = load i32, i32* %62
%1935 = sext i32 %1934 to i64
%1936 = getelementptr inbounds float**, float*** %1933, i64 %1935
%1937 = load float**, float*** %1936
%1938 = load i32, i32* %58
%1939 = sext i32 %1938 to i64
%1940 = getelementptr inbounds float*, float** %1937, i64 %1939
%1941 = load float*, float** %1940
%1942 = load i32, i32* %61
%1943 = sext i32 %1942 to i64
%1944 = getelementptr inbounds float, float* %1941, i64 %1943
%1945 = load float, float* %1944
%1946 = load float**, float*** %51
%1947 = load i32, i32* %62
%1948 = sext i32 %1947 to i64
%1949 = getelementptr inbounds float*, float** %1946, i64 %1948
%1950 = load float*, float** %1949
%1951 = load i32, i32* %58
%1952 = sext i32 %1951 to i64
%1953 = getelementptr inbounds float, float* %1950, i64 %1952
%1954 = load float, float* %1953
%1955 = call float @llvm.fmuladd.f32(float %1932, float %1945, float %1954)
store float %1955, float* %1953
br label %1956
1956: ; preds = %1919, %1915
%1957 = load i32, i32* %40
%1958 = icmp ne i32 %1957, 0
br i1 %1958, label %1959, label %2148
1959: ; preds = %1956
%1960 = load float***, float**** %39
%1961 = load i32, i32* %58
%1962 = sext i32 %1961 to i64
%1963 = getelementptr inbounds float**, float*** %1960, i64 %1962
%1964 = load float**, float*** %1963
%1965 = load i32, i32* %60
%1966 = sext i32 %1965 to i64
%1967 = getelementptr inbounds float*, float** %1964, i64 %1966
%1968 = load float*, float** %1967
%1969 = load i32, i32* %61
%1970 = sext i32 %1969 to i64
%1971 = getelementptr inbounds float, float* %1968, i64 %1970
%1972 = load float, float* %1971
%1973 = load float***, float**** %41
%1974 = load i32, i32* %62
%1975 = sext i32 %1974 to i64
%1976 = getelementptr inbounds float**, float*** %1973, i64 %1975
%1977 = load float**, float*** %1976
%1978 = load i32, i32* %58
%1979 = sext i32 %1978 to i64
%1980 = getelementptr inbounds float*, float** %1977, i64 %1979
%1981 = load float*, float** %1980
%1982 = load i32, i32* %60
%1983 = sext i32 %1982 to i64
%1984 = getelementptr inbounds float, float* %1981, i64 %1983
%1985 = load float, float* %1984
%1986 = fmul float %1972, %1985
%1987 = load float***, float**** %41
%1988 = load i32, i32* %62
%1989 = sext i32 %1988 to i64
%1990 = getelementptr inbounds float**, float*** %1987, i64 %1989
%1991 = load float**, float*** %1990
%1992 = load i32, i32* %58
%1993 = sext i32 %1992 to i64
%1994 = getelementptr inbounds float*, float** %1991, i64 %1993
%1995 = load float*, float** %1994
%1996 = load i32, i32* %61
%1997 = sext i32 %1996 to i64
%1998 = getelementptr inbounds float, float* %1995, i64 %1997
%1999 = load float, float* %1998
%2000 = load float**, float*** %52
%2001 = load i32, i32* %62
%2002 = sext i32 %2001 to i64
%2003 = getelementptr inbounds float*, float** %2000, i64 %2002
%2004 = load float*, float** %2003
%2005 = load i32, i32* %58
%2006 = sext i32 %2005 to i64
%2007 = getelementptr inbounds float, float* %2004, i64 %2006
%2008 = load float, float* %2007
%2009 = call float @llvm.fmuladd.f32(float %1986, float %1999, float %2008)
store float %2009, float* %2007
%2010 = load i32, i32* %60
%2011 = load i32, i32* %61
%2012 = icmp ne i32 %2010, %2011
br i1 %2012, label %2013, label %2147
2013: ; preds = %1959
%2014 = load float***, float**** %41
%2015 = load i32, i32* %62
%2016 = sext i32 %2015 to i64
%2017 = getelementptr inbounds float**, float*** %2014, i64 %2016
%2018 = load float**, float*** %2017
%2019 = load i32, i32* %58
%2020 = sext i32 %2019 to i64
%2021 = getelementptr inbounds float*, float** %2018, i64 %2020
%2022 = load float*, float** %2021
%2023 = load i32, i32* %60
%2024 = sext i32 %2023 to i64
%2025 = getelementptr inbounds float, float* %2022, i64 %2024
%2026 = load float, float* %2025
%2027 = fcmp une float %2026, 0.000000e+00
br i1 %2027, label %2028, label %2147
2028: ; preds = %2013
%2029 = load float***, float**** %41
%2030 = load i32, i32* %62
%2031 = sext i32 %2030 to i64
%2032 = getelementptr inbounds float**, float*** %2029, i64 %2031
%2033 = load float**, float*** %2032
%2034 = load i32, i32* %58
%2035 = sext i32 %2034 to i64
%2036 = getelementptr inbounds float*, float** %2033, i64 %2035
%2037 = load float*, float** %2036
%2038 = load i32, i32* %61
%2039 = sext i32 %2038 to i64
%2040 = getelementptr inbounds float, float* %2037, i64 %2039
%2041 = load float, float* %2040
%2042 = fcmp une float %2041, 0.000000e+00
br i1 %2042, label %2043, label %2147
2043: ; preds = %2028
%2044 = load i32, i32* %66
%2045 = add nsw i32 %2044, 1
store i32 %2045, i32* %66
%2046 = load float***, float**** %39
%2047 = load i32, i32* %58
%2048 = sext i32 %2047 to i64
%2049 = getelementptr inbounds float**, float*** %2046, i64 %2048
%2050 = load float**, float*** %2049
%2051 = load i32, i32* %60
%2052 = sext i32 %2051 to i64
%2053 = getelementptr inbounds float*, float** %2050, i64 %2052
%2054 = load float*, float** %2053
%2055 = load i32, i32* %61
%2056 = sext i32 %2055 to i64
%2057 = getelementptr inbounds float, float* %2054, i64 %2056
%2058 = load float, float* %2057
%2059 = load float**, float*** %53
%2060 = load i32, i32* %62
%2061 = sext i32 %2060 to i64
%2062 = getelementptr inbounds float*, float** %2059, i64 %2061
%2063 = load float*, float** %2062
%2064 = load i32, i32* %58
%2065 = sext i32 %2064 to i64
%2066 = getelementptr inbounds float, float* %2063, i64 %2065
%2067 = load float, float* %2066
%2068 = fadd float %2067, %2058
store float %2068, float* %2066
%2069 = load float***, float**** %39
%2070 = load i32, i32* %58
%2071 = sext i32 %2070 to i64
%2072 = getelementptr inbounds float**, float*** %2069, i64 %2071
%2073 = load float**, float*** %2072
%2074 = load i32, i32* %60
%2075 = sext i32 %2074 to i64
%2076 = getelementptr inbounds float*, float** %2073, i64 %2075
%2077 = load float*, float** %2076
%2078 = load i32, i32* %61
%2079 = sext i32 %2078 to i64
%2080 = getelementptr inbounds float, float* %2077, i64 %2079
%2081 = load float, float* %2080
%2082 = load float***, float**** %41
%2083 = load i32, i32* %62
%2084 = sext i32 %2083 to i64
%2085 = getelementptr inbounds float**, float*** %2082, i64 %2084
%2086 = load float**, float*** %2085
%2087 = load i32, i32* %58
%2088 = sext i32 %2087 to i64
%2089 = getelementptr inbounds float*, float** %2086, i64 %2088
%2090 = load float*, float** %2089
%2091 = load i32, i32* %60
%2092 = sext i32 %2091 to i64
%2093 = getelementptr inbounds float, float* %2090, i64 %2092
%2094 = load float, float* %2093
%2095 = fmul float %2081, %2094
%2096 = load float***, float**** %41
%2097 = load i32, i32* %62
%2098 = sext i32 %2097 to i64
%2099 = getelementptr inbounds float**, float*** %2096, i64 %2098
%2100 = load float**, float*** %2099
%2101 = load i32, i32* %58
%2102 = sext i32 %2101 to i64
%2103 = getelementptr inbounds float*, float** %2100, i64 %2102
%2104 = load float*, float** %2103
%2105 = load i32, i32* %61
%2106 = sext i32 %2105 to i64
%2107 = getelementptr inbounds float, float* %2104, i64 %2106
%2108 = load float, float* %2107
%2109 = load float**, float*** %54
%2110 = load i32, i32* %62
%2111 = sext i32 %2110 to i64
%2112 = getelementptr inbounds float*, float** %2109, i64 %2111
%2113 = load float*, float** %2112
%2114 = load i32, i32* %58
%2115 = sext i32 %2114 to i64
%2116 = getelementptr inbounds float, float* %2113, i64 %2115
%2117 = load float, float* %2116
%2118 = call float @llvm.fmuladd.f32(float %2095, float %2108, float %2117)
store float %2118, float* %2116
%2119 = load float***, float**** %41
%2120 = load i32, i32* %62
%2121 = sext i32 %2120 to i64
%2122 = getelementptr inbounds float**, float*** %2119, i64 %2121
%2123 = load float**, float*** %2122
%2124 = load i32, i32* %58
%2125 = sext i32 %2124 to i64
%2126 = getelementptr inbounds float*, float** %2123, i64 %2125
%2127 = load float*, float** %2126
%2128 = load i32, i32* %60
%2129 = sext i32 %2128 to i64
%2130 = getelementptr inbounds float, float* %2127, i64 %2129
%2131 = load float, float* %2130
%2132 = load float***, float**** %41
%2133 = load i32, i32* %62
%2134 = sext i32 %2133 to i64
%2135 = getelementptr inbounds float**, float*** %2132, i64 %2134
%2136 = load float**, float*** %2135
%2137 = load i32, i32* %58
%2138 = sext i32 %2137 to i64
%2139 = getelementptr inbounds float*, float** %2136, i64 %2138
%2140 = load float*, float** %2139
%2141 = load i32, i32* %61
%2142 = sext i32 %2141 to i64
%2143 = getelementptr inbounds float, float* %2140, i64 %2142
%2144 = load float, float* %2143
%2145 = load float, float* %70
%2146 = call float @llvm.fmuladd.f32(float %2131, float %2144, float %2145)
store float %2146, float* %70
br label %2147
2147: ; preds = %2043, %2028, %2013, %1959
br label %2148
2148: ; preds = %2147, %1956
br label %2149
2149: ; preds = %2148
%2150 = load i32, i32* %61
%2151 = add nsw i32 %2150, 1
store i32 %2151, i32* %61
br label %1907
2152: ; preds = %1907
br label %2153
2153: ; preds = %2152, %1891
br label %2154
2154: ; preds = %2153
%2155 = load i32, i32* %60
%2156 = add nsw i32 %2155, 1
store i32 %2156, i32* %60
br label %1883
2157: ; preds = %1883
%2158 = load i32**, i32*** %45
%2159 = load i32, i32* %62
%2160 = sext i32 %2159 to i64
%2161 = getelementptr inbounds i32*, i32** %2158, i64 %2160
%2162 = load i32*, i32** %2161
%2163 = load i32, i32* %58
%2164 = sext i32 %2163 to i64
%2165 = getelementptr inbounds i32, i32* %2162, i64 %2164
%2166 = load i32, i32* %2165
%2167 = sitofp i32 %2166 to double
%2168 = load i32**, i32*** %45
%2169 = load i32, i32* %62
%2170 = sext i32 %2169 to i64
%2171 = getelementptr inbounds i32*, i32** %2168, i64 %2170
%2172 = load i32*, i32** %2171
%2173 = load i32, i32* %58
%2174 = sext i32 %2173 to i64
%2175 = getelementptr inbounds i32, i32* %2172, i64 %2174
%2176 = load i32, i32* %2175
%2177 = sitofp i32 %2176 to double
%2178 = fsub double %2177, 1.000000e+00
%2179 = fdiv double %2167, %2178
%2180 = fptrunc double %2179 to float
%2181 = load float**, float*** %51
%2182 = load i32, i32* %62
%2183 = sext i32 %2182 to i64
%2184 = getelementptr inbounds float*, float** %2181, i64 %2183
%2185 = load float*, float** %2184
%2186 = load i32, i32* %58
%2187 = sext i32 %2186 to i64
%2188 = getelementptr inbounds float, float* %2185, i64 %2187
%2189 = load float, float* %2188
%2190 = fmul float %2189, %2180
store float %2190, float* %2188
%2191 = load i32**, i32*** %45
%2192 = load i32, i32* %62
%2193 = sext i32 %2192 to i64
%2194 = getelementptr inbounds i32*, i32** %2191, i64 %2193
%2195 = load i32*, i32** %2194
%2196 = load i32, i32* %58
%2197 = sext i32 %2196 to i64
%2198 = getelementptr inbounds i32, i32* %2195, i64 %2197
%2199 = load i32, i32* %2198
%2200 = sitofp i32 %2199 to double
%2201 = load i32**, i32*** %45
%2202 = load i32, i32* %62
%2203 = sext i32 %2202 to i64
%2204 = getelementptr inbounds i32*, i32** %2201, i64 %2203
%2205 = load i32*, i32** %2204
%2206 = load i32, i32* %58
%2207 = sext i32 %2206 to i64
%2208 = getelementptr inbounds i32, i32* %2205, i64 %2207
%2209 = load i32, i32* %2208
%2210 = sitofp i32 %2209 to double
%2211 = fsub double %2210, 1.000000e+00
%2212 = fdiv double %2200, %2211
%2213 = fptrunc double %2212 to float
%2214 = load float**, float*** %52
%2215 = load i32, i32* %62
%2216 = sext i32 %2215 to i64
%2217 = getelementptr inbounds float*, float** %2214, i64 %2216
%2218 = load float*, float** %2217
%2219 = load i32, i32* %58
%2220 = sext i32 %2219 to i64
%2221 = getelementptr inbounds float, float* %2218, i64 %2220
%2222 = load float, float* %2221
%2223 = fmul float %2222, %2213
store float %2223, float* %2221
%2224 = load i32, i32* %66
%2225 = icmp ne i32 %2224, 0
br i1 %2225, label %2226, label %2239
2226: ; preds = %2157
%2227 = load i32, i32* %66
%2228 = sitofp i32 %2227 to float
%2229 = load float**, float*** %53
%2230 = load i32, i32* %62
%2231 = sext i32 %2230 to i64
%2232 = getelementptr inbounds float*, float** %2229, i64 %2231
%2233 = load float*, float** %2232
%2234 = load i32, i32* %58
%2235 = sext i32 %2234 to i64
%2236 = getelementptr inbounds float, float* %2233, i64 %2235
%2237 = load float, float* %2236
%2238 = fdiv float %2237, %2228
store float %2238, float* %2236
br label %2249
2239: ; preds = %2157
%2240 = load float, float* @HUGE_VAL
%2241 = load float**, float*** %53
%2242 = load i32, i32* %62
%2243 = sext i32 %2242 to i64
%2244 = getelementptr inbounds float*, float** %2241, i64 %2243
%2245 = load float*, float** %2244
%2246 = load i32, i32* %58
%2247 = sext i32 %2246 to i64
%2248 = getelementptr inbounds float, float* %2245, i64 %2247
store float %2240, float* %2248
br label %2249
2249: ; preds = %2239, %2226
%2250 = load float, float* %70
%2251 = fcmp une float %2250, 0.000000e+00
br i1 %2251, label %2252, label %2264
2252: ; preds = %2249
%2253 = load float, float* %70
%2254 = load float**, float*** %54
%2255 = load i32, i32* %62
%2256 = sext i32 %2255 to i64
%2257 = getelementptr inbounds float*, float** %2254, i64 %2256
%2258 = load float*, float** %2257
%2259 = load i32, i32* %58
%2260 = sext i32 %2259 to i64
%2261 = getelementptr inbounds float, float* %2258, i64 %2260
%2262 = load float, float* %2261
%2263 = fdiv float %2262, %2253
store float %2263, float* %2261
br label %2274
2264: ; preds = %2249
%2265 = load float, float* @HUGE_VAL
%2266 = load float**, float*** %54
%2267 = load i32, i32* %62
%2268 = sext i32 %2267 to i64
%2269 = getelementptr inbounds float*, float** %2266, i64 %2268
%2270 = load float*, float** %2269
%2271 = load i32, i32* %58
%2272 = sext i32 %2271 to i64
%2273 = getelementptr inbounds float, float* %2270, i64 %2272
store float %2265, float* %2273
br label %2274
2274: ; preds = %2264, %2252
br label %2309
2275: ; preds = %1839
%2276 = load float, float* @HUGE_VAL
%2277 = load float**, float*** %54
%2278 = load i32, i32* %62
%2279 = sext i32 %2278 to i64
%2280 = getelementptr inbounds float*, float** %2277, i64 %2279
%2281 = load float*, float** %2280
%2282 = load i32, i32* %58
%2283 = sext i32 %2282 to i64
%2284 = getelementptr inbounds float, float* %2281, i64 %2283
store float %2276, float* %2284
%2285 = load float**, float*** %53
%2286 = load i32, i32* %62
%2287 = sext i32 %2286 to i64
%2288 = getelementptr inbounds float*, float** %2285, i64 %2287
%2289 = load float*, float** %2288
%2290 = load i32, i32* %58
%2291 = sext i32 %2290 to i64
%2292 = getelementptr inbounds float, float* %2289, i64 %2291
store float %2276, float* %2292
%2293 = load float**, float*** %52
%2294 = load i32, i32* %62
%2295 = sext i32 %2294 to i64
%2296 = getelementptr inbounds float*, float** %2293, i64 %2295
%2297 = load float*, float** %2296
%2298 = load i32, i32* %58
%2299 = sext i32 %2298 to i64
%2300 = getelementptr inbounds float, float* %2297, i64 %2299
store float %2276, float* %2300
%2301 = load float**, float*** %51
%2302 = load i32, i32* %62
%2303 = sext i32 %2302 to i64
%2304 = getelementptr inbounds float*, float** %2301, i64 %2303
%2305 = load float*, float** %2304
%2306 = load i32, i32* %58
%2307 = sext i32 %2306 to i64
%2308 = getelementptr inbounds float, float* %2305, i64 %2307
store float %2276, float* %2308
br label %2309
2309: ; preds = %2275, %2274
br label %2310
2310: ; preds = %2309
%2311 = load i32, i32* %62
%2312 = add nsw i32 %2311, 1
store i32 %2312, i32* %62
br label %1835
2313: ; preds = %1835
%2314 = load float**, float*** %54
%2315 = getelementptr inbounds float*, float** %2314, i64 0
%2316 = load float*, float** %2315
%2317 = load i32, i32* %58
%2318 = sext i32 %2317 to i64
%2319 = getelementptr inbounds float, float* %2316, i64 %2318
store float 0.000000e+00, float* %2319
%2320 = load float**, float*** %53
%2321 = getelementptr inbounds float*, float** %2320, i64 0
%2322 = load float*, float** %2321
%2323 = load i32, i32* %58
%2324 = sext i32 %2323 to i64
%2325 = getelementptr inbounds float, float* %2322, i64 %2324
store float 0.000000e+00, float* %2325
%2326 = load float**, float*** %52
%2327 = getelementptr inbounds float*, float** %2326, i64 0
%2328 = load float*, float** %2327
%2329 = load i32, i32* %58
%2330 = sext i32 %2329 to i64
%2331 = getelementptr inbounds float, float* %2328, i64 %2330
store float 0.000000e+00, float* %2331
%2332 = load float**, float*** %51
%2333 = getelementptr inbounds float*, float** %2332, i64 0
%2334 = load float*, float** %2333
%2335 = load i32, i32* %58
%2336 = sext i32 %2335 to i64
%2337 = getelementptr inbounds float, float* %2334, i64 %2336
store float 0.000000e+00, float* %2337
store i32 0, i32* %65
store i32 1, i32* %63
br label %2338
2338: ; preds = %2528, %2313
%2339 = load i32, i32* %63
%2340 = load i32, i32* %30
%2341 = icmp slt i32 %2339, %2340
br i1 %2341, label %2342, label %2531
2342: ; preds = %2338
%2343 = load i32, i32* %63
%2344 = add nsw i32 %2343, 1
store i32 %2344, i32* %64
br label %2345
2345: ; preds = %2524, %2342
%2346 = load i32, i32* %64
%2347 = load i32, i32* %30
%2348 = icmp sle i32 %2346, %2347
br i1 %2348, label %2349, label %2527
2349: ; preds = %2345
%2350 = load i32**, i32*** %45
%2351 = load i32, i32* %63
%2352 = sext i32 %2351 to i64
%2353 = getelementptr inbounds i32*, i32** %2350, i64 %2352
%2354 = load i32*, i32** %2353
%2355 = load i32, i32* %58
%2356 = sext i32 %2355 to i64
%2357 = getelementptr inbounds i32, i32* %2354, i64 %2356
%2358 = load i32, i32* %2357
%2359 = icmp sgt i32 %2358, 1
br i1 %2359, label %2360, label %2523
2360: ; preds = %2349
%2361 = load i32**, i32*** %45
%2362 = load i32, i32* %64
%2363 = sext i32 %2362 to i64
%2364 = getelementptr inbounds i32*, i32** %2361, i64 %2363
%2365 = load i32*, i32** %2364
%2366 = load i32, i32* %58
%2367 = sext i32 %2366 to i64
%2368 = getelementptr inbounds i32, i32* %2365, i64 %2367
%2369 = load i32, i32* %2368
%2370 = icmp sgt i32 %2369, 1
br i1 %2370, label %2371, label %2523
2371: ; preds = %2360
%2372 = load i32, i32* %65
%2373 = add nsw i32 %2372, 1
store i32 %2373, i32* %65
store i32 1, i32* %60
br label %2374
2374: ; preds = %2519, %2371
%2375 = load i32, i32* %60
%2376 = load i32*, i32** %37
%2377 = load i32, i32* %58
%2378 = sext i32 %2377 to i64
%2379 = getelementptr inbounds i32, i32* %2376, i64 %2378
%2380 = load i32, i32* %2379
%2381 = icmp sle i32 %2375, %2380
br i1 %2381, label %2382, label %2522
2382: ; preds = %2374
%2383 = load float***, float**** %41
%2384 = load i32, i32* %63
%2385 = sext i32 %2384 to i64
%2386 = getelementptr inbounds float**, float*** %2383, i64 %2385
%2387 = load float**, float*** %2386
%2388 = load i32, i32* %58
%2389 = sext i32 %2388 to i64
%2390 = getelementptr inbounds float*, float** %2387, i64 %2389
%2391 = load float*, float** %2390
%2392 = load i32, i32* %60
%2393 = sext i32 %2392 to i64
%2394 = getelementptr inbounds float, float* %2391, i64 %2393
%2395 = load float, float* %2394
%2396 = fcmp une float %2395, 0.000000e+00
br i1 %2396, label %2397, label %2518
2397: ; preds = %2382
store i32 1, i32* %61
br label %2398
2398: ; preds = %2514, %2397
%2399 = load i32, i32* %61
%2400 = load i32*, i32** %37
%2401 = load i32, i32* %58
%2402 = sext i32 %2401 to i64
%2403 = getelementptr inbounds i32, i32* %2400, i64 %2402
%2404 = load i32, i32* %2403
%2405 = icmp sle i32 %2399, %2404
br i1 %2405, label %2406, label %2517
2406: ; preds = %2398
%2407 = load float***, float**** %41
%2408 = load i32, i32* %64
%2409 = sext i32 %2408 to i64
%2410 = getelementptr inbounds float**, float*** %2407, i64 %2409
%2411 = load float**, float*** %2410
%2412 = load i32, i32* %58
%2413 = sext i32 %2412 to i64
%2414 = getelementptr inbounds float*, float** %2411, i64 %2413
%2415 = load float*, float** %2414
%2416 = load i32, i32* %61
%2417 = sext i32 %2416 to i64
%2418 = getelementptr inbounds float, float* %2415, i64 %2417
%2419 = load float, float* %2418
%2420 = fcmp une float %2419, 0.000000e+00
br i1 %2420, label %2421, label %2513
2421: ; preds = %2406
%2422 = load i32, i32* %60
%2423 = load i32, i32* %61
%2424 = icmp ne i32 %2422, %2423
br i1 %2424, label %2425, label %2460
2425: ; preds = %2421
%2426 = load float***, float**** %41
%2427 = load i32, i32* %63
%2428 = sext i32 %2427 to i64
%2429 = getelementptr inbounds float**, float*** %2426, i64 %2428
%2430 = load float**, float*** %2429
%2431 = load i32, i32* %58
%2432 = sext i32 %2431 to i64
%2433 = getelementptr inbounds float*, float** %2430, i64 %2432
%2434 = load float*, float** %2433
%2435 = load i32, i32* %60
%2436 = sext i32 %2435 to i64
%2437 = getelementptr inbounds float, float* %2434, i64 %2436
%2438 = load float, float* %2437
%2439 = load float***, float**** %41
%2440 = load i32, i32* %64
%2441 = sext i32 %2440 to i64
%2442 = getelementptr inbounds float**, float*** %2439, i64 %2441
%2443 = load float**, float*** %2442
%2444 = load i32, i32* %58
%2445 = sext i32 %2444 to i64
%2446 = getelementptr inbounds float*, float** %2443, i64 %2445
%2447 = load float*, float** %2446
%2448 = load i32, i32* %61
%2449 = sext i32 %2448 to i64
%2450 = getelementptr inbounds float, float* %2447, i64 %2449
%2451 = load float, float* %2450
%2452 = load float**, float*** %51
%2453 = getelementptr inbounds float*, float** %2452, i64 0
%2454 = load float*, float** %2453
%2455 = load i32, i32* %58
%2456 = sext i32 %2455 to i64
%2457 = getelementptr inbounds float, float* %2454, i64 %2456
%2458 = load float, float* %2457
%2459 = call float @llvm.fmuladd.f32(float %2438, float %2451, float %2458)
store float %2459, float* %2457
br label %2460
2460: ; preds = %2425, %2421
%2461 = load i32, i32* %40
%2462 = icmp ne i32 %2461, 0
br i1 %2462, label %2463, label %2512
2463: ; preds = %2460
%2464 = load float***, float**** %39
%2465 = load i32, i32* %58
%2466 = sext i32 %2465 to i64
%2467 = getelementptr inbounds float**, float*** %2464, i64 %2466
%2468 = load float**, float*** %2467
%2469 = load i32, i32* %60
%2470 = sext i32 %2469 to i64
%2471 = getelementptr inbounds float*, float** %2468, i64 %2470
%2472 = load float*, float** %2471
%2473 = load i32, i32* %61
%2474 = sext i32 %2473 to i64
%2475 = getelementptr inbounds float, float* %2472, i64 %2474
%2476 = load float, float* %2475
%2477 = load float***, float**** %41
%2478 = load i32, i32* %63
%2479 = sext i32 %2478 to i64
%2480 = getelementptr inbounds float**, float*** %2477, i64 %2479
%2481 = load float**, float*** %2480
%2482 = load i32, i32* %58
%2483 = sext i32 %2482 to i64
%2484 = getelementptr inbounds float*, float** %2481, i64 %2483
%2485 = load float*, float** %2484
%2486 = load i32, i32* %60
%2487 = sext i32 %2486 to i64
%2488 = getelementptr inbounds float, float* %2485, i64 %2487
%2489 = load float, float* %2488
%2490 = fmul float %2476, %2489
%2491 = load float***, float**** %41
%2492 = load i32, i32* %64
%2493 = sext i32 %2492 to i64
%2494 = getelementptr inbounds float**, float*** %2491, i64 %2493
%2495 = load float**, float*** %2494
%2496 = load i32, i32* %58
%2497 = sext i32 %2496 to i64
%2498 = getelementptr inbounds float*, float** %2495, i64 %2497
%2499 = load float*, float** %2498
%2500 = load i32, i32* %61
%2501 = sext i32 %2500 to i64
%2502 = getelementptr inbounds float, float* %2499, i64 %2501
%2503 = load float, float* %2502
%2504 = load float**, float*** %52
%2505 = getelementptr inbounds float*, float** %2504, i64 0
%2506 = load float*, float** %2505
%2507 = load i32, i32* %58
%2508 = sext i32 %2507 to i64
%2509 = getelementptr inbounds float, float* %2506, i64 %2508
%2510 = load float, float* %2509
%2511 = call float @llvm.fmuladd.f32(float %2490, float %2503, float %2510)
store float %2511, float* %2509
br label %2512
2512: ; preds = %2463, %2460
br label %2513
2513: ; preds = %2512, %2406
br label %2514
2514: ; preds = %2513
%2515 = load i32, i32* %61
%2516 = add nsw i32 %2515, 1
store i32 %2516, i32* %61
br label %2398
2517: ; preds = %2398
br label %2518
2518: ; preds = %2517, %2382
br label %2519
2519: ; preds = %2518
%2520 = load i32, i32* %60
%2521 = add nsw i32 %2520, 1
store i32 %2521, i32* %60
br label %2374
2522: ; preds = %2374
br label %2523
2523: ; preds = %2522, %2360, %2349
br label %2524
2524: ; preds = %2523
%2525 = load i32, i32* %64
%2526 = add nsw i32 %2525, 1
store i32 %2526, i32* %64
br label %2345
2527: ; preds = %2345
br label %2528
2528: ; preds = %2527
%2529 = load i32, i32* %63
%2530 = add nsw i32 %2529, 1
store i32 %2530, i32* %63
br label %2338
2531: ; preds = %2338
%2532 = load i32, i32* %65
%2533 = icmp ne i32 %2532, 0
br i1 %2533, label %2534, label %2555
2534: ; preds = %2531
%2535 = load i32, i32* %65
%2536 = sitofp i32 %2535 to float
%2537 = load float**, float*** %51
%2538 = getelementptr inbounds float*, float** %2537, i64 0
%2539 = load float*, float** %2538
%2540 = load i32, i32* %58
%2541 = sext i32 %2540 to i64
%2542 = getelementptr inbounds float, float* %2539, i64 %2541
%2543 = load float, float* %2542
%2544 = fdiv float %2543, %2536
store float %2544, float* %2542
%2545 = load i32, i32* %65
%2546 = sitofp i32 %2545 to float
%2547 = load float**, float*** %52
%2548 = getelementptr inbounds float*, float** %2547, i64 0
%2549 = load float*, float** %2548
%2550 = load i32, i32* %58
%2551 = sext i32 %2550 to i64
%2552 = getelementptr inbounds float, float* %2549, i64 %2551
%2553 = load float, float* %2552
%2554 = fdiv float %2553, %2546
store float %2554, float* %2552
br label %2569
2555: ; preds = %2531
%2556 = load float, float* @HUGE_VAL
%2557 = load float**, float*** %52
%2558 = getelementptr inbounds float*, float** %2557, i64 0
%2559 = load float*, float** %2558
%2560 = load i32, i32* %58
%2561 = sext i32 %2560 to i64
%2562 = getelementptr inbounds float, float* %2559, i64 %2561
store float %2556, float* %2562
%2563 = load float**, float*** %51
%2564 = getelementptr inbounds float*, float** %2563, i64 0
%2565 = load float*, float** %2564
%2566 = load i32, i32* %58
%2567 = sext i32 %2566 to i64
%2568 = getelementptr inbounds float, float* %2565, i64 %2567
store float %2556, float* %2568
br label %2569
2569: ; preds = %2555, %2534
store i32 0, i32* %66
store float 0.000000e+00, float* %70
%2570 = load i32, i32* %40
%2571 = icmp ne i32 %2570, 0
br i1 %2571, label %2572, label %2721
2572: ; preds = %2569
store i32 1, i32* %60
br label %2573
2573: ; preds = %2717, %2572
%2574 = load i32, i32* %60
%2575 = load i32*, i32** %37
%2576 = load i32, i32* %58
%2577 = sext i32 %2576 to i64
%2578 = getelementptr inbounds i32, i32* %2575, i64 %2577
%2579 = load i32, i32* %2578
%2580 = icmp sle i32 %2574, %2579
br i1 %2580, label %2581, label %2720
2581: ; preds = %2573
store i32 1, i32* %61
br label %2582
2582: ; preds = %2713, %2581
%2583 = load i32, i32* %61
%2584 = load i32*, i32** %37
%2585 = load i32, i32* %58
%2586 = sext i32 %2585 to i64
%2587 = getelementptr inbounds i32, i32* %2584, i64 %2586
%2588 = load i32, i32* %2587
%2589 = icmp sle i32 %2583, %2588
br i1 %2589, label %2590, label %2716
2590: ; preds = %2582
%2591 = load i32, i32* %60
%2592 = load i32, i32* %61
%2593 = icmp ne i32 %2591, %2592
br i1 %2593, label %2594, label %2712
2594: ; preds = %2590
%2595 = load float***, float**** %41
%2596 = getelementptr inbounds float**, float*** %2595, i64 -1
%2597 = load float**, float*** %2596
%2598 = load i32, i32* %58
%2599 = sext i32 %2598 to i64
%2600 = getelementptr inbounds float*, float** %2597, i64 %2599
%2601 = load float*, float** %2600
%2602 = load i32, i32* %60
%2603 = sext i32 %2602 to i64
%2604 = getelementptr inbounds float, float* %2601, i64 %2603
%2605 = load float, float* %2604
%2606 = fcmp une float %2605, 0.000000e+00
br i1 %2606, label %2607, label %2712
2607: ; preds = %2594
%2608 = load float***, float**** %41
%2609 = getelementptr inbounds float**, float*** %2608, i64 -1
%2610 = load float**, float*** %2609
%2611 = load i32, i32* %58
%2612 = sext i32 %2611 to i64
%2613 = getelementptr inbounds float*, float** %2610, i64 %2612
%2614 = load float*, float** %2613
%2615 = load i32, i32* %61
%2616 = sext i32 %2615 to i64
%2617 = getelementptr inbounds float, float* %2614, i64 %2616
%2618 = load float, float* %2617
%2619 = fcmp une float %2618, 0.000000e+00
br i1 %2619, label %2620, label %2712
2620: ; preds = %2607
%2621 = load i32, i32* %66
%2622 = add nsw i32 %2621, 1
store i32 %2622, i32* %66
%2623 = load float***, float**** %39
%2624 = load i32, i32* %58
%2625 = sext i32 %2624 to i64
%2626 = getelementptr inbounds float**, float*** %2623, i64 %2625
%2627 = load float**, float*** %2626
%2628 = load i32, i32* %60
%2629 = sext i32 %2628 to i64
%2630 = getelementptr inbounds float*, float** %2627, i64 %2629
%2631 = load float*, float** %2630
%2632 = load i32, i32* %61
%2633 = sext i32 %2632 to i64
%2634 = getelementptr inbounds float, float* %2631, i64 %2633
%2635 = load float, float* %2634
%2636 = load float**, float*** %53
%2637 = getelementptr inbounds float*, float** %2636, i64 0
%2638 = load float*, float** %2637
%2639 = load i32, i32* %58
%2640 = sext i32 %2639 to i64
%2641 = getelementptr inbounds float, float* %2638, i64 %2640
%2642 = load float, float* %2641
%2643 = fadd float %2642, %2635
store float %2643, float* %2641
%2644 = load float***, float**** %39
%2645 = load i32, i32* %58
%2646 = sext i32 %2645 to i64
%2647 = getelementptr inbounds float**, float*** %2644, i64 %2646
%2648 = load float**, float*** %2647
%2649 = load i32, i32* %60
%2650 = sext i32 %2649 to i64
%2651 = getelementptr inbounds float*, float** %2648, i64 %2650
%2652 = load float*, float** %2651
%2653 = load i32, i32* %61
%2654 = sext i32 %2653 to i64
%2655 = getelementptr inbounds float, float* %2652, i64 %2654
%2656 = load float, float* %2655
%2657 = load float***, float**** %41
%2658 = getelementptr inbounds float**, float*** %2657, i64 -1
%2659 = load float**, float*** %2658
%2660 = load i32, i32* %58
%2661 = sext i32 %2660 to i64
%2662 = getelementptr inbounds float*, float** %2659, i64 %2661
%2663 = load float*, float** %2662
%2664 = load i32, i32* %60
%2665 = sext i32 %2664 to i64
%2666 = getelementptr inbounds float, float* %2663, i64 %2665
%2667 = load float, float* %2666
%2668 = fmul float %2656, %2667
%2669 = load float***, float**** %41
%2670 = getelementptr inbounds float**, float*** %2669, i64 -1
%2671 = load float**, float*** %2670
%2672 = load i32, i32* %58
%2673 = sext i32 %2672 to i64
%2674 = getelementptr inbounds float*, float** %2671, i64 %2673
%2675 = load float*, float** %2674
%2676 = load i32, i32* %61
%2677 = sext i32 %2676 to i64
%2678 = getelementptr inbounds float, float* %2675, i64 %2677
%2679 = load float, float* %2678
%2680 = load float**, float*** %54
%2681 = getelementptr inbounds float*, float** %2680, i64 0
%2682 = load float*, float** %2681
%2683 = load i32, i32* %58
%2684 = sext i32 %2683 to i64
%2685 = getelementptr inbounds float, float* %2682, i64 %2684
%2686 = load float, float* %2685
%2687 = call float @llvm.fmuladd.f32(float %2668, float %2679, float %2686)
store float %2687, float* %2685
%2688 = load float***, float**** %41
%2689 = getelementptr inbounds float**, float*** %2688, i64 -1
%2690 = load float**, float*** %2689
%2691 = load i32, i32* %58
%2692 = sext i32 %2691 to i64
%2693 = getelementptr inbounds float*, float** %2690, i64 %2692
%2694 = load float*, float** %2693
%2695 = load i32, i32* %60
%2696 = sext i32 %2695 to i64
%2697 = getelementptr inbounds float, float* %2694, i64 %2696
%2698 = load float, float* %2697
%2699 = load float***, float**** %41
%2700 = getelementptr inbounds float**, float*** %2699, i64 -1
%2701 = load float**, float*** %2700
%2702 = load i32, i32* %58
%2703 = sext i32 %2702 to i64
%2704 = getelementptr inbounds float*, float** %2701, i64 %2703
%2705 = load float*, float** %2704
%2706 = load i32, i32* %61
%2707 = sext i32 %2706 to i64
%2708 = getelementptr inbounds float, float* %2705, i64 %2707
%2709 = load float, float* %2708
%2710 = load float, float* %70
%2711 = call float @llvm.fmuladd.f32(float %2698, float %2709, float %2710)
store float %2711, float* %70
br label %2712
2712: ; preds = %2620, %2607, %2594, %2590
br label %2713
2713: ; preds = %2712
%2714 = load i32, i32* %61
%2715 = add nsw i32 %2714, 1
store i32 %2715, i32* %61
br label %2582
2716: ; preds = %2582
br label %2717
2717: ; preds = %2716
%2718 = load i32, i32* %60
%2719 = add nsw i32 %2718, 1
store i32 %2719, i32* %60
br label %2573
2720: ; preds = %2573
br label %2721
2721: ; preds = %2720, %2569
%2722 = load i32, i32* %66
%2723 = icmp ne i32 %2722, 0
br i1 %2723, label %2724, label %2735
2724: ; preds = %2721
%2725 = load i32, i32* %66
%2726 = sitofp i32 %2725 to float
%2727 = load float**, float*** %53
%2728 = getelementptr inbounds float*, float** %2727, i64 0
%2729 = load float*, float** %2728
%2730 = load i32, i32* %58
%2731 = sext i32 %2730 to i64
%2732 = getelementptr inbounds float, float* %2729, i64 %2731
%2733 = load float, float* %2732
%2734 = fdiv float %2733, %2726
store float %2734, float* %2732
br label %2743
2735: ; preds = %2721
%2736 = load float, float* @HUGE_VAL
%2737 = load float**, float*** %53
%2738 = getelementptr inbounds float*, float** %2737, i64 0
%2739 = load float*, float** %2738
%2740 = load i32, i32* %58
%2741 = sext i32 %2740 to i64
%2742 = getelementptr inbounds float, float* %2739, i64 %2741
store float %2736, float* %2742
br label %2743
2743: ; preds = %2735, %2724
%2744 = load float, float* %70
%2745 = fcmp une float %2744, 0.000000e+00
br i1 %2745, label %2746, label %2756
2746: ; preds = %2743
%2747 = load float, float* %70
%2748 = load float**, float*** %54
%2749 = getelementptr inbounds float*, float** %2748, i64 0
%2750 = load float*, float** %2749
%2751 = load i32, i32* %58
%2752 = sext i32 %2751 to i64
%2753 = getelementptr inbounds float, float* %2750, i64 %2752
%2754 = load float, float* %2753
%2755 = fdiv float %2754, %2747
store float %2755, float* %2753
br label %2764
2756: ; preds = %2743
%2757 = load float, float* @HUGE_VAL
%2758 = load float**, float*** %54
%2759 = getelementptr inbounds float*, float** %2758, i64 0
%2760 = load float*, float** %2759
%2761 = load i32, i32* %58
%2762 = sext i32 %2761 to i64
%2763 = getelementptr inbounds float, float* %2760, i64 %2762
store float %2757, float* %2763
br label %2764
2764: ; preds = %2756, %2746
br label %2765
2765: ; preds = %2764
%2766 = load i32, i32* %58
%2767 = add nsw i32 %2766, 1
store i32 %2767, i32* %58
br label %1830
2768: ; preds = %1830
store i32 0, i32* %62
br label %2769
2769: ; preds = %2887, %2768
%2770 = load i32, i32* %62
%2771 = load i32, i32* %30
%2772 = icmp sle i32 %2770, %2771
br i1 %2772, label %2773, label %2890
2773: ; preds = %2769
%2774 = load float**, float*** %54
%2775 = load i32, i32* %62
%2776 = sext i32 %2775 to i64
%2777 = getelementptr inbounds float*, float** %2774, i64 %2776
%2778 = load float*, float** %2777
%2779 = getelementptr inbounds float, float* %2778, i64 0
store float 0.000000e+00, float* %2779
%2780 = load float**, float*** %53
%2781 = load i32, i32* %62
%2782 = sext i32 %2781 to i64
%2783 = getelementptr inbounds float*, float** %2780, i64 %2782
%2784 = load float*, float** %2783
%2785 = getelementptr inbounds float, float* %2784, i64 0
store float 0.000000e+00, float* %2785
%2786 = load float**, float*** %52
%2787 = load i32, i32* %62
%2788 = sext i32 %2787 to i64
%2789 = getelementptr inbounds float*, float** %2786, i64 %2788
%2790 = load float*, float** %2789
%2791 = getelementptr inbounds float, float* %2790, i64 0
store float 0.000000e+00, float* %2791
%2792 = load float**, float*** %51
%2793 = load i32, i32* %62
%2794 = sext i32 %2793 to i64
%2795 = getelementptr inbounds float*, float** %2792, i64 %2794
%2796 = load float*, float** %2795
%2797 = getelementptr inbounds float, float* %2796, i64 0
store float 0.000000e+00, float* %2797
store i32 1, i32* %58
br label %2798
2798: ; preds = %2883, %2773
%2799 = load i32, i32* %58
%2800 = load i32, i32* %32
%2801 = icmp sle i32 %2799, %2800
br i1 %2801, label %2802, label %2886
2802: ; preds = %2798
%2803 = load float**, float*** %51
%2804 = load i32, i32* %62
%2805 = sext i32 %2804 to i64
%2806 = getelementptr inbounds float*, float** %2803, i64 %2805
%2807 = load float*, float** %2806
%2808 = load i32, i32* %58
%2809 = sext i32 %2808 to i64
%2810 = getelementptr inbounds float, float* %2807, i64 %2809
%2811 = load float, float* %2810
%2812 = load i32, i32* %32
%2813 = sitofp i32 %2812 to float
%2814 = fdiv float %2811, %2813
%2815 = load float**, float*** %51
%2816 = load i32, i32* %62
%2817 = sext i32 %2816 to i64
%2818 = getelementptr inbounds float*, float** %2815, i64 %2817
%2819 = load float*, float** %2818
%2820 = getelementptr inbounds float, float* %2819, i64 0
%2821 = load float, float* %2820
%2822 = fadd float %2821, %2814
store float %2822, float* %2820
%2823 = load float**, float*** %52
%2824 = load i32, i32* %62
%2825 = sext i32 %2824 to i64
%2826 = getelementptr inbounds float*, float** %2823, i64 %2825
%2827 = load float*, float** %2826
%2828 = load i32, i32* %58
%2829 = sext i32 %2828 to i64
%2830 = getelementptr inbounds float, float* %2827, i64 %2829
%2831 = load float, float* %2830
%2832 = load i32, i32* %32
%2833 = sitofp i32 %2832 to float
%2834 = fdiv float %2831, %2833
%2835 = load float**, float*** %52
%2836 = load i32, i32* %62
%2837 = sext i32 %2836 to i64
%2838 = getelementptr inbounds float*, float** %2835, i64 %2837
%2839 = load float*, float** %2838
%2840 = getelementptr inbounds float, float* %2839, i64 0
%2841 = load float, float* %2840
%2842 = fadd float %2841, %2834
store float %2842, float* %2840
%2843 = load float**, float*** %53
%2844 = load i32, i32* %62
%2845 = sext i32 %2844 to i64
%2846 = getelementptr inbounds float*, float** %2843, i64 %2845
%2847 = load float*, float** %2846
%2848 = load i32, i32* %58
%2849 = sext i32 %2848 to i64
%2850 = getelementptr inbounds float, float* %2847, i64 %2849
%2851 = load float, float* %2850
%2852 = load i32, i32* %32
%2853 = sitofp i32 %2852 to float
%2854 = fdiv float %2851, %2853
%2855 = load float**, float*** %53
%2856 = load i32, i32* %62
%2857 = sext i32 %2856 to i64
%2858 = getelementptr inbounds float*, float** %2855, i64 %2857
%2859 = load float*, float** %2858
%2860 = getelementptr inbounds float, float* %2859, i64 0
%2861 = load float, float* %2860
%2862 = fadd float %2861, %2854
store float %2862, float* %2860
%2863 = load float**, float*** %54
%2864 = load i32, i32* %62
%2865 = sext i32 %2864 to i64
%2866 = getelementptr inbounds float*, float** %2863, i64 %2865
%2867 = load float*, float** %2866
%2868 = load i32, i32* %58
%2869 = sext i32 %2868 to i64
%2870 = getelementptr inbounds float, float* %2867, i64 %2869
%2871 = load float, float* %2870
%2872 = load i32, i32* %32
%2873 = sitofp i32 %2872 to float
%2874 = fdiv float %2871, %2873
%2875 = load float**, float*** %54
%2876 = load i32, i32* %62
%2877 = sext i32 %2876 to i64
%2878 = getelementptr inbounds float*, float** %2875, i64 %2877
%2879 = load float*, float** %2878
%2880 = getelementptr inbounds float, float* %2879, i64 0
%2881 = load float, float* %2880
%2882 = fadd float %2881, %2874
store float %2882, float* %2880
br label %2883
2883: ; preds = %2802
%2884 = load i32, i32* %58
%2885 = add nsw i32 %2884, 1
store i32 %2885, i32* %58
br label %2798
2886: ; preds = %2798
br label %2887
2887: ; preds = %2886
%2888 = load i32, i32* %62
%2889 = add nsw i32 %2888, 1
store i32 %2889, i32* %62
br label %2769
2890: ; preds = %2769
store i32 0, i32* %62
br label %2891
2891: ; preds = %2908, %2890
%2892 = load i32, i32* %62
%2893 = load i32, i32* %30
%2894 = icmp sle i32 %2892, %2893
br i1 %2894, label %2895, label %2911
2895: ; preds = %2891
%2896 = load float**, float*** %56
%2897 = load i32, i32* %62
%2898 = sext i32 %2897 to i64
%2899 = getelementptr inbounds float*, float** %2896, i64 %2898
%2900 = load float*, float** %2899
%2901 = getelementptr inbounds float, float* %2900, i64 0
store float 0.000000e+00, float* %2901
%2902 = load float**, float*** %55
%2903 = load i32, i32* %62
%2904 = sext i32 %2903 to i64
%2905 = getelementptr inbounds float*, float** %2902, i64 %2904
%2906 = load float*, float** %2905
%2907 = getelementptr inbounds float, float* %2906, i64 0
store float 0.000000e+00, float* %2907
br label %2908
2908: ; preds = %2895
%2909 = load i32, i32* %62
%2910 = add nsw i32 %2909, 1
store i32 %2910, i32* %62
br label %2891
2911: ; preds = %2891
store i32 1, i32* %58
br label %2912
2912: ; preds = %3117, %2911
%2913 = load i32, i32* %58
%2914 = load i32, i32* %32
%2915 = icmp sle i32 %2913, %2914
br i1 %2915, label %2916, label %3120
2916: ; preds = %2912
store i32 0, i32* %62
br label %2917
2917: ; preds = %3113, %2916
%2918 = load i32, i32* %62
%2919 = load i32, i32* %30
%2920 = icmp sle i32 %2918, %2919
br i1 %2920, label %2921, label %3116
2921: ; preds = %2917
%2922 = load i32**, i32*** %45
%2923 = load i32, i32* %62
%2924 = sext i32 %2923 to i64
%2925 = getelementptr inbounds i32*, i32** %2922, i64 %2924
%2926 = load i32*, i32** %2925
%2927 = load i32, i32* %58
%2928 = sext i32 %2927 to i64
%2929 = getelementptr inbounds i32, i32* %2926, i64 %2928
%2930 = load i32, i32* %2929
%2931 = icmp sgt i32 %2930, 1
br i1 %2931, label %2932, label %3054
2932: ; preds = %2921
store float 0.000000e+00, float* %72
store float 0.000000e+00, float* %71
store i32 1, i32* %59
br label %2933
2933: ; preds = %3003, %2932
%2934 = load i32, i32* %59
%2935 = load i32*, i32** %37
%2936 = load i32, i32* %58
%2937 = sext i32 %2936 to i64
%2938 = getelementptr inbounds i32, i32* %2935, i64 %2937
%2939 = load i32, i32* %2938
%2940 = icmp sle i32 %2934, %2939
br i1 %2940, label %2941, label %3006
2941: ; preds = %2933
%2942 = load float***, float**** %41
%2943 = load i32, i32* %62
%2944 = sext i32 %2943 to i64
%2945 = getelementptr inbounds float**, float*** %2942, i64 %2944
%2946 = load float**, float*** %2945
%2947 = load i32, i32* %58
%2948 = sext i32 %2947 to i64
%2949 = getelementptr inbounds float*, float** %2946, i64 %2948
%2950 = load float*, float** %2949
%2951 = load i32, i32* %59
%2952 = sext i32 %2951 to i64
%2953 = getelementptr inbounds float, float* %2950, i64 %2952
%2954 = load float, float* %2953
%2955 = load i32**, i32*** %38
%2956 = load i32, i32* %58
%2957 = sext i32 %2956 to i64
%2958 = getelementptr inbounds i32*, i32** %2955, i64 %2957
%2959 = load i32*, i32** %2958
%2960 = load i32, i32* %59
%2961 = sext i32 %2960 to i64
%2962 = getelementptr inbounds i32, i32* %2959, i64 %2961
%2963 = load i32, i32* %2962
%2964 = sitofp i32 %2963 to float
%2965 = load float, float* %71
%2966 = call float @llvm.fmuladd.f32(float %2954, float %2964, float %2965)
store float %2966, float* %71
%2967 = load float***, float**** %41
%2968 = load i32, i32* %62
%2969 = sext i32 %2968 to i64
%2970 = getelementptr inbounds float**, float*** %2967, i64 %2969
%2971 = load float**, float*** %2970
%2972 = load i32, i32* %58
%2973 = sext i32 %2972 to i64
%2974 = getelementptr inbounds float*, float** %2971, i64 %2973
%2975 = load float*, float** %2974
%2976 = load i32, i32* %59
%2977 = sext i32 %2976 to i64
%2978 = getelementptr inbounds float, float* %2975, i64 %2977
%2979 = load float, float* %2978
%2980 = load i32**, i32*** %38
%2981 = load i32, i32* %58
%2982 = sext i32 %2981 to i64
%2983 = getelementptr inbounds i32*, i32** %2980, i64 %2982
%2984 = load i32*, i32** %2983
%2985 = load i32, i32* %59
%2986 = sext i32 %2985 to i64
%2987 = getelementptr inbounds i32, i32* %2984, i64 %2986
%2988 = load i32, i32* %2987
%2989 = sitofp i32 %2988 to float
%2990 = fmul float %2979, %2989
%2991 = load i32**, i32*** %38
%2992 = load i32, i32* %58
%2993 = sext i32 %2992 to i64
%2994 = getelementptr inbounds i32*, i32** %2991, i64 %2993
%2995 = load i32*, i32** %2994
%2996 = load i32, i32* %59
%2997 = sext i32 %2996 to i64
%2998 = getelementptr inbounds i32, i32* %2995, i64 %2997
%2999 = load i32, i32* %2998
%3000 = sitofp i32 %2999 to float
%3001 = load float, float* %72
%3002 = call float @llvm.fmuladd.f32(float %2990, float %3000, float %3001)
store float %3002, float* %72
br label %3003
3003: ; preds = %2941
%3004 = load i32, i32* %59
%3005 = add nsw i32 %3004, 1
store i32 %3005, i32* %59
br label %2933
3006: ; preds = %2933
%3007 = load float, float* %71
%3008 = load float**, float*** %55
%3009 = load i32, i32* %62
%3010 = sext i32 %3009 to i64
%3011 = getelementptr inbounds float*, float** %3008, i64 %3010
%3012 = load float*, float** %3011
%3013 = load i32, i32* %58
%3014 = sext i32 %3013 to i64
%3015 = getelementptr inbounds float, float* %3012, i64 %3014
store float %3007, float* %3015
%3016 = load float, float* %72
%3017 = load float, float* %71
%3018 = load float, float* %71
%3019 = fneg float %3017
%3020 = call float @llvm.fmuladd.f32(float %3019, float %3018, float %3016)
%3021 = fpext float %3020 to double
%3022 = load i32**, i32*** %45
%3023 = load i32, i32* %62
%3024 = sext i32 %3023 to i64
%3025 = getelementptr inbounds i32*, i32** %3022, i64 %3024
%3026 = load i32*, i32** %3025
%3027 = load i32, i32* %58
%3028 = sext i32 %3027 to i64
%3029 = getelementptr inbounds i32, i32* %3026, i64 %3028
%3030 = load i32, i32* %3029
%3031 = sitofp i32 %3030 to double
%3032 = load i32**, i32*** %45
%3033 = load i32, i32* %62
%3034 = sext i32 %3033 to i64
%3035 = getelementptr inbounds i32*, i32** %3032, i64 %3034
%3036 = load i32*, i32** %3035
%3037 = load i32, i32* %58
%3038 = sext i32 %3037 to i64
%3039 = getelementptr inbounds i32, i32* %3036, i64 %3038
%3040 = load i32, i32* %3039
%3041 = sitofp i32 %3040 to double
%3042 = fsub double %3041, 1.000000e+00
%3043 = fdiv double %3031, %3042
%3044 = fmul double %3021, %3043
%3045 = fptrunc double %3044 to float
%3046 = load float**, float*** %56
%3047 = load i32, i32* %62
%3048 = sext i32 %3047 to i64
%3049 = getelementptr inbounds float*, float** %3046, i64 %3048
%3050 = load float*, float** %3049
%3051 = load i32, i32* %58
%3052 = sext i32 %3051 to i64
%3053 = getelementptr inbounds float, float* %3050, i64 %3052
store float %3045, float* %3053
br label %3072
3054: ; preds = %2921
%3055 = load float, float* @HUGE_VAL
%3056 = load float**, float*** %56
%3057 = load i32, i32* %62
%3058 = sext i32 %3057 to i64
%3059 = getelementptr inbounds float*, float** %3056, i64 %3058
%3060 = load float*, float** %3059
%3061 = load i32, i32* %58
%3062 = sext i32 %3061 to i64
%3063 = getelementptr inbounds float, float* %3060, i64 %3062
store float %3055, float* %3063
%3064 = load float**, float*** %55
%3065 = load i32, i32* %62
%3066 = sext i32 %3065 to i64
%3067 = getelementptr inbounds float*, float** %3064, i64 %3066
%3068 = load float*, float** %3067
%3069 = load i32, i32* %58
%3070 = sext i32 %3069 to i64
%3071 = getelementptr inbounds float, float* %3068, i64 %3070
store float %3055, float* %3071
br label %3072
3072: ; preds = %3054, %3006
%3073 = load float**, float*** %55
%3074 = load i32, i32* %62
%3075 = sext i32 %3074 to i64
%3076 = getelementptr inbounds float*, float** %3073, i64 %3075
%3077 = load float*, float** %3076
%3078 = load i32, i32* %58
%3079 = sext i32 %3078 to i64
%3080 = getelementptr inbounds float, float* %3077, i64 %3079
%3081 = load float, float* %3080
%3082 = load i32, i32* %32
%3083 = sitofp i32 %3082 to float
%3084 = fdiv float %3081, %3083
%3085 = load float**, float*** %55
%3086 = load i32, i32* %62
%3087 = sext i32 %3086 to i64
%3088 = getelementptr inbounds float*, float** %3085, i64 %3087
%3089 = load float*, float** %3088
%3090 = getelementptr inbounds float, float* %3089, i64 0
%3091 = load float, float* %3090
%3092 = fadd float %3091, %3084
store float %3092, float* %3090
%3093 = load float**, float*** %56
%3094 = load i32, i32* %62
%3095 = sext i32 %3094 to i64
%3096 = getelementptr inbounds float*, float** %3093, i64 %3095
%3097 = load float*, float** %3096
%3098 = load i32, i32* %58
%3099 = sext i32 %3098 to i64
%3100 = getelementptr inbounds float, float* %3097, i64 %3099
%3101 = load float, float* %3100
%3102 = load i32, i32* %32
%3103 = sitofp i32 %3102 to float
%3104 = fdiv float %3101, %3103
%3105 = load float**, float*** %56
%3106 = load i32, i32* %62
%3107 = sext i32 %3106 to i64
%3108 = getelementptr inbounds float*, float** %3105, i64 %3107
%3109 = load float*, float** %3108
%3110 = getelementptr inbounds float, float* %3109, i64 0
%3111 = load float, float* %3110
%3112 = fadd float %3111, %3104
store float %3112, float* %3110
br label %3113
3113: ; preds = %3072
%3114 = load i32, i32* %62
%3115 = add nsw i32 %3114, 1
store i32 %3115, i32* %62
br label %2917
3116: ; preds = %2917
br label %3117
3117: ; preds = %3116
%3118 = load i32, i32* %58
%3119 = add nsw i32 %3118, 1
store i32 %3119, i32* %58
br label %2912
3120: ; preds = %2912
%3121 = load float**, float*** %73
%3122 = load i32, i32* %30
%3123 = load i32, i32* %32
%3124 = call i32 @free_matrix(float** %3121, i32 0, i32 %3122, i32 0, i32 %3123)
%3125 = load i32*, i32** %74
%3126 = load i32, i32* %30
%3127 = call i32 @free_ivector(i32* %3125, i32 0, i32 %3126)
ret void
}

LLVM IR (-O2):
@HUGE_VAL = global float 0.000000e+00
define void @compute_allele_freq(i32 %0, i32 %1, i32* nocapture %2, i32 %3, i32 %4, i32 %5, i32*** nocapture %6, i32* nocapture %7, i32* nocapture %8, i32** nocapture %9, float*** nocapture %10, i32 %11, float*** nocapture %12, i32** nocapture %13, i32** nocapture %14, i32** nocapture %15, i32** nocapture %16, float** nocapture %17, float** nocapture %18, i32* nocapture %19, float** nocapture %20, float** nocapture %21, float** nocapture %22, float** nocapture %23, float** nocapture %24, float** nocapture %25, float** nocapture %26, float** nocapture %27) {
%29 = tail call i32* @ivector(i32 0, i32 %1)
%30 = icmp slt i32 %1, 0
br i1 %30, label %36, label %31
31: ; preds = %28
%32 = bitcast i32* %29 to i8*
%33 = zext i32 %1 to i64
%34 = shl nuw nsw i64 %33, 2
%35 = add nuw nsw i64 %34, 4
br label %36
36: ; preds = %31, %28
%37 = icmp slt i32 %0, 1
br i1 %37, label %42, label %38
38: ; preds = %36
%39 = icmp eq i32 %1, 0
%40 = add nuw i32 %0, 1
%41 = zext i32 %40 to i64
br label %118
42: ; preds = %133, %36
%43 = icmp slt i32 %3, 1
br i1 %43, label %145, label %44
44: ; preds = %42
%45 = add nuw i32 %3, 1
%46 = zext i32 %45 to i64
%47 = add nsw i64 %46, -1
%48 = icmp ult i64 %47, 8
br i1 %48, label %115, label %49
49: ; preds = %44
%50 = and i64 %47, -8
%51 = or i64 %50, 1
%52 = add nsw i64 %50, -8
%53 = lshr exact i64 %52, 3
%54 = add nuw nsw i64 %53, 1
%55 = and i64 %54, 1
%56 = icmp eq i64 %52, 0
br i1 %56, label %89, label %57
57: ; preds = %49
%58 = and i64 %54, 4611686018427387902
br label %59
59: ; preds = %59, %57
%60 = phi i64 [ 0, %57 ], [ %86, %59 ]
%61 = phi <4 x i32> [ zeroinitializer, %57 ], [ %84, %59 ]
%62 = phi <4 x i32> [ zeroinitializer, %57 ], [ %85, %59 ]
%63 = phi i64 [ 0, %57 ], [ %87, %59 ]
%64 = or i64 %60, 1
%65 = getelementptr inbounds i32, i32* %8, i64 %64
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = getelementptr inbounds i32, i32* %65, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
%70 = load <4 x i32>, <4 x i32>* %69
%71 = icmp sgt <4 x i32> %67, %61
%72 = icmp sgt <4 x i32> %70, %62
%73 = select <4 x i1> %71, <4 x i32> %67, <4 x i32> %61
%74 = select <4 x i1> %72, <4 x i32> %70, <4 x i32> %62
%75 = or i64 %60, 9
%76 = getelementptr inbounds i32, i32* %8, i64 %75
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = getelementptr inbounds i32, i32* %76, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = icmp sgt <4 x i32> %78, %73
%83 = icmp sgt <4 x i32> %81, %74
%84 = select <4 x i1> %82, <4 x i32> %78, <4 x i32> %73
%85 = select <4 x i1> %83, <4 x i32> %81, <4 x i32> %74
%86 = add nuw i64 %60, 16
%87 = add i64 %63, 2
%88 = icmp eq i64 %87, %58
br i1 %88, label %89, label %59
89: ; preds = %59, %49
%90 = phi <4 x i32> [ undef, %49 ], [ %84, %59 ]
%91 = phi <4 x i32> [ undef, %49 ], [ %85, %59 ]
%92 = phi i64 [ 0, %49 ], [ %86, %59 ]
%93 = phi <4 x i32> [ zeroinitializer, %49 ], [ %84, %59 ]
%94 = phi <4 x i32> [ zeroinitializer, %49 ], [ %85, %59 ]
%95 = icmp eq i64 %55, 0
br i1 %95, label %108, label %96
96: ; preds = %89
%97 = or i64 %92, 1
%98 = getelementptr inbounds i32, i32* %8, i64 %97
%99 = bitcast i32* %98 to <4 x i32>*
%100 = load <4 x i32>, <4 x i32>* %99
%101 = getelementptr inbounds i32, i32* %98, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
%103 = load <4 x i32>, <4 x i32>* %102
%104 = icmp sgt <4 x i32> %100, %93
%105 = icmp sgt <4 x i32> %103, %94
%106 = select <4 x i1> %104, <4 x i32> %100, <4 x i32> %93
%107 = select <4 x i1> %105, <4 x i32> %103, <4 x i32> %94
br label %108
108: ; preds = %89, %96
%109 = phi <4 x i32> [ %90, %89 ], [ %106, %96 ]
%110 = phi <4 x i32> [ %91, %89 ], [ %107, %96 ]
%111 = icmp sgt <4 x i32> %109, %110
%112 = select <4 x i1> %111, <4 x i32> %109, <4 x i32> %110
%113 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %112)
%114 = icmp eq i64 %47, %50
br i1 %114, label %145, label %115
115: ; preds = %44, %108
%116 = phi i64 [ 1, %44 ], [ %51, %108 ]
%117 = phi i32 [ 0, %44 ], [ %113, %108 ]
br label %136
118: ; preds = %38, %133
%119 = phi i64 [ 1, %38 ], [ %134, %133 ]
%120 = load i32, i32* %29
%121 = add nsw i32 %120, 1
store i32 %121, i32* %29
br i1 %39, label %133, label %122
122: ; preds = %118
%123 = getelementptr inbounds i32, i32* %2, i64 %119
%124 = load i32, i32* %123
%125 = icmp sgt i32 %124, %1
br i1 %125, label %131, label %126
126: ; preds = %122
%127 = sext i32 %124 to i64
%128 = getelementptr inbounds i32, i32* %29, i64 %127
%129 = load i32, i32* %128
%130 = add nsw i32 %129, 1
store i32 %130, i32* %128
br label %133
131: ; preds = %122
%132 = tail call i32 @exit(i32 133)
unreachable
133: ; preds = %118, %126
%134 = add nuw nsw i64 %119, 1
%135 = icmp eq i64 %134, %41
br i1 %135, label %42, label %118
136: ; preds = %115, %136
%137 = phi i64 [ %143, %136 ], [ %116, %115 ]
%138 = phi i32 [ %142, %136 ], [ %117, %115 ]
%139 = getelementptr inbounds i32, i32* %8, i64 %137
%140 = load i32, i32* %139
%141 = icmp sgt i32 %140, %138
%142 = select i1 %141, i32 %140, i32 %138
%143 = add nuw nsw i64 %137, 1
%144 = icmp eq i64 %143, %46
br i1 %144, label %145, label %136
145: ; preds = %136, %108, %42
%146 = phi i32 [ 0, %42 ], [ %113, %108 ], [ %142, %136 ]
%147 = tail call float** @matrix(i32 0, i32 %1, i32 0, i32 %3)
%148 = tail call i32*** @i3tensor(i32 -1, i32 %1, i32 0, i32 %3, i32 0, i32 %146)
%149 = tail call float** @matrix(i32 0, i32 %1, i32 0, i32 %3)
br i1 %30, label %253, label %150
150: ; preds = %145
%151 = icmp slt i32 %3, 0
%152 = add i32 %3, 1
%153 = add nuw i32 %1, 1
%154 = zext i32 %153 to i64
%155 = zext i32 %152 to i64
%156 = and i64 %155, 4294967288
%157 = add nsw i64 %156, -8
%158 = lshr exact i64 %157, 3
%159 = add nuw nsw i64 %158, 1
%160 = icmp ult i32 %152, 8
%161 = and i64 %155, 4294967288
%162 = and i64 %159, 1
%163 = icmp eq i64 %157, 0
%164 = and i64 %159, 4611686018427387902
%165 = icmp eq i64 %162, 0
%166 = icmp eq i64 %161, %155
%167 = and i64 %155, 1
%168 = icmp eq i64 %167, 0
%169 = sub nsw i64 0, %155
br label %170
170: ; preds = %150, %272
%171 = phi i64 [ 0, %150 ], [ %273, %272 ]
br i1 %151, label %272, label %172
172: ; preds = %170
%173 = getelementptr inbounds i32*, i32** %15, i64 %171
%174 = load i32*, i32** %173
%175 = getelementptr inbounds i32*, i32** %14, i64 %171
%176 = load i32*, i32** %175
%177 = getelementptr inbounds i32*, i32** %16, i64 %171
%178 = load i32*, i32** %177
br i1 %160, label %242, label %179
179: ; preds = %172
%180 = getelementptr i32, i32* %174, i64 %155
%181 = getelementptr i32, i32* %176, i64 %155
%182 = getelementptr i32, i32* %178, i64 %155
%183 = icmp ult i32* %174, %181
%184 = icmp ult i32* %176, %180
%185 = and i1 %183, %184
%186 = icmp ult i32* %174, %182
%187 = icmp ult i32* %178, %180
%188 = and i1 %186, %187
%189 = or i1 %185, %188
%190 = icmp ult i32* %176, %182
%191 = icmp ult i32* %178, %181
%192 = and i1 %190, %191
%193 = or i1 %189, %192
br i1 %193, label %242, label %194
194: ; preds = %179
br i1 %163, label %226, label %195
195: ; preds = %194, %195
%196 = phi i64 [ %223, %195 ], [ 0, %194 ]
%197 = phi i64 [ %224, %195 ], [ 0, %194 ]
%198 = getelementptr inbounds i32, i32* %174, i64 %196
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %199
%200 = getelementptr inbounds i32, i32* %198, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %201
%202 = getelementptr inbounds i32, i32* %176, i64 %196
%203 = bitcast i32* %202 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %203
%204 = getelementptr inbounds i32, i32* %202, i64 4
%205 = bitcast i32* %204 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %205
%206 = getelementptr inbounds i32, i32* %178, i64 %196
%207 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %207
%208 = getelementptr inbounds i32, i32* %206, i64 4
%209 = bitcast i32* %208 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %209
%210 = or i64 %196, 8
%211 = getelementptr inbounds i32, i32* %174, i64 %210
%212 = bitcast i32* %211 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %212
%213 = getelementptr inbounds i32, i32* %211, i64 4
%214 = bitcast i32* %213 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %214
%215 = getelementptr inbounds i32, i32* %176, i64 %210
%216 = bitcast i32* %215 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %216
%217 = getelementptr inbounds i32, i32* %215, i64 4
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %218
%219 = getelementptr inbounds i32, i32* %178, i64 %210
%220 = bitcast i32* %219 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %220
%221 = getelementptr inbounds i32, i32* %219, i64 4
%222 = bitcast i32* %221 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %222
%223 = add nuw i64 %196, 16
%224 = add i64 %197, 2
%225 = icmp eq i64 %224, %164
br i1 %225, label %226, label %195
226: ; preds = %195, %194
%227 = phi i64 [ 0, %194 ], [ %223, %195 ]
br i1 %165, label %241, label %228
228: ; preds = %226
%229 = getelementptr inbounds i32, i32* %174, i64 %227
%230 = bitcast i32* %229 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %230
%231 = getelementptr inbounds i32, i32* %229, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %232
%233 = getelementptr inbounds i32, i32* %176, i64 %227
%234 = bitcast i32* %233 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %234
%235 = getelementptr inbounds i32, i32* %233, i64 4
%236 = bitcast i32* %235 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %236
%237 = getelementptr inbounds i32, i32* %178, i64 %227
%238 = bitcast i32* %237 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %238
%239 = getelementptr inbounds i32, i32* %237, i64 4
%240 = bitcast i32* %239 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %240
br label %241
241: ; preds = %226, %228
br i1 %166, label %272, label %242
242: ; preds = %179, %172, %241
%243 = phi i64 [ 0, %179 ], [ 0, %172 ], [ %161, %241 ]
%244 = xor i64 %243, -1
br i1 %168, label %250, label %245
245: ; preds = %242
%246 = getelementptr inbounds i32, i32* %174, i64 %243
store i32 0, i32* %246
%247 = getelementptr inbounds i32, i32* %176, i64 %243
store i32 0, i32* %247
%248 = getelementptr inbounds i32, i32* %178, i64 %243
store i32 0, i32* %248
%249 = or i64 %243, 1
br label %250
250: ; preds = %245, %242
%251 = phi i64 [ %243, %242 ], [ %249, %245 ]
%252 = icmp eq i64 %244, %169
br i1 %252, label %272, label %261
253: ; preds = %272, %145
%254 = icmp slt i32 %1, -1
br i1 %254, label %280, label %255
255: ; preds = %253
%256 = icmp slt i32 %3, 0
%257 = add i32 %3, 1
%258 = add nuw i32 %1, 1
%259 = zext i32 %258 to i64
%260 = zext i32 %257 to i64
br label %275
261: ; preds = %250, %261
%262 = phi i64 [ %270, %261 ], [ %251, %250 ]
%263 = getelementptr inbounds i32, i32* %174, i64 %262
store i32 0, i32* %263
%264 = getelementptr inbounds i32, i32* %176, i64 %262
store i32 0, i32* %264
%265 = getelementptr inbounds i32, i32* %178, i64 %262
store i32 0, i32* %265
%266 = add nuw nsw i64 %262, 1
%267 = getelementptr inbounds i32, i32* %174, i64 %266
store i32 0, i32* %267
%268 = getelementptr inbounds i32, i32* %176, i64 %266
store i32 0, i32* %268
%269 = getelementptr inbounds i32, i32* %178, i64 %266
store i32 0, i32* %269
%270 = add nuw nsw i64 %262, 2
%271 = icmp eq i64 %270, %155
br i1 %271, label %272, label %261
272: ; preds = %250, %261, %241, %170
%273 = add nuw nsw i64 %171, 1
%274 = icmp eq i64 %273, %154
br i1 %274, label %253, label %170
275: ; preds = %255, %323
%276 = phi i64 [ -1, %255 ], [ %324, %323 ]
br i1 %256, label %323, label %277
277: ; preds = %275
%278 = getelementptr inbounds i32**, i32*** %148, i64 %276
%279 = getelementptr inbounds float**, float*** %12, i64 %276
br label %300
280: ; preds = %323, %253
br i1 %30, label %413, label %281
281: ; preds = %280
%282 = icmp slt i32 %3, 0
%283 = add i32 %3, 1
%284 = add nuw i32 %1, 1
%285 = zext i32 %284 to i64
%286 = zext i32 %283 to i64
%287 = and i64 %286, 4294967288
%288 = add nsw i64 %287, -8
%289 = lshr exact i64 %288, 3
%290 = add nuw nsw i64 %289, 1
%291 = icmp ult i32 %283, 8
%292 = and i64 %286, 4294967288
%293 = and i64 %290, 3
%294 = icmp ult i64 %288, 24
%295 = and i64 %290, 4611686018427387900
%296 = icmp eq i64 %293, 0
%297 = icmp eq i64 %292, %286
%298 = and i64 %286, 3
%299 = icmp eq i64 %298, 0
br label %326
300: ; preds = %277, %320
%301 = phi i64 [ 0, %277 ], [ %321, %320 ]
%302 = getelementptr inbounds i32, i32* %8, i64 %301
%303 = load i32, i32* %302
%304 = icmp slt i32 %303, 0
br i1 %304, label %320, label %305
305: ; preds = %300
%306 = load i32**, i32*** %278
%307 = getelementptr inbounds i32*, i32** %306, i64 %301
%308 = load i32*, i32** %307
%309 = load float**, float*** %279
%310 = getelementptr inbounds float*, float** %309, i64 %301
%311 = load float*, float** %310
br label %312
312: ; preds = %305, %312
%313 = phi i64 [ 0, %305 ], [ %316, %312 ]
%314 = getelementptr inbounds i32, i32* %308, i64 %313
store i32 0, i32* %314
%315 = getelementptr inbounds float, float* %311, i64 %313
store float 0.000000e+00, float* %315
%316 = add nuw nsw i64 %313, 1
%317 = load i32, i32* %302
%318 = sext i32 %317 to i64
%319 = icmp slt i64 %313, %318
br i1 %319, label %312, label %320
320: ; preds = %312, %300
%321 = add nuw nsw i64 %301, 1
%322 = icmp eq i64 %321, %260
br i1 %322, label %323, label %300
323: ; preds = %320, %275
%324 = add nsw i64 %276, 1
%325 = icmp eq i64 %324, %259
br i1 %325, label %280, label %275
326: ; preds = %281, %436
%327 = phi i64 [ 0, %281 ], [ %437, %436 ]
br i1 %282, label %436, label %328
328: ; preds = %326
%329 = getelementptr inbounds float*, float** %20, i64 %327
%330 = load float*, float** %329
%331 = getelementptr inbounds float*, float** %149, i64 %327
%332 = load float*, float** %331
br i1 %291, label %398, label %333
333: ; preds = %328
%334 = getelementptr float, float* %330, i64 %286
%335 = getelementptr float, float* %332, i64 %286
%336 = icmp ult float* %330, %335
%337 = icmp ult float* %332, %334
%338 = and i1 %336, %337
br i1 %338, label %398, label %339
339: ; preds = %333
br i1 %294, label %381, label %340
340: ; preds = %339, %340
%341 = phi i64 [ %378, %340 ], [ 0, %339 ]
%342 = phi i64 [ %379, %340 ], [ 0, %339 ]
%343 = getelementptr inbounds float, float* %330, i64 %341
%344 = bitcast float* %343 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %344
%345 = getelementptr inbounds float, float* %343, i64 4
%346 = bitcast float* %345 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %346
%347 = getelementptr inbounds float, float* %332, i64 %341
%348 = bitcast float* %347 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %348
%349 = getelementptr inbounds float, float* %347, i64 4
%350 = bitcast float* %349 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %350
%351 = or i64 %341, 8
%352 = getelementptr inbounds float, float* %330, i64 %351
%353 = bitcast float* %352 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %353
%354 = getelementptr inbounds float, float* %352, i64 4
%355 = bitcast float* %354 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %355
%356 = getelementptr inbounds float, float* %332, i64 %351
%357 = bitcast float* %356 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %357
%358 = getelementptr inbounds float, float* %356, i64 4
%359 = bitcast float* %358 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %359
%360 = or i64 %341, 16
%361 = getelementptr inbounds float, float* %330, i64 %360
%362 = bitcast float* %361 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %362
%363 = getelementptr inbounds float, float* %361, i64 4
%364 = bitcast float* %363 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %364
%365 = getelementptr inbounds float, float* %332, i64 %360
%366 = bitcast float* %365 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %366
%367 = getelementptr inbounds float, float* %365, i64 4
%368 = bitcast float* %367 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %368
%369 = or i64 %341, 24
%370 = getelementptr inbounds float, float* %330, i64 %369
%371 = bitcast float* %370 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %371
%372 = getelementptr inbounds float, float* %370, i64 4
%373 = bitcast float* %372 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %373
%374 = getelementptr inbounds float, float* %332, i64 %369
%375 = bitcast float* %374 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %375
%376 = getelementptr inbounds float, float* %374, i64 4
%377 = bitcast float* %376 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %377
%378 = add nuw i64 %341, 32
%379 = add i64 %342, 4
%380 = icmp eq i64 %379, %295
br i1 %380, label %381, label %340
381: ; preds = %340, %339
%382 = phi i64 [ 0, %339 ], [ %378, %340 ]
br i1 %296, label %397, label %383
383: ; preds = %381, %383
%384 = phi i64 [ %394, %383 ], [ %382, %381 ]
%385 = phi i64 [ %395, %383 ], [ 0, %381 ]
%386 = getelementptr inbounds float, float* %330, i64 %384
%387 = bitcast float* %386 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %387
%388 = getelementptr inbounds float, float* %386, i64 4
%389 = bitcast float* %388 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %389
%390 = getelementptr inbounds float, float* %332, i64 %384
%391 = bitcast float* %390 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %391
%392 = getelementptr inbounds float, float* %390, i64 4
%393 = bitcast float* %392 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %393
%394 = add nuw i64 %384, 8
%395 = add i64 %385, 1
%396 = icmp eq i64 %395, %293
br i1 %396, label %397, label %383
397: ; preds = %383, %381
br i1 %297, label %436, label %398
398: ; preds = %333, %328, %397
%399 = phi i64 [ 0, %333 ], [ 0, %328 ], [ %292, %397 ]
%400 = xor i64 %399, -1
%401 = add nsw i64 %400, %286
br i1 %299, label %410, label %402
402: ; preds = %398, %402
%403 = phi i64 [ %407, %402 ], [ %399, %398 ]
%404 = phi i64 [ %408, %402 ], [ 0, %398 ]
%405 = getelementptr inbounds float, float* %330, i64 %403
store float 0.000000e+00, float* %405
%406 = getelementptr inbounds float, float* %332, i64 %403
store float 0.000000e+00, float* %406
%407 = add nuw nsw i64 %403, 1
%408 = add i64 %404, 1
%409 = icmp eq i64 %408, %298
br i1 %409, label %410, label %402
410: ; preds = %402, %398
%411 = phi i64 [ %399, %398 ], [ %407, %402 ]
%412 = icmp ult i64 %401, 3
br i1 %412, label %436, label %421
413: ; preds = %436, %280
br i1 %37, label %445, label %414
414: ; preds = %413
%415 = icmp sgt i32 %1, 0
%416 = icmp eq i32 %1, 0
%417 = add i32 %3, 1
%418 = add nuw i32 %0, 1
%419 = zext i32 %418 to i64
%420 = zext i32 %417 to i64
br label %439
421: ; preds = %410, %421
%422 = phi i64 [ %434, %421 ], [ %411, %410 ]
%423 = getelementptr inbounds float, float* %330, i64 %422
store float 0.000000e+00, float* %423
%424 = getelementptr inbounds float, float* %332, i64 %422
store float 0.000000e+00, float* %424
%425 = add nuw nsw i64 %422, 1
%426 = getelementptr inbounds float, float* %330, i64 %425
store float 0.000000e+00, float* %426
%427 = getelementptr inbounds float, float* %332, i64 %425
store float 0.000000e+00, float* %427
%428 = add nuw nsw i64 %422, 2
%429 = getelementptr inbounds float, float* %330, i64 %428
store float 0.000000e+00, float* %429
%430 = getelementptr inbounds float, float* %332, i64 %428
store float 0.000000e+00, float* %430
%431 = add nuw nsw i64 %422, 3
%432 = getelementptr inbounds float, float* %330, i64 %431
store float 0.000000e+00, float* %432
%433 = getelementptr inbounds float, float* %332, i64 %431
store float 0.000000e+00, float* %433
%434 = add nuw nsw i64 %422, 4
%435 = icmp eq i64 %434, %286
br i1 %435, label %436, label %421
436: ; preds = %410, %421, %397, %326
%437 = add nuw nsw i64 %327, 1
%438 = icmp eq i64 %437, %285
br i1 %438, label %413, label %326
439: ; preds = %414, %741
%440 = phi i64 [ 1, %414 ], [ %742, %741 ]
br i1 %43, label %741, label %441
441: ; preds = %439
%442 = getelementptr inbounds i32, i32* %7, i64 %440
%443 = getelementptr inbounds i32**, i32*** %6, i64 %440
%444 = getelementptr inbounds i32, i32* %2, i64 %440
br label %451
445: ; preds = %741, %413
br i1 %43, label %752, label %446
446: ; preds = %445
%447 = add nuw i32 %1, 1
%448 = add nuw i32 %3, 1
%449 = zext i32 %448 to i64
%450 = zext i32 %447 to i64
br label %744
451: ; preds = %441, %738
%452 = phi i64 [ 1, %441 ], [ %739, %738 ]
%453 = load i32, i32* %442
%454 = sitofp i32 %453 to float
%455 = icmp sgt i32 %453, 0
br i1 %455, label %456, label %516
456: ; preds = %451
%457 = load i32**, i32*** %443
%458 = getelementptr inbounds i32*, i32** %457, i64 %452
%459 = load i32*, i32** %458
%460 = zext i32 %453 to i64
%461 = add nsw i64 %460, -1
%462 = and i64 %460, 3
%463 = icmp ult i64 %461, 3
br i1 %463, label %496, label %464
464: ; preds = %456
%465 = and i64 %460, 4294967292
br label %466
466: ; preds = %466, %464
%467 = phi i64 [ 0, %464 ], [ %493, %466 ]
%468 = phi float [ %454, %464 ], [ %492, %466 ]
%469 = phi i64 [ 0, %464 ], [ %494, %466 ]
%470 = getelementptr inbounds i32, i32* %459, i64 %467
%471 = load i32, i32* %470
%472 = icmp eq i32 %471, 0
%473 = fadd float %468, -1.000000e+00
%474 = select i1 %472, float %473, float %468
%475 = or i64 %467, 1
%476 = getelementptr inbounds i32, i32* %459, i64 %475
%477 = load i32, i32* %476
%478 = icmp eq i32 %477, 0
%479 = fadd float %474, -1.000000e+00
%480 = select i1 %478, float %479, float %474
%481 = or i64 %467, 2
%482 = getelementptr inbounds i32, i32* %459, i64 %481
%483 = load i32, i32* %482
%484 = icmp eq i32 %483, 0
%485 = fadd float %480, -1.000000e+00
%486 = select i1 %484, float %485, float %480
%487 = or i64 %467, 3
%488 = getelementptr inbounds i32, i32* %459, i64 %487
%489 = load i32, i32* %488
%490 = icmp eq i32 %489, 0
%491 = fadd float %486, -1.000000e+00
%492 = select i1 %490, float %491, float %486
%493 = add nuw nsw i64 %467, 4
%494 = add i64 %469, 4
%495 = icmp eq i64 %494, %465
br i1 %495, label %496, label %466
496: ; preds = %466, %456
%497 = phi float [ undef, %456 ], [ %492, %466 ]
%498 = phi i64 [ 0, %456 ], [ %493, %466 ]
%499 = phi float [ %454, %456 ], [ %492, %466 ]
%500 = icmp eq i64 %462, 0
br i1 %500, label %513, label %501
501: ; preds = %496, %501
%502 = phi i64 [ %510, %501 ], [ %498, %496 ]
%503 = phi float [ %509, %501 ], [ %499, %496 ]
%504 = phi i64 [ %511, %501 ], [ 0, %496 ]
%505 = getelementptr inbounds i32, i32* %459, i64 %502
%506 = load i32, i32* %505
%507 = icmp eq i32 %506, 0
%508 = fadd float %503, -1.000000e+00
%509 = select i1 %507, float %508, float %503
%510 = add nuw nsw i64 %502, 1
%511 = add i64 %504, 1
%512 = icmp eq i64 %511, %462
br i1 %512, label %513, label %501
513: ; preds = %501, %496
%514 = phi float [ %497, %496 ], [ %509, %501 ]
%515 = fcmp une float %514, 0.000000e+00
br i1 %515, label %518, label %581
516: ; preds = %451
%517 = icmp eq i32 %453, 0
br i1 %517, label %581, label %601
518: ; preds = %513
br i1 %455, label %519, label %601
519: ; preds = %518
%520 = load i32**, i32*** %443
%521 = getelementptr inbounds i32*, i32** %520, i64 %452
%522 = load i32*, i32** %521
%523 = fdiv float 1.000000e+00, %514
br label %524
524: ; preds = %519, %576
%525 = phi i64 [ 0, %519 ], [ %577, %576 ]
%526 = getelementptr inbounds i32, i32* %522, i64 %525
%527 = load i32, i32* %526
%528 = icmp eq i32 %527, 0
br i1 %528, label %576, label %529
529: ; preds = %524
%530 = load i32*, i32** %16
%531 = getelementptr inbounds i32, i32* %530, i64 %452
%532 = load i32, i32* %531
%533 = add nsw i32 %532, 1
store i32 %533, i32* %531
br i1 %416, label %542, label %534
534: ; preds = %529
%535 = load i32, i32* %444
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32*, i32** %16, i64 %536
%538 = load i32*, i32** %537
%539 = getelementptr inbounds i32, i32* %538, i64 %452
%540 = load i32, i32* %539
%541 = add nsw i32 %540, 1
store i32 %541, i32* %539
br label %542
542: ; preds = %534, %529
%543 = load float**, float*** %12
%544 = getelementptr inbounds float*, float** %543, i64 %452
%545 = load float*, float** %544
%546 = load i32, i32* %526
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds float, float* %545, i64 %547
%549 = load float, float* %548
%550 = fadd float %523, %549
store float %550, float* %548
%551 = load i32**, i32*** %148
%552 = getelementptr inbounds i32*, i32** %551, i64 %452
%553 = load i32*, i32** %552
%554 = getelementptr inbounds i32, i32* %553, i64 %547
%555 = load i32, i32* %554
%556 = add nsw i32 %555, 1
store i32 %556, i32* %554
br i1 %415, label %557, label %576
557: ; preds = %542
%558 = load i32, i32* %444
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float**, float*** %12, i64 %559
%561 = load float**, float*** %560
%562 = getelementptr inbounds float*, float** %561, i64 %452
%563 = load float*, float** %562
%564 = load i32, i32* %526
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %563, i64 %565
%567 = load float, float* %566
%568 = fadd float %523, %567
store float %568, float* %566
%569 = getelementptr inbounds i32**, i32*** %148, i64 %559
%570 = load i32**, i32*** %569
%571 = getelementptr inbounds i32*, i32** %570, i64 %452
%572 = load i32*, i32** %571
%573 = getelementptr inbounds i32, i32* %572, i64 %565
%574 = load i32, i32* %573
%575 = add nsw i32 %574, 1
store i32 %575, i32* %573
br label %576
576: ; preds = %524, %557, %542
%577 = add nuw nsw i64 %525, 1
%578 = load i32, i32* %442
%579 = sext i32 %578 to i64
%580 = icmp slt i64 %577, %579
br i1 %580, label %524, label %601
581: ; preds = %516, %513
%582 = phi float [ %454, %516 ], [ %514, %513 ]
%583 = load float**, float*** %12
%584 = getelementptr inbounds float*, float** %583, i64 %452
%585 = load float*, float** %584
%586 = load float, float* %585
%587 = fadd float %586, 1.000000e+00
store float %587, float* %585
%588 = load i32*, i32** %14
%589 = getelementptr inbounds i32, i32* %588, i64 %452
%590 = load i32, i32* %589
%591 = add nsw i32 %590, 1
store i32 %591, i32* %589
br i1 %415, label %592, label %601
592: ; preds = %581
%593 = load i32, i32* %444
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds float**, float*** %12, i64 %594
%596 = load float**, float*** %595
%597 = getelementptr inbounds float*, float** %596, i64 %452
%598 = load float*, float** %597
%599 = load float, float* %598
%600 = fadd float %599, 1.000000e+00
store float %600, float* %598
br label %601
601: ; preds = %576, %516, %518, %581, %592
%602 = phi float [ %514, %518 ], [ %582, %581 ], [ %582, %592 ], [ %454, %516 ], [ %514, %576 ]
%603 = fcmp ogt float %602, 0.000000e+00
br i1 %603, label %604, label %613
604: ; preds = %601
%605 = load i32, i32* %442
%606 = sitofp i32 %605 to float
%607 = fcmp olt float %602, %606
br i1 %607, label %608, label %613
608: ; preds = %604
%609 = load i32*, i32** %15
%610 = getelementptr inbounds i32, i32* %609, i64 %452
%611 = load i32, i32* %610
%612 = add nsw i32 %611, 1
store i32 %612, i32* %610
br label %613
613: ; preds = %608, %604, %601
br i1 %416, label %637, label %614
614: ; preds = %613
%615 = fcmp oeq float %602, 0.000000e+00
br i1 %615, label %616, label %624
616: ; preds = %614
%617 = load i32, i32* %444
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds i32*, i32** %14, i64 %618
%620 = load i32*, i32** %619
%621 = getelementptr inbounds i32, i32* %620, i64 %452
%622 = load i32, i32* %621
%623 = add nsw i32 %622, 1
store i32 %623, i32* %621
br label %624
624: ; preds = %616, %614
br i1 %603, label %625, label %637
625: ; preds = %624
%626 = load i32, i32* %442
%627 = sitofp i32 %626 to float
%628 = fcmp olt float %602, %627
br i1 %628, label %629, label %637
629: ; preds = %625
%630 = load i32, i32* %444
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds i32*, i32** %15, i64 %631
%633 = load i32*, i32** %632
%634 = getelementptr inbounds i32, i32* %633, i64 %452
%635 = load i32, i32* %634
%636 = add nsw i32 %635, 1
store i32 %636, i32* %634
br label %637
637: ; preds = %624, %625, %629, %613
%638 = fcmp ogt float %602, 1.000000e+00
br i1 %638, label %639, label %738
639: ; preds = %637
%640 = load i32, i32* %442
%641 = icmp eq i32 %640, 2
br i1 %641, label %657, label %642
642: ; preds = %639
%643 = icmp sgt i32 %640, 1
br i1 %643, label %644, label %721
644: ; preds = %642
%645 = add nsw i32 %640, -1
%646 = load i32**, i32*** %443
%647 = getelementptr inbounds i32*, i32** %646, i64 %452
%648 = load i32*, i32** %647
%649 = fadd float %602, -1.000000e+00
%650 = fmul float %602, %649
%651 = fpext float %650 to double
%652 = fmul double %651, 5.000000e-01
%653 = fdiv double 1.000000e+00, %652
%654 = zext i32 %640 to i64
%655 = zext i32 %645 to i64
%656 = zext i32 %640 to i64
br label %682
657: ; preds = %639
%658 = load i32**, i32*** %443
%659 = getelementptr inbounds i32*, i32** %658, i64 %452
%660 = load i32*, i32** %659
%661 = load i32, i32* %660
%662 = getelementptr inbounds i32, i32* %660, i64 1
%663 = load i32, i32* %662
%664 = icmp eq i32 %661, %663
br i1 %664, label %721, label %665
665: ; preds = %657
%666 = load float*, float** %20
%667 = getelementptr inbounds float, float* %666, i64 %452
%668 = load float, float* %667
%669 = fadd float %668, 1.000000e+00
store float %669, float* %667
br i1 %416, label %732, label %670
670: ; preds = %665
%671 = load i32, i32* %444
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds float*, float** %20, i64 %672
%674 = load float*, float** %673
%675 = getelementptr inbounds float, float* %674, i64 %452
%676 = load float, float* %675
%677 = fadd float %676, 1.000000e+00
store float %677, float* %675
%678 = load float*, float** %149
%679 = getelementptr inbounds float, float* %678, i64 %452
%680 = load float, float* %679
%681 = fadd float %680, 1.000000e+00
store float %681, float* %679
br label %729
682: ; preds = %644, %718
%683 = phi i64 [ 0, %644 ], [ %688, %718 ]
%684 = phi i64 [ 1, %644 ], [ %719, %718 ]
%685 = getelementptr inbounds i32, i32* %648, i64 %683
%686 = load i32, i32* %685
%687 = icmp ne i32 %686, 0
%688 = add nuw nsw i64 %683, 1
%689 = icmp ult i64 %688, %654
%690 = select i1 %687, i1 %689, i1 false
br i1 %690, label %691, label %718
691: ; preds = %682, %715
%692 = phi i64 [ %716, %715 ], [ %684, %682 ]
%693 = getelementptr inbounds i32, i32* %648, i64 %692
%694 = load i32, i32* %693
%695 = icmp eq i32 %694, 0
%696 = icmp eq i32 %686, %694
%697 = select i1 %695, i1 true, i1 %696
br i1 %697, label %715, label %698
698: ; preds = %691
%699 = load float*, float** %20
%700 = getelementptr inbounds float, float* %699, i64 %452
%701 = load float, float* %700
%702 = fpext float %701 to double
%703 = fadd double %653, %702
%704 = fptrunc double %703 to float
store float %704, float* %700
br i1 %416, label %715, label %705
705: ; preds = %698
%706 = load i32, i32* %444
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds float*, float** %20, i64 %707
%709 = load float*, float** %708
%710 = getelementptr inbounds float, float* %709, i64 %452
%711 = load float, float* %710
%712 = fpext float %711 to double
%713 = fadd double %653, %712
%714 = fptrunc double %713 to float
store float %714, float* %710
br label %715
715: ; preds = %691, %698, %705
%716 = add nuw nsw i64 %692, 1
%717 = icmp eq i64 %716, %656
br i1 %717, label %718, label %691
718: ; preds = %715, %682
%719 = add nuw nsw i64 %684, 1
%720 = icmp eq i64 %688, %655
br i1 %720, label %721, label %682
721: ; preds = %718, %642, %657
%722 = load float*, float** %149
%723 = getelementptr inbounds float, float* %722, i64 %452
%724 = load float, float* %723
%725 = fadd float %724, 1.000000e+00
store float %725, float* %723
br i1 %416, label %738, label %726
726: ; preds = %721
%727 = load i32, i32* %444
%728 = sext i32 %727 to i64
br label %729
729: ; preds = %726, %670
%730 = phi i64 [ %728, %726 ], [ %672, %670 ]
%731 = getelementptr inbounds float*, float** %149, i64 %730
br label %732
732: ; preds = %665, %729
%733 = phi float** [ %731, %729 ], [ %149, %665 ]
%734 = load float*, float** %733
%735 = getelementptr inbounds float, float* %734, i64 %452
%736 = load float, float* %735
%737 = fadd float %736, 1.000000e+00
store float %737, float* %735
br label %738
738: ; preds = %732, %637, %721
%739 = add nuw nsw i64 %452, 1
%740 = icmp eq i64 %739, %420
br i1 %740, label %741, label %451
741: ; preds = %738, %439
%742 = add nuw nsw i64 %440, 1
%743 = icmp eq i64 %742, %419
br i1 %743, label %445, label %439
744: ; preds = %446, %779
%745 = phi i64 [ 1, %446 ], [ %780, %779 ]
%746 = getelementptr inbounds i32, i32* %8, i64 %745
%747 = load i32, i32* %746
%748 = icmp slt i32 %747, 1
br i1 %748, label %779, label %749
749: ; preds = %744
%750 = add nuw i32 %747, 1
%751 = zext i32 %750 to i64
br label %758
752: ; preds = %779, %445
br i1 %30, label %782, label %753
753: ; preds = %752
%754 = add i32 %3, 1
%755 = add nuw i32 %1, 1
%756 = zext i32 %755 to i64
%757 = zext i32 %754 to i64
br label %792
758: ; preds = %749, %776
%759 = phi i64 [ 1, %749 ], [ %777, %776 ]
br i1 %30, label %776, label %760
760: ; preds = %758, %760
%761 = phi i64 [ %774, %760 ], [ 0, %758 ]
%762 = getelementptr inbounds i32, i32* %29, i64 %761
%763 = load i32, i32* %762
%764 = sitofp i32 %763 to float
%765 = getelementptr inbounds float**, float*** %12, i64 %761
%766 = load float**, float*** %765
%767 = getelementptr inbounds float*, float** %766, i64 %745
%768 = load float*, float** %767
%769 = load float, float* %768
%770 = fsub float %764, %769
%771 = getelementptr inbounds float, float* %768, i64 %759
%772 = load float, float* %771
%773 = fdiv float %772, %770
store float %773, float* %771
%774 = add nuw nsw i64 %761, 1
%775 = icmp eq i64 %774, %450
br i1 %775, label %776, label %760
776: ; preds = %760, %758
%777 = add nuw nsw i64 %759, 1
%778 = icmp eq i64 %777, %751
br i1 %778, label %779, label %758
779: ; preds = %776, %744
%780 = add nuw nsw i64 %745, 1
%781 = icmp eq i64 %780, %449
br i1 %781, label %752, label %744
782: ; preds = %831, %752
br i1 %43, label %837, label %783
783: ; preds = %782
%784 = add nuw i32 %1, 1
%785 = add nuw i32 %3, 1
%786 = zext i32 %785 to i64
%787 = zext i32 %784 to i64
%788 = and i64 %787, 1
%789 = icmp eq i32 %1, 0
%790 = and i64 %787, 4294967294
%791 = icmp eq i64 %788, 0
br label %834
792: ; preds = %753, %831
%793 = phi i64 [ 0, %753 ], [ %832, %831 ]
%794 = getelementptr inbounds float*, float** %149, i64 %793
%795 = load float*, float** %794
store float 0.000000e+00, float* %795
br i1 %43, label %827, label %796
796: ; preds = %792
%797 = getelementptr inbounds float*, float** %20, i64 %793
br label %798
798: ; preds = %796, %816
%799 = phi i64 [ 1, %796 ], [ %817, %816 ]
%800 = getelementptr inbounds float, float* %795, i64 %799
%801 = load float, float* %800
%802 = fcmp ogt float %801, 0.000000e+00
br i1 %802, label %803, label %812
803: ; preds = %798
%804 = load float*, float** %797
%805 = getelementptr inbounds float, float* %804, i64 %799
%806 = load float, float* %805
%807 = fdiv float %806, %801
store float %807, float* %805
%808 = load float, float* %804
%809 = fadd float %807, %808
store float %809, float* %804
%810 = load float, float* %795
%811 = fadd float %810, 1.000000e+00
store float %811, float* %795
br label %816
812: ; preds = %798
%813 = load float, float* @HUGE_VAL
%814 = load float*, float** %797
%815 = getelementptr inbounds float, float* %814, i64 %799
store float %813, float* %815
br label %816
816: ; preds = %803, %812
%817 = add nuw nsw i64 %799, 1
%818 = icmp eq i64 %817, %757
br i1 %818, label %819, label %798
819: ; preds = %816
%820 = load float, float* %795
%821 = fcmp ogt float %820, 0.000000e+00
br i1 %821, label %822, label %827
822: ; preds = %819
%823 = getelementptr inbounds float*, float** %20, i64 %793
%824 = load float*, float** %823
%825 = load float, float* %824
%826 = fdiv float %825, %820
store float %826, float* %824
br label %831
827: ; preds = %792, %819
%828 = load float, float* @HUGE_VAL
%829 = getelementptr inbounds float*, float** %20, i64 %793
%830 = load float*, float** %829
store float %828, float* %830
br label %831
831: ; preds = %822, %827
%832 = add nuw nsw i64 %793, 1
%833 = icmp eq i64 %832, %756
br i1 %833, label %782, label %792
834: ; preds = %783, %886
%835 = phi i64 [ 1, %783 ], [ %887, %886 ]
br i1 %30, label %886, label %836
836: ; preds = %834
br i1 %789, label %874, label %849
837: ; preds = %886, %782
br i1 %30, label %889, label %838
838: ; preds = %837
%839 = add i32 %3, 1
%840 = add nuw i32 %1, 1
%841 = zext i32 %840 to i64
%842 = zext i32 %839 to i64
%843 = add nsw i64 %842, -1
%844 = add nsw i64 %842, -2
%845 = and i64 %843, 3
%846 = icmp ult i64 %844, 3
%847 = and i64 %843, -4
%848 = icmp eq i64 %845, 0
br label %897
849: ; preds = %836, %849
%850 = phi i64 [ %871, %849 ], [ 0, %836 ]
%851 = phi i64 [ %872, %849 ], [ 0, %836 ]
%852 = getelementptr inbounds i32*, i32** %16, i64 %850
%853 = load i32*, i32** %852
%854 = getelementptr inbounds i32, i32* %853, i64 %835
%855 = load i32, i32* %854
%856 = sitofp i32 %855 to float
%857 = getelementptr inbounds float**, float*** %12, i64 %850
%858 = load float**, float*** %857
%859 = getelementptr inbounds float*, float** %858, i64 %835
%860 = load float*, float** %859
store float %856, float* %860
%861 = or i64 %850, 1
%862 = getelementptr inbounds i32*, i32** %16, i64 %861
%863 = load i32*, i32** %862
%864 = getelementptr inbounds i32, i32* %863, i64 %835
%865 = load i32, i32* %864
%866 = sitofp i32 %865 to float
%867 = getelementptr inbounds float**, float*** %12, i64 %861
%868 = load float**, float*** %867
%869 = getelementptr inbounds float*, float** %868, i64 %835
%870 = load float*, float** %869
store float %866, float* %870
%871 = add nuw nsw i64 %850, 2
%872 = add i64 %851, 2
%873 = icmp eq i64 %872, %790
br i1 %873, label %874, label %849
874: ; preds = %849, %836
%875 = phi i64 [ 0, %836 ], [ %871, %849 ]
br i1 %791, label %886, label %876
876: ; preds = %874
%877 = getelementptr inbounds i32*, i32** %16, i64 %875
%878 = load i32*, i32** %877
%879 = getelementptr inbounds i32, i32* %878, i64 %835
%880 = load i32, i32* %879
%881 = sitofp i32 %880 to float
%882 = getelementptr inbounds float**, float*** %12, i64 %875
%883 = load float**, float*** %882
%884 = getelementptr inbounds float*, float** %883, i64 %835
%885 = load float*, float** %884
store float %881, float* %885
br label %886
886: ; preds = %876, %874, %834
%887 = add nuw nsw i64 %835, 1
%888 = icmp eq i64 %887, %786
br i1 %888, label %837, label %834
889: ; preds = %944, %837
br i1 %43, label %951, label %890
890: ; preds = %889
%891 = icmp slt i32 %1, 1
%892 = getelementptr inbounds float**, float*** %12, i64 -1
%893 = add nuw i32 %1, 1
%894 = add nuw i32 %3, 1
%895 = zext i32 %894 to i64
%896 = zext i32 %893 to i64
br label %947
897: ; preds = %838, %944
%898 = phi i64 [ 0, %838 ], [ %945, %944 ]
%899 = getelementptr inbounds i32*, i32** %16, i64 %898
%900 = load i32*, i32** %899
store i32 2, i32* %900
br i1 %43, label %944, label %901
901: ; preds = %897
br i1 %846, label %931, label %902
902: ; preds = %901, %927
%903 = phi i64 [ %928, %927 ], [ 1, %901 ]
%904 = phi i64 [ %929, %927 ], [ 0, %901 ]
%905 = getelementptr inbounds i32, i32* %900, i64 %903
%906 = load i32, i32* %905
%907 = icmp slt i32 %906, 2
br i1 %907, label %908, label %909
908: ; preds = %902
store i32 0, i32* %900
br label %909
909: ; preds = %902, %908
%910 = add nuw nsw i64 %903, 1
%911 = getelementptr inbounds i32, i32* %900, i64 %910
%912 = load i32, i32* %911
%913 = icmp slt i32 %912, 2
br i1 %913, label %914, label %915
914: ; preds = %909
store i32 0, i32* %900
br label %915
915: ; preds = %914, %909
%916 = add nuw nsw i64 %903, 2
%917 = getelementptr inbounds i32, i32* %900, i64 %916
%918 = load i32, i32* %917
%919 = icmp slt i32 %918, 2
br i1 %919, label %920, label %921
920: ; preds = %915
store i32 0, i32* %900
br label %921
921: ; preds = %920, %915
%922 = add nuw nsw i64 %903, 3
%923 = getelementptr inbounds i32, i32* %900, i64 %922
%924 = load i32, i32* %923
%925 = icmp slt i32 %924, 2
br i1 %925, label %926, label %927
926: ; preds = %921
store i32 0, i32* %900
br label %927
927: ; preds = %926, %921
%928 = add nuw nsw i64 %903, 4
%929 = add i64 %904, 4
%930 = icmp eq i64 %929, %847
br i1 %930, label %931, label %902
931: ; preds = %927, %901
%932 = phi i64 [ 1, %901 ], [ %928, %927 ]
br i1 %848, label %944, label %933
933: ; preds = %931, %940
%934 = phi i64 [ %941, %940 ], [ %932, %931 ]
%935 = phi i64 [ %942, %940 ], [ 0, %931 ]
%936 = getelementptr inbounds i32, i32* %900, i64 %934
%937 = load i32, i32* %936
%938 = icmp slt i32 %937, 2
br i1 %938, label %939, label %940
939: ; preds = %933
store i32 0, i32* %900
br label %940
940: ; preds = %939, %933
%941 = add nuw nsw i64 %934, 1
%942 = add i64 %935, 1
%943 = icmp eq i64 %942, %845
br i1 %943, label %944, label %933
944: ; preds = %931, %940, %897
%945 = add nuw nsw i64 %898, 1
%946 = icmp eq i64 %945, %841
br i1 %946, label %889, label %897
947: ; preds = %890, %1184
%948 = phi i64 [ 1, %890 ], [ %1185, %1184 ]
br i1 %891, label %963, label %949
949: ; preds = %947
%950 = getelementptr inbounds i32, i32* %8, i64 %948
br label %1020
951: ; preds = %1184, %889
%952 = icmp slt i32 %3, 0
br i1 %952, label %1190, label %953
953: ; preds = %951
%954 = add nuw i32 %1, 1
%955 = add nuw i32 %3, 1
%956 = zext i32 %955 to i64
%957 = zext i32 %954 to i64
%958 = add nsw i64 %957, -1
%959 = and i64 %957, 3
%960 = icmp ult i64 %958, 3
%961 = and i64 %957, 4294967292
%962 = icmp eq i64 %959, 0
br label %1187
963: ; preds = %1173, %947
%964 = phi float [ 0.000000e+00, %947 ], [ %1174, %1173 ]
%965 = getelementptr inbounds i32, i32* %8, i64 %948
%966 = load i32, i32* %965
%967 = icmp slt i32 %966, 1
br i1 %967, label %1184, label %968
968: ; preds = %963
%969 = load float**, float*** %892
%970 = getelementptr inbounds float*, float** %969, i64 %948
%971 = load float*, float** %970
%972 = add nuw i32 %966, 1
%973 = zext i32 %972 to i64
%974 = add nsw i64 %973, -1
%975 = icmp ult i64 %974, 4
br i1 %975, label %1018, label %976
976: ; preds = %968
%977 = and i64 %974, -4
%978 = or i64 %977, 1
%979 = insertelement <4 x float> poison, float %964, i64 0
%980 = shufflevector <4 x float> %979, <4 x float> poison, <4 x i32> zeroinitializer
%981 = add nsw i64 %977, -4
%982 = lshr exact i64 %981, 2
%983 = add nuw nsw i64 %982, 1
%984 = and i64 %983, 1
%985 = icmp eq i64 %981, 0
br i1 %985, label %1006, label %986
986: ; preds = %976
%987 = and i64 %983, 9223372036854775806
br label %988
988: ; preds = %988, %986
%989 = phi i64 [ 0, %986 ], [ %1003, %988 ]
%990 = phi i64 [ 0, %986 ], [ %1004, %988 ]
%991 = or i64 %989, 1
%992 = getelementptr inbounds float, float* %971, i64 %991
%993 = bitcast float* %992 to <4 x float>*
%994 = load <4 x float>, <4 x float>* %993
%995 = fdiv <4 x float> %994, %980
%996 = bitcast float* %992 to <4 x float>*
store <4 x float> %995, <4 x float>* %996
%997 = or i64 %989, 5
%998 = getelementptr inbounds float, float* %971, i64 %997
%999 = bitcast float* %998 to <4 x float>*
%1000 = load <4 x float>, <4 x float>* %999
%1001 = fdiv <4 x float> %1000, %980
%1002 = bitcast float* %998 to <4 x float>*
store <4 x float> %1001, <4 x float>* %1002
%1003 = add nuw i64 %989, 8
%1004 = add i64 %990, 2
%1005 = icmp eq i64 %1004, %987
br i1 %1005, label %1006, label %988
1006: ; preds = %988, %976
%1007 = phi i64 [ 0, %976 ], [ %1003, %988 ]
%1008 = icmp eq i64 %984, 0
br i1 %1008, label %1016, label %1009
1009: ; preds = %1006
%1010 = or i64 %1007, 1
%1011 = getelementptr inbounds float, float* %971, i64 %1010
%1012 = bitcast float* %1011 to <4 x float>*
%1013 = load <4 x float>, <4 x float>* %1012
%1014 = fdiv <4 x float> %1013, %980
%1015 = bitcast float* %1011 to <4 x float>*
store <4 x float> %1014, <4 x float>* %1015
br label %1016
1016: ; preds = %1006, %1009
%1017 = icmp eq i64 %974, %977
br i1 %1017, label %1184, label %1018
1018: ; preds = %968, %1016
%1019 = phi i64 [ 1, %968 ], [ %978, %1016 ]
br label %1177
1020: ; preds = %949, %1173
%1021 = phi i64 [ 1, %949 ], [ %1175, %1173 ]
%1022 = phi float [ 0.000000e+00, %949 ], [ %1174, %1173 ]
%1023 = getelementptr inbounds i32*, i32** %16, i64 %1021
%1024 = load i32*, i32** %1023
%1025 = getelementptr inbounds i32, i32* %1024, i64 %948
%1026 = load i32, i32* %1025
%1027 = icmp eq i32 %1026, 0
br i1 %1027, label %1173, label %1028
1028: ; preds = %1020
%1029 = fadd float %1022, 1.000000e+00
%1030 = load i32, i32* %950
%1031 = icmp slt i32 %1030, 1
br i1 %1031, label %1173, label %1032
1032: ; preds = %1028
%1033 = getelementptr inbounds float**, float*** %12, i64 %1021
%1034 = load float**, float*** %1033
%1035 = getelementptr inbounds float*, float** %1034, i64 %948
%1036 = load float*, float** %1035
%1037 = load float**, float*** %892
%1038 = getelementptr inbounds float*, float** %1037, i64 %948
%1039 = load float*, float** %1038
%1040 = add nuw i32 %1030, 1
%1041 = zext i32 %1040 to i64
%1042 = add nsw i64 %1041, -1
%1043 = icmp ult i64 %1042, 8
br i1 %1043, label %1125, label %1044
1044: ; preds = %1032
%1045 = getelementptr float, float* %1039, i64 1
%1046 = getelementptr float, float* %1039, i64 %1041
%1047 = getelementptr float, float* %1036, i64 1
%1048 = getelementptr float, float* %1036, i64 %1041
%1049 = icmp ult float* %1045, %1048
%1050 = icmp ult float* %1047, %1046
%1051 = and i1 %1049, %1050
br i1 %1051, label %1125, label %1052
1052: ; preds = %1044
%1053 = and i64 %1042, -8
%1054 = or i64 %1053, 1
%1055 = add nsw i64 %1053, -8
%1056 = lshr exact i64 %1055, 3
%1057 = add nuw nsw i64 %1056, 1
%1058 = and i64 %1057, 1
%1059 = icmp eq i64 %1055, 0
br i1 %1059, label %1102, label %1060
1060: ; preds = %1052
%1061 = and i64 %1057, 4611686018427387902
br label %1062
1062: ; preds = %1062, %1060
%1063 = phi i64 [ 0, %1060 ], [ %1099, %1062 ]
%1064 = phi i64 [ 0, %1060 ], [ %1100, %1062 ]
%1065 = or i64 %1063, 1
%1066 = getelementptr inbounds float, float* %1036, i64 %1065
%1067 = bitcast float* %1066 to <4 x float>*
%1068 = load <4 x float>, <4 x float>* %1067
%1069 = getelementptr inbounds float, float* %1066, i64 4
%1070 = bitcast float* %1069 to <4 x float>*
%1071 = load <4 x float>, <4 x float>* %1070
%1072 = getelementptr inbounds float, float* %1039, i64 %1065
%1073 = bitcast float* %1072 to <4 x float>*
%1074 = load <4 x float>, <4 x float>* %1073
%1075 = getelementptr inbounds float, float* %1072, i64 4
%1076 = bitcast float* %1075 to <4 x float>*
%1077 = load <4 x float>, <4 x float>* %1076
%1078 = fadd <4 x float> %1068, %1074
%1079 = fadd <4 x float> %1071, %1077
%1080 = bitcast float* %1072 to <4 x float>*
store <4 x float> %1078, <4 x float>* %1080
%1081 = bitcast float* %1075 to <4 x float>*
store <4 x float> %1079, <4 x float>* %1081
%1082 = or i64 %1063, 9
%1083 = getelementptr inbounds float, float* %1036, i64 %1082
%1084 = bitcast float* %1083 to <4 x float>*
%1085 = load <4 x float>, <4 x float>* %1084
%1086 = getelementptr inbounds float, float* %1083, i64 4
%1087 = bitcast float* %1086 to <4 x float>*
%1088 = load <4 x float>, <4 x float>* %1087
%1089 = getelementptr inbounds float, float* %1039, i64 %1082
%1090 = bitcast float* %1089 to <4 x float>*
%1091 = load <4 x float>, <4 x float>* %1090
%1092 = getelementptr inbounds float, float* %1089, i64 4
%1093 = bitcast float* %1092 to <4 x float>*
%1094 = load <4 x float>, <4 x float>* %1093
%1095 = fadd <4 x float> %1085, %1091
%1096 = fadd <4 x float> %1088, %1094
%1097 = bitcast float* %1089 to <4 x float>*
store <4 x float> %1095, <4 x float>* %1097
%1098 = bitcast float* %1092 to <4 x float>*
store <4 x float> %1096, <4 x float>* %1098
%1099 = add nuw i64 %1063, 16
%1100 = add i64 %1064, 2
%1101 = icmp eq i64 %1100, %1061
br i1 %1101, label %1102, label %1062
1102: ; preds = %1062, %1052
%1103 = phi i64 [ 0, %1052 ], [ %1099, %1062 ]
%1104 = icmp eq i64 %1058, 0
br i1 %1104, label %1123, label %1105
1105: ; preds = %1102
%1106 = or i64 %1103, 1
%1107 = getelementptr inbounds float, float* %1036, i64 %1106
%1108 = bitcast float* %1107 to <4 x float>*
%1109 = load <4 x float>, <4 x float>* %1108
%1110 = getelementptr inbounds float, float* %1107, i64 4
%1111 = bitcast float* %1110 to <4 x float>*
%1112 = load <4 x float>, <4 x float>* %1111
%1113 = getelementptr inbounds float, float* %1039, i64 %1106
%1114 = bitcast float* %1113 to <4 x float>*
%1115 = load <4 x float>, <4 x float>* %1114
%1116 = getelementptr inbounds float, float* %1113, i64 4
%1117 = bitcast float* %1116 to <4 x float>*
%1118 = load <4 x float>, <4 x float>* %1117
%1119 = fadd <4 x float> %1109, %1115
%1120 = fadd <4 x float> %1112, %1118
%1121 = bitcast float* %1113 to <4 x float>*
store <4 x float> %1119, <4 x float>* %1121
%1122 = bitcast float* %1116 to <4 x float>*
store <4 x float> %1120, <4 x float>* %1122
br label %1123
1123: ; preds = %1102, %1105
%1124 = icmp eq i64 %1042, %1053
br i1 %1124, label %1173, label %1125
1125: ; preds = %1044, %1032, %1123
%1126 = phi i64 [ 1, %1044 ], [ 1, %1032 ], [ %1054, %1123 ]
%1127 = sub nsw i64 %1041, %1126
%1128 = xor i64 %1126, -1
%1129 = add nsw i64 %1128, %1041
%1130 = and i64 %1127, 3
%1131 = icmp eq i64 %1130, 0
br i1 %1131, label %1143, label %1132
1132: ; preds = %1125, %1132
%1133 = phi i64 [ %1140, %1132 ], [ %1126, %1125 ]
%1134 = phi i64 [ %1141, %1132 ], [ 0, %1125 ]
%1135 = getelementptr inbounds float, float* %1036, i64 %1133
%1136 = load float, float* %1135
%1137 = getelementptr inbounds float, float* %1039, i64 %1133
%1138 = load float, float* %1137
%1139 = fadd float %1136, %1138
store float %1139, float* %1137
%1140 = add nuw nsw i64 %1133, 1
%1141 = add i64 %1134, 1
%1142 = icmp eq i64 %1141, %1130
br i1 %1142, label %1143, label %1132
1143: ; preds = %1132, %1125
%1144 = phi i64 [ %1126, %1125 ], [ %1140, %1132 ]
%1145 = icmp ult i64 %1129, 3
br i1 %1145, label %1173, label %1146
1146: ; preds = %1143, %1146
%1147 = phi i64 [ %1171, %1146 ], [ %1144, %1143 ]
%1148 = getelementptr inbounds float, float* %1036, i64 %1147
%1149 = load float, float* %1148
%1150 = getelementptr inbounds float, float* %1039, i64 %1147
%1151 = load float, float* %1150
%1152 = fadd float %1149, %1151
store float %1152, float* %1150
%1153 = add nuw nsw i64 %1147, 1
%1154 = getelementptr inbounds float, float* %1036, i64 %1153
%1155 = load float, float* %1154
%1156 = getelementptr inbounds float, float* %1039, i64 %1153
%1157 = load float, float* %1156
%1158 = fadd float %1155, %1157
store float %1158, float* %1156
%1159 = add nuw nsw i64 %1147, 2
%1160 = getelementptr inbounds float, float* %1036, i64 %1159
%1161 = load float, float* %1160
%1162 = getelementptr inbounds float, float* %1039, i64 %1159
%1163 = load float, float* %1162
%1164 = fadd float %1161, %1163
store float %1164, float* %1162
%1165 = add nuw nsw i64 %1147, 3
%1166 = getelementptr inbounds float, float* %1036, i64 %1165
%1167 = load float, float* %1166
%1168 = getelementptr inbounds float, float* %1039, i64 %1165
%1169 = load float, float* %1168
%1170 = fadd float %1167, %1169
store float %1170, float* %1168
%1171 = add nuw nsw i64 %1147, 4
%1172 = icmp eq i64 %1171, %1041
br i1 %1172, label %1173, label %1146
1173: ; preds = %1143, %1146, %1123, %1028, %1020
%1174 = phi float [ %1022, %1020 ], [ %1029, %1028 ], [ %1029, %1123 ], [ %1029, %1146 ], [ %1029, %1143 ]
%1175 = add nuw nsw i64 %1021, 1
%1176 = icmp eq i64 %1175, %896
br i1 %1176, label %963, label %1020
1177: ; preds = %1018, %1177
%1178 = phi i64 [ %1182, %1177 ], [ %1019, %1018 ]
%1179 = getelementptr inbounds float, float* %971, i64 %1178
%1180 = load float, float* %1179
%1181 = fdiv float %1180, %964
store float %1181, float* %1179
%1182 = add nuw nsw i64 %1178, 1
%1183 = icmp eq i64 %1182, %973
br i1 %1183, label %1184, label %1177
1184: ; preds = %1177, %1016, %963
%1185 = add nuw nsw i64 %948, 1
%1186 = icmp eq i64 %1185, %895
br i1 %1186, label %951, label %947
1187: ; preds = %953, %1233
%1188 = phi i64 [ 0, %953 ], [ %1234, %1233 ]
br i1 %30, label %1233, label %1189
1189: ; preds = %1187
br i1 %960, label %1222, label %1201
1190: ; preds = %1233, %951
br i1 %43, label %1309, label %1191
1191: ; preds = %1190
%1192 = add nuw i32 %1, 1
%1193 = add nuw i32 %3, 1
%1194 = zext i32 %1193 to i64
%1195 = zext i32 %1192 to i64
%1196 = add nsw i64 %1195, -1
%1197 = and i64 %1195, 1
%1198 = icmp eq i64 %1196, 0
%1199 = and i64 %1195, 4294967294
%1200 = icmp eq i64 %1197, 0
br label %1236
1201: ; preds = %1189, %1201
%1202 = phi i64 [ %1219, %1201 ], [ 0, %1189 ]
%1203 = phi i64 [ %1220, %1201 ], [ 0, %1189 ]
%1204 = getelementptr inbounds i32*, i32** %13, i64 %1202
%1205 = load i32*, i32** %1204
%1206 = getelementptr inbounds i32, i32* %1205, i64 %1188
store i32 0, i32* %1206
%1207 = or i64 %1202, 1
%1208 = getelementptr inbounds i32*, i32** %13, i64 %1207
%1209 = load i32*, i32** %1208
%1210 = getelementptr inbounds i32, i32* %1209, i64 %1188
store i32 0, i32* %1210
%1211 = or i64 %1202, 2
%1212 = getelementptr inbounds i32*, i32** %13, i64 %1211
%1213 = load i32*, i32** %1212
%1214 = getelementptr inbounds i32, i32* %1213, i64 %1188
store i32 0, i32* %1214
%1215 = or i64 %1202, 3
%1216 = getelementptr inbounds i32*, i32** %13, i64 %1215
%1217 = load i32*, i32** %1216
%1218 = getelementptr inbounds i32, i32* %1217, i64 %1188
store i32 0, i32* %1218
%1219 = add nuw nsw i64 %1202, 4
%1220 = add i64 %1203, 4
%1221 = icmp eq i64 %1220, %961
br i1 %1221, label %1222, label %1201
1222: ; preds = %1201, %1189
%1223 = phi i64 [ 0, %1189 ], [ %1219, %1201 ]
br i1 %962, label %1233, label %1224
1224: ; preds = %1222, %1224
%1225 = phi i64 [ %1230, %1224 ], [ %1223, %1222 ]
%1226 = phi i64 [ %1231, %1224 ], [ 0, %1222 ]
%1227 = getelementptr inbounds i32*, i32** %13, i64 %1225
%1228 = load i32*, i32** %1227
%1229 = getelementptr inbounds i32, i32* %1228, i64 %1188
store i32 0, i32* %1229
%1230 = add nuw nsw i64 %1225, 1
%1231 = add i64 %1226, 1
%1232 = icmp eq i64 %1231, %959
br i1 %1232, label %1233, label %1224
1233: ; preds = %1222, %1224, %1187
%1234 = add nuw nsw i64 %1188, 1
%1235 = icmp eq i64 %1234, %956
br i1 %1235, label %1190, label %1187
1236: ; preds = %1191, %1303
%1237 = phi i64 [ 1, %1191 ], [ %1304, %1303 ]
%1238 = getelementptr inbounds i32, i32* %8, i64 %1237
%1239 = load i32, i32* %1238
%1240 = icmp slt i32 %1239, 1
br i1 %1240, label %1303, label %1241
1241: ; preds = %1236, %1298
%1242 = phi i32 [ %1299, %1298 ], [ %1239, %1236 ]
%1243 = phi i64 [ %1300, %1298 ], [ 1, %1236 ]
br i1 %30, label %1298, label %1244
1244: ; preds = %1241
br i1 %1198, label %1280, label %1245
1245: ; preds = %1244, %1276
%1246 = phi i64 [ %1277, %1276 ], [ 0, %1244 ]
%1247 = phi i64 [ %1278, %1276 ], [ 0, %1244 ]
%1248 = getelementptr inbounds float**, float*** %12, i64 %1246
%1249 = load float**, float*** %1248
%1250 = getelementptr inbounds float*, float** %1249, i64 %1237
%1251 = load float*, float** %1250
%1252 = getelementptr inbounds float, float* %1251, i64 %1243
%1253 = load float, float* %1252
%1254 = fcmp une float %1253, 0.000000e+00
br i1 %1254, label %1255, label %1261
1255: ; preds = %1245
%1256 = getelementptr inbounds i32*, i32** %13, i64 %1246
%1257 = load i32*, i32** %1256
%1258 = getelementptr inbounds i32, i32* %1257, i64 %1237
%1259 = load i32, i32* %1258
%1260 = add nsw i32 %1259, 1
store i32 %1260, i32* %1258
br label %1261
1261: ; preds = %1245, %1255
%1262 = or i64 %1246, 1
%1263 = getelementptr inbounds float**, float*** %12, i64 %1262
%1264 = load float**, float*** %1263
%1265 = getelementptr inbounds float*, float** %1264, i64 %1237
%1266 = load float*, float** %1265
%1267 = getelementptr inbounds float, float* %1266, i64 %1243
%1268 = load float, float* %1267
%1269 = fcmp une float %1268, 0.000000e+00
br i1 %1269, label %1270, label %1276
1270: ; preds = %1261
%1271 = getelementptr inbounds i32*, i32** %13, i64 %1262
%1272 = load i32*, i32** %1271
%1273 = getelementptr inbounds i32, i32* %1272, i64 %1237
%1274 = load i32, i32* %1273
%1275 = add nsw i32 %1274, 1
store i32 %1275, i32* %1273
br label %1276
1276: ; preds = %1270, %1261
%1277 = add nuw nsw i64 %1246, 2
%1278 = add i64 %1247, 2
%1279 = icmp eq i64 %1278, %1199
br i1 %1279, label %1280, label %1245
1280: ; preds = %1276, %1244
%1281 = phi i64 [ 0, %1244 ], [ %1277, %1276 ]
br i1 %1200, label %1296, label %1282
1282: ; preds = %1280
%1283 = getelementptr inbounds float**, float*** %12, i64 %1281
%1284 = load float**, float*** %1283
%1285 = getelementptr inbounds float*, float** %1284, i64 %1237
%1286 = load float*, float** %1285
%1287 = getelementptr inbounds float, float* %1286, i64 %1243
%1288 = load float, float* %1287
%1289 = fcmp une float %1288, 0.000000e+00
br i1 %1289, label %1290, label %1296
1290: ; preds = %1282
%1291 = getelementptr inbounds i32*, i32** %13, i64 %1281
%1292 = load i32*, i32** %1291
%1293 = getelementptr inbounds i32, i32* %1292, i64 %1237
%1294 = load i32, i32* %1293
%1295 = add nsw i32 %1294, 1
store i32 %1295, i32* %1293
br label %1296
1296: ; preds = %1282, %1290, %1280
%1297 = load i32, i32* %1238
br label %1298
1298: ; preds = %1296, %1241
%1299 = phi i32 [ %1297, %1296 ], [ %1242, %1241 ]
%1300 = add nuw nsw i64 %1243, 1
%1301 = sext i32 %1299 to i64
%1302 = icmp slt i64 %1243, %1301
br i1 %1302, label %1241, label %1303
1303: ; preds = %1298, %1236
%1304 = add nuw nsw i64 %1237, 1
%1305 = icmp eq i64 %1304, %1194
br i1 %1305, label %1306, label %1236
1306: ; preds = %1303
%1307 = load i32, i32* %19
%1308 = icmp eq i32 %1307, 0
br i1 %1308, label %1314, label %1372
1309: ; preds = %1190
%1310 = load i32, i32* %19
%1311 = icmp eq i32 %1310, 0
br i1 %1311, label %1312, label %1372
1312: ; preds = %1309
%1313 = mul nsw i32 %5, %0
store i32 %1313, i32* %19
br label %1372
1314: ; preds = %1306
%1315 = mul nsw i32 %5, %0
store i32 %1315, i32* %19
br i1 %43, label %1372, label %1316
1316: ; preds = %1314
%1317 = add nuw i32 %3, 1
%1318 = zext i32 %1317 to i64
%1319 = and i64 %1195, 1
%1320 = icmp eq i64 %1196, 0
%1321 = and i64 %1195, 4294967294
%1322 = icmp eq i64 %1319, 0
br label %1323
1323: ; preds = %1316, %1368
%1324 = phi i32 [ %1315, %1316 ], [ %1369, %1368 ]
%1325 = phi i64 [ 1, %1316 ], [ %1370, %1368 ]
br i1 %30, label %1368, label %1326
1326: ; preds = %1323
br i1 %1320, label %1355, label %1327
1327: ; preds = %1326, %1350
%1328 = phi i32 [ %1351, %1350 ], [ %1324, %1326 ]
%1329 = phi i64 [ %1352, %1350 ], [ 0, %1326 ]
%1330 = phi i64 [ %1353, %1350 ], [ 0, %1326 ]
%1331 = getelementptr inbounds i32*, i32** %16, i64 %1329
%1332 = load i32*, i32** %1331
%1333 = getelementptr inbounds i32, i32* %1332, i64 %1325
%1334 = load i32, i32* %1333
%1335 = icmp sgt i32 %1334, 1
%1336 = icmp slt i32 %1334, %1328
%1337 = select i1 %1335, i1 %1336, i1 false
br i1 %1337, label %1338, label %1339
1338: ; preds = %1327
store i32 %1334, i32* %19
br label %1339
1339: ; preds = %1327, %1338
%1340 = phi i32 [ %1328, %1327 ], [ %1334, %1338 ]
%1341 = or i64 %1329, 1
%1342 = getelementptr inbounds i32*, i32** %16, i64 %1341
%1343 = load i32*, i32** %1342
%1344 = getelementptr inbounds i32, i32* %1343, i64 %1325
%1345 = load i32, i32* %1344
%1346 = icmp sgt i32 %1345, 1
%1347 = icmp slt i32 %1345, %1340
%1348 = select i1 %1346, i1 %1347, i1 false
br i1 %1348, label %1349, label %1350
1349: ; preds = %1339
store i32 %1345, i32* %19
br label %1350
1350: ; preds = %1349, %1339
%1351 = phi i32 [ %1340, %1339 ], [ %1345, %1349 ]
%1352 = add nuw nsw i64 %1329, 2
%1353 = add i64 %1330, 2
%1354 = icmp eq i64 %1353, %1321
br i1 %1354, label %1355, label %1327
1355: ; preds = %1350, %1326
%1356 = phi i32 [ undef, %1326 ], [ %1351, %1350 ]
%1357 = phi i32 [ %1324, %1326 ], [ %1351, %1350 ]
%1358 = phi i64 [ 0, %1326 ], [ %1352, %1350 ]
br i1 %1322, label %1368, label %1359
1359: ; preds = %1355
%1360 = getelementptr inbounds i32*, i32** %16, i64 %1358
%1361 = load i32*, i32** %1360
%1362 = getelementptr inbounds i32, i32* %1361, i64 %1325
%1363 = load i32, i32* %1362
%1364 = icmp sgt i32 %1363, 1
%1365 = icmp slt i32 %1363, %1357
%1366 = select i1 %1364, i1 %1365, i1 false
br i1 %1366, label %1367, label %1368
1367: ; preds = %1359
store i32 %1363, i32* %19
br label %1368
1368: ; preds = %1355, %1367, %1359, %1323
%1369 = phi i32 [ %1324, %1323 ], [ %1356, %1355 ], [ %1357, %1359 ], [ %1363, %1367 ]
%1370 = add nuw nsw i64 %1325, 1
%1371 = icmp eq i64 %1370, %1318
br i1 %1371, label %1372, label %1323
1372: ; preds = %1368, %1312, %1309, %1314, %1306
%1373 = phi i32 [ %1315, %1314 ], [ %1307, %1306 ], [ %1310, %1309 ], [ %1313, %1312 ], [ %1369, %1368 ]
br i1 %30, label %1542, label %1374
1374: ; preds = %1372
%1375 = sitofp i32 %3 to float
%1376 = add i32 %3, 1
%1377 = add nuw i32 %1, 1
%1378 = zext i32 %1377 to i64
%1379 = icmp sgt i32 %1373, 0
%1380 = zext i32 %1376 to i64
%1381 = and i32 %1373, 1
%1382 = icmp eq i32 %1373, 1
%1383 = and i32 %1373, -2
%1384 = icmp eq i32 %1381, 0
br label %1392
1385: ; preds = %1483
br i1 %30, label %1542, label %1386
1386: ; preds = %1385
%1387 = add nsw i64 %1378, -1
%1388 = and i64 %1378, 3
%1389 = icmp ult i64 %1387, 3
br i1 %1389, label %1486, label %1390
1390: ; preds = %1386
%1391 = and i64 %1378, 4294967292
br label %1506
1392: ; preds = %1374, %1483
%1393 = phi i64 [ 0, %1374 ], [ %1484, %1483 ]
%1394 = getelementptr inbounds float*, float** %18, i64 %1393
%1395 = load float*, float** %1394
store float 0.000000e+00, float* %1395
br i1 %43, label %1483, label %1396
1396: ; preds = %1392
%1397 = getelementptr inbounds i32*, i32** %16, i64 %1393
%1398 = load i32*, i32** %1397
%1399 = getelementptr inbounds i32*, i32** %13, i64 %1393
%1400 = getelementptr inbounds i32**, i32*** %148, i64 %1393
br label %1401
1401: ; preds = %1396, %1477
%1402 = phi float [ 0.000000e+00, %1396 ], [ %1480, %1477 ]
%1403 = phi i64 [ 1, %1396 ], [ %1481, %1477 ]
%1404 = getelementptr inbounds i32, i32* %1398, i64 %1403
%1405 = load i32, i32* %1404
%1406 = icmp sgt i32 %1405, %1373
br i1 %1406, label %1407, label %1465
1407: ; preds = %1401
%1408 = getelementptr inbounds float, float* %1395, i64 %1403
store float 0.000000e+00, float* %1408
%1409 = getelementptr inbounds i32, i32* %8, i64 %1403
%1410 = load i32, i32* %1409
%1411 = icmp slt i32 %1410, 1
br i1 %1411, label %1477, label %1412
1412: ; preds = %1407
%1413 = load i32**, i32*** %1400
%1414 = getelementptr inbounds i32*, i32** %1413, i64 %1403
%1415 = load i32*, i32** %1414
%1416 = add nuw i32 %1410, 1
%1417 = zext i32 %1416 to i64
br label %1418
1418: ; preds = %1412, %1458
%1419 = phi i64 [ 1, %1412 ], [ %1463, %1458 ]
%1420 = phi float [ 0.000000e+00, %1412 ], [ %1462, %1458 ]
br i1 %1379, label %1421, label %1458
1421: ; preds = %1418
%1422 = getelementptr inbounds i32, i32* %1415, i64 %1419
%1423 = load i32, i32* %1422
br i1 %1382, label %1446, label %1424
1424: ; preds = %1421, %1424
%1425 = phi double [ %1442, %1424 ], [ 1.000000e+00, %1421 ]
%1426 = phi i32 [ %1443, %1424 ], [ 0, %1421 ]
%1427 = phi i32 [ %1444, %1424 ], [ 0, %1421 ]
%1428 = add i32 %1423, %1426
%1429 = sub i32 %1405, %1428
%1430 = sitofp i32 %1429 to double
%1431 = sub nsw i32 %1405, %1426
%1432 = sitofp i32 %1431 to double
%1433 = fdiv double %1430, %1432
%1434 = fmul double %1425, %1433
%1435 = or i32 %1426, 1
%1436 = add i32 %1423, %1435
%1437 = sub i32 %1405, %1436
%1438 = sitofp i32 %1437 to double
%1439 = sub nsw i32 %1405, %1435
%1440 = sitofp i32 %1439 to double
%1441 = fdiv double %1438, %1440
%1442 = fmul double %1434, %1441
%1443 = add nuw nsw i32 %1426, 2
%1444 = add i32 %1427, 2
%1445 = icmp eq i32 %1444, %1383
br i1 %1445, label %1446, label %1424
1446: ; preds = %1424, %1421
%1447 = phi double [ undef, %1421 ], [ %1442, %1424 ]
%1448 = phi double [ 1.000000e+00, %1421 ], [ %1442, %1424 ]
%1449 = phi i32 [ 0, %1421 ], [ %1443, %1424 ]
br i1 %1384, label %1458, label %1450
1450: ; preds = %1446
%1451 = add i32 %1423, %1449
%1452 = sub i32 %1405, %1451
%1453 = sitofp i32 %1452 to double
%1454 = sub nsw i32 %1405, %1449
%1455 = sitofp i32 %1454 to double
%1456 = fdiv double %1453, %1455
%1457 = fmul double %1448, %1456
br label %1458
1458: ; preds = %1450, %1446, %1418
%1459 = phi double [ 1.000000e+00, %1418 ], [ %1447, %1446 ], [ %1457, %1450 ]
%1460 = fsub double 1.000000e+00, %1459
%1461 = fptrunc double %1460 to float
%1462 = fadd float %1420, %1461
%1463 = add nuw nsw i64 %1419, 1
%1464 = icmp eq i64 %1463, %1417
br i1 %1464, label %1476, label %1418
1465: ; preds = %1401
%1466 = icmp eq i32 %1405, %1373
br i1 %1466, label %1467, label %1473
1467: ; preds = %1465
%1468 = load i32*, i32** %1399
%1469 = getelementptr inbounds i32, i32* %1468, i64 %1403
%1470 = load i32, i32* %1469
%1471 = sitofp i32 %1470 to float
%1472 = getelementptr inbounds float, float* %1395, i64 %1403
store float %1471, float* %1472
br label %1477
1473: ; preds = %1465
%1474 = load float, float* @HUGE_VAL
%1475 = getelementptr inbounds float, float* %1395, i64 %1403
store float %1474, float* %1475
br label %1477
1476: ; preds = %1458
store float %1462, float* %1408
br label %1477
1477: ; preds = %1407, %1476, %1467, %1473
%1478 = phi float [ 0.000000e+00, %1407 ], [ %1462, %1476 ], [ %1471, %1467 ], [ %1474, %1473 ]
%1479 = fdiv float %1478, %1375
%1480 = fadd float %1402, %1479
store float %1480, float* %1395
%1481 = add nuw nsw i64 %1403, 1
%1482 = icmp eq i64 %1481, %1380
br i1 %1482, label %1483, label %1401
1483: ; preds = %1477, %1392
%1484 = add nuw nsw i64 %1393, 1
%1485 = icmp eq i64 %1484, %1378
br i1 %1485, label %1385, label %1392
1486: ; preds = %1506, %1386
%1487 = phi i64 [ 0, %1386 ], [ %1528, %1506 ]
%1488 = icmp eq i64 %1388, 0
br i1 %1488, label %1499, label %1489
1489: ; preds = %1486, %1489
%1490 = phi i64 [ %1496, %1489 ], [ %1487, %1486 ]
%1491 = phi i64 [ %1497, %1489 ], [ 0, %1486 ]
%1492 = getelementptr inbounds float*, float** %17, i64 %1490
%1493 = load float*, float** %1492
store float 0.000000e+00, float* %1493
%1494 = getelementptr inbounds float*, float** %21, i64 %1490
%1495 = load float*, float** %1494
store float 0.000000e+00, float* %1495
%1496 = add nuw nsw i64 %1490, 1
%1497 = add i64 %1491, 1
%1498 = icmp eq i64 %1497, %1388
br i1 %1498, label %1499, label %1489
1499: ; preds = %1489, %1486
br i1 %30, label %1542, label %1500
1500: ; preds = %1499
%1501 = sitofp i32 %3 to float
%1502 = add i32 %3, 1
%1503 = add nuw i32 %1, 1
%1504 = zext i32 %1503 to i64
%1505 = zext i32 %1502 to i64
br label %1531
1506: ; preds = %1506, %1390
%1507 = phi i64 [ 0, %1390 ], [ %1528, %1506 ]
%1508 = phi i64 [ 0, %1390 ], [ %1529, %1506 ]
%1509 = getelementptr inbounds float*, float** %17, i64 %1507
%1510 = load float*, float** %1509
store float 0.000000e+00, float* %1510
%1511 = getelementptr inbounds float*, float** %21, i64 %1507
%1512 = load float*, float** %1511
store float 0.000000e+00, float* %1512
%1513 = or i64 %1507, 1
%1514 = getelementptr inbounds float*, float** %17, i64 %1513
%1515 = load float*, float** %1514
store float 0.000000e+00, float* %1515
%1516 = getelementptr inbounds float*, float** %21, i64 %1513
%1517 = load float*, float** %1516
store float 0.000000e+00, float* %1517
%1518 = or i64 %1507, 2
%1519 = getelementptr inbounds float*, float** %17, i64 %1518
%1520 = load float*, float** %1519
store float 0.000000e+00, float* %1520
%1521 = getelementptr inbounds float*, float** %21, i64 %1518
%1522 = load float*, float** %1521
store float 0.000000e+00, float* %1522
%1523 = or i64 %1507, 3
%1524 = getelementptr inbounds float*, float** %17, i64 %1523
%1525 = load float*, float** %1524
store float 0.000000e+00, float* %1525
%1526 = getelementptr inbounds float*, float** %21, i64 %1523
%1527 = load float*, float** %1526
store float 0.000000e+00, float* %1527
%1528 = add nuw nsw i64 %1507, 4
%1529 = add i64 %1508, 4
%1530 = icmp eq i64 %1529, %1391
br i1 %1530, label %1486, label %1506
1531: ; preds = %1500, %1656
%1532 = phi i64 [ 0, %1500 ], [ %1657, %1656 ]
br i1 %43, label %1656, label %1533
1533: ; preds = %1531
%1534 = getelementptr inbounds i32*, i32** %16, i64 %1532
%1535 = load i32*, i32** %1534
%1536 = getelementptr inbounds float*, float** %17, i64 %1532
%1537 = getelementptr inbounds float*, float** %21, i64 %1532
%1538 = getelementptr inbounds float*, float** %147, i64 %1532
%1539 = getelementptr inbounds float**, float*** %12, i64 %1532
%1540 = load float*, float** %1537
%1541 = load float*, float** %1536
br label %1558
1542: ; preds = %1656, %1372, %1385, %1499
br i1 %43, label %1664, label %1543
1543: ; preds = %1542
%1544 = icmp slt i32 %1, 1
%1545 = icmp eq i32 %11, 0
%1546 = load float*, float** %25
%1547 = load float*, float** %24
%1548 = load float*, float** %23
%1549 = load float*, float** %22
%1550 = icmp sgt i32 %1, 1
%1551 = getelementptr inbounds float**, float*** %12, i64 -1
%1552 = add nuw i32 %1, 1
%1553 = add nuw i32 %3, 1
%1554 = zext i32 %1553 to i64
%1555 = zext i32 %1552 to i64
%1556 = zext i32 %1 to i64
%1557 = zext i32 %1552 to i64
br label %1659
1558: ; preds = %1533, %1640
%1559 = phi i64 [ 1, %1533 ], [ %1654, %1640 ]
%1560 = getelementptr inbounds i32, i32* %1535, i64 %1559
%1561 = load i32, i32* %1560
%1562 = icmp sgt i32 %1561, 1
br i1 %1562, label %1563, label %1637
1563: ; preds = %1558
%1564 = load float*, float** %1538
%1565 = getelementptr inbounds float, float* %1564, i64 %1559
store float 0.000000e+00, float* %1565
%1566 = getelementptr inbounds i32, i32* %8, i64 %1559
%1567 = load i32, i32* %1566
%1568 = icmp slt i32 %1567, 1
br i1 %1568, label %1618, label %1569
1569: ; preds = %1563
%1570 = load float**, float*** %1539
%1571 = getelementptr inbounds float*, float** %1570, i64 %1559
%1572 = load float*, float** %1571
%1573 = add nuw i32 %1567, 1
%1574 = zext i32 %1573 to i64
%1575 = add nsw i64 %1574, -1
%1576 = add nsw i64 %1574, -2
%1577 = and i64 %1575, 3
%1578 = icmp ult i64 %1576, 3
br i1 %1578, label %1603, label %1579
1579: ; preds = %1569
%1580 = and i64 %1575, -4
br label %1581
1581: ; preds = %1581, %1579
%1582 = phi float [ 0.000000e+00, %1579 ], [ %1599, %1581 ]
%1583 = phi i64 [ 1, %1579 ], [ %1600, %1581 ]
%1584 = phi i64 [ 0, %1579 ], [ %1601, %1581 ]
%1585 = getelementptr inbounds float, float* %1572, i64 %1583
%1586 = load float, float* %1585
%1587 = tail call float @llvm.fmuladd.f32(float %1586, float %1586, float %1582)
store float %1587, float* %1565
%1588 = add nuw nsw i64 %1583, 1
%1589 = getelementptr inbounds float, float* %1572, i64 %1588
%1590 = load float, float* %1589
%1591 = tail call float @llvm.fmuladd.f32(float %1590, float %1590, float %1587)
store float %1591, float* %1565
%1592 = add nuw nsw i64 %1583, 2
%1593 = getelementptr inbounds float, float* %1572, i64 %1592
%1594 = load float, float* %1593
%1595 = tail call float @llvm.fmuladd.f32(float %1594, float %1594, float %1591)
store float %1595, float* %1565
%1596 = add nuw nsw i64 %1583, 3
%1597 = getelementptr inbounds float, float* %1572, i64 %1596
%1598 = load float, float* %1597
%1599 = tail call float @llvm.fmuladd.f32(float %1598, float %1598, float %1595)
store float %1599, float* %1565
%1600 = add nuw nsw i64 %1583, 4
%1601 = add i64 %1584, 4
%1602 = icmp eq i64 %1601, %1580
br i1 %1602, label %1603, label %1581
1603: ; preds = %1581, %1569
%1604 = phi float [ undef, %1569 ], [ %1599, %1581 ]
%1605 = phi float [ 0.000000e+00, %1569 ], [ %1599, %1581 ]
%1606 = phi i64 [ 1, %1569 ], [ %1600, %1581 ]
%1607 = icmp eq i64 %1577, 0
br i1 %1607, label %1618, label %1608
1608: ; preds = %1603, %1608
%1609 = phi float [ %1614, %1608 ], [ %1605, %1603 ]
%1610 = phi i64 [ %1615, %1608 ], [ %1606, %1603 ]
%1611 = phi i64 [ %1616, %1608 ], [ 0, %1603 ]
%1612 = getelementptr inbounds float, float* %1572, i64 %1610
%1613 = load float, float* %1612
%1614 = tail call float @llvm.fmuladd.f32(float %1613, float %1613, float %1609)
store float %1614, float* %1565
%1615 = add nuw nsw i64 %1610, 1
%1616 = add i64 %1611, 1
%1617 = icmp eq i64 %1616, %1577
br i1 %1617, label %1618, label %1608
1618: ; preds = %1603, %1608, %1563
%1619 = phi float [ 0.000000e+00, %1563 ], [ %1604, %1603 ], [ %1614, %1608 ]
%1620 = fsub float 1.000000e+00, %1619
%1621 = getelementptr inbounds float, float* %1540, i64 %1559
%1622 = sitofp i32 %1561 to float
%1623 = fadd float %1622, -1.000000e+00
%1624 = fdiv float %1622, %1623
%1625 = fmul float %1624, %1620
store float %1625, float* %1621
%1626 = sitofp i32 %1561 to double
%1627 = fadd double %1626, -1.000000e+00
%1628 = fmul double %1627, %1626
%1629 = fpext float %1625 to double
%1630 = fsub double 1.000000e+00, %1629
%1631 = fadd double %1626, -2.000000e+00
%1632 = fmul double %1631, %1630
%1633 = fadd double %1626, 1.000000e+00
%1634 = tail call double @llvm.fmuladd.f64(double %1632, double %1633, double 2.000000e+00)
%1635 = fdiv double %1628, %1634
%1636 = fptrunc double %1635 to float
br label %1640
1637: ; preds = %1558
%1638 = load float, float* @HUGE_VAL
%1639 = getelementptr inbounds float, float* %1541, i64 %1559
store float %1638, float* %1639
br label %1640
1640: ; preds = %1637, %1618
%1641 = phi float* [ %1540, %1637 ], [ %1541, %1618 ]
%1642 = phi float [ %1638, %1637 ], [ %1636, %1618 ]
%1643 = getelementptr inbounds float, float* %1641, i64 %1559
store float %1642, float* %1643
%1644 = getelementptr inbounds float, float* %1540, i64 %1559
%1645 = load float, float* %1644
%1646 = fdiv float %1645, %1501
%1647 = load float, float* %1540
%1648 = fadd float %1647, %1646
store float %1648, float* %1540
%1649 = getelementptr inbounds float, float* %1541, i64 %1559
%1650 = load float, float* %1649
%1651 = fdiv float %1650, %1501
%1652 = load float, float* %1541
%1653 = fadd float %1652, %1651
store float %1653, float* %1541
%1654 = add nuw nsw i64 %1559, 1
%1655 = icmp eq i64 %1654, %1505
br i1 %1655, label %1656, label %1558
1656: ; preds = %1640, %1531
%1657 = add nuw nsw i64 %1532, 1
%1658 = icmp eq i64 %1657, %1504
br i1 %1658, label %1542, label %1531
1659: ; preds = %1543, %1973
%1660 = phi i64 [ 1, %1543 ], [ %1975, %1973 ]
br i1 %1544, label %1806, label %1661
1661: ; preds = %1659
%1662 = getelementptr inbounds i32, i32* %8, i64 %1660
%1663 = getelementptr inbounds float**, float*** %10, i64 %1660
br label %1671
1664: ; preds = %1973, %1542
br i1 %30, label %2036, label %1665
1665: ; preds = %1664
%1666 = sitofp i32 %3 to float
%1667 = add i32 %3, 1
%1668 = add nuw i32 %1, 1
%1669 = zext i32 %1668 to i64
%1670 = zext i32 %1667 to i64
br label %1984
1671: ; preds = %1661, %1803
%1672 = phi i64 [ 1, %1661 ], [ %1804, %1803 ]
%1673 = getelementptr inbounds i32*, i32** %16, i64 %1672
%1674 = load i32*, i32** %1673
%1675 = getelementptr inbounds i32, i32* %1674, i64 %1660
%1676 = load i32, i32* %1675
%1677 = icmp sgt i32 %1676, 1
br i1 %1677, label %1678, label %1789
1678: ; preds = %1671
%1679 = getelementptr inbounds float*, float** %25, i64 %1672
%1680 = load float*, float** %1679
%1681 = getelementptr inbounds float, float* %1680, i64 %1660
store float 0.000000e+00, float* %1681
%1682 = getelementptr inbounds float*, float** %24, i64 %1672
%1683 = load float*, float** %1682
%1684 = getelementptr inbounds float, float* %1683, i64 %1660
store float 0.000000e+00, float* %1684
%1685 = getelementptr inbounds float*, float** %23, i64 %1672
%1686 = load float*, float** %1685
%1687 = getelementptr inbounds float, float* %1686, i64 %1660
store float 0.000000e+00, float* %1687
%1688 = getelementptr inbounds float*, float** %22, i64 %1672
%1689 = load float*, float** %1688
%1690 = getelementptr inbounds float, float* %1689, i64 %1660
store float 0.000000e+00, float* %1690
%1691 = load i32, i32* %1662
%1692 = icmp slt i32 %1691, 1
br i1 %1692, label %1763, label %1693
1693: ; preds = %1678
%1694 = getelementptr inbounds float**, float*** %12, i64 %1672
%1695 = load float**, float*** %1694
%1696 = getelementptr inbounds float*, float** %1695, i64 %1660
%1697 = load float*, float** %1696
%1698 = add nuw i32 %1691, 1
%1699 = zext i32 %1698 to i64
br label %1700
1700: ; preds = %1693, %1756
%1701 = phi i64 [ 1, %1693 ], [ %1759, %1756 ]
%1702 = phi float [ 0.000000e+00, %1693 ], [ %1758, %1756 ]
%1703 = phi i32 [ 0, %1693 ], [ %1757, %1756 ]
%1704 = getelementptr inbounds float, float* %1697, i64 %1701
%1705 = load float, float* %1704
%1706 = fcmp oeq float %1705, 0.000000e+00
br i1 %1706, label %1756, label %1707
1707: ; preds = %1700, %1751
%1708 = phi i64 [ %1754, %1751 ], [ 1, %1700 ]
%1709 = phi float [ %1753, %1751 ], [ %1702, %1700 ]
%1710 = phi i32 [ %1752, %1751 ], [ %1703, %1700 ]
%1711 = icmp eq i64 %1701, %1708
br i1 %1711, label %1718, label %1712
1712: ; preds = %1707
%1713 = load float, float* %1704
%1714 = getelementptr inbounds float, float* %1697, i64 %1708
%1715 = load float, float* %1714
%1716 = load float, float* %1690
%1717 = tail call float @llvm.fmuladd.f32(float %1713, float %1715, float %1716)
store float %1717, float* %1690
br label %1718
1718: ; preds = %1712, %1707
br i1 %1545, label %1751, label %1719
1719: ; preds = %1718
%1720 = load float**, float*** %1663
%1721 = getelementptr inbounds float*, float** %1720, i64 %1701
%1722 = load float*, float** %1721
%1723 = getelementptr inbounds float, float* %1722, i64 %1708
%1724 = load float, float* %1723
%1725 = load float, float* %1704
%1726 = fmul float %1724, %1725
%1727 = getelementptr inbounds float, float* %1697, i64 %1708
%1728 = load float, float* %1727
%1729 = load float, float* %1687
%1730 = tail call float @llvm.fmuladd.f32(float %1726, float %1728, float %1729)
store float %1730, float* %1687
br i1 %1711, label %1751, label %1731
1731: ; preds = %1719
%1732 = load float, float* %1704
%1733 = fcmp une float %1732, 0.000000e+00
br i1 %1733, label %1734, label %1751
1734: ; preds = %1731
%1735 = load float, float* %1727
%1736 = fcmp une float %1735, 0.000000e+00
br i1 %1736, label %1737, label %1751
1737: ; preds = %1734
%1738 = add nsw i32 %1710, 1
%1739 = load float, float* %1723
%1740 = load float, float* %1684
%1741 = fadd float %1739, %1740
store float %1741, float* %1684
%1742 = load float, float* %1723
%1743 = load float, float* %1704
%1744 = fmul float %1742, %1743
%1745 = load float, float* %1727
%1746 = load float, float* %1681
%1747 = tail call float @llvm.fmuladd.f32(float %1744, float %1745, float %1746)
store float %1747, float* %1681
%1748 = load float, float* %1704
%1749 = load float, float* %1727
%1750 = tail call float @llvm.fmuladd.f32(float %1748, float %1749, float %1709)
br label %1751
1751: ; preds = %1718, %1737, %1734, %1731, %1719
%1752 = phi i32 [ %1738, %1737 ], [ %1710, %1734 ], [ %1710, %1731 ], [ %1710, %1719 ], [ %1710, %1718 ]
%1753 = phi float [ %1750, %1737 ], [ %1709, %1734 ], [ %1709, %1731 ], [ %1709, %1719 ], [ %1709, %1718 ]
%1754 = add nuw nsw i64 %1708, 1
%1755 = icmp eq i64 %1754, %1699
br i1 %1755, label %1756, label %1707
1756: ; preds = %1751, %1700
%1757 = phi i32 [ %1703, %1700 ], [ %1752, %1751 ]
%1758 = phi float [ %1702, %1700 ], [ %1753, %1751 ]
%1759 = add nuw nsw i64 %1701, 1
%1760 = icmp eq i64 %1759, %1699
br i1 %1760, label %1761, label %1700
1761: ; preds = %1756
%1762 = load float, float* %1690
br label %1763
1763: ; preds = %1761, %1678
%1764 = phi float [ 0.000000e+00, %1678 ], [ %1762, %1761 ]
%1765 = phi i32 [ 0, %1678 ], [ %1757, %1761 ]
%1766 = phi float [ 0.000000e+00, %1678 ], [ %1758, %1761 ]
%1767 = sitofp i32 %1676 to double
%1768 = fadd double %1767, -1.000000e+00
%1769 = fdiv double %1767, %1768
%1770 = fptrunc double %1769 to float
%1771 = fmul float %1764, %1770
store float %1771, float* %1690
%1772 = load float, float* %1687
%1773 = fmul float %1772, %1770
store float %1773, float* %1687
%1774 = icmp eq i32 %1765, 0
br i1 %1774, label %1779, label %1775
1775: ; preds = %1763
%1776 = sitofp i32 %1765 to float
%1777 = load float, float* %1684
%1778 = fdiv float %1777, %1776
br label %1781
1779: ; preds = %1763
%1780 = load float, float* @HUGE_VAL
br label %1781
1781: ; preds = %1779, %1775
%1782 = phi float [ %1778, %1775 ], [ %1780, %1779 ]
store float %1782, float* %1684
%1783 = fcmp une float %1766, 0.000000e+00
br i1 %1783, label %1784, label %1787
1784: ; preds = %1781
%1785 = load float, float* %1681
%1786 = fdiv float %1785, %1766
store float %1786, float* %1681
br label %1803
1787: ; preds = %1781
%1788 = load float, float* @HUGE_VAL
store float %1788, float* %1681
br label %1803
1789: ; preds = %1671
%1790 = load float, float* @HUGE_VAL
%1791 = getelementptr inbounds float*, float** %25, i64 %1672
%1792 = load float*, float** %1791
%1793 = getelementptr inbounds float, float* %1792, i64 %1660
store float %1790, float* %1793
%1794 = getelementptr inbounds float*, float** %24, i64 %1672
%1795 = load float*, float** %1794
%1796 = getelementptr inbounds float, float* %1795, i64 %1660
store float %1790, float* %1796
%1797 = getelementptr inbounds float*, float** %23, i64 %1672
%1798 = load float*, float** %1797
%1799 = getelementptr inbounds float, float* %1798, i64 %1660
store float %1790, float* %1799
%1800 = getelementptr inbounds float*, float** %22, i64 %1672
%1801 = load float*, float** %1800
%1802 = getelementptr inbounds float, float* %1801, i64 %1660
store float %1790, float* %1802
br label %1803
1803: ; preds = %1789, %1787, %1784
%1804 = add nuw nsw i64 %1672, 1
%1805 = icmp eq i64 %1804, %1555
br i1 %1805, label %1806, label %1671
1806: ; preds = %1803, %1659
%1807 = getelementptr inbounds float, float* %1546, i64 %1660
store float 0.000000e+00, float* %1807
%1808 = getelementptr inbounds float, float* %1547, i64 %1660
store float 0.000000e+00, float* %1808
%1809 = getelementptr inbounds float, float* %1548, i64 %1660
store float 0.000000e+00, float* %1809
%1810 = getelementptr inbounds float, float* %1549, i64 %1660
store float 0.000000e+00, float* %1810
br i1 %1550, label %1811, label %1898
1811: ; preds = %1806
%1812 = getelementptr inbounds i32, i32* %8, i64 %1660
%1813 = getelementptr inbounds float**, float*** %10, i64 %1660
br label %1817
1814: ; preds = %1886
%1815 = add nuw nsw i64 %1819, 1
%1816 = icmp eq i64 %1821, %1556
br i1 %1816, label %1890, label %1817
1817: ; preds = %1814, %1811
%1818 = phi i64 [ 1, %1811 ], [ %1821, %1814 ]
%1819 = phi i64 [ 2, %1811 ], [ %1815, %1814 ]
%1820 = phi i32 [ 0, %1811 ], [ %1887, %1814 ]
%1821 = add nuw nsw i64 %1818, 1
%1822 = getelementptr inbounds i32*, i32** %16, i64 %1818
%1823 = load i32*, i32** %1822
%1824 = getelementptr inbounds i32, i32* %1823, i64 %1660
%1825 = load i32, i32* %1824
%1826 = icmp sgt i32 %1825, 1
%1827 = getelementptr inbounds float**, float*** %12, i64 %1818
br label %1828
1828: ; preds = %1817, %1886
%1829 = phi i64 [ %1819, %1817 ], [ %1888, %1886 ]
%1830 = phi i32 [ %1820, %1817 ], [ %1887, %1886 ]
br i1 %1826, label %1831, label %1886
1831: ; preds = %1828
%1832 = getelementptr inbounds i32*, i32** %16, i64 %1829
%1833 = load i32*, i32** %1832
%1834 = getelementptr inbounds i32, i32* %1833, i64 %1660
%1835 = load i32, i32* %1834
%1836 = icmp sgt i32 %1835, 1
br i1 %1836, label %1837, label %1886
1837: ; preds = %1831
%1838 = add nsw i32 %1830, 1
%1839 = load i32, i32* %1812
%1840 = icmp slt i32 %1839, 1
br i1 %1840, label %1886, label %1841
1841: ; preds = %1837
%1842 = load float**, float*** %1827
%1843 = getelementptr inbounds float*, float** %1842, i64 %1660
%1844 = load float*, float** %1843
%1845 = getelementptr inbounds float**, float*** %12, i64 %1829
%1846 = add nuw i32 %1839, 1
%1847 = zext i32 %1846 to i64
br label %1848
1848: ; preds = %1841, %1883
%1849 = phi i64 [ 1, %1841 ], [ %1884, %1883 ]
%1850 = getelementptr inbounds float, float* %1844, i64 %1849
%1851 = load float, float* %1850
%1852 = fcmp oeq float %1851, 0.000000e+00
br i1 %1852, label %1883, label %1853
1853: ; preds = %1848
%1854 = load float**, float*** %1845
%1855 = getelementptr inbounds float*, float** %1854, i64 %1660
%1856 = load float*, float** %1855
br label %1857
1857: ; preds = %1853, %1880
%1858 = phi i64 [ 1, %1853 ], [ %1881, %1880 ]
%1859 = getelementptr inbounds float, float* %1856, i64 %1858
%1860 = load float, float* %1859
%1861 = fcmp une float %1860, 0.000000e+00
br i1 %1861, label %1862, label %1880
1862: ; preds = %1857
%1863 = icmp eq i64 %1849, %1858
br i1 %1863, label %1868, label %1864
1864: ; preds = %1862
%1865 = load float, float* %1850
%1866 = load float, float* %1810
%1867 = tail call float @llvm.fmuladd.f32(float %1865, float %1860, float %1866)
store float %1867, float* %1810
br label %1868
1868: ; preds = %1864, %1862
br i1 %1545, label %1880, label %1869
1869: ; preds = %1868
%1870 = load float**, float*** %1813
%1871 = getelementptr inbounds float*, float** %1870, i64 %1849
%1872 = load float*, float** %1871
%1873 = getelementptr inbounds float, float* %1872, i64 %1858
%1874 = load float, float* %1873
%1875 = load float, float* %1850
%1876 = fmul float %1874, %1875
%1877 = load float, float* %1859
%1878 = load float, float* %1809
%1879 = tail call float @llvm.fmuladd.f32(float %1876, float %1877, float %1878)
store float %1879, float* %1809
br label %1880
1880: ; preds = %1857, %1869, %1868
%1881 = add nuw nsw i64 %1858, 1
%1882 = icmp eq i64 %1881, %1847
br i1 %1882, label %1883, label %1857
1883: ; preds = %1880, %1848
%1884 = add nuw nsw i64 %1849, 1
%1885 = icmp eq i64 %1884, %1847
br i1 %1885, label %1886, label %1848
1886: ; preds = %1883, %1837, %1828, %1831
%1887 = phi i32 [ %1830, %1831 ], [ %1830, %1828 ], [ %1838, %1837 ], [ %1838, %1883 ]
%1888 = add nuw nsw i64 %1829, 1
%1889 = icmp eq i64 %1888, %1557
br i1 %1889, label %1814, label %1828
1890: ; preds = %1814
%1891 = icmp eq i32 %1887, 0
br i1 %1891, label %1898, label %1892
1892: ; preds = %1890
%1893 = sitofp i32 %1887 to float
%1894 = load float, float* %1810
%1895 = fdiv float %1894, %1893
store float %1895, float* %1810
%1896 = load float, float* %1809
%1897 = fdiv float %1896, %1893
store float %1897, float* %1809
br label %1900
1898: ; preds = %1806, %1890
%1899 = load float, float* @HUGE_VAL
store float %1899, float* %1809
store float %1899, float* %1810
br label %1900
1900: ; preds = %1898, %1892
br i1 %1545, label %1961, label %1901
1901: ; preds = %1900
%1902 = getelementptr inbounds i32, i32* %8, i64 %1660
%1903 = load i32, i32* %1902
%1904 = icmp slt i32 %1903, 1
br i1 %1904, label %1961, label %1905
1905: ; preds = %1901
%1906 = getelementptr inbounds float**, float*** %10, i64 %1660
%1907 = add nuw i32 %1903, 1
%1908 = zext i32 %1907 to i64
br label %1909
1909: ; preds = %1952, %1905
%1910 = phi i64 [ 1, %1905 ], [ %1953, %1952 ]
%1911 = phi float [ 0.000000e+00, %1905 ], [ %1949, %1952 ]
%1912 = phi i32 [ 0, %1905 ], [ %1948, %1952 ]
br label %1913
1913: ; preds = %1909, %1947
%1914 = phi i64 [ 1, %1909 ], [ %1950, %1947 ]
%1915 = phi float [ %1911, %1909 ], [ %1949, %1947 ]
%1916 = phi i32 [ %1912, %1909 ], [ %1948, %1947 ]
%1917 = icmp eq i64 %1910, %1914
br i1 %1917, label %1947, label %1918
1918: ; preds = %1913
%1919 = load float**, float*** %1551
%1920 = getelementptr inbounds float*, float** %1919, i64 %1660
%1921 = load float*, float** %1920
%1922 = getelementptr inbounds float, float* %1921, i64 %1910
%1923 = load float, float* %1922
%1924 = fcmp une float %1923, 0.000000e+00
br i1 %1924, label %1925, label %1947
1925: ; preds = %1918
%1926 = getelementptr inbounds float, float* %1921, i64 %1914
%1927 = load float, float* %1926
%1928 = fcmp une float %1927, 0.000000e+00
br i1 %1928, label %1929, label %1947
1929: ; preds = %1925
%1930 = add nsw i32 %1916, 1
%1931 = load float**, float*** %1906
%1932 = getelementptr inbounds float*, float** %1931, i64 %1910
%1933 = load float*, float** %1932
%1934 = getelementptr inbounds float, float* %1933, i64 %1914
%1935 = load float, float* %1934
%1936 = load float, float* %1808
%1937 = fadd float %1935, %1936
store float %1937, float* %1808
%1938 = load float, float* %1934
%1939 = load float, float* %1922
%1940 = fmul float %1938, %1939
%1941 = load float, float* %1926
%1942 = load float, float* %1807
%1943 = tail call float @llvm.fmuladd.f32(float %1940, float %1941, float %1942)
store float %1943, float* %1807
%1944 = load float, float* %1922
%1945 = load float, float* %1926
%1946 = tail call float @llvm.fmuladd.f32(float %1944, float %1945, float %1915)
br label %1947
1947: ; preds = %1913, %1918, %1925, %1929
%1948 = phi i32 [ %1930, %1929 ], [ %1916, %1925 ], [ %1916, %1918 ], [ %1916, %1913 ]
%1949 = phi float [ %1946, %1929 ], [ %1915, %1925 ], [ %1915, %1918 ], [ %1915, %1913 ]
%1950 = add nuw nsw i64 %1914, 1
%1951 = icmp eq i64 %1950, %1908
br i1 %1951, label %1952, label %1913
1952: ; preds = %1947
%1953 = add nuw nsw i64 %1910, 1
%1954 = icmp eq i64 %1953, %1908
br i1 %1954, label %1955, label %1909
1955: ; preds = %1952
%1956 = icmp eq i32 %1948, 0
br i1 %1956, label %1961, label %1957
1957: ; preds = %1955
%1958 = sitofp i32 %1948 to float
%1959 = load float, float* %1808
%1960 = fdiv float %1959, %1958
br label %1964
1961: ; preds = %1901, %1900, %1955
%1962 = phi float [ %1949, %1955 ], [ 0.000000e+00, %1900 ], [ 0.000000e+00, %1901 ]
%1963 = load float, float* @HUGE_VAL
br label %1964
1964: ; preds = %1961, %1957
%1965 = phi float [ %1960, %1957 ], [ %1963, %1961 ]
%1966 = phi float [ %1949, %1957 ], [ %1962, %1961 ]
store float %1965, float* %1808
%1967 = fcmp une float %1966, 0.000000e+00
br i1 %1967, label %1968, label %1971
1968: ; preds = %1964
%1969 = load float, float* %1807
%1970 = fdiv float %1969, %1966
br label %1973
1971: ; preds = %1964
%1972 = load float, float* @HUGE_VAL
br label %1973
1973: ; preds = %1968, %1971
%1974 = phi float [ %1972, %1971 ], [ %1970, %1968 ]
store float %1974, float* %1807
%1975 = add nuw nsw i64 %1660, 1
%1976 = icmp eq i64 %1975, %1554
br i1 %1976, label %1664, label %1659
1977: ; preds = %2020
br i1 %30, label %2036, label %1978
1978: ; preds = %1977
%1979 = add nsw i64 %1669, -1
%1980 = and i64 %1669, 3
%1981 = icmp ult i64 %1979, 3
br i1 %1981, label %2023, label %1982
1982: ; preds = %1978
%1983 = and i64 %1669, 4294967292
br label %2043
1984: ; preds = %1665, %2020
%1985 = phi i64 [ 0, %1665 ], [ %2021, %2020 ]
%1986 = getelementptr inbounds float*, float** %25, i64 %1985
%1987 = load float*, float** %1986
store float 0.000000e+00, float* %1987
%1988 = getelementptr inbounds float*, float** %24, i64 %1985
%1989 = load float*, float** %1988
store float 0.000000e+00, float* %1989
%1990 = getelementptr inbounds float*, float** %23, i64 %1985
%1991 = load float*, float** %1990
store float 0.000000e+00, float* %1991
%1992 = getelementptr inbounds float*, float** %22, i64 %1985
%1993 = load float*, float** %1992
store float 0.000000e+00, float* %1993
br i1 %43, label %2020, label %1994
1994: ; preds = %1984, %2018
%1995 = phi float [ %2019, %2018 ], [ 0.000000e+00, %1984 ]
%1996 = phi i64 [ %2016, %2018 ], [ 1, %1984 ]
%1997 = getelementptr inbounds float, float* %1993, i64 %1996
%1998 = load float, float* %1997
%1999 = fdiv float %1998, %1666
%2000 = fadd float %1995, %1999
store float %2000, float* %1993
%2001 = getelementptr inbounds float, float* %1991, i64 %1996
%2002 = load float, float* %2001
%2003 = fdiv float %2002, %1666
%2004 = load float, float* %1991
%2005 = fadd float %2004, %2003
store float %2005, float* %1991
%2006 = getelementptr inbounds float, float* %1989, i64 %1996
%2007 = load float, float* %2006
%2008 = fdiv float %2007, %1666
%2009 = load float, float* %1989
%2010 = fadd float %2009, %2008
store float %2010, float* %1989
%2011 = getelementptr inbounds float, float* %1987, i64 %1996
%2012 = load float, float* %2011
%2013 = fdiv float %2012, %1666
%2014 = load float, float* %1987
%2015 = fadd float %2014, %2013
store float %2015, float* %1987
%2016 = add nuw nsw i64 %1996, 1
%2017 = icmp eq i64 %2016, %1670
br i1 %2017, label %2020, label %2018
2018: ; preds = %1994
%2019 = load float, float* %1993
br label %1994
2020: ; preds = %1994, %1984
%2021 = add nuw nsw i64 %1985, 1
%2022 = icmp eq i64 %2021, %1669
br i1 %2022, label %1977, label %1984
2023: ; preds = %2043, %1978
%2024 = phi i64 [ 0, %1978 ], [ %2065, %2043 ]
%2025 = icmp eq i64 %1980, 0
br i1 %2025, label %2036, label %2026
2026: ; preds = %2023, %2026
%2027 = phi i64 [ %2033, %2026 ], [ %2024, %2023 ]
%2028 = phi i64 [ %2034, %2026 ], [ 0, %2023 ]
%2029 = getelementptr inbounds float*, float** %27, i64 %2027
%2030 = load float*, float** %2029
store float 0.000000e+00, float* %2030
%2031 = getelementptr inbounds float*, float** %26, i64 %2027
%2032 = load float*, float** %2031
store float 0.000000e+00, float* %2032
%2033 = add nuw nsw i64 %2027, 1
%2034 = add i64 %2028, 1
%2035 = icmp eq i64 %2034, %1980
br i1 %2035, label %2036, label %2026
2036: ; preds = %2023, %2026, %1664, %1977
br i1 %43, label %2187, label %2037
2037: ; preds = %2036
%2038 = sitofp i32 %3 to float
%2039 = add nuw i32 %1, 1
%2040 = add nuw i32 %3, 1
%2041 = zext i32 %2040 to i64
%2042 = zext i32 %2039 to i64
br label %2068
2043: ; preds = %2043, %1982
%2044 = phi i64 [ 0, %1982 ], [ %2065, %2043 ]
%2045 = phi i64 [ 0, %1982 ], [ %2066, %2043 ]
%2046 = getelementptr inbounds float*, float** %27, i64 %2044
%2047 = load float*, float** %2046
store float 0.000000e+00, float* %2047
%2048 = getelementptr inbounds float*, float** %26, i64 %2044
%2049 = load float*, float** %2048
store float 0.000000e+00, float* %2049
%2050 = or i64 %2044, 1
%2051 = getelementptr inbounds float*, float** %27, i64 %2050
%2052 = load float*, float** %2051
store float 0.000000e+00, float* %2052
%2053 = getelementptr inbounds float*, float** %26, i64 %2050
%2054 = load float*, float** %2053
store float 0.000000e+00, float* %2054
%2055 = or i64 %2044, 2
%2056 = getelementptr inbounds float*, float** %27, i64 %2055
%2057 = load float*, float** %2056
store float 0.000000e+00, float* %2057
%2058 = getelementptr inbounds float*, float** %26, i64 %2055
%2059 = load float*, float** %2058
store float 0.000000e+00, float* %2059
%2060 = or i64 %2044, 3
%2061 = getelementptr inbounds float*, float** %27, i64 %2060
%2062 = load float*, float** %2061
store float 0.000000e+00, float* %2062
%2063 = getelementptr inbounds float*, float** %26, i64 %2060
%2064 = load float*, float** %2063
store float 0.000000e+00, float* %2064
%2065 = add nuw nsw i64 %2044, 4
%2066 = add i64 %2045, 4
%2067 = icmp eq i64 %2066, %1983
br i1 %2067, label %2023, label %2043
2068: ; preds = %2037, %2184
%2069 = phi i64 [ 1, %2037 ], [ %2185, %2184 ]
br i1 %30, label %2184, label %2070
2070: ; preds = %2068
%2071 = getelementptr inbounds i32, i32* %8, i64 %2069
%2072 = getelementptr inbounds i32*, i32** %9, i64 %2069
br label %2073
2073: ; preds = %2070, %2170
%2074 = phi i64 [ 0, %2070 ], [ %2182, %2170 ]
%2075 = getelementptr inbounds i32*, i32** %16, i64 %2074
%2076 = load i32*, i32** %2075
%2077 = getelementptr inbounds i32, i32* %2076, i64 %2069
%2078 = load i32, i32* %2077
%2079 = icmp sgt i32 %2078, 1
br i1 %2079, label %2080, label %2162
2080: ; preds = %2073
%2081 = load i32, i32* %2071
%2082 = icmp slt i32 %2081, 1
br i1 %2082, label %2143, label %2083
2083: ; preds = %2080
%2084 = getelementptr inbounds float**, float*** %12, i64 %2074
%2085 = load float**, float*** %2084
%2086 = getelementptr inbounds float*, float** %2085, i64 %2069
%2087 = load float*, float** %2086
%2088 = load i32*, i32** %2072
%2089 = zext i32 %2081 to i64
%2090 = and i64 %2089, 1
%2091 = icmp eq i32 %2081, 1
br i1 %2091, label %2126, label %2092
2092: ; preds = %2083
%2093 = and i64 %2089, 4294967294
br label %2094
2094: ; preds = %2094, %2092
%2095 = phi i64 [ 1, %2092 ], [ %2121, %2094 ]
%2096 = phi <2 x float> [ zeroinitializer, %2092 ], [ %2120, %2094 ]
%2097 = phi i64 [ 0, %2092 ], [ %2122, %2094 ]
%2098 = getelementptr inbounds float, float* %2087, i64 %2095
%2099 = load float, float* %2098
%2100 = getelementptr inbounds i32, i32* %2088, i64 %2095
%2101 = load i32, i32* %2100
%2102 = sitofp i32 %2101 to float
%2103 = fmul float %2099, %2102
%2104 = insertelement <2 x float> poison, float %2099, i64 0
%2105 = insertelement <2 x float> %2104, float %2103, i64 1
%2106 = insertelement <2 x float> poison, float %2102, i64 0
%2107 = shufflevector <2 x float> %2106, <2 x float> poison, <2 x i32> zeroinitializer
%2108 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %2105, <2 x float> %2107, <2 x float> %2096)
%2109 = add nuw nsw i64 %2095, 1
%2110 = getelementptr inbounds float, float* %2087, i64 %2109
%2111 = load float, float* %2110
%2112 = getelementptr inbounds i32, i32* %2088, i64 %2109
%2113 = load i32, i32* %2112
%2114 = sitofp i32 %2113 to float
%2115 = fmul float %2111, %2114
%2116 = insertelement <2 x float> poison, float %2111, i64 0
%2117 = insertelement <2 x float> %2116, float %2115, i64 1
%2118 = insertelement <2 x float> poison, float %2114, i64 0
%2119 = shufflevector <2 x float> %2118, <2 x float> poison, <2 x i32> zeroinitializer
%2120 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %2117, <2 x float> %2119, <2 x float> %2108)
%2121 = add nuw nsw i64 %2095, 2
%2122 = add i64 %2097, 2
%2123 = icmp eq i64 %2122, %2093
br i1 %2123, label %2124, label %2094
2124: ; preds = %2094
%2125 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %2117, <2 x float> %2119, <2 x float> %2108)
br label %2126
2126: ; preds = %2124, %2083
%2127 = phi <2 x float> [ undef, %2083 ], [ %2125, %2124 ]
%2128 = phi i64 [ 1, %2083 ], [ %2121, %2124 ]
%2129 = phi <2 x float> [ zeroinitializer, %2083 ], [ %2120, %2124 ]
%2130 = icmp eq i64 %2090, 0
br i1 %2130, label %2143, label %2131
2131: ; preds = %2126
%2132 = getelementptr inbounds float, float* %2087, i64 %2128
%2133 = load float, float* %2132
%2134 = getelementptr inbounds i32, i32* %2088, i64 %2128
%2135 = load i32, i32* %2134
%2136 = sitofp i32 %2135 to float
%2137 = fmul float %2133, %2136
%2138 = insertelement <2 x float> poison, float %2133, i64 0
%2139 = insertelement <2 x float> %2138, float %2137, i64 1
%2140 = insertelement <2 x float> poison, float %2136, i64 0
%2141 = shufflevector <2 x float> %2140, <2 x float> poison, <2 x i32> zeroinitializer
%2142 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %2139, <2 x float> %2141, <2 x float> %2129)
br label %2143
2143: ; preds = %2131, %2126, %2080
%2144 = phi <2 x float> [ zeroinitializer, %2080 ], [ %2127, %2126 ], [ %2142, %2131 ]
%2145 = getelementptr inbounds float*, float** %26, i64 %2074
%2146 = load float*, float** %2145
%2147 = getelementptr inbounds float, float* %2146, i64 %2069
%2148 = extractelement <2 x float> %2144, i64 0
store float %2148, float* %2147
%2149 = fneg float %2148
%2150 = extractelement <2 x float> %2144, i64 1
%2151 = tail call float @llvm.fmuladd.f32(float %2149, float %2148, float %2150)
%2152 = fpext float %2151 to double
%2153 = sitofp i32 %2078 to double
%2154 = fadd double %2153, -1.000000e+00
%2155 = fdiv double %2153, %2154
%2156 = fmul double %2155, %2152
%2157 = fptrunc double %2156 to float
%2158 = getelementptr inbounds float*, float** %27, i64 %2074
%2159 = load float*, float** %2158
%2160 = getelementptr inbounds float, float* %2159, i64 %2069
store float %2157, float* %2160
%2161 = load float, float* %2147
br label %2170
2162: ; preds = %2073
%2163 = load float, float* @HUGE_VAL
%2164 = getelementptr inbounds float*, float** %27, i64 %2074
%2165 = load float*, float** %2164
%2166 = getelementptr inbounds float, float* %2165, i64 %2069
store float %2163, float* %2166
%2167 = getelementptr inbounds float*, float** %26, i64 %2074
%2168 = load float*, float** %2167
%2169 = getelementptr inbounds float, float* %2168, i64 %2069
store float %2163, float* %2169
br label %2170
2170: ; preds = %2162, %2143
%2171 = phi float* [ %2165, %2162 ], [ %2159, %2143 ]
%2172 = phi float [ %2163, %2162 ], [ %2161, %2143 ]
%2173 = phi float* [ %2168, %2162 ], [ %2146, %2143 ]
%2174 = fdiv float %2172, %2038
%2175 = load float, float* %2173
%2176 = fadd float %2175, %2174
store float %2176, float* %2173
%2177 = getelementptr inbounds float, float* %2171, i64 %2069
%2178 = load float, float* %2177
%2179 = fdiv float %2178, %2038
%2180 = load float, float* %2171
%2181 = fadd float %2180, %2179
store float %2181, float* %2171
%2182 = add nuw nsw i64 %2074, 1
%2183 = icmp eq i64 %2182, %2042
br i1 %2183, label %2184, label %2073
2184: ; preds = %2170, %2068
%2185 = add nuw nsw i64 %2069, 1
%2186 = icmp eq i64 %2185, %2041
br i1 %2186, label %2187, label %2068
2187: ; preds = %2184, %2036
%2188 = tail call i32 @free_matrix(float** %147, i32 0, i32 %1, i32 0, i32 %3)
%2189 = tail call i32 @free_ivector(i32* %29, i32 0, i32 %1)
ret void
}