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

/* Forward declarations */

/* Type definitions */

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


x86 assembly (clang, -O0):
<sumCatAsc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    0x10(%rbp),%esi
lea    -0x70(%rbp),%rdi
call   1040 <ascertainmentBiasSequence@plt>
mov    -0x4(%rbp),%eax
mov    %eax,-0x74(%rbp)
test   %eax,%eax
je     1186 <sumCatAsc+0x66>
jmp    1164 <sumCatAsc+0x44>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
je     1254 <sumCatAsc+0x134>
jmp    1175 <sumCatAsc+0x55>
mov    -0x74(%rbp),%eax
sub    $0x2,%eax
je     131a <sumCatAsc+0x1fa>
jmp    13d8 <sumCatAsc+0x2b8>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    124f <sumCatAsc+0x12f>
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    123c <sumCatAsc+0x11c>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11fb <sumCatAsc+0xdb>
jmp    1241 <sumCatAsc+0x121>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118d <sumCatAsc+0x6d>
jmp    13df <sumCatAsc+0x2bf>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1315 <sumCatAsc+0x1f5>
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
movslq -0x30(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1302 <sumCatAsc+0x1e2>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c1 <sumCatAsc+0x1a1>
jmp    1307 <sumCatAsc+0x1e7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    125b <sumCatAsc+0x13b>
jmp    13df <sumCatAsc+0x2bf>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13d3 <sumCatAsc+0x2b3>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   0x10(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13c0 <sumCatAsc+0x2a0>
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    137f <sumCatAsc+0x25f>
jmp    13c5 <sumCatAsc+0x2a5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1321 <sumCatAsc+0x201>
jmp    13df <sumCatAsc+0x2bf>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumCatAsc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9d,%ebx
mov    %r8,0x38(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,0x30(%rsp)
mov    %edi,%r14d
mov    0xe0(%rsp),%esi
lea    0x80(%rsp),%rdi
call   1040 <ascertainmentBiasSequence@plt>
test   %r14d,%r14d
je     146f <sumCatAsc+0x34f>
cmp    $0x1,%r14d
je     16ba <sumCatAsc+0x59a>
cmp    $0x2,%r14d
jne    19c2 <sumCatAsc+0x8a2>
test   %ebx,%ebx
mov    0xe0(%rsp),%r14d
jle    19c9 <sumCatAsc+0x8a9>
movslq %r14d,%rax
mov    %ebx,%r13d
mov    %r14d,%edx
mov    %edx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x70(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x68(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rcx
mov    %rsi,0x60(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x58(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rcx,0x38(%rsp)
mov    0x8(%rsp),%r12
lea    0x30(%r12),%rdi
mov    %rax,0x40(%rsp)
lea    0x0(,%rax,8),%r10
mov    0x28(%rsp),%r8
lea    0x30(%r8),%rsi
mov    0x30(%rsp),%r9
lea    0x30(%r9),%rbp
xor    %r11d,%r11d
mov    %r13,0x10(%rsp)
mov    %r10,0x50(%rsp)
jmp    122f <sumCatAsc+0x10f>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r11
add    %r10,%rdi
add    %r10,%rsi
add    %r10,%rbp
add    %r10,%r9
add    %r10,%r8
add    %r10,%r12
cmp    %r13,%r11
je     19c9 <sumCatAsc+0x8a9>
test   %r14d,%r14d
jle    1210 <sumCatAsc+0xf0>
cmp    $0x4,%r14d
jae    1250 <sumCatAsc+0x130>
xor    %ebx,%ebx
jmp    13c0 <sumCatAsc+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11,%rax
imul   0x40(%rsp),%rax
lea    (%rax,%rdx,1),%rcx
mov    0x30(%rsp),%rbx
lea    (%rbx,%rax,8),%r15
lea    (%rbx,%rcx,8),%rbx
mov    0x8(%rsp),%r14
lea    (%r14,%rax,8),%r10
lea    (%r14,%rcx,8),%r13
mov    0x28(%rsp),%r14
lea    (%r14,%rax,8),%rax
lea    (%r14,%rcx,8),%rcx
cmp    %r13,%r15
setb   %r13b
mov    %r10,0x18(%rsp)
cmp    %rbx,%r10
setb   %r14b
mov    %r15,0x20(%rsp)
cmp    %rcx,%r15
setb   %cl
mov    %rax,0x48(%rsp)
cmp    %rbx,%rax
setb   %al
test   %r14b,%r13b
jne    1352 <sumCatAsc+0x232>
mov    $0x0,%ebx
and    %al,%cl
mov    0xe0(%rsp),%r14d
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%r10
jne    13c0 <sumCatAsc+0x2a0>
cmpq   $0x0,0x68(%rsp)
je     1368 <sumCatAsc+0x248>
mov    0x58(%rsp),%r13
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdi,%rbx,8),%xmm0
movupd -0x20(%rdi,%rbx,8),%xmm1
movupd -0x30(%rsi,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rbp,%rbx,8)
movupd %xmm0,-0x20(%rbp,%rbx,8)
movupd -0x10(%rdi,%rbx,8),%xmm0
movupd (%rdi,%rbx,8),%xmm1
movupd -0x10(%rsi,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rbp,%rbx,8)
movupd %xmm0,0x0(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r13
jne    12f0 <sumCatAsc+0x1d0>
jmp    136a <sumCatAsc+0x24a>
xor    %ebx,%ebx
mov    0xe0(%rsp),%r14d
mov    0x10(%rsp),%r13
mov    0x50(%rsp),%r10
jmp    13c0 <sumCatAsc+0x2a0>
xor    %ebx,%ebx
testb  $0x1,0x60(%rsp)
mov    0x10(%rsp),%r13
je     13ae <sumCatAsc+0x28e>
mov    0x18(%rsp),%rax
movupd (%rax,%rbx,8),%xmm0
movupd 0x10(%rax,%rbx,8),%xmm1
mov    0x48(%rsp),%rax
movupd (%rax,%rbx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rax,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x20(%rsp),%rax
movupd %xmm2,(%rax,%rbx,8)
movupd %xmm0,0x10(%rax,%rbx,8)
mov    0x70(%rsp),%rax
mov    %rax,%rbx
cmp    %rdx,%rax
je     1210 <sumCatAsc+0xf0>
nop
mov    %rbx,%rax
not    %rax
add    %rdx,%rax
mov    0x38(%rsp),%rcx
test   %rcx,%rcx
je     13fc <sumCatAsc+0x2dc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rbx,8),%xmm0
mulsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,(%r9,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    13e0 <sumCatAsc+0x2c0>
cmp    $0x3,%rax
jb     1210 <sumCatAsc+0xf0>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%rbx,8),%xmm0
mulsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,(%r9,%rbx,8)
movsd  0x8(%r12,%rbx,8),%xmm0
mulsd  0x8(%r8,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r9,%rbx,8)
movsd  0x10(%r12,%rbx,8),%xmm0
mulsd  0x10(%r8,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r9,%rbx,8)
movsd  0x18(%r12,%rbx,8),%xmm0
mulsd  0x18(%r8,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r9,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rdx
jne    1410 <sumCatAsc+0x2f0>
jmp    1210 <sumCatAsc+0xf0>
test   %ebx,%ebx
mov    0xe0(%rsp),%ebp
jle    19c9 <sumCatAsc+0x8a9>
movslq %ebp,%r11
mov    %ebx,%r14d
mov    %ebp,%edx
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%rcx
mov    %rcx,0x28(%rsp)
mov    %edx,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x10(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x48(%rsp)
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%rcx
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x18(%rsp)
mov    %edx,%r15d
and    $0x3,%r15d
lea    0x30(%rax),%rcx
mov    %rcx,0x40(%rsp)
mov    0x30(%rsp),%r8
lea    0x30(%r8),%rsi
lea    0x0(,%r11,8),%r13
add    $0x18,%rax
mov    %rax,0x8(%rsp)
xor    %r10d,%r10d
jmp    1513 <sumCatAsc+0x3f3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r10
add    %r13,%rsi
add    %r13,%r8
cmp    %r14,%r10
je     19c9 <sumCatAsc+0x8a9>
test   %ebp,%ebp
jle    1500 <sumCatAsc+0x3e0>
movzbl 0x80(%rsp,%r10,1),%r9d
imul   %r11,%r9
mov    0x38(%rsp),%rax
lea    (%rax,%r9,8),%r12
cmp    $0x4,%ebp
jb     1564 <sumCatAsc+0x444>
mov    %r10,%rax
imul   %r11,%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    0x28(%rsp),%rbx
lea    (%rbx,%r9,8),%rbx
cmp    %rbx,%rdi
jae    1600 <sumCatAsc+0x4e0>
add    %rdx,%rax
lea    (%rcx,%rax,8),%rax
cmp    %rax,%r12
jae    1600 <sumCatAsc+0x4e0>
xor    %edi,%edi
mov    %rdi,%rax
not    %rax
add    %rdx,%rax
test   %r15,%r15
je     159a <sumCatAsc+0x47a>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r8,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    1580 <sumCatAsc+0x460>
cmp    $0x3,%rax
jb     1500 <sumCatAsc+0x3e0>
mov    0x8(%rsp),%rax
lea    (%rax,%r9,8),%rax
nopl   (%rax)
movsd  -0x18(%rax,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r8,%rdi,8)
movsd  -0x10(%rax,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%r8,%rdi,8)
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%r8,%rdi,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%r8,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    15b0 <sumCatAsc+0x490>
jmp    1500 <sumCatAsc+0x3e0>
mov    %r14,%rbx
mov    %r11,%rcx
cmpq   $0x0,0x48(%rsp)
je     166e <sumCatAsc+0x54e>
mov    0x40(%rsp),%rax
lea    (%rax,%r9,8),%r11
mov    0x18(%rsp),%r14
xor    %eax,%eax
xchg   %ax,%ax
movupd -0x30(%r11,%rax,8),%xmm0
movupd -0x20(%r11,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x30(%rsi,%rax,8)
movupd %xmm1,-0x20(%rsi,%rax,8)
movupd -0x10(%r11,%rax,8),%xmm0
movupd (%r11,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,-0x10(%rsi,%rax,8)
movupd %xmm1,(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r14
jne    1620 <sumCatAsc+0x500>
jmp    1670 <sumCatAsc+0x550>
xor    %eax,%eax
testb  $0x1,0x20(%rsp)
mov    %rcx,%r11
je     169a <sumCatAsc+0x57a>
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%r12,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,(%rdi,%rax,8)
movupd %xmm1,0x10(%rdi,%rax,8)
mov    0x10(%rsp),%rax
mov    %rax,%rdi
cmp    %rdx,%rax
mov    0xe0(%rsp),%ebp
mov    %rbx,%r14
je     1500 <sumCatAsc+0x3e0>
jmp    1566 <sumCatAsc+0x446>
test   %ebx,%ebx
mov    0xe0(%rsp),%eax
jle    19c9 <sumCatAsc+0x8a9>
movslq %eax,%rsi
mov    %ebx,%ebx
mov    %eax,%edx
mov    0x38(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdi
mov    %rdi,0x40(%rsp)
mov    %edx,%edi
and    $0xfffffffc,%edi
mov    %rdi,0x70(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x68(%rsp)
mov    %rdi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rbp,%rdi
mov    %rbp,0x60(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x58(%rsp)
mov    %edx,%edi
and    $0x3,%edi
lea    0x30(%rcx),%rbp
mov    %rbp,0x78(%rsp)
mov    0x28(%rsp),%r8
lea    0x30(%r8),%rbp
mov    %rsi,%r12
lea    0x0(,%rsi,8),%r13
mov    %rdi,%rsi
mov    0x30(%rsp),%r11
lea    0x30(%r11),%rdi
add    $0x18,%rcx
mov    %rcx,0x50(%rsp)
xor    %r9d,%r9d
mov    %rbx,0x20(%rsp)
mov    %rsi,0x8(%rsp)
mov    %r12,0x18(%rsp)
jmp    1780 <sumCatAsc+0x660>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r13,%rbp
add    %r13,%rdi
add    %r13,%r11
add    %r13,%r8
cmp    %rbx,%r9
mov    0xe0(%rsp),%eax
je     19c9 <sumCatAsc+0x8a9>
test   %eax,%eax
jle    1760 <sumCatAsc+0x640>
movzbl 0x80(%rsp,%r9,1),%r10d
imul   %r12,%r10
mov    0x38(%rsp),%rax
lea    (%rax,%r10,8),%r14
cmpl   $0x4,0xe0(%rsp)
04
jae    1850 <sumCatAsc+0x730>
xor    %r15d,%r15d
mov    %r15,%rax
not    %rax
add    %rdx,%rax
test   %rsi,%rsi
je     17dc <sumCatAsc+0x6bc>
mov    %rsi,%rcx
nopl   0x0(%rax)
movsd  (%r14,%r15,8),%xmm0
mulsd  (%r8,%r15,8),%xmm0
movsd  %xmm0,(%r11,%r15,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rcx
jne    17c0 <sumCatAsc+0x6a0>
cmp    $0x3,%rax
jb     1760 <sumCatAsc+0x640>
mov    0x50(%rsp),%rax
lea    (%rax,%r10,8),%rax
nop
movsd  -0x18(%rax,%r15,8),%xmm0
mulsd  (%r8,%r15,8),%xmm0
movsd  %xmm0,(%r11,%r15,8)
movsd  -0x10(%rax,%r15,8),%xmm0
mulsd  0x8(%r8,%r15,8),%xmm0
movsd  %xmm0,0x8(%r11,%r15,8)
movsd  -0x8(%rax,%r15,8),%xmm0
mulsd  0x10(%r8,%r15,8),%xmm0
movsd  %xmm0,0x10(%r11,%r15,8)
movsd  (%rax,%r15,8),%xmm0
mulsd  0x18(%r8,%r15,8),%xmm0
movsd  %xmm0,0x18(%r11,%r15,8)
add    $0x4,%r15
cmp    %r15,%rdx
jne    17f0 <sumCatAsc+0x6d0>
jmp    1760 <sumCatAsc+0x640>
nop
mov    %r9,%rax
mov    %r12,%rcx
imul   %r12,%rax
lea    (%rax,%rdx,1),%rcx
mov    0x30(%rsp),%rbx
lea    (%rbx,%rax,8),%rsi
lea    (%rbx,%rcx,8),%r15
mov    0x28(%rsp),%rbx
lea    (%rbx,%rax,8),%r12
lea    (%rbx,%rcx,8),%rax
mov    0x40(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%rsi
setb   %cl
cmp    %r15,%r14
setb   %bl
mov    %rsi,0x10(%rsp)
cmp    %rax,%rsi
setb   %al
mov    %r12,0x48(%rsp)
cmp    %r15,%r12
setb   %sil
test   %bl,%cl
jne    1952 <sumCatAsc+0x832>
mov    $0x0,%r15d
and    %sil,%al
mov    0x18(%rsp),%r12
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%rsi
jne    17ab <sumCatAsc+0x68b>
cmpq   $0x0,0x68(%rsp)
je     1969 <sumCatAsc+0x849>
mov    0x78(%rsp),%rax
lea    (%rax,%r10,8),%rcx
mov    0x58(%rsp),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd -0x30(%rcx,%rax,8),%xmm0
movupd -0x20(%rcx,%rax,8),%xmm1
movupd -0x30(%rbp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd -0x20(%rbp,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%rdi,%rax,8)
movupd %xmm0,-0x20(%rdi,%rax,8)
movupd -0x10(%rcx,%rax,8),%xmm0
movupd (%rcx,%rax,8),%xmm1
movupd -0x10(%rbp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x0(%rbp,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rdi,%rax,8)
movupd %xmm0,(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    18f0 <sumCatAsc+0x7d0>
jmp    196b <sumCatAsc+0x84b>
xor    %r15d,%r15d
mov    0x18(%rsp),%r12
mov    0x20(%rsp),%rbx
mov    0x8(%rsp),%rsi
jmp    17ab <sumCatAsc+0x68b>
xor    %eax,%eax
testb  $0x1,0x60(%rsp)
mov    0x8(%rsp),%rsi
je     19ac <sumCatAsc+0x88c>
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
mov    0x48(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
mov    0x10(%rsp),%rcx
movupd %xmm2,(%rcx,%rax,8)
movupd %xmm0,0x10(%rcx,%rax,8)
mov    0x70(%rsp),%rax
mov    %rax,%r15
cmp    %rdx,%rax
je     1760 <sumCatAsc+0x640>
jmp    17ab <sumCatAsc+0x68b>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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