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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ ascertainmentBiasSequence(unsigned char *, int const);
int /*<<< orphan*/ assert(int /*<<< orphan*/);
void sumGammaAsc(int tipCase, double *sumtable, double *x1, double *x2,
                 double *tipVector, int n, const int numStates) {
  int i, l, k;
  double *left, *right, *sum;
  const int gammaStates = numStates * 4;
  unsigned char tip[32];
  ascertainmentBiasSequence(tip, numStates);
  switch (tipCase) {
  case 0:
    for (i = 0; i < n; i++) {
      left = &(tipVector[numStates * tip[i]]);
      right = &(tipVector[numStates * tip[i]]);
      for (l = 0; l < 4; l++) {
        sum = &sumtable[i * gammaStates + l * numStates];
        for (k = 0; k < numStates; k++)
          sum[k] = left[k] * right[k];
      }
    }
    break;
  case 1:
    for (i = 0; i < n; i++) {
      left = &(tipVector[numStates * tip[i]]);
      for (l = 0; l < 4; l++) {
        right = &(x2[gammaStates * i + l * numStates]);
        sum = &sumtable[i * gammaStates + l * numStates];
        for (k = 0; k < numStates; k++)
          sum[k] = left[k] * right[k];
      }
    }
    break;
  case 2:
    for (i = 0; i < n; i++) {
      for (l = 0; l < 4; l++) {
        left = &(x1[gammaStates * i + l * numStates]);
        right = &(x2[gammaStates * i + l * numStates]);
        sum = &(sumtable[i * gammaStates + l * numStates]);
        for (k = 0; k < numStates; k++)
          sum[k] = left[k] * right[k];
      }
    }
    break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<sumGammaAsc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    0x10(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    0x10(%rbp),%esi
lea    -0x80(%rbp),%rdi
call   1040 <ascertainmentBiasSequence@plt>
mov    -0x4(%rbp),%eax
mov    %eax,-0x84(%rbp)
test   %eax,%eax
je     1198 <sumGammaAsc+0x78>
jmp    1170 <sumGammaAsc+0x50>
mov    -0x84(%rbp),%eax
sub    $0x1,%eax
je     1293 <sumGammaAsc+0x173>
jmp    1184 <sumGammaAsc+0x64>
mov    -0x84(%rbp),%eax
sub    $0x2,%eax
je     138f <sumGammaAsc+0x26f>
jmp    148c <sumGammaAsc+0x36c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    128e <sumGammaAsc+0x16e>
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x80(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x80(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    127b <sumGammaAsc+0x15b>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1268 <sumGammaAsc+0x148>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1227 <sumGammaAsc+0x107>
jmp    126d <sumGammaAsc+0x14d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f4 <sumGammaAsc+0xd4>
jmp    1280 <sumGammaAsc+0x160>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    119f <sumGammaAsc+0x7f>
jmp    1493 <sumGammaAsc+0x373>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    138a <sumGammaAsc+0x26a>
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x80(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1377 <sumGammaAsc+0x257>
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1364 <sumGammaAsc+0x244>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1323 <sumGammaAsc+0x203>
jmp    1369 <sumGammaAsc+0x249>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ce <sumGammaAsc+0x1ae>
jmp    137c <sumGammaAsc+0x25c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129a <sumGammaAsc+0x17a>
jmp    1493 <sumGammaAsc+0x373>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1487 <sumGammaAsc+0x367>
movl   $0x0,-0x34(%rbp)
cmpl   $0x4,-0x34(%rbp)
jge    1474 <sumGammaAsc+0x354>
mov    -0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1461 <sumGammaAsc+0x341>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1420 <sumGammaAsc+0x300>
jmp    1466 <sumGammaAsc+0x346>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a9 <sumGammaAsc+0x289>
jmp    1479 <sumGammaAsc+0x359>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1396 <sumGammaAsc+0x276>
jmp    1493 <sumGammaAsc+0x373>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumGammaAsc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9d,%ebp
mov    %r8,0xe0(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,0x80(%rsp)
mov    %rsi,0x48(%rsp)
mov    %edi,%r12d
mov    0x1b0(%rsp),%ebx
lea    0x0(,%rbx,4),%r14d
lea    0x150(%rsp),%rdi
mov    %ebx,%esi
call   1040 <ascertainmentBiasSequence@plt>
movslq %ebx,%rax
mov    %rax,0xd0(%rsp)
test   %r12d,%r12d
je     1f64 <sumGammaAsc+0xe44>
cmp    $0x1,%r12d
je     2861 <sumGammaAsc+0x1741>
cmp    $0x2,%r12d
jne    34d4 <sumGammaAsc+0x23b4>
test   %ebp,%ebp
jle    34db <sumGammaAsc+0x23bb>
movslq %r14d,%r10
mov    %ebp,%eax
mov    %rax,0x108(%rsp)
mov    0xd0(%rsp),%r9
mov    %r9d,%r15d
lea    (%r9,%r9,1),%rdx
mov    %rdx,0x140(%rsp)
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xf8(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xc0(%rsp)
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rdx
mov    %rsi,0xf0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xe8(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x50(%rsp)
mov    %r9,%rdx
shl    $0x4,%rdx
mov    0x80(%rsp),%r11
lea    (%r11,%rdx,1),%rsi
add    $0x30,%rsi
mov    %rsi,0xa8(%rsp)
mov    0x60(%rsp),%r13
lea    0x30(%r13,%rdx,1),%rax
mov    %rax,0x78(%rsp)
mov    0x48(%rsp),%r14
lea    0x30(%r14,%rdx,1),%rax
mov    %rax,(%rsp)
lea    (%r14,%rdx,1),%rbp
mov    %rbp,0x68(%rsp)
lea    (%rdx,%r13,1),%rbp
add    %r11,%rdx
lea    (%r9,%r9,2),%rdi
lea    (%rdi,%r15,1),%rax
mov    %rax,0x128(%rsp)
lea    (%r15,%r9,2),%rax
mov    %rax,0x138(%rsp)
lea    (%r9,%r15,1),%rax
mov    %rax,0x148(%rsp)
lea    0x30(%r11),%rax
mov    %r10,0x118(%rsp)
lea    0x0(,%r10,8),%rsi
mov    %rsi,0x100(%rsp)
lea    0x30(%r13),%rbx
mov    %rbx,0x40(%rsp)
lea    0x30(%r14),%rbx
lea    0x30(%r11,%r9,8),%rsi
mov    %rsi,0xb0(%rsp)
lea    0x30(%r13,%r9,8),%rsi
lea    0x30(%r14,%r9,8),%rcx
mov    %rcx,0x110(%rsp)
lea    (%r14,%r9,8),%rcx
mov    %rcx,0x90(%rsp)
lea    0x0(%r13,%r9,8),%rcx
mov    %rcx,0x58(%rsp)
lea    (%r11,%r9,8),%r9
lea    0x30(%r11,%rdi,8),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x30(%r13,%rdi,8),%r12
lea    0x30(%r14,%rdi,8),%rcx
mov    %rcx,0xd8(%rsp)
lea    (%r14,%rdi,8),%rcx
lea    0x0(%r13,%rdi,8),%r8
mov    %r8,0x30(%rsp)
mov    %rdi,0x130(%rsp)
lea    (%r11,%rdi,8),%rdi
mov    %rdi,0xb8(%rsp)
mov    %rsi,%r8
xor    %esi,%esi
mov    %rsi,0x18(%rsp)
mov    %r11,%r10
jmp    13f6 <sumGammaAsc+0x2d6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x18(%rsp),%rsi
mov    %r11,%rcx
mov    %rsi,%r11
add    $0x1,%r11
mov    0xe0(%rsp),%rax
mov    0x100(%rsp),%rsi
add    %rsi,%rax
add    %rsi,0x40(%rsp)
mov    0x70(%rsp),%rbx
add    %rsi,%rbx
add    %rsi,%r14
add    %rsi,%r13
add    %rsi,%r10
add    %rsi,0xb0(%rsp)
add    %rsi,%r8
add    %rsi,0x110(%rsp)
add    %rsi,0x90(%rsp)
add    %rsi,0x58(%rsp)
add    %rsi,%r9
add    %rsi,0xa8(%rsp)
add    %rsi,0x78(%rsp)
add    %rsi,%rcx
mov    %rcx,(%rsp)
add    %rsi,0x68(%rsp)
add    %rsi,%rbp
add    %rsi,%rdx
add    %rsi,0xc8(%rsp)
add    %rsi,%r12
add    %rsi,0xd8(%rsp)
add    %rsi,%rdi
mov    %rdi,%rcx
add    %rsi,0x30(%rsp)
add    %rsi,0xb8(%rsp)
mov    %r11,%rsi
mov    %r11,0x18(%rsp)
cmp    0x108(%rsp),%r11
je     34db <sumGammaAsc+0x23bb>
mov    %rbx,0x70(%rsp)
mov    %rax,0xe0(%rsp)
mov    0x1b0(%rsp),%eax
test   %eax,%eax
mov    (%rsp),%r11
mov    %rcx,%rdi
jle    1340 <sumGammaAsc+0x220>
mov    0x18(%rsp),%rbx
imul   0x118(%rsp),%rbx
mov    0x1b0(%rsp),%eax
cmp    $0x4,%eax
mov    %rdx,0x28(%rsp)
mov    %rbp,0x10(%rsp)
mov    %r8,0x8(%rsp)
mov    %r12,0x20(%rsp)
mov    %rdi,0x38(%rsp)
mov    %rbx,0x88(%rsp)
jae    1470 <sumGammaAsc+0x350>
mov    %r8,%rcx
xor    %ebx,%ebx
mov    0x50(%rsp),%r8
jmp    1630 <sumGammaAsc+0x510>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%r15,1),%rax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rbx,8),%rbp
lea    (%rcx,%rax,8),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rbx,8),%r8
lea    (%rdx,%rax,8),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rbx,8),%rdi
lea    (%rsi,%rax,8),%rax
cmp    %rdx,%rbp
setb   %dl
cmp    %rcx,%r8
setb   %bl
cmp    %rax,%rbp
setb   %al
cmp    %rcx,%rdi
setb   %cl
test   %bl,%dl
jne    1595 <sumGammaAsc+0x475>
mov    %r8,0x98(%rsp)
mov    %rdi,0xa0(%rsp)
mov    $0x0,%ebx
and    %cl,%al
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x8(%rsp),%rcx
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%r8
jne    1630 <sumGammaAsc+0x510>
cmpq   $0x0,0xc0(%rsp)
mov    %rbp,0x120(%rsp)
je     15b6 <sumGammaAsc+0x496>
mov    0xe8(%rsp),%rbp
xor    %ebx,%ebx
mov    0xe0(%rsp),%rax
mov    0x40(%rsp),%r8
mov    0x70(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rax,%rbx,8),%xmm0
movupd -0x20(%rax,%rbx,8),%xmm1
movupd -0x30(%r8,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r8,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rsi,%rbx,8)
movupd %xmm0,-0x20(%rsi,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd -0x10(%r8,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r8,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rsi,%rbx,8)
movupd %xmm0,(%rsi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1530 <sumGammaAsc+0x410>
jmp    15b8 <sumGammaAsc+0x498>
xor    %ebx,%ebx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x8(%rsp),%rcx
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
mov    0x50(%rsp),%r8
jmp    1630 <sumGammaAsc+0x510>
xor    %ebx,%ebx
testb  $0x1,0xf0(%rsp)
01
mov    0x10(%rsp),%rbp
mov    0x50(%rsp),%r8
mov    0x8(%rsp),%rcx
je     1612 <sumGammaAsc+0x4f2>
mov    0x98(%rsp),%rax
movupd (%rax,%rbx,8),%xmm0
movupd 0x10(%rax,%rbx,8),%xmm1
mov    0xa0(%rsp),%rax
movupd (%rax,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x120(%rsp),%rax
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
je     16cb <sumGammaAsc+0x5ab>
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rbp
not    %rbp
add    %r15,%rbp
test   %r8,%r8
je     165d <sumGammaAsc+0x53d>
xchg   %ax,%ax
movsd  (%r10,%rbx,8),%xmm0
mulsd  0x0(%r13,%rbx,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%r8
jne    1640 <sumGammaAsc+0x520>
cmp    $0x3,%rbp
mov    0x10(%rsp),%rbp
jb     16cb <sumGammaAsc+0x5ab>
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rbx,8),%xmm0
mulsd  0x0(%r13,%rbx,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
movsd  0x8(%r10,%rbx,8),%xmm0
mulsd  0x8(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rbx,8)
movsd  0x10(%r10,%rbx,8),%xmm0
mulsd  0x10(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rbx,8)
movsd  0x18(%r10,%rbx,8),%xmm0
mulsd  0x18(%r13,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1670 <sumGammaAsc+0x550>
mov    %rcx,%r8
mov    0x1b0(%rsp),%eax
test   %eax,%eax
jle    1340 <sumGammaAsc+0x220>
mov    0x1b0(%rsp),%eax
cmp    $0x4,%eax
jae    1708 <sumGammaAsc+0x5e8>
mov    %rdi,%rcx
mov    %r12,%rsi
xor    %ebx,%ebx
mov    0x90(%rsp),%r12
mov    0x58(%rsp),%rdi
mov    0x50(%rsp),%r8
jmp    18f0 <sumGammaAsc+0x7d0>
mov    0xd0(%rsp),%rax
mov    0x88(%rsp),%rdx
add    %rdx,%rax
mov    0x148(%rsp),%rcx
lea    (%rcx,%rdx,1),%rcx
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
lea    (%rdx,%rcx,8),%rdx
mov    0x80(%rsp),%rsi
lea    (%rsi,%rax,8),%r8
lea    (%rsi,%rcx,8),%rdi
mov    0x60(%rsp),%rbp
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
cmp    %rdi,%rbx
setb   %dil
cmp    %rdx,%r8
setb   %cl
cmp    %rax,%rbx
setb   %al
cmp    %rdx,%rsi
setb   %dl
test   %cl,%dil
mov    0x90(%rsp),%r12
mov    0x58(%rsp),%rdi
jne    1861 <sumGammaAsc+0x741>
mov    %r8,0x120(%rsp)
mov    %rsi,0x98(%rsp)
mov    %rbx,0xa0(%rsp)
mov    $0x0,%ebx
and    %dl,%al
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%rcx
mov    0x50(%rsp),%r8
jne    18f0 <sumGammaAsc+0x7d0>
cmpq   $0x0,0xc0(%rsp)
mov    0xb0(%rsp),%rax
mov    %r11,(%rsp)
je     187d <sumGammaAsc+0x75d>
mov    0xe8(%rsp),%rbp
xor    %ebx,%ebx
mov    0x110(%rsp),%rcx
mov    0x8(%rsp),%rsi
nopl   (%rax)
movupd -0x30(%rax,%rbx,8),%xmm0
movupd -0x20(%rax,%rbx,8),%xmm1
movupd -0x30(%rsi,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rcx,%rbx,8)
movupd %xmm0,-0x20(%rcx,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd -0x10(%rsi,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm0,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1800 <sumGammaAsc+0x6e0>
jmp    187f <sumGammaAsc+0x75f>
xor    %ebx,%ebx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%rcx
mov    0x50(%rsp),%r8
jmp    18f0 <sumGammaAsc+0x7d0>
xor    %ebx,%ebx
testb  $0x1,0xf0(%rsp)
01
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%rcx
mov    (%rsp),%r11
je     18d8 <sumGammaAsc+0x7b8>
mov    0x120(%rsp),%rax
movupd (%rax,%rbx,8),%xmm0
movupd 0x10(%rax,%rbx,8),%xmm1
mov    0x98(%rsp),%rax
movupd (%rax,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xa0(%rsp),%rax
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
je     19a6 <sumGammaAsc+0x886>
nopl   0x0(%rax)
mov    %rbx,%rbp
not    %rbp
add    %r15,%rbp
test   $0x3,%r15b
je     193e <sumGammaAsc+0x81e>
lea    (%r12,%rbx,8),%rcx
lea    (%rdi,%rbx,8),%rax
lea    (%r9,%rbx,8),%rdx
xor    %esi,%esi
nopl   (%rax)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    1910 <sumGammaAsc+0x7f0>
add    %rsi,%rbx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x20(%rsp),%rsi
mov    0x38(%rsp),%rcx
cmp    $0x3,%rbp
jb     19a6 <sumGammaAsc+0x886>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rbx,8),%xmm0
mulsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
movsd  0x8(%r9,%rbx,8),%xmm0
mulsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
movsd  0x10(%r9,%rbx,8),%xmm0
mulsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rbx,8)
movsd  0x18(%r9,%rbx,8),%xmm0
mulsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r12,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1950 <sumGammaAsc+0x830>
mov    0x1b0(%rsp),%eax
test   %eax,%eax
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%r8
mov    %rsi,%r12
mov    %rcx,%rdi
jle    1340 <sumGammaAsc+0x220>
mov    0x1b0(%rsp),%eax
cmp    $0x4,%eax
jae    19dd <sumGammaAsc+0x8bd>
xor    %ebx,%ebx
mov    0x68(%rsp),%rax
jmp    1bb0 <sumGammaAsc+0xa90>
mov    0x140(%rsp),%rax
mov    0x88(%rsp),%rdx
add    %rdx,%rax
mov    0x138(%rsp),%rcx
lea    (%rcx,%rdx,1),%rcx
mov    0x48(%rsp),%rdx
lea    (%rdx,%rax,8),%rdi
lea    (%rdx,%rcx,8),%rdx
mov    0x80(%rsp),%rsi
lea    (%rsi,%rax,8),%r8
lea    (%rsi,%rcx,8),%rsi
mov    0x60(%rsp),%rbp
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
cmp    %rsi,%rdi
mov    %rdi,%rsi
setb   %dil
cmp    %rdx,%r8
setb   %cl
cmp    %rax,%rsi
setb   %al
cmp    %rdx,%rbx
setb   %dl
test   %cl,%dil
jne    1b2a <sumGammaAsc+0xa0a>
mov    %r8,0x98(%rsp)
mov    %rbx,0xa0(%rsp)
mov    $0x0,%ebx
and    %dl,%al
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x68(%rsp),%rax
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
jne    1bb0 <sumGammaAsc+0xa90>
cmpq   $0x0,0xc0(%rsp)
je     1b4b <sumGammaAsc+0xa2b>
mov    0xe8(%rsp),%rbp
xor    %ebx,%ebx
mov    0xa8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rax,%rbx,8),%xmm0
movupd -0x20(%rax,%rbx,8),%xmm1
mov    0x78(%rsp),%rcx
movupd -0x30(%rcx,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r11,%rbx,8)
movupd %xmm0,-0x20(%r11,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd -0x10(%rcx,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r11,%rbx,8)
movupd %xmm0,(%r11,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1ac0 <sumGammaAsc+0x9a0>
jmp    1b4d <sumGammaAsc+0xa2d>
xor    %ebx,%ebx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x68(%rsp),%rax
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
jmp    1bb0 <sumGammaAsc+0xa90>
xor    %ebx,%ebx
testb  $0x1,0xf0(%rsp)
01
mov    0x10(%rsp),%rbp
je     1b95 <sumGammaAsc+0xa75>
mov    0x98(%rsp),%rax
movupd (%rax,%rbx,8),%xmm0
movupd 0x10(%rax,%rbx,8),%xmm1
mov    0xa0(%rsp),%rax
movupd (%rax,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%rsi,%rbx,8)
movupd %xmm0,0x10(%rsi,%rbx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
mov    0x68(%rsp),%rax
je     1c7f <sumGammaAsc+0xb5f>
xchg   %ax,%ax
mov    %rbx,%rbp
not    %rbp
add    %r15,%rbp
test   $0x3,%r15b
je     1c18 <sumGammaAsc+0xaf8>
lea    (%rax,%rbx,8),%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rbx,8),%rax
lea    (%rdx,%rbx,8),%rdx
xor    %esi,%esi
mov    0x50(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1be0 <sumGammaAsc+0xac0>
add    %rsi,%rbx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x68(%rsp),%rax
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
cmp    $0x3,%rbp
mov    0x10(%rsp),%rbp
jb     1c7f <sumGammaAsc+0xb5f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rbx,8),%xmm0
mulsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
movsd  0x8(%rdx,%rbx,8),%xmm0
mulsd  0x8(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rbx,8)
movsd  0x10(%rdx,%rbx,8),%xmm0
mulsd  0x10(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rbx,8)
movsd  0x18(%rdx,%rbx,8),%xmm0
mulsd  0x18(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r15
jne    1c30 <sumGammaAsc+0xb10>
mov    0x1b0(%rsp),%eax
test   %eax,%eax
jle    1340 <sumGammaAsc+0x220>
mov    0x1b0(%rsp),%eax
cmp    $0x4,%eax
jae    1d9a <sumGammaAsc+0xc7a>
xor    %ebx,%ebx
mov    %rbx,%rbp
not    %rbp
add    %r15,%rbp
test   $0x3,%r15b
je     1d13 <sumGammaAsc+0xbf3>
mov    %rdi,%rcx
lea    (%rdi,%rbx,8),%rcx
mov    0x30(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
xor    %esi,%esi
mov    0x50(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm0
mulsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1ce0 <sumGammaAsc+0xbc0>
add    %rsi,%rbx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
cmp    $0x3,%rbp
mov    0x10(%rsp),%rbp
jb     1340 <sumGammaAsc+0x220>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15,%rsi
mov    0xb8(%rsp),%r15
movsd  (%r15,%rbx,8),%xmm0
mov    0x30(%rsp),%rax
mulsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
movsd  0x8(%r15,%rbx,8),%xmm0
mulsd  0x8(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rbx,8)
movsd  0x10(%r15,%rbx,8),%xmm0
mulsd  0x10(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rbx,8)
movsd  0x18(%r15,%rbx,8),%xmm0
mov    %rsi,%r15
mulsd  0x18(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1d30 <sumGammaAsc+0xc10>
jmp    1340 <sumGammaAsc+0x220>
mov    0x130(%rsp),%rax
mov    0x88(%rsp),%rdi
add    %rdi,%rax
add    0x128(%rsp),%rdi
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
lea    (%rcx,%rdi,8),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%rax,8),%r8
lea    (%rdx,%rdi,8),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rax,8),%rbx
lea    (%rsi,%rdi,8),%rax
cmp    %rdx,%rbp
setb   %sil
cmp    %rcx,%r8
setb   %dl
cmp    %rax,%rbp
setb   %al
cmp    %rcx,%rbx
setb   %cl
test   %dl,%sil
jne    1ed5 <sumGammaAsc+0xdb5>
mov    %r8,0xa0(%rsp)
mov    %rbx,0x88(%rsp)
mov    $0x0,%ebx
and    %cl,%al
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
jne    1ca0 <sumGammaAsc+0xb80>
cmpq   $0x0,0xc0(%rsp)
mov    %rbp,0x98(%rsp)
je     1ef4 <sumGammaAsc+0xdd4>
mov    0xe8(%rsp),%rbp
xor    %ebx,%ebx
mov    0xc8(%rsp),%rax
mov    0xd8(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rax,%rbx,8),%xmm0
movupd -0x20(%rax,%rbx,8),%xmm1
movupd -0x30(%r12,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r12,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rcx,%rbx,8)
movupd %xmm0,-0x20(%rcx,%rbx,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movupd -0x10(%r12,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r12,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rcx,%rbx,8)
movupd %xmm0,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1e70 <sumGammaAsc+0xd50>
jmp    1ef6 <sumGammaAsc+0xdd6>
xor    %ebx,%ebx
mov    0x28(%rsp),%rdx
mov    (%rsp),%r11
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x38(%rsp),%rdi
jmp    1ca0 <sumGammaAsc+0xb80>
xor    %ebx,%ebx
testb  $0x1,0xf0(%rsp)
01
mov    0x10(%rsp),%rbp
mov    0x38(%rsp),%rdi
je     1f4b <sumGammaAsc+0xe2b>
mov    0xa0(%rsp),%rax
movupd (%rax,%rbx,8),%xmm0
movupd 0x10(%rax,%rbx,8),%xmm1
mov    0x88(%rsp),%rax
movupd (%rax,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x98(%rsp),%rax
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
je     1340 <sumGammaAsc+0x220>
jmp    1ca0 <sumGammaAsc+0xb80>
test   %ebp,%ebp
jle    34db <sumGammaAsc+0x23bb>
movslq %r14d,%r8
mov    %ebp,%eax
mov    %rax,0xb8(%rsp)
mov    0x1b0(%rsp),%eax
mov    %eax,%edx
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rcx,1),%rax
mov    %rax,0x40(%rsp)
lea    (%rcx,%rcx,2),%rbp
lea    0x0(%rbp,%rdx,1),%rax
mov    %rax,0xa8(%rsp)
mov    0xe0(%rsp),%r9
lea    (%r9,%rdx,8),%rax
mov    %rax,0x10(%rsp)
lea    (%rdx,%rcx,2),%rax
mov    %rax,0xb0(%rsp)
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x60(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x68(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0x18(%rsp)
mov    %rcx,%rsi
shl    $0x4,%rsi
mov    0x48(%rsp),%r13
lea    (%rsi,%r13,1),%rax
add    $0x30,%rax
add    %r13,%rsi
lea    (%rcx,%rdx,1),%rdi
mov    %rdi,0x50(%rsp)
lea    0x30(%r9),%rdi
mov    %rdi,0x90(%rsp)
lea    0x30(%r13),%r10
mov    %r8,0x78(%rsp)
lea    0x0(,%r8,8),%r8
lea    0x18(%r9),%rdi
mov    %rdi,0x70(%rsp)
lea    0x30(%r13,%rcx,8),%r9
lea    0x0(%r13,%rcx,8),%r14
lea    0x30(,%rbp,8),%r15
add    %r13,%r15
mov    %rbp,0x110(%rsp)
lea    0x0(,%rbp,8),%r12
add    %r13,%r12
xor    %r11d,%r11d
mov    %r8,0x58(%rsp)
jmp    20aa <sumGammaAsc+0xf8a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    %r8,%r10
add    %r8,%r13
add    %r8,%r9
add    %r8,%r14
add    %r8,%rax
add    %r8,%rsi
add    %r8,%r15
add    %r8,%r12
cmp    0xb8(%rsp),%r11
je     34db <sumGammaAsc+0x23bb>
mov    0x1b0(%rsp),%ecx
test   %ecx,%ecx
jle    2080 <sumGammaAsc+0xf60>
mov    %r11,%rcx
imul   0x78(%rsp),%rcx
mov    %rcx,(%rsp)
movzbl 0x150(%rsp,%r11,1),%edi
imul   0xd0(%rsp),%rdi
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rdi,8),%rbp
mov    0x1b0(%rsp),%ecx
cmp    $0x4,%ecx
mov    %rdi,0x30(%rsp)
jae    2100 <sumGammaAsc+0xfe0>
xor    %edi,%edi
jmp    2200 <sumGammaAsc+0x10e0>
nopl   0x0(%rax,%rax,1)
mov    %r11,0x8(%rsp)
mov    %rdi,%rbx
mov    0x48(%rsp),%rdi
mov    (%rsp),%rcx
lea    (%rdi,%rcx,8),%r11
mov    0x10(%rsp),%rcx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
mov    %r11,0x38(%rsp)
cmp    %rcx,%r11
jae    2145 <sumGammaAsc+0x1025>
lea    (%rbx,%rdx,1),%rcx
lea    (%rdi,%rcx,8),%rcx
cmp    %rcx,%rbp
jae    2145 <sumGammaAsc+0x1025>
xor    %edi,%edi
mov    0x8(%rsp),%r11
jmp    2200 <sumGammaAsc+0x10e0>
cmpq   $0x0,0x28(%rsp)
je     2760 <sumGammaAsc+0x1640>
mov    0x90(%rsp),%rcx
mov    0x30(%rsp),%rdi
lea    (%rcx,%rdi,8),%rbx
mov    0x68(%rsp),%rdi
xor    %ecx,%ecx
mov    0x8(%rsp),%r11
xchg   %ax,%ax
movupd -0x30(%rbx,%rcx,8),%xmm0
movupd -0x20(%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x30(%r10,%rcx,8)
movupd %xmm1,-0x20(%r10,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm0
movupd (%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x10(%r10,%rcx,8)
movupd %xmm1,(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    2170 <sumGammaAsc+0x1050>
testb  $0x1,0x60(%rsp)
je     21e7 <sumGammaAsc+0x10c7>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
mov    0x38(%rsp),%rdi
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdi
cmp    %rdx,%rcx
mov    (%rsp),%rbx
je     22ac <sumGammaAsc+0x118c>
nopl   0x0(%rax)
mov    %rdi,%rcx
not    %rcx
add    %rdx,%rcx
mov    0x18(%rsp),%rbx
test   %rbx,%rbx
je     223b <sumGammaAsc+0x111b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    2220 <sumGammaAsc+0x1100>
cmp    $0x3,%rcx
mov    (%rsp),%rbx
jb     22ac <sumGammaAsc+0x118c>
mov    0x70(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x0(%r13,%rdi,8)
movsd  -0x10(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%r13,%rdi,8)
movsd  -0x8(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%r13,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%r13,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    2260 <sumGammaAsc+0x1140>
mov    0x1b0(%rsp),%ecx
test   %ecx,%ecx
jle    2080 <sumGammaAsc+0xf60>
mov    0x1b0(%rsp),%ecx
cmp    $0x4,%ecx
jae    22ce <sumGammaAsc+0x11ae>
xor    %edi,%edi
jmp    23e0 <sumGammaAsc+0x12c0>
mov    0xd0(%rsp),%rcx
add    %rbx,%rcx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rcx,8),%r8
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
mov    %r8,0x8(%rsp)
cmp    %rcx,%r8
jae    231b <sumGammaAsc+0x11fb>
mov    0x50(%rsp),%rcx
add    %rbx,%rcx
lea    (%rdi,%rcx,8),%rcx
cmp    %rcx,%rbp
jae    231b <sumGammaAsc+0x11fb>
xor    %edi,%edi
mov    0x58(%rsp),%r8
jmp    23e0 <sumGammaAsc+0x12c0>
cmpq   $0x0,0x28(%rsp)
je     282d <sumGammaAsc+0x170d>
mov    0x90(%rsp),%rcx
mov    0x30(%rsp),%rdi
lea    (%rcx,%rdi,8),%rbx
mov    0x68(%rsp),%rdi
xor    %ecx,%ecx
mov    0x58(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rbx,%rcx,8),%xmm0
movupd -0x20(%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x30(%r9,%rcx,8)
movupd %xmm1,-0x20(%r9,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm0
movupd (%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x10(%r9,%rcx,8)
movupd %xmm1,(%r9,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    2350 <sumGammaAsc+0x1230>
testb  $0x1,0x60(%rsp)
je     23c7 <sumGammaAsc+0x12a7>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
mov    0x8(%rsp),%rdi
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdi
cmp    %rdx,%rcx
mov    (%rsp),%rbx
je     248b <sumGammaAsc+0x136b>
nopl   0x0(%rax)
mov    %rdi,%rcx
not    %rcx
add    %rdx,%rcx
test   $0x3,%dl
je     241a <sumGammaAsc+0x12fa>
mov    0x18(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    2400 <sumGammaAsc+0x12e0>
cmp    $0x3,%rcx
mov    (%rsp),%rbx
jb     248b <sumGammaAsc+0x136b>
mov    0x70(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r14,%rdi,8)
movsd  -0x10(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%r14,%rdi,8)
movsd  -0x8(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%r14,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    2440 <sumGammaAsc+0x1320>
mov    0x1b0(%rsp),%ecx
test   %ecx,%ecx
jle    2080 <sumGammaAsc+0xf60>
mov    0x1b0(%rsp),%ecx
cmp    $0x4,%ecx
jb     24f4 <sumGammaAsc+0x13d4>
mov    0x40(%rsp),%rcx
add    %rbx,%rcx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
mov    %rdi,0x8(%rsp)
cmp    %rcx,%rdi
jae    259c <sumGammaAsc+0x147c>
mov    0xb0(%rsp),%rcx
add    %rbx,%rcx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
cmp    %rcx,%rbp
jae    259c <sumGammaAsc+0x147c>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %rdx,%rcx
test   $0x3,%dl
je     2529 <sumGammaAsc+0x1409>
mov    0x18(%rsp),%rbx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    2510 <sumGammaAsc+0x13f0>
cmp    $0x3,%rcx
mov    (%rsp),%rbx
jb     2650 <sumGammaAsc+0x1530>
mov    0x70(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    (%rsp),%rbx
nopl   0x0(%rax)
movsd  -0x18(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
movsd  -0x10(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsi,%rdi,8)
movsd  -0x8(%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsi,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    2550 <sumGammaAsc+0x1430>
jmp    2650 <sumGammaAsc+0x1530>
cmpq   $0x0,0x28(%rsp)
je     2844 <sumGammaAsc+0x1724>
mov    0x90(%rsp),%rcx
mov    0x30(%rsp),%rdi
lea    (%rcx,%rdi,8),%rbx
mov    0x68(%rsp),%rdi
xor    %ecx,%ecx
movupd -0x30(%rbx,%rcx,8),%xmm0
movupd -0x20(%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x30(%rax,%rcx,8)
movupd %xmm1,-0x20(%rax,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm0
movupd (%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x10(%rax,%rcx,8)
movupd %xmm1,(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    25c0 <sumGammaAsc+0x14a0>
testb  $0x1,0x60(%rsp)
je     2633 <sumGammaAsc+0x1513>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
mov    0x8(%rsp),%rdi
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdi
cmp    %rdx,%rcx
mov    (%rsp),%rbx
jne    24f6 <sumGammaAsc+0x13d6>
nopl   0x0(%rax,%rax,1)
mov    0x1b0(%rsp),%ecx
test   %ecx,%ecx
jle    2080 <sumGammaAsc+0xf60>
mov    0x1b0(%rsp),%ecx
cmp    $0x4,%ecx
jb     26b9 <sumGammaAsc+0x1599>
mov    0x110(%rsp),%rcx
add    %rbx,%rcx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdi
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%rbx
lea    (%rcx,%rbx,8),%rcx
mov    %rdi,0x8(%rsp)
cmp    %rcx,%rdi
jae    2777 <sumGammaAsc+0x1657>
mov    (%rsp),%rdi
add    0xa8(%rsp),%rdi
mov    0x48(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
cmp    %rcx,%rbp
jae    2777 <sumGammaAsc+0x1657>
xor    %ecx,%ecx
mov    %rcx,%rdi
not    %rdi
add    %rdx,%rdi
test   $0x3,%dl
je     26ea <sumGammaAsc+0x15ca>
mov    0x18(%rsp),%rbx
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    26d0 <sumGammaAsc+0x15b0>
cmp    $0x3,%rdi
jb     2080 <sumGammaAsc+0xf60>
mov    0x70(%rsp),%rdi
mov    0x30(%rsp),%rbx
lea    (%rdi,%rbx,8),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x18(%rdi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
movsd  -0x10(%rdi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%r12,%rcx,8)
movsd  -0x8(%rdi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%r12,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%r12,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    2710 <sumGammaAsc+0x15f0>
jmp    2080 <sumGammaAsc+0xf60>
xor    %ecx,%ecx
mov    0x8(%rsp),%r11
testb  $0x1,0x60(%rsp)
jne    21c3 <sumGammaAsc+0x10a3>
jmp    21e7 <sumGammaAsc+0x10c7>
cmpq   $0x0,0x28(%rsp)
je     2856 <sumGammaAsc+0x1736>
mov    0x90(%rsp),%rcx
mov    0x30(%rsp),%rdi
lea    (%rcx,%rdi,8),%rbx
mov    0x68(%rsp),%rdi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rbx,%rcx,8),%xmm0
movupd -0x20(%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x30(%r15,%rcx,8)
movupd %xmm1,-0x20(%r15,%rcx,8)
movupd -0x10(%rbx,%rcx,8),%xmm0
movupd (%rbx,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x10(%r15,%rcx,8)
movupd %xmm1,(%r15,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    27a0 <sumGammaAsc+0x1680>
testb  $0x1,0x60(%rsp)
je     2817 <sumGammaAsc+0x16f7>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
mov    0x8(%rsp),%rdi
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
mov    0x20(%rsp),%rdi
mov    %rdi,%rcx
cmp    %rdx,%rdi
je     2080 <sumGammaAsc+0xf60>
jmp    26bb <sumGammaAsc+0x159b>
xor    %ecx,%ecx
mov    0x58(%rsp),%r8
testb  $0x1,0x60(%rsp)
jne    23a3 <sumGammaAsc+0x1283>
jmp    23c7 <sumGammaAsc+0x12a7>
xor    %ecx,%ecx
testb  $0x1,0x60(%rsp)
jne    260f <sumGammaAsc+0x14ef>
jmp    2633 <sumGammaAsc+0x1513>
xor    %ecx,%ecx
testb  $0x1,0x60(%rsp)
jne    27f3 <sumGammaAsc+0x16d3>
jmp    2817 <sumGammaAsc+0x16f7>
test   %ebp,%ebp
jle    34db <sumGammaAsc+0x23bb>
movslq %r14d,%r8
mov    %ebp,%eax
mov    %rax,0x68(%rsp)
mov    0x1b0(%rsp),%eax
mov    %eax,%r11d
mov    0xd0(%rsp),%rax
lea    (%rax,%rax,1),%rcx
mov    %rcx,0xf0(%rsp)
lea    (%rax,%rax,2),%rbx
lea    (%rbx,%r11,1),%rcx
mov    %rcx,0xe8(%rsp)
mov    %r11d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0xd8(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x108(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x100(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x88(%rsp)
mov    %r11d,%ecx
and    $0x3,%ecx
mov    %rcx,0x50(%rsp)
mov    %rax,%r10
shl    $0x4,%r10
mov    0x60(%rsp),%rcx
lea    (%rcx,%r10,1),%r13
add    $0x30,%r13
mov    0x48(%rsp),%rbp
lea    (%r10,%rbp,1),%r15
add    $0x30,%r15
lea    (%r10,%rbp,1),%r14
add    %rcx,%r10
mov    0xe0(%rsp),%rdx
lea    (%rdx,%r11,8),%rsi
mov    %rsi,0xb0(%rsp)
lea    (%r11,%rax,2),%rdi
mov    %rdi,0xa0(%rsp)
lea    (%rax,%r11,1),%rsi
mov    %rsi,0xf8(%rsp)
lea    0x30(%rdx),%rdi
mov    %rdi,0x80(%rsp)
lea    0x30(%rcx),%rsi
mov    %rsi,0x20(%rsp)
mov    %r8,0x110(%rsp)
lea    0x0(,%r8,8),%rdi
mov    %rdi,0x90(%rsp)
lea    0x30(%rbp),%r9
lea    0x18(%rdx),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x30(%rcx,%rax,8),%rdx
mov    %rdx,0x8(%rsp)
lea    0x30(%rbp,%rax,8),%rdx
mov    %rdx,0x38(%rsp)
lea    0x0(%rbp,%rax,8),%r12
lea    (%rcx,%rax,8),%r8
lea    0x30(%rcx,%rbx,8),%rax
mov    %rax,0x70(%rsp)
lea    0x30(%rbp,%rbx,8),%rdx
mov    %rdx,0x28(%rsp)
lea    0x0(%rbp,%rbx,8),%rdx
mov    %rdx,0x30(%rsp)
mov    %rbx,0x98(%rsp)
lea    (%rcx,%rbx,8),%rdi
mov    %r11,%rsi
xor    %eax,%eax
mov    %rax,0xb8(%rsp)
mov    %r11,0xc0(%rsp)
jmp    2a4a <sumGammaAsc+0x192a>
nopw   0x0(%rax,%rax,1)
mov    0xb8(%rsp),%rdx
add    $0x1,%rdx
mov    0x90(%rsp),%rax
add    %rax,0x20(%rsp)
add    %rax,%r9
add    %rax,%rbp
add    %rax,%rcx
add    %rax,0x8(%rsp)
add    %rax,0x38(%rsp)
add    %rax,%r12
add    %rax,%r8
add    %rax,%r13
add    %rax,%r15
add    %rax,%r14
add    %rax,%r10
add    %rax,0x70(%rsp)
add    %rax,0x28(%rsp)
add    %rax,0x30(%rsp)
mov    (%rsp),%rdi
add    %rax,%rdi
mov    %rdx,%rax
mov    %rdx,0xb8(%rsp)
cmp    0x68(%rsp),%rdx
je     34db <sumGammaAsc+0x23bb>
mov    %rdi,(%rsp)
mov    0x1b0(%rsp),%eax
test   %eax,%eax
jle    29e0 <sumGammaAsc+0x18c0>
mov    0xb8(%rsp),%rax
mov    %r15,%rbx
mov    %rax,%r15
imul   0x110(%rsp),%r15
movzbl 0x150(%rsp,%rax,1),%edx
imul   0xd0(%rsp),%rdx
mov    0xe0(%rsp),%rax
lea    (%rax,%rdx,8),%r11
mov    %rdx,%rax
mov    0x1b0(%rsp),%edx
cmp    $0x4,%edx
mov    %r13,0x10(%rsp)
mov    %rbx,0x78(%rsp)
mov    %rax,0x18(%rsp)
mov    %r15,0x58(%rsp)
jae    2ac0 <sumGammaAsc+0x19a0>
xor    %edi,%edi
mov    %rbx,%r15
jmp    2c60 <sumGammaAsc+0x1b40>
nopw   0x0(%rax,%rax,1)
mov    %r9,0x40(%rsp)
lea    (%r15,%rsi,1),%rdx
mov    0x48(%rsp),%rdi
lea    (%rdi,%r15,8),%r9
lea    (%rdi,%rdx,8),%rdi
mov    0x60(%rsp),%rbx
lea    (%rbx,%r15,8),%r13
lea    (%rbx,%rdx,8),%rdx
mov    0xb0(%rsp),%rax
mov    0x18(%rsp),%rbx
lea    (%rax,%rbx,8),%rbx
cmp    %rbx,%r9
setb   %bl
cmp    %rdi,%r11
setb   %r15b
mov    %r9,%rax
cmp    %rdx,%r9
setb   %dl
mov    %r13,0xc8(%rsp)
cmp    %rdi,%r13
setb   %r9b
test   %r15b,%bl
jne    2be5 <sumGammaAsc+0x1ac5>
mov    $0x0,%edi
and    %r9b,%dl
mov    0x78(%rsp),%r15
mov    0x40(%rsp),%r9
jne    2c60 <sumGammaAsc+0x1b40>
cmpq   $0x0,0x108(%rsp)
mov    %rax,0x118(%rsp)
je     2bf3 <sumGammaAsc+0x1ad3>
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
mov    0x88(%rsp),%rbx
xor    %edi,%edi
mov    0x20(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r9,%rdi,8)
movupd %xmm0,-0x20(%r9,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
movupd (%rdx,%rdi,8),%xmm1
movupd -0x10(%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r9,%rdi,8)
movupd %xmm0,(%r9,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2b80 <sumGammaAsc+0x1a60>
jmp    2bf5 <sumGammaAsc+0x1ad5>
xor    %edi,%edi
mov    0x78(%rsp),%r15
mov    0x40(%rsp),%r9
jmp    2c60 <sumGammaAsc+0x1b40>
xor    %edi,%edi
testb  $0x1,0x100(%rsp)
01
mov    0x10(%rsp),%r13
je     2c3f <sumGammaAsc+0x1b1f>
movupd (%r11,%rdi,8),%xmm0
movupd 0x10(%r11,%rdi,8),%xmm1
mov    0xc8(%rsp),%rax
movupd (%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x118(%rsp),%rax
movupd %xmm2,(%rax,%rdi,8)
movupd %xmm0,0x10(%rax,%rdi,8)
mov    0xd8(%rsp),%rdx
mov    %rdx,%rdi
cmp    %rsi,%rdx
je     2d0f <sumGammaAsc+0x1bef>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdi,%rdx
not    %rdx
add    %rsi,%rdx
mov    0x50(%rsp),%rbx
test   %rbx,%rbx
je     2c9b <sumGammaAsc+0x1b7b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r11,%rdi,8),%xmm0
mulsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    2c80 <sumGammaAsc+0x1b60>
cmp    $0x3,%rdx
mov    0x10(%rsp),%r13
jb     2d0f <sumGammaAsc+0x1bef>
mov    0xa8(%rsp),%rdx
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rdi,8),%xmm0
mulsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
movsd  -0x10(%rdx,%rdi,8),%xmm0
mulsd  0x8(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rdi,8)
movsd  -0x8(%rdx,%rdi,8),%xmm0
mulsd  0x10(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
mulsd  0x18(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    2cc0 <sumGammaAsc+0x1ba0>
mov    0x1b0(%rsp),%edx
test   %edx,%edx
jle    29e0 <sumGammaAsc+0x18c0>
mov    0x1b0(%rsp),%edx
cmp    $0x4,%edx
jae    2d37 <sumGammaAsc+0x1c17>
xor    %r15d,%r15d
mov    0x18(%rsp),%rax
jmp    2f00 <sumGammaAsc+0x1de0>
mov    0xd0(%rsp),%rdx
mov    0x58(%rsp),%rdi
lea    (%rdi,%rdx,1),%r15
mov    0xf8(%rsp),%rax
add    %rax,%rdi
mov    0x48(%rsp),%rbx
lea    (%rbx,%r15,8),%rdx
lea    (%rbx,%rdi,8),%r13
mov    0x60(%rsp),%rax
lea    (%rax,%r15,8),%rbx
lea    (%rax,%rdi,8),%rax
mov    %rax,0x40(%rsp)
mov    0xb0(%rsp),%rax
mov    0x18(%rsp),%rdi
lea    (%rax,%rdi,8),%rdi
cmp    %rdi,%rdx
setb   %dil
cmp    %r13,%r11
setb   %r15b
mov    %rdx,%rax
cmp    0x40(%rsp),%rdx
setb   %dl
mov    %rbx,0xc8(%rsp)
cmp    %r13,%rbx
setb   %bl
test   %r15b,%dil
jne    2e71 <sumGammaAsc+0x1d51>
mov    %rax,0x118(%rsp)
mov    $0x0,%r15d
and    %bl,%dl
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rax
jne    2f00 <sumGammaAsc+0x1de0>
mov    %r9,0x40(%rsp)
cmpq   $0x0,0x108(%rsp)
mov    0x8(%rsp),%rsi
mov    0x38(%rsp),%rax
je     2e83 <sumGammaAsc+0x1d63>
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rdi
lea    (%rdx,%rdi,8),%rdx
mov    0x88(%rsp),%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%rsi,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rax,%rdi,8)
movupd %xmm0,-0x20(%rax,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
movupd (%rdx,%rdi,8),%xmm1
movupd -0x10(%rsi,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdi,8)
movupd %xmm0,(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2e10 <sumGammaAsc+0x1cf0>
jmp    2e85 <sumGammaAsc+0x1d65>
xor    %r15d,%r15d
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rax
jmp    2f00 <sumGammaAsc+0x1de0>
xor    %edi,%edi
testb  $0x1,0x100(%rsp)
01
mov    0x10(%rsp),%r13
je     2ecf <sumGammaAsc+0x1daf>
movupd (%r11,%rdi,8),%xmm0
movupd 0x10(%r11,%rdi,8),%xmm1
mov    0xc8(%rsp),%rax
movupd (%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x118(%rsp),%rax
movupd %xmm2,(%rax,%rdi,8)
movupd %xmm0,0x10(%rax,%rdi,8)
mov    0xd8(%rsp),%rdx
mov    %rdx,%r15
mov    0xc0(%rsp),%rsi
cmp    %rsi,%rdx
mov    0x40(%rsp),%r9
mov    0x18(%rsp),%rax
je     2faa <sumGammaAsc+0x1e8a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rdx
not    %rdx
add    %rsi,%rdx
test   $0x3,%sil
je     2f3c <sumGammaAsc+0x1e1c>
mov    0x50(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r11,%r15,8),%xmm0
mulsd  (%r8,%r15,8),%xmm0
movsd  %xmm0,(%r12,%r15,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rdi
jne    2f20 <sumGammaAsc+0x1e00>
cmp    $0x3,%rdx
jb     2faa <sumGammaAsc+0x1e8a>
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
xchg   %ax,%ax
movsd  -0x18(%rdx,%r15,8),%xmm0
mulsd  (%r8,%r15,8),%xmm0
movsd  %xmm0,(%r12,%r15,8)
movsd  -0x10(%rdx,%r15,8),%xmm0
mulsd  0x8(%r8,%r15,8),%xmm0
movsd  %xmm0,0x8(%r12,%r15,8)
movsd  -0x8(%rdx,%r15,8),%xmm0
mulsd  0x10(%r8,%r15,8),%xmm0
movsd  %xmm0,0x10(%r12,%r15,8)
movsd  (%rdx,%r15,8),%xmm0
mulsd  0x18(%r8,%r15,8),%xmm0
movsd  %xmm0,0x18(%r12,%r15,8)
add    $0x4,%r15
cmp    %r15,%rsi
jne    2f50 <sumGammaAsc+0x1e30>
mov    0x1b0(%rsp),%edx
test   %edx,%edx
mov    0x78(%rsp),%r15
jle    29e0 <sumGammaAsc+0x18c0>
mov    0x1b0(%rsp),%edx
cmp    $0x4,%edx
jb     310d <sumGammaAsc+0x1fed>
mov    0xf0(%rsp),%rdx
mov    0x58(%rsp),%rax
lea    (%rdx,%rax,1),%r15
mov    0xa0(%rsp),%rdx
lea    (%rdx,%rax,1),%rdi
mov    0x48(%rsp),%rbx
lea    (%rbx,%r15,8),%rdx
lea    (%rbx,%rdi,8),%rbx
mov    0x60(%rsp),%rax
lea    (%rax,%r15,8),%r13
lea    (%rax,%rdi,8),%rax
mov    %rax,0x40(%rsp)
mov    0xb0(%rsp),%rax
mov    0x18(%rsp),%rdi
lea    (%rax,%rdi,8),%rdi
mov    0x18(%rsp),%rax
cmp    %rdi,%rdx
setb   %dil
cmp    %rbx,%r11
setb   %r15b
mov    %rdx,0xc8(%rsp)
cmp    0x40(%rsp),%rdx
setb   %dl
mov    %r13,0x40(%rsp)
cmp    %rbx,%r13
setb   %bl
test   %r15b,%dil
jne    310d <sumGammaAsc+0x1fed>
mov    $0x0,%edi
and    %bl,%dl
mov    0x10(%rsp),%r15
jne    310f <sumGammaAsc+0x1fef>
cmpq   $0x0,0x108(%rsp)
je     31cb <sumGammaAsc+0x20ab>
mov    %rax,%rdi
mov    0x70(%rsp),%rax
mov    %r9,%rsi
mov    0x80(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    0x88(%rsp),%rbx
xor    %edi,%edi
mov    0x78(%rsp),%r13
nopl   0x0(%rax)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%r15,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r15,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r13,%rdi,8)
movupd %xmm0,-0x20(%r13,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
movupd (%rdx,%rdi,8),%xmm1
movupd -0x10(%r15,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r15,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r13,%rdi,8)
movupd %xmm0,0x0(%r13,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    30a0 <sumGammaAsc+0x1f80>
jmp    31d5 <sumGammaAsc+0x20b5>
xor    %edi,%edi
mov    %rdi,%rdx
not    %rdx
add    %rsi,%rdx
test   $0x3,%sil
je     314c <sumGammaAsc+0x202c>
mov    0x50(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r11,%rdi,8),%xmm0
mulsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    3130 <sumGammaAsc+0x2010>
cmp    $0x3,%rdx
mov    0x10(%rsp),%r13
jb     3250 <sumGammaAsc+0x2130>
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rdi,8),%xmm0
mulsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
movsd  -0x10(%rdx,%rdi,8),%xmm0
mulsd  0x8(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdi,8)
movsd  -0x8(%rdx,%rdi,8),%xmm0
mulsd  0x10(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
mulsd  0x18(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    3170 <sumGammaAsc+0x2050>
jmp    3250 <sumGammaAsc+0x2130>
mov    0x70(%rsp),%rax
mov    %r9,%rsi
xor    %edi,%edi
mov    %rax,0x70(%rsp)
testb  $0x1,0x100(%rsp)
01
mov    %rsi,%r9
je     321f <sumGammaAsc+0x20ff>
movupd (%r11,%rdi,8),%xmm0
movupd 0x10(%r11,%rdi,8),%xmm1
mov    0x40(%rsp),%rax
movupd (%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xc8(%rsp),%rax
movupd %xmm2,(%rax,%rdi,8)
movupd %xmm0,0x10(%rax,%rdi,8)
mov    0xd8(%rsp),%rdx
mov    %rdx,%rdi
mov    0xc0(%rsp),%rsi
cmp    %rsi,%rdx
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rax
jne    310f <sumGammaAsc+0x1fef>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x1b0(%rsp),%edx
test   %edx,%edx
mov    0x78(%rsp),%r15
jle    29e0 <sumGammaAsc+0x18c0>
mov    0x1b0(%rsp),%edx
cmp    $0x4,%edx
jae    333c <sumGammaAsc+0x221c>
xor    %edi,%edi
mov    %rdi,%rdx
not    %rdx
add    %rsi,%rdx
test   $0x3,%sil
je     32bc <sumGammaAsc+0x219c>
mov    0x50(%rsp),%rbx
mov    0x30(%rsp),%rax
mov    (%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r11,%rdi,8),%xmm0
mulsd  0x0(%r13,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    32a0 <sumGammaAsc+0x2180>
cmp    $0x3,%rdx
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rax
jb     29e0 <sumGammaAsc+0x18c0>
mov    %rax,%rdx
mov    0xa8(%rsp),%rax
lea    (%rax,%rdx,8),%rax
nop
movsd  -0x18(%rax,%rdi,8),%xmm0
mov    (%rsp),%rbx
mulsd  (%rbx,%rdi,8),%xmm0
mov    0x30(%rsp),%rdx
movsd  %xmm0,(%rdx,%rdi,8)
movsd  -0x10(%rax,%rdi,8),%xmm0
mulsd  0x8(%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  0x10(%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rdi,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  0x18(%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    32e0 <sumGammaAsc+0x21c0>
jmp    29e0 <sumGammaAsc+0x18c0>
mov    0x98(%rsp),%rdx
mov    0x58(%rsp),%rax
lea    (%rdx,%rax,1),%r15
add    0xe8(%rsp),%rax
mov    0x48(%rsp),%rdi
lea    (%rdi,%r15,8),%rdx
lea    (%rdi,%rax,8),%rdi
mov    0x60(%rsp),%rbx
lea    (%rbx,%r15,8),%r13
lea    (%rbx,%rax,8),%rax
mov    %rax,0x58(%rsp)
mov    0xb0(%rsp),%rax
mov    0x18(%rsp),%rbx
lea    (%rax,%rbx,8),%rbx
cmp    %rbx,%rdx
setb   %bl
cmp    %rdi,%r11
setb   %r15b
mov    %rdx,%rax
cmp    0x58(%rsp),%rdx
setb   %dl
mov    %r13,0x58(%rsp)
cmp    %rdi,%r13
setb   %r13b
test   %r15b,%bl
jne    3461 <sumGammaAsc+0x2341>
mov    $0x0,%edi
and    %r13b,%dl
mov    0x78(%rsp),%r15
jne    3276 <sumGammaAsc+0x2156>
cmpq   $0x0,0x108(%rsp)
mov    %rax,0x40(%rsp)
je     346d <sumGammaAsc+0x234d>
mov    0x80(%rsp),%rdx
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
mov    0x88(%rsp),%rbx
xor    %edi,%edi
mov    0x28(%rsp),%rax
mov    0x70(%rsp),%rsi
xchg   %ax,%ax
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%rsi,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rax,%rdi,8)
movupd %xmm0,-0x20(%rax,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
movupd (%rdx,%rdi,8),%xmm1
movupd -0x10(%rsi,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdi,8)
movupd %xmm0,(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    3400 <sumGammaAsc+0x22e0>
jmp    346f <sumGammaAsc+0x234f>
xor    %edi,%edi
mov    0x78(%rsp),%r15
jmp    3276 <sumGammaAsc+0x2156>
xor    %edi,%edi
testb  $0x1,0x100(%rsp)
01
mov    0x10(%rsp),%r13
je     34b3 <sumGammaAsc+0x2393>
movupd (%r11,%rdi,8),%xmm0
movupd 0x10(%r11,%rdi,8),%xmm1
mov    0x58(%rsp),%rax
movupd (%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdi,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x40(%rsp),%rax
movupd %xmm2,(%rax,%rdi,8)
movupd %xmm0,0x10(%rax,%rdi,8)
mov    0xd8(%rsp),%rdx
mov    %rdx,%rdi
mov    0xc0(%rsp),%rsi
cmp    %rsi,%rdx
je     29e0 <sumGammaAsc+0x18c0>
jmp    3276 <sumGammaAsc+0x2156>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @sumGammaAsc(i32 %0, double* %1, double* %2, double* %3, double* %4, i32 %5, i32 %6) {
%8 = alloca i32
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca i32
%22 = alloca [32 x i8]
store i32 %0, i32* %8
store double* %1, double** %9
store double* %2, double** %10
store double* %3, double** %11
store double* %4, double** %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%23 = load i32, i32* %14
%24 = mul nsw i32 %23, 4
store i32 %24, i32* %21
%25 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 0
%26 = load i32, i32* %14
%27 = call i32 @ascertainmentBiasSequence(i8* %25, i32 %26)
%28 = load i32, i32* %8
switch i32 %28, label %245 [
i32 0, label %29
i32 1, label %101
i32 2, label %173
]
29: ; preds = %7
store i32 0, i32* %15
br label %30
30: ; preds = %97, %29
%31 = load i32, i32* %15
%32 = load i32, i32* %13
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %100
34: ; preds = %30
%35 = load double*, double** %12
%36 = load i32, i32* %14
%37 = load i32, i32* %15
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 %38
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = mul nsw i32 %36, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %35, i64 %43
store double* %44, double** %18
%45 = load double*, double** %12
%46 = load i32, i32* %14
%47 = load i32, i32* %15
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 %48
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = mul nsw i32 %46, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %45, i64 %53
store double* %54, double** %19
store i32 0, i32* %16
br label %55
55: ; preds = %93, %34
%56 = load i32, i32* %16
%57 = icmp slt i32 %56, 4
br i1 %57, label %58, label %96
58: ; preds = %55
%59 = load double*, double** %9
%60 = load i32, i32* %15
%61 = load i32, i32* %21
%62 = mul nsw i32 %60, %61
%63 = load i32, i32* %16
%64 = load i32, i32* %14
%65 = mul nsw i32 %63, %64
%66 = add nsw i32 %62, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %59, i64 %67
store double* %68, double** %20
store i32 0, i32* %17
br label %69
69: ; preds = %89, %58
%70 = load i32, i32* %17
%71 = load i32, i32* %14
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %92
73: ; preds = %69
%74 = load double*, double** %18
%75 = load i32, i32* %17
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
%78 = load double, double* %77
%79 = load double*, double** %19
%80 = load i32, i32* %17
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
%83 = load double, double* %82
%84 = fmul double %78, %83
%85 = load double*, double** %20
%86 = load i32, i32* %17
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double, double* %85, i64 %87
store double %84, double* %88
br label %89
89: ; preds = %73
%90 = load i32, i32* %17
%91 = add nsw i32 %90, 1
store i32 %91, i32* %17
br label %69
92: ; preds = %69
br label %93
93: ; preds = %92
%94 = load i32, i32* %16
%95 = add nsw i32 %94, 1
store i32 %95, i32* %16
br label %55
96: ; preds = %55
br label %97
97: ; preds = %96
%98 = load i32, i32* %15
%99 = add nsw i32 %98, 1
store i32 %99, i32* %15
br label %30
100: ; preds = %30
br label %247
101: ; preds = %7
store i32 0, i32* %15
br label %102
102: ; preds = %169, %101
%103 = load i32, i32* %15
%104 = load i32, i32* %13
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %172
106: ; preds = %102
%107 = load double*, double** %12
%108 = load i32, i32* %14
%109 = load i32, i32* %15
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [32 x i8], [32 x i8]* %22, i64 0, i64 %110
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = mul nsw i32 %108, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %107, i64 %115
store double* %116, double** %18
store i32 0, i32* %16
br label %117
117: ; preds = %165, %106
%118 = load i32, i32* %16
%119 = icmp slt i32 %118, 4
br i1 %119, label %120, label %168
120: ; preds = %117
%121 = load double*, double** %11
%122 = load i32, i32* %21
%123 = load i32, i32* %15
%124 = mul nsw i32 %122, %123
%125 = load i32, i32* %16
%126 = load i32, i32* %14
%127 = mul nsw i32 %125, %126
%128 = add nsw i32 %124, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %121, i64 %129
store double* %130, double** %19
%131 = load double*, double** %9
%132 = load i32, i32* %15
%133 = load i32, i32* %21
%134 = mul nsw i32 %132, %133
%135 = load i32, i32* %16
%136 = load i32, i32* %14
%137 = mul nsw i32 %135, %136
%138 = add nsw i32 %134, %137
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double, double* %131, i64 %139
store double* %140, double** %20
store i32 0, i32* %17
br label %141
141: ; preds = %161, %120
%142 = load i32, i32* %17
%143 = load i32, i32* %14
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %164
145: ; preds = %141
%146 = load double*, double** %18
%147 = load i32, i32* %17
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
%151 = load double*, double** %19
%152 = load i32, i32* %17
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = fmul double %150, %155
%157 = load double*, double** %20
%158 = load i32, i32* %17
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
store double %156, double* %160
br label %161
161: ; preds = %145
%162 = load i32, i32* %17
%163 = add nsw i32 %162, 1
store i32 %163, i32* %17
br label %141
164: ; preds = %141
br label %165
165: ; preds = %164
%166 = load i32, i32* %16
%167 = add nsw i32 %166, 1
store i32 %167, i32* %16
br label %117
168: ; preds = %117
br label %169
169: ; preds = %168
%170 = load i32, i32* %15
%171 = add nsw i32 %170, 1
store i32 %171, i32* %15
br label %102
172: ; preds = %102
br label %247
173: ; preds = %7
store i32 0, i32* %15
br label %174
174: ; preds = %241, %173
%175 = load i32, i32* %15
%176 = load i32, i32* %13
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %244
178: ; preds = %174
store i32 0, i32* %16
br label %179
179: ; preds = %237, %178
%180 = load i32, i32* %16
%181 = icmp slt i32 %180, 4
br i1 %181, label %182, label %240
182: ; preds = %179
%183 = load double*, double** %10
%184 = load i32, i32* %21
%185 = load i32, i32* %15
%186 = mul nsw i32 %184, %185
%187 = load i32, i32* %16
%188 = load i32, i32* %14
%189 = mul nsw i32 %187, %188
%190 = add nsw i32 %186, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %183, i64 %191
store double* %192, double** %18
%193 = load double*, double** %11
%194 = load i32, i32* %21
%195 = load i32, i32* %15
%196 = mul nsw i32 %194, %195
%197 = load i32, i32* %16
%198 = load i32, i32* %14
%199 = mul nsw i32 %197, %198
%200 = add nsw i32 %196, %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %193, i64 %201
store double* %202, double** %19
%203 = load double*, double** %9
%204 = load i32, i32* %15
%205 = load i32, i32* %21
%206 = mul nsw i32 %204, %205
%207 = load i32, i32* %16
%208 = load i32, i32* %14
%209 = mul nsw i32 %207, %208
%210 = add nsw i32 %206, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %203, i64 %211
store double* %212, double** %20
store i32 0, i32* %17
br label %213
213: ; preds = %233, %182
%214 = load i32, i32* %17
%215 = load i32, i32* %14
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %236
217: ; preds = %213
%218 = load double*, double** %18
%219 = load i32, i32* %17
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
%222 = load double, double* %221
%223 = load double*, double** %19
%224 = load i32, i32* %17
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
%227 = load double, double* %226
%228 = fmul double %222, %227
%229 = load double*, double** %20
%230 = load i32, i32* %17
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds double, double* %229, i64 %231
store double %228, double* %232
br label %233
233: ; preds = %217
%234 = load i32, i32* %17
%235 = add nsw i32 %234, 1
store i32 %235, i32* %17
br label %213
236: ; preds = %213
br label %237
237: ; preds = %236
%238 = load i32, i32* %16
%239 = add nsw i32 %238, 1
store i32 %239, i32* %16
br label %179
240: ; preds = %179
br label %241
241: ; preds = %240
%242 = load i32, i32* %15
%243 = add nsw i32 %242, 1
store i32 %243, i32* %15
br label %174
244: ; preds = %174
br label %247
245: ; preds = %7
%246 = call i32 @assert(i32 0)
br label %247
247: ; preds = %245, %244, %172, %100
ret void
}

LLVM IR (-O2):
define void @sumGammaAsc(i32 %0, double* nocapture writeonly %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, i32 %5, i32 %6) {
%8 = alloca [32 x i8]
%9 = shl nsw i32 %6, 2
%10 = getelementptr inbounds [32 x i8], [32 x i8]* %8, i64 0, i64 0
%11 = call i32 @ascertainmentBiasSequence(i8* %10, i32 %6)
switch i32 %0, label %1721 [
i32 0, label %128
i32 1, label %68
i32 2, label %12
]
12: ; preds = %7
%13 = icmp sgt i32 %5, 0
br i1 %13, label %14, label %1723
14: ; preds = %12
%15 = icmp sgt i32 %6, 0
%16 = sext i32 %6 to i64
%17 = sext i32 %9 to i64
%18 = zext i32 %5 to i64
%19 = zext i32 %6 to i64
%20 = zext i32 %6 to i64
%21 = shl nsw i64 %16, 1
%22 = zext i32 %6 to i64
%23 = mul nsw i64 %16, 3
%24 = zext i32 %6 to i64
%25 = add nsw i64 %23, %19
%26 = add nsw i64 %21, %19
%27 = add nsw i64 %16, %19
%28 = and i64 %19, 4294967292
%29 = add nsw i64 %28, -4
%30 = lshr exact i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = icmp ult i32 %6, 4
%33 = and i64 %19, 4294967292
%34 = and i64 %31, 1
%35 = icmp eq i64 %29, 0
%36 = and i64 %31, 9223372036854775806
%37 = icmp eq i64 %34, 0
%38 = icmp eq i64 %33, %19
%39 = and i64 %19, 3
%40 = icmp eq i64 %39, 0
%41 = icmp ult i32 %6, 4
%42 = and i64 %19, 4294967292
%43 = and i64 %31, 1
%44 = icmp eq i64 %29, 0
%45 = and i64 %31, 9223372036854775806
%46 = icmp eq i64 %43, 0
%47 = icmp eq i64 %42, %19
%48 = and i64 %19, 3
%49 = icmp eq i64 %48, 0
%50 = icmp ult i32 %6, 4
%51 = and i64 %19, 4294967292
%52 = and i64 %31, 1
%53 = icmp eq i64 %29, 0
%54 = and i64 %31, 9223372036854775806
%55 = icmp eq i64 %52, 0
%56 = icmp eq i64 %51, %19
%57 = and i64 %19, 3
%58 = icmp eq i64 %57, 0
%59 = icmp ult i32 %6, 4
%60 = and i64 %19, 4294967292
%61 = and i64 %31, 1
%62 = icmp eq i64 %29, 0
%63 = and i64 %31, 9223372036854775806
%64 = icmp eq i64 %61, 0
%65 = icmp eq i64 %60, %19
%66 = and i64 %19, 3
%67 = icmp eq i64 %66, 0
br label %1162
68: ; preds = %7
%69 = icmp sgt i32 %5, 0
br i1 %69, label %70, label %1723
70: ; preds = %68
%71 = icmp sgt i32 %6, 0
%72 = sext i32 %6 to i64
%73 = sext i32 %9 to i64
%74 = zext i32 %5 to i64
%75 = zext i32 %6 to i64
%76 = zext i32 %6 to i64
%77 = shl nsw i64 %72, 1
%78 = zext i32 %6 to i64
%79 = mul nsw i64 %72, 3
%80 = zext i32 %6 to i64
%81 = add nsw i64 %79, %75
%82 = getelementptr double, double* %4, i64 %75
%83 = add nsw i64 %77, %75
%84 = getelementptr double, double* %4, i64 %75
%85 = add nsw i64 %72, %75
%86 = getelementptr double, double* %4, i64 %75
%87 = getelementptr double, double* %4, i64 %75
%88 = and i64 %75, 4294967292
%89 = add nsw i64 %88, -4
%90 = lshr exact i64 %89, 2
%91 = add nuw nsw i64 %90, 1
%92 = icmp ult i32 %6, 4
%93 = and i64 %75, 4294967292
%94 = and i64 %91, 1
%95 = icmp eq i64 %89, 0
%96 = and i64 %91, 9223372036854775806
%97 = icmp eq i64 %94, 0
%98 = icmp eq i64 %93, %75
%99 = and i64 %75, 3
%100 = icmp eq i64 %99, 0
%101 = icmp ult i32 %6, 4
%102 = and i64 %75, 4294967292
%103 = and i64 %91, 1
%104 = icmp eq i64 %89, 0
%105 = and i64 %91, 9223372036854775806
%106 = icmp eq i64 %103, 0
%107 = icmp eq i64 %102, %75
%108 = and i64 %75, 3
%109 = icmp eq i64 %108, 0
%110 = icmp ult i32 %6, 4
%111 = and i64 %75, 4294967292
%112 = and i64 %91, 1
%113 = icmp eq i64 %89, 0
%114 = and i64 %91, 9223372036854775806
%115 = icmp eq i64 %112, 0
%116 = icmp eq i64 %111, %75
%117 = and i64 %75, 3
%118 = icmp eq i64 %117, 0
%119 = icmp ult i32 %6, 4
%120 = and i64 %75, 4294967292
%121 = and i64 %91, 1
%122 = icmp eq i64 %89, 0
%123 = and i64 %91, 9223372036854775806
%124 = icmp eq i64 %121, 0
%125 = icmp eq i64 %120, %75
%126 = and i64 %75, 3
%127 = icmp eq i64 %126, 0
br label %605
128: ; preds = %7
%129 = icmp sgt i32 %5, 0
br i1 %129, label %130, label %1723
130: ; preds = %128
%131 = icmp sgt i32 %6, 0
%132 = sext i32 %6 to i64
%133 = sext i32 %9 to i64
%134 = zext i32 %5 to i64
%135 = zext i32 %6 to i64
%136 = zext i32 %6 to i64
%137 = shl nsw i64 %132, 1
%138 = zext i32 %6 to i64
%139 = mul nsw i64 %132, 3
%140 = zext i32 %6 to i64
%141 = add nsw i64 %139, %135
%142 = getelementptr double, double* %4, i64 %135
%143 = add nsw i64 %137, %135
%144 = getelementptr double, double* %4, i64 %135
%145 = add nsw i64 %132, %135
%146 = getelementptr double, double* %4, i64 %135
%147 = getelementptr double, double* %4, i64 %135
%148 = and i64 %135, 4294967292
%149 = add nsw i64 %148, -4
%150 = lshr exact i64 %149, 2
%151 = add nuw nsw i64 %150, 1
%152 = icmp ult i32 %6, 4
%153 = and i64 %135, 4294967292
%154 = and i64 %151, 1
%155 = icmp eq i64 %149, 0
%156 = and i64 %151, 9223372036854775806
%157 = icmp eq i64 %154, 0
%158 = icmp eq i64 %153, %135
%159 = and i64 %135, 3
%160 = icmp eq i64 %159, 0
%161 = icmp ult i32 %6, 4
%162 = and i64 %135, 4294967292
%163 = and i64 %151, 1
%164 = icmp eq i64 %149, 0
%165 = and i64 %151, 9223372036854775806
%166 = icmp eq i64 %163, 0
%167 = icmp eq i64 %162, %135
%168 = and i64 %135, 3
%169 = icmp eq i64 %168, 0
%170 = icmp ult i32 %6, 4
%171 = and i64 %135, 4294967292
%172 = and i64 %151, 1
%173 = icmp eq i64 %149, 0
%174 = and i64 %151, 9223372036854775806
%175 = icmp eq i64 %172, 0
%176 = icmp eq i64 %171, %135
%177 = and i64 %135, 3
%178 = icmp eq i64 %177, 0
%179 = icmp ult i32 %6, 4
%180 = and i64 %135, 4294967292
%181 = and i64 %151, 1
%182 = icmp eq i64 %149, 0
%183 = and i64 %151, 9223372036854775806
%184 = icmp eq i64 %181, 0
%185 = icmp eq i64 %180, %135
%186 = and i64 %135, 3
%187 = icmp eq i64 %186, 0
br label %188
188: ; preds = %130, %602
%189 = phi i64 [ 0, %130 ], [ %603, %602 ]
%190 = mul i64 %189, %133
%191 = getelementptr double, double* %1, i64 %190
%192 = add i64 %190, %135
%193 = getelementptr double, double* %1, i64 %192
%194 = mul i64 %189, %133
%195 = add i64 %194, %132
%196 = getelementptr double, double* %1, i64 %195
%197 = add i64 %145, %194
%198 = getelementptr double, double* %1, i64 %197
%199 = mul i64 %189, %133
%200 = add i64 %137, %199
%201 = getelementptr double, double* %1, i64 %200
%202 = add i64 %143, %199
%203 = getelementptr double, double* %1, i64 %202
%204 = mul i64 %189, %133
%205 = add i64 %139, %204
%206 = getelementptr double, double* %1, i64 %205
%207 = add i64 %141, %204
%208 = getelementptr double, double* %1, i64 %207
%209 = getelementptr inbounds [32 x i8], [32 x i8]* %8, i64 0, i64 %189
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = mul nsw i32 %211, %6
%213 = sext i32 %212 to i64
%214 = getelementptr double, double* %4, i64 %213
%215 = mul nsw i64 %189, %133
%216 = getelementptr inbounds double, double* %1, i64 %215
br i1 %131, label %217, label %602
217: ; preds = %188
br i1 %152, label %271, label %218
218: ; preds = %217
%219 = getelementptr double, double* %147, i64 %213
%220 = icmp ult double* %191, %219
%221 = icmp ult double* %214, %193
%222 = and i1 %220, %221
br i1 %222, label %271, label %223
223: ; preds = %218
br i1 %155, label %255, label %224
224: ; preds = %223, %224
%225 = phi i64 [ %252, %224 ], [ 0, %223 ]
%226 = phi i64 [ %253, %224 ], [ 0, %223 ]
%227 = getelementptr inbounds double, double* %214, i64 %225
%228 = bitcast double* %227 to <2 x double>*
%229 = load <2 x double>, <2 x double>* %228
%230 = getelementptr inbounds double, double* %227, i64 2
%231 = bitcast double* %230 to <2 x double>*
%232 = load <2 x double>, <2 x double>* %231
%233 = fmul <2 x double> %229, %229
%234 = fmul <2 x double> %232, %232
%235 = getelementptr inbounds double, double* %216, i64 %225
%236 = bitcast double* %235 to <2 x double>*
store <2 x double> %233, <2 x double>* %236
%237 = getelementptr inbounds double, double* %235, i64 2
%238 = bitcast double* %237 to <2 x double>*
store <2 x double> %234, <2 x double>* %238
%239 = or i64 %225, 4
%240 = getelementptr inbounds double, double* %214, i64 %239
%241 = bitcast double* %240 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = getelementptr inbounds double, double* %240, i64 2
%244 = bitcast double* %243 to <2 x double>*
%245 = load <2 x double>, <2 x double>* %244
%246 = fmul <2 x double> %242, %242
%247 = fmul <2 x double> %245, %245
%248 = getelementptr inbounds double, double* %216, i64 %239
%249 = bitcast double* %248 to <2 x double>*
store <2 x double> %246, <2 x double>* %249
%250 = getelementptr inbounds double, double* %248, i64 2
%251 = bitcast double* %250 to <2 x double>*
store <2 x double> %247, <2 x double>* %251
%252 = add nuw i64 %225, 8
%253 = add i64 %226, 2
%254 = icmp eq i64 %253, %156
br i1 %254, label %255, label %224
255: ; preds = %224, %223
%256 = phi i64 [ 0, %223 ], [ %252, %224 ]
br i1 %157, label %270, label %257
257: ; preds = %255
%258 = getelementptr inbounds double, double* %214, i64 %256
%259 = bitcast double* %258 to <2 x double>*
%260 = load <2 x double>, <2 x double>* %259
%261 = getelementptr inbounds double, double* %258, i64 2
%262 = bitcast double* %261 to <2 x double>*
%263 = load <2 x double>, <2 x double>* %262
%264 = fmul <2 x double> %260, %260
%265 = fmul <2 x double> %263, %263
%266 = getelementptr inbounds double, double* %216, i64 %256
%267 = bitcast double* %266 to <2 x double>*
store <2 x double> %264, <2 x double>* %267
%268 = getelementptr inbounds double, double* %266, i64 2
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> %265, <2 x double>* %269
br label %270
270: ; preds = %255, %257
br i1 %158, label %311, label %271
271: ; preds = %218, %217, %270
%272 = phi i64 [ 0, %218 ], [ 0, %217 ], [ %153, %270 ]
%273 = xor i64 %272, -1
%274 = add nsw i64 %273, %135
br i1 %160, label %285, label %275
275: ; preds = %271, %275
%276 = phi i64 [ %282, %275 ], [ %272, %271 ]
%277 = phi i64 [ %283, %275 ], [ 0, %271 ]
%278 = getelementptr inbounds double, double* %214, i64 %276
%279 = load double, double* %278
%280 = fmul double %279, %279
%281 = getelementptr inbounds double, double* %216, i64 %276
store double %280, double* %281
%282 = add nuw nsw i64 %276, 1
%283 = add i64 %277, 1
%284 = icmp eq i64 %283, %159
br i1 %284, label %285, label %275
285: ; preds = %275, %271
%286 = phi i64 [ %272, %271 ], [ %282, %275 ]
%287 = icmp ult i64 %274, 3
br i1 %287, label %311, label %288
288: ; preds = %285, %288
%289 = phi i64 [ %309, %288 ], [ %286, %285 ]
%290 = getelementptr inbounds double, double* %214, i64 %289
%291 = load double, double* %290
%292 = fmul double %291, %291
%293 = getelementptr inbounds double, double* %216, i64 %289
store double %292, double* %293
%294 = add nuw nsw i64 %289, 1
%295 = getelementptr inbounds double, double* %214, i64 %294
%296 = load double, double* %295
%297 = fmul double %296, %296
%298 = getelementptr inbounds double, double* %216, i64 %294
store double %297, double* %298
%299 = add nuw nsw i64 %289, 2
%300 = getelementptr inbounds double, double* %214, i64 %299
%301 = load double, double* %300
%302 = fmul double %301, %301
%303 = getelementptr inbounds double, double* %216, i64 %299
store double %302, double* %303
%304 = add nuw nsw i64 %289, 3
%305 = getelementptr inbounds double, double* %214, i64 %304
%306 = load double, double* %305
%307 = fmul double %306, %306
%308 = getelementptr inbounds double, double* %216, i64 %304
store double %307, double* %308
%309 = add nuw nsw i64 %289, 4
%310 = icmp eq i64 %309, %135
br i1 %310, label %311, label %288
311: ; preds = %285, %288, %270
%312 = add nsw i64 %215, %132
%313 = getelementptr inbounds double, double* %1, i64 %312
br i1 %131, label %314, label %602
314: ; preds = %311
br i1 %161, label %368, label %315
315: ; preds = %314
%316 = getelementptr double, double* %146, i64 %213
%317 = icmp ult double* %196, %316
%318 = icmp ult double* %214, %198
%319 = and i1 %317, %318
br i1 %319, label %368, label %320
320: ; preds = %315
br i1 %164, label %352, label %321
321: ; preds = %320, %321
%322 = phi i64 [ %349, %321 ], [ 0, %320 ]
%323 = phi i64 [ %350, %321 ], [ 0, %320 ]
%324 = getelementptr inbounds double, double* %214, i64 %322
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = getelementptr inbounds double, double* %324, i64 2
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = fmul <2 x double> %326, %326
%331 = fmul <2 x double> %329, %329
%332 = getelementptr inbounds double, double* %313, i64 %322
%333 = bitcast double* %332 to <2 x double>*
store <2 x double> %330, <2 x double>* %333
%334 = getelementptr inbounds double, double* %332, i64 2
%335 = bitcast double* %334 to <2 x double>*
store <2 x double> %331, <2 x double>* %335
%336 = or i64 %322, 4
%337 = getelementptr inbounds double, double* %214, i64 %336
%338 = bitcast double* %337 to <2 x double>*
%339 = load <2 x double>, <2 x double>* %338
%340 = getelementptr inbounds double, double* %337, i64 2
%341 = bitcast double* %340 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = fmul <2 x double> %339, %339
%344 = fmul <2 x double> %342, %342
%345 = getelementptr inbounds double, double* %313, i64 %336
%346 = bitcast double* %345 to <2 x double>*
store <2 x double> %343, <2 x double>* %346
%347 = getelementptr inbounds double, double* %345, i64 2
%348 = bitcast double* %347 to <2 x double>*
store <2 x double> %344, <2 x double>* %348
%349 = add nuw i64 %322, 8
%350 = add i64 %323, 2
%351 = icmp eq i64 %350, %165
br i1 %351, label %352, label %321
352: ; preds = %321, %320
%353 = phi i64 [ 0, %320 ], [ %349, %321 ]
br i1 %166, label %367, label %354
354: ; preds = %352
%355 = getelementptr inbounds double, double* %214, i64 %353
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = getelementptr inbounds double, double* %355, i64 2
%359 = bitcast double* %358 to <2 x double>*
%360 = load <2 x double>, <2 x double>* %359
%361 = fmul <2 x double> %357, %357
%362 = fmul <2 x double> %360, %360
%363 = getelementptr inbounds double, double* %313, i64 %353
%364 = bitcast double* %363 to <2 x double>*
store <2 x double> %361, <2 x double>* %364
%365 = getelementptr inbounds double, double* %363, i64 2
%366 = bitcast double* %365 to <2 x double>*
store <2 x double> %362, <2 x double>* %366
br label %367
367: ; preds = %352, %354
br i1 %167, label %408, label %368
368: ; preds = %315, %314, %367
%369 = phi i64 [ 0, %315 ], [ 0, %314 ], [ %162, %367 ]
%370 = xor i64 %369, -1
%371 = add nsw i64 %370, %135
br i1 %169, label %382, label %372
372: ; preds = %368, %372
%373 = phi i64 [ %379, %372 ], [ %369, %368 ]
%374 = phi i64 [ %380, %372 ], [ 0, %368 ]
%375 = getelementptr inbounds double, double* %214, i64 %373
%376 = load double, double* %375
%377 = fmul double %376, %376
%378 = getelementptr inbounds double, double* %313, i64 %373
store double %377, double* %378
%379 = add nuw nsw i64 %373, 1
%380 = add i64 %374, 1
%381 = icmp eq i64 %380, %168
br i1 %381, label %382, label %372
382: ; preds = %372, %368
%383 = phi i64 [ %369, %368 ], [ %379, %372 ]
%384 = icmp ult i64 %371, 3
br i1 %384, label %408, label %385
385: ; preds = %382, %385
%386 = phi i64 [ %406, %385 ], [ %383, %382 ]
%387 = getelementptr inbounds double, double* %214, i64 %386
%388 = load double, double* %387
%389 = fmul double %388, %388
%390 = getelementptr inbounds double, double* %313, i64 %386
store double %389, double* %390
%391 = add nuw nsw i64 %386, 1
%392 = getelementptr inbounds double, double* %214, i64 %391
%393 = load double, double* %392
%394 = fmul double %393, %393
%395 = getelementptr inbounds double, double* %313, i64 %391
store double %394, double* %395
%396 = add nuw nsw i64 %386, 2
%397 = getelementptr inbounds double, double* %214, i64 %396
%398 = load double, double* %397
%399 = fmul double %398, %398
%400 = getelementptr inbounds double, double* %313, i64 %396
store double %399, double* %400
%401 = add nuw nsw i64 %386, 3
%402 = getelementptr inbounds double, double* %214, i64 %401
%403 = load double, double* %402
%404 = fmul double %403, %403
%405 = getelementptr inbounds double, double* %313, i64 %401
store double %404, double* %405
%406 = add nuw nsw i64 %386, 4
%407 = icmp eq i64 %406, %136
br i1 %407, label %408, label %385
408: ; preds = %382, %385, %367
%409 = add nsw i64 %137, %215
%410 = getelementptr inbounds double, double* %1, i64 %409
br i1 %131, label %411, label %602
411: ; preds = %408
br i1 %170, label %465, label %412
412: ; preds = %411
%413 = getelementptr double, double* %144, i64 %213
%414 = icmp ult double* %201, %413
%415 = icmp ult double* %214, %203
%416 = and i1 %414, %415
br i1 %416, label %465, label %417
417: ; preds = %412
br i1 %173, label %449, label %418
418: ; preds = %417, %418
%419 = phi i64 [ %446, %418 ], [ 0, %417 ]
%420 = phi i64 [ %447, %418 ], [ 0, %417 ]
%421 = getelementptr inbounds double, double* %214, i64 %419
%422 = bitcast double* %421 to <2 x double>*
%423 = load <2 x double>, <2 x double>* %422
%424 = getelementptr inbounds double, double* %421, i64 2
%425 = bitcast double* %424 to <2 x double>*
%426 = load <2 x double>, <2 x double>* %425
%427 = fmul <2 x double> %423, %423
%428 = fmul <2 x double> %426, %426
%429 = getelementptr inbounds double, double* %410, i64 %419
%430 = bitcast double* %429 to <2 x double>*
store <2 x double> %427, <2 x double>* %430
%431 = getelementptr inbounds double, double* %429, i64 2
%432 = bitcast double* %431 to <2 x double>*
store <2 x double> %428, <2 x double>* %432
%433 = or i64 %419, 4
%434 = getelementptr inbounds double, double* %214, i64 %433
%435 = bitcast double* %434 to <2 x double>*
%436 = load <2 x double>, <2 x double>* %435
%437 = getelementptr inbounds double, double* %434, i64 2
%438 = bitcast double* %437 to <2 x double>*
%439 = load <2 x double>, <2 x double>* %438
%440 = fmul <2 x double> %436, %436
%441 = fmul <2 x double> %439, %439
%442 = getelementptr inbounds double, double* %410, i64 %433
%443 = bitcast double* %442 to <2 x double>*
store <2 x double> %440, <2 x double>* %443
%444 = getelementptr inbounds double, double* %442, i64 2
%445 = bitcast double* %444 to <2 x double>*
store <2 x double> %441, <2 x double>* %445
%446 = add nuw i64 %419, 8
%447 = add i64 %420, 2
%448 = icmp eq i64 %447, %174
br i1 %448, label %449, label %418
449: ; preds = %418, %417
%450 = phi i64 [ 0, %417 ], [ %446, %418 ]
br i1 %175, label %464, label %451
451: ; preds = %449
%452 = getelementptr inbounds double, double* %214, i64 %450
%453 = bitcast double* %452 to <2 x double>*
%454 = load <2 x double>, <2 x double>* %453
%455 = getelementptr inbounds double, double* %452, i64 2
%456 = bitcast double* %455 to <2 x double>*
%457 = load <2 x double>, <2 x double>* %456
%458 = fmul <2 x double> %454, %454
%459 = fmul <2 x double> %457, %457
%460 = getelementptr inbounds double, double* %410, i64 %450
%461 = bitcast double* %460 to <2 x double>*
store <2 x double> %458, <2 x double>* %461
%462 = getelementptr inbounds double, double* %460, i64 2
%463 = bitcast double* %462 to <2 x double>*
store <2 x double> %459, <2 x double>* %463
br label %464
464: ; preds = %449, %451
br i1 %176, label %505, label %465
465: ; preds = %412, %411, %464
%466 = phi i64 [ 0, %412 ], [ 0, %411 ], [ %171, %464 ]
%467 = xor i64 %466, -1
%468 = add nsw i64 %467, %135
br i1 %178, label %479, label %469
469: ; preds = %465, %469
%470 = phi i64 [ %476, %469 ], [ %466, %465 ]
%471 = phi i64 [ %477, %469 ], [ 0, %465 ]
%472 = getelementptr inbounds double, double* %214, i64 %470
%473 = load double, double* %472
%474 = fmul double %473, %473
%475 = getelementptr inbounds double, double* %410, i64 %470
store double %474, double* %475
%476 = add nuw nsw i64 %470, 1
%477 = add i64 %471, 1
%478 = icmp eq i64 %477, %177
br i1 %478, label %479, label %469
479: ; preds = %469, %465
%480 = phi i64 [ %466, %465 ], [ %476, %469 ]
%481 = icmp ult i64 %468, 3
br i1 %481, label %505, label %482
482: ; preds = %479, %482
%483 = phi i64 [ %503, %482 ], [ %480, %479 ]
%484 = getelementptr inbounds double, double* %214, i64 %483
%485 = load double, double* %484
%486 = fmul double %485, %485
%487 = getelementptr inbounds double, double* %410, i64 %483
store double %486, double* %487
%488 = add nuw nsw i64 %483, 1
%489 = getelementptr inbounds double, double* %214, i64 %488
%490 = load double, double* %489
%491 = fmul double %490, %490
%492 = getelementptr inbounds double, double* %410, i64 %488
store double %491, double* %492
%493 = add nuw nsw i64 %483, 2
%494 = getelementptr inbounds double, double* %214, i64 %493
%495 = load double, double* %494
%496 = fmul double %495, %495
%497 = getelementptr inbounds double, double* %410, i64 %493
store double %496, double* %497
%498 = add nuw nsw i64 %483, 3
%499 = getelementptr inbounds double, double* %214, i64 %498
%500 = load double, double* %499
%501 = fmul double %500, %500
%502 = getelementptr inbounds double, double* %410, i64 %498
store double %501, double* %502
%503 = add nuw nsw i64 %483, 4
%504 = icmp eq i64 %503, %138
br i1 %504, label %505, label %482
505: ; preds = %479, %482, %464
%506 = add nsw i64 %139, %215
%507 = getelementptr inbounds double, double* %1, i64 %506
br i1 %131, label %508, label %602
508: ; preds = %505
br i1 %179, label %562, label %509
509: ; preds = %508
%510 = getelementptr double, double* %142, i64 %213
%511 = icmp ult double* %206, %510
%512 = icmp ult double* %214, %208
%513 = and i1 %511, %512
br i1 %513, label %562, label %514
514: ; preds = %509
br i1 %182, label %546, label %515
515: ; preds = %514, %515
%516 = phi i64 [ %543, %515 ], [ 0, %514 ]
%517 = phi i64 [ %544, %515 ], [ 0, %514 ]
%518 = getelementptr inbounds double, double* %214, i64 %516
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = getelementptr inbounds double, double* %518, i64 2
%522 = bitcast double* %521 to <2 x double>*
%523 = load <2 x double>, <2 x double>* %522
%524 = fmul <2 x double> %520, %520
%525 = fmul <2 x double> %523, %523
%526 = getelementptr inbounds double, double* %507, i64 %516
%527 = bitcast double* %526 to <2 x double>*
store <2 x double> %524, <2 x double>* %527
%528 = getelementptr inbounds double, double* %526, i64 2
%529 = bitcast double* %528 to <2 x double>*
store <2 x double> %525, <2 x double>* %529
%530 = or i64 %516, 4
%531 = getelementptr inbounds double, double* %214, i64 %530
%532 = bitcast double* %531 to <2 x double>*
%533 = load <2 x double>, <2 x double>* %532
%534 = getelementptr inbounds double, double* %531, i64 2
%535 = bitcast double* %534 to <2 x double>*
%536 = load <2 x double>, <2 x double>* %535
%537 = fmul <2 x double> %533, %533
%538 = fmul <2 x double> %536, %536
%539 = getelementptr inbounds double, double* %507, i64 %530
%540 = bitcast double* %539 to <2 x double>*
store <2 x double> %537, <2 x double>* %540
%541 = getelementptr inbounds double, double* %539, i64 2
%542 = bitcast double* %541 to <2 x double>*
store <2 x double> %538, <2 x double>* %542
%543 = add nuw i64 %516, 8
%544 = add i64 %517, 2
%545 = icmp eq i64 %544, %183
br i1 %545, label %546, label %515
546: ; preds = %515, %514
%547 = phi i64 [ 0, %514 ], [ %543, %515 ]
br i1 %184, label %561, label %548
548: ; preds = %546
%549 = getelementptr inbounds double, double* %214, i64 %547
%550 = bitcast double* %549 to <2 x double>*
%551 = load <2 x double>, <2 x double>* %550
%552 = getelementptr inbounds double, double* %549, i64 2
%553 = bitcast double* %552 to <2 x double>*
%554 = load <2 x double>, <2 x double>* %553
%555 = fmul <2 x double> %551, %551
%556 = fmul <2 x double> %554, %554
%557 = getelementptr inbounds double, double* %507, i64 %547
%558 = bitcast double* %557 to <2 x double>*
store <2 x double> %555, <2 x double>* %558
%559 = getelementptr inbounds double, double* %557, i64 2
%560 = bitcast double* %559 to <2 x double>*
store <2 x double> %556, <2 x double>* %560
br label %561
561: ; preds = %546, %548
br i1 %185, label %602, label %562
562: ; preds = %509, %508, %561
%563 = phi i64 [ 0, %509 ], [ 0, %508 ], [ %180, %561 ]
%564 = xor i64 %563, -1
%565 = add nsw i64 %564, %135
br i1 %187, label %576, label %566
566: ; preds = %562, %566
%567 = phi i64 [ %573, %566 ], [ %563, %562 ]
%568 = phi i64 [ %574, %566 ], [ 0, %562 ]
%569 = getelementptr inbounds double, double* %214, i64 %567
%570 = load double, double* %569
%571 = fmul double %570, %570
%572 = getelementptr inbounds double, double* %507, i64 %567
store double %571, double* %572
%573 = add nuw nsw i64 %567, 1
%574 = add i64 %568, 1
%575 = icmp eq i64 %574, %186
br i1 %575, label %576, label %566
576: ; preds = %566, %562
%577 = phi i64 [ %563, %562 ], [ %573, %566 ]
%578 = icmp ult i64 %565, 3
br i1 %578, label %602, label %579
579: ; preds = %576, %579
%580 = phi i64 [ %600, %579 ], [ %577, %576 ]
%581 = getelementptr inbounds double, double* %214, i64 %580
%582 = load double, double* %581
%583 = fmul double %582, %582
%584 = getelementptr inbounds double, double* %507, i64 %580
store double %583, double* %584
%585 = add nuw nsw i64 %580, 1
%586 = getelementptr inbounds double, double* %214, i64 %585
%587 = load double, double* %586
%588 = fmul double %587, %587
%589 = getelementptr inbounds double, double* %507, i64 %585
store double %588, double* %589
%590 = add nuw nsw i64 %580, 2
%591 = getelementptr inbounds double, double* %214, i64 %590
%592 = load double, double* %591
%593 = fmul double %592, %592
%594 = getelementptr inbounds double, double* %507, i64 %590
store double %593, double* %594
%595 = add nuw nsw i64 %580, 3
%596 = getelementptr inbounds double, double* %214, i64 %595
%597 = load double, double* %596
%598 = fmul double %597, %597
%599 = getelementptr inbounds double, double* %507, i64 %595
store double %598, double* %599
%600 = add nuw nsw i64 %580, 4
%601 = icmp eq i64 %600, %140
br i1 %601, label %602, label %579
602: ; preds = %576, %579, %561, %188, %311, %408, %505
%603 = add nuw nsw i64 %189, 1
%604 = icmp eq i64 %603, %134
br i1 %604, label %1723, label %188
605: ; preds = %70, %1159
%606 = phi i64 [ 0, %70 ], [ %1160, %1159 ]
%607 = mul i64 %606, %73
%608 = getelementptr double, double* %1, i64 %607
%609 = add i64 %607, %75
%610 = getelementptr double, double* %1, i64 %609
%611 = getelementptr double, double* %3, i64 %607
%612 = getelementptr double, double* %3, i64 %609
%613 = mul i64 %606, %73
%614 = add i64 %613, %72
%615 = getelementptr double, double* %1, i64 %614
%616 = add i64 %85, %613
%617 = getelementptr double, double* %1, i64 %616
%618 = getelementptr double, double* %3, i64 %614
%619 = getelementptr double, double* %3, i64 %616
%620 = mul i64 %606, %73
%621 = add i64 %77, %620
%622 = getelementptr double, double* %1, i64 %621
%623 = add i64 %83, %620
%624 = getelementptr double, double* %1, i64 %623
%625 = getelementptr double, double* %3, i64 %621
%626 = getelementptr double, double* %3, i64 %623
%627 = mul i64 %606, %73
%628 = add i64 %79, %627
%629 = getelementptr double, double* %1, i64 %628
%630 = add i64 %81, %627
%631 = getelementptr double, double* %1, i64 %630
%632 = getelementptr double, double* %3, i64 %628
%633 = getelementptr double, double* %3, i64 %630
%634 = getelementptr inbounds [32 x i8], [32 x i8]* %8, i64 0, i64 %606
%635 = load i8, i8* %634
%636 = zext i8 %635 to i32
%637 = mul nsw i32 %636, %6
%638 = sext i32 %637 to i64
%639 = getelementptr double, double* %4, i64 %638
%640 = mul nsw i64 %606, %73
%641 = getelementptr inbounds double, double* %3, i64 %640
%642 = getelementptr inbounds double, double* %1, i64 %640
br i1 %71, label %643, label %1159
643: ; preds = %605
br i1 %92, label %719, label %644
644: ; preds = %643
%645 = getelementptr double, double* %87, i64 %638
%646 = icmp ult double* %608, %645
%647 = icmp ult double* %639, %610
%648 = and i1 %646, %647
%649 = icmp ult double* %608, %612
%650 = icmp ult double* %611, %610
%651 = and i1 %649, %650
%652 = or i1 %648, %651
br i1 %652, label %719, label %653
653: ; preds = %644
br i1 %95, label %697, label %654
654: ; preds = %653, %654
%655 = phi i64 [ %694, %654 ], [ 0, %653 ]
%656 = phi i64 [ %695, %654 ], [ 0, %653 ]
%657 = getelementptr inbounds double, double* %639, i64 %655
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %657, i64 2
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = getelementptr inbounds double, double* %641, i64 %655
%664 = bitcast double* %663 to <2 x double>*
%665 = load <2 x double>, <2 x double>* %664
%666 = getelementptr inbounds double, double* %663, i64 2
%667 = bitcast double* %666 to <2 x double>*
%668 = load <2 x double>, <2 x double>* %667
%669 = fmul <2 x double> %659, %665
%670 = fmul <2 x double> %662, %668
%671 = getelementptr inbounds double, double* %642, i64 %655
%672 = bitcast double* %671 to <2 x double>*
store <2 x double> %669, <2 x double>* %672
%673 = getelementptr inbounds double, double* %671, i64 2
%674 = bitcast double* %673 to <2 x double>*
store <2 x double> %670, <2 x double>* %674
%675 = or i64 %655, 4
%676 = getelementptr inbounds double, double* %639, i64 %675
%677 = bitcast double* %676 to <2 x double>*
%678 = load <2 x double>, <2 x double>* %677
%679 = getelementptr inbounds double, double* %676, i64 2
%680 = bitcast double* %679 to <2 x double>*
%681 = load <2 x double>, <2 x double>* %680
%682 = getelementptr inbounds double, double* %641, i64 %675
%683 = bitcast double* %682 to <2 x double>*
%684 = load <2 x double>, <2 x double>* %683
%685 = getelementptr inbounds double, double* %682, i64 2
%686 = bitcast double* %685 to <2 x double>*
%687 = load <2 x double>, <2 x double>* %686
%688 = fmul <2 x double> %678, %684
%689 = fmul <2 x double> %681, %687
%690 = getelementptr inbounds double, double* %642, i64 %675
%691 = bitcast double* %690 to <2 x double>*
store <2 x double> %688, <2 x double>* %691
%692 = getelementptr inbounds double, double* %690, i64 2
%693 = bitcast double* %692 to <2 x double>*
store <2 x double> %689, <2 x double>* %693
%694 = add nuw i64 %655, 8
%695 = add i64 %656, 2
%696 = icmp eq i64 %695, %96
br i1 %696, label %697, label %654
697: ; preds = %654, %653
%698 = phi i64 [ 0, %653 ], [ %694, %654 ]
br i1 %97, label %718, label %699
699: ; preds = %697
%700 = getelementptr inbounds double, double* %639, i64 %698
%701 = bitcast double* %700 to <2 x double>*
%702 = load <2 x double>, <2 x double>* %701
%703 = getelementptr inbounds double, double* %700, i64 2
%704 = bitcast double* %703 to <2 x double>*
%705 = load <2 x double>, <2 x double>* %704
%706 = getelementptr inbounds double, double* %641, i64 %698
%707 = bitcast double* %706 to <2 x double>*
%708 = load <2 x double>, <2 x double>* %707
%709 = getelementptr inbounds double, double* %706, i64 2
%710 = bitcast double* %709 to <2 x double>*
%711 = load <2 x double>, <2 x double>* %710
%712 = fmul <2 x double> %702, %708
%713 = fmul <2 x double> %705, %711
%714 = getelementptr inbounds double, double* %642, i64 %698
%715 = bitcast double* %714 to <2 x double>*
store <2 x double> %712, <2 x double>* %715
%716 = getelementptr inbounds double, double* %714, i64 2
%717 = bitcast double* %716 to <2 x double>*
store <2 x double> %713, <2 x double>* %717
br label %718
718: ; preds = %697, %699
br i1 %98, label %769, label %719
719: ; preds = %644, %643, %718
%720 = phi i64 [ 0, %644 ], [ 0, %643 ], [ %93, %718 ]
%721 = xor i64 %720, -1
%722 = add nsw i64 %721, %75
br i1 %100, label %735, label %723
723: ; preds = %719, %723
%724 = phi i64 [ %732, %723 ], [ %720, %719 ]
%725 = phi i64 [ %733, %723 ], [ 0, %719 ]
%726 = getelementptr inbounds double, double* %639, i64 %724
%727 = load double, double* %726
%728 = getelementptr inbounds double, double* %641, i64 %724
%729 = load double, double* %728
%730 = fmul double %727, %729
%731 = getelementptr inbounds double, double* %642, i64 %724
store double %730, double* %731
%732 = add nuw nsw i64 %724, 1
%733 = add i64 %725, 1
%734 = icmp eq i64 %733, %99
br i1 %734, label %735, label %723
735: ; preds = %723, %719
%736 = phi i64 [ %720, %719 ], [ %732, %723 ]
%737 = icmp ult i64 %722, 3
br i1 %737, label %769, label %738
738: ; preds = %735, %738
%739 = phi i64 [ %767, %738 ], [ %736, %735 ]
%740 = getelementptr inbounds double, double* %639, i64 %739
%741 = load double, double* %740
%742 = getelementptr inbounds double, double* %641, i64 %739
%743 = load double, double* %742
%744 = fmul double %741, %743
%745 = getelementptr inbounds double, double* %642, i64 %739
store double %744, double* %745
%746 = add nuw nsw i64 %739, 1
%747 = getelementptr inbounds double, double* %639, i64 %746
%748 = load double, double* %747
%749 = getelementptr inbounds double, double* %641, i64 %746
%750 = load double, double* %749
%751 = fmul double %748, %750
%752 = getelementptr inbounds double, double* %642, i64 %746
store double %751, double* %752
%753 = add nuw nsw i64 %739, 2
%754 = getelementptr inbounds double, double* %639, i64 %753
%755 = load double, double* %754
%756 = getelementptr inbounds double, double* %641, i64 %753
%757 = load double, double* %756
%758 = fmul double %755, %757
%759 = getelementptr inbounds double, double* %642, i64 %753
store double %758, double* %759
%760 = add nuw nsw i64 %739, 3
%761 = getelementptr inbounds double, double* %639, i64 %760
%762 = load double, double* %761
%763 = getelementptr inbounds double, double* %641, i64 %760
%764 = load double, double* %763
%765 = fmul double %762, %764
%766 = getelementptr inbounds double, double* %642, i64 %760
store double %765, double* %766
%767 = add nuw nsw i64 %739, 4
%768 = icmp eq i64 %767, %75
br i1 %768, label %769, label %738
769: ; preds = %735, %738, %718
%770 = add nsw i64 %640, %72
%771 = getelementptr inbounds double, double* %3, i64 %770
%772 = getelementptr inbounds double, double* %1, i64 %770
br i1 %71, label %773, label %1159
773: ; preds = %769
br i1 %101, label %849, label %774
774: ; preds = %773
%775 = getelementptr double, double* %86, i64 %638
%776 = icmp ult double* %615, %775
%777 = icmp ult double* %639, %617
%778 = and i1 %776, %777
%779 = icmp ult double* %615, %619
%780 = icmp ult double* %618, %617
%781 = and i1 %779, %780
%782 = or i1 %778, %781
br i1 %782, label %849, label %783
783: ; preds = %774
br i1 %104, label %827, label %784
784: ; preds = %783, %784
%785 = phi i64 [ %824, %784 ], [ 0, %783 ]
%786 = phi i64 [ %825, %784 ], [ 0, %783 ]
%787 = getelementptr inbounds double, double* %639, i64 %785
%788 = bitcast double* %787 to <2 x double>*
%789 = load <2 x double>, <2 x double>* %788
%790 = getelementptr inbounds double, double* %787, i64 2
%791 = bitcast double* %790 to <2 x double>*
%792 = load <2 x double>, <2 x double>* %791
%793 = getelementptr inbounds double, double* %771, i64 %785
%794 = bitcast double* %793 to <2 x double>*
%795 = load <2 x double>, <2 x double>* %794
%796 = getelementptr inbounds double, double* %793, i64 2
%797 = bitcast double* %796 to <2 x double>*
%798 = load <2 x double>, <2 x double>* %797
%799 = fmul <2 x double> %789, %795
%800 = fmul <2 x double> %792, %798
%801 = getelementptr inbounds double, double* %772, i64 %785
%802 = bitcast double* %801 to <2 x double>*
store <2 x double> %799, <2 x double>* %802
%803 = getelementptr inbounds double, double* %801, i64 2
%804 = bitcast double* %803 to <2 x double>*
store <2 x double> %800, <2 x double>* %804
%805 = or i64 %785, 4
%806 = getelementptr inbounds double, double* %639, i64 %805
%807 = bitcast double* %806 to <2 x double>*
%808 = load <2 x double>, <2 x double>* %807
%809 = getelementptr inbounds double, double* %806, i64 2
%810 = bitcast double* %809 to <2 x double>*
%811 = load <2 x double>, <2 x double>* %810
%812 = getelementptr inbounds double, double* %771, i64 %805
%813 = bitcast double* %812 to <2 x double>*
%814 = load <2 x double>, <2 x double>* %813
%815 = getelementptr inbounds double, double* %812, i64 2
%816 = bitcast double* %815 to <2 x double>*
%817 = load <2 x double>, <2 x double>* %816
%818 = fmul <2 x double> %808, %814
%819 = fmul <2 x double> %811, %817
%820 = getelementptr inbounds double, double* %772, i64 %805
%821 = bitcast double* %820 to <2 x double>*
store <2 x double> %818, <2 x double>* %821
%822 = getelementptr inbounds double, double* %820, i64 2
%823 = bitcast double* %822 to <2 x double>*
store <2 x double> %819, <2 x double>* %823
%824 = add nuw i64 %785, 8
%825 = add i64 %786, 2
%826 = icmp eq i64 %825, %105
br i1 %826, label %827, label %784
827: ; preds = %784, %783
%828 = phi i64 [ 0, %783 ], [ %824, %784 ]
br i1 %106, label %848, label %829
829: ; preds = %827
%830 = getelementptr inbounds double, double* %639, i64 %828
%831 = bitcast double* %830 to <2 x double>*
%832 = load <2 x double>, <2 x double>* %831
%833 = getelementptr inbounds double, double* %830, i64 2
%834 = bitcast double* %833 to <2 x double>*
%835 = load <2 x double>, <2 x double>* %834
%836 = getelementptr inbounds double, double* %771, i64 %828
%837 = bitcast double* %836 to <2 x double>*
%838 = load <2 x double>, <2 x double>* %837
%839 = getelementptr inbounds double, double* %836, i64 2
%840 = bitcast double* %839 to <2 x double>*
%841 = load <2 x double>, <2 x double>* %840
%842 = fmul <2 x double> %832, %838
%843 = fmul <2 x double> %835, %841
%844 = getelementptr inbounds double, double* %772, i64 %828
%845 = bitcast double* %844 to <2 x double>*
store <2 x double> %842, <2 x double>* %845
%846 = getelementptr inbounds double, double* %844, i64 2
%847 = bitcast double* %846 to <2 x double>*
store <2 x double> %843, <2 x double>* %847
br label %848
848: ; preds = %827, %829
br i1 %107, label %899, label %849
849: ; preds = %774, %773, %848
%850 = phi i64 [ 0, %774 ], [ 0, %773 ], [ %102, %848 ]
%851 = xor i64 %850, -1
%852 = add nsw i64 %851, %75
br i1 %109, label %865, label %853
853: ; preds = %849, %853
%854 = phi i64 [ %862, %853 ], [ %850, %849 ]
%855 = phi i64 [ %863, %853 ], [ 0, %849 ]
%856 = getelementptr inbounds double, double* %639, i64 %854
%857 = load double, double* %856
%858 = getelementptr inbounds double, double* %771, i64 %854
%859 = load double, double* %858
%860 = fmul double %857, %859
%861 = getelementptr inbounds double, double* %772, i64 %854
store double %860, double* %861
%862 = add nuw nsw i64 %854, 1
%863 = add i64 %855, 1
%864 = icmp eq i64 %863, %108
br i1 %864, label %865, label %853
865: ; preds = %853, %849
%866 = phi i64 [ %850, %849 ], [ %862, %853 ]
%867 = icmp ult i64 %852, 3
br i1 %867, label %899, label %868
868: ; preds = %865, %868
%869 = phi i64 [ %897, %868 ], [ %866, %865 ]
%870 = getelementptr inbounds double, double* %639, i64 %869
%871 = load double, double* %870
%872 = getelementptr inbounds double, double* %771, i64 %869
%873 = load double, double* %872
%874 = fmul double %871, %873
%875 = getelementptr inbounds double, double* %772, i64 %869
store double %874, double* %875
%876 = add nuw nsw i64 %869, 1
%877 = getelementptr inbounds double, double* %639, i64 %876
%878 = load double, double* %877
%879 = getelementptr inbounds double, double* %771, i64 %876
%880 = load double, double* %879
%881 = fmul double %878, %880
%882 = getelementptr inbounds double, double* %772, i64 %876
store double %881, double* %882
%883 = add nuw nsw i64 %869, 2
%884 = getelementptr inbounds double, double* %639, i64 %883
%885 = load double, double* %884
%886 = getelementptr inbounds double, double* %771, i64 %883
%887 = load double, double* %886
%888 = fmul double %885, %887
%889 = getelementptr inbounds double, double* %772, i64 %883
store double %888, double* %889
%890 = add nuw nsw i64 %869, 3
%891 = getelementptr inbounds double, double* %639, i64 %890
%892 = load double, double* %891
%893 = getelementptr inbounds double, double* %771, i64 %890
%894 = load double, double* %893
%895 = fmul double %892, %894
%896 = getelementptr inbounds double, double* %772, i64 %890
store double %895, double* %896
%897 = add nuw nsw i64 %869, 4
%898 = icmp eq i64 %897, %76
br i1 %898, label %899, label %868
899: ; preds = %865, %868, %848
%900 = add nsw i64 %77, %640
%901 = getelementptr inbounds double, double* %3, i64 %900
%902 = getelementptr inbounds double, double* %1, i64 %900
br i1 %71, label %903, label %1159
903: ; preds = %899
br i1 %110, label %979, label %904
904: ; preds = %903
%905 = getelementptr double, double* %84, i64 %638
%906 = icmp ult double* %622, %905
%907 = icmp ult double* %639, %624
%908 = and i1 %906, %907
%909 = icmp ult double* %622, %626
%910 = icmp ult double* %625, %624
%911 = and i1 %909, %910
%912 = or i1 %908, %911
br i1 %912, label %979, label %913
913: ; preds = %904
br i1 %113, label %957, label %914
914: ; preds = %913, %914
%915 = phi i64 [ %954, %914 ], [ 0, %913 ]
%916 = phi i64 [ %955, %914 ], [ 0, %913 ]
%917 = getelementptr inbounds double, double* %639, i64 %915
%918 = bitcast double* %917 to <2 x double>*
%919 = load <2 x double>, <2 x double>* %918
%920 = getelementptr inbounds double, double* %917, i64 2
%921 = bitcast double* %920 to <2 x double>*
%922 = load <2 x double>, <2 x double>* %921
%923 = getelementptr inbounds double, double* %901, i64 %915
%924 = bitcast double* %923 to <2 x double>*
%925 = load <2 x double>, <2 x double>* %924
%926 = getelementptr inbounds double, double* %923, i64 2
%927 = bitcast double* %926 to <2 x double>*
%928 = load <2 x double>, <2 x double>* %927
%929 = fmul <2 x double> %919, %925
%930 = fmul <2 x double> %922, %928
%931 = getelementptr inbounds double, double* %902, i64 %915
%932 = bitcast double* %931 to <2 x double>*
store <2 x double> %929, <2 x double>* %932
%933 = getelementptr inbounds double, double* %931, i64 2
%934 = bitcast double* %933 to <2 x double>*
store <2 x double> %930, <2 x double>* %934
%935 = or i64 %915, 4
%936 = getelementptr inbounds double, double* %639, i64 %935
%937 = bitcast double* %936 to <2 x double>*
%938 = load <2 x double>, <2 x double>* %937
%939 = getelementptr inbounds double, double* %936, i64 2
%940 = bitcast double* %939 to <2 x double>*
%941 = load <2 x double>, <2 x double>* %940
%942 = getelementptr inbounds double, double* %901, i64 %935
%943 = bitcast double* %942 to <2 x double>*
%944 = load <2 x double>, <2 x double>* %943
%945 = getelementptr inbounds double, double* %942, i64 2
%946 = bitcast double* %945 to <2 x double>*
%947 = load <2 x double>, <2 x double>* %946
%948 = fmul <2 x double> %938, %944
%949 = fmul <2 x double> %941, %947
%950 = getelementptr inbounds double, double* %902, i64 %935
%951 = bitcast double* %950 to <2 x double>*
store <2 x double> %948, <2 x double>* %951
%952 = getelementptr inbounds double, double* %950, i64 2
%953 = bitcast double* %952 to <2 x double>*
store <2 x double> %949, <2 x double>* %953
%954 = add nuw i64 %915, 8
%955 = add i64 %916, 2
%956 = icmp eq i64 %955, %114
br i1 %956, label %957, label %914
957: ; preds = %914, %913
%958 = phi i64 [ 0, %913 ], [ %954, %914 ]
br i1 %115, label %978, label %959
959: ; preds = %957
%960 = getelementptr inbounds double, double* %639, i64 %958
%961 = bitcast double* %960 to <2 x double>*
%962 = load <2 x double>, <2 x double>* %961
%963 = getelementptr inbounds double, double* %960, i64 2
%964 = bitcast double* %963 to <2 x double>*
%965 = load <2 x double>, <2 x double>* %964
%966 = getelementptr inbounds double, double* %901, i64 %958
%967 = bitcast double* %966 to <2 x double>*
%968 = load <2 x double>, <2 x double>* %967
%969 = getelementptr inbounds double, double* %966, i64 2
%970 = bitcast double* %969 to <2 x double>*
%971 = load <2 x double>, <2 x double>* %970
%972 = fmul <2 x double> %962, %968
%973 = fmul <2 x double> %965, %971
%974 = getelementptr inbounds double, double* %902, i64 %958
%975 = bitcast double* %974 to <2 x double>*
store <2 x double> %972, <2 x double>* %975
%976 = getelementptr inbounds double, double* %974, i64 2
%977 = bitcast double* %976 to <2 x double>*
store <2 x double> %973, <2 x double>* %977
br label %978
978: ; preds = %957, %959
br i1 %116, label %1029, label %979
979: ; preds = %904, %903, %978
%980 = phi i64 [ 0, %904 ], [ 0, %903 ], [ %111, %978 ]
%981 = xor i64 %980, -1
%982 = add nsw i64 %981, %75
br i1 %118, label %995, label %983
983: ; preds = %979, %983
%984 = phi i64 [ %992, %983 ], [ %980, %979 ]
%985 = phi i64 [ %993, %983 ], [ 0, %979 ]
%986 = getelementptr inbounds double, double* %639, i64 %984
%987 = load double, double* %986
%988 = getelementptr inbounds double, double* %901, i64 %984
%989 = load double, double* %988
%990 = fmul double %987, %989
%991 = getelementptr inbounds double, double* %902, i64 %984
store double %990, double* %991
%992 = add nuw nsw i64 %984, 1
%993 = add i64 %985, 1
%994 = icmp eq i64 %993, %117
br i1 %994, label %995, label %983
995: ; preds = %983, %979
%996 = phi i64 [ %980, %979 ], [ %992, %983 ]
%997 = icmp ult i64 %982, 3
br i1 %997, label %1029, label %998
998: ; preds = %995, %998
%999 = phi i64 [ %1027, %998 ], [ %996, %995 ]
%1000 = getelementptr inbounds double, double* %639, i64 %999
%1001 = load double, double* %1000
%1002 = getelementptr inbounds double, double* %901, i64 %999
%1003 = load double, double* %1002
%1004 = fmul double %1001, %1003
%1005 = getelementptr inbounds double, double* %902, i64 %999
store double %1004, double* %1005
%1006 = add nuw nsw i64 %999, 1
%1007 = getelementptr inbounds double, double* %639, i64 %1006
%1008 = load double, double* %1007
%1009 = getelementptr inbounds double, double* %901, i64 %1006
%1010 = load double, double* %1009
%1011 = fmul double %1008, %1010
%1012 = getelementptr inbounds double, double* %902, i64 %1006
store double %1011, double* %1012
%1013 = add nuw nsw i64 %999, 2
%1014 = getelementptr inbounds double, double* %639, i64 %1013
%1015 = load double, double* %1014
%1016 = getelementptr inbounds double, double* %901, i64 %1013
%1017 = load double, double* %1016
%1018 = fmul double %1015, %1017
%1019 = getelementptr inbounds double, double* %902, i64 %1013
store double %1018, double* %1019
%1020 = add nuw nsw i64 %999, 3
%1021 = getelementptr inbounds double, double* %639, i64 %1020
%1022 = load double, double* %1021
%1023 = getelementptr inbounds double, double* %901, i64 %1020
%1024 = load double, double* %1023
%1025 = fmul double %1022, %1024
%1026 = getelementptr inbounds double, double* %902, i64 %1020
store double %1025, double* %1026
%1027 = add nuw nsw i64 %999, 4
%1028 = icmp eq i64 %1027, %78
br i1 %1028, label %1029, label %998
1029: ; preds = %995, %998, %978
%1030 = add nsw i64 %79, %640
%1031 = getelementptr inbounds double, double* %3, i64 %1030
%1032 = getelementptr inbounds double, double* %1, i64 %1030
br i1 %71, label %1033, label %1159
1033: ; preds = %1029
br i1 %119, label %1109, label %1034
1034: ; preds = %1033
%1035 = getelementptr double, double* %82, i64 %638
%1036 = icmp ult double* %629, %1035
%1037 = icmp ult double* %639, %631
%1038 = and i1 %1036, %1037
%1039 = icmp ult double* %629, %633
%1040 = icmp ult double* %632, %631
%1041 = and i1 %1039, %1040
%1042 = or i1 %1038, %1041
br i1 %1042, label %1109, label %1043
1043: ; preds = %1034
br i1 %122, label %1087, label %1044
1044: ; preds = %1043, %1044
%1045 = phi i64 [ %1084, %1044 ], [ 0, %1043 ]
%1046 = phi i64 [ %1085, %1044 ], [ 0, %1043 ]
%1047 = getelementptr inbounds double, double* %639, i64 %1045
%1048 = bitcast double* %1047 to <2 x double>*
%1049 = load <2 x double>, <2 x double>* %1048
%1050 = getelementptr inbounds double, double* %1047, i64 2
%1051 = bitcast double* %1050 to <2 x double>*
%1052 = load <2 x double>, <2 x double>* %1051
%1053 = getelementptr inbounds double, double* %1031, i64 %1045
%1054 = bitcast double* %1053 to <2 x double>*
%1055 = load <2 x double>, <2 x double>* %1054
%1056 = getelementptr inbounds double, double* %1053, i64 2
%1057 = bitcast double* %1056 to <2 x double>*
%1058 = load <2 x double>, <2 x double>* %1057
%1059 = fmul <2 x double> %1049, %1055
%1060 = fmul <2 x double> %1052, %1058
%1061 = getelementptr inbounds double, double* %1032, i64 %1045
%1062 = bitcast double* %1061 to <2 x double>*
store <2 x double> %1059, <2 x double>* %1062
%1063 = getelementptr inbounds double, double* %1061, i64 2
%1064 = bitcast double* %1063 to <2 x double>*
store <2 x double> %1060, <2 x double>* %1064
%1065 = or i64 %1045, 4
%1066 = getelementptr inbounds double, double* %639, i64 %1065
%1067 = bitcast double* %1066 to <2 x double>*
%1068 = load <2 x double>, <2 x double>* %1067
%1069 = getelementptr inbounds double, double* %1066, i64 2
%1070 = bitcast double* %1069 to <2 x double>*
%1071 = load <2 x double>, <2 x double>* %1070
%1072 = getelementptr inbounds double, double* %1031, i64 %1065
%1073 = bitcast double* %1072 to <2 x double>*
%1074 = load <2 x double>, <2 x double>* %1073
%1075 = getelementptr inbounds double, double* %1072, i64 2
%1076 = bitcast double* %1075 to <2 x double>*
%1077 = load <2 x double>, <2 x double>* %1076
%1078 = fmul <2 x double> %1068, %1074
%1079 = fmul <2 x double> %1071, %1077
%1080 = getelementptr inbounds double, double* %1032, i64 %1065
%1081 = bitcast double* %1080 to <2 x double>*
store <2 x double> %1078, <2 x double>* %1081
%1082 = getelementptr inbounds double, double* %1080, i64 2
%1083 = bitcast double* %1082 to <2 x double>*
store <2 x double> %1079, <2 x double>* %1083
%1084 = add nuw i64 %1045, 8
%1085 = add i64 %1046, 2
%1086 = icmp eq i64 %1085, %123
br i1 %1086, label %1087, label %1044
1087: ; preds = %1044, %1043
%1088 = phi i64 [ 0, %1043 ], [ %1084, %1044 ]
br i1 %124, label %1108, label %1089
1089: ; preds = %1087
%1090 = getelementptr inbounds double, double* %639, i64 %1088
%1091 = bitcast double* %1090 to <2 x double>*
%1092 = load <2 x double>, <2 x double>* %1091
%1093 = getelementptr inbounds double, double* %1090, i64 2
%1094 = bitcast double* %1093 to <2 x double>*
%1095 = load <2 x double>, <2 x double>* %1094
%1096 = getelementptr inbounds double, double* %1031, i64 %1088
%1097 = bitcast double* %1096 to <2 x double>*
%1098 = load <2 x double>, <2 x double>* %1097
%1099 = getelementptr inbounds double, double* %1096, i64 2
%1100 = bitcast double* %1099 to <2 x double>*
%1101 = load <2 x double>, <2 x double>* %1100
%1102 = fmul <2 x double> %1092, %1098
%1103 = fmul <2 x double> %1095, %1101
%1104 = getelementptr inbounds double, double* %1032, i64 %1088
%1105 = bitcast double* %1104 to <2 x double>*
store <2 x double> %1102, <2 x double>* %1105
%1106 = getelementptr inbounds double, double* %1104, i64 2
%1107 = bitcast double* %1106 to <2 x double>*
store <2 x double> %1103, <2 x double>* %1107
br label %1108
1108: ; preds = %1087, %1089
br i1 %125, label %1159, label %1109
1109: ; preds = %1034, %1033, %1108
%1110 = phi i64 [ 0, %1034 ], [ 0, %1033 ], [ %120, %1108 ]
%1111 = xor i64 %1110, -1
%1112 = add nsw i64 %1111, %75
br i1 %127, label %1125, label %1113
1113: ; preds = %1109, %1113
%1114 = phi i64 [ %1122, %1113 ], [ %1110, %1109 ]
%1115 = phi i64 [ %1123, %1113 ], [ 0, %1109 ]
%1116 = getelementptr inbounds double, double* %639, i64 %1114
%1117 = load double, double* %1116
%1118 = getelementptr inbounds double, double* %1031, i64 %1114
%1119 = load double, double* %1118
%1120 = fmul double %1117, %1119
%1121 = getelementptr inbounds double, double* %1032, i64 %1114
store double %1120, double* %1121
%1122 = add nuw nsw i64 %1114, 1
%1123 = add i64 %1115, 1
%1124 = icmp eq i64 %1123, %126
br i1 %1124, label %1125, label %1113
1125: ; preds = %1113, %1109
%1126 = phi i64 [ %1110, %1109 ], [ %1122, %1113 ]
%1127 = icmp ult i64 %1112, 3
br i1 %1127, label %1159, label %1128
1128: ; preds = %1125, %1128
%1129 = phi i64 [ %1157, %1128 ], [ %1126, %1125 ]
%1130 = getelementptr inbounds double, double* %639, i64 %1129
%1131 = load double, double* %1130
%1132 = getelementptr inbounds double, double* %1031, i64 %1129
%1133 = load double, double* %1132
%1134 = fmul double %1131, %1133
%1135 = getelementptr inbounds double, double* %1032, i64 %1129
store double %1134, double* %1135
%1136 = add nuw nsw i64 %1129, 1
%1137 = getelementptr inbounds double, double* %639, i64 %1136
%1138 = load double, double* %1137
%1139 = getelementptr inbounds double, double* %1031, i64 %1136
%1140 = load double, double* %1139
%1141 = fmul double %1138, %1140
%1142 = getelementptr inbounds double, double* %1032, i64 %1136
store double %1141, double* %1142
%1143 = add nuw nsw i64 %1129, 2
%1144 = getelementptr inbounds double, double* %639, i64 %1143
%1145 = load double, double* %1144
%1146 = getelementptr inbounds double, double* %1031, i64 %1143
%1147 = load double, double* %1146
%1148 = fmul double %1145, %1147
%1149 = getelementptr inbounds double, double* %1032, i64 %1143
store double %1148, double* %1149
%1150 = add nuw nsw i64 %1129, 3
%1151 = getelementptr inbounds double, double* %639, i64 %1150
%1152 = load double, double* %1151
%1153 = getelementptr inbounds double, double* %1031, i64 %1150
%1154 = load double, double* %1153
%1155 = fmul double %1152, %1154
%1156 = getelementptr inbounds double, double* %1032, i64 %1150
store double %1155, double* %1156
%1157 = add nuw nsw i64 %1129, 4
%1158 = icmp eq i64 %1157, %80
br i1 %1158, label %1159, label %1128
1159: ; preds = %1125, %1128, %1108, %605, %769, %899, %1029
%1160 = add nuw nsw i64 %606, 1
%1161 = icmp eq i64 %1160, %74
br i1 %1161, label %1723, label %605
1162: ; preds = %14, %1718
%1163 = phi i64 [ 0, %14 ], [ %1719, %1718 ]
%1164 = mul i64 %1163, %17
%1165 = getelementptr double, double* %1, i64 %1164
%1166 = add i64 %1164, %19
%1167 = getelementptr double, double* %1, i64 %1166
%1168 = getelementptr double, double* %2, i64 %1164
%1169 = getelementptr double, double* %2, i64 %1166
%1170 = getelementptr double, double* %3, i64 %1164
%1171 = getelementptr double, double* %3, i64 %1166
%1172 = mul i64 %1163, %17
%1173 = add i64 %1172, %16
%1174 = getelementptr double, double* %1, i64 %1173
%1175 = add i64 %27, %1172
%1176 = getelementptr double, double* %1, i64 %1175
%1177 = getelementptr double, double* %2, i64 %1173
%1178 = getelementptr double, double* %2, i64 %1175
%1179 = getelementptr double, double* %3, i64 %1173
%1180 = getelementptr double, double* %3, i64 %1175
%1181 = mul i64 %1163, %17
%1182 = add i64 %21, %1181
%1183 = getelementptr double, double* %1, i64 %1182
%1184 = add i64 %26, %1181
%1185 = getelementptr double, double* %1, i64 %1184
%1186 = getelementptr double, double* %2, i64 %1182
%1187 = getelementptr double, double* %2, i64 %1184
%1188 = getelementptr double, double* %3, i64 %1182
%1189 = getelementptr double, double* %3, i64 %1184
%1190 = mul i64 %1163, %17
%1191 = add i64 %23, %1190
%1192 = getelementptr double, double* %1, i64 %1191
%1193 = add i64 %25, %1190
%1194 = getelementptr double, double* %1, i64 %1193
%1195 = getelementptr double, double* %2, i64 %1191
%1196 = getelementptr double, double* %2, i64 %1193
%1197 = getelementptr double, double* %3, i64 %1191
%1198 = getelementptr double, double* %3, i64 %1193
%1199 = mul nsw i64 %1163, %17
%1200 = getelementptr inbounds double, double* %2, i64 %1199
%1201 = getelementptr inbounds double, double* %3, i64 %1199
%1202 = getelementptr inbounds double, double* %1, i64 %1199
br i1 %15, label %1203, label %1718
1203: ; preds = %1162
br i1 %32, label %1278, label %1204
1204: ; preds = %1203
%1205 = icmp ult double* %1165, %1169
%1206 = icmp ult double* %1168, %1167
%1207 = and i1 %1205, %1206
%1208 = icmp ult double* %1165, %1171
%1209 = icmp ult double* %1170, %1167
%1210 = and i1 %1208, %1209
%1211 = or i1 %1207, %1210
br i1 %1211, label %1278, label %1212
1212: ; preds = %1204
br i1 %35, label %1256, label %1213
1213: ; preds = %1212, %1213
%1214 = phi i64 [ %1253, %1213 ], [ 0, %1212 ]
%1215 = phi i64 [ %1254, %1213 ], [ 0, %1212 ]
%1216 = getelementptr inbounds double, double* %1200, i64 %1214
%1217 = bitcast double* %1216 to <2 x double>*
%1218 = load <2 x double>, <2 x double>* %1217
%1219 = getelementptr inbounds double, double* %1216, i64 2
%1220 = bitcast double* %1219 to <2 x double>*
%1221 = load <2 x double>, <2 x double>* %1220
%1222 = getelementptr inbounds double, double* %1201, i64 %1214
%1223 = bitcast double* %1222 to <2 x double>*
%1224 = load <2 x double>, <2 x double>* %1223
%1225 = getelementptr inbounds double, double* %1222, i64 2
%1226 = bitcast double* %1225 to <2 x double>*
%1227 = load <2 x double>, <2 x double>* %1226
%1228 = fmul <2 x double> %1218, %1224
%1229 = fmul <2 x double> %1221, %1227
%1230 = getelementptr inbounds double, double* %1202, i64 %1214
%1231 = bitcast double* %1230 to <2 x double>*
store <2 x double> %1228, <2 x double>* %1231
%1232 = getelementptr inbounds double, double* %1230, i64 2
%1233 = bitcast double* %1232 to <2 x double>*
store <2 x double> %1229, <2 x double>* %1233
%1234 = or i64 %1214, 4
%1235 = getelementptr inbounds double, double* %1200, i64 %1234
%1236 = bitcast double* %1235 to <2 x double>*
%1237 = load <2 x double>, <2 x double>* %1236
%1238 = getelementptr inbounds double, double* %1235, i64 2
%1239 = bitcast double* %1238 to <2 x double>*
%1240 = load <2 x double>, <2 x double>* %1239
%1241 = getelementptr inbounds double, double* %1201, i64 %1234
%1242 = bitcast double* %1241 to <2 x double>*
%1243 = load <2 x double>, <2 x double>* %1242
%1244 = getelementptr inbounds double, double* %1241, i64 2
%1245 = bitcast double* %1244 to <2 x double>*
%1246 = load <2 x double>, <2 x double>* %1245
%1247 = fmul <2 x double> %1237, %1243
%1248 = fmul <2 x double> %1240, %1246
%1249 = getelementptr inbounds double, double* %1202, i64 %1234
%1250 = bitcast double* %1249 to <2 x double>*
store <2 x double> %1247, <2 x double>* %1250
%1251 = getelementptr inbounds double, double* %1249, i64 2
%1252 = bitcast double* %1251 to <2 x double>*
store <2 x double> %1248, <2 x double>* %1252
%1253 = add nuw i64 %1214, 8
%1254 = add i64 %1215, 2
%1255 = icmp eq i64 %1254, %36
br i1 %1255, label %1256, label %1213
1256: ; preds = %1213, %1212
%1257 = phi i64 [ 0, %1212 ], [ %1253, %1213 ]
br i1 %37, label %1277, label %1258
1258: ; preds = %1256
%1259 = getelementptr inbounds double, double* %1200, i64 %1257
%1260 = bitcast double* %1259 to <2 x double>*
%1261 = load <2 x double>, <2 x double>* %1260
%1262 = getelementptr inbounds double, double* %1259, i64 2
%1263 = bitcast double* %1262 to <2 x double>*
%1264 = load <2 x double>, <2 x double>* %1263
%1265 = getelementptr inbounds double, double* %1201, i64 %1257
%1266 = bitcast double* %1265 to <2 x double>*
%1267 = load <2 x double>, <2 x double>* %1266
%1268 = getelementptr inbounds double, double* %1265, i64 2
%1269 = bitcast double* %1268 to <2 x double>*
%1270 = load <2 x double>, <2 x double>* %1269
%1271 = fmul <2 x double> %1261, %1267
%1272 = fmul <2 x double> %1264, %1270
%1273 = getelementptr inbounds double, double* %1202, i64 %1257
%1274 = bitcast double* %1273 to <2 x double>*
store <2 x double> %1271, <2 x double>* %1274
%1275 = getelementptr inbounds double, double* %1273, i64 2
%1276 = bitcast double* %1275 to <2 x double>*
store <2 x double> %1272, <2 x double>* %1276
br label %1277
1277: ; preds = %1256, %1258
br i1 %38, label %1328, label %1278
1278: ; preds = %1204, %1203, %1277
%1279 = phi i64 [ 0, %1204 ], [ 0, %1203 ], [ %33, %1277 ]
%1280 = xor i64 %1279, -1
%1281 = add nsw i64 %1280, %19
br i1 %40, label %1294, label %1282
1282: ; preds = %1278, %1282
%1283 = phi i64 [ %1291, %1282 ], [ %1279, %1278 ]
%1284 = phi i64 [ %1292, %1282 ], [ 0, %1278 ]
%1285 = getelementptr inbounds double, double* %1200, i64 %1283
%1286 = load double, double* %1285
%1287 = getelementptr inbounds double, double* %1201, i64 %1283
%1288 = load double, double* %1287
%1289 = fmul double %1286, %1288
%1290 = getelementptr inbounds double, double* %1202, i64 %1283
store double %1289, double* %1290
%1291 = add nuw nsw i64 %1283, 1
%1292 = add i64 %1284, 1
%1293 = icmp eq i64 %1292, %39
br i1 %1293, label %1294, label %1282
1294: ; preds = %1282, %1278
%1295 = phi i64 [ %1279, %1278 ], [ %1291, %1282 ]
%1296 = icmp ult i64 %1281, 3
br i1 %1296, label %1328, label %1297
1297: ; preds = %1294, %1297
%1298 = phi i64 [ %1326, %1297 ], [ %1295, %1294 ]
%1299 = getelementptr inbounds double, double* %1200, i64 %1298
%1300 = load double, double* %1299
%1301 = getelementptr inbounds double, double* %1201, i64 %1298
%1302 = load double, double* %1301
%1303 = fmul double %1300, %1302
%1304 = getelementptr inbounds double, double* %1202, i64 %1298
store double %1303, double* %1304
%1305 = add nuw nsw i64 %1298, 1
%1306 = getelementptr inbounds double, double* %1200, i64 %1305
%1307 = load double, double* %1306
%1308 = getelementptr inbounds double, double* %1201, i64 %1305
%1309 = load double, double* %1308
%1310 = fmul double %1307, %1309
%1311 = getelementptr inbounds double, double* %1202, i64 %1305
store double %1310, double* %1311
%1312 = add nuw nsw i64 %1298, 2
%1313 = getelementptr inbounds double, double* %1200, i64 %1312
%1314 = load double, double* %1313
%1315 = getelementptr inbounds double, double* %1201, i64 %1312
%1316 = load double, double* %1315
%1317 = fmul double %1314, %1316
%1318 = getelementptr inbounds double, double* %1202, i64 %1312
store double %1317, double* %1318
%1319 = add nuw nsw i64 %1298, 3
%1320 = getelementptr inbounds double, double* %1200, i64 %1319
%1321 = load double, double* %1320
%1322 = getelementptr inbounds double, double* %1201, i64 %1319
%1323 = load double, double* %1322
%1324 = fmul double %1321, %1323
%1325 = getelementptr inbounds double, double* %1202, i64 %1319
store double %1324, double* %1325
%1326 = add nuw nsw i64 %1298, 4
%1327 = icmp eq i64 %1326, %19
br i1 %1327, label %1328, label %1297
1328: ; preds = %1294, %1297, %1277
%1329 = add nsw i64 %1199, %16
%1330 = getelementptr inbounds double, double* %2, i64 %1329
%1331 = getelementptr inbounds double, double* %3, i64 %1329
%1332 = getelementptr inbounds double, double* %1, i64 %1329
br i1 %15, label %1333, label %1718
1333: ; preds = %1328
br i1 %41, label %1408, label %1334
1334: ; preds = %1333
%1335 = icmp ult double* %1174, %1178
%1336 = icmp ult double* %1177, %1176
%1337 = and i1 %1335, %1336
%1338 = icmp ult double* %1174, %1180
%1339 = icmp ult double* %1179, %1176
%1340 = and i1 %1338, %1339
%1341 = or i1 %1337, %1340
br i1 %1341, label %1408, label %1342
1342: ; preds = %1334
br i1 %44, label %1386, label %1343
1343: ; preds = %1342, %1343
%1344 = phi i64 [ %1383, %1343 ], [ 0, %1342 ]
%1345 = phi i64 [ %1384, %1343 ], [ 0, %1342 ]
%1346 = getelementptr inbounds double, double* %1330, i64 %1344
%1347 = bitcast double* %1346 to <2 x double>*
%1348 = load <2 x double>, <2 x double>* %1347
%1349 = getelementptr inbounds double, double* %1346, i64 2
%1350 = bitcast double* %1349 to <2 x double>*
%1351 = load <2 x double>, <2 x double>* %1350
%1352 = getelementptr inbounds double, double* %1331, i64 %1344
%1353 = bitcast double* %1352 to <2 x double>*
%1354 = load <2 x double>, <2 x double>* %1353
%1355 = getelementptr inbounds double, double* %1352, i64 2
%1356 = bitcast double* %1355 to <2 x double>*
%1357 = load <2 x double>, <2 x double>* %1356
%1358 = fmul <2 x double> %1348, %1354
%1359 = fmul <2 x double> %1351, %1357
%1360 = getelementptr inbounds double, double* %1332, i64 %1344
%1361 = bitcast double* %1360 to <2 x double>*
store <2 x double> %1358, <2 x double>* %1361
%1362 = getelementptr inbounds double, double* %1360, i64 2
%1363 = bitcast double* %1362 to <2 x double>*
store <2 x double> %1359, <2 x double>* %1363
%1364 = or i64 %1344, 4
%1365 = getelementptr inbounds double, double* %1330, i64 %1364
%1366 = bitcast double* %1365 to <2 x double>*
%1367 = load <2 x double>, <2 x double>* %1366
%1368 = getelementptr inbounds double, double* %1365, i64 2
%1369 = bitcast double* %1368 to <2 x double>*
%1370 = load <2 x double>, <2 x double>* %1369
%1371 = getelementptr inbounds double, double* %1331, i64 %1364
%1372 = bitcast double* %1371 to <2 x double>*
%1373 = load <2 x double>, <2 x double>* %1372
%1374 = getelementptr inbounds double, double* %1371, i64 2
%1375 = bitcast double* %1374 to <2 x double>*
%1376 = load <2 x double>, <2 x double>* %1375
%1377 = fmul <2 x double> %1367, %1373
%1378 = fmul <2 x double> %1370, %1376
%1379 = getelementptr inbounds double, double* %1332, i64 %1364
%1380 = bitcast double* %1379 to <2 x double>*
store <2 x double> %1377, <2 x double>* %1380
%1381 = getelementptr inbounds double, double* %1379, i64 2
%1382 = bitcast double* %1381 to <2 x double>*
store <2 x double> %1378, <2 x double>* %1382
%1383 = add nuw i64 %1344, 8
%1384 = add i64 %1345, 2
%1385 = icmp eq i64 %1384, %45
br i1 %1385, label %1386, label %1343
1386: ; preds = %1343, %1342
%1387 = phi i64 [ 0, %1342 ], [ %1383, %1343 ]
br i1 %46, label %1407, label %1388
1388: ; preds = %1386
%1389 = getelementptr inbounds double, double* %1330, i64 %1387
%1390 = bitcast double* %1389 to <2 x double>*
%1391 = load <2 x double>, <2 x double>* %1390
%1392 = getelementptr inbounds double, double* %1389, i64 2
%1393 = bitcast double* %1392 to <2 x double>*
%1394 = load <2 x double>, <2 x double>* %1393
%1395 = getelementptr inbounds double, double* %1331, i64 %1387
%1396 = bitcast double* %1395 to <2 x double>*
%1397 = load <2 x double>, <2 x double>* %1396
%1398 = getelementptr inbounds double, double* %1395, i64 2
%1399 = bitcast double* %1398 to <2 x double>*
%1400 = load <2 x double>, <2 x double>* %1399
%1401 = fmul <2 x double> %1391, %1397
%1402 = fmul <2 x double> %1394, %1400
%1403 = getelementptr inbounds double, double* %1332, i64 %1387
%1404 = bitcast double* %1403 to <2 x double>*
store <2 x double> %1401, <2 x double>* %1404
%1405 = getelementptr inbounds double, double* %1403, i64 2
%1406 = bitcast double* %1405 to <2 x double>*
store <2 x double> %1402, <2 x double>* %1406
br label %1407
1407: ; preds = %1386, %1388
br i1 %47, label %1458, label %1408
1408: ; preds = %1334, %1333, %1407
%1409 = phi i64 [ 0, %1334 ], [ 0, %1333 ], [ %42, %1407 ]
%1410 = xor i64 %1409, -1
%1411 = add nsw i64 %1410, %19
br i1 %49, label %1424, label %1412
1412: ; preds = %1408, %1412
%1413 = phi i64 [ %1421, %1412 ], [ %1409, %1408 ]
%1414 = phi i64 [ %1422, %1412 ], [ 0, %1408 ]
%1415 = getelementptr inbounds double, double* %1330, i64 %1413
%1416 = load double, double* %1415
%1417 = getelementptr inbounds double, double* %1331, i64 %1413
%1418 = load double, double* %1417
%1419 = fmul double %1416, %1418
%1420 = getelementptr inbounds double, double* %1332, i64 %1413
store double %1419, double* %1420
%1421 = add nuw nsw i64 %1413, 1
%1422 = add i64 %1414, 1
%1423 = icmp eq i64 %1422, %48
br i1 %1423, label %1424, label %1412
1424: ; preds = %1412, %1408
%1425 = phi i64 [ %1409, %1408 ], [ %1421, %1412 ]
%1426 = icmp ult i64 %1411, 3
br i1 %1426, label %1458, label %1427
1427: ; preds = %1424, %1427
%1428 = phi i64 [ %1456, %1427 ], [ %1425, %1424 ]
%1429 = getelementptr inbounds double, double* %1330, i64 %1428
%1430 = load double, double* %1429
%1431 = getelementptr inbounds double, double* %1331, i64 %1428
%1432 = load double, double* %1431
%1433 = fmul double %1430, %1432
%1434 = getelementptr inbounds double, double* %1332, i64 %1428
store double %1433, double* %1434
%1435 = add nuw nsw i64 %1428, 1
%1436 = getelementptr inbounds double, double* %1330, i64 %1435
%1437 = load double, double* %1436
%1438 = getelementptr inbounds double, double* %1331, i64 %1435
%1439 = load double, double* %1438
%1440 = fmul double %1437, %1439
%1441 = getelementptr inbounds double, double* %1332, i64 %1435
store double %1440, double* %1441
%1442 = add nuw nsw i64 %1428, 2
%1443 = getelementptr inbounds double, double* %1330, i64 %1442
%1444 = load double, double* %1443
%1445 = getelementptr inbounds double, double* %1331, i64 %1442
%1446 = load double, double* %1445
%1447 = fmul double %1444, %1446
%1448 = getelementptr inbounds double, double* %1332, i64 %1442
store double %1447, double* %1448
%1449 = add nuw nsw i64 %1428, 3
%1450 = getelementptr inbounds double, double* %1330, i64 %1449
%1451 = load double, double* %1450
%1452 = getelementptr inbounds double, double* %1331, i64 %1449
%1453 = load double, double* %1452
%1454 = fmul double %1451, %1453
%1455 = getelementptr inbounds double, double* %1332, i64 %1449
store double %1454, double* %1455
%1456 = add nuw nsw i64 %1428, 4
%1457 = icmp eq i64 %1456, %20
br i1 %1457, label %1458, label %1427
1458: ; preds = %1424, %1427, %1407
%1459 = add nsw i64 %21, %1199
%1460 = getelementptr inbounds double, double* %2, i64 %1459
%1461 = getelementptr inbounds double, double* %3, i64 %1459
%1462 = getelementptr inbounds double, double* %1, i64 %1459
br i1 %15, label %1463, label %1718
1463: ; preds = %1458
br i1 %50, label %1538, label %1464
1464: ; preds = %1463
%1465 = icmp ult double* %1183, %1187
%1466 = icmp ult double* %1186, %1185
%1467 = and i1 %1465, %1466
%1468 = icmp ult double* %1183, %1189
%1469 = icmp ult double* %1188, %1185
%1470 = and i1 %1468, %1469
%1471 = or i1 %1467, %1470
br i1 %1471, label %1538, label %1472
1472: ; preds = %1464
br i1 %53, label %1516, label %1473
1473: ; preds = %1472, %1473
%1474 = phi i64 [ %1513, %1473 ], [ 0, %1472 ]
%1475 = phi i64 [ %1514, %1473 ], [ 0, %1472 ]
%1476 = getelementptr inbounds double, double* %1460, i64 %1474
%1477 = bitcast double* %1476 to <2 x double>*
%1478 = load <2 x double>, <2 x double>* %1477
%1479 = getelementptr inbounds double, double* %1476, i64 2
%1480 = bitcast double* %1479 to <2 x double>*
%1481 = load <2 x double>, <2 x double>* %1480
%1482 = getelementptr inbounds double, double* %1461, i64 %1474
%1483 = bitcast double* %1482 to <2 x double>*
%1484 = load <2 x double>, <2 x double>* %1483
%1485 = getelementptr inbounds double, double* %1482, i64 2
%1486 = bitcast double* %1485 to <2 x double>*
%1487 = load <2 x double>, <2 x double>* %1486
%1488 = fmul <2 x double> %1478, %1484
%1489 = fmul <2 x double> %1481, %1487
%1490 = getelementptr inbounds double, double* %1462, i64 %1474
%1491 = bitcast double* %1490 to <2 x double>*
store <2 x double> %1488, <2 x double>* %1491
%1492 = getelementptr inbounds double, double* %1490, i64 2
%1493 = bitcast double* %1492 to <2 x double>*
store <2 x double> %1489, <2 x double>* %1493
%1494 = or i64 %1474, 4
%1495 = getelementptr inbounds double, double* %1460, i64 %1494
%1496 = bitcast double* %1495 to <2 x double>*
%1497 = load <2 x double>, <2 x double>* %1496
%1498 = getelementptr inbounds double, double* %1495, i64 2
%1499 = bitcast double* %1498 to <2 x double>*
%1500 = load <2 x double>, <2 x double>* %1499
%1501 = getelementptr inbounds double, double* %1461, i64 %1494
%1502 = bitcast double* %1501 to <2 x double>*
%1503 = load <2 x double>, <2 x double>* %1502
%1504 = getelementptr inbounds double, double* %1501, i64 2
%1505 = bitcast double* %1504 to <2 x double>*
%1506 = load <2 x double>, <2 x double>* %1505
%1507 = fmul <2 x double> %1497, %1503
%1508 = fmul <2 x double> %1500, %1506
%1509 = getelementptr inbounds double, double* %1462, i64 %1494
%1510 = bitcast double* %1509 to <2 x double>*
store <2 x double> %1507, <2 x double>* %1510
%1511 = getelementptr inbounds double, double* %1509, i64 2
%1512 = bitcast double* %1511 to <2 x double>*
store <2 x double> %1508, <2 x double>* %1512
%1513 = add nuw i64 %1474, 8
%1514 = add i64 %1475, 2
%1515 = icmp eq i64 %1514, %54
br i1 %1515, label %1516, label %1473
1516: ; preds = %1473, %1472
%1517 = phi i64 [ 0, %1472 ], [ %1513, %1473 ]
br i1 %55, label %1537, label %1518
1518: ; preds = %1516
%1519 = getelementptr inbounds double, double* %1460, i64 %1517
%1520 = bitcast double* %1519 to <2 x double>*
%1521 = load <2 x double>, <2 x double>* %1520
%1522 = getelementptr inbounds double, double* %1519, i64 2
%1523 = bitcast double* %1522 to <2 x double>*
%1524 = load <2 x double>, <2 x double>* %1523
%1525 = getelementptr inbounds double, double* %1461, i64 %1517
%1526 = bitcast double* %1525 to <2 x double>*
%1527 = load <2 x double>, <2 x double>* %1526
%1528 = getelementptr inbounds double, double* %1525, i64 2
%1529 = bitcast double* %1528 to <2 x double>*
%1530 = load <2 x double>, <2 x double>* %1529
%1531 = fmul <2 x double> %1521, %1527
%1532 = fmul <2 x double> %1524, %1530
%1533 = getelementptr inbounds double, double* %1462, i64 %1517
%1534 = bitcast double* %1533 to <2 x double>*
store <2 x double> %1531, <2 x double>* %1534
%1535 = getelementptr inbounds double, double* %1533, i64 2
%1536 = bitcast double* %1535 to <2 x double>*
store <2 x double> %1532, <2 x double>* %1536
br label %1537
1537: ; preds = %1516, %1518
br i1 %56, label %1588, label %1538
1538: ; preds = %1464, %1463, %1537
%1539 = phi i64 [ 0, %1464 ], [ 0, %1463 ], [ %51, %1537 ]
%1540 = xor i64 %1539, -1
%1541 = add nsw i64 %1540, %19
br i1 %58, label %1554, label %1542
1542: ; preds = %1538, %1542
%1543 = phi i64 [ %1551, %1542 ], [ %1539, %1538 ]
%1544 = phi i64 [ %1552, %1542 ], [ 0, %1538 ]
%1545 = getelementptr inbounds double, double* %1460, i64 %1543
%1546 = load double, double* %1545
%1547 = getelementptr inbounds double, double* %1461, i64 %1543
%1548 = load double, double* %1547
%1549 = fmul double %1546, %1548
%1550 = getelementptr inbounds double, double* %1462, i64 %1543
store double %1549, double* %1550
%1551 = add nuw nsw i64 %1543, 1
%1552 = add i64 %1544, 1
%1553 = icmp eq i64 %1552, %57
br i1 %1553, label %1554, label %1542
1554: ; preds = %1542, %1538
%1555 = phi i64 [ %1539, %1538 ], [ %1551, %1542 ]
%1556 = icmp ult i64 %1541, 3
br i1 %1556, label %1588, label %1557
1557: ; preds = %1554, %1557
%1558 = phi i64 [ %1586, %1557 ], [ %1555, %1554 ]
%1559 = getelementptr inbounds double, double* %1460, i64 %1558
%1560 = load double, double* %1559
%1561 = getelementptr inbounds double, double* %1461, i64 %1558
%1562 = load double, double* %1561
%1563 = fmul double %1560, %1562
%1564 = getelementptr inbounds double, double* %1462, i64 %1558
store double %1563, double* %1564
%1565 = add nuw nsw i64 %1558, 1
%1566 = getelementptr inbounds double, double* %1460, i64 %1565
%1567 = load double, double* %1566
%1568 = getelementptr inbounds double, double* %1461, i64 %1565
%1569 = load double, double* %1568
%1570 = fmul double %1567, %1569
%1571 = getelementptr inbounds double, double* %1462, i64 %1565
store double %1570, double* %1571
%1572 = add nuw nsw i64 %1558, 2
%1573 = getelementptr inbounds double, double* %1460, i64 %1572
%1574 = load double, double* %1573
%1575 = getelementptr inbounds double, double* %1461, i64 %1572
%1576 = load double, double* %1575
%1577 = fmul double %1574, %1576
%1578 = getelementptr inbounds double, double* %1462, i64 %1572
store double %1577, double* %1578
%1579 = add nuw nsw i64 %1558, 3
%1580 = getelementptr inbounds double, double* %1460, i64 %1579
%1581 = load double, double* %1580
%1582 = getelementptr inbounds double, double* %1461, i64 %1579
%1583 = load double, double* %1582
%1584 = fmul double %1581, %1583
%1585 = getelementptr inbounds double, double* %1462, i64 %1579
store double %1584, double* %1585
%1586 = add nuw nsw i64 %1558, 4
%1587 = icmp eq i64 %1586, %22
br i1 %1587, label %1588, label %1557
1588: ; preds = %1554, %1557, %1537
%1589 = add nsw i64 %23, %1199
%1590 = getelementptr inbounds double, double* %2, i64 %1589
%1591 = getelementptr inbounds double, double* %3, i64 %1589
%1592 = getelementptr inbounds double, double* %1, i64 %1589
br i1 %15, label %1593, label %1718
1593: ; preds = %1588
br i1 %59, label %1668, label %1594
1594: ; preds = %1593
%1595 = icmp ult double* %1192, %1196
%1596 = icmp ult double* %1195, %1194
%1597 = and i1 %1595, %1596
%1598 = icmp ult double* %1192, %1198
%1599 = icmp ult double* %1197, %1194
%1600 = and i1 %1598, %1599
%1601 = or i1 %1597, %1600
br i1 %1601, label %1668, label %1602
1602: ; preds = %1594
br i1 %62, label %1646, label %1603
1603: ; preds = %1602, %1603
%1604 = phi i64 [ %1643, %1603 ], [ 0, %1602 ]
%1605 = phi i64 [ %1644, %1603 ], [ 0, %1602 ]
%1606 = getelementptr inbounds double, double* %1590, i64 %1604
%1607 = bitcast double* %1606 to <2 x double>*
%1608 = load <2 x double>, <2 x double>* %1607
%1609 = getelementptr inbounds double, double* %1606, i64 2
%1610 = bitcast double* %1609 to <2 x double>*
%1611 = load <2 x double>, <2 x double>* %1610
%1612 = getelementptr inbounds double, double* %1591, i64 %1604
%1613 = bitcast double* %1612 to <2 x double>*
%1614 = load <2 x double>, <2 x double>* %1613
%1615 = getelementptr inbounds double, double* %1612, i64 2
%1616 = bitcast double* %1615 to <2 x double>*
%1617 = load <2 x double>, <2 x double>* %1616
%1618 = fmul <2 x double> %1608, %1614
%1619 = fmul <2 x double> %1611, %1617
%1620 = getelementptr inbounds double, double* %1592, i64 %1604
%1621 = bitcast double* %1620 to <2 x double>*
store <2 x double> %1618, <2 x double>* %1621
%1622 = getelementptr inbounds double, double* %1620, i64 2
%1623 = bitcast double* %1622 to <2 x double>*
store <2 x double> %1619, <2 x double>* %1623
%1624 = or i64 %1604, 4
%1625 = getelementptr inbounds double, double* %1590, i64 %1624
%1626 = bitcast double* %1625 to <2 x double>*
%1627 = load <2 x double>, <2 x double>* %1626
%1628 = getelementptr inbounds double, double* %1625, i64 2
%1629 = bitcast double* %1628 to <2 x double>*
%1630 = load <2 x double>, <2 x double>* %1629
%1631 = getelementptr inbounds double, double* %1591, i64 %1624
%1632 = bitcast double* %1631 to <2 x double>*
%1633 = load <2 x double>, <2 x double>* %1632
%1634 = getelementptr inbounds double, double* %1631, i64 2
%1635 = bitcast double* %1634 to <2 x double>*
%1636 = load <2 x double>, <2 x double>* %1635
%1637 = fmul <2 x double> %1627, %1633
%1638 = fmul <2 x double> %1630, %1636
%1639 = getelementptr inbounds double, double* %1592, i64 %1624
%1640 = bitcast double* %1639 to <2 x double>*
store <2 x double> %1637, <2 x double>* %1640
%1641 = getelementptr inbounds double, double* %1639, i64 2
%1642 = bitcast double* %1641 to <2 x double>*
store <2 x double> %1638, <2 x double>* %1642
%1643 = add nuw i64 %1604, 8
%1644 = add i64 %1605, 2
%1645 = icmp eq i64 %1644, %63
br i1 %1645, label %1646, label %1603
1646: ; preds = %1603, %1602
%1647 = phi i64 [ 0, %1602 ], [ %1643, %1603 ]
br i1 %64, label %1667, label %1648
1648: ; preds = %1646
%1649 = getelementptr inbounds double, double* %1590, i64 %1647
%1650 = bitcast double* %1649 to <2 x double>*
%1651 = load <2 x double>, <2 x double>* %1650
%1652 = getelementptr inbounds double, double* %1649, i64 2
%1653 = bitcast double* %1652 to <2 x double>*
%1654 = load <2 x double>, <2 x double>* %1653
%1655 = getelementptr inbounds double, double* %1591, i64 %1647
%1656 = bitcast double* %1655 to <2 x double>*
%1657 = load <2 x double>, <2 x double>* %1656
%1658 = getelementptr inbounds double, double* %1655, i64 2
%1659 = bitcast double* %1658 to <2 x double>*
%1660 = load <2 x double>, <2 x double>* %1659
%1661 = fmul <2 x double> %1651, %1657
%1662 = fmul <2 x double> %1654, %1660
%1663 = getelementptr inbounds double, double* %1592, i64 %1647
%1664 = bitcast double* %1663 to <2 x double>*
store <2 x double> %1661, <2 x double>* %1664
%1665 = getelementptr inbounds double, double* %1663, i64 2
%1666 = bitcast double* %1665 to <2 x double>*
store <2 x double> %1662, <2 x double>* %1666
br label %1667
1667: ; preds = %1646, %1648
br i1 %65, label %1718, label %1668
1668: ; preds = %1594, %1593, %1667
%1669 = phi i64 [ 0, %1594 ], [ 0, %1593 ], [ %60, %1667 ]
%1670 = xor i64 %1669, -1
%1671 = add nsw i64 %1670, %19
br i1 %67, label %1684, label %1672
1672: ; preds = %1668, %1672
%1673 = phi i64 [ %1681, %1672 ], [ %1669, %1668 ]
%1674 = phi i64 [ %1682, %1672 ], [ 0, %1668 ]
%1675 = getelementptr inbounds double, double* %1590, i64 %1673
%1676 = load double, double* %1675
%1677 = getelementptr inbounds double, double* %1591, i64 %1673
%1678 = load double, double* %1677
%1679 = fmul double %1676, %1678
%1680 = getelementptr inbounds double, double* %1592, i64 %1673
store double %1679, double* %1680
%1681 = add nuw nsw i64 %1673, 1
%1682 = add i64 %1674, 1
%1683 = icmp eq i64 %1682, %66
br i1 %1683, label %1684, label %1672
1684: ; preds = %1672, %1668
%1685 = phi i64 [ %1669, %1668 ], [ %1681, %1672 ]
%1686 = icmp ult i64 %1671, 3
br i1 %1686, label %1718, label %1687
1687: ; preds = %1684, %1687
%1688 = phi i64 [ %1716, %1687 ], [ %1685, %1684 ]
%1689 = getelementptr inbounds double, double* %1590, i64 %1688
%1690 = load double, double* %1689
%1691 = getelementptr inbounds double, double* %1591, i64 %1688
%1692 = load double, double* %1691
%1693 = fmul double %1690, %1692
%1694 = getelementptr inbounds double, double* %1592, i64 %1688
store double %1693, double* %1694
%1695 = add nuw nsw i64 %1688, 1
%1696 = getelementptr inbounds double, double* %1590, i64 %1695
%1697 = load double, double* %1696
%1698 = getelementptr inbounds double, double* %1591, i64 %1695
%1699 = load double, double* %1698
%1700 = fmul double %1697, %1699
%1701 = getelementptr inbounds double, double* %1592, i64 %1695
store double %1700, double* %1701
%1702 = add nuw nsw i64 %1688, 2
%1703 = getelementptr inbounds double, double* %1590, i64 %1702
%1704 = load double, double* %1703
%1705 = getelementptr inbounds double, double* %1591, i64 %1702
%1706 = load double, double* %1705
%1707 = fmul double %1704, %1706
%1708 = getelementptr inbounds double, double* %1592, i64 %1702
store double %1707, double* %1708
%1709 = add nuw nsw i64 %1688, 3
%1710 = getelementptr inbounds double, double* %1590, i64 %1709
%1711 = load double, double* %1710
%1712 = getelementptr inbounds double, double* %1591, i64 %1709
%1713 = load double, double* %1712
%1714 = fmul double %1711, %1713
%1715 = getelementptr inbounds double, double* %1592, i64 %1709
store double %1714, double* %1715
%1716 = add nuw nsw i64 %1688, 4
%1717 = icmp eq i64 %1716, %24
br i1 %1717, label %1718, label %1687
1718: ; preds = %1684, %1687, %1667, %1162, %1328, %1458, %1588
%1719 = add nuw nsw i64 %1163, 1
%1720 = icmp eq i64 %1719, %18
br i1 %1720, label %1723, label %1162
1721: ; preds = %7
%1722 = call i32 @assert(i32 0)
br label %1723
1723: ; preds = %1718, %1159, %602, %12, %68, %128, %1721
ret void
}