void newviewFlexCat_Ancestral(int tipCase, double *extEV, int *cptr, double *x1,
                              double *x2, double *tipVector,
                              unsigned char *tipX1, unsigned char *tipX2, int n,
                              double *left, double *right, const int numStates,
                              double *diagptable, double *sumBuffer) {
  double *x3 = (double *)rax_malloc(sizeof(double) * numStates), *le, *ri, *v,
         *vl, *vr, ump_x1, ump_x2, x1px2;
  int i, l, j, scale;
  const int statesSquare = numStates * numStates;
  switch (tipCase) {
  case 0: {
    for (i = 0; i < n; i++) {
      le = &left[cptr[i] * statesSquare];
      ri = &right[cptr[i] * statesSquare];
      vl = &(tipVector[numStates * tipX1[i]]);
      vr = &(tipVector[numStates * tipX2[i]]);
      v = x3;
      for (l = 0; l < numStates; l++)
        v[l] = 0.0;
      for (l = 0; l < numStates; l++) {
        ump_x1 = 0.0;
        ump_x2 = 0.0;
        for (j = 0; j < numStates; j++) {
          ump_x1 += vl[j] * le[l * numStates + j];
          ump_x2 += vr[j] * ri[l * numStates + j];
        }
        x1px2 = ump_x1 * ump_x2;
        for (j = 0; j < numStates; j++)
          v[j] += x1px2 * extEV[l * numStates + j];
      }
      ancestralCat(v, sumBuffer, &diagptable[cptr[i] * statesSquare], i,
                   numStates);
    }
  } break;
  case 1: {
    for (i = 0; i < n; i++) {
      le = &left[cptr[i] * statesSquare];
      ri = &right[cptr[i] * statesSquare];
      vl = &(tipVector[numStates * tipX1[i]]);
      vr = &x2[numStates * i];
      v = x3;
      for (l = 0; l < numStates; l++)
        v[l] = 0.0;
      for (l = 0; l < numStates; l++) {
        ump_x1 = 0.0;
        ump_x2 = 0.0;
        for (j = 0; j < numStates; j++) {
          ump_x1 += vl[j] * le[l * numStates + j];
          ump_x2 += vr[j] * ri[l * numStates + j];
        }
        x1px2 = ump_x1 * ump_x2;
        for (j = 0; j < numStates; j++)
          v[j] += x1px2 * extEV[l * numStates + j];
      }
      scale = 1;
      for (l = 0; scale && (l < numStates); l++)
        scale =
            ((v[l] <
              (1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0)) &&
             (v[l] >
              -(1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      if (scale) {
        for (l = 0; l < numStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
      }
      ancestralCat(v, sumBuffer, &diagptable[cptr[i] * statesSquare], i,
                   numStates);
    }
  } break;
  case 2:
    for (i = 0; i < n; i++) {
      le = &left[cptr[i] * statesSquare];
      ri = &right[cptr[i] * statesSquare];
      vl = &x1[numStates * i];
      vr = &x2[numStates * i];
      v = x3;
      for (l = 0; l < numStates; l++)
        v[l] = 0.0;
      for (l = 0; l < numStates; l++) {
        ump_x1 = 0.0;
        ump_x2 = 0.0;
        for (j = 0; j < numStates; j++) {
          ump_x1 += vl[j] * le[l * numStates + j];
          ump_x2 += vr[j] * ri[l * numStates + j];
        }
        x1px2 = ump_x1 * ump_x2;
        for (j = 0; j < numStates; j++)
          v[j] += x1px2 * extEV[l * numStates + j];
      }
      scale = 1;
      for (l = 0; scale && (l < numStates); l++)
        scale =
            ((v[l] <
              (1.0 /
               115792089237316195423570985008687907853269984665640564039457584007913129639936.0)) &&
             (v[l] >
              -(1.0 /
                115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      if (scale) {
        for (l = 0; l < numStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
      }
      ancestralCat(v, sumBuffer, &diagptable[cptr[i] * statesSquare], i,
                   numStates);
    }
    break;
  default:
    assert(0);
  }
  rax_free(x3);
}


x86 assembly (clang, -O0):
<newviewFlexCat_Ancestral>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
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)
movslq 0x38(%rbp),%rdi
shl    $0x3,%rdi
xor    %eax,%eax
call   1030 <rax_malloc@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    0x38(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x90(%rbp)
test   %eax,%eax
je     11df <newviewFlexCat_Ancestral+0x9f>
jmp    11b7 <newviewFlexCat_Ancestral+0x77>
mov    -0x90(%rbp),%eax
sub    $0x1,%eax
je     1453 <newviewFlexCat_Ancestral+0x313>
jmp    11cb <newviewFlexCat_Ancestral+0x8b>
mov    -0x90(%rbp),%eax
sub    $0x2,%eax
je     17b5 <newviewFlexCat_Ancestral+0x675>
jmp    1b0c <newviewFlexCat_Ancestral+0x9cc>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    144e <newviewFlexCat_Ancestral+0x30e>
mov    0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x7c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    0x18(%rbp),%rdx
movslq -0x7c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    12bb <newviewFlexCat_Ancestral+0x17b>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1291 <newviewFlexCat_Ancestral+0x151>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    140b <newviewFlexCat_Ancestral+0x2cb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1381 <newviewFlexCat_Ancestral+0x241>
mov    -0x58(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12e8 <newviewFlexCat_Ancestral+0x1a8>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    13f8 <newviewFlexCat_Ancestral+0x2b8>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    139a <newviewFlexCat_Ancestral+0x25a>
jmp    13fd <newviewFlexCat_Ancestral+0x2bd>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    12c2 <newviewFlexCat_Ancestral+0x182>
mov    -0x50(%rbp),%rdi
mov    0x48(%rbp),%rsi
mov    0x40(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x8c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x7c(%rbp),%ecx
mov    0x38(%rbp),%r8d
mov    $0x0,%al
call   1060 <ancestralCat@plt>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    11e6 <newviewFlexCat_Ancestral+0xa6>
jmp    1b15 <newviewFlexCat_Ancestral+0x9d5>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    17b0 <newviewFlexCat_Ancestral+0x670>
mov    0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x7c(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1524 <newviewFlexCat_Ancestral+0x3e4>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    14fa <newviewFlexCat_Ancestral+0x3ba>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1674 <newviewFlexCat_Ancestral+0x534>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    15ea <newviewFlexCat_Ancestral+0x4aa>
mov    -0x58(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1551 <newviewFlexCat_Ancestral+0x411>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1661 <newviewFlexCat_Ancestral+0x521>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1603 <newviewFlexCat_Ancestral+0x4c3>
jmp    1666 <newviewFlexCat_Ancestral+0x526>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    152b <newviewFlexCat_Ancestral+0x3eb>
movl   $0x1,-0x88(%rbp)
movl   $0x0,-0x80(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x88(%rbp)
mov    %al,-0x91(%rbp)
je     16a9 <newviewFlexCat_Ancestral+0x569>
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
setl   %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    16bc <newviewFlexCat_Ancestral+0x57c>
jmp    1720 <newviewFlexCat_Ancestral+0x5e0>
mov    -0x50(%rbp),%rcx
movslq -0x80(%rbp),%rdx
xor    %eax,%eax
movsd  0x93a(%rip),%xmm0
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x92(%rbp)
jbe    1701 <newviewFlexCat_Ancestral+0x5c1>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x91c(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x92(%rbp)
mov    -0x92(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x88(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1685 <newviewFlexCat_Ancestral+0x545>
cmpl   $0x0,-0x88(%rbp)
je     176d <newviewFlexCat_Ancestral+0x62d>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1768 <newviewFlexCat_Ancestral+0x628>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  0x8b0(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1734 <newviewFlexCat_Ancestral+0x5f4>
jmp    176d <newviewFlexCat_Ancestral+0x62d>
mov    -0x50(%rbp),%rdi
mov    0x48(%rbp),%rsi
mov    0x40(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x8c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x7c(%rbp),%ecx
mov    0x38(%rbp),%r8d
mov    $0x0,%al
call   1060 <ancestralCat@plt>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    145a <newviewFlexCat_Ancestral+0x31a>
jmp    1b15 <newviewFlexCat_Ancestral+0x9d5>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1b07 <newviewFlexCat_Ancestral+0x9c7>
mov    0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x7c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    187b <newviewFlexCat_Ancestral+0x73b>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1851 <newviewFlexCat_Ancestral+0x711>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    19cb <newviewFlexCat_Ancestral+0x88b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1941 <newviewFlexCat_Ancestral+0x801>
mov    -0x58(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    18a8 <newviewFlexCat_Ancestral+0x768>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    19b8 <newviewFlexCat_Ancestral+0x878>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    195a <newviewFlexCat_Ancestral+0x81a>
jmp    19bd <newviewFlexCat_Ancestral+0x87d>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1882 <newviewFlexCat_Ancestral+0x742>
movl   $0x1,-0x88(%rbp)
movl   $0x0,-0x80(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x88(%rbp)
mov    %al,-0x93(%rbp)
je     1a00 <newviewFlexCat_Ancestral+0x8c0>
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
setl   %al
mov    %al,-0x93(%rbp)
mov    -0x93(%rbp),%al
test   $0x1,%al
jne    1a13 <newviewFlexCat_Ancestral+0x8d3>
jmp    1a77 <newviewFlexCat_Ancestral+0x937>
mov    -0x50(%rbp),%rcx
movslq -0x80(%rbp),%rdx
xor    %eax,%eax
movsd  0x5e3(%rip),%xmm0
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x94(%rbp)
jbe    1a58 <newviewFlexCat_Ancestral+0x918>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5c5(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x94(%rbp)
mov    -0x94(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x88(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    19dc <newviewFlexCat_Ancestral+0x89c>
cmpl   $0x0,-0x88(%rbp)
je     1ac4 <newviewFlexCat_Ancestral+0x984>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1abf <newviewFlexCat_Ancestral+0x97f>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  0x559(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1a8b <newviewFlexCat_Ancestral+0x94b>
jmp    1ac4 <newviewFlexCat_Ancestral+0x984>
mov    -0x50(%rbp),%rdi
mov    0x48(%rbp),%rsi
mov    0x40(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x8c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x7c(%rbp),%ecx
mov    0x38(%rbp),%r8d
mov    $0x0,%al
call   1060 <ancestralCat@plt>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17bc <newviewFlexCat_Ancestral+0x67c>
jmp    1b15 <newviewFlexCat_Ancestral+0x9d5>
xor    %edi,%edi
mov    $0x0,%al
call   1050 <assert@plt>
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   1040 <rax_free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newviewFlexCat_Ancestral>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x18(%rsp)
mov    %rcx,0x40(%rsp)
mov    %rdx,0xf8(%rsp)
mov    %rsi,0x8(%rsp)
mov    %edi,%r15d
mov    0x178(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0xe8(%rsp)
mov    0x168(%rsp),%r14d
mov    0x160(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x150(%rsp),%r12d
mov    0x148(%rsp),%r13
mov    0x140(%rsp),%rax
mov    %rax,0xd0(%rsp)
movslq %r14d,%rbp
lea    0x0(,%rbp,8),%rdi
mov    %rdi,0xc8(%rsp)
xor    %eax,%eax
call   1030 <rax_malloc@plt>
movslq %eax,%rbx
mov    %rbp,0x10(%rsp)
mov    %ebp,%eax
imul   %ebp,%eax
cltq
mov    %rax,0xe0(%rsp)
test   %r15d,%r15d
mov    %r14d,(%rsp)
je     17d7 <newviewFlexCat_Ancestral+0x687>
cmp    $0x1,%r15d
je     1c9b <newviewFlexCat_Ancestral+0xb4b>
cmp    $0x2,%r15d
jne    2287 <newviewFlexCat_Ancestral+0x1137>
test   %r12d,%r12d
jle    2290 <newviewFlexCat_Ancestral+0x1140>
mov    %r14d,%ebp
mov    %r14d,%r15d
lea    0x0(,%r15,8),%rax
mov    %rax,0x90(%rsp)
mov    %r12d,%eax
mov    %rax,0xd0(%rsp)
lea    (%rbx,%r15,8),%rax
mov    %rax,0x68(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r15d,%r14d
and    $0xfffffffe,%r14d
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x60(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xb8(%rsp)
mov    0x40(%rsp),%rax
lea    0x8(%rax),%r12
mov    0x58(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x88(%rsp)
mov    0x50(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
mov    0x18(%rsp),%rax
lea    0x8(%rax),%r13
mov    0x8(%rsp),%rax
lea    0x30(%rax),%rcx
mov    %rcx,0x78(%rsp)
add    $0x8,%rax
mov    %rax,0x70(%rsp)
xor    %ecx,%ecx
jmp    1349 <newviewFlexCat_Ancestral+0x1f9>
nopl   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rax
lea    (%rax,%r8,8),%rdx
mov    %rbx,%rdi
mov    0xf0(%rsp),%rsi
mov    (%rsp),%ebp
mov    %ebp,%r8d
xor    %eax,%eax
call   1070 <ancestralCat@plt>
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
mov    0xc8(%rsp),%rax
add    %rax,%r12
add    %rax,%r13
cmp    0xd0(%rsp),%rcx
je     2290 <newviewFlexCat_Ancestral+0x1140>
mov    0xf8(%rsp),%rax
movslq (%rax,%rcx,4),%r8
imul   0xe0(%rsp),%r8
test   %ebp,%ebp
mov    %rcx,0x20(%rsp)
jle    1300 <newviewFlexCat_Ancestral+0x1b0>
mov    %rcx,%rax
imul   0x10(%rsp),%rax
mov    0x50(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x58(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0xa0(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x98(%rsp)
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x90(%rsp),%rdx
mov    %r8,%rbp
call   1050 <memset@plt>
mov    0x88(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    0x80(%rsp),%rcx
mov    %rbp,0x48(%rsp)
lea    (%rcx,%rbp,8),%rcx
mov    0x70(%rsp),%rdx
mov    0x78(%rsp),%rsi
xor    %r8d,%r8d
mov    0x8(%rsp),%r10
jmp    1421 <newviewFlexCat_Ancestral+0x2d1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
mov    0xc8(%rsp),%rdi
add    %rdi,%rax
add    %rdi,%rcx
add    %rdi,%rsi
add    %rdi,%rdx
cmp    %r15,%r8
je     1690 <newviewFlexCat_Ancestral+0x540>
cmpl   $0x1,(%rsp)
jne    1430 <newviewFlexCat_Ancestral+0x2e0>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    148e <newviewFlexCat_Ancestral+0x33e>
nop
xorpd  %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r13,%rdi,8),%xmm2
movsd  0x0(%r13,%rdi,8),%xmm3
movhpd -0x8(%r12,%rdi,8),%xmm2
movsd  -0x8(%rax,%rdi,8),%xmm4
movsd  (%rax,%rdi,8),%xmm1
movhpd -0x8(%rcx,%rdi,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r12,%rdi,8),%xmm3
movhpd (%rcx,%rdi,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdi
movapd %xmm1,%xmm0
cmp    %rdi,%r14
jne    1440 <newviewFlexCat_Ancestral+0x2f0>
mov    %r8,%r9
imul   0x10(%rsp),%r9
test   $0x1,%r15b
je     14f7 <newviewFlexCat_Ancestral+0x3a7>
mov    %r8,0xc0(%rsp)
mov    %r10,%r8
lea    (%rdi,%r9,1),%r10
mov    0x98(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    0xa0(%rsp),%r11
movhpd (%r11,%rdi,8),%xmm0
mov    0xa8(%rsp),%rdi
movsd  (%rdi,%r10,8),%xmm2
mov    0xb0(%rsp),%rdi
movhpd (%rdi,%r10,8),%xmm2
mov    %r8,%r10
mov    0xc0(%rsp),%r8
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,(%rsp)
jb     1525 <newviewFlexCat_Ancestral+0x3d5>
lea    (%r9,%r15,1),%rdi
lea    (%r10,%rdi,8),%rdi
cmp    %rdi,%rbx
jae    15a0 <newviewFlexCat_Ancestral+0x450>
lea    (%r10,%r9,8),%rdi
cmp    0x68(%rsp),%rdi
jae    15a0 <newviewFlexCat_Ancestral+0x450>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%r15b
je     154e <newviewFlexCat_Ancestral+0x3fe>
add    %rbp,%r9
movsd  (%r10,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    0xb8(%rsp),%rbp
je     1400 <newviewFlexCat_Ancestral+0x2b0>
nop
movsd  -0x8(%rdx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    1560 <newviewFlexCat_Ancestral+0x410>
jmp    1400 <newviewFlexCat_Ancestral+0x2b0>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     1683 <newviewFlexCat_Ancestral+0x533>
mov    0x60(%rsp),%rbp
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rsi,%rdi,8),%xmm2
movupd -0x20(%rsi,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rbx,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbx,%rdi,8),%xmm2
movupd 0x20(%rbx,%rdi,8),%xmm5
movupd 0x30(%rbx,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rbx,%rdi,8)
movupd %xmm3,0x10(%rbx,%rdi,8)
movupd -0x10(%rsi,%rdi,8),%xmm2
movupd (%rsi,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbx,%rdi,8)
movupd %xmm3,0x30(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    15c0 <newviewFlexCat_Ancestral+0x470>
testb  $0x1,0x28(%rsp)
je     166d <newviewFlexCat_Ancestral+0x51d>
lea    (%rdi,%r9,1),%rbp
movupd (%r10,%rbp,8),%xmm2
movupd 0x10(%r10,%rbp,8),%xmm3
movupd (%rbx,%rdi,8),%xmm4
movupd 0x10(%rbx,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rdi,8)
movupd %xmm3,0x10(%rbx,%rdi,8)
mov    0x38(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r15,%rdi
je     1400 <newviewFlexCat_Ancestral+0x2b0>
jmp    1527 <newviewFlexCat_Ancestral+0x3d7>
xor    %edi,%edi
testb  $0x1,0x28(%rsp)
jne    1636 <newviewFlexCat_Ancestral+0x4e6>
jmp    166d <newviewFlexCat_Ancestral+0x51d>
xchg   %ax,%ax
cmpl   $0x0,(%rsp)
movsd  0x1964(%rip),%xmm1
movsd  0x1964(%rip),%xmm2
movsd  0x1964(%rip),%xmm4
movapd 0x196c(%rip),%xmm5
mov    0x20(%rsp),%rcx
mov    0x48(%rsp),%r8
jle    1300 <newviewFlexCat_Ancestral+0x1b0>
mov    $0x1,%eax
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
seta   %sil
ucomisd %xmm2,%xmm0
seta   %dl
and    %sil,%dl
cmp    $0x1,%dl
jne    16fb <newviewFlexCat_Ancestral+0x5ab>
lea    0x1(%rax),%rsi
cmp    0x10(%rsp),%rax
mov    %rsi,%rax
jl     16d0 <newviewFlexCat_Ancestral+0x580>
test   %dl,%dl
je     1300 <newviewFlexCat_Ancestral+0x1b0>
cmpl   $0x4,(%rsp)
jae    1710 <newviewFlexCat_Ancestral+0x5c0>
xor    %eax,%eax
jmp    17b0 <newviewFlexCat_Ancestral+0x660>
cmpq   $0x0,0x30(%rsp)
je     17cc <newviewFlexCat_Ancestral+0x67c>
mov    0x60(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd 0x20(%rbx,%rax,8),%xmm2
movupd 0x30(%rbx,%rax,8),%xmm3
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm3,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1730 <newviewFlexCat_Ancestral+0x5e0>
testb  $0x1,0x28(%rsp)
je     179d <newviewFlexCat_Ancestral+0x64d>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mov    0x38(%rsp),%rdx
mov    %rdx,%rax
cmp    %r15,%rdx
je     1300 <newviewFlexCat_Ancestral+0x1b0>
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    17b0 <newviewFlexCat_Ancestral+0x660>
jmp    1300 <newviewFlexCat_Ancestral+0x1b0>
xor    %eax,%eax
testb  $0x1,0x28(%rsp)
jne    177f <newviewFlexCat_Ancestral+0x62f>
jmp    179d <newviewFlexCat_Ancestral+0x64d>
mov    %r13,0x90(%rsp)
test   %r12d,%r12d
jle    2290 <newviewFlexCat_Ancestral+0x1140>
mov    %r14d,%ecx
mov    %r14d,%r14d
lea    0x0(,%r14,8),%rax
mov    %rax,0x88(%rsp)
mov    %r12d,%eax
mov    %rax,0x40(%rsp)
lea    (%rbx,%r14,8),%rax
mov    %rax,0x68(%rsp)
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r14d,%r15d
and    $0xfffffffe,%r15d
mov    %rdx,%rax
mov    %rdx,0x28(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x60(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0xb8(%rsp)
mov    0x48(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x80(%rsp)
mov    0x58(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x78(%rsp)
mov    0x50(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x70(%rsp)
mov    0x8(%rsp),%rax
lea    0x30(%rax),%rdx
mov    %rdx,0xd8(%rsp)
add    $0x8,%rax
mov    %rax,0x100(%rsp)
xor    %ebp,%ebp
jmp    18ef <newviewFlexCat_Ancestral+0x79f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xe8(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,8),%rdx
mov    %rbx,%rdi
mov    0xf0(%rsp),%rsi
mov    0x20(%rsp),%rbp
mov    %ebp,%ecx
mov    %r12d,%r8d
xor    %eax,%eax
call   1070 <ancestralCat@plt>
add    $0x1,%rbp
cmp    0x40(%rsp),%rbp
mov    %r12d,%ecx
je     2290 <newviewFlexCat_Ancestral+0x1140>
mov    0xf8(%rsp),%rax
mov    %rbp,0x20(%rsp)
movslq (%rax,%rbp,4),%rax
imul   0xe0(%rsp),%rax
mov    %rax,0x18(%rsp)
test   %ecx,%ecx
mov    %ecx,%r12d
jle    18b0 <newviewFlexCat_Ancestral+0x760>
mov    0xd0(%rsp),%rax
mov    0x20(%rsp),%rdx
movzbl (%rax,%rdx,1),%r12d
mov    0x10(%rsp),%rax
imul   %rax,%r12
mov    0x90(%rsp),%rcx
movzbl (%rcx,%rdx,1),%ebp
imul   %rax,%rbp
mov    0x50(%rsp),%rax
mov    0x18(%rsp),%r13
lea    (%rax,%r13,8),%rax
mov    %rax,0xb0(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%r13,8),%rax
mov    %rax,0xa8(%rsp)
mov    0x48(%rsp),%rax
lea    (%rax,%r12,8),%rcx
mov    %rcx,0xa0(%rsp)
lea    (%rax,%rbp,8),%rax
mov    %rax,0x98(%rsp)
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x88(%rsp),%rdx
call   1050 <memset@plt>
mov    0x80(%rsp),%rax
lea    (%rax,%r12,8),%r11
mov    (%rsp),%r12d
mov    0x78(%rsp),%rcx
lea    (%rcx,%r13,8),%rcx
mov    0x70(%rsp),%rdx
lea    (%rdx,%r13,8),%rdx
lea    (%rax,%rbp,8),%rsi
mov    0x100(%rsp),%rdi
mov    0xd8(%rsp),%r10
xor    %r8d,%r8d
jmp    1a01 <newviewFlexCat_Ancestral+0x8b1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
mov    0xc8(%rsp),%rax
add    %rax,%rcx
add    %rax,%rdx
add    %rax,%r10
add    %rax,%rdi
cmp    %r14,%r8
je     18b0 <newviewFlexCat_Ancestral+0x760>
cmp    $0x1,%r12d
jne    1a10 <newviewFlexCat_Ancestral+0x8c0>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    1a6b <newviewFlexCat_Ancestral+0x91b>
nop
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rbp,8),%xmm2
movsd  (%rsi,%rbp,8),%xmm3
movhpd -0x8(%r11,%rbp,8),%xmm2
movsd  -0x8(%rcx,%rbp,8),%xmm4
movsd  (%rcx,%rbp,8),%xmm1
movhpd -0x8(%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r11,%rbp,8),%xmm3
movhpd (%rdx,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm0
cmp    %rbp,%r15
jne    1a20 <newviewFlexCat_Ancestral+0x8d0>
mov    %r8,%r9
imul   0x10(%rsp),%r9
test   $0x1,%r14b
je     1ad6 <newviewFlexCat_Ancestral+0x986>
mov    %r8,0xc0(%rsp)
mov    %r12d,%r8d
lea    (%r9,%rbp,1),%r12
mov    0x98(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0xa0(%rsp),%r13
movhpd 0x0(%r13,%rbp,8),%xmm0
mov    0xa8(%rsp),%rbp
movsd  0x0(%rbp,%r12,8),%xmm2
mov    0xb0(%rsp),%rbp
movhpd 0x0(%rbp,%r12,8),%xmm2
mov    %r8d,%r12d
mov    0xc0(%rsp),%r8
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmp    $0x4,%r12d
jb     1b1b <newviewFlexCat_Ancestral+0x9cb>
lea    (%r9,%r14,1),%rax
mov    0x8(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1ba0 <newviewFlexCat_Ancestral+0xa50>
lea    0x0(,%r9,8),%rax
add    %rbp,%rax
cmp    0x68(%rsp),%rax
jae    1ba0 <newviewFlexCat_Ancestral+0xa50>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%r14b
je     1b49 <newviewFlexCat_Ancestral+0x9f9>
add    %rbp,%r9
mov    0x8(%rsp),%rax
movsd  (%rax,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0xb8(%rsp),%rbp
je     19e0 <newviewFlexCat_Ancestral+0x890>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1b60 <newviewFlexCat_Ancestral+0xa10>
jmp    19e0 <newviewFlexCat_Ancestral+0x890>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     1c90 <newviewFlexCat_Ancestral+0xb40>
mov    0x60(%rsp),%rax
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r10,%rbp,8),%xmm2
movupd -0x20(%r10,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rbx,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbx,%rbp,8),%xmm2
movupd 0x20(%rbx,%rbp,8),%xmm5
movupd 0x30(%rbx,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rbx,%rbp,8)
movupd %xmm3,0x10(%rbx,%rbp,8)
movupd -0x10(%r10,%rbp,8),%xmm2
movupd (%r10,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbx,%rbp,8)
movupd %xmm3,0x30(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    1bc0 <newviewFlexCat_Ancestral+0xa70>
testb  $0x1,0x28(%rsp)
je     1c7a <newviewFlexCat_Ancestral+0xb2a>
lea    (%r9,%rbp,1),%r12
mov    0x8(%rsp),%rax
movupd (%rax,%r12,8),%xmm2
movupd 0x10(%rax,%r12,8),%xmm3
mov    (%rsp),%r12d
movupd (%rbx,%rbp,8),%xmm4
movupd 0x10(%rbx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rbp,8)
movupd %xmm3,0x10(%rbx,%rbp,8)
mov    0x38(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
je     19e0 <newviewFlexCat_Ancestral+0x890>
jmp    1b1d <newviewFlexCat_Ancestral+0x9cd>
xor    %ebp,%ebp
testb  $0x1,0x28(%rsp)
jne    1c3a <newviewFlexCat_Ancestral+0xaea>
jmp    1c7a <newviewFlexCat_Ancestral+0xb2a>
test   %r12d,%r12d
jle    2290 <newviewFlexCat_Ancestral+0x1140>
mov    %r14d,%ecx
mov    %r14d,%r15d
lea    0x0(,%r15,8),%rax
mov    %rax,0x90(%rsp)
mov    %r12d,%eax
mov    %rax,0x40(%rsp)
lea    (%rbx,%r15,8),%rax
mov    %rax,0x98(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r15d,%r13d
and    $0xfffffffe,%r13d
mov    %rdx,%rax
mov    %rdx,0x30(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x28(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xc0(%rsp)
mov    0x48(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x88(%rsp)
mov    0x58(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x80(%rsp)
mov    0x50(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x78(%rsp)
mov    0x18(%rsp),%rax
lea    0x8(%rax),%r14
mov    0x8(%rsp),%rax
lea    0x30(%rax),%rdx
mov    %rdx,0x70(%rsp)
add    $0x8,%rax
mov    %rax,0xd8(%rsp)
xor    %ebp,%ebp
jmp    1dad <newviewFlexCat_Ancestral+0xc5d>
nopw   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rax
lea    (%rax,%rsi,8),%rdx
mov    %rbx,%rdi
mov    0xf0(%rsp),%rsi
mov    %ebp,%ecx
mov    %r12d,%r8d
xor    %eax,%eax
call   1070 <ancestralCat@plt>
add    $0x1,%rbp
add    0xc8(%rsp),%r14
cmp    0x40(%rsp),%rbp
mov    %r12d,%ecx
je     2290 <newviewFlexCat_Ancestral+0x1140>
mov    0xf8(%rsp),%rax
movslq (%rax,%rbp,4),%rsi
imul   0xe0(%rsp),%rsi
test   %ecx,%ecx
mov    %ecx,%r12d
jle    1d70 <newviewFlexCat_Ancestral+0xc20>
mov    0xd0(%rsp),%rax
movzbl (%rax,%rbp,1),%edi
mov    0x10(%rsp),%rcx
imul   %rcx,%rdi
mov    %rdi,(%rsp)
mov    %rbp,0x60(%rsp)
imul   %rcx,%rbp
mov    0x50(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xb8(%rsp)
mov    0x58(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,8),%rax
mov    %rax,0xa0(%rsp)
mov    %rbx,%rdi
mov    %rsi,%rbp
xor    %esi,%esi
mov    0x90(%rsp),%rdx
call   1050 <memset@plt>
mov    0x88(%rsp),%rax
mov    (%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    0x80(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    0x78(%rsp),%rdx
mov    %rbp,0x20(%rsp)
lea    (%rdx,%rbp,8),%rdx
mov    0xd8(%rsp),%rsi
mov    0x70(%rsp),%r10
xor    %r8d,%r8d
mov    0x8(%rsp),%r11
jmp    1eb1 <newviewFlexCat_Ancestral+0xd61>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
mov    0xc8(%rsp),%rdi
add    %rdi,%rcx
add    %rdi,%rdx
add    %rdi,%r10
add    %rdi,%rsi
cmp    %r15,%r8
je     2140 <newviewFlexCat_Ancestral+0xff0>
cmp    $0x1,%r12d
jne    1ec0 <newviewFlexCat_Ancestral+0xd70>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    1f1b <newviewFlexCat_Ancestral+0xdcb>
nop
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rbp,8),%xmm2
movsd  (%r14,%rbp,8),%xmm3
movhpd -0x8(%rax,%rbp,8),%xmm2
movsd  -0x8(%rcx,%rbp,8),%xmm4
movsd  (%rcx,%rbp,8),%xmm1
movhpd -0x8(%rdx,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%rax,%rbp,8),%xmm3
movhpd (%rdx,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm0
cmp    %rbp,%r13
jne    1ed0 <newviewFlexCat_Ancestral+0xd80>
mov    %r8,%r9
imul   0x10(%rsp),%r9
test   $0x1,%r15b
je     1f83 <newviewFlexCat_Ancestral+0xe33>
mov    %r8,(%rsp)
lea    (%r9,%rbp,1),%r8
mov    0xa0(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm0
mov    %r11,%rdi
mov    %r12d,%r11d
mov    0xa8(%rsp),%r12
movhpd (%r12,%rbp,8),%xmm0
mov    %r11d,%r12d
mov    %rdi,%r11
mov    0xb0(%rsp),%rbp
movsd  0x0(%rbp,%r8,8),%xmm2
mov    0xb8(%rsp),%rbp
movhpd 0x0(%rbp,%r8,8),%xmm2
mov    (%rsp),%r8
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmp    $0x4,%r12d
jb     1fb8 <newviewFlexCat_Ancestral+0xe68>
lea    (%r9,%r15,1),%rdi
lea    (%r11,%rdi,8),%rdi
cmp    %rdi,%rbx
jae    2040 <newviewFlexCat_Ancestral+0xef0>
lea    (%r11,%r9,8),%rdi
cmp    0x98(%rsp),%rdi
jae    2040 <newviewFlexCat_Ancestral+0xef0>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%r15b
je     1fe1 <newviewFlexCat_Ancestral+0xe91>
add    %rbp,%r9
movsd  (%r11,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rbp,8),%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    0xc0(%rsp),%rbp
je     1e90 <newviewFlexCat_Ancestral+0xd40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,(%rbx,%rdi,8)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rdi,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    2000 <newviewFlexCat_Ancestral+0xeb0>
jmp    1e90 <newviewFlexCat_Ancestral+0xd40>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x38(%rsp)
je     2127 <newviewFlexCat_Ancestral+0xfd7>
mov    0x28(%rsp),%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r10,%rbp,8),%xmm2
movupd -0x20(%r10,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rbx,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rbx,%rbp,8),%xmm2
movupd 0x20(%rbx,%rbp,8),%xmm5
movupd 0x30(%rbx,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rbx,%rbp,8)
movupd %xmm3,0x10(%rbx,%rbp,8)
movupd -0x10(%r10,%rbp,8),%xmm2
movupd (%r10,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rbx,%rbp,8)
movupd %xmm3,0x30(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    2060 <newviewFlexCat_Ancestral+0xf10>
testb  $0x1,0x30(%rsp)
je     2111 <newviewFlexCat_Ancestral+0xfc1>
lea    (%r9,%rbp,1),%rdi
movupd (%r11,%rdi,8),%xmm2
movupd 0x10(%r11,%rdi,8),%xmm3
movupd (%rbx,%rbp,8),%xmm4
movupd 0x10(%rbx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rbx,%rbp,8)
movupd %xmm3,0x10(%rbx,%rbp,8)
mov    0x68(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r15,%rdi
je     1e90 <newviewFlexCat_Ancestral+0xd40>
jmp    1fba <newviewFlexCat_Ancestral+0xe6a>
xor    %ebp,%ebp
testb  $0x1,0x30(%rsp)
jne    20da <newviewFlexCat_Ancestral+0xf8a>
jmp    2111 <newviewFlexCat_Ancestral+0xfc1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r12d,%r12d
movsd  0xeb5(%rip),%xmm1
movsd  0xeb5(%rip),%xmm2
movsd  0xeb5(%rip),%xmm4
movapd 0xebd(%rip),%xmm5
mov    0x60(%rsp),%rbp
mov    0x20(%rsp),%rsi
jle    1d70 <newviewFlexCat_Ancestral+0xc20>
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
seta   %dl
ucomisd %xmm2,%xmm0
seta   %cl
and    %dl,%cl
cmp    $0x1,%cl
jne    21a9 <newviewFlexCat_Ancestral+0x1059>
lea    0x1(%rax),%rdx
cmp    0x10(%rsp),%rax
mov    %rdx,%rax
jl     2180 <newviewFlexCat_Ancestral+0x1030>
test   %cl,%cl
je     1d70 <newviewFlexCat_Ancestral+0xc20>
cmp    $0x4,%r12d
jae    21be <newviewFlexCat_Ancestral+0x106e>
xor    %eax,%eax
jmp    2260 <newviewFlexCat_Ancestral+0x1110>
cmpq   $0x0,0x38(%rsp)
je     227c <newviewFlexCat_Ancestral+0x112c>
mov    0x28(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
movupd 0x20(%rbx,%rax,8),%xmm2
movupd 0x30(%rbx,%rax,8),%xmm3
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,0x20(%rbx,%rax,8)
movupd %xmm3,0x30(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    21e0 <newviewFlexCat_Ancestral+0x1090>
testb  $0x1,0x30(%rsp)
je     224d <newviewFlexCat_Ancestral+0x10fd>
movupd (%rbx,%rax,8),%xmm0
movupd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rbx,%rax,8)
movupd %xmm1,0x10(%rbx,%rax,8)
mov    0x68(%rsp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
je     1d70 <newviewFlexCat_Ancestral+0xc20>
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    2260 <newviewFlexCat_Ancestral+0x1110>
jmp    1d70 <newviewFlexCat_Ancestral+0xc20>
xor    %eax,%eax
testb  $0x1,0x30(%rsp)
jne    222f <newviewFlexCat_Ancestral+0x10df>
jmp    224d <newviewFlexCat_Ancestral+0x10fd>
xor    %edi,%edi
xor    %eax,%eax
call   1060 <assert@plt>
mov    %rbx,%rdi
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <rax_free@plt>

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

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