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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int /*<<< orphan*/);
int /*<<< orphan*/ reorder(double *, int, int const);
int /*<<< orphan*/ reorder_back(double *, int, int const);
void sumGAMMA_FLEX(int tipCase, double *sumtable, double *x1, double *x2,
                   double *tipVector, unsigned char *tipX1,
                   unsigned char *tipX2, int n, const int states) {
  int i, l, k;
  const int span = 4 * states;
  double *left, *right, *sum;
  switch (tipCase) {
  case 0:
    for (i = 0; i < n; i++) {
      left = &(tipVector[states * tipX1[i]]);
      right = &(tipVector[states * tipX2[i]]);
      for (l = 0; l < 4; l++) {
        sum = &sumtable[i * span + l * states];
        for (k = 0; k < states; k++)
          sum[k] = left[k] * right[k];
      }
    }
    break;
  case 1:
    reorder_back(x2, n, span);
    for (i = 0; i < n; i++) {
      left = &(tipVector[states * tipX1[i]]);
      for (l = 0; l < 4; l++) {
        right = &(x2[span * i + l * states]);
        sum = &sumtable[i * span + l * states];
        for (k = 0; k < states; k++)
          sum[k] = left[k] * right[k];
      }
    }
    reorder(x2, n, span);
    break;
  case 2:
    reorder_back(x1, n, span);
    reorder_back(x2, n, span);
    for (i = 0; i < n; i++) {
      for (l = 0; l < 4; l++) {
        left = &(x1[span * i + l * states]);
        right = &(x2[span * i + l * states]);
        sum = &(sumtable[i * span + l * states]);
        for (k = 0; k < states; k++)
          sum[k] = left[k] * right[k];
      }
    }
    reorder(x1, n, span);
    reorder(x2, n, span);
    break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<sumGAMMA_FLEX>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x20(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x5c(%rbp)
test   %eax,%eax
je     1197 <sumGAMMA_FLEX+0x67>
jmp    1175 <sumGAMMA_FLEX+0x45>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
je     1298 <sumGAMMA_FLEX+0x168>
jmp    1186 <sumGAMMA_FLEX+0x56>
mov    -0x5c(%rbp),%eax
sub    $0x2,%eax
je     13b5 <sumGAMMA_FLEX+0x285>
jmp    14ee <sumGAMMA_FLEX+0x3be>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1293 <sumGAMMA_FLEX+0x163>
mov    -0x28(%rbp),%rax
mov    0x20(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x34(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    0x20(%rbp),%ecx
mov    0x10(%rbp),%rdx
movslq -0x34(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    1280 <sumGAMMA_FLEX+0x150>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    126d <sumGAMMA_FLEX+0x13d>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    122c <sumGAMMA_FLEX+0xfc>
jmp    1272 <sumGAMMA_FLEX+0x142>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f9 <sumGAMMA_FLEX+0xc9>
jmp    1285 <sumGAMMA_FLEX+0x155>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    119e <sumGAMMA_FLEX+0x6e>
jmp    14f5 <sumGAMMA_FLEX+0x3c5>
mov    -0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1050 <reorder_back@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13a1 <sumGAMMA_FLEX+0x271>
mov    -0x28(%rbp),%rax
mov    0x20(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x34(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    138e <sumGAMMA_FLEX+0x25e>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    137b <sumGAMMA_FLEX+0x24b>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    133a <sumGAMMA_FLEX+0x20a>
jmp    1380 <sumGAMMA_FLEX+0x250>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e5 <sumGAMMA_FLEX+0x1b5>
jmp    1393 <sumGAMMA_FLEX+0x263>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ae <sumGAMMA_FLEX+0x17e>
mov    -0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1040 <reorder@plt>
jmp    14f5 <sumGAMMA_FLEX+0x3c5>
mov    -0x18(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1050 <reorder_back@plt>
mov    -0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1050 <reorder_back@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    14cb <sumGAMMA_FLEX+0x39b>
movl   $0x0,-0x38(%rbp)
cmpl   $0x4,-0x38(%rbp)
jge    14b8 <sumGAMMA_FLEX+0x388>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    14a5 <sumGAMMA_FLEX+0x375>
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1464 <sumGAMMA_FLEX+0x334>
jmp    14aa <sumGAMMA_FLEX+0x37a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13ed <sumGAMMA_FLEX+0x2bd>
jmp    14bd <sumGAMMA_FLEX+0x38d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13da <sumGAMMA_FLEX+0x2aa>
mov    -0x18(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1040 <reorder@plt>
mov    -0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    -0x40(%rbp),%edx
call   1040 <reorder@plt>
jmp    14f5 <sumGAMMA_FLEX+0x3c5>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumGAMMA_FLEX>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,0x90(%rsp)
mov    %r8,0x98(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rsi,0x60(%rsp)
mov    0x1a0(%rsp),%r12d
mov    0x198(%rsp),%ebx
lea    0x0(,%r12,4),%ebp
cmp    $0x2,%edi
mov    %r12,(%rsp)
je     1c9a <sumGAMMA_FLEX+0xb6a>
movslq %r12d,%rax
mov    %rax,0xe8(%rsp)
cmp    $0x1,%edi
je     298e <sumGAMMA_FLEX+0x185e>
test   %edi,%edi
jne    35fa <sumGAMMA_FLEX+0x24ca>
test   %ebx,%ebx
jle    3612 <sumGAMMA_FLEX+0x24e2>
mov    0x190(%rsp),%rax
mov    %rax,0x110(%rsp)
movslq %ebp,%rsi
mov    %ebx,%eax
mov    %rax,0x50(%rsp)
mov    (%rsp),%r15d
mov    0xe8(%rsp),%rdx
lea    (%rdx,%rdx,1),%rax
mov    %rax,0x20(%rsp)
lea    (%rdx,%rdx,2),%r9
lea    (%r9,%r15,1),%rax
mov    %rax,0x78(%rsp)
mov    0x98(%rsp),%rcx
lea    (%rcx,%r15,8),%rax
mov    %rax,0x88(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xe0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x70(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xf8(%rsp)
mov    %r15d,%ebp
and    $0x3,%ebp
mov    %rdx,%r11
shl    $0x4,%r11
mov    0x60(%rsp),%rdi
lea    (%rdi,%r11,1),%rbx
add    $0x30,%rbx
mov    %rbx,0xc0(%rsp)
add    %rdi,%r11
lea    (%r15,%rdx,2),%rbx
mov    %rbx,0x40(%rsp)
lea    (%rdx,%r15,1),%rbx
mov    %rbx,0x38(%rsp)
lea    0x30(%rcx),%rbx
mov    %rbx,0x80(%rsp)
lea    0x30(%rdi),%r10
mov    %rsi,0x108(%rsp)
lea    0x0(,%rsi,8),%rsi
mov    %rsi,0x48(%rsp)
add    $0x18,%rcx
mov    %rcx,0xb8(%rsp)
lea    0x30(%rdi,%rdx,8),%rax
lea    (%rdi,%rdx,8),%r8
lea    (%rdi,%r9,8),%rdx
add    $0x30,%rdx
mov    %r9,0xf0(%rsp)
lea    (%rdi,%r9,8),%r12
xor    %r9d,%r9d
mov    %rbp,0x28(%rsp)
jmp    12f6 <sumGAMMA_FLEX+0x1c6>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x48(%rsp),%rcx
add    %rcx,%r10
add    %rcx,%rdi
add    %rcx,%rax
add    %rcx,%r8
add    %rcx,0xc0(%rsp)
add    %rcx,%r11
mov    0x58(%rsp),%rdx
add    %rcx,%rdx
add    %rcx,%r12
cmp    0x50(%rsp),%r9
je     3612 <sumGAMMA_FLEX+0x24e2>
mov    %rdx,0x58(%rsp)
cmpl   $0x0,(%rsp)
jle    12c0 <sumGAMMA_FLEX+0x190>
mov    %r9,%rsi
imul   0x108(%rsp),%rsi
mov    0x90(%rsp),%rcx
movzbl (%rcx,%r9,1),%r14d
mov    0xe8(%rsp),%rcx
imul   %rcx,%r14
mov    0x110(%rsp),%rdx
movzbl (%rdx,%r9,1),%edx
imul   %rcx,%rdx
mov    0x98(%rsp),%rcx
lea    (%rcx,%r14,8),%rbx
lea    (%rcx,%rdx,8),%rbp
cmpl   $0x4,(%rsp)
mov    %r14,0x10(%rsp)
mov    %rsi,0x8(%rsp)
mov    %r9,0x18(%rsp)
mov    %rdx,0x30(%rsp)
jae    1370 <sumGAMMA_FLEX+0x240>
xor    %edx,%edx
jmp    14f0 <sumGAMMA_FLEX+0x3c0>
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%r15,1),%r9
mov    %rdx,%rcx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rsi,8),%r13
lea    (%rdx,%r9,8),%rdx
mov    0x88(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cmp    %rcx,%r13
setb   %r9b
cmp    %rdx,%rbp
setb   %r14b
mov    %r13,0xb0(%rsp)
cmp    %rsi,%r13
setb   %cl
cmp    %rdx,%rbx
setb   %sil
test   %r14b,%r9b
jne    147d <sumGAMMA_FLEX+0x34d>
mov    $0x0,%edx
and    %sil,%cl
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jne    14f0 <sumGAMMA_FLEX+0x3c0>
cmpq   $0x0,0x68(%rsp)
je     148b <sumGAMMA_FLEX+0x35b>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r14,8),%r14
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,8),%r9
mov    0xf8(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%r14,%rdx,8),%xmm0
movupd -0x20(%r14,%rdx,8),%xmm1
movupd -0x30(%r9,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r9,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r10,%rdx,8)
movupd %xmm0,-0x20(%r10,%rdx,8)
movupd -0x10(%r14,%rdx,8),%xmm0
movupd (%r14,%rdx,8),%xmm1
movupd -0x10(%r9,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r9,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r10,%rdx,8)
movupd %xmm0,(%r10,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1410 <sumGAMMA_FLEX+0x2e0>
jmp    148d <sumGAMMA_FLEX+0x35d>
xor    %edx,%edx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jmp    14f0 <sumGAMMA_FLEX+0x3c0>
xor    %edx,%edx
testb  $0x1,0x70(%rsp)
mov    0x18(%rsp),%r9
je     14cb <sumGAMMA_FLEX+0x39b>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xb0(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xe0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
mov    0x10(%rsp),%r14
je     159e <sumGAMMA_FLEX+0x46e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
mov    0x28(%rsp),%rsi
test   %rsi,%rsi
je     152a <sumGAMMA_FLEX+0x3fa>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1510 <sumGAMMA_FLEX+0x3e0>
cmp    $0x3,%rcx
jb     159e <sumGAMMA_FLEX+0x46e>
mov    0xb8(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rsi,%rdx,8),%xmm0
mulsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
movsd  -0x10(%rsi,%rdx,8),%xmm0
mulsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rdx,8)
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1550 <sumGAMMA_FLEX+0x420>
cmpl   $0x0,(%rsp)
jle    12c0 <sumGAMMA_FLEX+0x190>
cmpl   $0x4,(%rsp)
jae    15b5 <sumGAMMA_FLEX+0x485>
xor    %edx,%edx
jmp    1730 <sumGAMMA_FLEX+0x600>
mov    0xe8(%rsp),%rcx
mov    0x8(%rsp),%rsi
add    %rsi,%rcx
mov    0x38(%rsp),%rdx
add    %rsi,%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rcx,8),%r13
lea    (%rsi,%rdx,8),%rdx
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cmp    %rcx,%r13
setb   %r9b
cmp    %rdx,%rbp
setb   %r14b
mov    %r13,0xb0(%rsp)
cmp    %rsi,%r13
setb   %cl
cmp    %rdx,%rbx
setb   %sil
test   %r14b,%r9b
jne    1716 <sumGAMMA_FLEX+0x5e6>
mov    $0x0,%edx
and    %sil,%cl
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jne    1730 <sumGAMMA_FLEX+0x600>
cmpq   $0x0,0x68(%rsp)
je     1971 <sumGAMMA_FLEX+0x841>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r14,8),%r14
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    0xf8(%rsp),%rsi
xor    %edx,%edx
xchg   %ax,%ax
movupd -0x30(%r14,%rdx,8),%xmm0
movupd -0x20(%r14,%rdx,8),%xmm1
movupd -0x30(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rax,%rdx,8)
movupd %xmm0,-0x20(%rax,%rdx,8)
movupd -0x10(%r14,%rdx,8),%xmm0
movupd (%r14,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdx,8)
movupd %xmm0,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1660 <sumGAMMA_FLEX+0x530>
testb  $0x1,0x70(%rsp)
je     16fc <sumGAMMA_FLEX+0x5cc>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xb0(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xe0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
mov    0x10(%rsp),%r14
jne    1730 <sumGAMMA_FLEX+0x600>
jmp    17e2 <sumGAMMA_FLEX+0x6b2>
xor    %edx,%edx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
test   $0x3,%r15b
je     176b <sumGAMMA_FLEX+0x63b>
mov    0x28(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1750 <sumGAMMA_FLEX+0x620>
cmp    $0x3,%rcx
jb     17e2 <sumGAMMA_FLEX+0x6b2>
mov    0xb8(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rsi,%rdx,8),%xmm0
mulsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r8,%rdx,8)
movsd  -0x10(%rsi,%rdx,8),%xmm0
mulsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rdx,8)
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r8,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r8,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1790 <sumGAMMA_FLEX+0x660>
cmpl   $0x0,(%rsp)
jle    12c0 <sumGAMMA_FLEX+0x190>
cmpl   $0x4,(%rsp)
jae    17f9 <sumGAMMA_FLEX+0x6c9>
xor    %edx,%edx
jmp    1990 <sumGAMMA_FLEX+0x860>
mov    0x20(%rsp),%rcx
mov    0x8(%rsp),%rsi
add    %rsi,%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rsi,1),%r9
mov    0x60(%rsp),%rsi
lea    (%rsi,%rcx,8),%rdx
lea    (%rsi,%r9,8),%r9
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cmp    %rcx,%rdx
setb   %r13b
cmp    %r9,%rbp
setb   %r14b
mov    %rdx,0xb0(%rsp)
cmp    %rsi,%rdx
setb   %cl
cmp    %r9,%rbx
setb   %sil
test   %r14b,%r13b
jne    1983 <sumGAMMA_FLEX+0x853>
mov    $0x0,%edx
and    %sil,%cl
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jne    1990 <sumGAMMA_FLEX+0x860>
cmpq   $0x0,0x68(%rsp)
je     1c19 <sumGAMMA_FLEX+0xae9>
mov    %rax,%r13
mov    0x80(%rsp),%rcx
lea    (%rcx,%r14,8),%r14
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    0xf8(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%r14,%rdx,8),%xmm0
movupd -0x20(%r14,%rdx,8),%xmm1
movupd -0x30(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xc0(%rsp),%rax
movupd %xmm2,-0x30(%rax,%rdx,8)
movupd %xmm0,-0x20(%rax,%rdx,8)
movupd -0x10(%r14,%rdx,8),%xmm0
movupd (%r14,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdx,8)
movupd %xmm0,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    18b0 <sumGAMMA_FLEX+0x780>
testb  $0x1,0x70(%rsp)
je     1954 <sumGAMMA_FLEX+0x824>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xb0(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xe0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
mov    0x10(%rsp),%r14
mov    %r13,%rax
jne    1990 <sumGAMMA_FLEX+0x860>
jmp    1a42 <sumGAMMA_FLEX+0x912>
xor    %edx,%edx
testb  $0x1,0x70(%rsp)
jne    16ca <sumGAMMA_FLEX+0x59a>
jmp    16fc <sumGAMMA_FLEX+0x5cc>
xor    %edx,%edx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
nop
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
test   $0x3,%r15b
je     19cb <sumGAMMA_FLEX+0x89b>
mov    0x28(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    19b0 <sumGAMMA_FLEX+0x880>
cmp    $0x3,%rcx
jb     1a42 <sumGAMMA_FLEX+0x912>
mov    0xb8(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rsi,%rdx,8),%xmm0
mulsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
movsd  -0x10(%rsi,%rdx,8),%xmm0
mulsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r11,%rdx,8)
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r11,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r11,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    19f0 <sumGAMMA_FLEX+0x8c0>
cmpl   $0x0,(%rsp)
jle    12c0 <sumGAMMA_FLEX+0x190>
cmpl   $0x4,(%rsp)
jae    1b07 <sumGAMMA_FLEX+0x9d7>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
test   $0x3,%r15b
je     1a8b <sumGAMMA_FLEX+0x95b>
mov    0x28(%rsp),%rsi
nopl   0x0(%rax)
movsd  (%rbx,%rdx,8),%xmm0
mulsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1a70 <sumGAMMA_FLEX+0x940>
cmp    $0x3,%rcx
jb     12c0 <sumGAMMA_FLEX+0x190>
mov    0xb8(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rsi,%rdx,8),%xmm0
mulsd  -0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  -0x10(%rsi,%rdx,8),%xmm0
mulsd  -0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdx,8)
movsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  -0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r12,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1ab0 <sumGAMMA_FLEX+0x980>
jmp    12c0 <sumGAMMA_FLEX+0x190>
mov    0xf0(%rsp),%rcx
mov    0x8(%rsp),%rsi
lea    (%rcx,%rsi,1),%rdx
add    0x78(%rsp),%rsi
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdx
lea    (%rcx,%rsi,8),%r9
mov    0x88(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rsi,%rcx,8),%rcx
lea    (%rsi,%r14,8),%rsi
cmp    %rcx,%rdx
setb   %r13b
cmp    %r9,%rbp
setb   %r14b
mov    %rdx,0x8(%rsp)
cmp    %rsi,%rdx
setb   %cl
cmp    %r9,%rbx
setb   %sil
test   %r14b,%r13b
jne    1c2e <sumGAMMA_FLEX+0xafe>
mov    $0x0,%edx
and    %sil,%cl
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jne    1a58 <sumGAMMA_FLEX+0x928>
cmpq   $0x0,0x68(%rsp)
je     1c3f <sumGAMMA_FLEX+0xb0f>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r14,8),%r14
mov    0x30(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    0xf8(%rsp),%rsi
xor    %edx,%edx
mov    0x58(%rsp),%r9
movupd -0x30(%r14,%rdx,8),%xmm0
movupd -0x20(%r14,%rdx,8),%xmm1
movupd -0x30(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r9,%rdx,8)
movupd %xmm0,-0x20(%r9,%rdx,8)
movupd -0x10(%r14,%rdx,8),%xmm0
movupd (%r14,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r9,%rdx,8)
movupd %xmm0,(%r9,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1bb0 <sumGAMMA_FLEX+0xa80>
jmp    1c41 <sumGAMMA_FLEX+0xb11>
mov    %rax,%r13
xor    %edx,%edx
testb  $0x1,0x70(%rsp)
jne    1922 <sumGAMMA_FLEX+0x7f2>
jmp    1954 <sumGAMMA_FLEX+0x824>
xor    %edx,%edx
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r14
jmp    1a58 <sumGAMMA_FLEX+0x928>
xor    %edx,%edx
testb  $0x1,0x70(%rsp)
mov    0x18(%rsp),%r9
je     1c7c <sumGAMMA_FLEX+0xb4c>
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd 0x0(%rbp,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x8(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xe0(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
mov    0x10(%rsp),%r14
je     12c0 <sumGAMMA_FLEX+0x190>
jmp    1a58 <sumGAMMA_FLEX+0x928>
mov    %rdx,0x20(%rsp)
mov    %rdx,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
call   1050 <reorder_back@plt>
mov    0x48(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,0xa0(%rsp)
mov    %ebp,%edx
call   1050 <reorder_back@plt>
mov    %ebx,0xa4(%rsp)
test   %ebx,%ebx
jle    3624 <sumGAMMA_FLEX+0x24f4>
movslq %r12d,%r8
movslq 0xa0(%rsp),%rcx
mov    0xa4(%rsp),%eax
mov    %rax,0xf8(%rsp)
mov    %r12d,%r15d
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0xd8(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xd0(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x118(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x40(%rsp)
mov    %r8,%rsi
shl    $0x4,%rsi
mov    0x20(%rsp),%r11
lea    (%r11,%rsi,1),%rax
add    $0x30,%rax
mov    %rax,0x68(%rsp)
mov    0x48(%rsp),%rbp
lea    0x30(%rbp,%rsi,1),%rdx
mov    0x60(%rsp),%r14
lea    0x30(%r14,%rsi,1),%rbx
lea    (%r14,%rsi,1),%rax
mov    %rax,0x28(%rsp)
lea    (%rsi,%rbp,1),%rax
mov    %rax,0x88(%rsp)
add    %r11,%rsi
mov    %rsi,0x98(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,0x150(%rsp)
lea    (%r8,%r8,2),%r12
lea    (%r12,%r15,1),%rdi
mov    %rdi,0x130(%rsp)
lea    (%r15,%r8,2),%rdi
mov    %rdi,0x148(%rsp)
lea    (%r8,%r15,1),%rdi
mov    %rdi,0x120(%rsp)
lea    0x30(%r11),%rdi
mov    %rcx,0xf0(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x80(%rsp)
lea    0x30(%rbp),%rcx
mov    %rcx,0x110(%rsp)
lea    0x30(%r14),%rcx
mov    %rcx,0x108(%rsp)
lea    0x30(%r11,%r8,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x30(%rbp,%r8,8),%rcx
mov    %rcx,0xb0(%rsp)
lea    0x30(%r14,%r8,8),%rcx
mov    %rcx,0xe0(%rsp)
lea    (%r14,%r8,8),%r9
lea    0x0(%rbp,%r8,8),%r10
mov    %r8,0x128(%rsp)
lea    (%r11,%r8,8),%r8
lea    0x30(%r11,%r12,8),%rax
mov    %rax,0x90(%rsp)
lea    0x30(%rbp,%r12,8),%rsi
mov    %rsi,0x70(%rsp)
lea    0x30(%r14,%r12,8),%rax
mov    %rax,0x10(%rsp)
lea    (%r14,%r12,8),%r13
mov    %r13,0xc0(%rsp)
lea    0x0(%rbp,%r12,8),%rax
mov    %rax,0x58(%rsp)
mov    %r12,0x138(%rsp)
lea    (%r11,%r12,8),%rax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %r15,%rax
mov    0x40(%rsp),%r12
mov    %r15,0x78(%rsp)
jmp    1f4b <sumGAMMA_FLEX+0xe1b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%r15
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    0x80(%rsp),%rcx
add    %rcx,%rdi
add    %rcx,0x110(%rsp)
add    %rcx,0x108(%rsp)
add    %rcx,%r14
add    %rcx,%rbp
add    %rcx,%r11
add    %rcx,0xb8(%rsp)
add    %rcx,0xb0(%rsp)
add    %rcx,0xe0(%rsp)
add    %rcx,%r9
add    %rcx,%r10
add    %rcx,%r8
add    %rcx,0x68(%rsp)
mov    0xe8(%rsp),%rdx
add    %rcx,%rdx
mov    0x50(%rsp),%rbx
add    %rcx,%rbx
add    %rcx,0x28(%rsp)
add    %rcx,0x88(%rsp)
add    %rcx,0x98(%rsp)
add    %rcx,0x90(%rsp)
add    %rcx,0x70(%rsp)
add    %rcx,0x10(%rsp)
add    %rcx,0xc0(%rsp)
add    %rcx,0x58(%rsp)
add    %rcx,0x30(%rsp)
mov    %rax,%rsi
mov    %rax,0x18(%rsp)
cmp    0xf8(%rsp),%rax
mov    %r15,%rax
je     3624 <sumGAMMA_FLEX+0x24f4>
mov    %rbx,0x50(%rsp)
mov    %rdx,0xe8(%rsp)
cmpl   $0x0,(%rsp)
jle    1e90 <sumGAMMA_FLEX+0xd60>
mov    0x18(%rsp),%rbx
imul   0xf0(%rsp),%rbx
cmpl   $0x4,(%rsp)
mov    %rdi,0x8(%rsp)
mov    0x10(%rsp),%rcx
mov    %rbx,0x38(%rsp)
jae    1f90 <sumGAMMA_FLEX+0xe60>
xor    %r15d,%r15d
jmp    2130 <sumGAMMA_FLEX+0x1000>
nopl   (%rax)
lea    (%rbx,%rax,1),%rcx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rbx,8),%r15
lea    (%rdx,%rcx,8),%rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbx,8),%r13
lea    (%rsi,%rcx,8),%rsi
mov    0x48(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbx
lea    (%rdi,%rcx,8),%rcx
cmp    %rsi,%r15
setb   %sil
cmp    %rdx,%r13
setb   %dil
cmp    %rcx,%r15
setb   %cl
cmp    %rdx,%rbx
setb   %dl
test   %dil,%sil
jne    20a1 <sumGAMMA_FLEX+0xf71>
mov    %rbx,0x100(%rsp)
mov    %r15,0xc8(%rsp)
mov    $0x0,%r15d
and    %dl,%cl
mov    0x40(%rsp),%r12
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rcx
jne    2130 <sumGAMMA_FLEX+0x1000>
cmpq   $0x0,0xd0(%rsp)
je     20b5 <sumGAMMA_FLEX+0xf85>
mov    0x90(%rsp),%rsi
mov    0x118(%rsp),%rbx
xor    %edx,%edx
mov    0x110(%rsp),%rcx
mov    0x108(%rsp),%rax
nopl   0x0(%rax)
movupd -0x30(%rdi,%rdx,8),%xmm0
movupd -0x20(%rdi,%rdx,8),%xmm1
movupd -0x30(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rax,%rdx,8)
movupd %xmm0,-0x20(%rax,%rdx,8)
movupd -0x10(%rdi,%rdx,8),%xmm0
movupd (%rdi,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdx,8)
movupd %xmm0,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    2040 <sumGAMMA_FLEX+0xf10>
jmp    20bf <sumGAMMA_FLEX+0xf8f>
xor    %r15d,%r15d
mov    0x40(%rsp),%r12
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rcx
jmp    2130 <sumGAMMA_FLEX+0x1000>
mov    0x90(%rsp),%rsi
xor    %edx,%edx
mov    %rsi,0x90(%rsp)
testb  $0x1,0xa8(%rsp)
01
je     210d <sumGAMMA_FLEX+0xfdd>
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
mov    0x100(%rsp),%rax
movupd (%rax,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xc8(%rsp),%rax
movupd %xmm2,(%rax,%rdx,8)
movupd %xmm0,0x10(%rax,%rdx,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%r15
mov    0x78(%rsp),%rax
cmp    %rax,%rcx
mov    0x10(%rsp),%rcx
je     21db <sumGAMMA_FLEX+0x10ab>
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdx
not    %rdx
add    %rax,%rdx
test   %r12,%r12
je     216d <sumGAMMA_FLEX+0x103d>
mov    %r12,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r11,%r15,8),%xmm0
mulsd  0x0(%rbp,%r15,8),%xmm0
movsd  %xmm0,(%r14,%r15,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rbx
jne    2150 <sumGAMMA_FLEX+0x1020>
cmp    $0x3,%rdx
jb     21db <sumGAMMA_FLEX+0x10ab>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r11,%r15,8),%xmm0
mulsd  0x0(%rbp,%r15,8),%xmm0
movsd  %xmm0,(%r14,%r15,8)
movsd  0x8(%r11,%r15,8),%xmm0
mulsd  0x8(%rbp,%r15,8),%xmm0
movsd  %xmm0,0x8(%r14,%r15,8)
movsd  0x10(%r11,%r15,8),%xmm0
mulsd  0x10(%rbp,%r15,8),%xmm0
movsd  %xmm0,0x10(%r14,%r15,8)
movsd  0x18(%r11,%r15,8),%xmm0
mulsd  0x18(%rbp,%r15,8),%xmm0
movsd  %xmm0,0x18(%r14,%r15,8)
add    $0x4,%r15
cmp    %r15,%rax
jne    2180 <sumGAMMA_FLEX+0x1050>
mov    %rcx,0x10(%rsp)
cmpl   $0x0,(%rsp)
jle    1e90 <sumGAMMA_FLEX+0xd60>
cmpl   $0x4,(%rsp)
jae    21fb <sumGAMMA_FLEX+0x10cb>
xor    %r15d,%r15d
mov    %r12,%r13
jmp    23c0 <sumGAMMA_FLEX+0x1290>
mov    0x128(%rsp),%rcx
mov    0x38(%rsp),%rsi
add    %rsi,%rcx
mov    0x120(%rsp),%rdx
lea    (%rdx,%rsi,1),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rcx,8),%r12
lea    (%rsi,%rdx,8),%rsi
mov    0x20(%rsp),%rdi
lea    (%rdi,%rcx,8),%r13
lea    (%rdi,%rdx,8),%r15
mov    0x48(%rsp),%rbx
lea    (%rbx,%rcx,8),%rdi
lea    (%rbx,%rdx,8),%rcx
cmp    %r15,%r12
setb   %bl
mov    %r13,0xc8(%rsp)
cmp    %rsi,%r13
setb   %dl
cmp    %rcx,%r12
setb   %cl
cmp    %rsi,%rdi
setb   %sil
test   %dl,%bl
jne    2331 <sumGAMMA_FLEX+0x1201>
mov    %rdi,0x100(%rsp)
mov    $0x0,%r15d
and    %sil,%cl
mov    0x40(%rsp),%r13
mov    0x8(%rsp),%rdi
jne    23c0 <sumGAMMA_FLEX+0x1290>
mov    %r12,0x140(%rsp)
cmpq   $0x0,0xd0(%rsp)
mov    0xb8(%rsp),%rcx
je     2343 <sumGAMMA_FLEX+0x1213>
mov    0x90(%rsp),%r15
mov    0x118(%rsp),%rbx
xor    %edx,%edx
mov    0xb0(%rsp),%rsi
mov    0xe0(%rsp),%rax
nopl   0x0(%rax)
movupd -0x30(%rcx,%rdx,8),%xmm0
movupd -0x20(%rcx,%rdx,8),%xmm1
movupd -0x30(%rsi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rax,%rdx,8)
movupd %xmm0,-0x20(%rax,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd -0x10(%rsi,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rax,%rdx,8)
movupd %xmm0,(%rax,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    22d0 <sumGAMMA_FLEX+0x11a0>
jmp    234d <sumGAMMA_FLEX+0x121d>
xor    %r15d,%r15d
mov    0x40(%rsp),%r13
mov    0x8(%rsp),%rdi
jmp    23c0 <sumGAMMA_FLEX+0x1290>
mov    0x90(%rsp),%r15
xor    %edx,%edx
mov    %r15,0x90(%rsp)
testb  $0x1,0xa8(%rsp)
01
je     23a0 <sumGAMMA_FLEX+0x1270>
mov    0xc8(%rsp),%rax
movupd (%rax,%rdx,8),%xmm0
movupd 0x10(%rax,%rdx,8),%xmm1
mov    0x100(%rsp),%rax
movupd (%rax,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x140(%rsp),%rax
movupd %xmm2,(%rax,%rdx,8)
movupd %xmm0,0x10(%rax,%rdx,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%r15
mov    0x78(%rsp),%rax
cmp    %rax,%rcx
je     246a <sumGAMMA_FLEX+0x133a>
nopl   0x0(%rax)
mov    %r15,%rdx
not    %rdx
add    %rax,%rdx
test   $0x3,%al
je     23fc <sumGAMMA_FLEX+0x12cc>
lea    (%r9,%r15,8),%rbx
lea    (%r10,%r15,8),%r12
lea    (%r8,%r15,8),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm0
mulsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    23e0 <sumGAMMA_FLEX+0x12b0>
add    %rcx,%r15
cmp    $0x3,%rdx
jb     246a <sumGAMMA_FLEX+0x133a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%r15,8),%xmm0
mulsd  (%r10,%r15,8),%xmm0
movsd  %xmm0,(%r9,%r15,8)
movsd  0x8(%r8,%r15,8),%xmm0
mulsd  0x8(%r10,%r15,8),%xmm0
movsd  %xmm0,0x8(%r9,%r15,8)
movsd  0x10(%r8,%r15,8),%xmm0
mulsd  0x10(%r10,%r15,8),%xmm0
movsd  %xmm0,0x10(%r9,%r15,8)
movsd  0x18(%r8,%r15,8),%xmm0
mulsd  0x18(%r10,%r15,8),%xmm0
movsd  %xmm0,0x18(%r9,%r15,8)
add    $0x4,%r15
cmp    %r15,%rax
jne    2410 <sumGAMMA_FLEX+0x12e0>
mov    %r13,%r12
cmpl   $0x0,(%rsp)
jle    1e90 <sumGAMMA_FLEX+0xd60>
cmpl   $0x4,(%rsp)
jae    2491 <sumGAMMA_FLEX+0x1361>
xor    %edx,%edx
mov    0x28(%rsp),%rbx
mov    0x98(%rsp),%rsi
jmp    2650 <sumGAMMA_FLEX+0x1520>
mov    0x150(%rsp),%rcx
mov    0x38(%rsp),%rsi
add    %rsi,%rcx
mov    0x148(%rsp),%rdx
lea    (%rdx,%rsi,1),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rcx,8),%r15
lea    (%rsi,%rdx,8),%rsi
mov    0x20(%rsp),%rdi
lea    (%rdi,%rcx,8),%r13
lea    (%rdi,%rdx,8),%r12
mov    0x48(%rsp),%rbx
lea    (%rbx,%rcx,8),%rdi
lea    (%rbx,%rdx,8),%rcx
cmp    %r12,%r15
setb   %dl
cmp    %rsi,%r13
setb   %bl
cmp    %rcx,%r15
setb   %cl
cmp    %rsi,%rdi
setb   %sil
test   %bl,%dl
jne    25c9 <sumGAMMA_FLEX+0x1499>
mov    %rdi,0xc8(%rsp)
mov    $0x0,%edx
and    %sil,%cl
mov    0x40(%rsp),%r12
mov    0x98(%rsp),%rsi
mov    0x28(%rsp),%rbx
jne    2650 <sumGAMMA_FLEX+0x1520>
cmpq   $0x0,0xd0(%rsp)
mov    %r15,0x100(%rsp)
mov    %r12,%rdi
je     25df <sumGAMMA_FLEX+0x14af>
mov    0x118(%rsp),%rbx
xor    %edx,%edx
mov    0xe8(%rsp),%r15
mov    0x50(%rsp),%r12
mov    0x68(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rcx,%rdx,8),%xmm0
movupd -0x20(%rcx,%rdx,8),%xmm1
movupd -0x30(%r15,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r15,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r12,%rdx,8)
movupd %xmm0,-0x20(%r12,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd -0x10(%r15,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r15,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r12,%rdx,8)
movupd %xmm0,(%r12,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    2560 <sumGAMMA_FLEX+0x1430>
jmp    25e1 <sumGAMMA_FLEX+0x14b1>
xor    %edx,%edx
mov    0x40(%rsp),%r12
mov    0x98(%rsp),%rsi
mov    0x28(%rsp),%rbx
jmp    2650 <sumGAMMA_FLEX+0x1520>
xor    %edx,%edx
testb  $0x1,0xa8(%rsp)
01
mov    0x28(%rsp),%rbx
mov    %rdi,%r12
je     262f <sumGAMMA_FLEX+0x14ff>
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
mov    0xc8(%rsp),%rcx
movupd (%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x100(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
je     270e <sumGAMMA_FLEX+0x15de>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%r15
not    %r15
add    %rax,%r15
test   $0x3,%al
je     26ad <sumGAMMA_FLEX+0x157d>
lea    (%rbx,%rdx,8),%rbx
mov    0x88(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
lea    (%rsi,%rdx,8),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rsi,8),%xmm0
mulsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    2680 <sumGAMMA_FLEX+0x1550>
add    %rsi,%rdx
mov    0x78(%rsp),%rax
mov    0x98(%rsp),%rsi
mov    0x28(%rsp),%rbx
cmp    $0x3,%r15
mov    0x88(%rsp),%rdi
jb     270e <sumGAMMA_FLEX+0x15de>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  0x8(%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  0x10(%rsi,%rdx,8),%xmm0
mulsd  0x10(%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rdx,8)
movsd  0x18(%rsi,%rdx,8),%xmm0
mulsd  0x18(%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    26c0 <sumGAMMA_FLEX+0x1590>
mov    %rsi,0x98(%rsp)
cmpl   $0x0,(%rsp)
mov    0x8(%rsp),%rdi
jle    1e90 <sumGAMMA_FLEX+0xd60>
cmpl   $0x4,(%rsp)
jae    27fb <sumGAMMA_FLEX+0x16cb>
xor    %edx,%edx
mov    %rdx,%r15
not    %r15
add    %rax,%r15
test   $0x3,%al
je     2785 <sumGAMMA_FLEX+0x1655>
mov    0xc0(%rsp),%rax
lea    (%rax,%rdx,8),%rbx
mov    0x58(%rsp),%rax
lea    (%rax,%rdx,8),%rcx
mov    0x30(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdi
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rdi,%rsi,8),%xmm0
mulsd  (%rcx,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    2760 <sumGAMMA_FLEX+0x1630>
add    %rsi,%rdx
mov    0x78(%rsp),%rax
mov    0x8(%rsp),%rdi
cmp    $0x3,%r15
jb     1e90 <sumGAMMA_FLEX+0xd60>
nop
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
mov    %rax,%rcx
mov    0x58(%rsp),%rax
mulsd  (%rax,%rdx,8),%xmm0
mov    0xc0(%rsp),%rbx
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  0x10(%rsi,%rdx,8),%xmm0
mulsd  0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rdx,8)
movsd  0x18(%rsi,%rdx,8),%xmm0
mulsd  0x18(%rax,%rdx,8),%xmm0
mov    %rcx,%rax
movsd  %xmm0,0x18(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    2790 <sumGAMMA_FLEX+0x1660>
jmp    1e90 <sumGAMMA_FLEX+0xd60>
mov    0x138(%rsp),%rcx
mov    0x38(%rsp),%rbx
add    %rbx,%rcx
add    0x130(%rsp),%rbx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rcx,8),%r15
lea    (%rdx,%rbx,8),%rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,8),%r13
lea    (%rsi,%rbx,8),%r12
mov    0x48(%rsp),%rdi
lea    (%rdi,%rcx,8),%rsi
lea    (%rdi,%rbx,8),%rcx
cmp    %r12,%r15
setb   %dil
cmp    %rdx,%r13
setb   %bl
cmp    %rcx,%r15
setb   %cl
cmp    %rdx,%rsi
setb   %r12b
test   %bl,%dil
jne    296f <sumGAMMA_FLEX+0x183f>
mov    %rsi,0x38(%rsp)
mov    $0x0,%edx
and    %r12b,%cl
mov    0x40(%rsp),%r12
mov    0x8(%rsp),%rdi
jne    2731 <sumGAMMA_FLEX+0x1601>
mov    %r15,0xc8(%rsp)
cmpq   $0x0,0xd0(%rsp)
je     2980 <sumGAMMA_FLEX+0x1850>
mov    0x118(%rsp),%rbx
xor    %edx,%edx
mov    0x70(%rsp),%rcx
mov    0x90(%rsp),%rsi
mov    0x10(%rsp),%r15
nopl   (%rax)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
movupd -0x30(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r15,%rdx,8)
movupd %xmm0,-0x20(%r15,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
movupd -0x10(%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r15,%rdx,8)
movupd %xmm0,(%r15,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    28b0 <sumGAMMA_FLEX+0x1780>
testb  $0x1,0xa8(%rsp)
01
je     2956 <sumGAMMA_FLEX+0x1826>
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
mov    0x38(%rsp),%rcx
movupd (%rcx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xc8(%rsp),%rcx
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm0,0x10(%rcx,%rdx,8)
mov    0xd8(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rax,%rcx
je     1e90 <sumGAMMA_FLEX+0xd60>
jmp    2731 <sumGAMMA_FLEX+0x1601>
xor    %edx,%edx
mov    0x40(%rsp),%r12
mov    0x8(%rsp),%rdi
jmp    2731 <sumGAMMA_FLEX+0x1601>
xor    %edx,%edx
testb  $0x1,0xa8(%rsp)
01
jne    291d <sumGAMMA_FLEX+0x17ed>
jmp    2956 <sumGAMMA_FLEX+0x1826>
mov    0x48(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,0xa0(%rsp)
mov    %ebp,%edx
call   1050 <reorder_back@plt>
mov    %ebx,0xa4(%rsp)
test   %ebx,%ebx
jle    364b <sumGAMMA_FLEX+0x251b>
movslq 0xa0(%rsp),%r11
mov    0xa4(%rsp),%eax
mov    %rax,0xb0(%rsp)
mov    %r12d,%r14d
mov    0xe8(%rsp),%rcx
lea    (%rcx,%rcx,1),%rax
mov    %rax,0x100(%rsp)
lea    (%rcx,%rcx,2),%rbx
lea    (%rbx,%r14,1),%rax
mov    %rax,0x120(%rsp)
mov    %r14d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x40(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xf0(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rax
mov    %rsi,0x78(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xd8(%rsp)
mov    %r14d,%eax
and    $0x3,%eax
mov    %rax,0x28(%rsp)
mov    %rcx,%r15
shl    $0x4,%r15
mov    0x48(%rsp),%rdi
lea    (%rdi,%r15,1),%rbp
add    $0x30,%rbp
mov    0x60(%rsp),%r8
lea    (%r8,%r15,1),%rax
add    $0x30,%rax
mov    %rax,0x108(%rsp)
lea    (%r8,%r15,1),%r10
add    %rdi,%r15
mov    0x98(%rsp),%rax
lea    (%rax,%r14,8),%rdx
mov    %rdx,0x70(%rsp)
lea    (%r14,%rcx,2),%rdx
mov    %rdx,0x118(%rsp)
lea    (%rcx,%r14,1),%rdx
mov    %rdx,0xc8(%rsp)
lea    0x30(%rax),%rdx
mov    %rdx,0xd0(%rsp)
lea    0x30(%rdi),%r9
mov    %r11,0xf8(%rsp)
lea    0x0(,%r11,8),%rdx
mov    %rdx,0xe0(%rsp)
lea    0x30(%r8),%rdx
mov    %rdx,0x18(%rsp)
lea    0x18(%rax),%rax
mov    %rax,0x80(%rsp)
lea    0x30(%rdi,%rcx,8),%rax
mov    %rax,0x88(%rsp)
lea    0x30(%r8,%rcx,8),%rax
mov    %rax,0x110(%rsp)
lea    (%r8,%rcx,8),%r11
lea    (%rdi,%rcx,8),%rcx
lea    0x30(%rdi,%rbx,8),%rax
lea    0x30(%r8,%rbx,8),%rdx
mov    %rdx,0xb8(%rsp)
lea    (%r8,%rbx,8),%r13
mov    %rbx,0x128(%rsp)
lea    (%rdi,%rbx,8),%rsi
xor    %edx,%edx
mov    %rdx,0xc0(%rsp)
jmp    2ba9 <sumGAMMA_FLEX+0x1a79>
nopw   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rdx
mov    %rbx,%r9
mov    %rsi,%rbx
mov    %rdx,%rsi
add    $0x1,%rsi
mov    0xe0(%rsp),%rdx
add    %rdx,%r9
add    %rdx,0x18(%rsp)
add    %rdx,%r8
add    %rdx,%rdi
add    %rdx,0x88(%rsp)
add    %rdx,0x110(%rsp)
add    %rdx,%r11
add    %rdx,%rcx
mov    0x30(%rsp),%rbp
add    %rdx,%rbp
add    %rdx,0x108(%rsp)
add    %rdx,%r10
add    %rdx,%r15
mov    0x10(%rsp),%rax
add    %rdx,%rax
add    %rdx,0xb8(%rsp)
add    %rdx,%r13
add    %rdx,%rbx
mov    %rsi,%rdx
mov    %rsi,0xc0(%rsp)
cmp    0xb0(%rsp),%rsi
mov    %rbx,%rsi
je     364b <sumGAMMA_FLEX+0x251b>
mov    %rax,0x10(%rsp)
mov    %rbp,0x30(%rsp)
test   %r12d,%r12d
mov    %r9,%rbx
jle    2b20 <sumGAMMA_FLEX+0x19f0>
mov    0xc0(%rsp),%rbp
mov    %rbp,%rdx
imul   0xf8(%rsp),%rdx
mov    0x90(%rsp),%rax
movzbl (%rax,%rbp,1),%ebp
imul   0xe8(%rsp),%rbp
mov    0x98(%rsp),%rax
lea    (%rax,%rbp,8),%r9
cmp    $0x4,%r12d
mov    %rdx,0x58(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rbp,0x50(%rsp)
jae    2c20 <sumGAMMA_FLEX+0x1af0>
xor    %ebp,%ebp
mov    0x28(%rsp),%rdx
jmp    2dc0 <sumGAMMA_FLEX+0x1c90>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,0x68(%rsp)
lea    (%rdx,%r14,1),%rax
mov    0x60(%rsp),%rsi
lea    (%rsi,%rdx,8),%r12
lea    (%rsi,%rax,8),%r13
mov    %rbp,%rsi
mov    0x48(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rdx
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x70(%rsp),%rbp
lea    0x0(%rbp,%rsi,8),%rbp
cmp    %rbp,%r12
setb   %bpl
cmp    %r13,%r9
setb   %sil
mov    %r12,0x38(%rsp)
cmp    %rax,%r12
setb   %al
mov    %rdx,0x20(%rsp)
cmp    %r13,%rdx
setb   %dl
test   %sil,%bpl
jne    2d45 <sumGAMMA_FLEX+0x1c15>
mov    $0x0,%ebp
and    %dl,%al
mov    (%rsp),%r12
mov    0x28(%rsp),%rdx
mov    0x68(%rsp),%r13
mov    0x8(%rsp),%rsi
jne    2dc0 <sumGAMMA_FLEX+0x1c90>
cmpq   $0x0,0xf0(%rsp)
je     2d5c <sumGAMMA_FLEX+0x1c2c>
mov    0xd0(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0xd8(%rsp),%rdx
xor    %ebp,%ebp
mov    0x18(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%rax,%rbp,8),%xmm0
movupd -0x20(%rax,%rbp,8),%xmm1
movupd -0x30(%rbx,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r12,%rbp,8)
movupd %xmm0,-0x20(%r12,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm0
movupd (%rax,%rbp,8),%xmm1
movupd -0x10(%rbx,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rbx,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r12,%rbp,8)
movupd %xmm0,(%r12,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    2ce0 <sumGAMMA_FLEX+0x1bb0>
jmp    2d5e <sumGAMMA_FLEX+0x1c2e>
xor    %ebp,%ebp
mov    (%rsp),%r12
mov    0x28(%rsp),%rdx
mov    0x68(%rsp),%r13
mov    0x8(%rsp),%rsi
jmp    2dc0 <sumGAMMA_FLEX+0x1c90>
xor    %ebp,%ebp
testb  $0x1,0x78(%rsp)
mov    0x28(%rsp),%rdx
mov    (%rsp),%r12
je     2da3 <sumGAMMA_FLEX+0x1c73>
movupd (%r9,%rbp,8),%xmm0
movupd 0x10(%r9,%rbp,8),%xmm1
mov    0x20(%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x38(%rsp),%rax
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    0x40(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
je     2e62 <sumGAMMA_FLEX+0x1d32>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rax
not    %rax
add    %r14,%rax
test   %rdx,%rdx
je     2deb <sumGAMMA_FLEX+0x1cbb>
xchg   %ax,%ax
movsd  (%r9,%rbp,8),%xmm0
mulsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    2dd0 <sumGAMMA_FLEX+0x1ca0>
cmp    $0x3,%rax
jb     2e62 <sumGAMMA_FLEX+0x1d32>
mov    0x80(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    (%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rbp,8),%xmm0
mulsd  (%rdi,%rbp,8),%xmm0
movsd  %xmm0,(%r8,%rbp,8)
movsd  -0x10(%rax,%rbp,8),%xmm0
mulsd  0x8(%rdi,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r8,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm0
mulsd  0x10(%rdi,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r8,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%rdi,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r8,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r14
jne    2e10 <sumGAMMA_FLEX+0x1ce0>
test   %r12d,%r12d
mov    0x58(%rsp),%rdx
jle    2b20 <sumGAMMA_FLEX+0x19f0>
cmp    $0x4,%r12d
jae    2e83 <sumGAMMA_FLEX+0x1d53>
xor    %r12d,%r12d
mov    0x18(%rsp),%rbp
jmp    3040 <sumGAMMA_FLEX+0x1f10>
mov    0xe8(%rsp),%rax
lea    (%rdx,%rax,1),%r12
mov    0xc8(%rsp),%rax
add    %rax,%rdx
mov    0x60(%rsp),%rbp
lea    0x0(%rbp,%r12,8),%rsi
lea    0x0(%rbp,%rdx,8),%rbp
mov    0x48(%rsp),%rax
lea    (%rax,%r12,8),%r12
lea    (%rax,%rdx,8),%rax
mov    %rax,0x20(%rsp)
mov    0x70(%rsp),%rdx
mov    0x50(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
cmp    %rdx,%rsi
setb   0x38(%rsp)
cmp    %rbp,%r9
setb   %dl
mov    %rsi,0xa8(%rsp)
cmp    0x20(%rsp),%rsi
setb   %al
mov    %r12,0x20(%rsp)
cmp    %rbp,%r12
setb   %bpl
test   %dl,0x38(%rsp)
jne    2fc1 <sumGAMMA_FLEX+0x1e91>
mov    $0x0,%r12d
and    %bpl,%al
mov    0x18(%rsp),%rbp
mov    0x8(%rsp),%rsi
jne    3040 <sumGAMMA_FLEX+0x1f10>
mov    %rbx,0x38(%rsp)
cmpq   $0x0,0xf0(%rsp)
mov    0x88(%rsp),%rsi
mov    0x110(%rsp),%rbx
je     2fd0 <sumGAMMA_FLEX+0x1ea0>
mov    0xd0(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0xd8(%rsp),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rax,%rbp,8),%xmm0
movupd -0x20(%rax,%rbp,8),%xmm1
movupd -0x30(%rsi,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rbx,%rbp,8)
movupd %xmm0,-0x20(%rbx,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm0
movupd (%rax,%rbp,8),%xmm1
movupd -0x10(%rsi,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rbx,%rbp,8)
movupd %xmm0,(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    2f60 <sumGAMMA_FLEX+0x1e30>
jmp    2fd2 <sumGAMMA_FLEX+0x1ea2>
xor    %r12d,%r12d
mov    0x18(%rsp),%rbp
mov    0x8(%rsp),%rsi
jmp    3040 <sumGAMMA_FLEX+0x1f10>
xor    %ebp,%ebp
testb  $0x1,0x78(%rsp)
mov    0x58(%rsp),%rdx
je     3016 <sumGAMMA_FLEX+0x1ee6>
movupd (%r9,%rbp,8),%xmm0
movupd 0x10(%r9,%rbp,8),%xmm1
mov    0x20(%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xa8(%rsp),%rax
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    0x40(%rsp),%rax
mov    %rax,%r12
cmp    %r14,%rax
mov    0x38(%rsp),%rbx
mov    0x18(%rsp),%rbp
mov    0x8(%rsp),%rsi
je     30fa <sumGAMMA_FLEX+0x1fca>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rax
not    %rax
add    %r14,%rax
test   $0x3,%r14b
je     307c <sumGAMMA_FLEX+0x1f4c>
mov    0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%r12,8),%xmm0
mulsd  (%rcx,%r12,8),%xmm0
movsd  %xmm0,(%r11,%r12,8)
add    $0x1,%r12
add    $0xffffffffffffffff,%rdx
jne    3060 <sumGAMMA_FLEX+0x1f30>
cmp    $0x3,%rax
mov    0x58(%rsp),%rdx
jb     30fa <sumGAMMA_FLEX+0x1fca>
mov    0x80(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0x58(%rsp),%rdx
nopl   (%rax)
movsd  -0x18(%rax,%r12,8),%xmm0
mulsd  (%rcx,%r12,8),%xmm0
movsd  %xmm0,(%r11,%r12,8)
movsd  -0x10(%rax,%r12,8),%xmm0
mulsd  0x8(%rcx,%r12,8),%xmm0
movsd  %xmm0,0x8(%r11,%r12,8)
movsd  -0x8(%rax,%r12,8),%xmm0
mulsd  0x10(%rcx,%r12,8),%xmm0
movsd  %xmm0,0x10(%r11,%r12,8)
movsd  (%rax,%r12,8),%xmm0
mulsd  0x18(%rcx,%r12,8),%xmm0
movsd  %xmm0,0x18(%r11,%r12,8)
add    $0x4,%r12
cmp    %r12,%r14
jne    30a0 <sumGAMMA_FLEX+0x1f70>
mov    %rbp,0x18(%rsp)
mov    (%rsp),%r12
test   %r12d,%r12d
jle    2b20 <sumGAMMA_FLEX+0x19f0>
cmp    $0x4,%r12d
jae    3119 <sumGAMMA_FLEX+0x1fe9>
xor    %ebp,%ebp
jmp    32d0 <sumGAMMA_FLEX+0x21a0>
mov    0x100(%rsp),%rax
lea    (%rax,%rdx,1),%r12
mov    0x118(%rsp),%rax
add    %rax,%rdx
mov    0x60(%rsp),%rbp
lea    0x0(%rbp,%r12,8),%rsi
lea    0x0(%rbp,%rdx,8),%rbp
mov    0x48(%rsp),%rax
lea    (%rax,%r12,8),%r12
lea    (%rax,%rdx,8),%rax
mov    %rax,0x20(%rsp)
mov    0x70(%rsp),%rdx
mov    0x50(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
cmp    %rdx,%rsi
setb   0x38(%rsp)
cmp    %rbp,%r9
setb   %dl
mov    %rsi,0xa8(%rsp)
cmp    0x20(%rsp),%rsi
setb   %al
mov    %r12,0x20(%rsp)
cmp    %rbp,%r12
setb   %sil
test   %dl,0x38(%rsp)
jne    325a <sumGAMMA_FLEX+0x212a>
mov    $0x0,%ebp
and    %sil,%al
mov    (%rsp),%r12
mov    0x8(%rsp),%rsi
jne    32d0 <sumGAMMA_FLEX+0x21a0>
cmpq   $0x0,0xf0(%rsp)
mov    %r13,0x68(%rsp)
je     3267 <sumGAMMA_FLEX+0x2137>
mov    0xd0(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0xd8(%rsp),%rdx
xor    %ebp,%ebp
mov    0x108(%rsp),%r13
mov    0x30(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%rax,%rbp,8),%xmm0
movupd -0x20(%rax,%rbp,8),%xmm1
movupd -0x30(%r12,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r12,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r13,%rbp,8)
movupd %xmm0,-0x20(%r13,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm0
movupd (%rax,%rbp,8),%xmm1
movupd -0x10(%r12,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r12,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r13,%rbp,8)
movupd %xmm0,0x0(%r13,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    31f0 <sumGAMMA_FLEX+0x20c0>
jmp    3269 <sumGAMMA_FLEX+0x2139>
xor    %ebp,%ebp
mov    (%rsp),%r12
mov    0x8(%rsp),%rsi
jmp    32d0 <sumGAMMA_FLEX+0x21a0>
xor    %ebp,%ebp
testb  $0x1,0x78(%rsp)
mov    0x68(%rsp),%r13
mov    (%rsp),%r12
mov    0x58(%rsp),%rdx
je     32b6 <sumGAMMA_FLEX+0x2186>
movupd (%r9,%rbp,8),%xmm0
movupd 0x10(%r9,%rbp,8),%xmm1
mov    0x20(%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0xa8(%rsp),%rax
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    0x40(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
je     3386 <sumGAMMA_FLEX+0x2256>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
not    %rax
add    %r14,%rax
test   $0x3,%r14b
je     330c <sumGAMMA_FLEX+0x21dc>
mov    0x28(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rbp,8),%xmm0
mulsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r10,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    32f0 <sumGAMMA_FLEX+0x21c0>
cmp    $0x3,%rax
mov    0x58(%rsp),%rdx
jb     3386 <sumGAMMA_FLEX+0x2256>
mov    0x80(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0x58(%rsp),%rdx
nopl   (%rax)
movsd  -0x18(%rax,%rbp,8),%xmm0
mulsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r10,%rbp,8)
movsd  -0x10(%rax,%rbp,8),%xmm0
mulsd  0x8(%r15,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r10,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm0
mulsd  0x10(%r15,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r10,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%r15,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r10,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r14
jne    3330 <sumGAMMA_FLEX+0x2200>
test   %r12d,%r12d
jle    2b20 <sumGAMMA_FLEX+0x19f0>
cmp    $0x4,%r12d
jae    3448 <sumGAMMA_FLEX+0x2318>
xor    %ebp,%ebp
mov    %rbp,%rax
not    %rax
add    %r14,%rax
test   $0x3,%r14b
je     33cc <sumGAMMA_FLEX+0x229c>
mov    0x28(%rsp),%rdx
nop
movsd  (%r9,%rbp,8),%xmm0
mulsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    33b0 <sumGAMMA_FLEX+0x2280>
cmp    $0x3,%rax
jb     2b20 <sumGAMMA_FLEX+0x19f0>
mov    0x80(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rbp,8),%xmm0
mulsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
movsd  -0x10(%rax,%rbp,8),%xmm0
mulsd  0x8(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r13,%rbp,8)
movsd  -0x8(%rax,%rbp,8),%xmm0
mulsd  0x10(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x10(%r13,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
mulsd  0x18(%rsi,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r13,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r14
jne    33f0 <sumGAMMA_FLEX+0x22c0>
jmp    2b20 <sumGAMMA_FLEX+0x19f0>
mov    0x128(%rsp),%rax
add    %rdx,%rax
add    0x120(%rsp),%rdx
mov    %rdx,%rsi
mov    0x60(%rsp),%rbp
lea    0x0(,%rax,8),%rdx
add    %rbp,%rdx
lea    0x0(%rbp,%rsi,8),%rbp
mov    %rbp,0x38(%rsp)
mov    0x48(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%r12
lea    0x0(%rbp,%rsi,8),%rsi
mov    0x70(%rsp),%rbp
mov    0x50(%rsp),%rax
lea    0x0(%rbp,%rax,8),%rbp
cmp    %rbp,%rdx
setb   0x58(%rsp)
mov    0x38(%rsp),%rax
cmp    %rax,%r9
setb   %bpl
mov    %rdx,0x20(%rsp)
cmp    %rsi,%rdx
setb   %dl
mov    %r12,0xa8(%rsp)
cmp    %rax,%r12
setb   %al
test   %bpl,0x58(%rsp)
jne    358a <sumGAMMA_FLEX+0x245a>
mov    $0x0,%ebp
and    %al,%dl
mov    (%rsp),%r12
mov    0x8(%rsp),%rsi
jne    339b <sumGAMMA_FLEX+0x226b>
cmpq   $0x0,0xf0(%rsp)
mov    %r13,0x68(%rsp)
je     359a <sumGAMMA_FLEX+0x246a>
mov    0xd0(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    0xd8(%rsp),%rdx
xor    %ebp,%ebp
mov    0x10(%rsp),%r12
mov    0xb8(%rsp),%r13
movupd -0x30(%rax,%rbp,8),%xmm0
movupd -0x20(%rax,%rbp,8),%xmm1
movupd -0x30(%r12,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%r12,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r13,%rbp,8)
movupd %xmm0,-0x20(%r13,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm0
movupd (%rax,%rbp,8),%xmm1
movupd -0x10(%r12,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r12,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r13,%rbp,8)
movupd %xmm0,0x0(%r13,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    3520 <sumGAMMA_FLEX+0x23f0>
jmp    359c <sumGAMMA_FLEX+0x246c>
xor    %ebp,%ebp
mov    (%rsp),%r12
mov    0x8(%rsp),%rsi
jmp    339b <sumGAMMA_FLEX+0x226b>
xor    %ebp,%ebp
testb  $0x1,0x78(%rsp)
mov    0x68(%rsp),%r13
mov    (%rsp),%r12
je     35e4 <sumGAMMA_FLEX+0x24b4>
movupd (%r9,%rbp,8),%xmm0
movupd 0x10(%r9,%rbp,8),%xmm1
mov    0xa8(%rsp),%rax
movupd (%rax,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x20(%rsp),%rax
movupd %xmm2,(%rax,%rbp,8)
movupd %xmm0,0x10(%rax,%rbp,8)
mov    0x40(%rsp),%rax
mov    %rax,%rbp
cmp    %r14,%rax
je     2b20 <sumGAMMA_FLEX+0x19f0>
jmp    339b <sumGAMMA_FLEX+0x226b>
xor    %edi,%edi
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <assert@plt>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rdi
mov    0xa4(%rsp),%ebx
mov    %ebx,%esi
mov    0xa0(%rsp),%ebp
mov    %ebp,%edx
call   1040 <reorder@plt>
mov    0x48(%rsp),%rdi
mov    %ebx,%esi
mov    %ebp,%edx
jmp    365e <sumGAMMA_FLEX+0x252e>
mov    0x48(%rsp),%rdi
mov    0xa4(%rsp),%esi
mov    0xa0(%rsp),%edx
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <reorder@plt>

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

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