#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*/ assert(int /*<<< orphan*/);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
void newviewGAMMA_FLEX(int tipCase, double *x1, double *x2, double *x3,
                       double *extEV, double *tipVector, unsigned char *tipX1,
                       unsigned char *tipX2, int n, double *left, double *right,
                       int *wgt, int *scalerIncrement, const int states,
                       const int maxStateValue) {
  double *uX1, *uX2, *v, x1px2, *vl, *vr, al, ar;
  int i, j, l, k, scale, addScale = 0;
  const int statesSquare = states * states, span = states * 4,
            precomputeLength = maxStateValue * span;
  switch (tipCase) {
  case 0: {
    double *umpX1 = (double *)malloc(sizeof(double) * precomputeLength),
           *umpX2 = (double *)malloc(sizeof(double) * precomputeLength);
    for (i = 0; i < maxStateValue; i++) {
      v = &(tipVector[states * i]);
      for (k = 0; k < span; k++) {
        umpX1[span * i + k] = 0.0;
        umpX2[span * i + k] = 0.0;
        for (l = 0; l < states; l++) {
          umpX1[span * i + k] += v[l] * left[k * states + l];
          umpX2[span * i + k] += v[l] * right[k * states + l];
        }
      }
    }
    for (i = 0; i < n; i++) {
      uX1 = &umpX1[span * tipX1[i]];
      uX2 = &umpX2[span * tipX2[i]];
      for (j = 0; j < 4; j++) {
        v = &x3[i * span + j * states];
        for (k = 0; k < states; k++)
          v[k] = 0.0;
        for (k = 0; k < states; k++) {
          x1px2 = uX1[j * states + k] * uX2[j * states + k];
          for (l = 0; l < states; l++)
            v[l] += x1px2 * extEV[states * k + l];
        }
      }
    }
    free(umpX1);
    free(umpX2);
  } break;
  case 1: {
    double *umpX1 = (double *)malloc(sizeof(double) * precomputeLength),
           *ump_x2 = (double *)malloc(sizeof(double) * states);
    for (i = 0; i < maxStateValue; i++) {
      v = &(tipVector[states * i]);
      for (k = 0; k < span; k++) {
        umpX1[span * i + k] = 0.0;
        for (l = 0; l < states; l++)
          umpX1[span * i + k] += v[l] * left[k * states + l];
      }
    }
    for (i = 0; i < n; i++) {
      uX1 = &umpX1[span * tipX1[i]];
      for (k = 0; k < 4; k++) {
        v = &(x2[span * i + k * states]);
        for (l = 0; l < states; l++) {
          ump_x2[l] = 0.0;
          for (j = 0; j < states; j++)
            ump_x2[l] += v[j] * right[k * statesSquare + l * states + j];
        }
        v = &(x3[span * i + states * k]);
        for (l = 0; l < states; l++)
          v[l] = 0;
        for (l = 0; l < states; l++) {
          x1px2 = uX1[k * states + l] * ump_x2[l];
          for (j = 0; j < states; j++)
            v[j] += x1px2 * extEV[l * states + j];
        }
      }
      v = &x3[span * i];
      scale = 1;
      for (l = 0; scale && (l < span); l++)
        scale =
            ((((v[l]) < 0) ? (-(v[l])) : (v[l])) <
             (1.0 /
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0));
      if (scale) {
        for (l = 0; l < span; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
        addScale += wgt[i];
      }
    }
    free(umpX1);
    free(ump_x2);
  } break;
  case 2:
    for (i = 0; i < n; i++) {
      for (k = 0; k < 4; k++) {
        vl = &(x1[span * i + states * k]);
        vr = &(x2[span * i + states * k]);
        v = &(x3[span * i + states * k]);
        for (l = 0; l < states; l++)
          v[l] = 0;
        for (l = 0; l < states; l++) {
          al = 0.0;
          ar = 0.0;
          for (j = 0; j < states; j++) {
            al += vl[j] * left[k * statesSquare + l * states + j];
            ar += vr[j] * right[k * statesSquare + l * states + j];
          }
          x1px2 = al * ar;
          for (j = 0; j < states; j++)
            v[j] += x1px2 * extEV[states * l + j];
        }
      }
      v = &(x3[span * i]);
      scale = 1;
      for (l = 0; scale && (l < span); l++)
        scale = ((
            (((v[l]) < 0) ? (-(v[l])) : (v[l])) <
            (1.0 /
             115792089237316195423570985008687907853269984665640564039457584007913129639936.0)));
      if (scale) {
        for (l = 0; l < span; l++)
          v[l] *=
              115792089237316195423570985008687907853269984665640564039457584007913129639936.0;
        addScale += wgt[i];
      }
    }
    break;
  default:
    assert(0);
  }
  *scalerIncrement = addScale;
}


x86 assembly (clang, -O0):
<newviewGAMMA_FLEX>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x88(%rbp)
mov    0x48(%rbp),%eax
imul   %eax,%eax
mov    %eax,-0x8c(%rbp)
mov    0x48(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x90(%rbp)
mov    0x50(%rbp),%eax
mov    -0x90(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0xbc(%rbp)
test   %eax,%eax
je     11e5 <newviewGAMMA_FLEX+0xb5>
jmp    11bd <newviewGAMMA_FLEX+0x8d>
mov    -0xbc(%rbp),%eax
sub    $0x1,%eax
je     1534 <newviewGAMMA_FLEX+0x404>
jmp    11d1 <newviewGAMMA_FLEX+0xa1>
mov    -0xbc(%rbp),%eax
sub    $0x2,%eax
je     1a05 <newviewGAMMA_FLEX+0x8d5>
jmp    1d87 <newviewGAMMA_FLEX+0xc57>
movslq -0x94(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x94(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1376 <newviewGAMMA_FLEX+0x246>
mov    -0x30(%rbp),%rax
mov    0x48(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x90(%rbp),%eax
jge    1363 <newviewGAMMA_FLEX+0x233>
mov    -0xa0(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1350 <newviewGAMMA_FLEX+0x220>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa0(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa8(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    129e <newviewGAMMA_FLEX+0x16e>
jmp    1355 <newviewGAMMA_FLEX+0x225>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    124a <newviewGAMMA_FLEX+0x11a>
jmp    1368 <newviewGAMMA_FLEX+0x238>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    121e <newviewGAMMA_FLEX+0xee>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1517 <newviewGAMMA_FLEX+0x3e7>
mov    -0xa0(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x74(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    0x18(%rbp),%rdx
movslq -0x74(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x78(%rbp)
cmpl   $0x4,-0x78(%rbp)
jge    1504 <newviewGAMMA_FLEX+0x3d4>
mov    -0x20(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x90(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1444 <newviewGAMMA_FLEX+0x314>
mov    -0x48(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    141a <newviewGAMMA_FLEX+0x2ea>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    14f1 <newviewGAMMA_FLEX+0x3c1>
mov    -0x38(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x78(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    14de <newviewGAMMA_FLEX+0x3ae>
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    0x48(%rbp),%ecx
imul   -0x80(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    148f <newviewGAMMA_FLEX+0x35f>
jmp    14e3 <newviewGAMMA_FLEX+0x3b3>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    144b <newviewGAMMA_FLEX+0x31b>
jmp    14f6 <newviewGAMMA_FLEX+0x3c6>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    13e4 <newviewGAMMA_FLEX+0x2b4>
jmp    1509 <newviewGAMMA_FLEX+0x3d9>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    137d <newviewGAMMA_FLEX+0x24d>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
jmp    1d8e <newviewGAMMA_FLEX+0xc5e>
movslq -0x94(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq 0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x50(%rbp),%eax
jge    1657 <newviewGAMMA_FLEX+0x527>
mov    -0x30(%rbp),%rax
mov    0x48(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x90(%rbp),%eax
jge    1644 <newviewGAMMA_FLEX+0x514>
mov    -0xb0(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1631 <newviewGAMMA_FLEX+0x501>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xb0(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    15cb <newviewGAMMA_FLEX+0x49b>
jmp    1636 <newviewGAMMA_FLEX+0x506>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1596 <newviewGAMMA_FLEX+0x466>
jmp    1649 <newviewGAMMA_FLEX+0x519>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    156a <newviewGAMMA_FLEX+0x43a>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    19e8 <newviewGAMMA_FLEX+0x8b8>
mov    -0xb0(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x74(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x4,-0x80(%rbp)
jge    1880 <newviewGAMMA_FLEX+0x750>
mov    -0x18(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1770 <newviewGAMMA_FLEX+0x640>
mov    -0xb8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    175d <newviewGAMMA_FLEX+0x62d>
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   0x48(%rbp),%edx
add    %edx,%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xb8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16f7 <newviewGAMMA_FLEX+0x5c7>
jmp    1762 <newviewGAMMA_FLEX+0x632>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    16d1 <newviewGAMMA_FLEX+0x5a1>
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    0x48(%rbp),%edx
imul   -0x80(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    17c6 <newviewGAMMA_FLEX+0x696>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    179c <newviewGAMMA_FLEX+0x66c>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    186d <newviewGAMMA_FLEX+0x73d>
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    185a <newviewGAMMA_FLEX+0x72a>
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   0x48(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    180b <newviewGAMMA_FLEX+0x6db>
jmp    185f <newviewGAMMA_FLEX+0x72f>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17cd <newviewGAMMA_FLEX+0x69d>
jmp    1872 <newviewGAMMA_FLEX+0x742>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    169b <newviewGAMMA_FLEX+0x56b>
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x84(%rbp)
movl   $0x0,-0x7c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x84(%rbp)
mov    %al,-0xbd(%rbp)
je     18d4 <newviewGAMMA_FLEX+0x7a4>
mov    -0x7c(%rbp),%eax
cmp    -0x90(%rbp),%eax
setl   %al
mov    %al,-0xbd(%rbp)
mov    -0xbd(%rbp),%al
test   $0x1,%al
jne    18e7 <newviewGAMMA_FLEX+0x7b7>
jmp    1973 <newviewGAMMA_FLEX+0x843>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    192e <newviewGAMMA_FLEX+0x7fe>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1943 <newviewGAMMA_FLEX+0x813>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0x6b5(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x84(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    18ad <newviewGAMMA_FLEX+0x77d>
cmpl   $0x0,-0x84(%rbp)
je     19d5 <newviewGAMMA_FLEX+0x8a5>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x90(%rbp),%eax
jge    19be <newviewGAMMA_FLEX+0x88e>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  0x65a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1987 <newviewGAMMA_FLEX+0x857>
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    19da <newviewGAMMA_FLEX+0x8aa>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    165e <newviewGAMMA_FLEX+0x52e>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
jmp    1d8e <newviewGAMMA_FLEX+0xc5e>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1d82 <newviewGAMMA_FLEX+0xc52>
movl   $0x0,-0x80(%rbp)
cmpl   $0x4,-0x80(%rbp)
jge    1c1a <newviewGAMMA_FLEX+0xaea>
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    0x48(%rbp),%edx
imul   -0x80(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    0x48(%rbp),%edx
imul   -0x80(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
mov    0x48(%rbp),%edx
imul   -0x80(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1ac9 <newviewGAMMA_FLEX+0x999>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1a9f <newviewGAMMA_FLEX+0x96f>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1c07 <newviewGAMMA_FLEX+0xad7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1b8f <newviewGAMMA_FLEX+0xa5f>
mov    -0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   0x48(%rbp),%edx
add    %edx,%ecx
add    -0x78(%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 -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   0x48(%rbp),%edx
add    %edx,%ecx
add    -0x78(%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    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1af3 <newviewGAMMA_FLEX+0x9c3>
movsd  -0x68(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x48(%rbp),%eax
jge    1bf4 <newviewGAMMA_FLEX+0xac4>
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    0x48(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1ba5 <newviewGAMMA_FLEX+0xa75>
jmp    1bf9 <newviewGAMMA_FLEX+0xac9>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1ad0 <newviewGAMMA_FLEX+0x9a0>
jmp    1c0c <newviewGAMMA_FLEX+0xadc>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1a1f <newviewGAMMA_FLEX+0x8ef>
mov    -0x20(%rbp),%rax
mov    -0x90(%rbp),%ecx
imul   -0x74(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x84(%rbp)
movl   $0x0,-0x7c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x84(%rbp)
mov    %al,-0xc9(%rbp)
je     1c6e <newviewGAMMA_FLEX+0xb3e>
mov    -0x7c(%rbp),%eax
cmp    -0x90(%rbp),%eax
setl   %al
mov    %al,-0xc9(%rbp)
mov    -0xc9(%rbp),%al
test   $0x1,%al
jne    1c81 <newviewGAMMA_FLEX+0xb51>
jmp    1d0d <newviewGAMMA_FLEX+0xbdd>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1cc8 <newviewGAMMA_FLEX+0xb98>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    1cdd <newviewGAMMA_FLEX+0xbad>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  0x31b(%rip),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x84(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1c47 <newviewGAMMA_FLEX+0xb17>
cmpl   $0x0,-0x84(%rbp)
je     1d6f <newviewGAMMA_FLEX+0xc3f>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x90(%rbp),%eax
jge    1d58 <newviewGAMMA_FLEX+0xc28>
mov    -0x48(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  0x2c0(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1d21 <newviewGAMMA_FLEX+0xbf1>
mov    0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    1d74 <newviewGAMMA_FLEX+0xc44>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1a0c <newviewGAMMA_FLEX+0x8dc>
jmp    1d8e <newviewGAMMA_FLEX+0xc5e>
xor    %edi,%edi
call   1040 <assert@plt>
mov    -0x88(%rbp),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newviewGAMMA_FLEX>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r9,%r14
mov    %rcx,0x28(%rsp)
mov    %rdx,0xd8(%rsp)
mov    %rsi,0x40(%rsp)
mov    0x1e0(%rsp),%r15d
mov    0x1d8(%rsp),%r13d
mov    0x1b0(%rsp),%edx
lea    0x0(,%r13,4),%eax
mov    %eax,%ebx
imul   %r15d,%ebx
mov    %eax,0x14(%rsp)
cltq
mov    %rax,0x50(%rsp)
test   %edi,%edi
mov    %r8,0x60(%rsp)
je     19bb <newviewGAMMA_FLEX+0x87b>
mov    %r13d,%ecx
imul   %r13d,%ecx
cmp    $0x1,%edi
je     1abb <newviewGAMMA_FLEX+0x97b>
cmp    $0x2,%edi
jne    1c48 <newviewGAMMA_FLEX+0xb08>
test   %edx,%edx
jle    3048 <newviewGAMMA_FLEX+0x1f08>
mov    %r13d,%r14d
lea    0x0(,%r14,8),%rax
mov    %rax,0x38(%rsp)
mov    %ecx,%eax
mov    %rax,0xa0(%rsp)
mov    0x50(%rsp),%rcx
cmp    $0x2,%ecx
mov    $0x1,%eax
cmovge 0x14(%rsp),%eax
mov    %edx,%edx
mov    %rdx,0x138(%rsp)
mov    %r14d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xb0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xf0(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rax,0x110(%rsp)
and    $0x7ffffffc,%eax
mov    %rax,0x158(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x150(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %r14d,%edi
and    $0xfffffffe,%edi
mov    %rdx,%rax
mov    %rdx,0x70(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x68(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x88(%rsp)
mov    %rsi,%rax
mov    %rsi,0x148(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x140(%rsp)
movslq %r13d,%rsi
mov    0x28(%rsp),%rax
lea    (%rax,%r14,8),%rdx
mov    %rdx,0x98(%rsp)
mov    0x40(%rsp),%rdx
add    $0x8,%rdx
mov    %rdx,0xd0(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x160(%rsp)
mov    0x1c0(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0x90(%rsp)
mov    %rsi,0x18(%rsp)
lea    0x0(,%rsi,8),%rcx
mov    %rcx,0x58(%rsp)
mov    0x1b8(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0xb8(%rsp)
mov    0xd8(%rsp),%rcx
lea    0x8(%rcx),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x30(%r8),%rcx
mov    %rcx,0x128(%rsp)
lea    0x30(%rax),%rsi
lea    0x8(%r8),%rcx
mov    %rdi,%r8
mov    %rcx,0x120(%rsp)
lea    0x8(%rax),%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,0x118(%rsp)
xor    %eax,%eax
movl   $0x0,0x20(%rsp)
mov    %rdi,0x30(%rsp)
mov    %r14,0x80(%rsp)
jmp    13ae <newviewGAMMA_FLEX+0x26e>
mov    0x1c8(%rsp),%rax
mov    0x20(%rsp),%ecx
mov    0x130(%rsp),%rdx
add    (%rax,%rdx,4),%ecx
mov    %rdx,%rax
mov    %ecx,0x20(%rsp)
add    $0x1,%rax
mov    %rax,%rcx
mov    0x160(%rsp),%rax
add    %rax,0xd0(%rsp)
add    %rax,0xc8(%rsp)
add    %rax,%rsi
add    %rax,0x48(%rsp)
add    %rax,0x118(%rsp)
mov    %rcx,%rax
cmp    0x138(%rsp),%rcx
je     306c <newviewGAMMA_FLEX+0x1f2c>
mov    0x14(%rsp),%ecx
imul   %eax,%ecx
mov    %ecx,0xc0(%rsp)
mov    %rax,0x130(%rsp)
imul   0x50(%rsp),%rax
mov    %rax,0xa8(%rsp)
xor    %ebx,%ebx
mov    %rsi,0xe0(%rsp)
jmp    13fe <newviewGAMMA_FLEX+0x2be>
xchg   %ax,%ax
mov    0xe8(%rsp),%rbx
add    $0x1,%rbx
cmp    $0x4,%rbx
mov    0xe0(%rsp),%rsi
je     1830 <newviewGAMMA_FLEX+0x6f0>
test   %r13d,%r13d
jle    1810 <newviewGAMMA_FLEX+0x6d0>
mov    %rbx,%r13
imul   0x18(%rsp),%r13
mov    0xa8(%rsp),%rax
lea    (%rax,%r13,1),%rbp
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x108(%rsp)
mov    0xd8(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x100(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%rbp,8),%rax
mov    %rax,(%rsp)
mov    %ebx,%eax
mov    0x1d8(%rsp),%edx
imul   %edx,%eax
add    0xc0(%rsp),%eax
cltq
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1040 <memset@plt>
mov    0x80(%rsp),%r14
mov    0x30(%rsp),%r8
movapd 0x2b88(%rip),%xmm7
mov    %rbx,0xe8(%rsp)
imul   0xa0(%rsp),%rbx
mov    0x98(%rsp),%rax
lea    (%rax,%rbp,8),%rax
mov    %rax,0x78(%rsp)
mov    0xd0(%rsp),%rax
lea    (%rax,%r13,8),%r15
mov    0x90(%rsp),%rax
lea    (%rax,%rbx,8),%rsi
mov    0xb8(%rsp),%rax
mov    %rbx,0xf8(%rsp)
lea    (%rax,%rbx,8),%rdi
mov    0xc8(%rsp),%rax
lea    (%rax,%r13,8),%r12
mov    0xe0(%rsp),%rax
lea    (%rax,%r13,8),%rax
mov    0x48(%rsp),%rdx
lea    (%rdx,%r13,8),%rbx
mov    0x1d8(%rsp),%r13d
mov    0x120(%rsp),%rbp
mov    0x128(%rsp),%r10
xor    %r11d,%r11d
jmp    1543 <newviewGAMMA_FLEX+0x403>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%r11
add    $0x1,%r11
mov    0x58(%rsp),%rdx
add    %rdx,%rsi
add    %rdx,%rdi
add    %rdx,%r10
add    %rdx,%rbp
cmp    %r14,%r11
je     13e0 <newviewGAMMA_FLEX+0x2a0>
cmp    $0x1,%r13d
jne    1560 <newviewGAMMA_FLEX+0x420>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    15bd <newviewGAMMA_FLEX+0x47d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rdx,8),%xmm2
movsd  (%r15,%rdx,8),%xmm3
movhpd -0x8(%r12,%rdx,8),%xmm2
movsd  -0x8(%rdi,%rdx,8),%xmm4
movsd  (%rdi,%rdx,8),%xmm1
movhpd -0x8(%rsi,%rdx,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movhpd (%r12,%rdx,8),%xmm3
movhpd (%rsi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rdx
movapd %xmm1,%xmm0
cmp    %rdx,%r8
jne    1570 <newviewGAMMA_FLEX+0x430>
mov    %r11,0x8(%rsp)
imul   0x18(%rsp),%r11
test   $0x1,%r14b
je     1629 <newviewGAMMA_FLEX+0x4e9>
mov    0xf8(%rsp),%rcx
lea    (%r11,%rcx,1),%r9
add    %rdx,%r9
mov    0x108(%rsp),%r8
movsd  (%r8,%rdx,8),%xmm0
mov    0x30(%rsp),%r8
mov    0x100(%rsp),%rcx
movhpd (%rcx,%rdx,8),%xmm0
mov    0x80(%rsp),%r14
mov    0x1b8(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm2
mov    0x1c0(%rsp),%rdx
movhpd (%rdx,%r9,8),%xmm2
mulpd  %xmm0,%xmm2
addpd  %xmm2,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
mulpd  %xmm1,%xmm0
cmp    $0x4,%r13d
jb     1661 <newviewGAMMA_FLEX+0x521>
lea    (%r11,%r14,1),%rdx
mov    0x60(%rsp),%r9
lea    (%r9,%rdx,8),%rdx
cmp    %rdx,(%rsp)
jae    16f0 <newviewGAMMA_FLEX+0x5b0>
lea    (%r9,%r11,8),%rdx
cmp    0x78(%rsp),%rdx
jae    16f0 <newviewGAMMA_FLEX+0x5b0>
xor    %r9d,%r9d
mov    %r9,%rdx
test   $0x1,%r14b
je     1696 <newviewGAMMA_FLEX+0x556>
add    %r9,%r11
mov    0x60(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    (%rsp),%rcx
addsd  (%rcx,%r9,8),%xmm1
movsd  %xmm1,(%rcx,%r9,8)
mov    %r9,%rdx
or     $0x1,%rdx
not    %r9
cmp    0x88(%rsp),%r9
je     1520 <newviewGAMMA_FLEX+0x3e0>
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    16b0 <newviewGAMMA_FLEX+0x570>
jmp    1520 <newviewGAMMA_FLEX+0x3e0>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0xf0(%rsp)
je     17f8 <newviewGAMMA_FLEX+0x6b8>
mov    0x68(%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    1710 <newviewGAMMA_FLEX+0x5d0>
testb  $0x1,0x70(%rsp)
je     17df <newviewGAMMA_FLEX+0x69f>
lea    (%r9,%r11,1),%rdx
mov    0x60(%rsp),%r13
movupd 0x0(%r13,%rdx,8),%xmm2
movupd 0x10(%r13,%rdx,8),%xmm3
mov    0x1d8(%rsp),%r13d
mov    (%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    0xb0(%rsp),%rdx
mov    %rdx,%r9
cmp    %r14,%rdx
je     1520 <newviewGAMMA_FLEX+0x3e0>
jmp    1664 <newviewGAMMA_FLEX+0x524>
xor    %r9d,%r9d
testb  $0x1,0x70(%rsp)
jne    1792 <newviewGAMMA_FLEX+0x652>
jmp    17df <newviewGAMMA_FLEX+0x69f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
cmp    $0x4,%rbx
jne    13fe <newviewGAMMA_FLEX+0x2be>
jmp    1350 <newviewGAMMA_FLEX+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r13d,%r13d
jle    1350 <newviewGAMMA_FLEX+0x210>
mov    0x28(%rsp),%rax
mov    0xa8(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    $0x1,%ecx
nop
mov    0x118(%rsp),%rdx
movsd  -0x8(%rdx,%rcx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0x2796(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0x27b9(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0x2795(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    189f <newviewGAMMA_FLEX+0x75f>
lea    0x1(%rcx),%rdx
cmp    0x50(%rsp),%rcx
mov    %rdx,%rcx
jl     1850 <newviewGAMMA_FLEX+0x710>
movsd  0x2779(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    18c7 <newviewGAMMA_FLEX+0x787>
test   %r13d,%r13d
jle    1350 <newviewGAMMA_FLEX+0x210>
cmpl   $0x4,0x110(%rsp)
04
jae    18d4 <newviewGAMMA_FLEX+0x794>
xor    %eax,%eax
jmp    1980 <newviewGAMMA_FLEX+0x840>
mov    0x130(%rsp),%rax
jmp    136e <newviewGAMMA_FLEX+0x22e>
cmpq   $0x0,0x150(%rsp)
je     19ad <newviewGAMMA_FLEX+0x86d>
mov    0x140(%rsp),%rdx
xor    %ecx,%ecx
nopl   (%rax)
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    18f0 <newviewGAMMA_FLEX+0x7b0>
testb  $0x1,0x148(%rsp)
01
je     1960 <newviewGAMMA_FLEX+0x820>
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    0x158(%rsp),%rcx
mov    %rcx,%rax
cmp    0x110(%rsp),%rcx
je     1350 <newviewGAMMA_FLEX+0x210>
nopl   0x0(%rax)
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x2693(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,0x110(%rsp)
jne    1980 <newviewGAMMA_FLEX+0x840>
jmp    1350 <newviewGAMMA_FLEX+0x210>
xor    %ecx,%ecx
testb  $0x1,0x148(%rsp)
01
jne    1942 <newviewGAMMA_FLEX+0x802>
jmp    1960 <newviewGAMMA_FLEX+0x820>
shl    $0x3,%ebx
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %r15d,%ebp
mov    %rax,%r15
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
test   %ebp,%ebp
jle    1c5c <newviewGAMMA_FLEX+0xb1c>
mov    0x1d8(%rsp),%eax
movslq %eax,%r13
mov    0x14(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%r10d
cmovge %ecx,%r10d
mov    %ebp,%r8d
mov    %eax,%esi
shl    $0x3,%r13
xor    %r9d,%r9d
jmp    1a20 <newviewGAMMA_FLEX+0x8e0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r13,%r14
cmp    %r8,%r9
je     1c5c <newviewGAMMA_FLEX+0xb1c>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    1a10 <newviewGAMMA_FLEX+0x8d0>
mov    %r9,%r11
imul   0x50(%rsp),%r11
mov    0x1c0(%rsp),%rdx
mov    0x1b8(%rsp),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%r11,1),%rax
movq   $0x0,(%r15,%rax,8)
movq   $0x0,(%r12,%rax,8)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rbx,8),%xmm0
mulsd  (%rcx,%rbx,8),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  (%r14,%rbx,8),%xmm0
mulsd  (%rdx,%rbx,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1a70 <newviewGAMMA_FLEX+0x930>
add    $0x1,%rdi
add    %r13,%rcx
add    %r13,%rdx
cmp    %r10,%rdi
jne    1a50 <newviewGAMMA_FLEX+0x910>
jmp    1a10 <newviewGAMMA_FLEX+0x8d0>
mov    %ecx,0x30(%rsp)
shl    $0x3,%ebx
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,%rbp
lea    0x0(,%r13,8),%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
test   %r15d,%r15d
mov    %rbp,0x48(%rsp)
jle    28dc <newviewGAMMA_FLEX+0x179c>
mov    0x14(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r12d
cmovge %eax,%r12d
movslq %r13d,%rax
mov    %r15d,%ecx
mov    %rcx,0x58(%rsp)
mov    %r13d,%r9d
mov    %r9d,%edi
and    $0xfffffffe,%edi
lea    0x8(%r14),%rdx
mov    %rax,0x8(%rsp)
lea    0x0(,%rax,8),%rcx
mov    0x1b8(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x88(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
jmp    1b67 <newviewGAMMA_FLEX+0xa27>
nopl   (%rax)
mov    0x18(%rsp),%rsi
add    $0x1,%rsi
add    %rcx,%rdx
mov    %rsi,%rax
mov    %rsi,0x18(%rsp)
cmp    0x58(%rsp),%rsi
mov    0x1d8(%rsp),%r13d
je     28dc <newviewGAMMA_FLEX+0x179c>
test   %r13d,%r13d
jle    1b40 <newviewGAMMA_FLEX+0xa00>
mov    0x18(%rsp),%rsi
mov    %rsi,%rax
imul   0x8(%rsp),%rax
lea    (%r14,%rax,8),%rax
mov    %rax,(%rsp)
mov    %rsi,%rax
imul   0x50(%rsp),%rax
mov    0x88(%rsp),%r10
xor    %r11d,%r11d
jmp    1bac <newviewGAMMA_FLEX+0xa6c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %rcx,%r10
cmp    %r12,%r11
je     1b40 <newviewGAMMA_FLEX+0xa00>
lea    (%r11,%rax,1),%r13
movq   $0x0,0x0(%rbp,%r13,8)
mov    0x1d8(%rsp),%esi
xorpd  %xmm0,%xmm0
xor    %r8d,%r8d
cmp    $0x1,%esi
je     1c09 <newviewGAMMA_FLEX+0xac9>
nopl   0x0(%rax)
movsd  -0x8(%rdx,%r8,8),%xmm1
mulsd  -0x8(%r10,%r8,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%r13,8)
movsd  (%rdx,%r8,8),%xmm0
mulsd  (%r10,%r8,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%r13,8)
add    $0x2,%r8
cmp    %r8,%rdi
jne    1bd0 <newviewGAMMA_FLEX+0xa90>
test   $0x1,%r9b
je     1ba0 <newviewGAMMA_FLEX+0xa60>
mov    %r11,%r15
imul   0x8(%rsp),%r15
mov    (%rsp),%rsi
movsd  (%rsi,%r8,8),%xmm1
add    %r8,%r15
mov    0x1b8(%rsp),%rsi
mulsd  (%rsi,%r15,8),%xmm1
mov    0x48(%rsp),%rbp
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%r13,8)
jmp    1ba0 <newviewGAMMA_FLEX+0xa60>
movl   $0x0,0x20(%rsp)
xor    %edi,%edi
call   1050 <assert@plt>
jmp    306c <newviewGAMMA_FLEX+0x1f2c>
mov    0x1b0(%rsp),%eax
test   %eax,%eax
mov    0x60(%rsp),%rbx
jle    3038 <newviewGAMMA_FLEX+0x1ef8>
mov    0x1d8(%rsp),%edx
mov    %edx,%ebp
lea    0x0(,%rbp,8),%rcx
mov    %rcx,0x38(%rsp)
movslq %edx,%r10
mov    %eax,%ecx
mov    %rcx,0x128(%rsp)
lea    (%r10,%r10,1),%rax
mov    %rax,0x100(%rsp)
lea    (%rdx,%rdx,1),%ecx
mov    %rcx,0x130(%rsp)
lea    (%r10,%r10,2),%r8
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xb0(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x30(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,0x80(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x78(%rsp)
mov    %rbp,%rcx
neg    %rcx
mov    %rcx,0x58(%rsp)
mov    %r10,%rdi
shl    $0x4,%rdi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rdi,1),%r9
add    $0x30,%r9
add    %rcx,%rdi
lea    (%rdx,%rdx,2),%edx
mov    %edx,0x138(%rsp)
lea    (%r8,%rbp,1),%rdx
mov    %rdx,0x118(%rsp)
lea    0x0(%rbp,%r10,2),%rdx
mov    %rdx,0x20(%rsp)
lea    (%r10,%rbp,1),%rdx
mov    %rdx,0x110(%rsp)
lea    0x30(%rbx),%rdx
mov    %rdx,0x98(%rsp)
lea    0x0(,%r10,8),%rdx
mov    %rdx,0x18(%rsp)
lea    0x30(%rcx),%r13
mov    0x50(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
mov    %rdx,0x120(%rsp)
lea    0x8(%rbx),%rdx
mov    %rdx,0x90(%rsp)
lea    0x8(%rcx),%r14
lea    0x30(%rcx,%r10,8),%rsi
lea    (%rcx,%r10,8),%rbx
lea    (%rcx,%r8,8),%rdx
add    $0x30,%rdx
mov    %r8,0x68(%rsp)
lea    (%rcx,%r8,8),%rcx
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    %r10,0xa0(%rsp)
jmp    1dff <newviewGAMMA_FLEX+0xcbf>
xchg   %ax,%ax
mov    0x48(%rsp),%r8
add    $0x1,%r8
mov    0x120(%rsp),%rax
add    %rax,%r13
add    %rax,%r14
mov    0xe8(%rsp),%rsi
add    %rax,%rsi
add    %rax,%rbx
mov    0xd0(%rsp),%r9
add    %rax,%r9
mov    0x108(%rsp),%rdi
add    %rax,%rdi
add    %rax,%rdx
mov    0xf0(%rsp),%rcx
add    %rax,%rcx
mov    %r8,%rax
mov    %r8,0x48(%rsp)
cmp    0x128(%rsp),%r8
je     3038 <newviewGAMMA_FLEX+0x1ef8>
mov    %rcx,0xf0(%rsp)
mov    %rsi,0xe8(%rsp)
mov    %r9,0xd0(%rsp)
mov    %rdi,0x108(%rsp)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    1da0 <newviewGAMMA_FLEX+0xc60>
mov    %rdx,0x40(%rsp)
mov    0x48(%rsp),%rsi
mov    %rsi,%rax
mov    0x50(%rsp),%r8
imul   %r8,%rax
lea    (%rax,%rbp,1),%r11
lea    (%rax,%r10,1),%rcx
mov    %rcx,0x8(%rsp)
mov    0x110(%rsp),%rdx
lea    (%rdx,%rax,1),%rcx
mov    %rcx,(%rsp)
mov    0x100(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0x70(%rsp)
mov    0x20(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,1),%r9
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,1),%r10
mov    0x14(%rsp),%ecx
mov    %ecx,%edx
imul   %esi,%edx
mov    0x1a0(%rsp),%rcx
movzbl (%rcx,%rsi,1),%edi
imul   %r8,%rdi
mov    0x1a8(%rsp),%rcx
movzbl (%rcx,%rsi,1),%esi
imul   %r8,%rsi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x88(%rsp)
lea    (%rcx,%r11,8),%rax
mov    %rax,0xf8(%rsp)
mov    0x8(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0xd8(%rsp)
mov    (%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0xe0(%rsp)
mov    0x70(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0xc8(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0xa8(%rsp)
lea    (%rcx,%r9,8),%rax
mov    %rax,0x70(%rsp)
lea    (%rcx,%r10,8),%rax
mov    %rax,0xc0(%rsp)
lea    (%r15,%rdi,8),%rax
mov    %rax,0x8(%rsp)
lea    (%r12,%rsi,8),%rax
mov    %rax,(%rsp)
mov    %rdx,0xb8(%rsp)
movslq %edx,%rax
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1040 <memset@plt>
mov    0xa0(%rsp),%r10
mov    0x60(%rsp),%r9
mov    0x90(%rsp),%rax
mov    0x98(%rsp),%rcx
xor    %edx,%edx
mov    0xb0(%rsp),%r11
jmp    1fa8 <newviewGAMMA_FLEX+0xe68>
nopl   0x0(%rax)
add    $0x1,%rdx
mov    0x18(%rsp),%rsi
add    %rsi,%rcx
add    %rsi,%rax
cmp    %rbp,%rdx
je     2190 <newviewGAMMA_FLEX+0x1050>
mov    %rdx,%r8
imul   %r10,%r8
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
mov    (%rsp),%rsi
mulsd  (%rsi,%rdx,8),%xmm0
mov    0x1d8(%rsp),%esi
cmp    $0x4,%esi
jb     1ff6 <newviewGAMMA_FLEX+0xeb6>
lea    (%r8,%rbp,1),%rsi
lea    (%r9,%rsi,8),%rsi
cmp    %rsi,0x88(%rsp)
jae    2080 <newviewGAMMA_FLEX+0xf40>
lea    (%r9,%r8,8),%rsi
cmp    0xf8(%rsp),%rsi
jae    2080 <newviewGAMMA_FLEX+0xf40>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bpl
je     2027 <newviewGAMMA_FLEX+0xee7>
add    %rdi,%r8
movsd  (%r9,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x88(%rsp),%rsi
addsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x58(%rsp),%rdi
je     1f90 <newviewGAMMA_FLEX+0xe50>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r14,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rsi,8)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rsi,8),%xmm1
movsd  %xmm1,(%r14,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    2040 <newviewGAMMA_FLEX+0xf00>
jmp    1f90 <newviewGAMMA_FLEX+0xe50>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     2173 <newviewGAMMA_FLEX+0x1033>
mov    0x78(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r13,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r13,%rdi,8),%xmm2
movupd -0x10(%r13,%rdi,8),%xmm5
movupd 0x0(%r13,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r13,%rdi,8)
movupd %xmm3,-0x20(%r13,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r13,%rdi,8)
movupd %xmm3,0x0(%r13,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    20a0 <newviewGAMMA_FLEX+0xf60>
testb  $0x1,0x80(%rsp)
01
je     2162 <newviewGAMMA_FLEX+0x1022>
lea    (%rdi,%r8,1),%rsi
movupd (%r9,%rsi,8),%xmm2
movupd 0x10(%r9,%rsi,8),%xmm3
mov    0x88(%rsp),%rsi
movupd (%rsi,%rdi,8),%xmm4
movupd 0x10(%rsi,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rsi,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
mov    %r11,%rdi
cmp    %rbp,%r11
je     1f90 <newviewGAMMA_FLEX+0xe50>
jmp    1ff8 <newviewGAMMA_FLEX+0xeb8>
xor    %edi,%edi
testb  $0x1,0x80(%rsp)
01
jne    2123 <newviewGAMMA_FLEX+0xfe3>
jmp    2162 <newviewGAMMA_FLEX+0x1022>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    0x40(%rsp),%rdx
jle    1da0 <newviewGAMMA_FLEX+0xc60>
mov    0x1d8(%rsp),%eax
mov    0xb8(%rsp),%rcx
add    %ecx,%eax
cltq
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1040 <memset@plt>
mov    0xa0(%rsp),%r10
mov    0x60(%rsp),%r9
mov    0x90(%rsp),%rax
mov    0x98(%rsp),%rcx
xor    %edx,%edx
mov    0xd8(%rsp),%r11
jmp    2218 <newviewGAMMA_FLEX+0x10d8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdx
mov    0x18(%rsp),%rsi
add    %rsi,%rcx
add    %rsi,%rax
cmp    %rbp,%rdx
je     2400 <newviewGAMMA_FLEX+0x12c0>
mov    %rdx,%r8
imul   %r10,%r8
lea    (%rdx,%r10,1),%rsi
mov    0x8(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm0
mov    (%rsp),%rdi
mulsd  (%rdi,%rsi,8),%xmm0
mov    0x1d8(%rsp),%esi
cmp    $0x4,%esi
jb     2261 <newviewGAMMA_FLEX+0x1121>
lea    (%r8,%rbp,1),%rsi
lea    (%r9,%rsi,8),%rsi
cmp    %rsi,%r11
jae    22e0 <newviewGAMMA_FLEX+0x11a0>
lea    (%r9,%r8,8),%rsi
cmp    0xe0(%rsp),%rsi
jae    22e0 <newviewGAMMA_FLEX+0x11a0>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bpl
je     228c <newviewGAMMA_FLEX+0x114c>
add    %rdi,%r8
movsd  (%r9,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r11,%rdi,8),%xmm1
movsd  %xmm1,(%r11,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x58(%rsp),%rdi
je     2200 <newviewGAMMA_FLEX+0x10c0>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    22a0 <newviewGAMMA_FLEX+0x1160>
jmp    2200 <newviewGAMMA_FLEX+0x10c0>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     2389 <newviewGAMMA_FLEX+0x1249>
mov    0x78(%rsp),%rsi
xor    %edi,%edi
mov    0xe8(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r11,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r11,%rdi,8),%xmm2
movupd -0x10(%r11,%rdi,8),%xmm5
movupd (%r11,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r11,%rdi,8)
movupd %xmm3,-0x20(%r11,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r11,%rdi,8)
movupd %xmm3,(%r11,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    2310 <newviewGAMMA_FLEX+0x11d0>
jmp    238b <newviewGAMMA_FLEX+0x124b>
xor    %edi,%edi
testb  $0x1,0x80(%rsp)
01
mov    0xd8(%rsp),%r11
je     23d8 <newviewGAMMA_FLEX+0x1298>
lea    (%rdi,%r8,1),%rsi
movupd (%r9,%rsi,8),%xmm2
movupd 0x10(%r9,%rsi,8),%xmm3
movupd (%r11,%rdi,8),%xmm4
movupd 0x10(%r11,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r11,%rdi,8)
movupd %xmm3,0x10(%r11,%rdi,8)
mov    0xb0(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     2200 <newviewGAMMA_FLEX+0x10c0>
jmp    2263 <newviewGAMMA_FLEX+0x1123>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    0x40(%rsp),%rdx
jle    1da0 <newviewGAMMA_FLEX+0xc60>
mov    0x130(%rsp),%rax
mov    0xb8(%rsp),%rcx
add    %ecx,%eax
cltq
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1040 <memset@plt>
mov    0xa0(%rsp),%r10
mov    0x60(%rsp),%r9
mov    0x90(%rsp),%rax
mov    0x98(%rsp),%rcx
xor    %edx,%edx
mov    0xc8(%rsp),%r11
jmp    2488 <newviewGAMMA_FLEX+0x1348>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    0x18(%rsp),%rsi
add    %rsi,%rcx
add    %rsi,%rax
cmp    %rbp,%rdx
je     2680 <newviewGAMMA_FLEX+0x1540>
mov    %rdx,%r8
imul   %r10,%r8
mov    0x100(%rsp),%rsi
add    %rdx,%rsi
mov    0x8(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm0
mov    (%rsp),%rdi
mulsd  (%rdi,%rsi,8),%xmm0
mov    0x1d8(%rsp),%esi
cmp    $0x4,%esi
jb     24dc <newviewGAMMA_FLEX+0x139c>
lea    (%r8,%rbp,1),%rsi
lea    (%r9,%rsi,8),%rsi
cmp    %rsi,%r11
jae    2560 <newviewGAMMA_FLEX+0x1420>
lea    (%r9,%r8,8),%rsi
cmp    0xa8(%rsp),%rsi
jae    2560 <newviewGAMMA_FLEX+0x1420>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bpl
je     2507 <newviewGAMMA_FLEX+0x13c7>
add    %rdi,%r8
movsd  (%r9,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r11,%rdi,8),%xmm1
movsd  %xmm1,(%r11,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x58(%rsp),%rdi
mov    0x108(%rsp),%rdi
je     2470 <newviewGAMMA_FLEX+0x1330>
nopl   (%rax)
movsd  -0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    2520 <newviewGAMMA_FLEX+0x13e0>
jmp    2470 <newviewGAMMA_FLEX+0x1330>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     2609 <newviewGAMMA_FLEX+0x14c9>
mov    0x78(%rsp),%rsi
xor    %edi,%edi
mov    0xd0(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r11,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r11,%rdi,8),%xmm2
movupd -0x10(%r11,%rdi,8),%xmm5
movupd (%r11,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r11,%rdi,8)
movupd %xmm3,-0x20(%r11,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r11,%rdi,8)
movupd %xmm3,(%r11,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    2590 <newviewGAMMA_FLEX+0x1450>
jmp    260b <newviewGAMMA_FLEX+0x14cb>
xor    %edi,%edi
testb  $0x1,0x80(%rsp)
01
mov    0xc8(%rsp),%r11
je     2658 <newviewGAMMA_FLEX+0x1518>
lea    (%rdi,%r8,1),%rsi
movupd (%r9,%rsi,8),%xmm2
movupd 0x10(%r9,%rsi,8),%xmm3
movupd (%r11,%rdi,8),%xmm4
movupd 0x10(%r11,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r11,%rdi,8)
movupd %xmm3,0x10(%r11,%rdi,8)
mov    0xb0(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     2470 <newviewGAMMA_FLEX+0x1330>
jmp    24de <newviewGAMMA_FLEX+0x139e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
mov    0x40(%rsp),%rdx
jle    1da0 <newviewGAMMA_FLEX+0xc60>
mov    0xb8(%rsp),%rax
add    0x138(%rsp),%eax
cltq
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x38(%rsp),%rdx
call   1040 <memset@plt>
mov    0x40(%rsp),%rdx
mov    0xa0(%rsp),%r10
mov    0x60(%rsp),%r9
mov    0x90(%rsp),%rax
mov    0x98(%rsp),%rcx
xor    %r11d,%r11d
jmp    2708 <newviewGAMMA_FLEX+0x15c8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
mov    0x18(%rsp),%rsi
add    %rsi,%rcx
add    %rsi,%rax
cmp    %rbp,%r11
je     1da0 <newviewGAMMA_FLEX+0xc60>
mov    %r11,%r8
imul   %r10,%r8
mov    0x68(%rsp),%rsi
add    %r11,%rsi
mov    0x8(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm0
mov    (%rsp),%rdi
mulsd  (%rdi,%rsi,8),%xmm0
mov    0x1d8(%rsp),%esi
cmp    $0x4,%esi
jb     275b <newviewGAMMA_FLEX+0x161b>
lea    (%r8,%rbp,1),%rsi
lea    (%r9,%rsi,8),%rsi
cmp    %rsi,0x70(%rsp)
jae    27e0 <newviewGAMMA_FLEX+0x16a0>
lea    (%r9,%r8,8),%rsi
cmp    0xc0(%rsp),%rsi
jae    27e0 <newviewGAMMA_FLEX+0x16a0>
xor    %edi,%edi
mov    %rdi,%rsi
test   $0x1,%bpl
je     2789 <newviewGAMMA_FLEX+0x1649>
add    %rdi,%r8
movsd  (%r9,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x70(%rsp),%rsi
addsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%rsi,%rdi,8)
mov    %rdi,%rsi
or     $0x1,%rsi
not    %rdi
cmp    0x58(%rsp),%rdi
mov    0xf0(%rsp),%rdi
je     26f0 <newviewGAMMA_FLEX+0x15b0>
nop
movsd  -0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rsi,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdi,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbp
jne    27a0 <newviewGAMMA_FLEX+0x1660>
jmp    26f0 <newviewGAMMA_FLEX+0x15b0>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     28ce <newviewGAMMA_FLEX+0x178e>
mov    0x78(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rdi,8),%xmm2
movupd -0x20(%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rdx,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rdx,%rdi,8),%xmm2
movupd -0x10(%rdx,%rdi,8),%xmm5
movupd (%rdx,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rdx,%rdi,8)
movupd %xmm3,-0x20(%rdx,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm2
movupd (%rcx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rdx,%rdi,8)
movupd %xmm3,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    2800 <newviewGAMMA_FLEX+0x16c0>
testb  $0x1,0x80(%rsp)
01
je     28b5 <newviewGAMMA_FLEX+0x1775>
lea    (%rdi,%r8,1),%rsi
movupd (%r9,%rsi,8),%xmm2
movupd 0x10(%r9,%rsi,8),%xmm3
mov    0x70(%rsp),%rsi
movupd (%rsi,%rdi,8),%xmm4
movupd 0x10(%rsi,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rsi,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
mov    0xb0(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rbp,%rsi
je     26f0 <newviewGAMMA_FLEX+0x15b0>
jmp    275d <newviewGAMMA_FLEX+0x161d>
xor    %edi,%edi
testb  $0x1,0x80(%rsp)
01
jne    2879 <newviewGAMMA_FLEX+0x1739>
jmp    28b5 <newviewGAMMA_FLEX+0x1775>
mov    0x1b0(%rsp),%esi
test   %esi,%esi
jle    3052 <newviewGAMMA_FLEX+0x1f12>
movslq %r13d,%rdx
mov    %r13d,%r13d
mov    0x30(%rsp),%eax
mov    %rax,0xf0(%rsp)
mov    0x14(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovge %eax,%ecx
mov    %esi,%eax
mov    %rax,0xa0(%rsp)
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rcx,0x38(%rsp)
and    $0x7ffffffc,%ecx
mov    %rcx,0x90(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,0xb8(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r13d,%r14d
and    $0xfffffffe,%r14d
mov    %rsi,%rax
mov    %rsi,0x80(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x108(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x58(%rsp)
mov    %rcx,%rax
mov    %rcx,0x128(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x120(%rsp)
lea    0x0(,%r13,8),%rax
mov    %rax,0xe8(%rsp)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r13,8),%rax
mov    %rax,0xa8(%rsp)
mov    0xd8(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x78(%rsp)
mov    0x50(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x98(%rsp)
mov    0x1c0(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0x70(%rsp)
mov    %rdx,0x8(%rsp)
lea    0x0(,%rdx,8),%r15
mov    0x60(%rsp),%rax
lea    0x30(%rax),%rdx
mov    %rdx,0xd0(%rsp)
lea    0x30(%rcx),%rdx
add    $0x8,%rax
mov    %rax,0xc8(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0xe0(%rsp)
xor    %esi,%esi
mov    %rcx,%rdi
movl   $0x0,0x20(%rsp)
jmp    2aa2 <newviewGAMMA_FLEX+0x1962>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1c8(%rsp),%rax
mov    0x20(%rsp),%ecx
mov    0x40(%rsp),%rsi
add    (%rax,%rsi,4),%ecx
mov    %ecx,0x20(%rsp)
mov    0x68(%rsp),%rdx
mov    0xc0(%rsp),%rdi
add    $0x1,%rsi
mov    0x98(%rsp),%rax
add    %rax,0x78(%rsp)
add    %rax,%rdx
add    %rax,0xe0(%rsp)
add    %rax,%rdi
cmp    0xa0(%rsp),%rsi
je     305a <newviewGAMMA_FLEX+0x1f1a>
mov    %rdi,0xc0(%rsp)
mov    %rdx,0x68(%rsp)
mov    0x14(%rsp),%eax
imul   %esi,%eax
mov    %eax,0xb0(%rsp)
mov    0x1a0(%rsp),%rax
movzbl (%rax,%rsi,1),%eax
mov    0x50(%rsp),%rcx
imul   %rcx,%rax
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x18(%rsp)
mov    %rsi,0x40(%rsp)
imul   %rcx,%rsi
mov    %rsi,0xf8(%rsp)
xor    %r10d,%r10d
jmp    2b0e <newviewGAMMA_FLEX+0x19ce>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    $0x4,%r10
je     2a50 <newviewGAMMA_FLEX+0x1910>
mov    0x1d8(%rsp),%ecx
test   %ecx,%ecx
jle    2b00 <newviewGAMMA_FLEX+0x19c0>
mov    %r10d,%eax
imul   %ecx,%eax
add    0xb0(%rsp),%eax
mov    %r10,%rdx
imul   0x8(%rsp),%rdx
mov    0xf8(%rsp),%rcx
lea    (%rdx,%rcx,1),%r11
cltq
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    0xd8(%rsp),%rax
lea    (%rax,%r11,8),%r8
mov    %r10,%r9
imul   0xf0(%rsp),%r9
mov    0x78(%rsp),%rax
mov    %rdx,(%rsp)
lea    (%rax,%rdx,8),%rdx
mov    0x70(%rsp),%rax
lea    (%rax,%r9,8),%rsi
xor    %eax,%eax
jmp    2b90 <newviewGAMMA_FLEX+0x1a50>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %r15,%rsi
cmp    %r13,%rax
je     2c20 <newviewGAMMA_FLEX+0x1ae0>
movq   $0x0,(%rbx,%rax,8)
mov    0x1d8(%rsp),%ecx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cmp    $0x1,%ecx
je     2be1 <newviewGAMMA_FLEX+0x1aa1>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbp,8),%xmm1
mulsd  -0x8(%rsi,%rbp,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  (%rdx,%rbp,8),%xmm0
mulsd  (%rsi,%rbp,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    2bb0 <newviewGAMMA_FLEX+0x1a70>
test   $0x1,%r13b
je     2b80 <newviewGAMMA_FLEX+0x1a40>
mov    %rax,%rcx
imul   0x8(%rsp),%rcx
add    %r9,%rcx
movsd  (%r8,%rbp,8),%xmm1
add    %rbp,%rcx
mov    0x1c0(%rsp),%rbp
mulsd  0x0(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
jmp    2b80 <newviewGAMMA_FLEX+0x1a40>
nopl   0x0(%rax,%rax,1)
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2b00 <newviewGAMMA_FLEX+0x19c0>
mov    %r10,0x100(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%r11,8),%r12
xor    %esi,%esi
mov    0xe8(%rsp),%rdx
mov    %r11,%rbp
call   1040 <memset@plt>
movapd 0x13b6(%rip),%xmm7
mov    0x60(%rsp),%r11
mov    0xa8(%rsp),%rax
lea    (%rax,%rbp,8),%r8
mov    0x68(%rsp),%rax
mov    (%rsp),%rdx
lea    (%rax,%rdx,8),%rcx
mov    0xe0(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
mov    0xc8(%rsp),%rsi
mov    0xd0(%rsp),%rdi
xor    %r10d,%r10d
jmp    2cb3 <newviewGAMMA_FLEX+0x1b73>
nopl   0x0(%rax)
add    $0x1,%r10
add    %r15,%rdi
add    %r15,%rsi
cmp    %r13,%r10
je     2e80 <newviewGAMMA_FLEX+0x1d40>
mov    %r10,%r9
imul   0x8(%rsp),%r9
mov    (%rsp),%rax
add    %r10,%rax
mov    0x18(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rbx,%r10,8),%xmm0
mov    0x1d8(%rsp),%eax
cmp    $0x4,%eax
jb     2cfe <newviewGAMMA_FLEX+0x1bbe>
lea    (%r9,%r13,1),%rax
lea    (%r11,%rax,8),%rax
cmp    %rax,%r12
jae    2d80 <newviewGAMMA_FLEX+0x1c40>
lea    (%r11,%r9,8),%rax
cmp    %r8,%rax
jae    2d80 <newviewGAMMA_FLEX+0x1c40>
xor    %ebp,%ebp
mov    %rbp,%rax
test   $0x1,%r13b
je     2d29 <newviewGAMMA_FLEX+0x1be9>
add    %rbp,%r9
movsd  (%r11,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rbp,8),%xmm1
movsd  %xmm1,(%r12,%rbp,8)
mov    %rbp,%rax
or     $0x1,%rax
not    %rbp
cmp    0x58(%rsp),%rbp
je     2ca0 <newviewGAMMA_FLEX+0x1b60>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rax,8)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    2d40 <newviewGAMMA_FLEX+0x1c00>
jmp    2ca0 <newviewGAMMA_FLEX+0x1b60>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x30(%rsp)
je     2e6d <newviewGAMMA_FLEX+0x1d2d>
mov    0x108(%rsp),%rax
xor    %ebp,%ebp
xchg   %ax,%ax
movupd -0x30(%rdi,%rbp,8),%xmm2
movupd -0x20(%rdi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rcx,%rbp,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rcx,%rbp,8),%xmm2
movupd -0x10(%rcx,%rbp,8),%xmm5
movupd (%rcx,%rbp,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rcx,%rbp,8)
movupd %xmm3,-0x20(%rcx,%rbp,8)
movupd -0x10(%rdi,%rbp,8),%xmm2
movupd (%rdi,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rcx,%rbp,8)
movupd %xmm3,(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rax
jne    2da0 <newviewGAMMA_FLEX+0x1c60>
testb  $0x1,0x80(%rsp)
01
je     2e54 <newviewGAMMA_FLEX+0x1d14>
lea    (%r9,%rbp,1),%rax
movupd (%r11,%rax,8),%xmm2
movupd 0x10(%r11,%rax,8),%xmm3
movupd (%r12,%rbp,8),%xmm4
movupd 0x10(%r12,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r12,%rbp,8)
movupd %xmm3,0x10(%r12,%rbp,8)
mov    0x88(%rsp),%rax
mov    %rax,%rbp
cmp    %r13,%rax
je     2ca0 <newviewGAMMA_FLEX+0x1b60>
jmp    2d00 <newviewGAMMA_FLEX+0x1bc0>
xor    %ebp,%ebp
testb  $0x1,0x80(%rsp)
01
jne    2e19 <newviewGAMMA_FLEX+0x1cd9>
jmp    2e54 <newviewGAMMA_FLEX+0x1d14>
nopl   0x0(%rax,%rax,1)
mov    0x100(%rsp),%r10
add    $0x1,%r10
cmp    $0x4,%r10
jne    2b0e <newviewGAMMA_FLEX+0x19ce>
mov    0x1d8(%rsp),%eax
test   %eax,%eax
jle    2a50 <newviewGAMMA_FLEX+0x1910>
mov    0x28(%rsp),%rax
mov    0xf8(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
mov    $0x1,%ecx
mov    0xc0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdi,%rcx,8),%xmm1
movapd %xmm1,%xmm2
xorpd  0x111e(%rip),%xmm2
movapd %xmm1,%xmm0
cmpltsd 0x1141(%rip),%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0x111d(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    2f17 <newviewGAMMA_FLEX+0x1dd7>
lea    0x1(%rcx),%rdx
cmp    0x50(%rsp),%rcx
mov    %rdx,%rcx
jl     2ed0 <newviewGAMMA_FLEX+0x1d90>
movsd  0x1101(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    2f42 <newviewGAMMA_FLEX+0x1e02>
mov    0x1d8(%rsp),%ecx
test   %ecx,%ecx
jle    2a50 <newviewGAMMA_FLEX+0x1910>
cmpl   $0x4,0x38(%rsp)
jae    2f51 <newviewGAMMA_FLEX+0x1e11>
xor    %eax,%eax
jmp    3000 <newviewGAMMA_FLEX+0x1ec0>
mov    0x68(%rsp),%rdx
mov    0x40(%rsp),%rsi
jmp    2a75 <newviewGAMMA_FLEX+0x1935>
cmpq   $0x0,0xb8(%rsp)
je     302a <newviewGAMMA_FLEX+0x1eea>
mov    0x120(%rsp),%rdx
xor    %ecx,%ecx
mov    0x68(%rsp),%rsi
nop
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    2f70 <newviewGAMMA_FLEX+0x1e30>
testb  $0x1,0x128(%rsp)
01
je     2fe0 <newviewGAMMA_FLEX+0x1ea0>
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    0x90(%rsp),%rcx
mov    %rcx,%rax
cmp    0x38(%rsp),%rcx
je     2a50 <newviewGAMMA_FLEX+0x1910>
cs nopw 0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x1013(%rip),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,0x38(%rsp)
jne    3000 <newviewGAMMA_FLEX+0x1ec0>
jmp    2a50 <newviewGAMMA_FLEX+0x1910>
xor    %ecx,%ecx
testb  $0x1,0x128(%rsp)
01
jne    2fc2 <newviewGAMMA_FLEX+0x1e82>
jmp    2fe0 <newviewGAMMA_FLEX+0x1ea0>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
movl   $0x0,0x20(%rsp)
jmp    306c <newviewGAMMA_FLEX+0x1f2c>
movl   $0x0,0x20(%rsp)
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x1d0(%rsp),%rax
mov    0x20(%rsp),%ecx
mov    %ecx,(%rax)
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @newviewGAMMA_FLEX(i32 %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, i8* nocapture %6, i8* nocapture %7, i32 %8, double* nocapture %9, double* nocapture %10, i32* nocapture %11, i32* nocapture writeonly %12, i32 %13, i32 %14) {
%16 = mul nsw i32 %13, %13
%17 = shl i32 %13, 2
%18 = mul nsw i32 %17, %14
switch i32 %0, label %1370 [
i32 0, label %61
i32 1, label %712
i32 2, label %19
]
19: ; preds = %15
%20 = icmp sgt i32 %8, 0
br i1 %20, label %21, label %1372
21: ; preds = %19
%22 = icmp sgt i32 %13, 0
%23 = zext i32 %13 to i64
%24 = shl nuw nsw i64 %23, 3
%25 = sext i32 %13 to i64
%26 = zext i32 %16 to i64
%27 = sext i32 %17 to i64
%28 = call i32 @llvm.smax.i32(i32 %17, i32 1)
%29 = zext i32 %8 to i64
%30 = zext i32 %28 to i64
%31 = getelementptr double, double* %3, i64 %23
%32 = and i64 %23, 4294967292
%33 = add nsw i64 %32, -4
%34 = lshr exact i64 %33, 2
%35 = add nuw nsw i64 %34, 1
%36 = and i64 %30, 2147483644
%37 = add nsw i64 %36, -4
%38 = lshr exact i64 %37, 2
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %23, 1
%41 = icmp eq i32 %13, 1
%42 = and i64 %23, 4294967294
%43 = icmp eq i64 %40, 0
%44 = icmp ult i32 %13, 4
%45 = and i64 %23, 4294967292
%46 = and i64 %35, 1
%47 = icmp eq i64 %33, 0
%48 = and i64 %35, 9223372036854775806
%49 = icmp eq i64 %46, 0
%50 = icmp eq i64 %45, %23
%51 = and i64 %23, 1
%52 = icmp eq i64 %51, 0
%53 = sub nsw i64 0, %23
%54 = icmp ult i32 %28, 4
%55 = and i64 %30, 2147483644
%56 = and i64 %39, 1
%57 = icmp eq i64 %37, 0
%58 = and i64 %39, 9223372036854775806
%59 = icmp eq i64 %56, 0
%60 = icmp eq i64 %55, %30
br label %1093
61: ; preds = %15
%62 = shl i32 %18, 3
%63 = tail call i64 @malloc(i32 %62)
%64 = inttoptr i64 %63 to double*
%65 = tail call i64 @malloc(i32 %62)
%66 = inttoptr i64 %65 to double*
%67 = icmp sgt i32 %14, 0
br i1 %67, label %68, label %76
68: ; preds = %61
%69 = icmp sgt i32 %13, 0
%70 = sext i32 %13 to i64
%71 = call i32 @llvm.smax.i32(i32 %17, i32 1)
%72 = sext i32 %17 to i64
%73 = zext i32 %14 to i64
%74 = zext i32 %71 to i64
%75 = zext i32 %13 to i64
br label %136
76: ; preds = %167, %61
%77 = icmp sgt i32 %8, 0
br i1 %77, label %78, label %709
78: ; preds = %76
%79 = icmp sgt i32 %13, 0
%80 = zext i32 %13 to i64
%81 = shl nuw nsw i64 %80, 3
%82 = sext i32 %13 to i64
%83 = sext i32 %17 to i64
%84 = zext i32 %8 to i64
%85 = shl nsw i64 %82, 1
%86 = shl nuw i32 %13, 1
%87 = mul nsw i64 %82, 3
%88 = mul i32 %13, 3
%89 = add nsw i64 %87, %80
%90 = add nsw i64 %85, %80
%91 = add nsw i64 %82, %80
%92 = and i64 %80, 4294967292
%93 = add nsw i64 %92, -4
%94 = lshr exact i64 %93, 2
%95 = add nuw nsw i64 %94, 1
%96 = icmp ult i32 %13, 4
%97 = and i64 %80, 4294967292
%98 = and i64 %95, 1
%99 = icmp eq i64 %93, 0
%100 = and i64 %95, 9223372036854775806
%101 = icmp eq i64 %98, 0
%102 = icmp eq i64 %97, %80
%103 = and i64 %80, 1
%104 = icmp eq i64 %103, 0
%105 = sub nsw i64 0, %80
%106 = icmp ult i32 %13, 4
%107 = and i64 %80, 4294967292
%108 = and i64 %95, 1
%109 = icmp eq i64 %93, 0
%110 = and i64 %95, 9223372036854775806
%111 = icmp eq i64 %108, 0
%112 = icmp eq i64 %107, %80
%113 = and i64 %80, 1
%114 = icmp eq i64 %113, 0
%115 = sub nsw i64 0, %80
%116 = icmp ult i32 %13, 4
%117 = and i64 %80, 4294967292
%118 = and i64 %95, 1
%119 = icmp eq i64 %93, 0
%120 = and i64 %95, 9223372036854775806
%121 = icmp eq i64 %118, 0
%122 = icmp eq i64 %117, %80
%123 = and i64 %80, 1
%124 = icmp eq i64 %123, 0
%125 = sub nsw i64 0, %80
%126 = icmp ult i32 %13, 4
%127 = and i64 %80, 4294967292
%128 = and i64 %95, 1
%129 = icmp eq i64 %93, 0
%130 = and i64 %95, 9223372036854775806
%131 = icmp eq i64 %128, 0
%132 = icmp eq i64 %127, %80
%133 = and i64 %80, 1
%134 = icmp eq i64 %133, 0
%135 = sub nsw i64 0, %80
br label %170
136: ; preds = %68, %167
%137 = phi i64 [ 0, %68 ], [ %168, %167 ]
%138 = mul nsw i64 %137, %70
%139 = getelementptr inbounds double, double* %5, i64 %138
br i1 %69, label %140, label %167
140: ; preds = %136
%141 = mul nsw i64 %137, %72
br label %142
142: ; preds = %164, %140
%143 = phi i64 [ 0, %140 ], [ %165, %164 ]
%144 = add nsw i64 %143, %141
%145 = getelementptr inbounds double, double* %64, i64 %144
store double 0.000000e+00, double* %145
%146 = getelementptr inbounds double, double* %66, i64 %144
store double 0.000000e+00, double* %146
%147 = mul nsw i64 %143, %70
br label %148
148: ; preds = %142, %148
%149 = phi i64 [ 0, %142 ], [ %162, %148 ]
%150 = getelementptr inbounds double, double* %139, i64 %149
%151 = load double, double* %150
%152 = add nsw i64 %149, %147
%153 = getelementptr inbounds double, double* %9, i64 %152
%154 = load double, double* %153
%155 = load double, double* %145
%156 = tail call double @llvm.fmuladd.f64(double %151, double %154, double %155)
store double %156, double* %145
%157 = load double, double* %150
%158 = getelementptr inbounds double, double* %10, i64 %152
%159 = load double, double* %158
%160 = load double, double* %146
%161 = tail call double @llvm.fmuladd.f64(double %157, double %159, double %160)
store double %161, double* %146
%162 = add nuw nsw i64 %149, 1
%163 = icmp eq i64 %162, %75
br i1 %163, label %164, label %148
164: ; preds = %148
%165 = add nuw nsw i64 %143, 1
%166 = icmp eq i64 %165, %74
br i1 %166, label %167, label %142
167: ; preds = %164, %136
%168 = add nuw nsw i64 %137, 1
%169 = icmp eq i64 %168, %73
br i1 %169, label %76, label %136
170: ; preds = %78, %706
%171 = phi i64 [ 0, %78 ], [ %707, %706 ]
%172 = mul i64 %171, %83
%173 = getelementptr double, double* %3, i64 %172
%174 = add i64 %172, %80
%175 = getelementptr double, double* %3, i64 %174
%176 = mul i64 %171, %83
%177 = add i64 %176, %82
%178 = getelementptr double, double* %3, i64 %177
%179 = add i64 %91, %176
%180 = getelementptr double, double* %3, i64 %179
%181 = mul i64 %171, %83
%182 = add i64 %85, %181
%183 = getelementptr double, double* %3, i64 %182
%184 = add i64 %90, %181
%185 = getelementptr double, double* %3, i64 %184
%186 = mul i64 %171, %83
%187 = add i64 %87, %186
%188 = getelementptr double, double* %3, i64 %187
%189 = add i64 %89, %186
%190 = getelementptr double, double* %3, i64 %189
%191 = trunc i64 %171 to i32
%192 = mul i32 %17, %191
%193 = getelementptr inbounds i8, i8* %6, i64 %171
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = mul nsw i32 %17, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %64, i64 %197
%199 = getelementptr inbounds i8, i8* %7, i64 %171
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = mul nsw i32 %17, %201
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %66, i64 %203
%205 = mul nsw i64 %171, %83
%206 = getelementptr inbounds double, double* %3, i64 %205
br i1 %79, label %207, label %706
207: ; preds = %170
%208 = sext i32 %192 to i64
%209 = getelementptr double, double* %3, i64 %208
%210 = bitcast double* %209 to i8*
br label %211
211: ; preds = %325, %207
%212 = phi i64 [ 0, %207 ], [ %326, %325 ]
%213 = mul i64 %212, %82
%214 = getelementptr inbounds double, double* %198, i64 %212
%215 = load double, double* %214
%216 = getelementptr inbounds double, double* %204, i64 %212
%217 = load double, double* %216
%218 = fmul double %215, %217
%219 = mul nsw i64 %212, %82
br i1 %96, label %294, label %220
220: ; preds = %211
%221 = add i64 %213, %80
%222 = getelementptr double, double* %4, i64 %221
%223 = getelementptr double, double* %4, i64 %213
%224 = icmp ult double* %173, %222
%225 = icmp ult double* %223, %175
%226 = and i1 %224, %225
br i1 %226, label %294, label %227
227: ; preds = %220
%228 = insertelement <2 x double> poison, double %218, i64 0
%229 = shufflevector <2 x double> %228, <2 x double> poison, <2 x i32> zeroinitializer
%230 = insertelement <2 x double> poison, double %218, i64 0
%231 = shufflevector <2 x double> %230, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %99, label %273, label %232
232: ; preds = %227, %232
%233 = phi i64 [ %270, %232 ], [ 0, %227 ]
%234 = phi i64 [ %271, %232 ], [ 0, %227 ]
%235 = add nsw i64 %233, %219
%236 = getelementptr inbounds double, double* %4, i64 %235
%237 = bitcast double* %236 to <2 x double>*
%238 = load <2 x double>, <2 x double>* %237
%239 = getelementptr inbounds double, double* %236, i64 2
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr inbounds double, double* %206, i64 %233
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = getelementptr inbounds double, double* %242, i64 2
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %229, <2 x double> %238, <2 x double> %244)
%249 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %241, <2 x double> %247)
%250 = bitcast double* %242 to <2 x double>*
store <2 x double> %248, <2 x double>* %250
%251 = bitcast double* %245 to <2 x double>*
store <2 x double> %249, <2 x double>* %251
%252 = or i64 %233, 4
%253 = add nsw i64 %252, %219
%254 = getelementptr inbounds double, double* %4, i64 %253
%255 = bitcast double* %254 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = getelementptr inbounds double, double* %254, i64 2
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = getelementptr inbounds double, double* %206, i64 %252
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %260, i64 2
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %229, <2 x double> %256, <2 x double> %262)
%267 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %259, <2 x double> %265)
%268 = bitcast double* %260 to <2 x double>*
store <2 x double> %266, <2 x double>* %268
%269 = bitcast double* %263 to <2 x double>*
store <2 x double> %267, <2 x double>* %269
%270 = add nuw i64 %233, 8
%271 = add i64 %234, 2
%272 = icmp eq i64 %271, %100
br i1 %272, label %273, label %232
273: ; preds = %232, %227
%274 = phi i64 [ 0, %227 ], [ %270, %232 ]
br i1 %101, label %293, label %275
275: ; preds = %273
%276 = add nsw i64 %274, %219
%277 = getelementptr inbounds double, double* %4, i64 %276
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = getelementptr inbounds double, double* %277, i64 2
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr inbounds double, double* %206, i64 %274
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %283, i64 2
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %229, <2 x double> %279, <2 x double> %285)
%290 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %231, <2 x double> %282, <2 x double> %288)
%291 = bitcast double* %283 to <2 x double>*
store <2 x double> %289, <2 x double>* %291
%292 = bitcast double* %286 to <2 x double>*
store <2 x double> %290, <2 x double>* %292
br label %293
293: ; preds = %273, %275
br i1 %102, label %325, label %294
294: ; preds = %220, %211, %293
%295 = phi i64 [ 0, %220 ], [ 0, %211 ], [ %97, %293 ]
%296 = xor i64 %295, -1
br i1 %104, label %305, label %297
297: ; preds = %294
%298 = add nsw i64 %295, %219
%299 = getelementptr inbounds double, double* %4, i64 %298
%300 = load double, double* %299
%301 = getelementptr inbounds double, double* %206, i64 %295
%302 = load double, double* %301
%303 = tail call double @llvm.fmuladd.f64(double %218, double %300, double %302)
store double %303, double* %301
%304 = or i64 %295, 1
br label %305
305: ; preds = %297, %294
%306 = phi i64 [ %295, %294 ], [ %304, %297 ]
%307 = icmp eq i64 %296, %105
br i1 %307, label %325, label %308
308: ; preds = %305, %308
%309 = phi i64 [ %323, %308 ], [ %306, %305 ]
%310 = add nsw i64 %309, %219
%311 = getelementptr inbounds double, double* %4, i64 %310
%312 = load double, double* %311
%313 = getelementptr inbounds double, double* %206, i64 %309
%314 = load double, double* %313
%315 = tail call double @llvm.fmuladd.f64(double %218, double %312, double %314)
store double %315, double* %313
%316 = add nuw nsw i64 %309, 1
%317 = add nsw i64 %316, %219
%318 = getelementptr inbounds double, double* %4, i64 %317
%319 = load double, double* %318
%320 = getelementptr inbounds double, double* %206, i64 %316
%321 = load double, double* %320
%322 = tail call double @llvm.fmuladd.f64(double %218, double %319, double %321)
store double %322, double* %320
%323 = add nuw nsw i64 %309, 2
%324 = icmp eq i64 %323, %80
br i1 %324, label %325, label %308
325: ; preds = %305, %308, %293
%326 = add nuw nsw i64 %212, 1
%327 = icmp eq i64 %326, %80
br i1 %327, label %328, label %211
328: ; preds = %325
%329 = add nsw i64 %205, %82
%330 = getelementptr inbounds double, double* %3, i64 %329
br i1 %79, label %331, label %706
331: ; preds = %328
%332 = add i32 %192, %13
%333 = sext i32 %332 to i64
%334 = getelementptr double, double* %3, i64 %333
%335 = bitcast double* %334 to i8*
br label %336
336: ; preds = %331, %451
%337 = phi i64 [ 0, %331 ], [ %452, %451 ]
%338 = mul i64 %337, %82
%339 = add nsw i64 %337, %82
%340 = getelementptr inbounds double, double* %198, i64 %339
%341 = load double, double* %340
%342 = getelementptr inbounds double, double* %204, i64 %339
%343 = load double, double* %342
%344 = fmul double %341, %343
%345 = mul nsw i64 %337, %82
br i1 %106, label %420, label %346
346: ; preds = %336
%347 = add i64 %338, %80
%348 = getelementptr double, double* %4, i64 %347
%349 = getelementptr double, double* %4, i64 %338
%350 = icmp ult double* %178, %348
%351 = icmp ult double* %349, %180
%352 = and i1 %350, %351
br i1 %352, label %420, label %353
353: ; preds = %346
%354 = insertelement <2 x double> poison, double %344, i64 0
%355 = shufflevector <2 x double> %354, <2 x double> poison, <2 x i32> zeroinitializer
%356 = insertelement <2 x double> poison, double %344, i64 0
%357 = shufflevector <2 x double> %356, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %109, label %399, label %358
358: ; preds = %353, %358
%359 = phi i64 [ %396, %358 ], [ 0, %353 ]
%360 = phi i64 [ %397, %358 ], [ 0, %353 ]
%361 = add nsw i64 %359, %345
%362 = getelementptr inbounds double, double* %4, i64 %361
%363 = bitcast double* %362 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = getelementptr inbounds double, double* %362, i64 2
%366 = bitcast double* %365 to <2 x double>*
%367 = load <2 x double>, <2 x double>* %366
%368 = getelementptr inbounds double, double* %330, i64 %359
%369 = bitcast double* %368 to <2 x double>*
%370 = load <2 x double>, <2 x double>* %369
%371 = getelementptr inbounds double, double* %368, i64 2
%372 = bitcast double* %371 to <2 x double>*
%373 = load <2 x double>, <2 x double>* %372
%374 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %355, <2 x double> %364, <2 x double> %370)
%375 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %357, <2 x double> %367, <2 x double> %373)
%376 = bitcast double* %368 to <2 x double>*
store <2 x double> %374, <2 x double>* %376
%377 = bitcast double* %371 to <2 x double>*
store <2 x double> %375, <2 x double>* %377
%378 = or i64 %359, 4
%379 = add nsw i64 %378, %345
%380 = getelementptr inbounds double, double* %4, i64 %379
%381 = bitcast double* %380 to <2 x double>*
%382 = load <2 x double>, <2 x double>* %381
%383 = getelementptr inbounds double, double* %380, i64 2
%384 = bitcast double* %383 to <2 x double>*
%385 = load <2 x double>, <2 x double>* %384
%386 = getelementptr inbounds double, double* %330, i64 %378
%387 = bitcast double* %386 to <2 x double>*
%388 = load <2 x double>, <2 x double>* %387
%389 = getelementptr inbounds double, double* %386, i64 2
%390 = bitcast double* %389 to <2 x double>*
%391 = load <2 x double>, <2 x double>* %390
%392 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %355, <2 x double> %382, <2 x double> %388)
%393 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %357, <2 x double> %385, <2 x double> %391)
%394 = bitcast double* %386 to <2 x double>*
store <2 x double> %392, <2 x double>* %394
%395 = bitcast double* %389 to <2 x double>*
store <2 x double> %393, <2 x double>* %395
%396 = add nuw i64 %359, 8
%397 = add i64 %360, 2
%398 = icmp eq i64 %397, %110
br i1 %398, label %399, label %358
399: ; preds = %358, %353
%400 = phi i64 [ 0, %353 ], [ %396, %358 ]
br i1 %111, label %419, label %401
401: ; preds = %399
%402 = add nsw i64 %400, %345
%403 = getelementptr inbounds double, double* %4, i64 %402
%404 = bitcast double* %403 to <2 x double>*
%405 = load <2 x double>, <2 x double>* %404
%406 = getelementptr inbounds double, double* %403, i64 2
%407 = bitcast double* %406 to <2 x double>*
%408 = load <2 x double>, <2 x double>* %407
%409 = getelementptr inbounds double, double* %330, i64 %400
%410 = bitcast double* %409 to <2 x double>*
%411 = load <2 x double>, <2 x double>* %410
%412 = getelementptr inbounds double, double* %409, i64 2
%413 = bitcast double* %412 to <2 x double>*
%414 = load <2 x double>, <2 x double>* %413
%415 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %355, <2 x double> %405, <2 x double> %411)
%416 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %357, <2 x double> %408, <2 x double> %414)
%417 = bitcast double* %409 to <2 x double>*
store <2 x double> %415, <2 x double>* %417
%418 = bitcast double* %412 to <2 x double>*
store <2 x double> %416, <2 x double>* %418
br label %419
419: ; preds = %399, %401
br i1 %112, label %451, label %420
420: ; preds = %346, %336, %419
%421 = phi i64 [ 0, %346 ], [ 0, %336 ], [ %107, %419 ]
%422 = xor i64 %421, -1
br i1 %114, label %431, label %423
423: ; preds = %420
%424 = add nsw i64 %421, %345
%425 = getelementptr inbounds double, double* %4, i64 %424
%426 = load double, double* %425
%427 = getelementptr inbounds double, double* %330, i64 %421
%428 = load double, double* %427
%429 = tail call double @llvm.fmuladd.f64(double %344, double %426, double %428)
store double %429, double* %427
%430 = or i64 %421, 1
br label %431
431: ; preds = %423, %420
%432 = phi i64 [ %421, %420 ], [ %430, %423 ]
%433 = icmp eq i64 %422, %115
br i1 %433, label %451, label %434
434: ; preds = %431, %434
%435 = phi i64 [ %449, %434 ], [ %432, %431 ]
%436 = add nsw i64 %435, %345
%437 = getelementptr inbounds double, double* %4, i64 %436
%438 = load double, double* %437
%439 = getelementptr inbounds double, double* %330, i64 %435
%440 = load double, double* %439
%441 = tail call double @llvm.fmuladd.f64(double %344, double %438, double %440)
store double %441, double* %439
%442 = add nuw nsw i64 %435, 1
%443 = add nsw i64 %442, %345
%444 = getelementptr inbounds double, double* %4, i64 %443
%445 = load double, double* %444
%446 = getelementptr inbounds double, double* %330, i64 %442
%447 = load double, double* %446
%448 = tail call double @llvm.fmuladd.f64(double %344, double %445, double %447)
store double %448, double* %446
%449 = add nuw nsw i64 %435, 2
%450 = icmp eq i64 %449, %80
br i1 %450, label %451, label %434
451: ; preds = %431, %434, %419
%452 = add nuw nsw i64 %337, 1
%453 = icmp eq i64 %452, %80
br i1 %453, label %454, label %336
454: ; preds = %451
%455 = add nsw i64 %85, %205
%456 = getelementptr inbounds double, double* %3, i64 %455
br i1 %79, label %457, label %706
457: ; preds = %454
%458 = add i32 %192, %86
%459 = sext i32 %458 to i64
%460 = getelementptr double, double* %3, i64 %459
%461 = bitcast double* %460 to i8*
br label %462
462: ; preds = %457, %577
%463 = phi i64 [ 0, %457 ], [ %578, %577 ]
%464 = mul i64 %463, %82
%465 = add nsw i64 %463, %85
%466 = getelementptr inbounds double, double* %198, i64 %465
%467 = load double, double* %466
%468 = getelementptr inbounds double, double* %204, i64 %465
%469 = load double, double* %468
%470 = fmul double %467, %469
%471 = mul nsw i64 %463, %82
br i1 %116, label %546, label %472
472: ; preds = %462
%473 = add i64 %464, %80
%474 = getelementptr double, double* %4, i64 %473
%475 = getelementptr double, double* %4, i64 %464
%476 = icmp ult double* %183, %474
%477 = icmp ult double* %475, %185
%478 = and i1 %476, %477
br i1 %478, label %546, label %479
479: ; preds = %472
%480 = insertelement <2 x double> poison, double %470, i64 0
%481 = shufflevector <2 x double> %480, <2 x double> poison, <2 x i32> zeroinitializer
%482 = insertelement <2 x double> poison, double %470, i64 0
%483 = shufflevector <2 x double> %482, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %119, label %525, label %484
484: ; preds = %479, %484
%485 = phi i64 [ %522, %484 ], [ 0, %479 ]
%486 = phi i64 [ %523, %484 ], [ 0, %479 ]
%487 = add nsw i64 %485, %471
%488 = getelementptr inbounds double, double* %4, i64 %487
%489 = bitcast double* %488 to <2 x double>*
%490 = load <2 x double>, <2 x double>* %489
%491 = getelementptr inbounds double, double* %488, i64 2
%492 = bitcast double* %491 to <2 x double>*
%493 = load <2 x double>, <2 x double>* %492
%494 = getelementptr inbounds double, double* %456, i64 %485
%495 = bitcast double* %494 to <2 x double>*
%496 = load <2 x double>, <2 x double>* %495
%497 = getelementptr inbounds double, double* %494, i64 2
%498 = bitcast double* %497 to <2 x double>*
%499 = load <2 x double>, <2 x double>* %498
%500 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %481, <2 x double> %490, <2 x double> %496)
%501 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %483, <2 x double> %493, <2 x double> %499)
%502 = bitcast double* %494 to <2 x double>*
store <2 x double> %500, <2 x double>* %502
%503 = bitcast double* %497 to <2 x double>*
store <2 x double> %501, <2 x double>* %503
%504 = or i64 %485, 4
%505 = add nsw i64 %504, %471
%506 = getelementptr inbounds double, double* %4, i64 %505
%507 = bitcast double* %506 to <2 x double>*
%508 = load <2 x double>, <2 x double>* %507
%509 = getelementptr inbounds double, double* %506, i64 2
%510 = bitcast double* %509 to <2 x double>*
%511 = load <2 x double>, <2 x double>* %510
%512 = getelementptr inbounds double, double* %456, i64 %504
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = getelementptr inbounds double, double* %512, i64 2
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %481, <2 x double> %508, <2 x double> %514)
%519 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %483, <2 x double> %511, <2 x double> %517)
%520 = bitcast double* %512 to <2 x double>*
store <2 x double> %518, <2 x double>* %520
%521 = bitcast double* %515 to <2 x double>*
store <2 x double> %519, <2 x double>* %521
%522 = add nuw i64 %485, 8
%523 = add i64 %486, 2
%524 = icmp eq i64 %523, %120
br i1 %524, label %525, label %484
525: ; preds = %484, %479
%526 = phi i64 [ 0, %479 ], [ %522, %484 ]
br i1 %121, label %545, label %527
527: ; preds = %525
%528 = add nsw i64 %526, %471
%529 = getelementptr inbounds double, double* %4, i64 %528
%530 = bitcast double* %529 to <2 x double>*
%531 = load <2 x double>, <2 x double>* %530
%532 = getelementptr inbounds double, double* %529, i64 2
%533 = bitcast double* %532 to <2 x double>*
%534 = load <2 x double>, <2 x double>* %533
%535 = getelementptr inbounds double, double* %456, i64 %526
%536 = bitcast double* %535 to <2 x double>*
%537 = load <2 x double>, <2 x double>* %536
%538 = getelementptr inbounds double, double* %535, i64 2
%539 = bitcast double* %538 to <2 x double>*
%540 = load <2 x double>, <2 x double>* %539
%541 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %481, <2 x double> %531, <2 x double> %537)
%542 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %483, <2 x double> %534, <2 x double> %540)
%543 = bitcast double* %535 to <2 x double>*
store <2 x double> %541, <2 x double>* %543
%544 = bitcast double* %538 to <2 x double>*
store <2 x double> %542, <2 x double>* %544
br label %545
545: ; preds = %525, %527
br i1 %122, label %577, label %546
546: ; preds = %472, %462, %545
%547 = phi i64 [ 0, %472 ], [ 0, %462 ], [ %117, %545 ]
%548 = xor i64 %547, -1
br i1 %124, label %557, label %549
549: ; preds = %546
%550 = add nsw i64 %547, %471
%551 = getelementptr inbounds double, double* %4, i64 %550
%552 = load double, double* %551
%553 = getelementptr inbounds double, double* %456, i64 %547
%554 = load double, double* %553
%555 = tail call double @llvm.fmuladd.f64(double %470, double %552, double %554)
store double %555, double* %553
%556 = or i64 %547, 1
br label %557
557: ; preds = %549, %546
%558 = phi i64 [ %547, %546 ], [ %556, %549 ]
%559 = icmp eq i64 %548, %125
br i1 %559, label %577, label %560
560: ; preds = %557, %560
%561 = phi i64 [ %575, %560 ], [ %558, %557 ]
%562 = add nsw i64 %561, %471
%563 = getelementptr inbounds double, double* %4, i64 %562
%564 = load double, double* %563
%565 = getelementptr inbounds double, double* %456, i64 %561
%566 = load double, double* %565
%567 = tail call double @llvm.fmuladd.f64(double %470, double %564, double %566)
store double %567, double* %565
%568 = add nuw nsw i64 %561, 1
%569 = add nsw i64 %568, %471
%570 = getelementptr inbounds double, double* %4, i64 %569
%571 = load double, double* %570
%572 = getelementptr inbounds double, double* %456, i64 %568
%573 = load double, double* %572
%574 = tail call double @llvm.fmuladd.f64(double %470, double %571, double %573)
store double %574, double* %572
%575 = add nuw nsw i64 %561, 2
%576 = icmp eq i64 %575, %80
br i1 %576, label %577, label %560
577: ; preds = %557, %560, %545
%578 = add nuw nsw i64 %463, 1
%579 = icmp eq i64 %578, %80
br i1 %579, label %580, label %462
580: ; preds = %577
%581 = add nsw i64 %87, %205
%582 = getelementptr inbounds double, double* %3, i64 %581
br i1 %79, label %583, label %706
583: ; preds = %580
%584 = add i32 %192, %88
%585 = sext i32 %584 to i64
%586 = getelementptr double, double* %3, i64 %585
%587 = bitcast double* %586 to i8*
br label %588
588: ; preds = %583, %703
%589 = phi i64 [ 0, %583 ], [ %704, %703 ]
%590 = mul i64 %589, %82
%591 = add nsw i64 %589, %87
%592 = getelementptr inbounds double, double* %198, i64 %591
%593 = load double, double* %592
%594 = getelementptr inbounds double, double* %204, i64 %591
%595 = load double, double* %594
%596 = fmul double %593, %595
%597 = mul nsw i64 %589, %82
br i1 %126, label %672, label %598
598: ; preds = %588
%599 = add i64 %590, %80
%600 = getelementptr double, double* %4, i64 %599
%601 = getelementptr double, double* %4, i64 %590
%602 = icmp ult double* %188, %600
%603 = icmp ult double* %601, %190
%604 = and i1 %602, %603
br i1 %604, label %672, label %605
605: ; preds = %598
%606 = insertelement <2 x double> poison, double %596, i64 0
%607 = shufflevector <2 x double> %606, <2 x double> poison, <2 x i32> zeroinitializer
%608 = insertelement <2 x double> poison, double %596, i64 0
%609 = shufflevector <2 x double> %608, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %129, label %651, label %610
610: ; preds = %605, %610
%611 = phi i64 [ %648, %610 ], [ 0, %605 ]
%612 = phi i64 [ %649, %610 ], [ 0, %605 ]
%613 = add nsw i64 %611, %597
%614 = getelementptr inbounds double, double* %4, i64 %613
%615 = bitcast double* %614 to <2 x double>*
%616 = load <2 x double>, <2 x double>* %615
%617 = getelementptr inbounds double, double* %614, i64 2
%618 = bitcast double* %617 to <2 x double>*
%619 = load <2 x double>, <2 x double>* %618
%620 = getelementptr inbounds double, double* %582, i64 %611
%621 = bitcast double* %620 to <2 x double>*
%622 = load <2 x double>, <2 x double>* %621
%623 = getelementptr inbounds double, double* %620, i64 2
%624 = bitcast double* %623 to <2 x double>*
%625 = load <2 x double>, <2 x double>* %624
%626 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %607, <2 x double> %616, <2 x double> %622)
%627 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %609, <2 x double> %619, <2 x double> %625)
%628 = bitcast double* %620 to <2 x double>*
store <2 x double> %626, <2 x double>* %628
%629 = bitcast double* %623 to <2 x double>*
store <2 x double> %627, <2 x double>* %629
%630 = or i64 %611, 4
%631 = add nsw i64 %630, %597
%632 = getelementptr inbounds double, double* %4, i64 %631
%633 = bitcast double* %632 to <2 x double>*
%634 = load <2 x double>, <2 x double>* %633
%635 = getelementptr inbounds double, double* %632, i64 2
%636 = bitcast double* %635 to <2 x double>*
%637 = load <2 x double>, <2 x double>* %636
%638 = getelementptr inbounds double, double* %582, i64 %630
%639 = bitcast double* %638 to <2 x double>*
%640 = load <2 x double>, <2 x double>* %639
%641 = getelementptr inbounds double, double* %638, i64 2
%642 = bitcast double* %641 to <2 x double>*
%643 = load <2 x double>, <2 x double>* %642
%644 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %607, <2 x double> %634, <2 x double> %640)
%645 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %609, <2 x double> %637, <2 x double> %643)
%646 = bitcast double* %638 to <2 x double>*
store <2 x double> %644, <2 x double>* %646
%647 = bitcast double* %641 to <2 x double>*
store <2 x double> %645, <2 x double>* %647
%648 = add nuw i64 %611, 8
%649 = add i64 %612, 2
%650 = icmp eq i64 %649, %130
br i1 %650, label %651, label %610
651: ; preds = %610, %605
%652 = phi i64 [ 0, %605 ], [ %648, %610 ]
br i1 %131, label %671, label %653
653: ; preds = %651
%654 = add nsw i64 %652, %597
%655 = getelementptr inbounds double, double* %4, i64 %654
%656 = bitcast double* %655 to <2 x double>*
%657 = load <2 x double>, <2 x double>* %656
%658 = getelementptr inbounds double, double* %655, i64 2
%659 = bitcast double* %658 to <2 x double>*
%660 = load <2 x double>, <2 x double>* %659
%661 = getelementptr inbounds double, double* %582, i64 %652
%662 = bitcast double* %661 to <2 x double>*
%663 = load <2 x double>, <2 x double>* %662
%664 = getelementptr inbounds double, double* %661, i64 2
%665 = bitcast double* %664 to <2 x double>*
%666 = load <2 x double>, <2 x double>* %665
%667 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %607, <2 x double> %657, <2 x double> %663)
%668 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %609, <2 x double> %660, <2 x double> %666)
%669 = bitcast double* %661 to <2 x double>*
store <2 x double> %667, <2 x double>* %669
%670 = bitcast double* %664 to <2 x double>*
store <2 x double> %668, <2 x double>* %670
br label %671
671: ; preds = %651, %653
br i1 %132, label %703, label %672
672: ; preds = %598, %588, %671
%673 = phi i64 [ 0, %598 ], [ 0, %588 ], [ %127, %671 ]
%674 = xor i64 %673, -1
br i1 %134, label %683, label %675
675: ; preds = %672
%676 = add nsw i64 %673, %597
%677 = getelementptr inbounds double, double* %4, i64 %676
%678 = load double, double* %677
%679 = getelementptr inbounds double, double* %582, i64 %673
%680 = load double, double* %679
%681 = tail call double @llvm.fmuladd.f64(double %596, double %678, double %680)
store double %681, double* %679
%682 = or i64 %673, 1
br label %683
683: ; preds = %675, %672
%684 = phi i64 [ %673, %672 ], [ %682, %675 ]
%685 = icmp eq i64 %674, %135
br i1 %685, label %703, label %686
686: ; preds = %683, %686
%687 = phi i64 [ %701, %686 ], [ %684, %683 ]
%688 = add nsw i64 %687, %597
%689 = getelementptr inbounds double, double* %4, i64 %688
%690 = load double, double* %689
%691 = getelementptr inbounds double, double* %582, i64 %687
%692 = load double, double* %691
%693 = tail call double @llvm.fmuladd.f64(double %596, double %690, double %692)
store double %693, double* %691
%694 = add nuw nsw i64 %687, 1
%695 = add nsw i64 %694, %597
%696 = getelementptr inbounds double, double* %4, i64 %695
%697 = load double, double* %696
%698 = getelementptr inbounds double, double* %582, i64 %694
%699 = load double, double* %698
%700 = tail call double @llvm.fmuladd.f64(double %596, double %697, double %699)
store double %700, double* %698
%701 = add nuw nsw i64 %687, 2
%702 = icmp eq i64 %701, %80
br i1 %702, label %703, label %686
703: ; preds = %683, %686, %671
%704 = add nuw nsw i64 %589, 1
%705 = icmp eq i64 %704, %80
br i1 %705, label %706, label %588
706: ; preds = %703, %454, %170, %328, %580
%707 = add nuw nsw i64 %171, 1
%708 = icmp eq i64 %707, %84
br i1 %708, label %709, label %170
709: ; preds = %706, %76
%710 = tail call i32 @free(double* %64)
%711 = tail call i32 @free(double* %66)
br label %1372
712: ; preds = %15
%713 = shl i32 %18, 3
%714 = tail call i64 @malloc(i32 %713)
%715 = inttoptr i64 %714 to double*
%716 = shl i32 %13, 3
%717 = tail call i64 @malloc(i32 %716)
%718 = inttoptr i64 %717 to double*
%719 = icmp sgt i32 %14, 0
br i1 %719, label %720, label %732
720: ; preds = %712
%721 = icmp sgt i32 %13, 0
%722 = sext i32 %13 to i64
%723 = call i32 @llvm.smax.i32(i32 %17, i32 1)
%724 = sext i32 %17 to i64
%725 = zext i32 %14 to i64
%726 = zext i32 %723 to i64
%727 = zext i32 %13 to i64
%728 = and i64 %727, 1
%729 = icmp eq i32 %13, 1
%730 = and i64 %727, 4294967294
%731 = icmp eq i64 %728, 0
br label %774
732: ; preds = %818, %712
%733 = icmp sgt i32 %8, 0
br i1 %733, label %734, label %1089
734: ; preds = %732
%735 = icmp sgt i32 %13, 0
%736 = sext i32 %13 to i64
%737 = zext i32 %13 to i64
%738 = shl nuw nsw i64 %737, 3
%739 = zext i32 %16 to i64
%740 = sext i32 %17 to i64
%741 = call i32 @llvm.smax.i32(i32 %17, i32 1)
%742 = zext i32 %8 to i64
%743 = zext i32 %741 to i64
%744 = getelementptr double, double* %3, i64 %737
%745 = and i64 %737, 4294967292
%746 = add nsw i64 %745, -4
%747 = lshr exact i64 %746, 2
%748 = add nuw nsw i64 %747, 1
%749 = and i64 %743, 2147483644
%750 = add nsw i64 %749, -4
%751 = lshr exact i64 %750, 2
%752 = add nuw nsw i64 %751, 1
%753 = and i64 %737, 1
%754 = icmp eq i32 %13, 1
%755 = and i64 %737, 4294967294
%756 = icmp eq i64 %753, 0
%757 = icmp ult i32 %13, 4
%758 = and i64 %737, 4294967292
%759 = and i64 %748, 1
%760 = icmp eq i64 %746, 0
%761 = and i64 %748, 9223372036854775806
%762 = icmp eq i64 %759, 0
%763 = icmp eq i64 %758, %737
%764 = and i64 %737, 1
%765 = icmp eq i64 %764, 0
%766 = sub nsw i64 0, %737
%767 = icmp ult i32 %741, 4
%768 = and i64 %743, 2147483644
%769 = and i64 %752, 1
%770 = icmp eq i64 %750, 0
%771 = and i64 %752, 9223372036854775806
%772 = icmp eq i64 %769, 0
%773 = icmp eq i64 %768, %743
br label %821
774: ; preds = %720, %818
%775 = phi i64 [ 0, %720 ], [ %819, %818 ]
%776 = mul nsw i64 %775, %722
%777 = getelementptr inbounds double, double* %5, i64 %776
br i1 %721, label %778, label %818
778: ; preds = %774
%779 = mul nsw i64 %775, %724
br label %780
780: ; preds = %815, %778
%781 = phi i64 [ 0, %778 ], [ %816, %815 ]
%782 = add nsw i64 %781, %779
%783 = getelementptr inbounds double, double* %715, i64 %782
store double 0.000000e+00, double* %783
%784 = mul nsw i64 %781, %722
br i1 %729, label %805, label %785
785: ; preds = %780, %785
%786 = phi double [ %801, %785 ], [ 0.000000e+00, %780 ]
%787 = phi i64 [ %802, %785 ], [ 0, %780 ]
%788 = phi i64 [ %803, %785 ], [ 0, %780 ]
%789 = getelementptr inbounds double, double* %777, i64 %787
%790 = load double, double* %789
%791 = add nsw i64 %787, %784
%792 = getelementptr inbounds double, double* %9, i64 %791
%793 = load double, double* %792
%794 = tail call double @llvm.fmuladd.f64(double %790, double %793, double %786)
store double %794, double* %783
%795 = or i64 %787, 1
%796 = getelementptr inbounds double, double* %777, i64 %795
%797 = load double, double* %796
%798 = add nsw i64 %795, %784
%799 = getelementptr inbounds double, double* %9, i64 %798
%800 = load double, double* %799
%801 = tail call double @llvm.fmuladd.f64(double %797, double %800, double %794)
store double %801, double* %783
%802 = add nuw nsw i64 %787, 2
%803 = add i64 %788, 2
%804 = icmp eq i64 %803, %730
br i1 %804, label %805, label %785
805: ; preds = %785, %780
%806 = phi double [ 0.000000e+00, %780 ], [ %801, %785 ]
%807 = phi i64 [ 0, %780 ], [ %802, %785 ]
br i1 %731, label %815, label %808
808: ; preds = %805
%809 = getelementptr inbounds double, double* %777, i64 %807
%810 = load double, double* %809
%811 = add nsw i64 %807, %784
%812 = getelementptr inbounds double, double* %9, i64 %811
%813 = load double, double* %812
%814 = tail call double @llvm.fmuladd.f64(double %810, double %813, double %806)
store double %814, double* %783
br label %815
815: ; preds = %805, %808
%816 = add nuw nsw i64 %781, 1
%817 = icmp eq i64 %816, %726
br i1 %817, label %818, label %780
818: ; preds = %815, %774
%819 = add nuw nsw i64 %775, 1
%820 = icmp eq i64 %819, %725
br i1 %820, label %732, label %774
821: ; preds = %734, %1085
%822 = phi i64 [ 0, %734 ], [ %1087, %1085 ]
%823 = phi i32 [ 0, %734 ], [ %1086, %1085 ]
%824 = trunc i64 %822 to i32
%825 = mul i32 %17, %824
%826 = getelementptr inbounds i8, i8* %6, i64 %822
%827 = load i8, i8* %826
%828 = zext i8 %827 to i32
%829 = mul nsw i32 %17, %828
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds double, double* %715, i64 %830
%832 = mul nsw i64 %822, %740
br label %833
833: ; preds = %1009, %821
%834 = phi i64 [ 0, %821 ], [ %1010, %1009 ]
%835 = trunc i64 %834 to i32
%836 = mul i32 %835, %13
%837 = add i32 %825, %836
%838 = sext i32 %837 to i64
%839 = getelementptr double, double* %3, i64 %838
%840 = bitcast double* %839 to i8*
%841 = mul nsw i64 %834, %736
%842 = add i64 %841, %832
%843 = getelementptr inbounds double, double* %2, i64 %842
br i1 %735, label %844, label %1011
844: ; preds = %833
%845 = mul nsw i64 %834, %739
br label %846
846: ; preds = %881, %844
%847 = phi i64 [ 0, %844 ], [ %882, %881 ]
%848 = getelementptr inbounds double, double* %718, i64 %847
store double 0.000000e+00, double* %848
%849 = mul nsw i64 %847, %736
%850 = add nsw i64 %849, %845
br i1 %754, label %871, label %851
851: ; preds = %846, %851
%852 = phi double [ %867, %851 ], [ 0.000000e+00, %846 ]
%853 = phi i64 [ %868, %851 ], [ 0, %846 ]
%854 = phi i64 [ %869, %851 ], [ 0, %846 ]
%855 = getelementptr inbounds double, double* %843, i64 %853
%856 = load double, double* %855
%857 = add nsw i64 %850, %853
%858 = getelementptr inbounds double, double* %10, i64 %857
%859 = load double, double* %858
%860 = tail call double @llvm.fmuladd.f64(double %856, double %859, double %852)
store double %860, double* %848
%861 = or i64 %853, 1
%862 = getelementptr inbounds double, double* %843, i64 %861
%863 = load double, double* %862
%864 = add nsw i64 %850, %861
%865 = getelementptr inbounds double, double* %10, i64 %864
%866 = load double, double* %865
%867 = tail call double @llvm.fmuladd.f64(double %863, double %866, double %860)
store double %867, double* %848
%868 = add nuw nsw i64 %853, 2
%869 = add i64 %854, 2
%870 = icmp eq i64 %869, %755
br i1 %870, label %871, label %851
871: ; preds = %851, %846
%872 = phi double [ 0.000000e+00, %846 ], [ %867, %851 ]
%873 = phi i64 [ 0, %846 ], [ %868, %851 ]
br i1 %756, label %881, label %874
874: ; preds = %871
%875 = getelementptr inbounds double, double* %843, i64 %873
%876 = load double, double* %875
%877 = add nsw i64 %850, %873
%878 = getelementptr inbounds double, double* %10, i64 %877
%879 = load double, double* %878
%880 = tail call double @llvm.fmuladd.f64(double %876, double %879, double %872)
store double %880, double* %848
br label %881
881: ; preds = %871, %874
%882 = add nuw nsw i64 %847, 1
%883 = icmp eq i64 %882, %737
br i1 %883, label %884, label %846
884: ; preds = %881
%885 = getelementptr double, double* %3, i64 %842
br i1 %735, label %886, label %1011
886: ; preds = %884
%887 = getelementptr double, double* %744, i64 %842
br label %888
888: ; preds = %1003, %886
%889 = phi i64 [ 0, %886 ], [ %1004, %1003 ]
%890 = mul i64 %889, %736
%891 = add nsw i64 %889, %841
%892 = getelementptr inbounds double, double* %831, i64 %891
%893 = load double, double* %892
%894 = getelementptr inbounds double, double* %718, i64 %889
%895 = load double, double* %894
%896 = fmul double %893, %895
%897 = mul nsw i64 %889, %736
br i1 %757, label %972, label %898
898: ; preds = %888
%899 = add i64 %890, %737
%900 = getelementptr double, double* %4, i64 %899
%901 = getelementptr double, double* %4, i64 %890
%902 = icmp ult double* %885, %900
%903 = icmp ult double* %901, %887
%904 = and i1 %902, %903
br i1 %904, label %972, label %905
905: ; preds = %898
%906 = insertelement <2 x double> poison, double %896, i64 0
%907 = shufflevector <2 x double> %906, <2 x double> poison, <2 x i32> zeroinitializer
%908 = insertelement <2 x double> poison, double %896, i64 0
%909 = shufflevector <2 x double> %908, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %760, label %951, label %910
910: ; preds = %905, %910
%911 = phi i64 [ %948, %910 ], [ 0, %905 ]
%912 = phi i64 [ %949, %910 ], [ 0, %905 ]
%913 = add nsw i64 %911, %897
%914 = getelementptr inbounds double, double* %4, i64 %913
%915 = bitcast double* %914 to <2 x double>*
%916 = load <2 x double>, <2 x double>* %915
%917 = getelementptr inbounds double, double* %914, i64 2
%918 = bitcast double* %917 to <2 x double>*
%919 = load <2 x double>, <2 x double>* %918
%920 = getelementptr inbounds double, double* %885, i64 %911
%921 = bitcast double* %920 to <2 x double>*
%922 = load <2 x double>, <2 x double>* %921
%923 = getelementptr inbounds double, double* %920, i64 2
%924 = bitcast double* %923 to <2 x double>*
%925 = load <2 x double>, <2 x double>* %924
%926 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %907, <2 x double> %916, <2 x double> %922)
%927 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %909, <2 x double> %919, <2 x double> %925)
%928 = bitcast double* %920 to <2 x double>*
store <2 x double> %926, <2 x double>* %928
%929 = bitcast double* %923 to <2 x double>*
store <2 x double> %927, <2 x double>* %929
%930 = or i64 %911, 4
%931 = add nsw i64 %930, %897
%932 = getelementptr inbounds double, double* %4, i64 %931
%933 = bitcast double* %932 to <2 x double>*
%934 = load <2 x double>, <2 x double>* %933
%935 = getelementptr inbounds double, double* %932, i64 2
%936 = bitcast double* %935 to <2 x double>*
%937 = load <2 x double>, <2 x double>* %936
%938 = getelementptr inbounds double, double* %885, i64 %930
%939 = bitcast double* %938 to <2 x double>*
%940 = load <2 x double>, <2 x double>* %939
%941 = getelementptr inbounds double, double* %938, i64 2
%942 = bitcast double* %941 to <2 x double>*
%943 = load <2 x double>, <2 x double>* %942
%944 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %907, <2 x double> %934, <2 x double> %940)
%945 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %909, <2 x double> %937, <2 x double> %943)
%946 = bitcast double* %938 to <2 x double>*
store <2 x double> %944, <2 x double>* %946
%947 = bitcast double* %941 to <2 x double>*
store <2 x double> %945, <2 x double>* %947
%948 = add nuw i64 %911, 8
%949 = add i64 %912, 2
%950 = icmp eq i64 %949, %761
br i1 %950, label %951, label %910
951: ; preds = %910, %905
%952 = phi i64 [ 0, %905 ], [ %948, %910 ]
br i1 %762, label %971, label %953
953: ; preds = %951
%954 = add nsw i64 %952, %897
%955 = getelementptr inbounds double, double* %4, i64 %954
%956 = bitcast double* %955 to <2 x double>*
%957 = load <2 x double>, <2 x double>* %956
%958 = getelementptr inbounds double, double* %955, i64 2
%959 = bitcast double* %958 to <2 x double>*
%960 = load <2 x double>, <2 x double>* %959
%961 = getelementptr inbounds double, double* %885, i64 %952
%962 = bitcast double* %961 to <2 x double>*
%963 = load <2 x double>, <2 x double>* %962
%964 = getelementptr inbounds double, double* %961, i64 2
%965 = bitcast double* %964 to <2 x double>*
%966 = load <2 x double>, <2 x double>* %965
%967 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %907, <2 x double> %957, <2 x double> %963)
%968 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %909, <2 x double> %960, <2 x double> %966)
%969 = bitcast double* %961 to <2 x double>*
store <2 x double> %967, <2 x double>* %969
%970 = bitcast double* %964 to <2 x double>*
store <2 x double> %968, <2 x double>* %970
br label %971
971: ; preds = %951, %953
br i1 %763, label %1003, label %972
972: ; preds = %898, %888, %971
%973 = phi i64 [ 0, %898 ], [ 0, %888 ], [ %758, %971 ]
%974 = xor i64 %973, -1
br i1 %765, label %983, label %975
975: ; preds = %972
%976 = add nsw i64 %973, %897
%977 = getelementptr inbounds double, double* %4, i64 %976
%978 = load double, double* %977
%979 = getelementptr inbounds double, double* %885, i64 %973
%980 = load double, double* %979
%981 = tail call double @llvm.fmuladd.f64(double %896, double %978, double %980)
store double %981, double* %979
%982 = or i64 %973, 1
br label %983
983: ; preds = %975, %972
%984 = phi i64 [ %973, %972 ], [ %982, %975 ]
%985 = icmp eq i64 %974, %766
br i1 %985, label %1003, label %986
986: ; preds = %983, %986
%987 = phi i64 [ %1001, %986 ], [ %984, %983 ]
%988 = add nsw i64 %987, %897
%989 = getelementptr inbounds double, double* %4, i64 %988
%990 = load double, double* %989
%991 = getelementptr inbounds double, double* %885, i64 %987
%992 = load double, double* %991
%993 = tail call double @llvm.fmuladd.f64(double %896, double %990, double %992)
store double %993, double* %991
%994 = add nuw nsw i64 %987, 1
%995 = add nsw i64 %994, %897
%996 = getelementptr inbounds double, double* %4, i64 %995
%997 = load double, double* %996
%998 = getelementptr inbounds double, double* %885, i64 %994
%999 = load double, double* %998
%1000 = tail call double @llvm.fmuladd.f64(double %896, double %997, double %999)
store double %1000, double* %998
%1001 = add nuw nsw i64 %987, 2
%1002 = icmp eq i64 %1001, %737
br i1 %1002, label %1003, label %986
1003: ; preds = %983, %986, %971
%1004 = add nuw nsw i64 %889, 1
%1005 = icmp eq i64 %1004, %737
br i1 %1005, label %1006, label %888
1006: ; preds = %1003
%1007 = add nuw nsw i64 %834, 1
%1008 = icmp eq i64 %1007, 4
br i1 %1008, label %1014, label %1009
1009: ; preds = %1006, %1011
%1010 = phi i64 [ %1007, %1006 ], [ %1012, %1011 ]
br label %833
1011: ; preds = %833, %884
%1012 = add nuw nsw i64 %834, 1
%1013 = icmp eq i64 %1012, 4
br i1 %1013, label %1081, label %1009
1014: ; preds = %1006
%1015 = getelementptr inbounds double, double* %3, i64 %832
br i1 %735, label %1016, label %1081
1016: ; preds = %1014, %1016
%1017 = phi i64 [ %1024, %1016 ], [ 0, %1014 ]
%1018 = getelementptr inbounds double, double* %1015, i64 %1017
%1019 = load double, double* %1018
%1020 = fcmp olt double %1019, 0.000000e+00
%1021 = fneg double %1019
%1022 = select i1 %1020, double %1021, double %1019
%1023 = fcmp olt double %1022, 0x2FF0000000000000
%1024 = add nuw nsw i64 %1017, 1
%1025 = icmp slt i64 %1024, %740
%1026 = select i1 %1023, i1 %1025, i1 false
br i1 %1026, label %1016, label %1027
1027: ; preds = %1016
br i1 %1023, label %1028, label %1085
1028: ; preds = %1027
br i1 %735, label %1029, label %1081
1029: ; preds = %1028
br i1 %767, label %1072, label %1030
1030: ; preds = %1029
br i1 %770, label %1058, label %1031
1031: ; preds = %1030, %1031
%1032 = phi i64 [ %1055, %1031 ], [ 0, %1030 ]
%1033 = phi i64 [ %1056, %1031 ], [ 0, %1030 ]
%1034 = getelementptr inbounds double, double* %1015, i64 %1032
%1035 = bitcast double* %1034 to <2 x double>*
%1036 = load <2 x double>, <2 x double>* %1035
%1037 = getelementptr inbounds double, double* %1034, i64 2
%1038 = bitcast double* %1037 to <2 x double>*
%1039 = load <2 x double>, <2 x double>* %1038
%1040 = fmul <2 x double> %1036, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1041 = fmul <2 x double> %1039, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1042 = bitcast double* %1034 to <2 x double>*
store <2 x double> %1040, <2 x double>* %1042
%1043 = bitcast double* %1037 to <2 x double>*
store <2 x double> %1041, <2 x double>* %1043
%1044 = or i64 %1032, 4
%1045 = getelementptr inbounds double, double* %1015, i64 %1044
%1046 = bitcast double* %1045 to <2 x double>*
%1047 = load <2 x double>, <2 x double>* %1046
%1048 = getelementptr inbounds double, double* %1045, i64 2
%1049 = bitcast double* %1048 to <2 x double>*
%1050 = load <2 x double>, <2 x double>* %1049
%1051 = fmul <2 x double> %1047, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1052 = fmul <2 x double> %1050, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1053 = bitcast double* %1045 to <2 x double>*
store <2 x double> %1051, <2 x double>* %1053
%1054 = bitcast double* %1048 to <2 x double>*
store <2 x double> %1052, <2 x double>* %1054
%1055 = add nuw i64 %1032, 8
%1056 = add i64 %1033, 2
%1057 = icmp eq i64 %1056, %771
br i1 %1057, label %1058, label %1031
1058: ; preds = %1031, %1030
%1059 = phi i64 [ 0, %1030 ], [ %1055, %1031 ]
br i1 %772, label %1071, label %1060
1060: ; preds = %1058
%1061 = getelementptr inbounds double, double* %1015, i64 %1059
%1062 = bitcast double* %1061 to <2 x double>*
%1063 = load <2 x double>, <2 x double>* %1062
%1064 = getelementptr inbounds double, double* %1061, i64 2
%1065 = bitcast double* %1064 to <2 x double>*
%1066 = load <2 x double>, <2 x double>* %1065
%1067 = fmul <2 x double> %1063, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1068 = fmul <2 x double> %1066, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1069 = bitcast double* %1061 to <2 x double>*
store <2 x double> %1067, <2 x double>* %1069
%1070 = bitcast double* %1064 to <2 x double>*
store <2 x double> %1068, <2 x double>* %1070
br label %1071
1071: ; preds = %1058, %1060
br i1 %773, label %1081, label %1072
1072: ; preds = %1029, %1071
%1073 = phi i64 [ 0, %1029 ], [ %768, %1071 ]
br label %1074
1074: ; preds = %1072, %1074
%1075 = phi i64 [ %1079, %1074 ], [ %1073, %1072 ]
%1076 = getelementptr inbounds double, double* %1015, i64 %1075
%1077 = load double, double* %1076
%1078 = fmul double %1077, 0x4FF0000000000000
store double %1078, double* %1076
%1079 = add nuw nsw i64 %1075, 1
%1080 = icmp eq i64 %1079, %743
br i1 %1080, label %1081, label %1074
1081: ; preds = %1011, %1074, %1071, %1014, %1028
%1082 = getelementptr inbounds i32, i32* %11, i64 %822
%1083 = load i32, i32* %1082
%1084 = add nsw i32 %1083, %823
br label %1085
1085: ; preds = %1027, %1081
%1086 = phi i32 [ %1084, %1081 ], [ %823, %1027 ]
%1087 = add nuw nsw i64 %822, 1
%1088 = icmp eq i64 %1087, %742
br i1 %1088, label %1089, label %821
1089: ; preds = %1085, %732
%1090 = phi i32 [ 0, %732 ], [ %1086, %1085 ]
%1091 = tail call i32 @free(double* %715)
%1092 = tail call i32 @free(double* %718)
br label %1372
1093: ; preds = %21, %1366
%1094 = phi i64 [ 0, %21 ], [ %1368, %1366 ]
%1095 = phi i32 [ 0, %21 ], [ %1367, %1366 ]
%1096 = trunc i64 %1094 to i32
%1097 = mul i32 %17, %1096
%1098 = mul nsw i64 %1094, %27
br label %1099
1099: ; preds = %1290, %1093
%1100 = phi i64 [ 0, %1093 ], [ %1291, %1290 ]
%1101 = mul nsw i64 %1100, %25
%1102 = add i64 %1101, %1098
%1103 = getelementptr inbounds double, double* %1, i64 %1102
%1104 = getelementptr inbounds double, double* %2, i64 %1102
%1105 = getelementptr double, double* %3, i64 %1102
br i1 %22, label %1106, label %1292
1106: ; preds = %1099
%1107 = trunc i64 %1100 to i32
%1108 = mul i32 %1107, %13
%1109 = add i32 %1097, %1108
%1110 = sext i32 %1109 to i64
%1111 = getelementptr double, double* %3, i64 %1110
%1112 = bitcast double* %1111 to i8*
%1113 = mul nsw i64 %1100, %26
%1114 = getelementptr double, double* %31, i64 %1102
br label %1115
1115: ; preds = %1284, %1106
%1116 = phi i64 [ 0, %1106 ], [ %1285, %1284 ]
%1117 = mul i64 %1116, %25
%1118 = getelementptr double, double* %4, i64 %1117
%1119 = add i64 %1117, %23
%1120 = getelementptr double, double* %4, i64 %1119
%1121 = mul nsw i64 %1116, %25
%1122 = add nsw i64 %1121, %1113
br i1 %41, label %1159, label %1123
1123: ; preds = %1115, %1123
%1124 = phi i64 [ %1156, %1123 ], [ 0, %1115 ]
%1125 = phi <2 x double> [ %1155, %1123 ], [ zeroinitializer, %1115 ]
%1126 = phi i64 [ %1157, %1123 ], [ 0, %1115 ]
%1127 = getelementptr inbounds double, double* %1103, i64 %1124
%1128 = load double, double* %1127
%1129 = add nsw i64 %1122, %1124
%1130 = getelementptr inbounds double, double* %9, i64 %1129
%1131 = load double, double* %1130
%1132 = getelementptr inbounds double, double* %1104, i64 %1124
%1133 = load double, double* %1132
%1134 = getelementptr inbounds double, double* %10, i64 %1129
%1135 = load double, double* %1134
%1136 = insertelement <2 x double> poison, double %1128, i64 0
%1137 = insertelement <2 x double> %1136, double %1133, i64 1
%1138 = insertelement <2 x double> poison, double %1131, i64 0
%1139 = insertelement <2 x double> %1138, double %1135, i64 1
%1140 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1137, <2 x double> %1139, <2 x double> %1125)
%1141 = or i64 %1124, 1
%1142 = getelementptr inbounds double, double* %1103, i64 %1141
%1143 = load double, double* %1142
%1144 = add nsw i64 %1122, %1141
%1145 = getelementptr inbounds double, double* %9, i64 %1144
%1146 = load double, double* %1145
%1147 = getelementptr inbounds double, double* %1104, i64 %1141
%1148 = load double, double* %1147
%1149 = getelementptr inbounds double, double* %10, i64 %1144
%1150 = load double, double* %1149
%1151 = insertelement <2 x double> poison, double %1143, i64 0
%1152 = insertelement <2 x double> %1151, double %1148, i64 1
%1153 = insertelement <2 x double> poison, double %1146, i64 0
%1154 = insertelement <2 x double> %1153, double %1150, i64 1
%1155 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1152, <2 x double> %1154, <2 x double> %1140)
%1156 = add nuw nsw i64 %1124, 2
%1157 = add i64 %1126, 2
%1158 = icmp eq i64 %1157, %42
br i1 %1158, label %1159, label %1123
1159: ; preds = %1123, %1115
%1160 = phi <2 x double> [ undef, %1115 ], [ %1155, %1123 ]
%1161 = phi i64 [ 0, %1115 ], [ %1156, %1123 ]
%1162 = phi <2 x double> [ zeroinitializer, %1115 ], [ %1155, %1123 ]
br i1 %43, label %1178, label %1163
1163: ; preds = %1159
%1164 = getelementptr inbounds double, double* %1103, i64 %1161
%1165 = load double, double* %1164
%1166 = add nsw i64 %1122, %1161
%1167 = getelementptr inbounds double, double* %9, i64 %1166
%1168 = load double, double* %1167
%1169 = getelementptr inbounds double, double* %1104, i64 %1161
%1170 = load double, double* %1169
%1171 = getelementptr inbounds double, double* %10, i64 %1166
%1172 = load double, double* %1171
%1173 = insertelement <2 x double> poison, double %1165, i64 0
%1174 = insertelement <2 x double> %1173, double %1170, i64 1
%1175 = insertelement <2 x double> poison, double %1168, i64 0
%1176 = insertelement <2 x double> %1175, double %1172, i64 1
%1177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1174, <2 x double> %1176, <2 x double> %1162)
br label %1178
1178: ; preds = %1159, %1163
%1179 = phi <2 x double> [ %1160, %1159 ], [ %1177, %1163 ]
%1180 = shufflevector <2 x double> %1179, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%1181 = fmul <2 x double> %1180, %1179
%1182 = extractelement <2 x double> %1181, i64 0
%1183 = mul nsw i64 %1116, %25
br i1 %44, label %1253, label %1184
1184: ; preds = %1178
%1185 = icmp ult double* %1105, %1120
%1186 = icmp ult double* %1118, %1114
%1187 = and i1 %1185, %1186
br i1 %1187, label %1253, label %1188
1188: ; preds = %1184
%1189 = shufflevector <2 x double> %1181, <2 x double> poison, <2 x i32> zeroinitializer
%1190 = shufflevector <2 x double> %1181, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %47, label %1232, label %1191
1191: ; preds = %1188, %1191
%1192 = phi i64 [ %1229, %1191 ], [ 0, %1188 ]
%1193 = phi i64 [ %1230, %1191 ], [ 0, %1188 ]
%1194 = add nsw i64 %1192, %1183
%1195 = getelementptr inbounds double, double* %4, i64 %1194
%1196 = bitcast double* %1195 to <2 x double>*
%1197 = load <2 x double>, <2 x double>* %1196
%1198 = getelementptr inbounds double, double* %1195, i64 2
%1199 = bitcast double* %1198 to <2 x double>*
%1200 = load <2 x double>, <2 x double>* %1199
%1201 = getelementptr inbounds double, double* %1105, i64 %1192
%1202 = bitcast double* %1201 to <2 x double>*
%1203 = load <2 x double>, <2 x double>* %1202
%1204 = getelementptr inbounds double, double* %1201, i64 2
%1205 = bitcast double* %1204 to <2 x double>*
%1206 = load <2 x double>, <2 x double>* %1205
%1207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1189, <2 x double> %1197, <2 x double> %1203)
%1208 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1190, <2 x double> %1200, <2 x double> %1206)
%1209 = bitcast double* %1201 to <2 x double>*
store <2 x double> %1207, <2 x double>* %1209
%1210 = bitcast double* %1204 to <2 x double>*
store <2 x double> %1208, <2 x double>* %1210
%1211 = or i64 %1192, 4
%1212 = add nsw i64 %1211, %1183
%1213 = getelementptr inbounds double, double* %4, i64 %1212
%1214 = bitcast double* %1213 to <2 x double>*
%1215 = load <2 x double>, <2 x double>* %1214
%1216 = getelementptr inbounds double, double* %1213, i64 2
%1217 = bitcast double* %1216 to <2 x double>*
%1218 = load <2 x double>, <2 x double>* %1217
%1219 = getelementptr inbounds double, double* %1105, i64 %1211
%1220 = bitcast double* %1219 to <2 x double>*
%1221 = load <2 x double>, <2 x double>* %1220
%1222 = getelementptr inbounds double, double* %1219, i64 2
%1223 = bitcast double* %1222 to <2 x double>*
%1224 = load <2 x double>, <2 x double>* %1223
%1225 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1189, <2 x double> %1215, <2 x double> %1221)
%1226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1190, <2 x double> %1218, <2 x double> %1224)
%1227 = bitcast double* %1219 to <2 x double>*
store <2 x double> %1225, <2 x double>* %1227
%1228 = bitcast double* %1222 to <2 x double>*
store <2 x double> %1226, <2 x double>* %1228
%1229 = add nuw i64 %1192, 8
%1230 = add i64 %1193, 2
%1231 = icmp eq i64 %1230, %48
br i1 %1231, label %1232, label %1191
1232: ; preds = %1191, %1188
%1233 = phi i64 [ 0, %1188 ], [ %1229, %1191 ]
br i1 %49, label %1252, label %1234
1234: ; preds = %1232
%1235 = add nsw i64 %1233, %1183
%1236 = getelementptr inbounds double, double* %4, i64 %1235
%1237 = bitcast double* %1236 to <2 x double>*
%1238 = load <2 x double>, <2 x double>* %1237
%1239 = getelementptr inbounds double, double* %1236, i64 2
%1240 = bitcast double* %1239 to <2 x double>*
%1241 = load <2 x double>, <2 x double>* %1240
%1242 = getelementptr inbounds double, double* %1105, i64 %1233
%1243 = bitcast double* %1242 to <2 x double>*
%1244 = load <2 x double>, <2 x double>* %1243
%1245 = getelementptr inbounds double, double* %1242, i64 2
%1246 = bitcast double* %1245 to <2 x double>*
%1247 = load <2 x double>, <2 x double>* %1246
%1248 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1189, <2 x double> %1238, <2 x double> %1244)
%1249 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1190, <2 x double> %1241, <2 x double> %1247)
%1250 = bitcast double* %1242 to <2 x double>*
store <2 x double> %1248, <2 x double>* %1250
%1251 = bitcast double* %1245 to <2 x double>*
store <2 x double> %1249, <2 x double>* %1251
br label %1252
1252: ; preds = %1232, %1234
br i1 %50, label %1284, label %1253
1253: ; preds = %1184, %1178, %1252
%1254 = phi i64 [ 0, %1184 ], [ 0, %1178 ], [ %45, %1252 ]
%1255 = xor i64 %1254, -1
br i1 %52, label %1264, label %1256
1256: ; preds = %1253
%1257 = add nsw i64 %1254, %1183
%1258 = getelementptr inbounds double, double* %4, i64 %1257
%1259 = load double, double* %1258
%1260 = getelementptr inbounds double, double* %1105, i64 %1254
%1261 = load double, double* %1260
%1262 = tail call double @llvm.fmuladd.f64(double %1182, double %1259, double %1261)
store double %1262, double* %1260
%1263 = or i64 %1254, 1
br label %1264
1264: ; preds = %1256, %1253
%1265 = phi i64 [ %1254, %1253 ], [ %1263, %1256 ]
%1266 = icmp eq i64 %1255, %53
br i1 %1266, label %1284, label %1267
1267: ; preds = %1264, %1267
%1268 = phi i64 [ %1282, %1267 ], [ %1265, %1264 ]
%1269 = add nsw i64 %1268, %1183
%1270 = getelementptr inbounds double, double* %4, i64 %1269
%1271 = load double, double* %1270
%1272 = getelementptr inbounds double, double* %1105, i64 %1268
%1273 = load double, double* %1272
%1274 = tail call double @llvm.fmuladd.f64(double %1182, double %1271, double %1273)
store double %1274, double* %1272
%1275 = add nuw nsw i64 %1268, 1
%1276 = add nsw i64 %1275, %1183
%1277 = getelementptr inbounds double, double* %4, i64 %1276
%1278 = load double, double* %1277
%1279 = getelementptr inbounds double, double* %1105, i64 %1275
%1280 = load double, double* %1279
%1281 = tail call double @llvm.fmuladd.f64(double %1182, double %1278, double %1280)
store double %1281, double* %1279
%1282 = add nuw nsw i64 %1268, 2
%1283 = icmp eq i64 %1282, %23
br i1 %1283, label %1284, label %1267
1284: ; preds = %1264, %1267, %1252
%1285 = add nuw nsw i64 %1116, 1
%1286 = icmp eq i64 %1285, %23
br i1 %1286, label %1287, label %1115
1287: ; preds = %1284
%1288 = add nuw nsw i64 %1100, 1
%1289 = icmp eq i64 %1288, 4
br i1 %1289, label %1295, label %1290
1290: ; preds = %1287, %1292
%1291 = phi i64 [ %1288, %1287 ], [ %1293, %1292 ]
br label %1099
1292: ; preds = %1099
%1293 = add nuw nsw i64 %1100, 1
%1294 = icmp eq i64 %1293, 4
br i1 %1294, label %1362, label %1290
1295: ; preds = %1287
%1296 = getelementptr inbounds double, double* %3, i64 %1098
br i1 %22, label %1297, label %1362
1297: ; preds = %1295, %1297
%1298 = phi i64 [ %1305, %1297 ], [ 0, %1295 ]
%1299 = getelementptr inbounds double, double* %1296, i64 %1298
%1300 = load double, double* %1299
%1301 = fcmp olt double %1300, 0.000000e+00
%1302 = fneg double %1300
%1303 = select i1 %1301, double %1302, double %1300
%1304 = fcmp olt double %1303, 0x2FF0000000000000
%1305 = add nuw nsw i64 %1298, 1
%1306 = icmp slt i64 %1305, %27
%1307 = select i1 %1304, i1 %1306, i1 false
br i1 %1307, label %1297, label %1308
1308: ; preds = %1297
br i1 %1304, label %1309, label %1366
1309: ; preds = %1308
br i1 %22, label %1310, label %1362
1310: ; preds = %1309
br i1 %54, label %1353, label %1311
1311: ; preds = %1310
br i1 %57, label %1339, label %1312
1312: ; preds = %1311, %1312
%1313 = phi i64 [ %1336, %1312 ], [ 0, %1311 ]
%1314 = phi i64 [ %1337, %1312 ], [ 0, %1311 ]
%1315 = getelementptr inbounds double, double* %1296, i64 %1313
%1316 = bitcast double* %1315 to <2 x double>*
%1317 = load <2 x double>, <2 x double>* %1316
%1318 = getelementptr inbounds double, double* %1315, i64 2
%1319 = bitcast double* %1318 to <2 x double>*
%1320 = load <2 x double>, <2 x double>* %1319
%1321 = fmul <2 x double> %1317, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1322 = fmul <2 x double> %1320, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1323 = bitcast double* %1315 to <2 x double>*
store <2 x double> %1321, <2 x double>* %1323
%1324 = bitcast double* %1318 to <2 x double>*
store <2 x double> %1322, <2 x double>* %1324
%1325 = or i64 %1313, 4
%1326 = getelementptr inbounds double, double* %1296, i64 %1325
%1327 = bitcast double* %1326 to <2 x double>*
%1328 = load <2 x double>, <2 x double>* %1327
%1329 = getelementptr inbounds double, double* %1326, i64 2
%1330 = bitcast double* %1329 to <2 x double>*
%1331 = load <2 x double>, <2 x double>* %1330
%1332 = fmul <2 x double> %1328, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1333 = fmul <2 x double> %1331, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1334 = bitcast double* %1326 to <2 x double>*
store <2 x double> %1332, <2 x double>* %1334
%1335 = bitcast double* %1329 to <2 x double>*
store <2 x double> %1333, <2 x double>* %1335
%1336 = add nuw i64 %1313, 8
%1337 = add i64 %1314, 2
%1338 = icmp eq i64 %1337, %58
br i1 %1338, label %1339, label %1312
1339: ; preds = %1312, %1311
%1340 = phi i64 [ 0, %1311 ], [ %1336, %1312 ]
br i1 %59, label %1352, label %1341
1341: ; preds = %1339
%1342 = getelementptr inbounds double, double* %1296, i64 %1340
%1343 = bitcast double* %1342 to <2 x double>*
%1344 = load <2 x double>, <2 x double>* %1343
%1345 = getelementptr inbounds double, double* %1342, i64 2
%1346 = bitcast double* %1345 to <2 x double>*
%1347 = load <2 x double>, <2 x double>* %1346
%1348 = fmul <2 x double> %1344, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1349 = fmul <2 x double> %1347, <double 0x4FF0000000000000, double 0x4FF0000000000000>
%1350 = bitcast double* %1342 to <2 x double>*
store <2 x double> %1348, <2 x double>* %1350
%1351 = bitcast double* %1345 to <2 x double>*
store <2 x double> %1349, <2 x double>* %1351
br label %1352
1352: ; preds = %1339, %1341
br i1 %60, label %1362, label %1353
1353: ; preds = %1310, %1352
%1354 = phi i64 [ 0, %1310 ], [ %55, %1352 ]
br label %1355
1355: ; preds = %1353, %1355
%1356 = phi i64 [ %1360, %1355 ], [ %1354, %1353 ]
%1357 = getelementptr inbounds double, double* %1296, i64 %1356
%1358 = load double, double* %1357
%1359 = fmul double %1358, 0x4FF0000000000000
store double %1359, double* %1357
%1360 = add nuw nsw i64 %1356, 1
%1361 = icmp eq i64 %1360, %30
br i1 %1361, label %1362, label %1355
1362: ; preds = %1292, %1355, %1352, %1295, %1309
%1363 = getelementptr inbounds i32, i32* %11, i64 %1094
%1364 = load i32, i32* %1363
%1365 = add nsw i32 %1364, %1095
br label %1366
1366: ; preds = %1308, %1362
%1367 = phi i32 [ %1365, %1362 ], [ %1095, %1308 ]
%1368 = add nuw nsw i64 %1094, 1
%1369 = icmp eq i64 %1368, %29
br i1 %1369, label %1372, label %1093
1370: ; preds = %15
%1371 = tail call i32 @assert(i32 0)
br label %1372
1372: ; preds = %1366, %19, %1370, %1089, %709
%1373 = phi i32 [ 0, %1370 ], [ %1090, %1089 ], [ 0, %709 ], [ 0, %19 ], [ %1367, %1366 ]
store i32 %1373, i32* %12
ret void
}