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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ ceil(double);
int /*<<< orphan*/ get_het_alleles(int, int *, int *, int);
void check_alpha_sanity(int **alpha_prior, int max_gen, int **first_alpha_prior,
                        int ref, double **weight, int normal_factor) {
  int i, j;
  int max;
  double frac[14][6];
  double temp;
  for (i = 0; i < max_gen; i++) {
    int tot = alpha_prior[i][0];
    for (j = 1; j < 6; j++)
      tot += alpha_prior[i][j];
    for (j = 0; j < 6; j++)
      frac[i][j] = (double)alpha_prior[i][j] / (double)tot;
  }
  for (i = 0; i < 4; i++) {
    max = 0;
    for (j = 1; j < 6; j++)
      if (alpha_prior[i][j] > alpha_prior[i][max])
        max = j;
    int bad = 0;
    if (max != i)
      bad = 1;
    else
      for (j = 0; j < 6; j++)
        if ((j != i) && (frac[i][j] > 0.3))
          bad = 1;
    if (bad)
      for (j = 0; j < 6; j++)
        alpha_prior[i][j] = first_alpha_prior[i][j];
  }
  i = 4;
  temp = frac[i][i] - frac[ref][i];
  if (temp < 0.5)
    for (j = 0; j < 6; j++)
      alpha_prior[i][j] = first_alpha_prior[i][j];
  i = 5;
  temp = frac[i][i] - frac[ref][i];
  if (temp < -0.1)
    for (j = 0; j < 6; j++)
      alpha_prior[i][j] = first_alpha_prior[i][j];
  for (i = 6; i < max_gen; i++) {
    int a, b;
    get_het_alleles(i, &a, &b, ref);
    if (b == ref) {
      int ti;
      ti = a;
      a = b;
      b = ti;
    }
    if (frac[i][b] - frac[ref][b] < 0.25)
      for (j = 0; j < 6; j++)
        alpha_prior[i][j] = first_alpha_prior[i][j];
    else {
      int bad = 0;
      if (ref == a)
        frac[i][a] -= 0.05;
      else
        frac[i][a] -= ((frac[ref][a] > 0.05) ? frac[ref][a] : 0.05);
      frac[i][b] -= ((0.05 > frac[ref][b]) ? 0.05 : frac[ref][b]);
      for (j = 0; j < 6; j++)
        if (j != a && j != b)
          if (frac[i][j] > frac[i][a] || frac[i][j] > frac[i][b]) {
            bad = 1;
            j = 6;
          }
      if (bad)
        for (j = 0; j < 6; j++)
          alpha_prior[i][j] = first_alpha_prior[i][j];
    }
  }
  for (i = 0; i < max_gen; i++) {
    double scale = alpha_prior[i][0];
    for (j = 1; j < 6; j++)
      scale += alpha_prior[i][j];
    scale = (double)normal_factor / scale;
    for (j = 0; j < 6; j++)
      if (alpha_prior[i][j] > 1)
        alpha_prior[i][j] =
            ((1 > (int)ceil(scale * (double)alpha_prior[i][j]))
                 ? 1
                 : (int)ceil(scale * (double)alpha_prior[i][j]));
  }
}


x86 assembly (clang, -O0):
<check_alpha_sanity>:
push   %rbp
mov    %rsp,%rbp
sub    $0x320,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1214 <check_alpha_sanity+0xf4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    %eax,-0x2ec(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    11a6 <check_alpha_sanity+0x86>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2ec(%rbp),%eax
mov    %eax,-0x2ec(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    116f <check_alpha_sanity+0x4f>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1201 <check_alpha_sanity+0xe1>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
cvtsi2sdl -0x2ec(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ad <check_alpha_sanity+0x8d>
jmp    1206 <check_alpha_sanity+0xe6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1148 <check_alpha_sanity+0x28>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    137d <check_alpha_sanity+0x25d>
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1282 <check_alpha_sanity+0x162>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    126f <check_alpha_sanity+0x14f>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1274 <check_alpha_sanity+0x154>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1233 <check_alpha_sanity+0x113>
movl   $0x0,-0x2f0(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     12a7 <check_alpha_sanity+0x187>
movl   $0x1,-0x2f0(%rbp)
jmp    1313 <check_alpha_sanity+0x1f3>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    130e <check_alpha_sanity+0x1ee>
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     12fb <check_alpha_sanity+0x1db>
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd39(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12fb <check_alpha_sanity+0x1db>
movl   $0x1,-0x2f0(%rbp)
jmp    1300 <check_alpha_sanity+0x1e0>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ae <check_alpha_sanity+0x18e>
jmp    1313 <check_alpha_sanity+0x1f3>
cmpl   $0x0,-0x2f0(%rbp)
je     136a <check_alpha_sanity+0x24a>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1365 <check_alpha_sanity+0x245>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1327 <check_alpha_sanity+0x207>
jmp    136a <check_alpha_sanity+0x24a>
jmp    136f <check_alpha_sanity+0x24f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    121b <check_alpha_sanity+0xfb>
movl   $0x4,-0x30(%rbp)
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  0xc36(%rip),%xmm0
ucomisd -0x2e8(%rbp),%xmm0
ff
jbe    1422 <check_alpha_sanity+0x302>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    141d <check_alpha_sanity+0x2fd>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13df <check_alpha_sanity+0x2bf>
jmp    1422 <check_alpha_sanity+0x302>
movl   $0x5,-0x30(%rbp)
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  0xb99(%rip),%xmm0
ucomisd -0x2e8(%rbp),%xmm0
ff
jbe    14c7 <check_alpha_sanity+0x3a7>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    14c2 <check_alpha_sanity+0x3a2>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1484 <check_alpha_sanity+0x364>
jmp    14c7 <check_alpha_sanity+0x3a7>
movl   $0x6,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1885 <check_alpha_sanity+0x765>
mov    -0x30(%rbp),%edi
mov    -0x1c(%rbp),%ecx
lea    -0x2f4(%rbp),%rsi
lea    -0x2f8(%rbp),%rdx
call   1040 <get_het_alleles@plt>
mov    -0x2f8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1526 <check_alpha_sanity+0x406>
mov    -0x2f4(%rbp),%eax
mov    %eax,-0x2fc(%rbp)
mov    -0x2f8(%rbp),%eax
mov    %eax,-0x2f4(%rbp)
mov    -0x2fc(%rbp),%eax
mov    %eax,-0x2f8(%rbp)
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xaa6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    15be <check_alpha_sanity+0x49e>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    15b9 <check_alpha_sanity+0x499>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    157b <check_alpha_sanity+0x45b>
jmp    1872 <check_alpha_sanity+0x752>
movl   $0x0,-0x300(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2f4(%rbp),%eax
jne    160b <check_alpha_sanity+0x4eb>
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa1b(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    16aa <check_alpha_sanity+0x58a>
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x9e7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1666 <check_alpha_sanity+0x546>
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
jmp    167b <check_alpha_sanity+0x55b>
movsd  0x9aa(%rip),%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
jmp    167b <check_alpha_sanity+0x55b>
movsd  -0x310(%rbp),%xmm1
ff
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
movsd  0x94d(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    16eb <check_alpha_sanity+0x5cb>
movsd  0x93a(%rip),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
jmp    1711 <check_alpha_sanity+0x5f1>
movslq -0x1c(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0x318(%rbp),%xmm1
ff
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1816 <check_alpha_sanity+0x6f6>
mov    -0x34(%rbp),%eax
cmp    -0x2f4(%rbp),%eax
je     1803 <check_alpha_sanity+0x6e3>
mov    -0x34(%rbp),%eax
cmp    -0x2f8(%rbp),%eax
je     1803 <check_alpha_sanity+0x6e3>
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f4(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
ja     17ed <check_alpha_sanity+0x6cd>
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x30(%rbp),%rcx
lea    -0x2e0(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2f8(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    17fe <check_alpha_sanity+0x6de>
movl   $0x1,-0x300(%rbp)
movl   $0x6,-0x34(%rbp)
jmp    1803 <check_alpha_sanity+0x6e3>
jmp    1808 <check_alpha_sanity+0x6e8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1747 <check_alpha_sanity+0x627>
cmpl   $0x0,-0x300(%rbp)
je     186d <check_alpha_sanity+0x74d>
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    1868 <check_alpha_sanity+0x748>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    182a <check_alpha_sanity+0x70a>
jmp    186d <check_alpha_sanity+0x74d>
jmp    1872 <check_alpha_sanity+0x752>
jmp    1877 <check_alpha_sanity+0x757>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14ce <check_alpha_sanity+0x3ae>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19e4 <check_alpha_sanity+0x8c4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x1,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    18f4 <check_alpha_sanity+0x7d4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
addsd  -0x308(%rbp),%xmm0
ff
movsd  %xmm0,-0x308(%rbp)
ff
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18b7 <check_alpha_sanity+0x797>
cvtsi2sdl -0x2c(%rbp),%xmm0
divsd  -0x308(%rbp),%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movl   $0x0,-0x34(%rbp)
cmpl   $0x6,-0x34(%rbp)
jge    19d1 <check_alpha_sanity+0x8b1>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    19be <check_alpha_sanity+0x89e>
movsd  -0x308(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    1979 <check_alpha_sanity+0x859>
mov    $0x1,%eax
mov    %eax,-0x31c(%rbp)
jmp    19a5 <check_alpha_sanity+0x885>
movsd  -0x308(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %eax,-0x31c(%rbp)
mov    -0x31c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    19c3 <check_alpha_sanity+0x8a3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1910 <check_alpha_sanity+0x7f0>
jmp    19d6 <check_alpha_sanity+0x8b6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    188c <check_alpha_sanity+0x76c>
add    $0x320,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_alpha_sanity>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2e8,%rsp
mov    %r9d,0x20(%rsp)
mov    %ecx,%r13d
mov    %esi,%r15d
mov    %rdi,%r12
mov    %esi,%esi
test   %r15d,%r15d
jle    11d7 <check_alpha_sanity+0xb7>
lea    0x60(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,8),%rdi
movq   (%rdi),%xmm0
pshufd $0x55,%xmm0,%xmm1
movq   0x8(%rdi),%xmm2
cvtdq2pd %xmm0,%xmm3
paddd  %xmm2,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm2,%xmm1
movq   0x10(%rdi),%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm4,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm3
cvtdq2pd %xmm2,%xmm1
divpd  %xmm0,%xmm1
movapd %xmm3,-0x20(%rax)
cvtdq2pd %xmm4,%xmm2
divpd  %xmm0,%xmm2
movapd %xmm1,-0x10(%rax)
movapd %xmm2,(%rax)
add    $0x1,%rcx
add    $0x30,%rax
cmp    %rcx,%rsi
jne    1160 <check_alpha_sanity+0x40>
mov    %rsi,0x28(%rsp)
lea    0x68(%rsp),%rax
xor    %ecx,%ecx
mov    $0x2,%r9d
mov    $0x3,%r10d
mov    $0x4,%r11d
mov    $0x5,%r14d
movsd  0xdfd(%rip),%xmm0
mov    $0x1,%r8d
jmp    1248 <check_alpha_sanity+0x128>
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rcx,8),%rsi
mov    (%rsi),%edi
mov    %edi,(%rbx)
mov    0x4(%rsi),%edi
mov    %edi,0x4(%rbx)
mov    0x8(%rsi),%edi
mov    %edi,0x8(%rbx)
mov    0xc(%rsi),%edi
mov    %edi,0xc(%rbx)
mov    0x10(%rsi),%edi
mov    %edi,0x10(%rbx)
mov    0x14(%rsi),%esi
mov    %esi,0x14(%rbx)
add    $0x1,%rcx
add    $0x30,%rax
cmp    $0x4,%rcx
je     1302 <check_alpha_sanity+0x1e2>
mov    (%r12,%rcx,8),%rbx
mov    0x4(%rbx),%esi
mov    0x8(%rbx),%edi
xor    %ebp,%ebp
cmp    (%rbx),%esi
setg   %bpl
cmp    (%rbx,%rbp,4),%edi
cmovg  %r9d,%ebp
mov    0xc(%rbx),%esi
cmp    (%rbx,%rbp,4),%esi
cmovg  %r10d,%ebp
mov    0x10(%rbx),%esi
cmp    (%rbx,%rbp,4),%esi
cmovg  %r11d,%ebp
mov    0x14(%rbx),%esi
cmp    (%rbx,%rbp,4),%esi
cmovg  %r14d,%ebp
cmp    %rbp,%rcx
jne    1210 <check_alpha_sanity+0xf0>
test   %rcx,%rcx
je     12a0 <check_alpha_sanity+0x180>
movsd  -0x28(%rax),%xmm1
xor    %esi,%esi
ucomisd %xmm0,%xmm1
seta   %sil
cmp    $0x1,%rcx
jne    12a2 <check_alpha_sanity+0x182>
jmp    12b5 <check_alpha_sanity+0x195>
xor    %esi,%esi
movsd  -0x20(%rax),%xmm1
ucomisd %xmm0,%xmm1
cmova  %r8d,%esi
cmp    $0x2,%rcx
je     12c8 <check_alpha_sanity+0x1a8>
movsd  -0x18(%rax),%xmm1
ucomisd %xmm0,%xmm1
cmova  %r8d,%esi
cmp    $0x3,%rcx
je     12d8 <check_alpha_sanity+0x1b8>
movsd  -0x10(%rax),%xmm1
ucomisd %xmm0,%xmm1
jbe    12d8 <check_alpha_sanity+0x1b8>
mov    $0x1,%esi
movsd  (%rax),%xmm1
ucomisd %xmm0,%xmm1
ja     1210 <check_alpha_sanity+0xf0>
movsd  -0x8(%rax),%xmm1
ucomisd %xmm0,%xmm1
ja     1210 <check_alpha_sanity+0xf0>
test   %esi,%esi
je     1236 <check_alpha_sanity+0x116>
jmp    1210 <check_alpha_sanity+0xf0>
movsd  0x120(%rsp),%xmm0
movslq %r13d,%rax
mov    %rax,0x30(%rsp)
lea    (%rax,%rax,2),%rax
shl    $0x4,%rax
subsd  0x60(%rsp,%rax,1),%xmm0
movsd  0xcdf(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    135a <check_alpha_sanity+0x23a>
mov    0x20(%rdx),%rcx
mov    0x20(%r12),%rdi
mov    (%rcx),%esi
mov    %esi,(%rdi)
mov    0x4(%rcx),%esi
mov    %esi,0x4(%rdi)
mov    0x8(%rcx),%esi
mov    %esi,0x8(%rdi)
mov    0xc(%rcx),%esi
mov    %esi,0xc(%rdi)
mov    0x10(%rcx),%esi
mov    %esi,0x10(%rdi)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rdi)
movsd  0x158(%rsp),%xmm0
subsd  0x68(%rsp,%rax,1),%xmm0
movsd  0xc9f(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    13a2 <check_alpha_sanity+0x282>
mov    0x28(%rdx),%rcx
mov    0x28(%r12),%rdi
mov    (%rcx),%esi
mov    %esi,(%rdi)
mov    0x4(%rcx),%esi
mov    %esi,0x4(%rdi)
mov    0x8(%rcx),%esi
mov    %esi,0x8(%rdi)
mov    0xc(%rcx),%esi
mov    %esi,0xc(%rdi)
mov    0x10(%rcx),%esi
mov    %esi,0x10(%rdi)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rdi)
mov    %rdx,0x18(%rsp)
mov    %r15d,0x24(%rsp)
cmp    $0x7,%r15d
jl     1630 <check_alpha_sanity+0x510>
lea    0x160(%rsp),%rbx
mov    0x30(%rsp),%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x160,%rcx
mov    %rcx,0x38(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rcx,2),%rcx
shl    $0x4,%rcx
add    $0xfffffffffffffee0,%rcx
mov    %rcx,0x8(%rsp)
mov    $0x6,%ebp
xor    %r15d,%r15d
lea    (%rsp,%rax,1),%r14
add    $0x40,%r14
nopl   0x0(%rax)
mov    %ebp,%edi
lea    0x10(%rsp),%rsi
lea    0x14(%rsp),%rdx
mov    %r13d,%ecx
call   1040 <get_het_alleles@plt>
mov    0x14(%rsp),%eax
cmp    %r13d,%eax
jne    142a <check_alpha_sanity+0x30a>
mov    0x10(%rsp),%eax
mov    %r13d,0x10(%rsp)
mov    %eax,0x14(%rsp)
movslq %eax,%rsi
lea    (%rbx,%rsi,8),%rdx
movsd  (%r15,%rdx,1),%xmm0
subsd  (%r14,%rsi,8),%xmm0
movsd  0xbd3(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    14a0 <check_alpha_sanity+0x380>
mov    0x18(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    (%r12,%rbp,8),%rcx
mov    (%rax),%edx
mov    %edx,(%rcx)
mov    0x4(%rax),%edx
mov    %edx,0x4(%rcx)
mov    0x8(%rax),%edx
mov    %edx,0x8(%rcx)
mov    0xc(%rax),%edx
mov    %edx,0xc(%rcx)
mov    0x10(%rax),%edx
mov    %edx,0x10(%rcx)
mov    0x14(%rax),%eax
mov    %eax,0x14(%rcx)
add    $0x1,%rbp
add    $0x30,%r15
cmp    %r15,0x8(%rsp)
jne    1400 <check_alpha_sanity+0x2e0>
jmp    1630 <check_alpha_sanity+0x510>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq 0x10(%rsp),%rcx
cmp    %r13d,%ecx
jne    14e0 <check_alpha_sanity+0x3c0>
mov    0x38(%rsp),%rdi
movsd  (%rdi,%r15,1),%xmm0
addsd  0xb6b(%rip),%xmm0
movsd  %xmm0,(%rdi,%r15,1)
mov    0x30(%rsp),%rdi
movsd  0xb50(%rip),%xmm1
jmp    150d <check_alpha_sanity+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rcx,8),%xmm0
movsd  0xb32(%rip),%xmm2
maxsd  %xmm2,%xmm0
lea    (%rbx,%rcx,8),%rdi
movsd  (%r15,%rdi,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdi,1)
movapd %xmm2,%xmm1
mov    %rcx,%rdi
lea    (%r14,%rsi,8),%rsi
maxsd  (%rsi),%xmm1
movsd  (%rdx,%r15,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%r15,1)
lea    (%rbx,%rdi,8),%rdx
test   %ecx,%ecx
je     1551 <check_alpha_sanity+0x431>
test   %eax,%eax
je     1551 <check_alpha_sanity+0x431>
movsd  0x160(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
ja     144b <check_alpha_sanity+0x32b>
cmp    $0x1,%ecx
je     157b <check_alpha_sanity+0x45b>
cmp    $0x1,%eax
je     157b <check_alpha_sanity+0x45b>
movsd  0x168(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
ja     144b <check_alpha_sanity+0x32b>
cmp    $0x2,%ecx
je     15a5 <check_alpha_sanity+0x485>
cmp    $0x2,%eax
je     15a5 <check_alpha_sanity+0x485>
movsd  0x170(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
ja     144b <check_alpha_sanity+0x32b>
cmp    $0x3,%ecx
je     15cf <check_alpha_sanity+0x4af>
cmp    $0x3,%eax
je     15cf <check_alpha_sanity+0x4af>
movsd  0x178(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
ja     144b <check_alpha_sanity+0x32b>
cmp    $0x4,%ecx
je     15f9 <check_alpha_sanity+0x4d9>
cmp    $0x4,%eax
je     15f9 <check_alpha_sanity+0x4d9>
movsd  0x180(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
ja     144b <check_alpha_sanity+0x32b>
cmp    $0x5,%ecx
je     147a <check_alpha_sanity+0x35a>
cmp    $0x5,%eax
je     147a <check_alpha_sanity+0x35a>
movsd  0x188(%rsp,%r15,1),%xmm1
ucomisd (%rdx,%r15,1),%xmm1
ja     144b <check_alpha_sanity+0x32b>
ucomisd %xmm0,%xmm1
jbe    147a <check_alpha_sanity+0x35a>
jmp    144b <check_alpha_sanity+0x32b>
cmpl   $0x0,0x24(%rsp)
mov    0x28(%rsp),%r14
jle    186f <check_alpha_sanity+0x74f>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x20(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %ebp,%ebp
jmp    168f <check_alpha_sanity+0x56f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbp,8),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl 0x14(%rax),%xmm1
movsd  0x8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    (%r12,%rbp,8),%rcx
mov    %eax,0x14(%rcx)
add    $0x1,%rbp
cmp    %rbp,%r14
je     186f <check_alpha_sanity+0x74f>
mov    (%r12,%rbp,8),%rcx
mov    (%rcx),%edx
mov    0x4(%rcx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x8(%rcx),%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sdl 0xc(%rcx),%xmm1
addsd  %xmm2,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x10(%rcx),%xmm2
xorps  %xmm3,%xmm3
cvtsi2sdl 0x14(%rcx),%xmm3
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm3
movsd  0x18(%rsp),%xmm1
divsd  %xmm3,%xmm1
cmp    $0x2,%edx
movsd  %xmm1,0x8(%rsp)
jl     1728 <check_alpha_sanity+0x608>
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    1714 <check_alpha_sanity+0x5f4>
mov    (%r12,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
jmp    1719 <check_alpha_sanity+0x5f9>
mov    $0x1,%eax
movsd  0x8(%rsp),%xmm1
mov    (%r12,%rbp,8),%rcx
mov    %eax,(%rcx)
mov    0x4(%rcx),%eax
cmp    $0x2,%eax
jl     176c <check_alpha_sanity+0x64c>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    175a <check_alpha_sanity+0x63a>
mov    (%r12,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
jmp    175f <check_alpha_sanity+0x63f>
mov    $0x1,%eax
movsd  0x8(%rsp),%xmm1
mov    (%r12,%rbp,8),%rcx
mov    %eax,0x4(%rcx)
mov    0x8(%rcx),%eax
cmp    $0x2,%eax
jl     17b3 <check_alpha_sanity+0x693>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    17a1 <check_alpha_sanity+0x681>
mov    (%r12,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
jmp    17a6 <check_alpha_sanity+0x686>
mov    $0x1,%eax
movsd  0x8(%rsp),%xmm1
mov    (%r12,%rbp,8),%rcx
mov    %eax,0x8(%rcx)
mov    0xc(%rcx),%eax
cmp    $0x2,%eax
jl     17fa <check_alpha_sanity+0x6da>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    17e8 <check_alpha_sanity+0x6c8>
mov    (%r12,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
jmp    17ed <check_alpha_sanity+0x6cd>
mov    $0x1,%eax
movsd  0x8(%rsp),%xmm1
mov    (%r12,%rbp,8),%rcx
mov    %eax,0xc(%rcx)
mov    0x10(%rcx),%eax
cmp    $0x2,%eax
jl     1841 <check_alpha_sanity+0x721>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    182f <check_alpha_sanity+0x70f>
mov    (%r12,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
jmp    1834 <check_alpha_sanity+0x714>
mov    $0x1,%eax
movsd  0x8(%rsp),%xmm1
mov    (%r12,%rbp,8),%rcx
mov    %eax,0x10(%rcx)
mov    0x14(%rcx),%eax
cmp    $0x2,%eax
jl     1682 <check_alpha_sanity+0x562>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jg     1660 <check_alpha_sanity+0x540>
mov    $0x1,%eax
jmp    167b <check_alpha_sanity+0x55b>
add    $0x2e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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