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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ ascertainmentBiasSequence(unsigned char *, int const);
int /*<<< orphan*/ assert(int /*<<< orphan*/);
void newviewAscCat(int tipCase, double *x1, double *x2, double *x3,
                   double *extEV, double *tipVector, int *ex3, const int n,
                   double *left, double *right, const int numStates) {
  double *le, *ri, *v, *vl, *vr, ump_x1, ump_x2, x1px2;
  int i, l, j, scale;
  unsigned char tip[32];
  ascertainmentBiasSequence(tip, numStates);
  switch (tipCase) {
  case 0: {
    for (i = 0; i < n; i++) {
      le = &left[0];
      ri = &right[0];
      vl = &(tipVector[numStates * tip[i]]);
      vr = &(tipVector[numStates * tip[i]]);
      v = &x3[numStates * i];
      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];
      }
    }
  } break;
  case 1: {
    for (i = 0; i < n; i++) {
      le = &left[0];
      ri = &right[0];
      vl = &(tipVector[numStates * tip[i]]);
      vr = &x2[numStates * i];
      v = &x3[numStates * i];
      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;
        ex3[i] += 1;
      }
    }
  } break;
  case 2:
    for (i = 0; i < n; i++) {
      le = &left[0];
      ri = &right[0];
      vl = &x1[numStates * i];
      vr = &x2[numStates * i];
      v = &x3[numStates * i];
      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;
        ex3[i] += 1;
      }
    }
    break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<newviewAscCat>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x30(%rbp),%esi
lea    -0xa0(%rbp),%rdi
call   1040 <ascertainmentBiasSequence@plt>
mov    -0x4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
test   %eax,%eax
je     11a1 <newviewAscCat+0x81>
jmp    1179 <newviewAscCat+0x59>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
je     1394 <newviewAscCat+0x274>
jmp    118d <newviewAscCat+0x6d>
mov    -0xa4(%rbp),%eax
sub    $0x2,%eax
je     1675 <newviewAscCat+0x555>
jmp    194b <newviewAscCat+0x82b>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    138f <newviewAscCat+0x26f>
mov    0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x74(%rbp),%rdx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x74(%rbp),%rdx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1256 <newviewAscCat+0x136>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    122c <newviewAscCat+0x10c>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    137c <newviewAscCat+0x25c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1304 <newviewAscCat+0x1e4>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%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    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1280 <newviewAscCat+0x160>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1369 <newviewAscCat+0x249>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    131a <newviewAscCat+0x1fa>
jmp    136e <newviewAscCat+0x24e>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    125d <newviewAscCat+0x13d>
jmp    1381 <newviewAscCat+0x261>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11a8 <newviewAscCat+0x88>
jmp    1952 <newviewAscCat+0x832>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1670 <newviewAscCat+0x550>
mov    0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x74(%rbp),%rdx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    143e <newviewAscCat+0x31e>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1414 <newviewAscCat+0x2f4>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1564 <newviewAscCat+0x444>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    14ec <newviewAscCat+0x3cc>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%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    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1468 <newviewAscCat+0x348>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1551 <newviewAscCat+0x431>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1502 <newviewAscCat+0x3e2>
jmp    1556 <newviewAscCat+0x436>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1445 <newviewAscCat+0x325>
movl   $0x1,-0x80(%rbp)
movl   $0x0,-0x78(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x80(%rbp)
mov    %al,-0xa5(%rbp)
je     1593 <newviewAscCat+0x473>
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
setl   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    15a6 <newviewAscCat+0x486>
jmp    1607 <newviewAscCat+0x4e7>
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
xor    %eax,%eax
movsd  0xa50(%rip),%xmm0
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xa6(%rbp)
jbe    15eb <newviewAscCat+0x4cb>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa32(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa6(%rbp)
mov    -0xa6(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1572 <newviewAscCat+0x452>
cmpl   $0x0,-0x80(%rbp)
je     165d <newviewAscCat+0x53d>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    164c <newviewAscCat+0x52c>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0x9cc(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1618 <newviewAscCat+0x4f8>
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1662 <newviewAscCat+0x542>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    139b <newviewAscCat+0x27b>
jmp    1952 <newviewAscCat+0x832>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1946 <newviewAscCat+0x826>
mov    0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    0x28(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1714 <newviewAscCat+0x5f4>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16ea <newviewAscCat+0x5ca>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    183a <newviewAscCat+0x71a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    17c2 <newviewAscCat+0x6a2>
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%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    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    173e <newviewAscCat+0x61e>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1827 <newviewAscCat+0x707>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17d8 <newviewAscCat+0x6b8>
jmp    182c <newviewAscCat+0x70c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    171b <newviewAscCat+0x5fb>
movl   $0x1,-0x80(%rbp)
movl   $0x0,-0x78(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x80(%rbp)
mov    %al,-0xa7(%rbp)
je     1869 <newviewAscCat+0x749>
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
setl   %al
mov    %al,-0xa7(%rbp)
mov    -0xa7(%rbp),%al
test   $0x1,%al
jne    187c <newviewAscCat+0x75c>
jmp    18dd <newviewAscCat+0x7bd>
mov    -0x48(%rbp),%rcx
movslq -0x78(%rbp),%rdx
xor    %eax,%eax
movsd  0x77a(%rip),%xmm0
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xa8(%rbp)
jbe    18c1 <newviewAscCat+0x7a1>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x75c(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xa8(%rbp)
mov    -0xa8(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1848 <newviewAscCat+0x728>
cmpl   $0x0,-0x80(%rbp)
je     1933 <newviewAscCat+0x813>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1922 <newviewAscCat+0x802>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  0x6f6(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18ee <newviewAscCat+0x7ce>
mov    0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1938 <newviewAscCat+0x818>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    167c <newviewAscCat+0x55c>
jmp    1952 <newviewAscCat+0x832>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newviewAscCat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x18(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x38(%rsp)
mov    %edi,%r15d
mov    0x140(%rsp),%ebp
mov    0x128(%rsp),%ebx
lea    0xc0(%rsp),%rdi
mov    %ebp,%esi
call   1050 <ascertainmentBiasSequence@plt>
movslq %ebp,%r11
test   %r15d,%r15d
mov    %r11,0x98(%rsp)
je     1799 <newviewAscCat+0x669>
cmp    $0x1,%r15d
je     1bc3 <newviewAscCat+0xa93>
cmp    $0x2,%r15d
jne    21b7 <newviewAscCat+0x1087>
test   %ebx,%ebx
mov    0x10(%rsp),%rax
jle    21be <newviewAscCat+0x108e>
mov    %r11d,%r15d
lea    0x0(,%r15,8),%rcx
mov    %rcx,0x58(%rsp)
mov    %ebx,%ecx
mov    %rcx,0x60(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x28(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x8(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r15d,%esi
and    $0xfffffffe,%esi
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x18(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x88(%rsp)
mov    0x38(%rsp),%rcx
lea    0x8(%rcx),%r12
lea    0x0(,%r11,8),%rcx
mov    %rcx,0x30(%rsp)
mov    0x138(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0xb8(%rsp)
mov    0x130(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x40(%rsp),%rcx
lea    0x8(%rcx),%r14
lea    0x30(%rax),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x48(%rsp),%rcx
lea    0x30(%rcx),%rbx
add    $0x8,%rax
mov    %rax,0xa0(%rsp)
lea    0x8(%rcx),%r13
xor    %edi,%edi
mov    %rcx,%rbp
mov    %rsi,0x90(%rsp)
jmp    12bf <newviewAscCat+0x18f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x120(%rsp),%rax
addl   $0x1,(%rax,%rdi,4)
add    $0x1,%rdi
mov    0x30(%rsp),%rax
add    %rax,%r12
add    %rax,%r14
add    %rax,%rbx
add    %rax,%r13
add    %rax,%rbp
cmp    0x60(%rsp),%rdi
je     21be <newviewAscCat+0x108e>
cmpl   $0x0,0x140(%rsp)
jle    1290 <newviewAscCat+0x160>
mov    %rbp,0x68(%rsp)
mov    %rdi,%rax
imul   %r11,%rax
lea    (%rax,%r15,1),%rcx
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
mov    %rsi,(%rsp)
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x80(%rsp)
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x78(%rsp)
mov    %rdi,0x70(%rsp)
mov    %edi,%eax
imul   0x140(%rsp),%eax
cltq
lea    (%rdx,%rax,8),%rdi
xor    %esi,%esi
mov    0x58(%rsp),%rdx
call   1030 <memset@plt>
mov    0x98(%rsp),%r11
mov    0x10(%rsp),%r8
mov    0xa0(%rsp),%rax
mov    0xa8(%rsp),%rcx
mov    0xb0(%rsp),%rdx
mov    0xb8(%rsp),%rsi
xor    %r10d,%r10d
jmp    138e <newviewAscCat+0x25e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x30(%rsp),%rdi
add    %rdi,%rsi
add    %rdi,%rdx
add    %rdi,%rcx
add    %rdi,%rax
cmp    %r15,%r10
je     1630 <newviewAscCat+0x500>
cmpl   $0x1,0x140(%rsp)
01
mov    0x90(%rsp),%rbp
jne    13b0 <newviewAscCat+0x280>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    140d <newviewAscCat+0x2dd>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rdi,8),%xmm2
movsd  (%r14,%rdi,8),%xmm3
movhpd -0x8(%r12,%rdi,8),%xmm2
movsd  -0x8(%rsi,%rdi,8),%xmm4
movsd  (%rsi,%rdi,8),%xmm1
movhpd -0x8(%rdx,%rdi,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r12,%rdi,8),%xmm3
movhpd (%rdx,%rdi,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdi
movapd %xmm1,%xmm0
cmp    %rdi,%rbp
jne    13c0 <newviewAscCat+0x290>
mov    %r10,%r9
imul   %r11,%r9
test   $0x1,%r15b
je     146c <newviewAscCat+0x33c>
lea    (%rdi,%r9,1),%r8
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    %r10,%rbp
mov    %r11,%r10
mov    0x80(%rsp),%r11
movhpd (%r11,%rdi,8),%xmm0
mov    %r10,%r11
mov    %rbp,%r10
mov    0x138(%rsp),%rdi
movsd  (%rdi,%r8,8),%xmm2
mov    0x130(%rsp),%rdi
movhpd (%rdi,%r8,8),%xmm2
mov    0x10(%rsp),%r8
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,0x140(%rsp)
04
jb     14a3 <newviewAscCat+0x373>
lea    (%r9,%r15,1),%rdi
lea    (%r8,%rdi,8),%rdi
cmp    %rdi,(%rsp)
jae    1530 <newviewAscCat+0x400>
lea    (%r8,%r9,8),%rdi
cmp    0x50(%rsp),%rdi
jae    1530 <newviewAscCat+0x400>
xor    %ebp,%ebp
mov    %rbp,%rdi
test   $0x1,%r15b
je     14d0 <newviewAscCat+0x3a0>
add    %rbp,%r9
movsd  (%r8,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
mov    (%rsp),%rdi
addsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
mov    %rbp,%rdi
or     $0x1,%rdi
not    %rbp
cmp    0x88(%rsp),%rbp
je     1370 <newviewAscCat+0x240>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r13,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdi,8)
movsd  (%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rdi,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r15
jne    14f0 <newviewAscCat+0x3c0>
jmp    1370 <newviewAscCat+0x240>
nopl   (%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x8(%rsp)
je     1619 <newviewAscCat+0x4e9>
mov    0x18(%rsp),%rbp
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rbx,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rbx,%rdi,8),%xmm2
movupd -0x10(%rbx,%rdi,8),%xmm5
movupd (%rbx,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rbx,%rdi,8)
movupd %xmm3,-0x20(%rbx,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rbx,%rdi,8)
movupd %xmm3,(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1550 <newviewAscCat+0x420>
testb  $0x1,0x20(%rsp)
je     1603 <newviewAscCat+0x4d3>
lea    (%rdi,%r9,1),%rbp
movupd (%r8,%rbp,8),%xmm2
movupd 0x10(%r8,%rbp,8),%xmm3
mov    (%rsp),%rbp
movupd 0x0(%rbp,%rdi,8),%xmm4
movupd 0x10(%rbp,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,0x0(%rbp,%rdi,8)
movupd %xmm3,0x10(%rbp,%rdi,8)
mov    0x28(%rsp),%rdi
mov    %rdi,%rbp
cmp    %r15,%rdi
je     1370 <newviewAscCat+0x240>
jmp    14a5 <newviewAscCat+0x375>
xor    %edi,%edi
testb  $0x1,0x20(%rsp)
jne    15c6 <newviewAscCat+0x496>
jmp    1603 <newviewAscCat+0x4d3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x140(%rsp)
movsd  0x19c0(%rip),%xmm1
movsd  0x19c0(%rip),%xmm2
movsd  0x19c0(%rip),%xmm4
movapd 0x19c8(%rip),%xmm5
mov    0x70(%rsp),%rdi
mov    0x68(%rsp),%rbp
jle    1290 <newviewAscCat+0x160>
mov    $0x1,%eax
nopl   (%rax)
movsd  -0x8(%rbp,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
seta   %dl
ucomisd %xmm2,%xmm0
seta   %cl
and    %dl,%cl
cmp    $0x1,%cl
jne    1697 <newviewAscCat+0x567>
lea    0x1(%rax),%rdx
cmp    %r11,%rax
mov    %rdx,%rax
jl     1670 <newviewAscCat+0x540>
test   %cl,%cl
je     129c <newviewAscCat+0x16c>
cmpl   $0x0,0x140(%rsp)
jle    1290 <newviewAscCat+0x160>
cmpl   $0x4,0x140(%rsp)
04
jae    16be <newviewAscCat+0x58e>
xor    %eax,%eax
jmp    1770 <newviewAscCat+0x640>
cmpq   $0x0,0x8(%rsp)
je     178e <newviewAscCat+0x65e>
mov    0x18(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rbx,%rax,8),%xmm0
movupd -0x20(%rbx,%rax,8),%xmm1
movupd -0x10(%rbx,%rax,8),%xmm2
movupd (%rbx,%rax,8),%xmm3
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,-0x30(%rbx,%rax,8)
movupd %xmm1,-0x20(%rbx,%rax,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rbx,%rax,8)
movupd %xmm3,(%rbx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    16e0 <newviewAscCat+0x5b0>
testb  $0x1,0x20(%rsp)
je     1751 <newviewAscCat+0x621>
mov    (%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x28(%rsp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
je     1290 <newviewAscCat+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1770 <newviewAscCat+0x640>
jmp    1290 <newviewAscCat+0x160>
xor    %eax,%eax
testb  $0x1,0x20(%rsp)
jne    172f <newviewAscCat+0x5ff>
jmp    1751 <newviewAscCat+0x621>
test   %ebx,%ebx
mov    0x10(%rsp),%rax
jle    21be <newviewAscCat+0x108e>
mov    0x140(%rsp),%r15d
lea    0x0(,%r15,8),%rcx
mov    %rcx,0x40(%rsp)
mov    %ebx,%ecx
mov    %rcx,0x20(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x80(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x78(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r15d,%r14d
and    $0xfffffffe,%r14d
mov    %rdx,%rcx
mov    %rdx,0x50(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x28(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x30(%rsp)
mov    0x18(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0x70(%rsp)
mov    0x138(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0x68(%rsp)
lea    0x0(,%r11,8),%r12
mov    0x130(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0x60(%rsp)
lea    0x30(%rax),%rcx
mov    %rcx,0x38(%rsp)
mov    0x48(%rsp),%rcx
lea    0x30(%rcx),%r13
add    $0x8,%rax
mov    %rax,0x58(%rsp)
lea    0x8(%rcx),%rbp
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    1892 <newviewAscCat+0x762>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
add    %r12,%r13
add    %r12,%rbp
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
cmp    0x20(%rsp),%rcx
je     21be <newviewAscCat+0x108e>
cmpl   $0x0,0x140(%rsp)
jle    1870 <newviewAscCat+0x740>
mov    0x8(%rsp),%rdx
mov    %rdx,%rax
mov    0x98(%rsp),%rcx
imul   %rcx,%rax
movzbl 0xc0(%rsp,%rdx,1),%ebx
imul   %rcx,%rbx
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %rsi,(%rsp)
add    %r15,%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rax,0x90(%rsp)
mov    %edx,%eax
imul   0x140(%rsp),%eax
cltq
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x40(%rsp),%rdx
call   1030 <memset@plt>
mov    0x10(%rsp),%r11
mov    0x70(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0x58(%rsp),%rcx
mov    0x38(%rsp),%r10
mov    0x60(%rsp),%rsi
mov    0x68(%rsp),%rdi
xor    %r8d,%r8d
jmp    1949 <newviewAscCat+0x819>
nopl   0x0(%rax)
add    $0x1,%r8
add    %r12,%rdi
add    %r12,%rsi
add    %r12,%r10
add    %r12,%rcx
cmp    %r15,%r8
je     1870 <newviewAscCat+0x740>
cmpl   $0x1,0x140(%rsp)
01
jne    1960 <newviewAscCat+0x830>
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
jmp    19b6 <newviewAscCat+0x886>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbx,8),%xmm2
movsd  (%rax,%rbx,8),%xmm3
unpcklpd %xmm2,%xmm2
movsd  -0x8(%rdi,%rbx,8),%xmm4
movsd  (%rdi,%rbx,8),%xmm1
movhpd -0x8(%rsi,%rbx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
unpcklpd %xmm3,%xmm3
movhpd (%rsi,%rbx,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbx
movapd %xmm1,%xmm0
cmp    %rbx,%r14
jne    1970 <newviewAscCat+0x840>
mov    %r8,%r9
imul   0x98(%rsp),%r9
test   $0x1,%r15b
je     19fe <newviewAscCat+0x8ce>
mov    0x90(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm0
add    %r9,%rbx
unpcklpd %xmm0,%xmm0
mov    0x138(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm2
mov    0x130(%rsp),%rdx
movhpd (%rdx,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,0x140(%rsp)
04
jb     1a38 <newviewAscCat+0x908>
lea    (%r9,%r15,1),%rdx
lea    (%r11,%rdx,8),%rdx
cmp    %rdx,(%rsp)
jae    1ac0 <newviewAscCat+0x990>
lea    (%r11,%r9,8),%rdx
cmp    0x88(%rsp),%rdx
jae    1ac0 <newviewAscCat+0x990>
xor    %ebx,%ebx
mov    %rbx,%rdx
test   $0x1,%r15b
je     1a65 <newviewAscCat+0x935>
add    %rbx,%r9
movsd  (%r11,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
mov    (%rsp),%rdx
addsd  (%rdx,%rbx,8),%xmm1
movsd  %xmm1,(%rdx,%rbx,8)
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
cmp    0x30(%rsp),%rbx
je     1930 <newviewAscCat+0x800>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbp,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    1a80 <newviewAscCat+0x950>
jmp    1930 <newviewAscCat+0x800>
nopl   0x0(%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x78(%rsp)
je     1bb8 <newviewAscCat+0xa88>
mov    0x28(%rsp),%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r10,%rbx,8),%xmm2
movupd -0x20(%r10,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r13,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r13,%rbx,8),%xmm2
movupd -0x10(%r13,%rbx,8),%xmm5
movupd 0x0(%r13,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r13,%rbx,8)
movupd %xmm3,-0x20(%r13,%rbx,8)
movupd -0x10(%r10,%rbx,8),%xmm2
movupd (%r10,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r13,%rbx,8)
movupd %xmm3,0x0(%r13,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1ae0 <newviewAscCat+0x9b0>
testb  $0x1,0x50(%rsp)
je     1b9f <newviewAscCat+0xa6f>
lea    (%rbx,%r9,1),%rdx
movupd (%r11,%rdx,8),%xmm2
movupd 0x10(%r11,%rdx,8),%xmm3
mov    (%rsp),%rdx
movupd (%rdx,%rbx,8),%xmm4
movupd 0x10(%rdx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rbx,8)
movupd %xmm3,0x10(%rdx,%rbx,8)
mov    0x80(%rsp),%rdx
mov    %rdx,%rbx
cmp    %r15,%rdx
je     1930 <newviewAscCat+0x800>
jmp    1a3a <newviewAscCat+0x90a>
xor    %ebx,%ebx
testb  $0x1,0x50(%rsp)
jne    1b64 <newviewAscCat+0xa34>
jmp    1b9f <newviewAscCat+0xa6f>
test   %ebx,%ebx
mov    0x10(%rsp),%rax
jle    21be <newviewAscCat+0x108e>
mov    0x140(%rsp),%r15d
lea    0x0(,%r15,8),%rcx
mov    %rcx,0x38(%rsp)
mov    %ebx,%ecx
mov    %rcx,0x60(%rsp)
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x50(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x28(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r15d,%r13d
and    $0xfffffffe,%r13d
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x20(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x90(%rsp)
mov    0x18(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0x58(%rsp)
mov    0x138(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x0(,%r11,8),%rcx
mov    %rcx,0x30(%rsp)
mov    0x130(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0xb0(%rsp)
mov    0x40(%rsp),%rcx
lea    0x8(%rcx),%r12
lea    0x30(%rax),%rcx
mov    %rcx,0xa8(%rsp)
mov    0x48(%rsp),%rcx
lea    0x30(%rcx),%r14
add    $0x8,%rax
mov    %rax,0xa0(%rsp)
lea    0x8(%rcx),%rbx
xor    %esi,%esi
mov    %rcx,%rdi
jmp    1cdc <newviewAscCat+0xbac>
nopl   0x0(%rax)
mov    0x120(%rsp),%rax
addl   $0x1,(%rax,%rsi,4)
add    $0x1,%rsi
mov    0x30(%rsp),%rax
add    %rax,%r12
add    %rax,%r14
add    %rax,%rbx
add    %rax,%rdi
cmp    0x60(%rsp),%rsi
je     21be <newviewAscCat+0x108e>
cmpl   $0x0,0x140(%rsp)
jle    1cb0 <newviewAscCat+0xb80>
mov    %rdi,0x68(%rsp)
mov    %rsi,%rax
imul   %r11,%rax
lea    (%rax,%r15,1),%rcx
movzbl 0xc0(%rsp,%rsi,1),%ebp
imul   %r11,%rbp
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rdi
mov    %rdi,(%rsp)
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x78(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    %rcx,0x88(%rsp)
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x80(%rsp)
mov    %rsi,0x70(%rsp)
mov    %esi,%eax
imul   0x140(%rsp),%eax
cltq
lea    (%rdx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1030 <memset@plt>
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    0xa0(%rsp),%rcx
mov    0xa8(%rsp),%r10
mov    0xb0(%rsp),%rsi
mov    0xb8(%rsp),%rdi
xor    %r11d,%r11d
jmp    1dae <newviewAscCat+0xc7e>
xchg   %ax,%ax
add    $0x1,%r11
mov    0x30(%rsp),%rdx
add    %rdx,%rdi
add    %rdx,%rsi
add    %rdx,%r10
add    %rdx,%rcx
cmp    %r15,%r11
je     2040 <newviewAscCat+0xf10>
cmpl   $0x1,0x140(%rsp)
01
jne    1dc0 <newviewAscCat+0xc90>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    1e1b <newviewAscCat+0xceb>
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rbp,8),%xmm2
movsd  (%r12,%rbp,8),%xmm3
movhpd -0x8(%rax,%rbp,8),%xmm2
movsd  -0x8(%rdi,%rbp,8),%xmm4
movsd  (%rdi,%rbp,8),%xmm1
movhpd -0x8(%rsi,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%rax,%rbp,8),%xmm3
movhpd (%rsi,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm0
cmp    %rbp,%r13
jne    1dd0 <newviewAscCat+0xca0>
mov    %r11,%r9
imul   0x98(%rsp),%r9
test   $0x1,%r15b
je     1e7d <newviewAscCat+0xd4d>
lea    (%r9,%rbp,1),%r8
mov    0x80(%rsp),%rdx
movsd  (%rdx,%rbp,8),%xmm0
mov    %r11,%rdx
mov    0x88(%rsp),%r11
movhpd (%r11,%rbp,8),%xmm0
mov    %rdx,%r11
mov    0x138(%rsp),%rbp
movsd  0x0(%rbp,%r8,8),%xmm2
mov    0x130(%rsp),%rbp
movhpd 0x0(%rbp,%r8,8),%xmm2
mov    0x10(%rsp),%r8
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmpl   $0x4,0x140(%rsp)
04
jb     1eb4 <newviewAscCat+0xd84>
lea    (%r9,%r15,1),%rdx
lea    (%r8,%rdx,8),%rdx
cmp    %rdx,(%rsp)
jae    1f40 <newviewAscCat+0xe10>
lea    (%r8,%r9,8),%rdx
cmp    0x78(%rsp),%rdx
jae    1f40 <newviewAscCat+0xe10>
xor    %ebp,%ebp
mov    %rbp,%rdx
test   $0x1,%r15b
je     1ee1 <newviewAscCat+0xdb1>
add    %rbp,%r9
movsd  (%r8,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
mov    (%rsp),%rdx
addsd  (%rdx,%rbp,8),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
mov    %rbp,%rdx
or     $0x1,%rdx
not    %rbp
cmp    0x90(%rsp),%rbp
je     1d90 <newviewAscCat+0xc60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r15
jne    1f00 <newviewAscCat+0xdd0>
jmp    1d90 <newviewAscCat+0xc60>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x28(%rsp)
je     2033 <newviewAscCat+0xf03>
mov    0x20(%rsp),%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r10,%rbp,8),%xmm2
movupd -0x20(%r10,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r14,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r14,%rbp,8),%xmm2
movupd -0x10(%r14,%rbp,8),%xmm5
movupd (%r14,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r14,%rbp,8)
movupd %xmm3,-0x20(%r14,%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,-0x10(%r14,%rbp,8)
movupd %xmm3,(%r14,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1f60 <newviewAscCat+0xe30>
testb  $0x1,0x8(%rsp)
je     201d <newviewAscCat+0xeed>
lea    (%r9,%rbp,1),%rdx
movupd (%r8,%rdx,8),%xmm2
movupd 0x10(%r8,%rdx,8),%xmm3
mov    (%rsp),%rdx
movupd (%rdx,%rbp,8),%xmm4
movupd 0x10(%rdx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rbp,8)
movupd %xmm3,0x10(%rdx,%rbp,8)
mov    0x50(%rsp),%rdx
mov    %rdx,%rbp
cmp    %r15,%rdx
je     1d90 <newviewAscCat+0xc60>
jmp    1eb6 <newviewAscCat+0xd86>
xor    %ebp,%ebp
testb  $0x1,0x8(%rsp)
jne    1fe2 <newviewAscCat+0xeb2>
jmp    201d <newviewAscCat+0xeed>
xchg   %ax,%ax
cmpl   $0x0,0x140(%rsp)
mov    0x98(%rsp),%r11
movsd  0xfa8(%rip),%xmm1
movsd  0xfa8(%rip),%xmm2
movsd  0xfa8(%rip),%xmm4
movapd 0xfb0(%rip),%xmm5
mov    0x70(%rsp),%rsi
mov    0x68(%rsp),%rdi
jle    1cb0 <newviewAscCat+0xb80>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rdi,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
seta   %dl
ucomisd %xmm2,%xmm0
seta   %cl
and    %dl,%cl
cmp    $0x1,%cl
jne    20b7 <newviewAscCat+0xf87>
lea    0x1(%rax),%rdx
cmp    %r11,%rax
mov    %rdx,%rax
jl     2090 <newviewAscCat+0xf60>
test   %cl,%cl
je     1cbc <newviewAscCat+0xb8c>
cmpl   $0x0,0x140(%rsp)
jle    1cb0 <newviewAscCat+0xb80>
cmpl   $0x4,0x140(%rsp)
04
jae    20de <newviewAscCat+0xfae>
xor    %eax,%eax
jmp    2190 <newviewAscCat+0x1060>
cmpq   $0x0,0x28(%rsp)
je     21ac <newviewAscCat+0x107c>
mov    0x20(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r14,%rax,8),%xmm0
movupd -0x20(%r14,%rax,8),%xmm1
movupd -0x10(%r14,%rax,8),%xmm2
movupd (%r14,%rax,8),%xmm3
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,-0x30(%r14,%rax,8)
movupd %xmm1,-0x20(%r14,%rax,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%r14,%rax,8)
movupd %xmm3,(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2100 <newviewAscCat+0xfd0>
testb  $0x1,0x8(%rsp)
je     2179 <newviewAscCat+0x1049>
mov    (%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x50(%rsp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
je     1cb0 <newviewAscCat+0xb80>
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    2190 <newviewAscCat+0x1060>
jmp    1cb0 <newviewAscCat+0xb80>
xor    %eax,%eax
testb  $0x1,0x8(%rsp)
jne    2157 <newviewAscCat+0x1027>
jmp    2179 <newviewAscCat+0x1049>
xor    %edi,%edi
call   1040 <assert@plt>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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