#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 newviewAscGamma(int tipCase, double *x1, double *x2, double *x3,
                     double *extEV, double *tipVector, int *ex3, const int n,
                     double *left, double *right, const int numStates) {
  int i, j, l, k, scale;
  const int statesSquare = numStates * numStates, gammaStates = 4 * numStates;
  double *vl, *vr, al, ar, *v, x1px2;
  unsigned char tip[32];
  ascertainmentBiasSequence(tip, numStates);
  switch (tipCase) {
  case 0: {
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(tipVector[numStates * tip[i]]);
        vr = &(tipVector[numStates * tip[i]]);
        v = &(x3[gammaStates * i + numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
    }
  } break;
  case 1: {
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(tipVector[numStates * tip[i]]);
        vr = &(x2[gammaStates * i + numStates * k]);
        v = &(x3[gammaStates * i + numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
      v = &x3[gammaStates * i];
      scale = 1;
      for (l = 0; scale && (l < gammaStates); l++)
        scale =
            ((((v[l]) < 0) ? (-(v[l])) : (v[l])) <
             (1.0 /
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
      if (scale) {
        for (l = 0; l < gammaStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
        ex3[i] += 1;
      }
    }
  } break;
  case 2:
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(x1[gammaStates * i + numStates * k]);
        vr = &(x2[gammaStates * i + numStates * k]);
        v = &(x3[gammaStates * i + numStates * k]);
        for (l = 0; l < numStates; l++)
          v[l] = 0;
        for (l = 0; l < numStates; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < numStates; j++) {
            al += vl[j] * left[k * statesSquare + l * numStates + j];
            ar += vr[j] * right[k * statesSquare + l * numStates + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < numStates; j++)
            v[j] += x1px2 * extEV[numStates * l + j];
        }
      }
      v = &(x3[gammaStates * i]);
      scale = 1;
      for (l = 0; scale && (l < gammaStates); l++)
        scale = ((
            (((v[l]) < 0) ? (-(v[l])) : (v[l])) <
            (1.0 /
             115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      if (scale) {
        for (l = 0; l < gammaStates; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
        ex3[i] += 1;
      }
    }
    break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<newviewAscGamma>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%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),%eax
imul   %eax,%eax
mov    %eax,-0x48(%rbp)
mov    0x30(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x4c(%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     11b3 <newviewAscGamma+0x93>
jmp    118b <newviewAscGamma+0x6b>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
je     13d5 <newviewAscGamma+0x2b5>
jmp    119f <newviewAscGamma+0x7f>
mov    -0xa4(%rbp),%eax
sub    $0x2,%eax
je     172f <newviewAscGamma+0x60f>
jmp    1a87 <newviewAscGamma+0x967>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13d0 <newviewAscGamma+0x2b0>
movl   $0x0,-0x40(%rbp)
cmpl   $0x4,-0x40(%rbp)
jge    13bd <newviewAscGamma+0x29d>
mov    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x34(%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    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x34(%rbp),%rdx
movzbl -0xa0(%rbp,%rdx,1),%edx
ff
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1272 <newviewAscGamma+0x152>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1248 <newviewAscGamma+0x128>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    13aa <newviewAscGamma+0x28a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1332 <newviewAscGamma+0x212>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    129c <newviewAscGamma+0x17c>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1397 <newviewAscGamma+0x277>
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1348 <newviewAscGamma+0x228>
jmp    139c <newviewAscGamma+0x27c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1279 <newviewAscGamma+0x159>
jmp    13af <newviewAscGamma+0x28f>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11cd <newviewAscGamma+0xad>
jmp    13c2 <newviewAscGamma+0x2a2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ba <newviewAscGamma+0x9a>
jmp    1a8e <newviewAscGamma+0x96e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    172a <newviewAscGamma+0x60a>
movl   $0x0,-0x40(%rbp)
cmpl   $0x4,-0x40(%rbp)
jge    15dd <newviewAscGamma+0x4bd>
mov    -0x30(%rbp),%rax
mov    0x30(%rbp),%ecx
movslq -0x34(%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    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1492 <newviewAscGamma+0x372>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1468 <newviewAscGamma+0x348>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    15ca <newviewAscGamma+0x4aa>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1552 <newviewAscGamma+0x432>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14bc <newviewAscGamma+0x39c>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    15b7 <newviewAscGamma+0x497>
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1568 <newviewAscGamma+0x448>
jmp    15bc <newviewAscGamma+0x49c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1499 <newviewAscGamma+0x379>
jmp    15cf <newviewAscGamma+0x4af>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13ef <newviewAscGamma+0x2cf>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44(%rbp)
mov    %al,-0xa5(%rbp)
je     1625 <newviewAscGamma+0x505>
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
setl   %al
mov    %al,-0xa5(%rbp)
mov    -0xa5(%rbp),%al
test   $0x1,%al
jne    1638 <newviewAscGamma+0x518>
jmp    16c1 <newviewAscGamma+0x5a1>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    167f <newviewAscGamma+0x55f>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1694 <newviewAscGamma+0x574>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  0x964(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1604 <newviewAscGamma+0x4e4>
cmpl   $0x0,-0x44(%rbp)
je     1717 <newviewAscGamma+0x5f7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1706 <newviewAscGamma+0x5e6>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x912(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16d2 <newviewAscGamma+0x5b2>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    171c <newviewAscGamma+0x5fc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13dc <newviewAscGamma+0x2bc>
jmp    1a8e <newviewAscGamma+0x96e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1a82 <newviewAscGamma+0x962>
movl   $0x0,-0x40(%rbp)
cmpl   $0x4,-0x40(%rbp)
jge    1935 <newviewAscGamma+0x815>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    17ea <newviewAscGamma+0x6ca>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17c0 <newviewAscGamma+0x6a0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1922 <newviewAscGamma+0x802>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    18aa <newviewAscGamma+0x78a>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x48(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   0x30(%rbp),%edx
add    %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1814 <newviewAscGamma+0x6f4>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    190f <newviewAscGamma+0x7ef>
movsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18c0 <newviewAscGamma+0x7a0>
jmp    1914 <newviewAscGamma+0x7f4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17f1 <newviewAscGamma+0x6d1>
jmp    1927 <newviewAscGamma+0x807>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1749 <newviewAscGamma+0x629>
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44(%rbp)
mov    %al,-0xb1(%rbp)
je     197d <newviewAscGamma+0x85d>
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
setl   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    1990 <newviewAscGamma+0x870>
jmp    1a19 <newviewAscGamma+0x8f9>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    19d7 <newviewAscGamma+0x8b7>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    19ec <newviewAscGamma+0x8cc>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  0x60c(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    195c <newviewAscGamma+0x83c>
cmpl   $0x0,-0x44(%rbp)
je     1a6f <newviewAscGamma+0x94f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a5e <newviewAscGamma+0x93e>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x5ba(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a2a <newviewAscGamma+0x90a>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1a74 <newviewAscGamma+0x954>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1736 <newviewAscGamma+0x616>
jmp    1a8e <newviewAscGamma+0x96e>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newviewAscGamma>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,0x18(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x98(%rsp)
mov    %rsi,0x80(%rsp)
mov    %edi,%r14d
mov    0x1e0(%rsp),%ebx
mov    0x1c8(%rsp),%r15d
mov    %ebx,%ebp
imul   %ebx,%ebp
lea    0x0(,%rbx,4),%eax
mov    %eax,0xc(%rsp)
lea    0x160(%rsp),%rdi
mov    %ebx,%esi
call   1050 <ascertainmentBiasSequence@plt>
movslq %ebx,%rax
mov    %rax,0x10(%rsp)
test   %r14d,%r14d
je     1985 <newviewAscGamma+0x855>
cmp    $0x1,%r14d
je     1f15 <newviewAscGamma+0xde5>
cmp    $0x2,%r14d
jne    2705 <newviewAscGamma+0x15d5>
test   %r15d,%r15d
mov    0x18(%rsp),%rax
jle    270c <newviewAscGamma+0x15dc>
mov    0x10(%rsp),%rsi
mov    %esi,%r14d
mov    0xc(%rsp),%ecx
movslq %ecx,%rdi
cmp    $0x2,%edi
mov    $0x1,%edx
cmovge %ecx,%edx
mov    %ebp,%ecx
mov    %rcx,0xe0(%rsp)
mov    %r15d,%ecx
mov    %rcx,0x120(%rsp)
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xf8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xf0(%rsp)
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rdx,0x30(%rsp)
and    $0x7ffffffc,%edx
mov    %rdx,0x140(%rsp)
lea    -0x4(%rdx),%rcx
mov    %rcx,0x138(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r14d,%r12d
and    $0xfffffffe,%r12d
mov    %rbp,%rcx
mov    %rbp,0xe8(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x78(%rsp)
mov    %r14,%rcx
neg    %rcx
mov    %rcx,0x118(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x130(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x128(%rsp)
lea    0x0(,%r14,8),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%r14,8),%rdx
mov    %rdx,0xd0(%rsp)
mov    0x80(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0x40(%rsp)
mov    %rdi,0x38(%rsp)
lea    0x0(,%rdi,8),%rdx
mov    %rdx,0x148(%rsp)
mov    0x1d8(%rsp),%rdx
lea    0x8(%rdx),%rdx
mov    %rdx,0xc8(%rsp)
lea    0x0(,%rsi,8),%rdx
mov    %rdx,0x28(%rsp)
mov    0x1d0(%rsp),%rdx
lea    0x8(%rdx),%rdx
mov    %rdx,0xc0(%rsp)
mov    0x98(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0x70(%rsp)
lea    0x30(%rax),%rdx
mov    %rdx,0xb8(%rsp)
lea    0x30(%rcx),%rdx
add    $0x8,%rax
mov    %rax,0xb0(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0x68(%rsp)
xor    %esi,%esi
mov    %rcx,0x20(%rsp)
jmp    1387 <newviewAscGamma+0x257>
nopl   (%rax)
mov    0x1c0(%rsp),%rax
mov    0x60(%rsp),%rsi
addl   $0x1,(%rax,%rsi,4)
add    $0x1,%rsi
mov    0x148(%rsp),%rax
add    %rax,0x40(%rsp)
add    %rax,0x70(%rsp)
mov    0x50(%rsp),%rdx
add    %rax,%rdx
add    %rax,0x68(%rsp)
add    %rax,0x20(%rsp)
cmp    0x120(%rsp),%rsi
je     270c <newviewAscGamma+0x15dc>
mov    %rdx,0x50(%rsp)
mov    0xc(%rsp),%eax
imul   %esi,%eax
mov    %eax,0x88(%rsp)
mov    %rsi,0x60(%rsp)
imul   0x38(%rsp),%rsi
mov    %rsi,0x90(%rsp)
xor    %ebx,%ebx
jmp    13d6 <newviewAscGamma+0x2a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rbx
add    $0x1,%rbx
cmp    $0x4,%rbx
je     17f0 <newviewAscGamma+0x6c0>
mov    0x1e0(%rsp),%edx
test   %edx,%edx
jle    17d0 <newviewAscGamma+0x6a0>
mov    %rbx,%r13
imul   0x10(%rsp),%r13
mov    0x90(%rsp),%rax
lea    (%rax,%r13,1),%rbp
mov    0x80(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x110(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0xa8(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%rbp,8),%rax
mov    %rax,0x58(%rsp)
mov    %ebx,%eax
imul   %edx,%eax
add    0x88(%rsp),%eax
cltq
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0xd8(%rsp),%rdx
call   1030 <memset@plt>
movapd 0x1bb7(%rip),%xmm7
mov    %rbx,0xa0(%rsp)
imul   0xe0(%rsp),%rbx
mov    0xd0(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x100(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%r13,8),%r15
mov    0xc8(%rsp),%rax
lea    (%rax,%rbx,8),%rsi
mov    0xc0(%rsp),%rax
mov    %rbx,0x108(%rsp)
lea    (%rax,%rbx,8),%rdi
mov    0x70(%rsp),%rax
lea    (%rax,%r13,8),%r8
mov    0x50(%rsp),%rax
lea    (%rax,%r13,8),%rax
mov    0x68(%rsp),%rdx
lea    (%rdx,%r13,8),%rbx
mov    0xb0(%rsp),%rbp
mov    0xb8(%rsp),%r10
xor    %r13d,%r13d
jmp    14fe <newviewAscGamma+0x3ce>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x28(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%rdi
add    %rdx,%r10
add    %rdx,%rbp
cmp    %r14,%r13
je     13c0 <newviewAscGamma+0x290>
mov    0x1e0(%rsp),%edx
cmp    $0x1,%edx
jne    1520 <newviewAscGamma+0x3f0>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    157d <newviewAscGamma+0x44d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r8,%rdx,8),%xmm2
movsd  (%r8,%rdx,8),%xmm3
movhpd -0x8(%r15,%rdx,8),%xmm2
movsd  -0x8(%rsi,%rdx,8),%xmm4
movsd  (%rsi,%rdx,8),%xmm1
movhpd -0x8(%rdi,%rdx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r15,%rdx,8),%xmm3
movhpd (%rdi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdx
movapd %xmm1,%xmm0
cmp    %rdx,%r12
jne    1530 <newviewAscGamma+0x400>
mov    %r13,%r11
imul   0x10(%rsp),%r11
test   $0x1,%r14b
je     15e1 <newviewAscGamma+0x4b1>
mov    0x108(%rsp),%rcx
lea    (%r11,%rcx,1),%r9
add    %rdx,%r9
mov    %r13,%rcx
mov    0xa8(%rsp),%r13
movsd  0x0(%r13,%rdx,8),%xmm0
mov    %rcx,%r13
mov    0x110(%rsp),%rcx
movhpd (%rcx,%rdx,8),%xmm0
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm2
mov    0x1d0(%rsp),%rdx
movhpd (%rdx,%r9,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
mov    0x1e0(%rsp),%edx
cmp    $0x4,%edx
jb     1623 <newviewAscGamma+0x4f3>
lea    (%r11,%r14,1),%rdx
mov    0x18(%rsp),%r9
lea    (%r9,%rdx,8),%rdx
cmp    %rdx,0x58(%rsp)
jae    16b0 <newviewAscGamma+0x580>
lea    (%r9,%r11,8),%rdx
cmp    0x100(%rsp),%rdx
jae    16b0 <newviewAscGamma+0x580>
xor    %r9d,%r9d
mov    %r9,%rdx
test   $0x1,%r14b
je     1659 <newviewAscGamma+0x529>
add    %r9,%r11
mov    0x18(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x58(%rsp),%rcx
addsd  (%rcx,%r9,8),%xmm1
movsd  %xmm1,(%rcx,%r9,8)
mov    %r9,%rdx
or     $0x1,%rdx
not    %r9
cmp    0x118(%rsp),%r9
je     14e0 <newviewAscGamma+0x3b0>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r14
jne    1670 <newviewAscGamma+0x540>
jmp    14e0 <newviewAscGamma+0x3b0>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf0(%rsp)
je     17ba <newviewAscGamma+0x68a>
mov    0x78(%rsp),%rdx
xor    %r9d,%r9d
nop
movupd -0x30(%r10,%r9,8),%xmm2
movupd -0x20(%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rax,%r9,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rax,%r9,8),%xmm2
movupd -0x10(%rax,%r9,8),%xmm5
movupd (%rax,%r9,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rax,%r9,8)
movupd %xmm3,-0x20(%rax,%r9,8)
movupd -0x10(%r10,%r9,8),%xmm2
movupd (%r10,%r9,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rax,%r9,8)
movupd %xmm3,(%rax,%r9,8)
add    $0x8,%r9
add    $0xfffffffffffffffe,%rdx
jne    16d0 <newviewAscGamma+0x5a0>
testb  $0x1,0xe8(%rsp)
01
je     17a1 <newviewAscGamma+0x671>
lea    (%r9,%r11,1),%rdx
mov    %r13,%rcx
mov    0x18(%rsp),%r13
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
mov    %rcx,%r13
mov    0x58(%rsp),%rcx
movupd (%rcx,%r9,8),%xmm4
movupd 0x10(%rcx,%r9,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%r9,8)
movupd %xmm3,0x10(%rcx,%r9,8)
mov    0xf8(%rsp),%rdx
mov    %rdx,%r9
cmp    %r14,%rdx
je     14e0 <newviewAscGamma+0x3b0>
jmp    1626 <newviewAscGamma+0x4f6>
xor    %r9d,%r9d
testb  $0x1,0xe8(%rsp)
01
jne    1755 <newviewAscGamma+0x625>
jmp    17a1 <newviewAscGamma+0x671>
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    $0x4,%rbx
jne    13d6 <newviewAscGamma+0x2a6>
jmp    1340 <newviewAscGamma+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1e0(%rsp),%eax
test   %eax,%eax
jle    1340 <newviewAscGamma+0x210>
mov    0x48(%rsp),%rax
mov    0x90(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rdx
movsd  -0x8(%rdx,%rcx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0x17c9(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0x17ec(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0x17c8(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    186c <newviewAscGamma+0x73c>
lea    0x1(%rcx),%rdx
cmp    0x38(%rsp),%rcx
mov    %rdx,%rcx
jl     1820 <newviewAscGamma+0x6f0>
movsd  0x17ac(%rip),%xmm1
ucomisd %xmm0,%xmm1
mov    0x60(%rsp),%rsi
jbe    1351 <newviewAscGamma+0x221>
mov    0x1e0(%rsp),%ecx
test   %ecx,%ecx
jle    1340 <newviewAscGamma+0x210>
cmpl   $0x4,0x30(%rsp)
jae    18a0 <newviewAscGamma+0x770>
xor    %eax,%eax
jmp    1950 <newviewAscGamma+0x820>
cmpq   $0x0,0x138(%rsp)
je     1977 <newviewAscGamma+0x847>
mov    0x128(%rsp),%rdx
xor    %ecx,%ecx
mov    0x50(%rsp),%rsi
xchg   %ax,%ax
movupd -0x30(%rsi,%rcx,8),%xmm0
movupd -0x20(%rsi,%rcx,8),%xmm1
movupd -0x10(%rsi,%rcx,8),%xmm2
movupd (%rsi,%rcx,8),%xmm3
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,-0x30(%rsi,%rcx,8)
movupd %xmm1,-0x20(%rsi,%rcx,8)
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
movupd %xmm2,-0x10(%rsi,%rcx,8)
movupd %xmm3,(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    18c0 <newviewAscGamma+0x790>
testb  $0x1,0x130(%rsp)
01
je     1930 <newviewAscGamma+0x800>
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rax,%rcx,8)
movupd %xmm1,0x10(%rax,%rcx,8)
mov    0x140(%rsp),%rcx
mov    %rcx,%rax
cmp    0x30(%rsp),%rcx
je     1340 <newviewAscGamma+0x210>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x16c6(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,0x30(%rsp)
jne    1950 <newviewAscGamma+0x820>
jmp    1340 <newviewAscGamma+0x210>
xor    %ecx,%ecx
testb  $0x1,0x130(%rsp)
01
jne    1912 <newviewAscGamma+0x7e2>
jmp    1930 <newviewAscGamma+0x800>
test   %r15d,%r15d
mov    0x18(%rsp),%rax
jle    270c <newviewAscGamma+0x15dc>
mov    0x1e0(%rsp),%ecx
mov    %ecx,%ebx
lea    0x0(,%rbx,8),%rcx
mov    %rcx,0x68(%rsp)
mov    %ebp,%edx
movslq 0xc(%rsp),%rsi
mov    %r15d,%ecx
mov    %rcx,0xb8(%rsp)
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x100(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %ebx,%r12d
and    $0xfffffffe,%r12d
mov    %rdi,%rcx
mov    %rdi,0xf0(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xe8(%rsp)
mov    %rbx,%rcx
neg    %rcx
mov    %rcx,0x118(%rsp)
mov    0x30(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0xb0(%rsp)
mov    0x1d8(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0x20(%rsp)
mov    %rdx,0x88(%rsp)
lea    0x0(,%rdx,8),%rcx
mov    %rcx,0x98(%rsp)
mov    0x10(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x58(%rsp)
mov    0x1d0(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0x38(%rsp)
lea    0x30(%rax),%rcx
mov    %rcx,0x80(%rsp)
mov    0x48(%rsp),%rcx
lea    0x30(%rcx),%r13
mov    %rsi,0xc0(%rsp)
lea    0x0(,%rsi,8),%rdx
mov    %rdx,0x60(%rsp)
add    $0x8,%rax
mov    %rax,0xe0(%rsp)
lea    0x8(%rcx),%r14
xor    %ecx,%ecx
jmp    1ae5 <newviewAscGamma+0x9b5>
cs nopw 0x0(%rax,%rax,1)
mov    0xc8(%rsp),%rcx
add    $0x1,%rcx
mov    0xd8(%rsp),%r13
mov    0x60(%rsp),%rax
add    %rax,%r13
mov    0xd0(%rsp),%r14
add    %rax,%r14
cmp    0xb8(%rsp),%rcx
je     270c <newviewAscGamma+0x15dc>
mov    %rcx,%rax
imul   0xc0(%rsp),%rax
mov    %rax,0x90(%rsp)
add    %rbx,%rax
mov    %rax,0x40(%rsp)
mov    0xc(%rsp),%eax
imul   %ecx,%eax
mov    %eax,0x70(%rsp)
mov    %rcx,0xc8(%rsp)
movzbl 0x160(%rsp,%rcx,1),%eax
imul   0x10(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0xa8(%rsp)
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
mov    %r14,0xd0(%rsp)
mov    %r13,0xd8(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,0x50(%rsp)
xor    %eax,%eax
mov    %rax,0x78(%rsp)
jmp    1bab <newviewAscGamma+0xa7b>
nop
mov    0x78(%rsp),%rcx
add    $0x1,%rcx
mov    0x98(%rsp),%rax
add    %rax,0x50(%rsp)
add    %rax,0xa0(%rsp)
mov    0x58(%rsp),%rax
add    %rax,%r13
add    %rax,%r14
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
cmp    $0x4,%rcx
je     1ab0 <newviewAscGamma+0x980>
mov    0x1e0(%rsp),%eax
test   %eax,%eax
jle    1b70 <newviewAscGamma+0xa40>
mov    0x78(%rsp),%rbp
mov    %rbp,%rax
imul   0x10(%rsp),%rax
mov    0x90(%rsp),%rcx
add    %rax,%rcx
add    0x40(%rsp),%rax
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x28(%rsp)
lea    (%rdx,%rax,8),%rax
mov    %rax,0x108(%rsp)
mov    %ebp,%eax
mov    0x1e0(%rsp),%ecx
imul   %ecx,%eax
add    0x70(%rsp),%eax
cltq
lea    (%rdx,%rax,8),%rdi
xor    %esi,%esi
mov    0x68(%rsp),%rdx
call   1030 <memset@plt>
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%r11
imul   0x88(%rsp),%rbp
mov    %rbp,0x110(%rsp)
mov    0xe0(%rsp),%rcx
mov    0x80(%rsp),%rdx
mov    0xa0(%rsp),%rsi
mov    0x50(%rsp),%rdi
xor    %r9d,%r9d
jmp    1c6e <newviewAscGamma+0xb3e>
nopl   (%rax)
add    $0x1,%r9
mov    0x58(%rsp),%rax
add    %rax,%rdi
add    %rax,%rsi
add    %rax,%rdx
add    %rax,%rcx
cmp    %rbx,%r9
je     1b70 <newviewAscGamma+0xa40>
mov    0x1e0(%rsp),%eax
cmp    $0x1,%eax
jne    1c90 <newviewAscGamma+0xb60>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    1ce8 <newviewAscGamma+0xbb8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rax,8),%xmm2
movsd  (%r15,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
movsd  -0x8(%rdi,%rax,8),%xmm4
movsd  (%rdi,%rax,8),%xmm1
movhpd -0x8(%rsi,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
unpcklpd %xmm3,%xmm3
movhpd (%rsi,%rax,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rax
movapd %xmm1,%xmm0
cmp    %rax,%r12
jne    1ca0 <newviewAscGamma+0xb70>
mov    %r9,%r10
imul   0x10(%rsp),%r10
test   $0x1,%bl
je     1d4e <newviewAscGamma+0xc1e>
mov    0x110(%rsp),%rbp
add    %r10,%rbp
add    %rax,%rbp
mov    %r9,0x28(%rsp)
mov    %r11,%r9
mov    %r8,%r11
mov    0xa8(%rsp),%r8
movsd  (%r8,%rax,8),%xmm0
mov    %r11,%r8
mov    %r9,%r11
mov    0x28(%rsp),%r9
unpcklpd %xmm0,%xmm0
mov    0x1d8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm2
mov    0x1d0(%rsp),%rax
movhpd (%rax,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
mov    0x1e0(%rsp),%eax
cmp    $0x4,%eax
jb     1d85 <newviewAscGamma+0xc55>
lea    (%r10,%rbx,1),%rax
lea    (%r11,%rax,8),%rax
cmp    %rax,%r8
jae    1e00 <newviewAscGamma+0xcd0>
lea    (%r11,%r10,8),%rax
cmp    0x108(%rsp),%rax
jae    1e00 <newviewAscGamma+0xcd0>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%bl
je     1daf <newviewAscGamma+0xc7f>
add    %rbp,%r10
movsd  (%r11,%r10,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r8,%rbp,8),%xmm1
movsd  %xmm1,(%r8,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x118(%rsp),%rbp
je     1c50 <newviewAscGamma+0xb20>
movsd  -0x8(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rax,8)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1dc0 <newviewAscGamma+0xc90>
jmp    1c50 <newviewAscGamma+0xb20>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf8(%rsp)
je     1f07 <newviewAscGamma+0xdd7>
mov    0xe8(%rsp),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rax,8),%xmm2
movupd -0x20(%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r13,%rax,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r13,%rax,8),%xmm2
movupd -0x10(%r13,%rax,8),%xmm5
movupd 0x0(%r13,%rax,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r13,%rax,8)
movupd %xmm3,-0x20(%r13,%rax,8)
movupd -0x10(%rdx,%rax,8),%xmm2
movupd (%rdx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r13,%rax,8)
movupd %xmm3,0x0(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1e30 <newviewAscGamma+0xd00>
testb  $0x1,0xf0(%rsp)
01
je     1eee <newviewAscGamma+0xdbe>
lea    (%rax,%r10,1),%rbp
movupd (%r11,%rbp,8),%xmm2
movupd 0x10(%r11,%rbp,8),%xmm3
movupd (%r8,%rax,8),%xmm4
movupd 0x10(%r8,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%rax,8)
movupd %xmm3,0x10(%r8,%rax,8)
mov    0x100(%rsp),%rax
mov    %rax,%rbp
cmp    %rbx,%rax
je     1c50 <newviewAscGamma+0xb20>
jmp    1d87 <newviewAscGamma+0xc57>
xor    %eax,%eax
testb  $0x1,0xf0(%rsp)
01
jne    1eb3 <newviewAscGamma+0xd83>
jmp    1eee <newviewAscGamma+0xdbe>
test   %r15d,%r15d
mov    0x18(%rsp),%rax
jle    270c <newviewAscGamma+0x15dc>
mov    0x1e0(%rsp),%ecx
mov    %ecx,%r13d
lea    0x0(,%r13,8),%rcx
mov    %rcx,0xe0(%rsp)
mov    0xc(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%edx
cmovge %ecx,%edx
mov    %ebp,%esi
mov    %rsi,0xd8(%rsp)
mov    %r15d,%esi
mov    %rsi,0x148(%rsp)
mov    %r13d,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xe8(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x78(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rdx,0x38(%rsp)
and    $0x7ffffffc,%edx
mov    %rdx,0x130(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0x128(%rsp)
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %r13d,%r10d
and    $0xfffffffe,%r10d
mov    %rsi,%rdx
mov    %rsi,0xa0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x50(%rsp)
mov    %r13,%rdx
neg    %rdx
mov    %rdx,0x110(%rsp)
mov    %rdi,%rdx
mov    %rdi,0x158(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x150(%rsp)
movslq %ecx,%rsi
mov    0x48(%rsp),%rcx
lea    (%rcx,%r13,8),%rdx
mov    %rdx,0xd0(%rsp)
mov    0x30(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0x140(%rsp)
mov    0x1d8(%rsp),%rdx
lea    0x8(%rdx),%rdx
mov    %rdx,0xc8(%rsp)
mov    0x10(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
mov    %rdx,0x118(%rsp)
mov    0x1d0(%rsp),%rdx
lea    0x8(%rdx),%rdx
mov    %rdx,0xc0(%rsp)
mov    0x98(%rsp),%rdx
lea    0x8(%rdx),%rdx
mov    %rdx,0x68(%rsp)
lea    0x0(,%rsi,8),%rdx
mov    %rdx,0x138(%rsp)
lea    0x30(%rax),%rdx
mov    %rdx,0xb8(%rsp)
lea    0x30(%rcx),%rdx
add    $0x8,%rax
mov    %rax,0xb0(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0x88(%rsp)
xor    %edi,%edi
mov    %rcx,%rbp
mov    %rsi,0x120(%rsp)
mov    %r10,0xa8(%rsp)
jmp    2100 <newviewAscGamma+0xfd0>
nopl   0x0(%rax)
mov    0x1c0(%rsp),%rax
mov    0x60(%rsp),%rdi
addl   $0x1,(%rax,%rdi,4)
mov    0x120(%rsp),%rsi
mov    0x20(%rsp),%rbp
add    $0x1,%rdi
mov    0x138(%rsp),%rax
add    %rax,0x68(%rsp)
mov    0x40(%rsp),%rdx
add    %rax,%rdx
add    %rax,0x88(%rsp)
add    %rax,%rbp
cmp    0x148(%rsp),%rdi
je     270c <newviewAscGamma+0x15dc>
mov    %rbp,0x20(%rsp)
mov    %rdx,0x40(%rsp)
mov    0xc(%rsp),%eax
imul   %edi,%eax
mov    %eax,0x80(%rsp)
movzbl 0x160(%rsp,%rdi,1),%eax
imul   0x10(%rsp),%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0xf8(%rsp)
mov    %rdi,0x60(%rsp)
imul   %rsi,%rdi
mov    %rdi,0x70(%rsp)
mov    0x140(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
xor    %ebp,%ebp
mov    0x1e0(%rsp),%r14d
jmp    2176 <newviewAscGamma+0x1046>
nopl   (%rax)
mov    0x90(%rsp),%rbp
add    $0x1,%rbp
cmp    $0x4,%rbp
je     2570 <newviewAscGamma+0x1440>
test   %r14d,%r14d
jle    2550 <newviewAscGamma+0x1420>
mov    %rbp,%rbx
imul   0x10(%rsp),%rbx
mov    0x70(%rsp),%rax
lea    (%rbx,%rax,1),%r12
mov    0x98(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0x108(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rcx,%r12,8),%rax
mov    %rax,0x28(%rsp)
mov    %ebp,%eax
imul   %r14d,%eax
add    0x80(%rsp),%eax
cltq
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0xe0(%rsp),%rdx
call   1030 <memset@plt>
mov    0xa8(%rsp),%r10
movapd 0xe2b(%rip),%xmm7
mov    %rbp,0x90(%rsp)
imul   0xd8(%rsp),%rbp
mov    0xd0(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0xf0(%rsp)
mov    0xc8(%rsp),%rax
lea    (%rax,%rbp,8),%rdx
mov    0xc0(%rsp),%rax
mov    %rbp,0x100(%rsp)
lea    (%rax,%rbp,8),%rsi
mov    0x68(%rsp),%rax
lea    (%rax,%rbx,8),%r12
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,8),%rcx
mov    0x88(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0xb0(%rsp),%rbx
mov    0xb8(%rsp),%r9
xor    %r11d,%r11d
jmp    2286 <newviewAscGamma+0x1156>
nopl   (%rax)
mov    0x58(%rsp),%r11
add    $0x1,%r11
mov    0x118(%rsp),%rbp
add    %rbp,%rdx
add    %rbp,%rsi
add    %rbp,%r9
add    %rbp,%rbx
cmp    %r13,%r11
je     2160 <newviewAscGamma+0x1030>
cmp    $0x1,%r14d
jne    22a0 <newviewAscGamma+0x1170>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    22fd <newviewAscGamma+0x11cd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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(%r15,%rbp,8),%xmm2
movsd  -0x8(%rdx,%rbp,8),%xmm4
movsd  (%rdx,%rbp,8),%xmm1
movhpd -0x8(%rsi,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r15,%rbp,8),%xmm3
movhpd (%rsi,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbp
movapd %xmm1,%xmm0
cmp    %rbp,%r10
jne    22b0 <newviewAscGamma+0x1180>
mov    %r11,0x58(%rsp)
imul   0x10(%rsp),%r11
test   $0x1,%r13b
je     236c <newviewAscGamma+0x123c>
mov    0x100(%rsp),%rdi
lea    (%r11,%rdi,1),%r8
add    %rbp,%r8
mov    0x108(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm0
mov    %r14,%r10
mov    0xf8(%rsp),%r14
movhpd (%r14,%rbp,8),%xmm0
mov    %r10,%r14
mov    0xa8(%rsp),%r10
mov    0x1d8(%rsp),%rbp
movsd  0x0(%rbp,%r8,8),%xmm2
mov    0x1d0(%rsp),%rbp
movhpd 0x0(%rbp,%r8,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmp    $0x4,%r14d
jb     23a8 <newviewAscGamma+0x1278>
lea    (%r11,%r13,1),%rbp
mov    0x18(%rsp),%r8
lea    (%r8,%rbp,8),%rbp
cmp    %rbp,0x28(%rsp)
jae    2430 <newviewAscGamma+0x1300>
lea    (%r8,%r11,8),%rbp
cmp    0xf0(%rsp),%rbp
jae    2430 <newviewAscGamma+0x1300>
xor    %r8d,%r8d
mov    %r8,%rbp
test   $0x1,%r13b
je     23df <newviewAscGamma+0x12af>
add    %r8,%r11
mov    0x18(%rsp),%rbp
movsd  0x0(%rbp,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x28(%rsp),%rdi
addsd  (%rdi,%r8,8),%xmm1
movsd  %xmm1,(%rdi,%r8,8)
mov    %r8,%rbp
or     $0x1,%rbp
not    %r8
cmp    0x110(%rsp),%r8
je     2260 <newviewAscGamma+0x1130>
movsd  -0x8(%rbx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rax,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rax,%rbp,8)
movsd  (%rbx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r13
jne    23f0 <newviewAscGamma+0x12c0>
jmp    2260 <newviewAscGamma+0x1130>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x78(%rsp)
je     253b <newviewAscGamma+0x140b>
mov    0x50(%rsp),%rbp
xor    %r8d,%r8d
nopl   0x0(%rax)
movupd -0x30(%r9,%r8,8),%xmm2
movupd -0x20(%r9,%r8,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rcx,%r8,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rcx,%r8,8),%xmm2
movupd -0x10(%rcx,%r8,8),%xmm5
movupd (%rcx,%r8,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rcx,%r8,8)
movupd %xmm3,-0x20(%rcx,%r8,8)
movupd -0x10(%r9,%r8,8),%xmm2
movupd (%r9,%r8,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rcx,%r8,8)
movupd %xmm3,(%rcx,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%rbp
jne    2450 <newviewAscGamma+0x1320>
testb  $0x1,0xa0(%rsp)
01
je     2522 <newviewAscGamma+0x13f2>
lea    (%r8,%r11,1),%rbp
mov    0x18(%rsp),%r14
movupd (%r14,%rbp,8),%xmm2
movupd 0x10(%r14,%rbp,8),%xmm3
mov    0x1e0(%rsp),%r14d
mov    0x28(%rsp),%rdi
movupd (%rdi,%r8,8),%xmm4
movupd 0x10(%rdi,%r8,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdi,%r8,8)
movupd %xmm3,0x10(%rdi,%r8,8)
mov    0xe8(%rsp),%rbp
mov    %rbp,%r8
cmp    %r13,%rbp
je     2260 <newviewAscGamma+0x1130>
jmp    23ab <newviewAscGamma+0x127b>
xor    %r8d,%r8d
testb  $0x1,0xa0(%rsp)
01
jne    24d5 <newviewAscGamma+0x13a5>
jmp    2522 <newviewAscGamma+0x13f2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x4,%rbp
jne    2176 <newviewAscGamma+0x1046>
jmp    20b0 <newviewAscGamma+0xf80>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r14d,%r14d
jle    20b0 <newviewAscGamma+0xf80>
mov    0x48(%rsp),%rax
mov    0x70(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    $0x1,%ecx
mov    0x120(%rsp),%rsi
mov    0x20(%rsp),%rbp
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rcx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0xa4e(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0xa71(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0xa4d(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    25e5 <newviewAscGamma+0x14b5>
lea    0x1(%rcx),%rdx
cmp    %rsi,%rcx
mov    %rdx,%rcx
jl     25a0 <newviewAscGamma+0x1470>
movsd  0xa33(%rip),%xmm1
ucomisd %xmm0,%xmm1
mov    0x60(%rsp),%rdi
jbe    20ce <newviewAscGamma+0xf9e>
test   %r14d,%r14d
jle    20b0 <newviewAscGamma+0xf80>
cmpl   $0x4,0x38(%rsp)
jae    2613 <newviewAscGamma+0x14e3>
xor    %eax,%eax
jmp    26d0 <newviewAscGamma+0x15a0>
cmpq   $0x0,0x128(%rsp)
je     26f7 <newviewAscGamma+0x15c7>
mov    0x150(%rsp),%rdx
xor    %ecx,%ecx
mov    0x40(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rsi,%rcx,8),%xmm0
movupd -0x20(%rsi,%rcx,8),%xmm1
movupd -0x10(%rsi,%rcx,8),%xmm2
movupd (%rsi,%rcx,8),%xmm3
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,-0x30(%rsi,%rcx,8)
movupd %xmm1,-0x20(%rsi,%rcx,8)
mulpd  %xmm7,%xmm2
mulpd  %xmm7,%xmm3
movupd %xmm2,-0x10(%rsi,%rcx,8)
movupd %xmm3,(%rsi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2640 <newviewAscGamma+0x1510>
testb  $0x1,0x158(%rsp)
01
je     26b0 <newviewAscGamma+0x1580>
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
mulpd  %xmm7,%xmm0
mulpd  %xmm7,%xmm1
movupd %xmm0,(%rax,%rcx,8)
movupd %xmm1,0x10(%rax,%rcx,8)
mov    0x130(%rsp),%rcx
mov    %rcx,%rax
cmp    0x38(%rsp),%rcx
je     20b0 <newviewAscGamma+0xf80>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x946(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,0x38(%rsp)
jne    26d0 <newviewAscGamma+0x15a0>
jmp    20b0 <newviewAscGamma+0xf80>
xor    %ecx,%ecx
testb  $0x1,0x158(%rsp)
jne    2692 <newviewAscGamma+0x1562>
jmp    26b0 <newviewAscGamma+0x1580>
xor    %edi,%edi
call   1040 <assert@plt>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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