#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 i, j;
  int max;
  double scale_factor[14];
  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;
    if (max != i)
      for (j = 0; j < 6; j++)
        alpha_prior[i][j] = first_alpha_prior[i][j];
  }
  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;
  }
  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.7)
    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.15)
      for (j = 0; j < 6; j++)
        alpha_prior[i][j] = first_alpha_prior[i][j];
    else {
      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]);
      int bad = 0;
      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];
    }
  }
  int max_weight = 0;
  for (i = 0; i < max_gen; i++) {
    scale_factor[i] = alpha_prior[i][0];
    for (j = 1; j < 6; j++)
      scale_factor[i] += alpha_prior[i][j];
    if (weight[i][0] > weight[max_weight][0])
      max_weight = i;
  }
  for (i = 0; i < max_gen; i++)
    if (i != max_weight)
      scale_factor[i] = scale_factor[max_weight] / scale_factor[i];
  for (i = 0; i < max_gen; i++)
    if (i != max_weight && weight[i][0] < 4.0)
      for (j = 0; j < 6; j++)
        alpha_prior[i][j] =
            ((1 > (int)ceil(scale_factor[i] * (double)alpha_prior[i][j]))
                 ? 1
                 : (int)ceil(scale_factor[i] * (double)alpha_prior[i][j]));
}


x86 assembly (clang, -O0):
<check_alpha_sanity>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    1214 <check_alpha_sanity+0xf4>
movl   $0x0,-0x34(%rbp)
movl   $0x1,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    11ab <check_alpha_sanity+0x8b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1198 <check_alpha_sanity+0x78>
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    119d <check_alpha_sanity+0x7d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115c <check_alpha_sanity+0x3c>
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     1201 <check_alpha_sanity+0xe1>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    11fc <check_alpha_sanity+0xdc>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11be <check_alpha_sanity+0x9e>
jmp    1201 <check_alpha_sanity+0xe1>
jmp    1206 <check_alpha_sanity+0xe6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1144 <check_alpha_sanity+0x24>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12e7 <check_alpha_sanity+0x1c7>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    %eax,-0x35c(%rbp)
movl   $0x1,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1279 <check_alpha_sanity+0x159>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x35c(%rbp),%eax
mov    %eax,-0x35c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1242 <check_alpha_sanity+0x122>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    12d4 <check_alpha_sanity+0x1b4>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
cvtsi2sdl -0x35c(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1280 <check_alpha_sanity+0x160>
jmp    12d9 <check_alpha_sanity+0x1b9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    121b <check_alpha_sanity+0xfb>
movl   $0x4,-0x2c(%rbp)
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  0xccc(%rip),%xmm0
ucomisd -0x358(%rbp),%xmm0
ff
jbe    138c <check_alpha_sanity+0x26c>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1387 <check_alpha_sanity+0x267>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1349 <check_alpha_sanity+0x229>
jmp    138c <check_alpha_sanity+0x26c>
movl   $0x5,-0x2c(%rbp)
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  0xc2f(%rip),%xmm0
ucomisd -0x358(%rbp),%xmm0
ff
jbe    1431 <check_alpha_sanity+0x311>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    142c <check_alpha_sanity+0x30c>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ee <check_alpha_sanity+0x2ce>
jmp    1431 <check_alpha_sanity+0x311>
movl   $0x6,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17ef <check_alpha_sanity+0x6cf>
mov    -0x2c(%rbp),%edi
mov    -0x1c(%rbp),%ecx
lea    -0x360(%rbp),%rsi
lea    -0x364(%rbp),%rdx
call   1040 <get_het_alleles@plt>
mov    -0x364(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    1490 <check_alpha_sanity+0x370>
mov    -0x360(%rbp),%eax
mov    %eax,-0x368(%rbp)
mov    -0x364(%rbp),%eax
mov    %eax,-0x360(%rbp)
mov    -0x368(%rbp),%eax
mov    %eax,-0x364(%rbp)
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0xb44(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1528 <check_alpha_sanity+0x408>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1523 <check_alpha_sanity+0x403>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14e5 <check_alpha_sanity+0x3c5>
jmp    17dc <check_alpha_sanity+0x6bc>
mov    -0x1c(%rbp),%eax
cmp    -0x360(%rbp),%eax
jne    156b <check_alpha_sanity+0x44b>
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x360(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xac3(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    160a <check_alpha_sanity+0x4ea>
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x360(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa8f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    15c6 <check_alpha_sanity+0x4a6>
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x360(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x378(%rbp)
ff
jmp    15db <check_alpha_sanity+0x4bb>
movsd  0xa52(%rip),%xmm0
movsd  %xmm0,-0x378(%rbp)
ff
jmp    15db <check_alpha_sanity+0x4bb>
movsd  -0x378(%rbp),%xmm1
ff
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x360(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
movsd  0x9f5(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    164b <check_alpha_sanity+0x52b>
movsd  0x9e2(%rip),%xmm0
movsd  %xmm0,-0x380(%rbp)
ff
jmp    1671 <check_alpha_sanity+0x551>
movslq -0x1c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x380(%rbp)
ff
movsd  -0x380(%rbp),%xmm1
ff
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x36c(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1780 <check_alpha_sanity+0x660>
mov    -0x30(%rbp),%eax
cmp    -0x360(%rbp),%eax
je     176d <check_alpha_sanity+0x64d>
mov    -0x30(%rbp),%eax
cmp    -0x364(%rbp),%eax
je     176d <check_alpha_sanity+0x64d>
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x360(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
ja     1757 <check_alpha_sanity+0x637>
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x364(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1768 <check_alpha_sanity+0x648>
movl   $0x1,-0x36c(%rbp)
movl   $0x6,-0x30(%rbp)
jmp    176d <check_alpha_sanity+0x64d>
jmp    1772 <check_alpha_sanity+0x652>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16b1 <check_alpha_sanity+0x591>
cmpl   $0x0,-0x36c(%rbp)
je     17d7 <check_alpha_sanity+0x6b7>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    17d2 <check_alpha_sanity+0x6b2>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1794 <check_alpha_sanity+0x674>
jmp    17d7 <check_alpha_sanity+0x6b7>
jmp    17dc <check_alpha_sanity+0x6bc>
jmp    17e1 <check_alpha_sanity+0x6c1>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1438 <check_alpha_sanity+0x318>
movl   $0x0,-0x370(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18b8 <check_alpha_sanity+0x798>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
movl   $0x1,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1873 <check_alpha_sanity+0x753>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
addsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1830 <check_alpha_sanity+0x710>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x370(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
ucomisd (%rax),%xmm0
jbe    18a5 <check_alpha_sanity+0x785>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x370(%rbp)
jmp    18aa <check_alpha_sanity+0x78a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1800 <check_alpha_sanity+0x6e0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1917 <check_alpha_sanity+0x7f7>
mov    -0x2c(%rbp),%eax
cmp    -0x370(%rbp),%eax
je     1904 <check_alpha_sanity+0x7e4>
movslq -0x370(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
divsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
jmp    1909 <check_alpha_sanity+0x7e9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18bf <check_alpha_sanity+0x79f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a22 <check_alpha_sanity+0x902>
mov    -0x2c(%rbp),%eax
cmp    -0x370(%rbp),%eax
je     1a0f <check_alpha_sanity+0x8ef>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x6c3(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1a0f <check_alpha_sanity+0x8ef>
movl   $0x0,-0x30(%rbp)
cmpl   $0x6,-0x30(%rbp)
jge    1a0a <check_alpha_sanity+0x8ea>
movslq -0x2c(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jle    19b2 <check_alpha_sanity+0x892>
mov    $0x1,%eax
mov    %eax,-0x384(%rbp)
jmp    19e3 <check_alpha_sanity+0x8c3>
movslq -0x2c(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %eax,-0x384(%rbp)
mov    -0x384(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    195e <check_alpha_sanity+0x83e>
jmp    1a0f <check_alpha_sanity+0x8ef>
jmp    1a14 <check_alpha_sanity+0x8f4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    191e <check_alpha_sanity+0x7fe>
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_alpha_sanity>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x358,%rsp
mov    %rdi,%r13
mov    (%rdi),%rax
mov    0x4(%rax),%edi
xor    %ebp,%ebp
cmp    (%rax),%edi
mov    0x8(%rax),%edi
setg   %bpl
cmp    (%rax,%rbp,4),%edi
mov    $0x2,%edi
cmovle %ebp,%edi
mov    0xc(%rax),%ebp
cmp    (%rax,%rdi,4),%ebp
mov    $0x3,%ebp
cmovle %edi,%ebp
mov    0x10(%rax),%edi
cmp    (%rax,%rbp,4),%edi
mov    $0x4,%edi
cmovle %ebp,%edi
mov    %ecx,%r14d
mov    %rdx,0x8(%rsp)
mov    %esi,%ebx
mov    0x14(%rax),%ecx
cmp    (%rax,%rdi,4),%ecx
jg     1182 <check_alpha_sanity+0x62>
test   %edi,%edi
je     11ac <check_alpha_sanity+0x8c>
mov    0x8(%rsp),%rcx
mov    (%rcx),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    0x8(%rcx),%edx
mov    %edx,0x8(%rax)
mov    0xc(%rcx),%edx
mov    %edx,0xc(%rax)
mov    0x10(%rcx),%edx
mov    %edx,0x10(%rax)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rax)
mov    0x8(%r13),%rax
mov    0x4(%rax),%ecx
xor    %edx,%edx
cmp    (%rax),%ecx
mov    0x8(%rax),%ecx
setg   %dl
cmp    (%rax,%rdx,4),%ecx
mov    $0x2,%ecx
cmovle %edx,%ecx
mov    0xc(%rax),%edx
cmp    (%rax,%rcx,4),%edx
mov    $0x3,%edx
cmovle %ecx,%edx
mov    0x10(%rax),%ecx
cmp    (%rax,%rdx,4),%ecx
mov    $0x4,%ecx
cmovle %edx,%ecx
mov    0x14(%rax),%edx
cmp    (%rax,%rcx,4),%edx
jg     11f1 <check_alpha_sanity+0xd1>
cmp    $0x1,%ecx
je     121c <check_alpha_sanity+0xfc>
mov    0x8(%rsp),%rcx
mov    0x8(%rcx),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    0x8(%rcx),%edx
mov    %edx,0x8(%rax)
mov    0xc(%rcx),%edx
mov    %edx,0xc(%rax)
mov    0x10(%rcx),%edx
mov    %edx,0x10(%rax)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rax)
mov    0x10(%r13),%rax
mov    0x4(%rax),%ecx
xor    %edx,%edx
cmp    (%rax),%ecx
mov    0x8(%rax),%ecx
setg   %dl
cmp    (%rax,%rdx,4),%ecx
mov    $0x2,%ecx
cmovle %edx,%ecx
mov    0xc(%rax),%edx
cmp    (%rax,%rcx,4),%edx
mov    $0x3,%edx
cmovle %ecx,%edx
mov    0x10(%rax),%ecx
cmp    (%rax,%rdx,4),%ecx
mov    $0x4,%ecx
cmovle %edx,%ecx
mov    0x14(%rax),%edx
cmp    (%rax,%rcx,4),%edx
jg     1261 <check_alpha_sanity+0x141>
cmp    $0x2,%ecx
je     128c <check_alpha_sanity+0x16c>
mov    0x8(%rsp),%rcx
mov    0x10(%rcx),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    0x8(%rcx),%edx
mov    %edx,0x8(%rax)
mov    0xc(%rcx),%edx
mov    %edx,0xc(%rax)
mov    0x10(%rcx),%edx
mov    %edx,0x10(%rax)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rax)
mov    0x18(%r13),%rax
mov    0x4(%rax),%ecx
xor    %edx,%edx
cmp    (%rax),%ecx
mov    0x8(%rax),%ecx
setg   %dl
cmp    (%rax,%rdx,4),%ecx
mov    $0x2,%ecx
cmovle %edx,%ecx
mov    0xc(%rax),%edx
cmp    (%rax,%rcx,4),%edx
mov    $0x3,%edx
cmovle %ecx,%edx
mov    0x10(%rax),%ecx
cmp    (%rax,%rdx,4),%ecx
mov    $0x4,%ecx
cmovle %edx,%ecx
mov    0x14(%rax),%edx
cmp    (%rax,%rcx,4),%edx
jg     12d1 <check_alpha_sanity+0x1b1>
cmp    $0x3,%ecx
je     12fc <check_alpha_sanity+0x1dc>
mov    0x8(%rsp),%rcx
mov    0x18(%rcx),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    0x8(%rcx),%edx
mov    %edx,0x8(%rax)
mov    0xc(%rcx),%edx
mov    %edx,0xc(%rax)
mov    0x10(%rcx),%edx
mov    %edx,0x10(%rax)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rax)
mov    %ebx,%esi
test   %ebx,%ebx
mov    %r8,0x28(%rsp)
jle    13f4 <check_alpha_sanity+0x2d4>
lea    0xd0(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rcx,8),%rdx
movq   (%rdx),%xmm0
pshufd $0x55,%xmm0,%xmm1
movq   0x8(%rdx),%xmm2
cvtdq2pd %xmm0,%xmm3
paddd  %xmm2,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm2,%xmm1
movq   0x10(%rdx),%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm4,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%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    1320 <check_alpha_sanity+0x200>
movsd  0x190(%rsp),%xmm0
movslq %r14d,%rdi
lea    (%rdi,%rdi,2),%rax
shl    $0x4,%rax
subsd  0xd0(%rsp,%rax,1),%xmm0
movsd  0xc43(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    13f7 <check_alpha_sanity+0x2d7>
mov    0x8(%rsp),%rax
mov    0x20(%rax),%rax
mov    0x20(%r13),%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)
jmp    13f7 <check_alpha_sanity+0x2d7>
movslq %r14d,%rdi
mov    %rsi,0x18(%rsp)
movsd  0x1c8(%rsp),%xmm0
mov    %rdi,0x20(%rsp)
lea    (%rdi,%rdi,2),%rax
shl    $0x4,%rax
subsd  0xd8(%rsp,%rax,1),%xmm0
movsd  0xbe5(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1458 <check_alpha_sanity+0x338>
mov    0x8(%rsp),%rcx
mov    0x28(%rcx),%rcx
mov    0x28(%r13),%rdx
mov    (%rcx),%esi
mov    %esi,(%rdx)
mov    0x4(%rcx),%esi
mov    %esi,0x4(%rdx)
mov    0x8(%rcx),%esi
mov    %esi,0x8(%rdx)
mov    0xc(%rcx),%esi
mov    %esi,0xc(%rdx)
mov    0x10(%rcx),%esi
mov    %esi,0x10(%rdx)
mov    0x14(%rcx),%ecx
mov    %ecx,0x14(%rdx)
mov    %ebx,0x14(%rsp)
cmp    $0x7,%ebx
jl     16ee <check_alpha_sanity+0x5ce>
lea    0x1d0(%rsp),%rbp
mov    0x20(%rsp),%rcx
lea    (%rsp,%rcx,8),%rcx
add    $0x1d0,%rcx
mov    %rcx,0x30(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rcx,2),%rcx
shl    $0x4,%rcx
add    $0xfffffffffffffee0,%rcx
mov    %rcx,0x38(%rsp)
mov    $0x6,%ebx
xor    %r12d,%r12d
lea    (%rsp,%rax,1),%r15
add    $0xb0,%r15
xchg   %ax,%ax
mov    %ebx,%edi
lea    0x40(%rsp),%rsi
lea    0x10(%rsp),%rdx
mov    %r14d,%ecx
call   1040 <get_het_alleles@plt>
mov    0x10(%rsp),%eax
cmp    %r14d,%eax
jne    14da <check_alpha_sanity+0x3ba>
mov    0x40(%rsp),%eax
mov    %r14d,0x40(%rsp)
mov    %eax,0x10(%rsp)
movslq %eax,%rsi
lea    0x0(,%rsi,8),%rdx
add    %rbp,%rdx
movsd  (%r12,%rdx,1),%xmm0
subsd  (%r15,%rsi,8),%xmm0
movsd  0xb14(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1550 <check_alpha_sanity+0x430>
mov    0x8(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    0x0(%r13,%rbx,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,%rbx
add    $0x30,%r12
cmp    %r12,0x38(%rsp)
jne    14b0 <check_alpha_sanity+0x390>
jmp    16ee <check_alpha_sanity+0x5ce>
nopw   0x0(%rax,%rax,1)
movslq 0x40(%rsp),%rcx
cmp    %r14d,%ecx
jne    1590 <check_alpha_sanity+0x470>
mov    0x30(%rsp),%rdi
movsd  (%rdi,%r12,1),%xmm0
addsd  0xab3(%rip),%xmm0
movsd  %xmm0,(%rdi,%r12,1)
mov    0x20(%rsp),%rdi
movsd  0xa98(%rip),%xmm1
jmp    15c4 <check_alpha_sanity+0x4a4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rcx,8),%xmm0
movsd  0xa7a(%rip),%xmm2
maxsd  %xmm2,%xmm0
lea    0x0(,%rcx,8),%rdi
add    %rbp,%rdi
movsd  (%r12,%rdi,1),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rdi,1)
movapd %xmm2,%xmm1
mov    %rcx,%rdi
lea    (%r15,%rsi,8),%rsi
maxsd  (%rsi),%xmm1
movsd  (%rdx,%r12,1),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%r12,1)
lea    0x0(,%rdi,8),%rdx
add    %rbp,%rdx
test   %ecx,%ecx
je     160f <check_alpha_sanity+0x4ef>
test   %eax,%eax
je     160f <check_alpha_sanity+0x4ef>
movsd  0x1d0(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
cmp    $0x1,%ecx
je     1639 <check_alpha_sanity+0x519>
cmp    $0x1,%eax
je     1639 <check_alpha_sanity+0x519>
movsd  0x1d8(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
cmp    $0x2,%ecx
je     1663 <check_alpha_sanity+0x543>
cmp    $0x2,%eax
je     1663 <check_alpha_sanity+0x543>
movsd  0x1e0(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
cmp    $0x3,%ecx
je     168d <check_alpha_sanity+0x56d>
cmp    $0x3,%eax
je     168d <check_alpha_sanity+0x56d>
movsd  0x1e8(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
cmp    $0x4,%ecx
je     16b7 <check_alpha_sanity+0x597>
cmp    $0x4,%eax
je     16b7 <check_alpha_sanity+0x597>
movsd  0x1f0(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
cmp    $0x5,%ecx
je     1532 <check_alpha_sanity+0x412>
cmp    $0x5,%eax
je     1532 <check_alpha_sanity+0x412>
movsd  0x1f8(%rsp,%r12,1),%xmm1
ucomisd (%rdx,%r12,1),%xmm1
ja     1502 <check_alpha_sanity+0x3e2>
ucomisd %xmm0,%xmm1
jbe    1532 <check_alpha_sanity+0x412>
jmp    1502 <check_alpha_sanity+0x3e2>
mov    0x14(%rsp),%edi
test   %edi,%edi
mov    0x28(%rsp),%rbx
mov    0x18(%rsp),%r12
jle    19ed <check_alpha_sanity+0x8cd>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    171b <check_alpha_sanity+0x5fb>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %edx,%ecx
cmp    %rax,%r12
je     1784 <check_alpha_sanity+0x664>
mov    0x0(%r13,%rax,8),%rdx
xorps  %xmm0,%xmm0
cvtsi2sdl (%rdx),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rdx),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rdx),%xmm0
xorps  %xmm2,%xmm2
cvtsi2sdl 0xc(%rdx),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rdx),%xmm0
addsd  %xmm2,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x14(%rdx),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp,%rax,8)
mov    (%rbx,%rax,8),%rdx
movsd  (%rdx),%xmm0
movslq %ecx,%rdx
mov    (%rbx,%rdx,8),%rdx
ucomisd (%rdx),%xmm0
mov    %eax,%edx
ja     1710 <check_alpha_sanity+0x5f0>
mov    %ecx,%edx
jmp    1710 <check_alpha_sanity+0x5f0>
test   %edi,%edi
jle    19ed <check_alpha_sanity+0x8cd>
movslq %edx,%rax
mov    %eax,%r14d
cmp    $0x1,%r12d
jne    17a2 <check_alpha_sanity+0x682>
xor    %ecx,%ecx
test   $0x1,%r12b
jne    17fa <check_alpha_sanity+0x6da>
jmp    1811 <check_alpha_sanity+0x6f1>
mov    %r12d,%edx
and    $0xfffffffe,%edx
xor    %esi,%esi
jmp    17b9 <check_alpha_sanity+0x699>
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %rdx,%rsi
je     17f0 <check_alpha_sanity+0x6d0>
mov    %rsi,%rcx
cmp    %rsi,%r14
je     17d3 <check_alpha_sanity+0x6b3>
movsd  0x40(%rsp,%rax,8),%xmm0
divsd  0x40(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x40(%rsp,%rcx,8)
lea    0x1(%rcx),%rsi
cmp    %r14,%rsi
je     17b0 <check_alpha_sanity+0x690>
movsd  0x40(%rsp,%rax,8),%xmm0
divsd  0x48(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x48(%rsp,%rcx,8)
jmp    17b0 <check_alpha_sanity+0x690>
add    $0x2,%rcx
test   $0x1,%r12b
je     1811 <check_alpha_sanity+0x6f1>
cmp    %r14,%rcx
je     1811 <check_alpha_sanity+0x6f1>
movsd  0x40(%rsp,%rax,8),%xmm0
divsd  0x40(%rsp,%rcx,8),%xmm0
movsd  %xmm0,0x40(%rsp,%rcx,8)
test   %edi,%edi
jle    19ed <check_alpha_sanity+0x8cd>
xor    %ebp,%ebp
movsd  0x805(%rip),%xmm0
jmp    184e <check_alpha_sanity+0x72e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rbp,8),%rax
mov    %r15d,0x14(%rax)
movsd  0x7e7(%rip),%xmm0
add    $0x1,%rbp
cmp    %rbp,%r12
je     19ed <check_alpha_sanity+0x8cd>
cmp    %rbp,%r14
je     1841 <check_alpha_sanity+0x721>
mov    (%rbx,%rbp,8),%rax
ucomisd (%rax),%xmm0
jbe    1841 <check_alpha_sanity+0x721>
movsd  0x40(%rsp,%rbp,8),%xmm1
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax),%xmm0
movsd  %xmm1,0x8(%rsp)
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %rax,%rcx
mov    $0x1,%r15d
mov    $0x1,%eax
test   %ecx,%ecx
jle    18a7 <check_alpha_sanity+0x787>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    %eax,(%rcx)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4(%rcx),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    18e0 <check_alpha_sanity+0x7c0>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %rax,%r15
mov    0x0(%r13,%rbp,8),%rax
mov    %r15d,0x4(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %rax,%rcx
mov    $0x1,%r15d
mov    $0x1,%eax
test   %ecx,%ecx
jle    1926 <check_alpha_sanity+0x806>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    %eax,0x8(%rcx)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc(%rcx),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    1960 <check_alpha_sanity+0x840>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %rax,%r15
mov    0x0(%r13,%rbp,8),%rax
mov    %r15d,0xc(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    %rax,%rcx
mov    $0x1,%r15d
mov    $0x1,%eax
test   %ecx,%ecx
jle    19a6 <check_alpha_sanity+0x886>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl 0x10(%rax),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    %eax,0x10(%rcx)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x14(%rcx),%xmm0
mulsd  0x8(%rsp),%xmm0
call   1030 <ceil@plt>
test   %eax,%eax
jle    1830 <check_alpha_sanity+0x710>
mov    0x0(%r13,%rbp,8),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl 0x14(%rax),%xmm1
movsd  0x8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %rax,%r15
jmp    1830 <check_alpha_sanity+0x710>
add    $0x358,%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) {
%6 = alloca i32**
%7 = alloca i32
%8 = alloca i32**
%9 = alloca i32
%10 = alloca double**
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [14 x double]
%15 = alloca [14 x [6 x double]]
%16 = alloca double
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store i32** %0, i32*** %6
store i32 %1, i32* %7
store i32** %2, i32*** %8
store i32 %3, i32* %9
store double** %4, double*** %10
store i32 0, i32* %11
br label %23
23: ; preds = %87, %5
%24 = load i32, i32* %11
%25 = icmp slt i32 %24, 4
br i1 %25, label %26, label %90
26: ; preds = %23
store i32 0, i32* %13
store i32 1, i32* %12
br label %27
27: ; preds = %53, %26
%28 = load i32, i32* %12
%29 = icmp slt i32 %28, 6
br i1 %29, label %30, label %56
30: ; preds = %27
%31 = load i32**, i32*** %6
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i32*, i32** %31, i64 %33
%35 = load i32*, i32** %34
%36 = load i32, i32* %12
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %35, i64 %37
%39 = load i32, i32* %38
%40 = load i32**, i32*** %6
%41 = load i32, i32* %11
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i32*, i32** %40, i64 %42
%44 = load i32*, i32** %43
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
%48 = load i32, i32* %47
%49 = icmp sgt i32 %39, %48
br i1 %49, label %50, label %52
50: ; preds = %30
%51 = load i32, i32* %12
store i32 %51, i32* %13
br label %52
52: ; preds = %50, %30
br label %53
53: ; preds = %52
%54 = load i32, i32* %12
%55 = add nsw i32 %54, 1
store i32 %55, i32* %12
br label %27
56: ; preds = %27
%57 = load i32, i32* %13
%58 = load i32, i32* %11
%59 = icmp ne i32 %57, %58
br i1 %59, label %60, label %86
60: ; preds = %56
store i32 0, i32* %12
br label %61
61: ; preds = %82, %60
%62 = load i32, i32* %12
%63 = icmp slt i32 %62, 6
br i1 %63, label %64, label %85
64: ; preds = %61
%65 = load i32**, i32*** %8
%66 = load i32, i32* %11
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32*, i32** %65, i64 %67
%69 = load i32*, i32** %68
%70 = load i32, i32* %12
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %69, i64 %71
%73 = load i32, i32* %72
%74 = load i32**, i32*** %6
%75 = load i32, i32* %11
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32*, i32** %74, i64 %76
%78 = load i32*, i32** %77
%79 = load i32, i32* %12
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
store i32 %73, i32* %81
br label %82
82: ; preds = %64
%83 = load i32, i32* %12
%84 = add nsw i32 %83, 1
store i32 %84, i32* %12
br label %61
85: ; preds = %61
br label %86
86: ; preds = %85, %56
br label %87
87: ; preds = %86
%88 = load i32, i32* %11
%89 = add nsw i32 %88, 1
store i32 %89, i32* %11
br label %23
90: ; preds = %23
store i32 0, i32* %11
br label %91
91: ; preds = %149, %90
%92 = load i32, i32* %11
%93 = load i32, i32* %7
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %152
95: ; preds = %91
%96 = load i32**, i32*** %6
%97 = load i32, i32* %11
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32*, i32** %96, i64 %98
%100 = load i32*, i32** %99
%101 = getelementptr inbounds i32, i32* %100, i64 0
%102 = load i32, i32* %101
store i32 %102, i32* %17
store i32 1, i32* %12
br label %103
103: ; preds = %118, %95
%104 = load i32, i32* %12
%105 = icmp slt i32 %104, 6
br i1 %105, label %106, label %121
106: ; preds = %103
%107 = load i32**, i32*** %6
%108 = load i32, i32* %11
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32*, i32** %107, i64 %109
%111 = load i32*, i32** %110
%112 = load i32, i32* %12
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
%115 = load i32, i32* %114
%116 = load i32, i32* %17
%117 = add nsw i32 %116, %115
store i32 %117, i32* %17
br label %118
118: ; preds = %106
%119 = load i32, i32* %12
%120 = add nsw i32 %119, 1
store i32 %120, i32* %12
br label %103
121: ; preds = %103
store i32 0, i32* %12
br label %122
122: ; preds = %145, %121
%123 = load i32, i32* %12
%124 = icmp slt i32 %123, 6
br i1 %124, label %125, label %148
125: ; preds = %122
%126 = load i32**, i32*** %6
%127 = load i32, i32* %11
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32*, i32** %126, i64 %128
%130 = load i32*, i32** %129
%131 = load i32, i32* %12
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i32, i32* %130, i64 %132
%134 = load i32, i32* %133
%135 = sitofp i32 %134 to double
%136 = load i32, i32* %17
%137 = sitofp i32 %136 to double
%138 = fdiv double %135, %137
%139 = load i32, i32* %11
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %140
%142 = load i32, i32* %12
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [6 x double], [6 x double]* %141, i64 0, i64 %143
store double %138, double* %144
br label %145
145: ; preds = %125
%146 = load i32, i32* %12
%147 = add nsw i32 %146, 1
store i32 %147, i32* %12
br label %122
148: ; preds = %122
br label %149
149: ; preds = %148
%150 = load i32, i32* %11
%151 = add nsw i32 %150, 1
store i32 %151, i32* %11
br label %91
152: ; preds = %91
store i32 4, i32* %11
%153 = load i32, i32* %11
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %154
%156 = load i32, i32* %11
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [6 x double], [6 x double]* %155, i64 0, i64 %157
%159 = load double, double* %158
%160 = load i32, i32* %9
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %161
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [6 x double], [6 x double]* %162, i64 0, i64 %164
%166 = load double, double* %165
%167 = fsub double %159, %166
store double %167, double* %16
%168 = load double, double* %16
%169 = fcmp olt double %168, 5.000000e-01
br i1 %169, label %170, label %196
170: ; preds = %152
store i32 0, i32* %12
br label %171
171: ; preds = %192, %170
%172 = load i32, i32* %12
%173 = icmp slt i32 %172, 6
br i1 %173, label %174, label %195
174: ; preds = %171
%175 = load i32**, i32*** %8
%176 = load i32, i32* %11
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32*, i32** %175, i64 %177
%179 = load i32*, i32** %178
%180 = load i32, i32* %12
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %179, i64 %181
%183 = load i32, i32* %182
%184 = load i32**, i32*** %6
%185 = load i32, i32* %11
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32*, i32** %184, i64 %186
%188 = load i32*, i32** %187
%189 = load i32, i32* %12
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %188, i64 %190
store i32 %183, i32* %191
br label %192
192: ; preds = %174
%193 = load i32, i32* %12
%194 = add nsw i32 %193, 1
store i32 %194, i32* %12
br label %171
195: ; preds = %171
br label %196
196: ; preds = %195, %152
store i32 5, i32* %11
%197 = load i32, i32* %11
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %198
%200 = load i32, i32* %11
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [6 x double], [6 x double]* %199, i64 0, i64 %201
%203 = load double, double* %202
%204 = load i32, i32* %9
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %205
%207 = load i32, i32* %11
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [6 x double], [6 x double]* %206, i64 0, i64 %208
%210 = load double, double* %209
%211 = fsub double %203, %210
store double %211, double* %16
%212 = load double, double* %16
%213 = fcmp olt double %212, 0x3FE6666666666666
br i1 %213, label %214, label %240
214: ; preds = %196
store i32 0, i32* %12
br label %215
215: ; preds = %236, %214
%216 = load i32, i32* %12
%217 = icmp slt i32 %216, 6
br i1 %217, label %218, label %239
218: ; preds = %215
%219 = load i32**, i32*** %8
%220 = load i32, i32* %11
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32*, i32** %219, i64 %221
%223 = load i32*, i32** %222
%224 = load i32, i32* %12
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i32, i32* %223, i64 %225
%227 = load i32, i32* %226
%228 = load i32**, i32*** %6
%229 = load i32, i32* %11
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32*, i32** %228, i64 %230
%232 = load i32*, i32** %231
%233 = load i32, i32* %12
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
store i32 %227, i32* %235
br label %236
236: ; preds = %218
%237 = load i32, i32* %12
%238 = add nsw i32 %237, 1
store i32 %238, i32* %12
br label %215
239: ; preds = %215
br label %240
240: ; preds = %239, %196
store i32 6, i32* %11
br label %241
241: ; preds = %448, %240
%242 = load i32, i32* %11
%243 = load i32, i32* %7
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %451
245: ; preds = %241
%246 = load i32, i32* %11
%247 = load i32, i32* %9
%248 = call i32 @get_het_alleles(i32 %246, i32* %18, i32* %19, i32 %247)
%249 = load i32, i32* %19
%250 = load i32, i32* %9
%251 = icmp eq i32 %249, %250
br i1 %251, label %252, label %256
252: ; preds = %245
%253 = load i32, i32* %18
store i32 %253, i32* %20
%254 = load i32, i32* %19
store i32 %254, i32* %18
%255 = load i32, i32* %20
store i32 %255, i32* %19
br label %256
256: ; preds = %252, %245
%257 = load i32, i32* %11
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %258
%260 = load i32, i32* %19
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [6 x double], [6 x double]* %259, i64 0, i64 %261
%263 = load double, double* %262
%264 = load i32, i32* %9
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %265
%267 = load i32, i32* %19
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds [6 x double], [6 x double]* %266, i64 0, i64 %268
%270 = load double, double* %269
%271 = fsub double %263, %270
%272 = fcmp olt double %271, 1.500000e-01
br i1 %272, label %273, label %299
273: ; preds = %256
store i32 0, i32* %12
br label %274
274: ; preds = %295, %273
%275 = load i32, i32* %12
%276 = icmp slt i32 %275, 6
br i1 %276, label %277, label %298
277: ; preds = %274
%278 = load i32**, i32*** %8
%279 = load i32, i32* %11
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i32*, i32** %278, i64 %280
%282 = load i32*, i32** %281
%283 = load i32, i32* %12
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32, i32* %282, i64 %284
%286 = load i32, i32* %285
%287 = load i32**, i32*** %6
%288 = load i32, i32* %11
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32*, i32** %287, i64 %289
%291 = load i32*, i32** %290
%292 = load i32, i32* %12
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
store i32 %286, i32* %294
br label %295
295: ; preds = %277
%296 = load i32, i32* %12
%297 = add nsw i32 %296, 1
store i32 %297, i32* %12
br label %274
298: ; preds = %274
br label %447
299: ; preds = %256
%300 = load i32, i32* %9
%301 = load i32, i32* %18
%302 = icmp eq i32 %300, %301
br i1 %302, label %303, label %312
303: ; preds = %299
%304 = load i32, i32* %11
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %305
%307 = load i32, i32* %18
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [6 x double], [6 x double]* %306, i64 0, i64 %308
%310 = load double, double* %309
%311 = fsub double %310, 5.000000e-02
store double %311, double* %309
br label %340
312: ; preds = %299
%313 = load i32, i32* %9
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %314
%316 = load i32, i32* %18
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [6 x double], [6 x double]* %315, i64 0, i64 %317
%319 = load double, double* %318
%320 = fcmp ogt double %319, 5.000000e-02
br i1 %320, label %321, label %329
321: ; preds = %312
%322 = load i32, i32* %9
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %323
%325 = load i32, i32* %18
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds [6 x double], [6 x double]* %324, i64 0, i64 %326
%328 = load double, double* %327
br label %330
329: ; preds = %312
br label %330
330: ; preds = %329, %321
%331 = phi double [ %328, %321 ], [ 5.000000e-02, %329 ]
%332 = load i32, i32* %11
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %333
%335 = load i32, i32* %18
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds [6 x double], [6 x double]* %334, i64 0, i64 %336
%338 = load double, double* %337
%339 = fsub double %338, %331
store double %339, double* %337
br label %340
340: ; preds = %330, %303
%341 = load i32, i32* %9
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %342
%344 = load i32, i32* %19
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds [6 x double], [6 x double]* %343, i64 0, i64 %345
%347 = load double, double* %346
%348 = fcmp ogt double 5.000000e-02, %347
br i1 %348, label %349, label %350
349: ; preds = %340
br label %358
350: ; preds = %340
%351 = load i32, i32* %9
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %352
%354 = load i32, i32* %19
%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 %358
358: ; preds = %350, %349
%359 = phi double [ 5.000000e-02, %349 ], [ %357, %350 ]
%360 = load i32, i32* %11
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %361
%363 = load i32, i32* %19
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [6 x double], [6 x double]* %362, i64 0, i64 %364
%366 = load double, double* %365
%367 = fsub double %366, %359
store double %367, double* %365
store i32 0, i32* %21
store i32 0, i32* %12
br label %368
368: ; preds = %414, %358
%369 = load i32, i32* %12
%370 = icmp slt i32 %369, 6
br i1 %370, label %371, label %417
371: ; preds = %368
%372 = load i32, i32* %12
%373 = load i32, i32* %18
%374 = icmp ne i32 %372, %373
br i1 %374, label %375, label %413
375: ; preds = %371
%376 = load i32, i32* %12
%377 = load i32, i32* %19
%378 = icmp ne i32 %376, %377
br i1 %378, label %379, label %413
379: ; preds = %375
%380 = load i32, i32* %11
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %381
%383 = load i32, i32* %12
%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
%387 = load i32, i32* %11
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %388
%390 = load i32, i32* %18
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds [6 x double], [6 x double]* %389, i64 0, i64 %391
%393 = load double, double* %392
%394 = fcmp ogt double %386, %393
br i1 %394, label %411, label %395
395: ; preds = %379
%396 = load i32, i32* %11
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %397
%399 = load i32, i32* %12
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [6 x double], [6 x double]* %398, i64 0, i64 %400
%402 = load double, double* %401
%403 = load i32, i32* %11
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [14 x [6 x double]], [14 x [6 x double]]* %15, i64 0, i64 %404
%406 = load i32, i32* %19
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds [6 x double], [6 x double]* %405, i64 0, i64 %407
%409 = load double, double* %408
%410 = fcmp ogt double %402, %409
br i1 %410, label %411, label %412
411: ; preds = %395, %379
store i32 1, i32* %21
store i32 6, i32* %12
br label %412
412: ; preds = %411, %395
br label %413
413: ; preds = %412, %375, %371
br label %414
414: ; preds = %413
%415 = load i32, i32* %12
%416 = add nsw i32 %415, 1
store i32 %416, i32* %12
br label %368
417: ; preds = %368
%418 = load i32, i32* %21
%419 = icmp ne i32 %418, 0
br i1 %419, label %420, label %446
420: ; preds = %417
store i32 0, i32* %12
br label %421
421: ; preds = %442, %420
%422 = load i32, i32* %12
%423 = icmp slt i32 %422, 6
br i1 %423, label %424, label %445
424: ; preds = %421
%425 = load i32**, i32*** %8
%426 = load i32, i32* %11
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i32*, i32** %425, i64 %427
%429 = load i32*, i32** %428
%430 = load i32, i32* %12
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i32, i32* %429, i64 %431
%433 = load i32, i32* %432
%434 = load i32**, i32*** %6
%435 = load i32, i32* %11
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds i32*, i32** %434, i64 %436
%438 = load i32*, i32** %437
%439 = load i32, i32* %12
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %438, i64 %440
store i32 %433, i32* %441
br label %442
442: ; preds = %424
%443 = load i32, i32* %12
%444 = add nsw i32 %443, 1
store i32 %444, i32* %12
br label %421
445: ; preds = %421
br label %446
446: ; preds = %445, %417
br label %447
447: ; preds = %446, %298
br label %448
448: ; preds = %447
%449 = load i32, i32* %11
%450 = add nsw i32 %449, 1
store i32 %450, i32* %11
br label %241
451: ; preds = %241
store i32 0, i32* %22
store i32 0, i32* %11
br label %452
452: ; preds = %509, %451
%453 = load i32, i32* %11
%454 = load i32, i32* %7
%455 = icmp slt i32 %453, %454
br i1 %455, label %456, label %512
456: ; preds = %452
%457 = load i32**, i32*** %6
%458 = load i32, i32* %11
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i32*, i32** %457, i64 %459
%461 = load i32*, i32** %460
%462 = getelementptr inbounds i32, i32* %461, i64 0
%463 = load i32, i32* %462
%464 = sitofp i32 %463 to double
%465 = load i32, i32* %11
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %466
store double %464, double* %467
store i32 1, i32* %12
br label %468
468: ; preds = %487, %456
%469 = load i32, i32* %12
%470 = icmp slt i32 %469, 6
br i1 %470, label %471, label %490
471: ; preds = %468
%472 = load i32**, i32*** %6
%473 = load i32, i32* %11
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32*, i32** %472, i64 %474
%476 = load i32*, i32** %475
%477 = load i32, i32* %12
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i32, i32* %476, i64 %478
%480 = load i32, i32* %479
%481 = sitofp i32 %480 to double
%482 = load i32, i32* %11
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %483
%485 = load double, double* %484
%486 = fadd double %485, %481
store double %486, double* %484
br label %487
487: ; preds = %471
%488 = load i32, i32* %12
%489 = add nsw i32 %488, 1
store i32 %489, i32* %12
br label %468
490: ; preds = %468
%491 = load double**, double*** %10
%492 = load i32, i32* %11
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds double*, double** %491, i64 %493
%495 = load double*, double** %494
%496 = getelementptr inbounds double, double* %495, i64 0
%497 = load double, double* %496
%498 = load double**, double*** %10
%499 = load i32, i32* %22
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double*, double** %498, i64 %500
%502 = load double*, double** %501
%503 = getelementptr inbounds double, double* %502, i64 0
%504 = load double, double* %503
%505 = fcmp ogt double %497, %504
br i1 %505, label %506, label %508
506: ; preds = %490
%507 = load i32, i32* %11
store i32 %507, i32* %22
br label %508
508: ; preds = %506, %490
br label %509
509: ; preds = %508
%510 = load i32, i32* %11
%511 = add nsw i32 %510, 1
store i32 %511, i32* %11
br label %452
512: ; preds = %452
store i32 0, i32* %11
br label %513
513: ; preds = %535, %512
%514 = load i32, i32* %11
%515 = load i32, i32* %7
%516 = icmp slt i32 %514, %515
br i1 %516, label %517, label %538
517: ; preds = %513
%518 = load i32, i32* %11
%519 = load i32, i32* %22
%520 = icmp ne i32 %518, %519
br i1 %520, label %521, label %534
521: ; preds = %517
%522 = load i32, i32* %22
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %523
%525 = load double, double* %524
%526 = load i32, i32* %11
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %527
%529 = load double, double* %528
%530 = fdiv double %525, %529
%531 = load i32, i32* %11
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %532
store double %530, double* %533
br label %534
534: ; preds = %521, %517
br label %535
535: ; preds = %534
%536 = load i32, i32* %11
%537 = add nsw i32 %536, 1
store i32 %537, i32* %11
br label %513
538: ; preds = %513
store i32 0, i32* %11
br label %539
539: ; preds = %613, %538
%540 = load i32, i32* %11
%541 = load i32, i32* %7
%542 = icmp slt i32 %540, %541
br i1 %542, label %543, label %616
543: ; preds = %539
%544 = load i32, i32* %11
%545 = load i32, i32* %22
%546 = icmp ne i32 %544, %545
br i1 %546, label %547, label %612
547: ; preds = %543
%548 = load double**, double*** %10
%549 = load i32, i32* %11
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds double*, double** %548, i64 %550
%552 = load double*, double** %551
%553 = getelementptr inbounds double, double* %552, i64 0
%554 = load double, double* %553
%555 = fcmp olt double %554, 4.000000e+00
br i1 %555, label %556, label %612
556: ; preds = %547
store i32 0, i32* %12
br label %557
557: ; preds = %608, %556
%558 = load i32, i32* %12
%559 = icmp slt i32 %558, 6
br i1 %559, label %560, label %611
560: ; preds = %557
%561 = load i32, i32* %11
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %562
%564 = load double, double* %563
%565 = load i32**, i32*** %6
%566 = load i32, i32* %11
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i32*, i32** %565, i64 %567
%569 = load i32*, i32** %568
%570 = load i32, i32* %12
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds i32, i32* %569, i64 %571
%573 = load i32, i32* %572
%574 = sitofp i32 %573 to double
%575 = fmul double %564, %574
%576 = call i64 @ceil(double %575)
%577 = trunc i64 %576 to i32
%578 = icmp sgt i32 1, %577
br i1 %578, label %579, label %580
579: ; preds = %560
br label %598
580: ; preds = %560
%581 = load i32, i32* %11
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [14 x double], [14 x double]* %14, i64 0, i64 %582
%584 = load double, double* %583
%585 = load i32**, i32*** %6
%586 = load i32, i32* %11
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i32*, i32** %585, i64 %587
%589 = load i32*, i32** %588
%590 = load i32, i32* %12
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds i32, i32* %589, i64 %591
%593 = load i32, i32* %592
%594 = sitofp i32 %593 to double
%595 = fmul double %584, %594
%596 = call i64 @ceil(double %595)
%597 = trunc i64 %596 to i32
br label %598
598: ; preds = %580, %579
%599 = phi i32 [ 1, %579 ], [ %597, %580 ]
%600 = load i32**, i32*** %6
%601 = load i32, i32* %11
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds i32*, i32** %600, i64 %602
%604 = load i32*, i32** %603
%605 = load i32, i32* %12
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %604, i64 %606
store i32 %599, i32* %607
br label %608
608: ; preds = %598
%609 = load i32, i32* %12
%610 = add nsw i32 %609, 1
store i32 %610, i32* %12
br label %557
611: ; preds = %557
br label %612
612: ; preds = %611, %547, %543
br label %613
613: ; preds = %612
%614 = load i32, i32* %11
%615 = add nsw i32 %614, 1
store i32 %615, i32* %11
br label %539
616: ; preds = %539
ret void
}

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