#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 */
double fabs(double);
double log(double);
int /*<<< orphan*/ printf(char *, int const, int);
int /*<<< orphan*/ reorder(double *, int, int const);
int /*<<< orphan*/ reorder_back(double *, int, int const);
int virtual_width(int const);
double evaluateGAMMA_FLEX(int *wptr, double *x1_start, double *x2_start,
                          double *tipVector, unsigned char *tipX1, const int n,
                          double *diagptable, const int states) {
  double sum = 0.0, term, *x1, *x2;
  int i, j, k;
  const int span = states * 4;
  int vn = virtual_width(n);
  printf("n: %d %d\n", n, vn);
  if (tipX1 == 0) {
    reorder_back(x1_start, vn, span);
  }
  reorder_back(x2_start, vn, span);
  if (tipX1) {
    for (i = 0; i < n; i++) {
      x1 = &(tipVector[states * tipX1[i]]);
      x2 = &(x2_start[span * i]);
      for (j = 0, term = 0.0; j < 4; j++)
        for (k = 0; k < states; k++)
          term += x1[k] * x2[j * states + k] * diagptable[j * states + k];
      term = log(0.25 * fabs(term));
      sum += wptr[i] * term;
    }
  } else {
    for (i = 0; i < n; i++) {
      x1 = &(x1_start[span * i]);
      x2 = &(x2_start[span * i]);
      for (j = 0, term = 0.0; j < 4; j++)
        for (k = 0; k < states; k++)
          term += x1[j * states + k] * x2[j * states + k] *
                  diagptable[j * states + k];
      term = log(0.25 * fabs(term));
      sum += wptr[i] * term;
    }
  }
  if (tipX1 == 0) {
    reorder(x1_start, vn, span);
  }
  reorder(x2_start, vn, span);
  return sum;
}


x86 assembly (clang, -O0):
<evaluateGAMMA_FLEX>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    0x18(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x60(%rbp)
mov    -0x2c(%rbp),%edi
call   1040 <virtual_width@plt>
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%esi
mov    -0x64(%rbp),%edx
lea    0xe80(%rip),%rdi
call   1030 <printf@plt>
cmpq   $0x0,-0x28(%rbp)
jne    11bf <evaluateGAMMA_FLEX+0x6f>
mov    -0x10(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x60(%rbp),%edx
call   1070 <reorder_back@plt>
mov    -0x18(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x60(%rbp),%edx
call   1070 <reorder_back@plt>
cmpq   $0x0,-0x28(%rbp)
je     131e <evaluateGAMMA_FLEX+0x1ce>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1319 <evaluateGAMMA_FLEX+0x1c9>
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x54(%rbp),%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x54(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    12c1 <evaluateGAMMA_FLEX+0x171>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12ae <evaluateGAMMA_FLEX+0x15e>
mov    -0x48(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1249 <evaluateGAMMA_FLEX+0xf9>
jmp    12b3 <evaluateGAMMA_FLEX+0x163>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1238 <evaluateGAMMA_FLEX+0xe8>
movsd  -0x40(%rbp),%xmm1
movaps 0xd43(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xd27(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11e0 <evaluateGAMMA_FLEX+0x90>
jmp    1461 <evaluateGAMMA_FLEX+0x311>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    145c <evaluateGAMMA_FLEX+0x30c>
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x54(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x54(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x4,-0x58(%rbp)
jge    1404 <evaluateGAMMA_FLEX+0x2b4>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    13f1 <evaluateGAMMA_FLEX+0x2a1>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
imul   0x18(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1383 <evaluateGAMMA_FLEX+0x233>
jmp    13f6 <evaluateGAMMA_FLEX+0x2a6>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1372 <evaluateGAMMA_FLEX+0x222>
movsd  -0x40(%rbp),%xmm1
movaps 0xc00(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xbe4(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <log@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1325 <evaluateGAMMA_FLEX+0x1d5>
jmp    1461 <evaluateGAMMA_FLEX+0x311>
cmpq   $0x0,-0x28(%rbp)
jne    147b <evaluateGAMMA_FLEX+0x32b>
mov    -0x10(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x60(%rbp),%edx
call   1050 <reorder@plt>
mov    -0x18(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    -0x60(%rbp),%edx
call   1050 <reorder@plt>
movsd  -0x38(%rbp),%xmm0
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evaluateGAMMA_FLEX>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9d,%r15d
mov    %r8,%rbx
mov    %rcx,0x38(%rsp)
mov    %rdx,%r13
mov    %rsi,%r12
mov    %rdi,0x90(%rsp)
mov    0xe8(%rsp),%eax
lea    0x0(,%rax,4),%r14d
mov    %r9d,%edi
call   1040 <virtual_width@plt>
mov    %eax,%ebp
lea    0xe7e(%rip),%rdi
mov    %r15d,%esi
mov    %eax,%edx
call   1030 <printf@plt>
mov    %rbx,0x88(%rsp)
test   %rbx,%rbx
mov    %r13,0x48(%rsp)
je     1580 <evaluateGAMMA_FLEX+0x430>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
call   1070 <reorder_back@plt>
test   %r15d,%r15d
jle    19bb <evaluateGAMMA_FLEX+0x86b>
mov    %r12,0x70(%rsp)
mov    %ebp,0x28(%rsp)
mov    0xe8(%rsp),%r8d
movslq %r8d,%rdx
mov    %r14d,0x2c(%rsp)
movslq %r14d,%rcx
mov    %r15d,%eax
mov    %rax,0x80(%rsp)
lea    (%rdx,%rdx,1),%rax
mov    %rax,0x60(%rsp)
lea    (%rdx,%rdx,2),%rsi
mov    %r8d,%r15d
lea    -0x1(%r15),%rax
mov    %rax,0x20(%rsp)
mov    %r15,(%rsp)
and    $0xfffffffe,%r15d
mov    0x38(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x10(%rsp)
lea    0x8(%r13),%rbx
mov    %rcx,0x78(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x18(%rsp)
mov    0xe0(%rsp),%rcx
lea    0x8(%rcx,%rdx,8),%rax
mov    %rax,0x68(%rsp)
lea    0x8(,%rdx,8),%r12
add    %r13,%r12
mov    %rdx,0x40(%rsp)
mov    %rdx,%rax
shl    $0x4,%rax
lea    (%rcx,%rax,1),%rdx
add    $0x8,%rdx
mov    %rdx,0x30(%rsp)
mov    %r13,%rdx
lea    0x8(%r13,%rax,1),%r13
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x8(%rcx,%rsi,8),%rax
mov    %rax,0x58(%rsp)
mov    %rsi,0x50(%rsp)
lea    (%rdx,%rsi,8),%r14
add    $0x8,%r14
xor    %ebp,%ebp
jmp    130c <evaluateGAMMA_FLEX+0x1bc>
nop
andpd  0xd58(%rip),%xmm0
mulsd  0xd60(%rip),%xmm0
call   1060 <log@plt>
mov    0xe0(%rsp),%rcx
mov    0xe8(%rsp),%r8d
mov    0x90(%rsp),%rax
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rbp,4),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
add    $0x1,%rbp
mov    0x18(%rsp),%rax
add    %rax,%rbx
add    %rax,%r12
add    %rax,%r13
add    %rax,%r14
cmp    0x80(%rsp),%rbp
je     19a0 <evaluateGAMMA_FLEX+0x850>
xorpd  %xmm0,%xmm0
test   %r8d,%r8d
jle    12a0 <evaluateGAMMA_FLEX+0x150>
mov    0x88(%rsp),%rax
movzbl (%rax,%rbp,1),%r10d
imul   0x40(%rsp),%r10
mov    %rbp,%rax
imul   0x78(%rsp),%rax
cmpq   $0x0,0x20(%rsp)
je     1390 <evaluateGAMMA_FLEX+0x240>
mov    0x10(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
xorpd  %xmm1,%xmm1
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rsi,8),%xmm2
movsd  (%rdx,%rsi,8),%xmm0
mulsd  -0x8(%rbx,%rsi,8),%xmm2
mulsd  (%rcx,%rsi,8),%xmm2
mulsd  (%rbx,%rsi,8),%xmm0
mulsd  0x8(%rcx,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rsi
movapd %xmm0,%xmm1
cmp    %rsi,%r15
jne    1350 <evaluateGAMMA_FLEX+0x200>
jmp    1396 <evaluateGAMMA_FLEX+0x246>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x38(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rax,8),%r9
testb  $0x1,(%rsp)
je     13c2 <evaluateGAMMA_FLEX+0x272>
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%r9,%rsi,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
jle    12a0 <evaluateGAMMA_FLEX+0x150>
cmpq   $0x0,0x20(%rsp)
je     1534 <evaluateGAMMA_FLEX+0x3e4>
mov    0x10(%rsp),%rax
lea    (%rax,%r10,8),%rdi
xor    %esi,%esi
movapd %xmm0,%xmm1
mov    0x68(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdi,%rsi,8),%xmm2
movsd  (%rdi,%rsi,8),%xmm0
mulsd  -0x8(%r12,%rsi,8),%xmm2
mulsd  -0x8(%rax,%rsi,8),%xmm2
mulsd  (%r12,%rsi,8),%xmm0
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rsi
movapd %xmm0,%xmm1
cmp    %rsi,%r15
jne    13f0 <evaluateGAMMA_FLEX+0x2a0>
testb  $0x1,(%rsp)
je     1447 <evaluateGAMMA_FLEX+0x2f7>
movsd  (%rdx,%rsi,8),%xmm1
add    0x40(%rsp),%rsi
mulsd  (%r9,%rsi,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
jle    12a0 <evaluateGAMMA_FLEX+0x150>
cmpq   $0x0,0x20(%rsp)
je     1545 <evaluateGAMMA_FLEX+0x3f5>
mov    0x10(%rsp),%rax
lea    (%rax,%r10,8),%rdi
xor    %esi,%esi
movapd %xmm0,%xmm1
mov    0x30(%rsp),%rax
movsd  -0x8(%rdi,%rsi,8),%xmm2
movsd  (%rdi,%rsi,8),%xmm0
mulsd  -0x8(%r13,%rsi,8),%xmm2
mulsd  -0x8(%rax,%rsi,8),%xmm2
mulsd  0x0(%r13,%rsi,8),%xmm0
mulsd  (%rax,%rsi,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rsi
movapd %xmm0,%xmm1
cmp    %rsi,%r15
jne    1470 <evaluateGAMMA_FLEX+0x320>
testb  $0x1,(%rsp)
je     14c8 <evaluateGAMMA_FLEX+0x378>
movsd  (%rdx,%rsi,8),%xmm1
add    0x60(%rsp),%rsi
mulsd  (%r9,%rsi,8),%xmm1
mulsd  (%rcx,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
jle    12a0 <evaluateGAMMA_FLEX+0x150>
cmpq   $0x0,0x20(%rsp)
je     1556 <evaluateGAMMA_FLEX+0x406>
mov    0x10(%rsp),%rax
lea    (%rax,%r10,8),%rsi
xor    %eax,%eax
movapd %xmm0,%xmm1
mov    0x58(%rsp),%rdi
nopl   (%rax)
movsd  -0x8(%rsi,%rax,8),%xmm2
movsd  (%rsi,%rax,8),%xmm0
mulsd  -0x8(%r14,%rax,8),%xmm2
mulsd  -0x8(%rdi,%rax,8),%xmm2
mulsd  (%r14,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%r15
jne    14f0 <evaluateGAMMA_FLEX+0x3a0>
testb  $0x1,(%rsp)
je     12a0 <evaluateGAMMA_FLEX+0x150>
jmp    1562 <evaluateGAMMA_FLEX+0x412>
xor    %esi,%esi
testb  $0x1,(%rsp)
jne    142e <evaluateGAMMA_FLEX+0x2de>
jmp    1447 <evaluateGAMMA_FLEX+0x2f7>
xor    %esi,%esi
testb  $0x1,(%rsp)
jne    14af <evaluateGAMMA_FLEX+0x35f>
jmp    14c8 <evaluateGAMMA_FLEX+0x378>
xor    %eax,%eax
testb  $0x1,(%rsp)
je     12a0 <evaluateGAMMA_FLEX+0x150>
movsd  (%rdx,%rax,8),%xmm1
add    0x50(%rsp),%rax
mulsd  (%r9,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm1,%xmm0
jmp    12a0 <evaluateGAMMA_FLEX+0x150>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
call   1070 <reorder_back@plt>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
call   1070 <reorder_back@plt>
test   %r15d,%r15d
mov    %r12,0x70(%rsp)
jle    19c7 <evaluateGAMMA_FLEX+0x877>
mov    %ebp,0x28(%rsp)
mov    0xe8(%rsp),%edi
mov    %rdi,%r8
movslq %r8d,%rcx
mov    %r14d,0x2c(%rsp)
movslq %r14d,%rax
mov    %r15d,%edx
mov    %rdx,0x38(%rsp)
lea    (%rcx,%rcx,1),%rsi
mov    %rsi,0x50(%rsp)
lea    (%rcx,%rcx,2),%rdi
mov    %r8d,%r14d
lea    -0x1(%r14),%rsi
mov    %rsi,0x18(%rsp)
mov    %r14,0x68(%rsp)
and    $0xfffffffe,%r14d
lea    0x8(%r12),%rbp
mov    %rax,0x78(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x40(%rsp)
lea    0x8(%r13),%rbx
mov    0xe0(%rsp),%rsi
lea    (%rsi,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
lea    (%rsi,%rax,1),%rdx
add    $0x8,%rdx
mov    %rdx,0x60(%rsp)
lea    0x8(%r13,%rax,1),%r10
lea    0x8(%r12,%rax,1),%r11
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x8(%r13,%rcx,8),%r15
mov    %r12,%rax
mov    %rcx,0x58(%rsp)
lea    0x8(%r12,%rcx,8),%r12
lea    0x8(%rsi,%rdi,8),%rcx
mov    %rcx,0xa0(%rsp)
lea    0x8(%r13,%rdi,8),%r13
mov    %rdi,0x98(%rsp)
lea    (%rax,%rdi,8),%rax
add    $0x8,%rax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,(%rsp)
jmp    173d <evaluateGAMMA_FLEX+0x5ed>
nopw   0x0(%rax,%rax,1)
andpd  0x968(%rip),%xmm0
mulsd  0x970(%rip),%xmm0
mov    %r13,0x80(%rsp)
mov    %r10,%r13
mov    %r12,0x20(%rsp)
mov    %r15,%r12
mov    %r11,%r15
call   1060 <log@plt>
mov    %r15,%r11
mov    %r12,%r15
mov    0x20(%rsp),%r12
mov    %r13,%r10
mov    0x80(%rsp),%r13
mov    0xe0(%rsp),%rsi
mov    0xe8(%rsp),%edi
mov    %rdi,%r8
mov    0x90(%rsp),%rax
mov    (%rsp),%rcx
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
add    $0x1,%rcx
mov    0x40(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
add    %rax,%r15
add    %rax,%r12
add    %rax,%r10
add    %rax,%r11
add    %rax,%r13
add    %rax,0x10(%rsp)
mov    %rcx,(%rsp)
cmp    0x38(%rsp),%rcx
je     19a0 <evaluateGAMMA_FLEX+0x850>
xorpd  %xmm0,%xmm0
test   %r8d,%r8d
jle    1690 <evaluateGAMMA_FLEX+0x540>
mov    (%rsp),%rax
imul   0x78(%rsp),%rax
cmpq   $0x0,0x18(%rsp)
je     17b0 <evaluateGAMMA_FLEX+0x660>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
mov    0x48(%rsp),%r9
mov    0x30(%rsp),%rdi
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rdx,8),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  -0x8(%rbx,%rdx,8),%xmm2
mulsd  (%rsi,%rdx,8),%xmm2
mulsd  (%rbx,%rdx,8),%xmm0
mulsd  0x8(%rsi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r14
jne    1770 <evaluateGAMMA_FLEX+0x620>
jmp    17c0 <evaluateGAMMA_FLEX+0x670>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x48(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%r9,%rax,8),%r9
mov    0x68(%rsp),%rax
test   $0x1,%al
je     17ea <evaluateGAMMA_FLEX+0x69a>
movsd  (%rcx,%rdx,8),%xmm1
mulsd  (%r9,%rdx,8),%xmm1
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
jle    1690 <evaluateGAMMA_FLEX+0x540>
cmpq   $0x0,0x18(%rsp)
je     1953 <evaluateGAMMA_FLEX+0x803>
xor    %edx,%edx
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r12,%rdx,8),%xmm2
movsd  (%r12,%rdx,8),%xmm0
mulsd  -0x8(%r15,%rdx,8),%xmm2
mulsd  -0x8(%rdi,%rdx,8),%xmm2
mulsd  (%r15,%rdx,8),%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r14
jne    1810 <evaluateGAMMA_FLEX+0x6c0>
test   $0x1,%al
je     1867 <evaluateGAMMA_FLEX+0x717>
add    0x58(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  (%r9,%rdx,8),%xmm1
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
mov    0x60(%rsp),%rdi
jle    1690 <evaluateGAMMA_FLEX+0x540>
cmpq   $0x0,0x18(%rsp)
je     1962 <evaluateGAMMA_FLEX+0x812>
xor    %edx,%edx
movapd %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r11,%rdx,8),%xmm2
movsd  (%r11,%rdx,8),%xmm0
mulsd  -0x8(%r10,%rdx,8),%xmm2
mulsd  -0x8(%rdi,%rdx,8),%xmm2
mulsd  (%r10,%rdx,8),%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r14
jne    1890 <evaluateGAMMA_FLEX+0x740>
test   $0x1,%al
je     18e7 <evaluateGAMMA_FLEX+0x797>
add    0x50(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  (%r9,%rdx,8),%xmm1
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
test   %r8d,%r8d
jle    1690 <evaluateGAMMA_FLEX+0x540>
cmpq   $0x0,0x18(%rsp)
je     1971 <evaluateGAMMA_FLEX+0x821>
mov    %rcx,%r8
xor    %edx,%edx
movapd %xmm0,%xmm1
mov    0xa0(%rsp),%rdi
mov    0x10(%rsp),%rcx
xchg   %ax,%ax
movsd  -0x8(%rcx,%rdx,8),%xmm2
movsd  (%rcx,%rdx,8),%xmm0
mulsd  -0x8(%r13,%rdx,8),%xmm2
mulsd  -0x8(%rdi,%rdx,8),%xmm2
mulsd  0x0(%r13,%rdx,8),%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    %rdx,%r14
jne    1910 <evaluateGAMMA_FLEX+0x7c0>
test   $0x1,%al
je     1690 <evaluateGAMMA_FLEX+0x540>
jmp    197e <evaluateGAMMA_FLEX+0x82e>
xor    %edx,%edx
test   $0x1,%al
jne    184e <evaluateGAMMA_FLEX+0x6fe>
jmp    1867 <evaluateGAMMA_FLEX+0x717>
xor    %edx,%edx
test   $0x1,%al
jne    18ce <evaluateGAMMA_FLEX+0x77e>
jmp    18e7 <evaluateGAMMA_FLEX+0x797>
mov    %rcx,%r8
xor    %edx,%edx
test   $0x1,%al
je     1690 <evaluateGAMMA_FLEX+0x540>
add    0x98(%rsp),%rdx
movsd  (%r8,%rdx,8),%xmm1
mulsd  (%r9,%rdx,8),%xmm1
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1690 <evaluateGAMMA_FLEX+0x540>
cmpq   $0x0,0x88(%rsp)
mov    0x48(%rsp),%r13
mov    0x2c(%rsp),%r14d
mov    0x28(%rsp),%ebp
jne    19e0 <evaluateGAMMA_FLEX+0x890>
jmp    19d1 <evaluateGAMMA_FLEX+0x881>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
jmp    19e0 <evaluateGAMMA_FLEX+0x890>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x8(%rsp)
mov    0x70(%rsp),%rdi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <reorder@plt>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
call   1050 <reorder@plt>
movsd  0x8(%rsp),%xmm0
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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