#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 */
int /*<<< orphan*/ ancestralGamma(double *, double *, double *, int, int const,
                                  int const);
int /*<<< orphan*/ assert(int /*<<< orphan*/);
int /*<<< orphan*/ rax_free(double *);
scalar_t__ rax_malloc(int);
void newviewFlexGamma_Ancestral(int tipCase, double *x1, double *x2,
                                double *extEV, double *tipVector,
                                unsigned char *tipX1, unsigned char *tipX2,
                                int n, double *left, double *right,
                                const int numStates, double *diagptable,
                                double *sumBuffer) {
  double *v, *x3 = (double *)rax_malloc(sizeof(double) * 4 * numStates);
  double x1px2;
  int i, j, l, k, scale;
  double *vl, *vr, al, ar;
  const int statesSquare = numStates * numStates, gammaStates = 4 * numStates;
  switch (tipCase) {
  case 0: {
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(tipVector[numStates * tipX1[i]]);
        vr = &(tipVector[numStates * tipX2[i]]);
        v = &(x3[numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
      ancestralGamma(x3, sumBuffer, diagptable, i, numStates, gammaStates);
    }
  } break;
  case 1: {
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(tipVector[numStates * tipX1[i]]);
        vr = &(x2[gammaStates * i + numStates * k]);
        v = &(x3[numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
      v = x3;
      scale = 1;
      for (l = 0; scale && (l < gammaStates); l++)
        scale =
            ((((v[l]) < 0) ? (-(v[l])) : (v[l])) <
             (1.0 /
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
      if (scale) {
        for (l = 0; l < gammaStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
      }
      ancestralGamma(x3, sumBuffer, diagptable, i, numStates, gammaStates);
    }
  } break;
  case 2:
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(x1[gammaStates * i + numStates * k]);
        vr = &(x2[gammaStates * i + numStates * k]);
        v = &(x3[numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
      v = x3;
      scale = 1;
      for (l = 0; scale && (l < gammaStates); l++)
        scale = ((
            (((v[l]) < 0) ? (-(v[l])) : (v[l])) <
            (1.0 /
             115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      if (scale) {
        for (l = 0; l < gammaStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
      }
      ancestralGamma(x3, sumBuffer, diagptable, i, numStates, gammaStates);
    }
    break;
  default:
    assert(0);
  }
  rax_free(x3);
}


x86 assembly (clang, -O0):
<newviewFlexGamma_Ancestral>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x30(%rbp),%edi
shl    $0x5,%edi
call   1030 <rax_malloc@plt>
mov    %rax,-0x40(%rbp)
mov    0x30(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0x84(%rbp)
mov    0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x88(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x8c(%rbp)
test   %eax,%eax
je     11e1 <newviewFlexGamma_Ancestral+0xa1>
jmp    11b9 <newviewFlexGamma_Ancestral+0x79>
mov    -0x8c(%rbp),%eax
sub    $0x1,%eax
je     141a <newviewFlexGamma_Ancestral+0x2da>
jmp    11cd <newviewFlexGamma_Ancestral+0x8d>
mov    -0x8c(%rbp),%eax
sub    $0x2,%eax
je     1777 <newviewFlexGamma_Ancestral+0x637>
jmp    1ad5 <newviewFlexGamma_Ancestral+0x995>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1415 <newviewFlexGamma_Ancestral+0x2d5>
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    13e8 <newviewFlexGamma_Ancestral+0x2a8>
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x4c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x4c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x58(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1297 <newviewFlexGamma_Ancestral+0x157>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    126d <newviewFlexGamma_Ancestral+0x12d>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    13d5 <newviewFlexGamma_Ancestral+0x295>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    135d <newviewFlexGamma_Ancestral+0x21d>
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12c1 <newviewFlexGamma_Ancestral+0x181>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    13c2 <newviewFlexGamma_Ancestral+0x282>
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1373 <newviewFlexGamma_Ancestral+0x233>
jmp    13c7 <newviewFlexGamma_Ancestral+0x287>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    129e <newviewFlexGamma_Ancestral+0x15e>
jmp    13da <newviewFlexGamma_Ancestral+0x29a>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    11fb <newviewFlexGamma_Ancestral+0xbb>
mov    -0x40(%rbp),%rdi
mov    0x40(%rbp),%rsi
mov    0x38(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
mov    0x30(%rbp),%r8d
mov    -0x88(%rbp),%r9d
call   1060 <ancestralGamma@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11e8 <newviewFlexGamma_Ancestral+0xa8>
jmp    1adc <newviewFlexGamma_Ancestral+0x99c>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1772 <newviewFlexGamma_Ancestral+0x632>
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    1622 <newviewFlexGamma_Ancestral+0x4e2>
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x4c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x58(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    14d1 <newviewFlexGamma_Ancestral+0x391>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14a7 <newviewFlexGamma_Ancestral+0x367>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    160f <newviewFlexGamma_Ancestral+0x4cf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1597 <newviewFlexGamma_Ancestral+0x457>
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    14fb <newviewFlexGamma_Ancestral+0x3bb>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    15fc <newviewFlexGamma_Ancestral+0x4bc>
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15ad <newviewFlexGamma_Ancestral+0x46d>
jmp    1601 <newviewFlexGamma_Ancestral+0x4c1>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14d8 <newviewFlexGamma_Ancestral+0x398>
jmp    1614 <newviewFlexGamma_Ancestral+0x4d4>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1434 <newviewFlexGamma_Ancestral+0x2f4>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x8d(%rbp)
je     165c <newviewFlexGamma_Ancestral+0x51c>
mov    -0x54(%rbp),%eax
cmp    -0x88(%rbp),%eax
setl   %al
mov    %al,-0x8d(%rbp)
mov    -0x8d(%rbp),%al
test   $0x1,%al
jne    166f <newviewFlexGamma_Ancestral+0x52f>
jmp    16f8 <newviewFlexGamma_Ancestral+0x5b8>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    16b6 <newviewFlexGamma_Ancestral+0x576>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    16cb <newviewFlexGamma_Ancestral+0x58b>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x92d(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1638 <newviewFlexGamma_Ancestral+0x4f8>
cmpl   $0x0,-0x5c(%rbp)
je     1745 <newviewFlexGamma_Ancestral+0x605>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1740 <newviewFlexGamma_Ancestral+0x600>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x8d8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1709 <newviewFlexGamma_Ancestral+0x5c9>
jmp    1745 <newviewFlexGamma_Ancestral+0x605>
mov    -0x40(%rbp),%rdi
mov    0x40(%rbp),%rsi
mov    0x38(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
mov    0x30(%rbp),%r8d
mov    -0x88(%rbp),%r9d
call   1060 <ancestralGamma@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1421 <newviewFlexGamma_Ancestral+0x2e1>
jmp    1adc <newviewFlexGamma_Ancestral+0x99c>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1ad0 <newviewFlexGamma_Ancestral+0x990>
movl   $0x0,-0x58(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    1980 <newviewFlexGamma_Ancestral+0x840>
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x58(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x58(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    182f <newviewFlexGamma_Ancestral+0x6ef>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1805 <newviewFlexGamma_Ancestral+0x6c5>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    196d <newviewFlexGamma_Ancestral+0x82d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    18f5 <newviewFlexGamma_Ancestral+0x7b5>
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   -0x84(%rbp),%ecx
mov    -0x54(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1859 <newviewFlexGamma_Ancestral+0x719>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    195a <newviewFlexGamma_Ancestral+0x81a>
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    190b <newviewFlexGamma_Ancestral+0x7cb>
jmp    195f <newviewFlexGamma_Ancestral+0x81f>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1836 <newviewFlexGamma_Ancestral+0x6f6>
jmp    1972 <newviewFlexGamma_Ancestral+0x832>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1791 <newviewFlexGamma_Ancestral+0x651>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x5c(%rbp)
mov    %al,-0x99(%rbp)
je     19ba <newviewFlexGamma_Ancestral+0x87a>
mov    -0x54(%rbp),%eax
cmp    -0x88(%rbp),%eax
setl   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    19cd <newviewFlexGamma_Ancestral+0x88d>
jmp    1a56 <newviewFlexGamma_Ancestral+0x916>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1a14 <newviewFlexGamma_Ancestral+0x8d4>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1a29 <newviewFlexGamma_Ancestral+0x8e9>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  0x5cf(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1996 <newviewFlexGamma_Ancestral+0x856>
cmpl   $0x0,-0x5c(%rbp)
je     1aa3 <newviewFlexGamma_Ancestral+0x963>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1a9e <newviewFlexGamma_Ancestral+0x95e>
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0x57a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1a67 <newviewFlexGamma_Ancestral+0x927>
jmp    1aa3 <newviewFlexGamma_Ancestral+0x963>
mov    -0x40(%rbp),%rdi
mov    0x40(%rbp),%rsi
mov    0x38(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
mov    0x30(%rbp),%r8d
mov    -0x88(%rbp),%r9d
call   1060 <ancestralGamma@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    177e <newviewFlexGamma_Ancestral+0x63e>
jmp    1adc <newviewFlexGamma_Ancestral+0x99c>
xor    %edi,%edi
call   1050 <assert@plt>
mov    -0x40(%rbp),%rdi
call   1040 <rax_free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newviewFlexGamma_Ancestral>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,0x120(%rsp)
mov    %r8,0x78(%rsp)
mov    %rcx,%r15
mov    %rdx,0x88(%rsp)
mov    %rsi,0x70(%rsp)
mov    %edi,%r12d
mov    0x1d0(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0x1c8(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0x1c0(%rsp),%ebx
mov    0x1b8(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x1b0(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x1a8(%rsp),%r14d
mov    0x1a0(%rsp),%rbp
mov    %ebx,%edi
shl    $0x5,%edi
call   1030 <rax_malloc@plt>
mov    %rax,0x18(%rsp)
mov    %ebx,%eax
imul   %ebx,%eax
lea    0x0(,%rbx,4),%ecx
mov    %ecx,0x14(%rsp)
movslq %ebx,%rcx
mov    %rcx,0x28(%rsp)
test   %r12d,%r12d
mov    %r15,0x30(%rsp)
mov    %rbx,(%rsp)
je     1970 <newviewFlexGamma_Ancestral+0x820>
cmp    $0x1,%r12d
je     1f15 <newviewFlexGamma_Ancestral+0xdc5>
cmp    $0x2,%r12d
jne    2670 <newviewFlexGamma_Ancestral+0x1520>
test   %r14d,%r14d
jle    2677 <newviewFlexGamma_Ancestral+0x1527>
mov    0x28(%rsp),%rdx
mov    %edx,%r13d
mov    0x14(%rsp),%ecx
movslq %ecx,%rsi
cmp    $0x2,%esi
mov    $0x1,%edi
cmovge %ecx,%edi
mov    %eax,%eax
mov    %rax,0x120(%rsp)
mov    %r14d,%eax
mov    %rax,0x40(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rdi,0x48(%rsp)
and    $0x7ffffffc,%edi
mov    %rdi,0x140(%rsp)
lea    -0x4(%rdi),%rax
mov    %rax,0x138(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %r13d,%r12d
and    $0xfffffffe,%r12d
mov    %rcx,%rax
mov    %rcx,0xe0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x118(%rsp)
mov    %rdi,%rax
mov    %rdi,0x130(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x128(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0x50(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r13,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x70(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x38(%rsp)
mov    %rsi,0x68(%rsp)
lea    0x0(,%rsi,8),%rax
mov    %rax,0x148(%rsp)
mov    0xa0(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xd0(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x90(%rsp)
mov    0x98(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xc8(%rsp)
mov    0x88(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x58(%rsp)
lea    0x30(%r15),%rax
mov    %rax,0xc0(%rsp)
lea    0x30(%rcx),%rax
mov    %rax,0xb8(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0xb0(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0xa8(%rsp)
xor    %ebx,%ebx
jmp    13f6 <newviewFlexGamma_Ancestral+0x2a6>
nopw   0x0(%rax,%rax,1)
mov    0x158(%rsp),%rsi
mov    0x150(%rsp),%rdx
mov    0x60(%rsp),%rbx
mov    %ebx,%ecx
mov    (%rsp),%r8
mov    0x14(%rsp),%r9d
call   1070 <ancestralGamma@plt>
add    $0x1,%rbx
mov    0x148(%rsp),%rax
add    %rax,0x38(%rsp)
add    %rax,0x58(%rsp)
cmp    0x40(%rsp),%rbx
je     2677 <newviewFlexGamma_Ancestral+0x1527>
mov    %rbx,0x60(%rsp)
imul   0x68(%rsp),%rbx
mov    %rbx,0x78(%rsp)
xor    %ebx,%ebx
mov    0x18(%rsp),%rdi
jmp    142b <newviewFlexGamma_Ancestral+0x2db>
nop
mov    0x80(%rsp),%rbx
add    $0x1,%rbx
cmp    $0x4,%rbx
mov    0x18(%rsp),%rdi
je     1820 <newviewFlexGamma_Ancestral+0x6d0>
cmpl   $0x0,(%rsp)
jle    1800 <newviewFlexGamma_Ancestral+0x6b0>
mov    %rbx,%rbp
imul   0x28(%rsp),%rbp
mov    0x78(%rsp),%rax
add    %rbp,%rax
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x110(%rsp)
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x108(%rsp)
lea    (%rdi,%rbp,8),%rax
mov    %rax,0x8(%rsp)
mov    %ebx,%eax
imul   (%rsp),%eax
cltq
lea    (%rdi,%rax,8),%rdi
xor    %esi,%esi
mov    0x50(%rsp),%rdx
call   1050 <memset@plt>
movapd 0x1b7c(%rip),%xmm7
mov    %rbx,0x80(%rsp)
imul   0x120(%rsp),%rbx
mov    0xd8(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0xf8(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rbp,8),%r15
mov    0xd0(%rsp),%rax
lea    (%rax,%rbx,8),%rsi
mov    0xc8(%rsp),%rax
mov    %rbx,0x100(%rsp)
lea    (%rax,%rbx,8),%rdi
mov    0x58(%rsp),%rax
lea    (%rax,%rbp,8),%r8
mov    0xb8(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rbp,8),%rbx
mov    0xb0(%rsp),%rbp
mov    0xc0(%rsp),%r10
xor    %r14d,%r14d
jmp    1541 <newviewFlexGamma_Ancestral+0x3f1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    0x90(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%rdi
add    %rdx,%r10
add    %rdx,%rbp
cmp    %r13,%r14
je     1410 <newviewFlexGamma_Ancestral+0x2c0>
cmpl   $0x1,(%rsp)
jne    1550 <newviewFlexGamma_Ancestral+0x400>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    15ad <newviewFlexGamma_Ancestral+0x45d>
nop
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r8,%rdx,8),%xmm2
movsd  (%r8,%rdx,8),%xmm3
movhpd -0x8(%r15,%rdx,8),%xmm2
movsd  -0x8(%rsi,%rdx,8),%xmm4
movsd  (%rsi,%rdx,8),%xmm1
movhpd -0x8(%rdi,%rdx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r15,%rdx,8),%xmm3
movhpd (%rdi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdx
movapd %xmm1,%xmm0
cmp    %rdx,%r12
jne    1560 <newviewFlexGamma_Ancestral+0x410>
mov    %r14,%r11
imul   0x28(%rsp),%r11
test   $0x1,%r13b
je     1610 <newviewFlexGamma_Ancestral+0x4c0>
mov    0x100(%rsp),%rcx
lea    (%r11,%rcx,1),%r9
add    %rdx,%r9
mov    0x108(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
mov    %r14,%rcx
mov    0x110(%rsp),%r14
movhpd (%r14,%rdx,8),%xmm0
mov    %rcx,%r14
mov    0xa0(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm2
mov    0x98(%rsp),%rdx
movhpd (%rdx,%r9,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,(%rsp)
jb     164c <newviewFlexGamma_Ancestral+0x4fc>
lea    (%r11,%r13,1),%rdx
mov    0x30(%rsp),%r9
lea    (%r9,%rdx,8),%rdx
cmp    %rdx,0x8(%rsp)
jae    16e0 <newviewFlexGamma_Ancestral+0x590>
lea    (%r9,%r11,8),%rdx
cmp    0xf8(%rsp),%rdx
jae    16e0 <newviewFlexGamma_Ancestral+0x590>
xor    %r9d,%r9d
mov    %r9,%rdx
test   $0x1,%r13b
je     1682 <newviewFlexGamma_Ancestral+0x532>
add    %r9,%r11
mov    0x30(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x8(%rsp),%rcx
addsd  (%rcx,%r9,8),%xmm1
movsd  %xmm1,(%rcx,%r9,8)
mov    %r9,%rdx
or     $0x1,%rdx
not    %r9
cmp    0x118(%rsp),%r9
je     1520 <newviewFlexGamma_Ancestral+0x3d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r13
jne    16a0 <newviewFlexGamma_Ancestral+0x550>
jmp    1520 <newviewFlexGamma_Ancestral+0x3d0>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xe8(%rsp)
je     17e9 <newviewFlexGamma_Ancestral+0x699>
mov    0x20(%rsp),%rdx
xor    %r9d,%r9d
nop
movupd -0x30(%r10,%r9,8),%xmm2
movupd -0x20(%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rax,%r9,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rax,%r9,8),%xmm2
movupd -0x10(%rax,%r9,8),%xmm5
movupd (%rax,%r9,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rax,%r9,8)
movupd %xmm3,-0x20(%rax,%r9,8)
movupd -0x10(%r10,%r9,8),%xmm2
movupd (%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rax,%r9,8)
movupd %xmm3,(%rax,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%rdx
jne    1700 <newviewFlexGamma_Ancestral+0x5b0>
testb  $0x1,0xe0(%rsp)
01
je     17d0 <newviewFlexGamma_Ancestral+0x680>
lea    (%r9,%r11,1),%rdx
mov    %r14,%rcx
mov    0x30(%rsp),%r14
movupd (%r14,%rdx,8),%xmm2
movupd 0x10(%r14,%rdx,8),%xmm3
mov    %rcx,%r14
mov    0x8(%rsp),%rcx
movupd (%rcx,%r9,8),%xmm4
movupd 0x10(%rcx,%r9,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%r9,8)
movupd %xmm3,0x10(%rcx,%r9,8)
mov    0xf0(%rsp),%rdx
mov    %rdx,%r9
cmp    %r13,%rdx
je     1520 <newviewFlexGamma_Ancestral+0x3d0>
jmp    164f <newviewFlexGamma_Ancestral+0x4ff>
xor    %r9d,%r9d
testb  $0x1,0xe0(%rsp)
01
jne    1785 <newviewFlexGamma_Ancestral+0x635>
jmp    17d0 <newviewFlexGamma_Ancestral+0x680>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    $0x4,%rbx
jne    142b <newviewFlexGamma_Ancestral+0x2db>
jmp    13b0 <newviewFlexGamma_Ancestral+0x260>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,(%rsp)
jle    13b0 <newviewFlexGamma_Ancestral+0x260>
mov    $0x1,%eax
nop
movsd  -0x8(%rdi,%rax,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0x17be(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0x17e1(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0x17bd(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1877 <newviewFlexGamma_Ancestral+0x727>
lea    0x1(%rax),%rcx
cmp    0x68(%rsp),%rax
mov    %rcx,%rax
jl     1830 <newviewFlexGamma_Ancestral+0x6e0>
movsd  0x17a1(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    13b0 <newviewFlexGamma_Ancestral+0x260>
cmpl   $0x4,0x48(%rsp)
jae    1897 <newviewFlexGamma_Ancestral+0x747>
xor    %eax,%eax
jmp    1940 <newviewFlexGamma_Ancestral+0x7f0>
cmpq   $0x0,0x138(%rsp)
je     1962 <newviewFlexGamma_Ancestral+0x812>
mov    0x128(%rsp),%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
movupd 0x30(%rdi,%rax,8),%xmm3
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    18b0 <newviewFlexGamma_Ancestral+0x760>
testb  $0x1,0x130(%rsp)
01
je     1920 <newviewFlexGamma_Ancestral+0x7d0>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mov    0x140(%rsp),%rcx
mov    %rcx,%rax
cmp    0x48(%rsp),%rcx
je     13b0 <newviewFlexGamma_Ancestral+0x260>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  0x16db(%rip),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,0x48(%rsp)
jne    1940 <newviewFlexGamma_Ancestral+0x7f0>
jmp    13b0 <newviewFlexGamma_Ancestral+0x260>
xor    %eax,%eax
testb  $0x1,0x130(%rsp)
01
jne    1902 <newviewFlexGamma_Ancestral+0x7b2>
jmp    1920 <newviewFlexGamma_Ancestral+0x7d0>
mov    %rbp,0xd8(%rsp)
test   %r14d,%r14d
jle    2677 <newviewFlexGamma_Ancestral+0x1527>
mov    (%rsp),%r13d
lea    0x0(,%r13,8),%rcx
mov    %rcx,0xd0(%rsp)
mov    %eax,%ecx
mov    %r14d,%eax
mov    %rax,0xa8(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r15,%rsi
mov    %r13d,%r15d
and    $0xfffffffe,%r15d
mov    %rdx,%rax
mov    %rdx,0xe0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x88(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x80(%rsp)
mov    0x78(%rsp),%rax
add    $0x8,%rax
mov    %rax,0xc0(%rsp)
mov    0xa0(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x68(%rsp)
mov    %rcx,0xc8(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x70(%rsp)
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    0x98(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x48(%rsp)
lea    0x30(%rsi),%rax
mov    %rax,0xb8(%rsp)
mov    0x18(%rsp),%rax
lea    0x30(%rax),%rcx
mov    %rcx,0x60(%rsp)
lea    0x8(%rsi),%rcx
mov    %rcx,0xb0(%rsp)
add    $0x8,%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
jmp    1ad4 <newviewFlexGamma_Ancestral+0x984>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
mov    0x158(%rsp),%rsi
mov    0x150(%rsp),%rdx
mov    0x50(%rsp),%rbx
mov    %ebx,%ecx
mov    (%rsp),%r8
mov    0x14(%rsp),%r9d
call   1070 <ancestralGamma@plt>
add    $0x1,%rbx
mov    %rbx,%rax
mov    %rbx,0x50(%rsp)
cmp    0xa8(%rsp),%rbx
je     2677 <newviewFlexGamma_Ancestral+0x1527>
mov    0x40(%rsp),%r14
mov    0x60(%rsp),%r12
mov    0x48(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0x68(%rsp),%rax
mov    %rax,0x58(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
jmp    1b38 <newviewFlexGamma_Ancestral+0x9e8>
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0x70(%rsp),%rax
add    %rax,0x58(%rsp)
add    %rax,0x38(%rsp)
mov    0x90(%rsp),%rax
add    %rax,%r12
add    %rax,%r14
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    $0x4,%rcx
je     1a90 <newviewFlexGamma_Ancestral+0x940>
cmpl   $0x0,(%rsp)
jle    1b00 <newviewFlexGamma_Ancestral+0x9b0>
mov    0x20(%rsp),%rcx
mov    %rcx,%rax
mov    %rcx,%rdi
mov    %rcx,0x20(%rsp)
mov    0x28(%rsp),%rcx
imul   %rcx,%rax
mov    0x120(%rsp),%rdx
mov    0x50(%rsp),%rsi
movzbl (%rdx,%rsi,1),%ebx
imul   %rcx,%rbx
mov    0xd8(%rsp),%rdx
movzbl (%rdx,%rsi,1),%ebp
imul   %rcx,%rbp
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    %rdx,0x8(%rsp)
add    %r13,%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0xf8(%rsp)
mov    0x78(%rsp),%rax
lea    (%rax,%rbx,8),%rdx
mov    %rdx,0x110(%rsp)
lea    (%rax,%rbp,8),%rax
mov    %rax,0x108(%rsp)
mov    %edi,%eax
imul   (%rsp),%eax
cltq
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0xd0(%rsp),%rdx
call   1050 <memset@plt>
mov    0x80(%rsp),%r8
mov    0x20(%rsp),%rax
imul   0xc8(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0xc0(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
lea    (%rax,%rbp,8),%rdx
mov    0xb0(%rsp),%rsi
mov    0xb8(%rsp),%r11
mov    0x38(%rsp),%rax
mov    0x58(%rsp),%rbx
xor    %r9d,%r9d
jmp    1c41 <newviewFlexGamma_Ancestral+0xaf1>
xchg   %ax,%ax
add    $0x1,%r9
mov    0x90(%rsp),%rdi
add    %rdi,%rbx
add    %rdi,%rax
add    %rdi,%r11
add    %rdi,%rsi
cmp    %r13,%r9
je     1b00 <newviewFlexGamma_Ancestral+0x9b0>
cmpl   $0x1,(%rsp)
jne    1c50 <newviewFlexGamma_Ancestral+0xb00>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    1ca9 <newviewFlexGamma_Ancestral+0xb59>
nop
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbp,8),%xmm2
movsd  (%rdx,%rbp,8),%xmm3
movhpd -0x8(%rcx,%rbp,8),%xmm2
movsd  -0x8(%rbx,%rbp,8),%xmm4
movsd  (%rbx,%rbp,8),%xmm1
movhpd -0x8(%rax,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%rcx,%rbp,8),%xmm3
movhpd (%rax,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm0
cmp    %rbp,%r15
jne    1c60 <newviewFlexGamma_Ancestral+0xb10>
mov    %r9,%r10
imul   0x28(%rsp),%r10
test   $0x1,%r13b
je     1d1e <newviewFlexGamma_Ancestral+0xbce>
mov    0x100(%rsp),%rdi
mov    %r9,0x118(%rsp)
lea    (%r10,%rdi,1),%r9
add    %rbp,%r9
mov    0x108(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm0
mov    %r8,%rdi
mov    0x110(%rsp),%r8
movhpd (%r8,%rbp,8),%xmm0
mov    %rdi,%r8
mov    0xa0(%rsp),%rbp
movsd  0x0(%rbp,%r9,8),%xmm2
mov    0x98(%rsp),%rbp
movhpd 0x0(%rbp,%r9,8),%xmm2
mov    0x118(%rsp),%r9
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,(%rsp)
jb     1d68 <newviewFlexGamma_Ancestral+0xc18>
lea    (%r10,%r13,1),%rdi
mov    0x30(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
cmp    %rdi,0x8(%rsp)
jae    1df0 <newviewFlexGamma_Ancestral+0xca0>
lea    0x0(,%r10,8),%rdi
add    %rbp,%rdi
cmp    0xf8(%rsp),%rdi
jae    1df0 <newviewFlexGamma_Ancestral+0xca0>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%r13b
je     1d9b <newviewFlexGamma_Ancestral+0xc4b>
add    %rbp,%r10
mov    0x30(%rsp),%rdi
movsd  (%rdi,%r10,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x8(%rsp),%rdi
addsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    %r8,%rbp
je     1c20 <newviewFlexGamma_Ancestral+0xad0>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r14,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rdi,8)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rdi,8),%xmm1
movsd  %xmm1,(%r14,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1db0 <newviewFlexGamma_Ancestral+0xc60>
jmp    1c20 <newviewFlexGamma_Ancestral+0xad0>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xe8(%rsp)
je     1f07 <newviewFlexGamma_Ancestral+0xdb7>
mov    0x88(%rsp),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r11,%rbp,8),%xmm2
movupd -0x20(%r11,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r12,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r12,%rbp,8),%xmm2
movupd -0x10(%r12,%rbp,8),%xmm5
movupd (%r12,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r12,%rbp,8)
movupd %xmm3,-0x20(%r12,%rbp,8)
movupd -0x10(%r11,%rbp,8),%xmm2
movupd (%r11,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r12,%rbp,8)
movupd %xmm3,(%r12,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1e20 <newviewFlexGamma_Ancestral+0xcd0>
testb  $0x1,0xe0(%rsp)
01
je     1eee <newviewFlexGamma_Ancestral+0xd9e>
lea    (%r10,%rbp,1),%rdi
mov    0x30(%rsp),%r8
movupd (%r8,%rdi,8),%xmm2
movupd 0x10(%r8,%rdi,8),%xmm3
mov    0x80(%rsp),%r8
mov    0x8(%rsp),%rdi
movupd (%rdi,%rbp,8),%xmm4
movupd 0x10(%rdi,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdi,%rbp,8)
movupd %xmm3,0x10(%rdi,%rbp,8)
mov    0xf0(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r13,%rdi
je     1c20 <newviewFlexGamma_Ancestral+0xad0>
jmp    1d6a <newviewFlexGamma_Ancestral+0xc1a>
xor    %ebp,%ebp
testb  $0x1,0xe0(%rsp)
01
jne    1ea5 <newviewFlexGamma_Ancestral+0xd55>
jmp    1eee <newviewFlexGamma_Ancestral+0xd9e>
test   %r14d,%r14d
jle    2677 <newviewFlexGamma_Ancestral+0x1527>
mov    (%rsp),%r13d
lea    0x0(,%r13,8),%rcx
mov    %rcx,0x50(%rsp)
mov    0x14(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%edx
cmovge %ecx,%edx
mov    %eax,%eax
mov    %rax,0xd8(%rsp)
mov    %r14d,%eax
mov    %rax,0x148(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe8(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rdx,0x40(%rsp)
and    $0x7ffffffc,%edx
mov    %rdx,0x138(%rsp)
lea    -0x4(%rdx),%rax
mov    %rax,0x130(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r13d,%r12d
and    $0xfffffffe,%r12d
mov    %rsi,%rax
mov    %rsi,0xe0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x20(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x118(%rsp)
mov    %rdx,%rax
mov    %rdx,0x128(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x160(%rsp)
movslq %ecx,%rdx
mov    0x18(%rsp),%rcx
lea    (%rcx,%r13,8),%rax
mov    %rax,0xd0(%rsp)
mov    0x78(%rsp),%rax
add    $0x8,%rax
mov    %rax,0xc8(%rsp)
mov    0xa0(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xc0(%rsp)
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    0x98(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xb8(%rsp)
mov    0x88(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x38(%rsp)
mov    %rdx,0x60(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x140(%rsp)
lea    0x30(%r15),%rax
mov    %rax,0xb0(%rsp)
lea    0x30(%rcx),%rax
mov    %rax,0xa8(%rsp)
lea    0x8(%r15),%rax
mov    %rax,0x68(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0x48(%rsp)
xor    %ebx,%ebx
jmp    20df <newviewFlexGamma_Ancestral+0xf8f>
nopl   0x0(%rax,%rax,1)
mov    0x158(%rsp),%rsi
mov    0x150(%rsp),%rdx
mov    %ebx,%ecx
mov    (%rsp),%r8
mov    0x14(%rsp),%r9d
call   1070 <ancestralGamma@plt>
add    $0x1,%rbx
mov    0x140(%rsp),%rax
add    %rax,0x38(%rsp)
cmp    0x148(%rsp),%rbx
je     2677 <newviewFlexGamma_Ancestral+0x1527>
mov    %rbx,%rax
imul   0x60(%rsp),%rax
mov    %rax,0x70(%rsp)
xor    %ebp,%ebp
mov    0x18(%rsp),%rdi
mov    %rbx,0x58(%rsp)
jmp    2120 <newviewFlexGamma_Ancestral+0xfd0>
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rbp
add    $0x1,%rbp
cmp    $0x4,%rbp
mov    0x18(%rsp),%rdi
mov    0x58(%rsp),%rbx
je     2520 <newviewFlexGamma_Ancestral+0x13d0>
cmpl   $0x0,(%rsp)
jle    2500 <newviewFlexGamma_Ancestral+0x13b0>
mov    0x120(%rsp),%rax
movzbl (%rax,%rbx,1),%r15d
mov    0x28(%rsp),%rax
imul   %rax,%r15
mov    %rbp,%rbx
imul   %rax,%rbx
mov    0x70(%rsp),%rax
add    %rbx,%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
mov    %rcx,0x110(%rsp)
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x108(%rsp)
lea    (%rdi,%rbx,8),%rax
mov    %rax,0x8(%rsp)
mov    %ebp,%eax
imul   (%rsp),%eax
cltq
lea    (%rdi,%rax,8),%rdi
xor    %esi,%esi
mov    0x50(%rsp),%rdx
call   1050 <memset@plt>
movapd 0xe73(%rip),%xmm7
mov    %rbp,0x80(%rsp)
imul   0xd8(%rsp),%rbp
mov    0xd0(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rax,0xf8(%rsp)
mov    0xc8(%rsp),%rax
lea    (%rax,%r15,8),%r15
mov    0xc0(%rsp),%rax
lea    (%rax,%rbp,8),%rsi
mov    0xb8(%rsp),%rax
mov    %rbp,0x100(%rsp)
lea    (%rax,%rbp,8),%rdi
mov    0x38(%rsp),%rax
lea    (%rax,%rbx,8),%r8
mov    0xa8(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x48(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbx
mov    0x68(%rsp),%rbp
mov    0xb0(%rsp),%r10
xor    %ecx,%ecx
jmp    2241 <newviewFlexGamma_Ancestral+0x10f1>
nopl   (%rax)
add    $0x1,%rcx
mov    0x90(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%rdi
add    %rdx,%r10
add    %rdx,%rbp
cmp    %r13,%rcx
je     2100 <newviewFlexGamma_Ancestral+0xfb0>
cmpl   $0x1,(%rsp)
jne    2250 <newviewFlexGamma_Ancestral+0x1100>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    22ad <newviewFlexGamma_Ancestral+0x115d>
nop
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r8,%rdx,8),%xmm2
movsd  (%r8,%rdx,8),%xmm3
movhpd -0x8(%r15,%rdx,8),%xmm2
movsd  -0x8(%rsi,%rdx,8),%xmm4
movsd  (%rsi,%rdx,8),%xmm1
movhpd -0x8(%rdi,%rdx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r15,%rdx,8),%xmm3
movhpd (%rdi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdx
movapd %xmm1,%xmm0
cmp    %rdx,%r12
jne    2260 <newviewFlexGamma_Ancestral+0x1110>
mov    %rcx,%r11
imul   0x28(%rsp),%r11
test   $0x1,%r13b
je     2310 <newviewFlexGamma_Ancestral+0x11c0>
mov    %rcx,%r14
mov    0x100(%rsp),%rcx
lea    (%r11,%rcx,1),%r9
add    %rdx,%r9
mov    0x108(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
mov    %r14,%rcx
mov    0x110(%rsp),%r14
movhpd (%r14,%rdx,8),%xmm0
mov    0xa0(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm2
mov    0x98(%rsp),%rdx
movhpd (%rdx,%r9,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,(%rsp)
jb     234c <newviewFlexGamma_Ancestral+0x11fc>
lea    (%r11,%r13,1),%rdx
mov    0x30(%rsp),%r9
lea    (%r9,%rdx,8),%rdx
cmp    %rdx,0x8(%rsp)
jae    23e0 <newviewFlexGamma_Ancestral+0x1290>
lea    (%r9,%r11,8),%rdx
cmp    0xf8(%rsp),%rdx
jae    23e0 <newviewFlexGamma_Ancestral+0x1290>
xor    %r9d,%r9d
mov    %r9,%rdx
test   $0x1,%r13b
je     2382 <newviewFlexGamma_Ancestral+0x1232>
add    %r9,%r11
mov    0x30(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x8(%rsp),%rdx
addsd  (%rdx,%r9,8),%xmm1
movsd  %xmm1,(%rdx,%r9,8)
mov    %r9,%rdx
or     $0x1,%rdx
not    %r9
cmp    0x118(%rsp),%r9
je     2220 <newviewFlexGamma_Ancestral+0x10d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r13
jne    23a0 <newviewFlexGamma_Ancestral+0x1250>
jmp    2220 <newviewFlexGamma_Ancestral+0x10d0>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xe8(%rsp)
je     24e3 <newviewFlexGamma_Ancestral+0x1393>
mov    0x20(%rsp),%rdx
xor    %r9d,%r9d
nop
movupd -0x30(%r10,%r9,8),%xmm2
movupd -0x20(%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rax,%r9,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rax,%r9,8),%xmm2
movupd -0x10(%rax,%r9,8),%xmm5
movupd (%rax,%r9,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rax,%r9,8)
movupd %xmm3,-0x20(%rax,%r9,8)
movupd -0x10(%r10,%r9,8),%xmm2
movupd (%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rax,%r9,8)
movupd %xmm3,(%rax,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%rdx
jne    2400 <newviewFlexGamma_Ancestral+0x12b0>
testb  $0x1,0xe0(%rsp)
01
je     24ca <newviewFlexGamma_Ancestral+0x137a>
lea    (%r9,%r11,1),%rdx
mov    0x30(%rsp),%r14
movupd (%r14,%rdx,8),%xmm2
movupd 0x10(%r14,%rdx,8),%xmm3
mov    0x8(%rsp),%rdx
movupd (%rdx,%r9,8),%xmm4
movupd 0x10(%rdx,%r9,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%r9,8)
movupd %xmm3,0x10(%rdx,%r9,8)
mov    0xf0(%rsp),%rdx
mov    %rdx,%r9
cmp    %r13,%rdx
je     2220 <newviewFlexGamma_Ancestral+0x10d0>
jmp    234f <newviewFlexGamma_Ancestral+0x11ff>
xor    %r9d,%r9d
testb  $0x1,0xe0(%rsp)
01
jne    2485 <newviewFlexGamma_Ancestral+0x1335>
jmp    24ca <newviewFlexGamma_Ancestral+0x137a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    $0x4,%rbp
jne    2120 <newviewFlexGamma_Ancestral+0xfd0>
jmp    20a0 <newviewFlexGamma_Ancestral+0xf50>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,(%rsp)
jle    20a0 <newviewFlexGamma_Ancestral+0xf50>
mov    $0x1,%eax
nop
movsd  -0x8(%rdi,%rax,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0xabe(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0xae1(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0xabd(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    2577 <newviewFlexGamma_Ancestral+0x1427>
lea    0x1(%rax),%rcx
cmp    0x60(%rsp),%rax
mov    %rcx,%rax
jl     2530 <newviewFlexGamma_Ancestral+0x13e0>
movsd  0xaa1(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    20a0 <newviewFlexGamma_Ancestral+0xf50>
cmpl   $0x4,0x40(%rsp)
jae    2597 <newviewFlexGamma_Ancestral+0x1447>
xor    %eax,%eax
jmp    2640 <newviewFlexGamma_Ancestral+0x14f0>
cmpq   $0x0,0x130(%rsp)
je     2662 <newviewFlexGamma_Ancestral+0x1512>
mov    0x160(%rsp),%rcx
xor    %eax,%eax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm2
movupd 0x30(%rdi,%rax,8),%xmm3
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    25b0 <newviewFlexGamma_Ancestral+0x1460>
testb  $0x1,0x128(%rsp)
01
je     2620 <newviewFlexGamma_Ancestral+0x14d0>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mov    0x138(%rsp),%rcx
mov    %rcx,%rax
cmp    0x40(%rsp),%rcx
je     20a0 <newviewFlexGamma_Ancestral+0xf50>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  0x9db(%rip),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,0x40(%rsp)
jne    2640 <newviewFlexGamma_Ancestral+0x14f0>
jmp    20a0 <newviewFlexGamma_Ancestral+0xf50>
xor    %eax,%eax
testb  $0x1,0x128(%rsp)
01
jne    2602 <newviewFlexGamma_Ancestral+0x14b2>
jmp    2620 <newviewFlexGamma_Ancestral+0x14d0>
xor    %edi,%edi
call   1060 <assert@plt>
mov    0x18(%rsp),%rdi
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <rax_free@plt>

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

LLVM IR (-O2):
define void @newviewFlexGamma_Ancestral(i32 %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, i8* nocapture %5, i8* nocapture %6, i32 %7, double* nocapture %8, double* nocapture %9, i32 %10, double* %11, double* %12) {
%14 = shl i32 %10, 5
%15 = tail call i64 @rax_malloc(i32 %14)
%16 = inttoptr i64 %15 to double*
%17 = mul nsw i32 %10, %10
%18 = shl i32 %10, 2
switch i32 %0, label %880 [
i32 0, label %103
i32 1, label %61
i32 2, label %19
]
19: ; preds = %13
%20 = icmp sgt i32 %7, 0
br i1 %20, label %21, label %882
21: ; preds = %19
%22 = icmp sgt i32 %10, 0
%23 = zext i32 %10 to i64
%24 = shl nuw nsw i64 %23, 3
%25 = sext i32 %10 to i64
%26 = zext i32 %17 to i64
%27 = sext i32 %18 to i64
%28 = call i32 @llvm.smax.i32(i32 %18, i32 1)
%29 = zext i32 %7 to i64
%30 = zext i32 %28 to i64
%31 = getelementptr double, double* %16, i64 %23
%32 = and i64 %23, 4294967292
%33 = add nsw i64 %32, -4
%34 = lshr exact i64 %33, 2
%35 = add nuw nsw i64 %34, 1
%36 = and i64 %30, 2147483644
%37 = add nsw i64 %36, -4
%38 = lshr exact i64 %37, 2
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %23, 1
%41 = icmp eq i32 %10, 1
%42 = and i64 %23, 4294967294
%43 = icmp eq i64 %40, 0
%44 = icmp ult i32 %10, 4
%45 = and i64 %23, 4294967292
%46 = and i64 %35, 1
%47 = icmp eq i64 %33, 0
%48 = and i64 %35, 9223372036854775806
%49 = icmp eq i64 %46, 0
%50 = icmp eq i64 %45, %23
%51 = and i64 %23, 1
%52 = icmp eq i64 %51, 0
%53 = sub nsw i64 0, %23
%54 = icmp ult i32 %28, 4
%55 = and i64 %30, 2147483644
%56 = and i64 %39, 1
%57 = icmp eq i64 %37, 0
%58 = and i64 %39, 9223372036854775806
%59 = icmp eq i64 %56, 0
%60 = icmp eq i64 %55, %30
br label %612
61: ; preds = %13
%62 = icmp sgt i32 %7, 0
br i1 %62, label %63, label %882
63: ; preds = %61
%64 = icmp sgt i32 %10, 0
%65 = zext i32 %10 to i64
%66 = shl nuw nsw i64 %65, 3
%67 = sext i32 %10 to i64
%68 = zext i32 %17 to i64
%69 = sext i32 %18 to i64
%70 = call i32 @llvm.smax.i32(i32 %18, i32 1)
%71 = zext i32 %7 to i64
%72 = zext i32 %70 to i64
%73 = getelementptr double, double* %16, i64 %65
%74 = and i64 %65, 4294967292
%75 = add nsw i64 %74, -4
%76 = lshr exact i64 %75, 2
%77 = add nuw nsw i64 %76, 1
%78 = and i64 %72, 2147483644
%79 = add nsw i64 %78, -4
%80 = lshr exact i64 %79, 2
%81 = add nuw nsw i64 %80, 1
%82 = and i64 %65, 1
%83 = icmp eq i32 %10, 1
%84 = and i64 %65, 4294967294
%85 = icmp eq i64 %82, 0
%86 = icmp ult i32 %10, 4
%87 = and i64 %65, 4294967292
%88 = and i64 %77, 1
%89 = icmp eq i64 %75, 0
%90 = and i64 %77, 9223372036854775806
%91 = icmp eq i64 %88, 0
%92 = icmp eq i64 %87, %65
%93 = and i64 %65, 1
%94 = icmp eq i64 %93, 0
%95 = sub nsw i64 0, %65
%96 = icmp ult i32 %70, 4
%97 = and i64 %72, 2147483644
%98 = and i64 %81, 1
%99 = icmp eq i64 %79, 0
%100 = and i64 %81, 9223372036854775806
%101 = icmp eq i64 %98, 0
%102 = icmp eq i64 %97, %72
br label %339
103: ; preds = %13
%104 = icmp sgt i32 %7, 0
br i1 %104, label %105, label %882
105: ; preds = %103
%106 = icmp sgt i32 %10, 0
%107 = zext i32 %10 to i64
%108 = shl nuw nsw i64 %107, 3
%109 = sext i32 %10 to i64
%110 = zext i32 %17 to i64
%111 = zext i32 %7 to i64
%112 = and i64 %107, 4294967292
%113 = add nsw i64 %112, -4
%114 = lshr exact i64 %113, 2
%115 = add nuw nsw i64 %114, 1
%116 = and i64 %107, 1
%117 = icmp eq i32 %10, 1
%118 = and i64 %107, 4294967294
%119 = icmp eq i64 %116, 0
%120 = icmp ult i32 %10, 4
%121 = and i64 %107, 4294967292
%122 = and i64 %115, 1
%123 = icmp eq i64 %113, 0
%124 = and i64 %115, 9223372036854775806
%125 = icmp eq i64 %122, 0
%126 = icmp eq i64 %121, %107
%127 = and i64 %107, 1
%128 = icmp eq i64 %127, 0
%129 = sub nsw i64 0, %107
br label %130
130: ; preds = %105, %334
%131 = phi i64 [ 0, %105 ], [ %337, %334 ]
%132 = getelementptr inbounds i8, i8* %5, i64 %131
%133 = getelementptr inbounds i8, i8* %6, i64 %131
br label %134
134: ; preds = %130, %331
%135 = phi i64 [ 0, %130 ], [ %332, %331 ]
%136 = mul i64 %135, %109
%137 = getelementptr double, double* %16, i64 %136
%138 = add i64 %136, %107
%139 = getelementptr double, double* %16, i64 %138
%140 = load i8, i8* %132
%141 = zext i8 %140 to i32
%142 = mul nsw i32 %141, %10
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %4, i64 %143
%145 = load i8, i8* %133
%146 = zext i8 %145 to i32
%147 = mul nsw i32 %146, %10
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %4, i64 %148
%150 = mul nsw i64 %135, %109
%151 = getelementptr inbounds double, double* %16, i64 %150
br i1 %106, label %152, label %331
152: ; preds = %134
%153 = trunc i64 %135 to i32
%154 = mul i32 %153, %10
%155 = sext i32 %154 to i64
%156 = getelementptr double, double* %16, i64 %155
%157 = bitcast double* %156 to i8*
%158 = mul nsw i64 %135, %110
br label %159
159: ; preds = %328, %152
%160 = phi i64 [ 0, %152 ], [ %329, %328 ]
%161 = mul i64 %160, %109
%162 = getelementptr double, double* %3, i64 %161
%163 = add i64 %161, %107
%164 = getelementptr double, double* %3, i64 %163
%165 = mul nsw i64 %160, %109
%166 = add nsw i64 %165, %158
br i1 %117, label %203, label %167
167: ; preds = %159, %167
%168 = phi i64 [ %200, %167 ], [ 0, %159 ]
%169 = phi <2 x double> [ %199, %167 ], [ zeroinitializer, %159 ]
%170 = phi i64 [ %201, %167 ], [ 0, %159 ]
%171 = getelementptr inbounds double, double* %144, i64 %168
%172 = load double, double* %171
%173 = add nsw i64 %166, %168
%174 = getelementptr inbounds double, double* %8, i64 %173
%175 = load double, double* %174
%176 = getelementptr inbounds double, double* %149, i64 %168
%177 = load double, double* %176
%178 = getelementptr inbounds double, double* %9, i64 %173
%179 = load double, double* %178
%180 = insertelement <2 x double> poison, double %177, i64 0
%181 = insertelement <2 x double> %180, double %172, i64 1
%182 = insertelement <2 x double> poison, double %179, i64 0
%183 = insertelement <2 x double> %182, double %175, i64 1
%184 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %181, <2 x double> %183, <2 x double> %169)
%185 = or i64 %168, 1
%186 = getelementptr inbounds double, double* %144, i64 %185
%187 = load double, double* %186
%188 = add nsw i64 %166, %185
%189 = getelementptr inbounds double, double* %8, i64 %188
%190 = load double, double* %189
%191 = getelementptr inbounds double, double* %149, i64 %185
%192 = load double, double* %191
%193 = getelementptr inbounds double, double* %9, i64 %188
%194 = load double, double* %193
%195 = insertelement <2 x double> poison, double %192, i64 0
%196 = insertelement <2 x double> %195, double %187, i64 1
%197 = insertelement <2 x double> poison, double %194, i64 0
%198 = insertelement <2 x double> %197, double %190, i64 1
%199 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %196, <2 x double> %198, <2 x double> %184)
%200 = add nuw nsw i64 %168, 2
%201 = add i64 %170, 2
%202 = icmp eq i64 %201, %118
br i1 %202, label %203, label %167
203: ; preds = %167, %159
%204 = phi <2 x double> [ undef, %159 ], [ %199, %167 ]
%205 = phi i64 [ 0, %159 ], [ %200, %167 ]
%206 = phi <2 x double> [ zeroinitializer, %159 ], [ %199, %167 ]
br i1 %119, label %222, label %207
207: ; preds = %203
%208 = getelementptr inbounds double, double* %144, i64 %205
%209 = load double, double* %208
%210 = add nsw i64 %166, %205
%211 = getelementptr inbounds double, double* %8, i64 %210
%212 = load double, double* %211
%213 = getelementptr inbounds double, double* %149, i64 %205
%214 = load double, double* %213
%215 = getelementptr inbounds double, double* %9, i64 %210
%216 = load double, double* %215
%217 = insertelement <2 x double> poison, double %214, i64 0
%218 = insertelement <2 x double> %217, double %209, i64 1
%219 = insertelement <2 x double> poison, double %216, i64 0
%220 = insertelement <2 x double> %219, double %212, i64 1
%221 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %218, <2 x double> %220, <2 x double> %206)
br label %222
222: ; preds = %203, %207
%223 = phi <2 x double> [ %204, %203 ], [ %221, %207 ]
%224 = shufflevector <2 x double> %223, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%225 = fmul <2 x double> %224, %223
%226 = extractelement <2 x double> %225, i64 0
%227 = mul nsw i64 %160, %109
br i1 %120, label %297, label %228
228: ; preds = %222
%229 = icmp ult double* %137, %164
%230 = icmp ult double* %162, %139
%231 = and i1 %229, %230
br i1 %231, label %297, label %232
232: ; preds = %228
%233 = shufflevector <2 x double> %225, <2 x double> poison, <2 x i32> zeroinitializer
%234 = shufflevector <2 x double> %225, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %123, label %276, label %235
235: ; preds = %232, %235
%236 = phi i64 [ %273, %235 ], [ 0, %232 ]
%237 = phi i64 [ %274, %235 ], [ 0, %232 ]
%238 = add nsw i64 %236, %227
%239 = getelementptr inbounds double, double* %3, i64 %238
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr inbounds double, double* %239, i64 2
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = getelementptr inbounds double, double* %151, i64 %236
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = getelementptr inbounds double, double* %245, i64 2
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %233, <2 x double> %241, <2 x double> %247)
%252 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %234, <2 x double> %244, <2 x double> %250)
%253 = bitcast double* %245 to <2 x double>*
store <2 x double> %251, <2 x double>* %253
%254 = bitcast double* %248 to <2 x double>*
store <2 x double> %252, <2 x double>* %254
%255 = or i64 %236, 4
%256 = add nsw i64 %255, %227
%257 = getelementptr inbounds double, double* %3, i64 %256
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = getelementptr inbounds double, double* %257, i64 2
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %151, i64 %255
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = getelementptr inbounds double, double* %263, i64 2
%267 = bitcast double* %266 to <2 x double>*
%268 = load <2 x double>, <2 x double>* %267
%269 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %233, <2 x double> %259, <2 x double> %265)
%270 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %234, <2 x double> %262, <2 x double> %268)
%271 = bitcast double* %263 to <2 x double>*
store <2 x double> %269, <2 x double>* %271
%272 = bitcast double* %266 to <2 x double>*
store <2 x double> %270, <2 x double>* %272
%273 = add nuw i64 %236, 8
%274 = add i64 %237, 2
%275 = icmp eq i64 %274, %124
br i1 %275, label %276, label %235
276: ; preds = %235, %232
%277 = phi i64 [ 0, %232 ], [ %273, %235 ]
br i1 %125, label %296, label %278
278: ; preds = %276
%279 = add nsw i64 %277, %227
%280 = getelementptr inbounds double, double* %3, i64 %279
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr inbounds double, double* %280, i64 2
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %151, i64 %277
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = getelementptr inbounds double, double* %286, i64 2
%290 = bitcast double* %289 to <2 x double>*
%291 = load <2 x double>, <2 x double>* %290
%292 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %233, <2 x double> %282, <2 x double> %288)
%293 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %234, <2 x double> %285, <2 x double> %291)
%294 = bitcast double* %286 to <2 x double>*
store <2 x double> %292, <2 x double>* %294
%295 = bitcast double* %289 to <2 x double>*
store <2 x double> %293, <2 x double>* %295
br label %296
296: ; preds = %276, %278
br i1 %126, label %328, label %297
297: ; preds = %228, %222, %296
%298 = phi i64 [ 0, %228 ], [ 0, %222 ], [ %121, %296 ]
%299 = xor i64 %298, -1
br i1 %128, label %308, label %300
300: ; preds = %297
%301 = add nsw i64 %298, %227
%302 = getelementptr inbounds double, double* %3, i64 %301
%303 = load double, double* %302
%304 = getelementptr inbounds double, double* %151, i64 %298
%305 = load double, double* %304
%306 = tail call double @llvm.fmuladd.f64(double %226, double %303, double %305)
store double %306, double* %304
%307 = or i64 %298, 1
br label %308
308: ; preds = %300, %297
%309 = phi i64 [ %298, %297 ], [ %307, %300 ]
%310 = icmp eq i64 %299, %129
br i1 %310, label %328, label %311
311: ; preds = %308, %311
%312 = phi i64 [ %326, %311 ], [ %309, %308 ]
%313 = add nsw i64 %312, %227
%314 = getelementptr inbounds double, double* %3, i64 %313
%315 = load double, double* %314
%316 = getelementptr inbounds double, double* %151, i64 %312
%317 = load double, double* %316
%318 = tail call double @llvm.fmuladd.f64(double %226, double %315, double %317)
store double %318, double* %316
%319 = add nuw nsw i64 %312, 1
%320 = add nsw i64 %319, %227
%321 = getelementptr inbounds double, double* %3, i64 %320
%322 = load double, double* %321
%323 = getelementptr inbounds double, double* %151, i64 %319
%324 = load double, double* %323
%325 = tail call double @llvm.fmuladd.f64(double %226, double %322, double %324)
store double %325, double* %323
%326 = add nuw nsw i64 %312, 2
%327 = icmp eq i64 %326, %107
br i1 %327, label %328, label %311
328: ; preds = %308, %311, %296
%329 = add nuw nsw i64 %160, 1
%330 = icmp eq i64 %329, %107
br i1 %330, label %331, label %159
331: ; preds = %328, %134
%332 = add nuw nsw i64 %135, 1
%333 = icmp eq i64 %332, 4
br i1 %333, label %334, label %134
334: ; preds = %331
%335 = trunc i64 %131 to i32
%336 = tail call i32 @ancestralGamma(double* %16, double* %12, double* %11, i32 %335, i32 %10, i32 %18)
%337 = add nuw nsw i64 %131, 1
%338 = icmp eq i64 %337, %111
br i1 %338, label %882, label %130
339: ; preds = %63, %607
%340 = phi i64 [ 0, %63 ], [ %610, %607 ]
%341 = getelementptr inbounds i8, i8* %5, i64 %340
%342 = mul nsw i64 %340, %69
br label %344
343: ; preds = %535
br i1 %64, label %543, label %607
344: ; preds = %538, %339
%345 = phi i64 [ 0, %339 ], [ %539, %538 ]
%346 = load i8, i8* %341
%347 = zext i8 %346 to i32
%348 = mul nsw i32 %347, %10
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %4, i64 %349
%351 = mul i64 %345, %67
%352 = add nsw i64 %351, %342
%353 = getelementptr inbounds double, double* %2, i64 %352
%354 = getelementptr double, double* %16, i64 %351
br i1 %64, label %355, label %540
355: ; preds = %344
%356 = trunc i64 %345 to i32
%357 = mul i32 %356, %10
%358 = sext i32 %357 to i64
%359 = getelementptr double, double* %16, i64 %358
%360 = bitcast double* %359 to i8*
%361 = mul nsw i64 %345, %68
%362 = getelementptr double, double* %73, i64 %351
br label %363
363: ; preds = %532, %355
%364 = phi i64 [ 0, %355 ], [ %533, %532 ]
%365 = mul i64 %364, %67
%366 = getelementptr double, double* %3, i64 %365
%367 = add i64 %365, %65
%368 = getelementptr double, double* %3, i64 %367
%369 = mul nsw i64 %364, %67
%370 = add nsw i64 %369, %361
br i1 %83, label %407, label %371
371: ; preds = %363, %371
%372 = phi i64 [ %404, %371 ], [ 0, %363 ]
%373 = phi <2 x double> [ %403, %371 ], [ zeroinitializer, %363 ]
%374 = phi i64 [ %405, %371 ], [ 0, %363 ]
%375 = getelementptr inbounds double, double* %350, i64 %372
%376 = load double, double* %375
%377 = add nsw i64 %370, %372
%378 = getelementptr inbounds double, double* %8, i64 %377
%379 = load double, double* %378
%380 = getelementptr inbounds double, double* %353, i64 %372
%381 = load double, double* %380
%382 = getelementptr inbounds double, double* %9, i64 %377
%383 = load double, double* %382
%384 = insertelement <2 x double> poison, double %381, i64 0
%385 = insertelement <2 x double> %384, double %376, i64 1
%386 = insertelement <2 x double> poison, double %383, i64 0
%387 = insertelement <2 x double> %386, double %379, i64 1
%388 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %385, <2 x double> %387, <2 x double> %373)
%389 = or i64 %372, 1
%390 = getelementptr inbounds double, double* %350, i64 %389
%391 = load double, double* %390
%392 = add nsw i64 %370, %389
%393 = getelementptr inbounds double, double* %8, i64 %392
%394 = load double, double* %393
%395 = getelementptr inbounds double, double* %353, i64 %389
%396 = load double, double* %395
%397 = getelementptr inbounds double, double* %9, i64 %392
%398 = load double, double* %397
%399 = insertelement <2 x double> poison, double %396, i64 0
%400 = insertelement <2 x double> %399, double %391, i64 1
%401 = insertelement <2 x double> poison, double %398, i64 0
%402 = insertelement <2 x double> %401, double %394, i64 1
%403 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %400, <2 x double> %402, <2 x double> %388)
%404 = add nuw nsw i64 %372, 2
%405 = add i64 %374, 2
%406 = icmp eq i64 %405, %84
br i1 %406, label %407, label %371
407: ; preds = %371, %363
%408 = phi <2 x double> [ undef, %363 ], [ %403, %371 ]
%409 = phi i64 [ 0, %363 ], [ %404, %371 ]
%410 = phi <2 x double> [ zeroinitializer, %363 ], [ %403, %371 ]
br i1 %85, label %426, label %411
411: ; preds = %407
%412 = getelementptr inbounds double, double* %350, i64 %409
%413 = load double, double* %412
%414 = add nsw i64 %370, %409
%415 = getelementptr inbounds double, double* %8, i64 %414
%416 = load double, double* %415
%417 = getelementptr inbounds double, double* %353, i64 %409
%418 = load double, double* %417
%419 = getelementptr inbounds double, double* %9, i64 %414
%420 = load double, double* %419
%421 = insertelement <2 x double> poison, double %418, i64 0
%422 = insertelement <2 x double> %421, double %413, i64 1
%423 = insertelement <2 x double> poison, double %420, i64 0
%424 = insertelement <2 x double> %423, double %416, i64 1
%425 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %422, <2 x double> %424, <2 x double> %410)
br label %426
426: ; preds = %407, %411
%427 = phi <2 x double> [ %408, %407 ], [ %425, %411 ]
%428 = shufflevector <2 x double> %427, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%429 = fmul <2 x double> %428, %427
%430 = extractelement <2 x double> %429, i64 0
%431 = mul nsw i64 %364, %67
br i1 %86, label %501, label %432
432: ; preds = %426
%433 = icmp ult double* %354, %368
%434 = icmp ult double* %366, %362
%435 = and i1 %433, %434
br i1 %435, label %501, label %436
436: ; preds = %432
%437 = shufflevector <2 x double> %429, <2 x double> poison, <2 x i32> zeroinitializer
%438 = shufflevector <2 x double> %429, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %89, label %480, label %439
439: ; preds = %436, %439
%440 = phi i64 [ %477, %439 ], [ 0, %436 ]
%441 = phi i64 [ %478, %439 ], [ 0, %436 ]
%442 = add nsw i64 %440, %431
%443 = getelementptr inbounds double, double* %3, i64 %442
%444 = bitcast double* %443 to <2 x double>*
%445 = load <2 x double>, <2 x double>* %444
%446 = getelementptr inbounds double, double* %443, i64 2
%447 = bitcast double* %446 to <2 x double>*
%448 = load <2 x double>, <2 x double>* %447
%449 = getelementptr inbounds double, double* %354, i64 %440
%450 = bitcast double* %449 to <2 x double>*
%451 = load <2 x double>, <2 x double>* %450
%452 = getelementptr inbounds double, double* %449, i64 2
%453 = bitcast double* %452 to <2 x double>*
%454 = load <2 x double>, <2 x double>* %453
%455 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %437, <2 x double> %445, <2 x double> %451)
%456 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %438, <2 x double> %448, <2 x double> %454)
%457 = bitcast double* %449 to <2 x double>*
store <2 x double> %455, <2 x double>* %457
%458 = bitcast double* %452 to <2 x double>*
store <2 x double> %456, <2 x double>* %458
%459 = or i64 %440, 4
%460 = add nsw i64 %459, %431
%461 = getelementptr inbounds double, double* %3, i64 %460
%462 = bitcast double* %461 to <2 x double>*
%463 = load <2 x double>, <2 x double>* %462
%464 = getelementptr inbounds double, double* %461, i64 2
%465 = bitcast double* %464 to <2 x double>*
%466 = load <2 x double>, <2 x double>* %465
%467 = getelementptr inbounds double, double* %354, i64 %459
%468 = bitcast double* %467 to <2 x double>*
%469 = load <2 x double>, <2 x double>* %468
%470 = getelementptr inbounds double, double* %467, i64 2
%471 = bitcast double* %470 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %437, <2 x double> %463, <2 x double> %469)
%474 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %438, <2 x double> %466, <2 x double> %472)
%475 = bitcast double* %467 to <2 x double>*
store <2 x double> %473, <2 x double>* %475
%476 = bitcast double* %470 to <2 x double>*
store <2 x double> %474, <2 x double>* %476
%477 = add nuw i64 %440, 8
%478 = add i64 %441, 2
%479 = icmp eq i64 %478, %90
br i1 %479, label %480, label %439
480: ; preds = %439, %436
%481 = phi i64 [ 0, %436 ], [ %477, %439 ]
br i1 %91, label %500, label %482
482: ; preds = %480
%483 = add nsw i64 %481, %431
%484 = getelementptr inbounds double, double* %3, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds double, double* %354, i64 %481
%491 = bitcast double* %490 to <2 x double>*
%492 = load <2 x double>, <2 x double>* %491
%493 = getelementptr inbounds double, double* %490, i64 2
%494 = bitcast double* %493 to <2 x double>*
%495 = load <2 x double>, <2 x double>* %494
%496 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %437, <2 x double> %486, <2 x double> %492)
%497 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %438, <2 x double> %489, <2 x double> %495)
%498 = bitcast double* %490 to <2 x double>*
store <2 x double> %496, <2 x double>* %498
%499 = bitcast double* %493 to <2 x double>*
store <2 x double> %497, <2 x double>* %499
br label %500
500: ; preds = %480, %482
br i1 %92, label %532, label %501
501: ; preds = %432, %426, %500
%502 = phi i64 [ 0, %432 ], [ 0, %426 ], [ %87, %500 ]
%503 = xor i64 %502, -1
br i1 %94, label %512, label %504
504: ; preds = %501
%505 = add nsw i64 %502, %431
%506 = getelementptr inbounds double, double* %3, i64 %505
%507 = load double, double* %506
%508 = getelementptr inbounds double, double* %354, i64 %502
%509 = load double, double* %508
%510 = tail call double @llvm.fmuladd.f64(double %430, double %507, double %509)
store double %510, double* %508
%511 = or i64 %502, 1
br label %512
512: ; preds = %504, %501
%513 = phi i64 [ %502, %501 ], [ %511, %504 ]
%514 = icmp eq i64 %503, %95
br i1 %514, label %532, label %515
515: ; preds = %512, %515
%516 = phi i64 [ %530, %515 ], [ %513, %512 ]
%517 = add nsw i64 %516, %431
%518 = getelementptr inbounds double, double* %3, i64 %517
%519 = load double, double* %518
%520 = getelementptr inbounds double, double* %354, i64 %516
%521 = load double, double* %520
%522 = tail call double @llvm.fmuladd.f64(double %430, double %519, double %521)
store double %522, double* %520
%523 = add nuw nsw i64 %516, 1
%524 = add nsw i64 %523, %431
%525 = getelementptr inbounds double, double* %3, i64 %524
%526 = load double, double* %525
%527 = getelementptr inbounds double, double* %354, i64 %523
%528 = load double, double* %527
%529 = tail call double @llvm.fmuladd.f64(double %430, double %526, double %528)
store double %529, double* %527
%530 = add nuw nsw i64 %516, 2
%531 = icmp eq i64 %530, %65
br i1 %531, label %532, label %515
532: ; preds = %512, %515, %500
%533 = add nuw nsw i64 %364, 1
%534 = icmp eq i64 %533, %65
br i1 %534, label %535, label %363
535: ; preds = %532
%536 = add nuw nsw i64 %345, 1
%537 = icmp eq i64 %536, 4
br i1 %537, label %343, label %538
538: ; preds = %535, %540
%539 = phi i64 [ %536, %535 ], [ %541, %540 ]
br label %344
540: ; preds = %344
%541 = add nuw nsw i64 %345, 1
%542 = icmp eq i64 %541, 4
br i1 %542, label %607, label %538
543: ; preds = %343, %543
%544 = phi i64 [ %551, %543 ], [ 0, %343 ]
%545 = getelementptr inbounds double, double* %16, i64 %544
%546 = load double, double* %545
%547 = fcmp olt double %546, 0.000000e+00
%548 = fneg double %546
%549 = select i1 %547, double %548, double %546
%550 = fcmp olt double %549, 0x2FF0000000000000
%551 = add nuw nsw i64 %544, 1
%552 = icmp slt i64 %551, %69
%553 = select i1 %550, i1 %552, i1 false
br i1 %553, label %543, label %554
554: ; preds = %543
br i1 %550, label %555, label %607
555: ; preds = %554
br i1 %96, label %598, label %556
556: ; preds = %555
br i1 %99, label %584, label %557
557: ; preds = %556, %557
%558 = phi i64 [ %581, %557 ], [ 0, %556 ]
%559 = phi i64 [ %582, %557 ], [ 0, %556 ]
%560 = getelementptr inbounds double, double* %16, i64 %558
%561 = bitcast double* %560 to <2 x double>*
%562 = load <2 x double>, <2 x double>* %561
%563 = getelementptr inbounds double, double* %560, i64 2
%564 = bitcast double* %563 to <2 x double>*
%565 = load <2 x double>, <2 x double>* %564
%566 = fmul <2 x double> %562, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%567 = fmul <2 x double> %565, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%568 = bitcast double* %560 to <2 x double>*
store <2 x double> %566, <2 x double>* %568
%569 = bitcast double* %563 to <2 x double>*
store <2 x double> %567, <2 x double>* %569
%570 = or i64 %558, 4
%571 = getelementptr inbounds double, double* %16, i64 %570
%572 = bitcast double* %571 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = getelementptr inbounds double, double* %571, i64 2
%575 = bitcast double* %574 to <2 x double>*
%576 = load <2 x double>, <2 x double>* %575
%577 = fmul <2 x double> %573, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%578 = fmul <2 x double> %576, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%579 = bitcast double* %571 to <2 x double>*
store <2 x double> %577, <2 x double>* %579
%580 = bitcast double* %574 to <2 x double>*
store <2 x double> %578, <2 x double>* %580
%581 = add nuw i64 %558, 8
%582 = add i64 %559, 2
%583 = icmp eq i64 %582, %100
br i1 %583, label %584, label %557
584: ; preds = %557, %556
%585 = phi i64 [ 0, %556 ], [ %581, %557 ]
br i1 %101, label %597, label %586
586: ; preds = %584
%587 = getelementptr inbounds double, double* %16, i64 %585
%588 = bitcast double* %587 to <2 x double>*
%589 = load <2 x double>, <2 x double>* %588
%590 = getelementptr inbounds double, double* %587, i64 2
%591 = bitcast double* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = fmul <2 x double> %589, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%594 = fmul <2 x double> %592, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%595 = bitcast double* %587 to <2 x double>*
store <2 x double> %593, <2 x double>* %595
%596 = bitcast double* %590 to <2 x double>*
store <2 x double> %594, <2 x double>* %596
br label %597
597: ; preds = %584, %586
br i1 %102, label %607, label %598
598: ; preds = %555, %597
%599 = phi i64 [ 0, %555 ], [ %97, %597 ]
br label %600
600: ; preds = %598, %600
%601 = phi i64 [ %605, %600 ], [ %599, %598 ]
%602 = getelementptr inbounds double, double* %16, i64 %601
%603 = load double, double* %602
%604 = fmul double %603, 0x4FF0000000000000
store double %604, double* %602
%605 = add nuw nsw i64 %601, 1
%606 = icmp eq i64 %605, %72
br i1 %606, label %607, label %600
607: ; preds = %540, %600, %597, %343, %554
%608 = trunc i64 %340 to i32
%609 = tail call i32 @ancestralGamma(double* %16, double* %12, double* %11, i32 %608, i32 %10, i32 %18)
%610 = add nuw nsw i64 %340, 1
%611 = icmp eq i64 %610, %71
br i1 %611, label %882, label %339
612: ; preds = %21, %875
%613 = phi i64 [ 0, %21 ], [ %878, %875 ]
%614 = mul nsw i64 %613, %27
br label %616
615: ; preds = %803
br i1 %22, label %811, label %875
616: ; preds = %806, %612
%617 = phi i64 [ 0, %612 ], [ %807, %806 ]
%618 = mul i64 %617, %25
%619 = add nsw i64 %618, %614
%620 = getelementptr inbounds double, double* %1, i64 %619
%621 = getelementptr inbounds double, double* %2, i64 %619
%622 = getelementptr double, double* %16, i64 %618
br i1 %22, label %623, label %808
623: ; preds = %616
%624 = trunc i64 %617 to i32
%625 = mul i32 %624, %10
%626 = sext i32 %625 to i64
%627 = getelementptr double, double* %16, i64 %626
%628 = bitcast double* %627 to i8*
%629 = mul nsw i64 %617, %26
%630 = getelementptr double, double* %31, i64 %618
br label %631
631: ; preds = %800, %623
%632 = phi i64 [ 0, %623 ], [ %801, %800 ]
%633 = mul i64 %632, %25
%634 = getelementptr double, double* %3, i64 %633
%635 = add i64 %633, %23
%636 = getelementptr double, double* %3, i64 %635
%637 = mul nsw i64 %632, %25
%638 = add nsw i64 %637, %629
br i1 %41, label %675, label %639
639: ; preds = %631, %639
%640 = phi i64 [ %672, %639 ], [ 0, %631 ]
%641 = phi <2 x double> [ %671, %639 ], [ zeroinitializer, %631 ]
%642 = phi i64 [ %673, %639 ], [ 0, %631 ]
%643 = getelementptr inbounds double, double* %620, i64 %640
%644 = load double, double* %643
%645 = add nsw i64 %638, %640
%646 = getelementptr inbounds double, double* %8, i64 %645
%647 = load double, double* %646
%648 = getelementptr inbounds double, double* %621, i64 %640
%649 = load double, double* %648
%650 = getelementptr inbounds double, double* %9, i64 %645
%651 = load double, double* %650
%652 = insertelement <2 x double> poison, double %649, i64 0
%653 = insertelement <2 x double> %652, double %644, i64 1
%654 = insertelement <2 x double> poison, double %651, i64 0
%655 = insertelement <2 x double> %654, double %647, i64 1
%656 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %653, <2 x double> %655, <2 x double> %641)
%657 = or i64 %640, 1
%658 = getelementptr inbounds double, double* %620, i64 %657
%659 = load double, double* %658
%660 = add nsw i64 %638, %657
%661 = getelementptr inbounds double, double* %8, i64 %660
%662 = load double, double* %661
%663 = getelementptr inbounds double, double* %621, i64 %657
%664 = load double, double* %663
%665 = getelementptr inbounds double, double* %9, i64 %660
%666 = load double, double* %665
%667 = insertelement <2 x double> poison, double %664, i64 0
%668 = insertelement <2 x double> %667, double %659, i64 1
%669 = insertelement <2 x double> poison, double %666, i64 0
%670 = insertelement <2 x double> %669, double %662, i64 1
%671 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %668, <2 x double> %670, <2 x double> %656)
%672 = add nuw nsw i64 %640, 2
%673 = add i64 %642, 2
%674 = icmp eq i64 %673, %42
br i1 %674, label %675, label %639
675: ; preds = %639, %631
%676 = phi <2 x double> [ undef, %631 ], [ %671, %639 ]
%677 = phi i64 [ 0, %631 ], [ %672, %639 ]
%678 = phi <2 x double> [ zeroinitializer, %631 ], [ %671, %639 ]
br i1 %43, label %694, label %679
679: ; preds = %675
%680 = getelementptr inbounds double, double* %620, i64 %677
%681 = load double, double* %680
%682 = add nsw i64 %638, %677
%683 = getelementptr inbounds double, double* %8, i64 %682
%684 = load double, double* %683
%685 = getelementptr inbounds double, double* %621, i64 %677
%686 = load double, double* %685
%687 = getelementptr inbounds double, double* %9, i64 %682
%688 = load double, double* %687
%689 = insertelement <2 x double> poison, double %686, i64 0
%690 = insertelement <2 x double> %689, double %681, i64 1
%691 = insertelement <2 x double> poison, double %688, i64 0
%692 = insertelement <2 x double> %691, double %684, i64 1
%693 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %690, <2 x double> %692, <2 x double> %678)
br label %694
694: ; preds = %675, %679
%695 = phi <2 x double> [ %676, %675 ], [ %693, %679 ]
%696 = shufflevector <2 x double> %695, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%697 = fmul <2 x double> %696, %695
%698 = extractelement <2 x double> %697, i64 0
%699 = mul nsw i64 %632, %25
br i1 %44, label %769, label %700
700: ; preds = %694
%701 = icmp ult double* %622, %636
%702 = icmp ult double* %634, %630
%703 = and i1 %701, %702
br i1 %703, label %769, label %704
704: ; preds = %700
%705 = shufflevector <2 x double> %697, <2 x double> poison, <2 x i32> zeroinitializer
%706 = shufflevector <2 x double> %697, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %47, label %748, label %707
707: ; preds = %704, %707
%708 = phi i64 [ %745, %707 ], [ 0, %704 ]
%709 = phi i64 [ %746, %707 ], [ 0, %704 ]
%710 = add nsw i64 %708, %699
%711 = getelementptr inbounds double, double* %3, i64 %710
%712 = bitcast double* %711 to <2 x double>*
%713 = load <2 x double>, <2 x double>* %712
%714 = getelementptr inbounds double, double* %711, i64 2
%715 = bitcast double* %714 to <2 x double>*
%716 = load <2 x double>, <2 x double>* %715
%717 = getelementptr inbounds double, double* %622, i64 %708
%718 = bitcast double* %717 to <2 x double>*
%719 = load <2 x double>, <2 x double>* %718
%720 = getelementptr inbounds double, double* %717, i64 2
%721 = bitcast double* %720 to <2 x double>*
%722 = load <2 x double>, <2 x double>* %721
%723 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %705, <2 x double> %713, <2 x double> %719)
%724 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %706, <2 x double> %716, <2 x double> %722)
%725 = bitcast double* %717 to <2 x double>*
store <2 x double> %723, <2 x double>* %725
%726 = bitcast double* %720 to <2 x double>*
store <2 x double> %724, <2 x double>* %726
%727 = or i64 %708, 4
%728 = add nsw i64 %727, %699
%729 = getelementptr inbounds double, double* %3, i64 %728
%730 = bitcast double* %729 to <2 x double>*
%731 = load <2 x double>, <2 x double>* %730
%732 = getelementptr inbounds double, double* %729, i64 2
%733 = bitcast double* %732 to <2 x double>*
%734 = load <2 x double>, <2 x double>* %733
%735 = getelementptr inbounds double, double* %622, i64 %727
%736 = bitcast double* %735 to <2 x double>*
%737 = load <2 x double>, <2 x double>* %736
%738 = getelementptr inbounds double, double* %735, i64 2
%739 = bitcast double* %738 to <2 x double>*
%740 = load <2 x double>, <2 x double>* %739
%741 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %705, <2 x double> %731, <2 x double> %737)
%742 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %706, <2 x double> %734, <2 x double> %740)
%743 = bitcast double* %735 to <2 x double>*
store <2 x double> %741, <2 x double>* %743
%744 = bitcast double* %738 to <2 x double>*
store <2 x double> %742, <2 x double>* %744
%745 = add nuw i64 %708, 8
%746 = add i64 %709, 2
%747 = icmp eq i64 %746, %48
br i1 %747, label %748, label %707
748: ; preds = %707, %704
%749 = phi i64 [ 0, %704 ], [ %745, %707 ]
br i1 %49, label %768, label %750
750: ; preds = %748
%751 = add nsw i64 %749, %699
%752 = getelementptr inbounds double, double* %3, i64 %751
%753 = bitcast double* %752 to <2 x double>*
%754 = load <2 x double>, <2 x double>* %753
%755 = getelementptr inbounds double, double* %752, i64 2
%756 = bitcast double* %755 to <2 x double>*
%757 = load <2 x double>, <2 x double>* %756
%758 = getelementptr inbounds double, double* %622, i64 %749
%759 = bitcast double* %758 to <2 x double>*
%760 = load <2 x double>, <2 x double>* %759
%761 = getelementptr inbounds double, double* %758, i64 2
%762 = bitcast double* %761 to <2 x double>*
%763 = load <2 x double>, <2 x double>* %762
%764 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %705, <2 x double> %754, <2 x double> %760)
%765 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %706, <2 x double> %757, <2 x double> %763)
%766 = bitcast double* %758 to <2 x double>*
store <2 x double> %764, <2 x double>* %766
%767 = bitcast double* %761 to <2 x double>*
store <2 x double> %765, <2 x double>* %767
br label %768
768: ; preds = %748, %750
br i1 %50, label %800, label %769
769: ; preds = %700, %694, %768
%770 = phi i64 [ 0, %700 ], [ 0, %694 ], [ %45, %768 ]
%771 = xor i64 %770, -1
br i1 %52, label %780, label %772
772: ; preds = %769
%773 = add nsw i64 %770, %699
%774 = getelementptr inbounds double, double* %3, i64 %773
%775 = load double, double* %774
%776 = getelementptr inbounds double, double* %622, i64 %770
%777 = load double, double* %776
%778 = tail call double @llvm.fmuladd.f64(double %698, double %775, double %777)
store double %778, double* %776
%779 = or i64 %770, 1
br label %780
780: ; preds = %772, %769
%781 = phi i64 [ %770, %769 ], [ %779, %772 ]
%782 = icmp eq i64 %771, %53
br i1 %782, label %800, label %783
783: ; preds = %780, %783
%784 = phi i64 [ %798, %783 ], [ %781, %780 ]
%785 = add nsw i64 %784, %699
%786 = getelementptr inbounds double, double* %3, i64 %785
%787 = load double, double* %786
%788 = getelementptr inbounds double, double* %622, i64 %784
%789 = load double, double* %788
%790 = tail call double @llvm.fmuladd.f64(double %698, double %787, double %789)
store double %790, double* %788
%791 = add nuw nsw i64 %784, 1
%792 = add nsw i64 %791, %699
%793 = getelementptr inbounds double, double* %3, i64 %792
%794 = load double, double* %793
%795 = getelementptr inbounds double, double* %622, i64 %791
%796 = load double, double* %795
%797 = tail call double @llvm.fmuladd.f64(double %698, double %794, double %796)
store double %797, double* %795
%798 = add nuw nsw i64 %784, 2
%799 = icmp eq i64 %798, %23
br i1 %799, label %800, label %783
800: ; preds = %780, %783, %768
%801 = add nuw nsw i64 %632, 1
%802 = icmp eq i64 %801, %23
br i1 %802, label %803, label %631
803: ; preds = %800
%804 = add nuw nsw i64 %617, 1
%805 = icmp eq i64 %804, 4
br i1 %805, label %615, label %806
806: ; preds = %803, %808
%807 = phi i64 [ %804, %803 ], [ %809, %808 ]
br label %616
808: ; preds = %616
%809 = add nuw nsw i64 %617, 1
%810 = icmp eq i64 %809, 4
br i1 %810, label %875, label %806
811: ; preds = %615, %811
%812 = phi i64 [ %819, %811 ], [ 0, %615 ]
%813 = getelementptr inbounds double, double* %16, i64 %812
%814 = load double, double* %813
%815 = fcmp olt double %814, 0.000000e+00
%816 = fneg double %814
%817 = select i1 %815, double %816, double %814
%818 = fcmp olt double %817, 0x2FF0000000000000
%819 = add nuw nsw i64 %812, 1
%820 = icmp slt i64 %819, %27
%821 = select i1 %818, i1 %820, i1 false
br i1 %821, label %811, label %822
822: ; preds = %811
br i1 %818, label %823, label %875
823: ; preds = %822
br i1 %54, label %866, label %824
824: ; preds = %823
br i1 %57, label %852, label %825
825: ; preds = %824, %825
%826 = phi i64 [ %849, %825 ], [ 0, %824 ]
%827 = phi i64 [ %850, %825 ], [ 0, %824 ]
%828 = getelementptr inbounds double, double* %16, i64 %826
%829 = bitcast double* %828 to <2 x double>*
%830 = load <2 x double>, <2 x double>* %829
%831 = getelementptr inbounds double, double* %828, i64 2
%832 = bitcast double* %831 to <2 x double>*
%833 = load <2 x double>, <2 x double>* %832
%834 = fmul <2 x double> %830, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%835 = fmul <2 x double> %833, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%836 = bitcast double* %828 to <2 x double>*
store <2 x double> %834, <2 x double>* %836
%837 = bitcast double* %831 to <2 x double>*
store <2 x double> %835, <2 x double>* %837
%838 = or i64 %826, 4
%839 = getelementptr inbounds double, double* %16, i64 %838
%840 = bitcast double* %839 to <2 x double>*
%841 = load <2 x double>, <2 x double>* %840
%842 = getelementptr inbounds double, double* %839, i64 2
%843 = bitcast double* %842 to <2 x double>*
%844 = load <2 x double>, <2 x double>* %843
%845 = fmul <2 x double> %841, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%846 = fmul <2 x double> %844, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%847 = bitcast double* %839 to <2 x double>*
store <2 x double> %845, <2 x double>* %847
%848 = bitcast double* %842 to <2 x double>*
store <2 x double> %846, <2 x double>* %848
%849 = add nuw i64 %826, 8
%850 = add i64 %827, 2
%851 = icmp eq i64 %850, %58
br i1 %851, label %852, label %825
852: ; preds = %825, %824
%853 = phi i64 [ 0, %824 ], [ %849, %825 ]
br i1 %59, label %865, label %854
854: ; preds = %852
%855 = getelementptr inbounds double, double* %16, i64 %853
%856 = bitcast double* %855 to <2 x double>*
%857 = load <2 x double>, <2 x double>* %856
%858 = getelementptr inbounds double, double* %855, i64 2
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = fmul <2 x double> %857, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%862 = fmul <2 x double> %860, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%863 = bitcast double* %855 to <2 x double>*
store <2 x double> %861, <2 x double>* %863
%864 = bitcast double* %858 to <2 x double>*
store <2 x double> %862, <2 x double>* %864
br label %865
865: ; preds = %852, %854
br i1 %60, label %875, label %866
866: ; preds = %823, %865
%867 = phi i64 [ 0, %823 ], [ %55, %865 ]
br label %868
868: ; preds = %866, %868
%869 = phi i64 [ %873, %868 ], [ %867, %866 ]
%870 = getelementptr inbounds double, double* %16, i64 %869
%871 = load double, double* %870
%872 = fmul double %871, 0x4FF0000000000000
store double %872, double* %870
%873 = add nuw nsw i64 %869, 1
%874 = icmp eq i64 %873, %30
br i1 %874, label %875, label %868
875: ; preds = %808, %868, %865, %615, %822
%876 = trunc i64 %613 to i32
%877 = tail call i32 @ancestralGamma(double* %16, double* %12, double* %11, i32 %876, i32 %10, i32 %18)
%878 = add nuw nsw i64 %613, 1
%879 = icmp eq i64 %878, %29
br i1 %879, label %882, label %612
880: ; preds = %13
%881 = tail call i32 @assert(i32 0)
br label %882
882: ; preds = %875, %607, %334, %19, %61, %103, %880
%883 = tail call i32 @rax_free(double* %16)
ret void
}