#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 */
typedef scalar_t__ *n;
typedef size_t m;
typedef size_t j;
typedef size_t i;

/* Variables and functions */
scalar_t__ fabs(double);
void elemhess(int job, double *mat, int n, int low, int hi, double *vr,
              double *vi, int *work) {
  int i, j, m;
  double x, y;
  for (m = low + 1; m < hi; m++) {
    for (x = 0, i = m, j = m; j <= hi; j++) {
      if (fabs(mat[((j) * (n) + (m - 1))]) > fabs(x)) {
        x = mat[((j) * (n) + (m - 1))];
        i = j;
      }
    }
    if ((work[m] = i) != m) {
      for (j = m - 1; j < n; j++) {
        y = mat[((i) * (n) + (j))];
        mat[((i) * (n) + (j))] = mat[((m) * (n) + (j))];
        mat[((m) * (n) + (j))] = y;
      }
      for (j = 0; j <= hi; j++) {
        y = mat[((j) * (n) + (i))];
        mat[((j) * (n) + (i))] = mat[((j) * (n) + (m))];
        mat[((j) * (n) + (m))] = y;
      }
    }
    if (x != 0) {
      for (i = m + 1; i <= hi; i++) {
        if ((y = mat[((i) * (n) + (m - 1))]) != 0) {
          y = mat[((i) * (n) + (m - 1))] = y / x;
          for (j = m; j < n; j++) {
            mat[((i) * (n) + (j))] -= y * mat[((m) * (n) + (j))];
          }
          for (j = 0; j <= hi; j++) {
            mat[((j) * (n) + (m))] += y * mat[((j) * (n) + (i))];
          }
        }
      }
    }
  }
  if (job) {
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        vr[((i) * (n) + (j))] = 0.0;
        vi[((i) * (n) + (j))] = 0.0;
      }
      vr[((i) * (n) + (i))] = 1.0;
    }
    for (m = hi - 1; m > low; m--) {
      for (i = m + 1; i <= hi; i++) {
        vr[((i) * (n) + (m))] = mat[((i) * (n) + (m - 1))];
      }
      if ((i = work[m]) != m) {
        for (j = m; j <= hi; j++) {
          vr[((m) * (n) + (j))] = vr[((i) * (n) + (j))];
          vr[((i) * (n) + (j))] = 0.0;
        }
        vr[((i) * (n) + (m))] = 1.0;
      }
    }
  }
}


x86 assembly (clang, -O0):
<elemhess>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    149d <elemhess+0x38d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11e1 <elemhess+0xd1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%rax
cmp    %rcx,%rax
jle    11ce <elemhess+0xbe>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    11d3 <elemhess+0xc3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115e <elemhess+0x4e>
mov    -0x2c(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    %eax,(%rcx,%rdx,4)
cmp    -0x34(%rbp),%eax
je     1305 <elemhess+0x1f5>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    127d <elemhess+0x16d>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1201 <elemhess+0xf1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1300 <elemhess+0x1f0>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1284 <elemhess+0x174>
jmp    1305 <elemhess+0x1f5>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1322 <elemhess+0x212>
jp     1322 <elemhess+0x212>
jmp    148a <elemhess+0x37a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1485 <elemhess+0x375>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    136f <elemhess+0x25f>
jp     136f <elemhess+0x25f>
jmp    1472 <elemhess+0x362>
movsd  -0x48(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    140e <elemhess+0x2fe>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    139f <elemhess+0x28f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     146d <elemhess+0x35d>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1415 <elemhess+0x305>
jmp    1472 <elemhess+0x362>
jmp    1477 <elemhess+0x367>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    132b <elemhess+0x21b>
jmp    148a <elemhess+0x37a>
jmp    148f <elemhess+0x37f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    113e <elemhess+0x2e>
cmpl   $0x0,-0x4(%rbp)
je     1654 <elemhess+0x544>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1539 <elemhess+0x429>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    150d <elemhess+0x3fd>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14c1 <elemhess+0x3b1>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xada(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14ae <elemhess+0x39e>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    164f <elemhess+0x53f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     15a2 <elemhess+0x492>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1557 <elemhess+0x447>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
cmp    -0x34(%rbp),%eax
je     163c <elemhess+0x52c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     161e <elemhess+0x50e>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15bf <elemhess+0x4af>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x9c9(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1641 <elemhess+0x531>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1542 <elemhess+0x432>
jmp    1654 <elemhess+0x544>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<elemhess>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,0x28(%rsp)
mov    %edx,0x4(%rsp)
mov    %rsi,0x10(%rsp)
mov    %edi,0xb0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
lea    0x1(%rcx),%eax
cmp    %r8d,%eax
mov    %r8,0x30(%rsp)
jge    1a43 <elemhess+0x933>
movslq %eax,%r11
movslq 0x4(%rsp),%r9
movslq %r8d,%rax
mov    %rax,0x38(%rsp)
add    $0x1,%r8d
mov    0x90(%rsp),%rax
lea    0x2(%rax),%edx
lea    0x1(%r9),%rcx
imul   %r11,%rcx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,8),%rdi
mov    %rdi,0x118(%rsp)
lea    0x0(,%r9,8),%r13
lea    0x8(,%r9,8),%rax
mov    %rax,0xb8(%rsp)
lea    0x8(,%r11,8),%rbp
imul   %r9,%rbp
mov    %rbp,0x110(%rsp)
mov    %r9,%rbx
imul   %r11,%rbx
lea    0x1(%r11),%rax
imul   %r9,%rax
mov    %rax,0x100(%rsp)
mov    %r8d,%r14d
and    $0xfffffffe,%r14d
mov    %r9,%r15
shl    $0x4,%r15
mov    %r9,%rax
sub    %r11,%rax
lea    (%rsi,%rcx,8),%r12
add    $0x10,%r12
lea    0x0(,%r11,8),%rbp
mov    %r8,0x80(%rsp)
lea    -0x1(%r8),%rcx
mov    %rcx,0x78(%rsp)
lea    -0x1(%r11),%r10
lea    -0x4(%r9),%rcx
mov    %rcx,0xe8(%rsp)
lea    0x30(%rsi),%rcx
mov    %rcx,0xc8(%rsp)
lea    0x10(%rsi),%rcx
mov    %rcx,0xe0(%rsp)
lea    (%rsi,%rbx,8),%rcx
mov    %rcx,0x48(%rsp)
lea    0x0(,%r9,8),%rcx
add    %rbp,%rcx
mov    %rcx,0xa0(%rsp)
lea    (%rsi,%r11,8),%rdi
add    $0x10,%rdi
xor    %r8d,%r8d
mov    %rbx,0x108(%rsp)
mov    %rbx,%rcx
mov    %rdi,%rbx
mov    %r11,0x128(%rsp)
mov    %r9,0x120(%rsp)
mov    %r14,0xf8(%rsp)
mov    %r15,0xf0(%rsp)
jmp    1304 <elemhess+0x1f4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
mov    0xc0(%rsp),%r10
add    $0x1,%r10
mov    0xb4(%rsp),%edx
add    $0x1,%edx
add    $0x1,%r8
mov    0x150(%rsp),%rcx
add    %r9,%rcx
add    %r13,%rbx
mov    %rbx,0x48(%rsp)
addq   $0x8,0xa0(%rsp)
mov    0xa8(%rsp),%rbp
add    $0x8,%rbp
mov    0x168(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    %rsi,%r11
add    0xb8(%rsp),%r12
mov    0x158(%rsp),%rbx
add    $0x8,%rbx
cmp    0x30(%rsp),%r11d
je     1a43 <elemhess+0x933>
mov    %rbp,0xa8(%rsp)
mov    %r12,0x160(%rsp)
mov    %edx,0xb4(%rsp)
movslq %edx,%r15
mov    %r9,%rdx
imul   %r15,%rdx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,8),%rbp
mov    %rax,0x168(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x170(%rsp)
movslq %r10d,%rdi
mov    0xe8(%rsp),%rax
sub    %rdi,%rax
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xd8(%rsp)
mov    %rcx,0x150(%rsp)
lea    (%rcx,%rdi,1),%rax
mov    0xe0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    (%rsi,%rax,8),%r14
mov    %r9,%rax
sub    %rdi,%rax
mov    %rax,0x70(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x130(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x138(%rsp)
mov    %r8,%rax
imul   %r9,%rax
mov    0x108(%rsp),%rcx
add    %rax,%rcx
mov    %rdi,0x20(%rsp)
add    %rdi,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x140(%rsp)
mov    0x128(%rsp),%rcx
add    %r8,%rcx
mov    %r9,%rdi
sub    %rcx,%rdi
mov    %rdi,0x68(%rsp)
mov    0x100(%rsp),%rcx
add    %rax,%rcx
lea    (%rsi,%rcx,8),%rcx
mov    %rcx,0x98(%rsp)
mov    %rbx,0x158(%rsp)
lea    (%rbx,%rdx,8),%rcx
mov    %rcx,0x148(%rsp)
add    %r11,%rdx
mov    %rdx,0x190(%rsp)
lea    0x1(%r15),%rcx
imul   %r9,%rcx
mov    %rcx,0x180(%rsp)
mov    0xb8(%rsp),%rcx
mov    %r8,0x88(%rsp)
imul   %r8,%rcx
add    0x118(%rsp),%rcx
mov    %rcx,0x178(%rsp)
lea    (%rsi,%rax,8),%rax
add    0x110(%rsp),%rax
mov    %rax,0x188(%rsp)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
lea    0x0(,%r15,8),%rax
mov    %rax,0x60(%rsp)
mov    %r15,0x18(%rsp)
lea    0x0(%r13,%r15,8),%rax
mov    %rax,0x58(%rsp)
mov    %r11d,%r15d
mov    %r10,0xc0(%rsp)
mov    %r10,%rbx
mov    %r11,0x50(%rsp)
mov    %r11d,%eax
mov    %r11d,0x8(%rsp)
jmp    14c5 <elemhess+0x3b5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1,%r15d
mov    %r12,%r13
add    %r12,%r14
cmp    0x38(%rsp),%rbx
jge    1500 <elemhess+0x3f0>
mov    %r13,%r12
movsd  (%r14),%xmm0
call   1030 <fabs@plt>
mov    %rax,%r13
movsd  0x40(%rsp),%xmm0
call   1030 <fabs@plt>
cmp    %rax,%r13
jle    14b0 <elemhess+0x3a0>
movsd  (%r14),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    %r15d,0x8(%rsp)
jmp    14b0 <elemhess+0x3a0>
nopw   0x0(%rax,%rax,1)
mov    0x1d8(%rsp),%rax
mov    0x50(%rsp),%rsi
mov    0x8(%rsp),%ecx
mov    %ecx,(%rax,%rsi,4)
cmp    %esi,%ecx
mov    0x120(%rsp),%r9
mov    0xf8(%rsp),%r14
mov    0xf0(%rsp),%r15
mov    0x160(%rsp),%r12
xorpd  %xmm7,%xmm7
mov    0x148(%rsp),%r10
je     17b0 <elemhess+0x6a0>
mov    0xc0(%rsp),%rax
cmp    0x4(%rsp),%eax
mov    0x48(%rsp),%rdi
jge    16fd <elemhess+0x5ed>
mov    %ecx,%eax
imul   0x4(%rsp),%eax
movslq %eax,%r8
mov    0x20(%rsp),%rax
mov    %rax,%rdx
mov    0x70(%rsp),%rbx
cmp    $0x4,%rbx
jb     16d0 <elemhess+0x5c0>
lea    (%rax,%r8,1),%rcx
mov    0x10(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
cmp    0x98(%rsp),%rdx
jae    15b7 <elemhess+0x4a7>
lea    (%r9,%r8,1),%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x20(%rsp),%rdx
cmp    %rax,0x140(%rsp)
jb     16d0 <elemhess+0x5c0>
cmpq   $0x4,0x130(%rsp)
jae    15c9 <elemhess+0x4b9>
xor    %ecx,%ecx
jmp    164e <elemhess+0x53e>
mov    0xc8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
xor    %ecx,%ecx
mov    0xd8(%rsp),%rax
mov    0xd0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rcx,8),%xmm0
movups -0x20(%rdx,%rcx,8),%xmm1
movups -0x10(%rbx,%rcx,8),%xmm2
movups (%rbx,%rcx,8),%xmm3
movups %xmm2,-0x30(%rdx,%rcx,8)
movups %xmm3,-0x20(%rdx,%rcx,8)
movups %xmm0,-0x10(%rbx,%rcx,8)
movups %xmm1,(%rbx,%rcx,8)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd 0x20(%rbx,%rcx,8),%xmm3
movupd %xmm2,-0x10(%rdx,%rcx,8)
movupd %xmm3,(%rdx,%rcx,8)
movupd %xmm0,0x10(%rbx,%rcx,8)
movupd %xmm1,0x20(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    15f0 <elemhess+0x4e0>
mov    0x70(%rsp),%rbx
mov    %rbx,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x1,0x138(%rsp)
01
je     16c2 <elemhess+0x5b2>
mov    %rsi,%rax
imul   %r9,%rax
add    0x20(%rsp),%rcx
lea    (%rcx,%r8,1),%rdi
mov    %rdi,0x98(%rsp)
mov    0x10(%rsp),%rsi
movupd (%rsi,%rdi,8),%xmm0
movupd 0x10(%rsi,%rdi,8),%xmm1
add    %rax,%rcx
mov    0x48(%rsp),%rdi
movupd (%rsi,%rcx,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm3
mov    0x98(%rsp),%rax
movupd %xmm2,(%rsi,%rax,8)
movupd %xmm3,0x10(%rsi,%rax,8)
movupd %xmm0,(%rsi,%rcx,8)
movupd %xmm1,0x10(%rsi,%rcx,8)
mov    0x50(%rsp),%rsi
cmp    %rdx,%rbx
mov    0x8(%rsp),%ecx
je     16fd <elemhess+0x5ed>
add    0x20(%rsp),%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%r8,8),%rax
mov    0x8(%rsp),%ecx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rax,%rdx,8)
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x1,%rdx
cmp    %r9,%rdx
jl     16e0 <elemhess+0x5d0>
cmpl   $0x0,0x30(%rsp)
js     17b0 <elemhess+0x6a0>
movslq %ecx,%r8
cmpq   $0x0,0x78(%rsp)
je     1a2e <elemhess+0x91e>
lea    (%r9,%r8,1),%rdx
mov    0x10(%rsp),%rdi
xor    %ecx,%ecx
mov    0xa8(%rsp),%rax
mov    0xa0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%r8,8),%xmm0
movsd  (%rdi,%rax,1),%xmm1
movsd  %xmm1,(%rdi,%r8,8)
movsd  %xmm0,(%rdi,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
movsd  (%rdi,%rbx,1),%xmm1
movsd  %xmm1,(%rdi,%rdx,8)
movsd  %xmm0,(%rdi,%rbx,1)
add    $0x2,%rcx
add    %r15,%rdi
cmp    %rcx,%r14
jne    1740 <elemhess+0x630>
testb  $0x1,0x80(%rsp)
01
je     17b0 <elemhess+0x6a0>
imul   %r9,%rcx
add    %rcx,%r8
mov    0x10(%rsp),%rax
movsd  (%rax,%r8,8),%xmm0
add    %rsi,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%r8,8)
movsd  %xmm0,(%rax,%rcx,8)
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x40(%rsp),%xmm0
ucomisd %xmm7,%xmm0
movapd 0x183d(%rip),%xmm8
mov    0x48(%rsp),%rbx
mov    0x88(%rsp),%r8
mov    0x18(%rsp),%rdi
jne    17dd <elemhess+0x6cd>
jnp    1290 <elemhess+0x180>
mov    0x20(%rsp),%rax
add    $0x2,%eax
cmp    0x30(%rsp),%eax
jg     1290 <elemhess+0x180>
mov    0x68(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
add    %rsi,%rax
mov    %rax,0x70(%rsp)
xor    %edx,%edx
jmp    183b <elemhess+0x72b>
nopl   0x0(%rax)
lea    0x1(%rdi),%rcx
add    $0x1,%rdx
mov    %r11,%r10
add    %r13,%r10
add    %r13,%rbp
addq   $0x8,0x58(%rsp)
addq   $0x8,0x60(%rsp)
cmp    0x38(%rsp),%rdi
mov    %rcx,%rdi
jge    1290 <elemhess+0x180>
mov    %r10,%r11
mov    %rdi,%rcx
imul   %r9,%rcx
add    0x20(%rsp),%rcx
mov    0x10(%rsp),%r10
movsd  (%r10,%rcx,8),%xmm0
ucomisd %xmm7,%xmm0
jne    185d <elemhess+0x74d>
jnp    1810 <elemhess+0x700>
divsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
cmp    %r9,%rsi
mov    %rdi,%rcx
mov    %rdi,0x18(%rsp)
jge    196e <elemhess+0x85e>
movapd %xmm0,%xmm1
xorpd  %xmm8,%xmm1
mov    %rsi,%rcx
cmpq   $0x4,0x68(%rsp)
jb     1950 <elemhess+0x840>
mov    %rdx,%rcx
imul   %r9,%rcx
mov    0x190(%rsp),%rax
lea    (%rax,%rcx,1),%rdi
lea    (%r10,%rdi,8),%rdi
cmp    %rdi,0x188(%rsp)
mov    0x18(%rsp),%rdi
jbe    18d6 <elemhess+0x7c6>
add    0x180(%rsp),%rcx
lea    (%r10,%rcx,8),%rdi
mov    %rsi,%rcx
cmp    %rdi,0x178(%rsp)
mov    0x18(%rsp),%rdi
jb     1950 <elemhess+0x840>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
xor    %ecx,%ecx
mov    0x170(%rsp),%rax
mov    %r11,%r10
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r12,%rcx,8),%xmm3
movupd (%r12,%rcx,8),%xmm4
movupd -0x10(%r10,%rcx,8),%xmm5
movupd (%r10,%rcx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,-0x10(%r10,%rcx,8)
movupd %xmm4,(%r10,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    18f0 <elemhess+0x7e0>
mov    0x70(%rsp),%rcx
mov    0x8(%rsp),%rax
cmp    %rax,0x68(%rsp)
mov    0x10(%rsp),%r10
je     196e <elemhess+0x85e>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%rbp,%rcx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %r9,%rcx
jl     1950 <elemhess+0x840>
cmpl   $0x0,0x30(%rsp)
js     1810 <elemhess+0x700>
cmpq   $0x0,0x78(%rsp)
je     19d6 <elemhess+0x8c6>
mov    %r10,%rdi
xor    %ecx,%ecx
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%rbx
mov    0x60(%rsp),%rsi
mov    0x58(%rsp),%rax
movsd  (%rdi,%rsi,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%r8,1),%xmm1
movsd  %xmm1,(%rdi,%r8,1)
movsd  (%rdi,%rax,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rbx,1),%xmm1
movsd  %xmm1,(%rdi,%rbx,1)
add    $0x2,%rcx
add    %r15,%rdi
cmp    %rcx,%r14
jne    19a0 <elemhess+0x890>
jmp    19d8 <elemhess+0x8c8>
xor    %ecx,%ecx
testb  $0x1,0x80(%rsp)
01
mov    0x48(%rsp),%rbx
mov    0x88(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x50(%rsp),%rsi
je     1810 <elemhess+0x700>
imul   %r9,%rcx
mov    0x18(%rsp),%rsi
lea    (%rcx,%rsi,1),%rdi
mov    0x50(%rsp),%rsi
mulsd  (%r10,%rdi,8),%xmm0
mov    0x18(%rsp),%rdi
add    %rsi,%rcx
addsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
jmp    1810 <elemhess+0x700>
xor    %ecx,%ecx
testb  $0x1,0x80(%rsp)
01
jne    1780 <elemhess+0x670>
jmp    17b0 <elemhess+0x6a0>
cmpl   $0x0,0xb0(%rsp)
mov    0x28(%rsp),%r9
je     20bd <elemhess+0xfad>
cmpl   $0x0,0x4(%rsp)
jle    1cdd <elemhess+0xbcd>
mov    0x1d0(%rsp),%rbx
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x18(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rax
mov    %rax,0x8(%rsp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,0x38(%rsp)
lea    0x70(%rbx),%rbp
lea    0x0(,%rcx,8),%r8
lea    0x70(%r9),%rdi
lea    0x10(%rbx),%rax
lea    0x10(%r9),%r10
mov    %rdx,0x58(%rsp)
mov    %rdx,%r15
shl    $0x5,%r15
xor    %r13d,%r13d
xorpd  %xmm0,%xmm0
mov    %r9,%r11
mov    %rbx,%r14
mov    %r15,0x40(%rsp)
jmp    1b1a <elemhess+0xa0a>
nopl   0x0(%rax,%rax,1)
add    %r13,%r12
mov    0x28(%rsp),%r9
movabs $0x3ff0000000000000,%rdx
mov    %rdx,(%r9,%r12,8)
add    $0x1,%r13
add    %r8,%rbp
add    %r8,%rdi
add    %r8,%rax
add    %r8,%r10
add    %r8,%r14
add    %r8,%r11
cmp    %rcx,%r13
mov    0x40(%rsp),%r15
je     1cdd <elemhess+0xbcd>
mov    %r13,%r12
imul   %rcx,%r12
cmpl   $0x4,0x4(%rsp)
jb     1b56 <elemhess+0xa46>
lea    (%r12,%rcx,1),%rdx
lea    (%rbx,%rdx,8),%rsi
lea    (%r9,%r12,8),%rbx
cmp    %rsi,%rbx
mov    0x1d0(%rsp),%rbx
jae    1c00 <elemhess+0xaf0>
lea    (%rbx,%r12,8),%rsi
lea    (%r9,%rdx,8),%rdx
cmp    %rdx,%rsi
jae    1c00 <elemhess+0xaf0>
xor    %r15d,%r15d
mov    0x38(%rsp),%r9
mov    %r15,%rdx
not    %rdx
add    %rcx,%rdx
test   %r9,%r9
je     1b8a <elemhess+0xa7a>
mov    %r9,%rsi
nop
movq   $0x0,(%r11,%r15,8)
movq   $0x0,(%r14,%r15,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rsi
jne    1b70 <elemhess+0xa60>
cmp    $0x3,%rdx
jb     1ae0 <elemhess+0x9d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r11,%r15,8)
movq   $0x0,-0x10(%rax,%r15,8)
movq   $0x0,0x8(%r11,%r15,8)
movq   $0x0,-0x8(%rax,%r15,8)
movq   $0x0,0x10(%r11,%r15,8)
movq   $0x0,(%rax,%r15,8)
movq   $0x0,0x18(%r11,%r15,8)
movq   $0x0,0x8(%rax,%r15,8)
add    $0x4,%r15
cmp    %r15,%rcx
jne    1ba0 <elemhess+0xa90>
jmp    1ae0 <elemhess+0x9d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0xc,0x60(%rsp)
jae    1c0c <elemhess+0xafc>
xor    %esi,%esi
jmp    1c89 <elemhess+0xb79>
mov    0x8(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm0,-0x70(%rdi,%rsi,8)
movupd %xmm0,-0x60(%rdi,%rsi,8)
movupd %xmm0,-0x70(%rbp,%rsi,8)
movupd %xmm0,-0x60(%rbp,%rsi,8)
movupd %xmm0,-0x50(%rdi,%rsi,8)
movupd %xmm0,-0x40(%rdi,%rsi,8)
movupd %xmm0,-0x50(%rbp,%rsi,8)
movupd %xmm0,-0x40(%rbp,%rsi,8)
movupd %xmm0,-0x30(%rdi,%rsi,8)
movupd %xmm0,-0x20(%rdi,%rsi,8)
movupd %xmm0,-0x30(%rbp,%rsi,8)
movupd %xmm0,-0x20(%rbp,%rsi,8)
movupd %xmm0,-0x10(%rdi,%rsi,8)
movupd %xmm0,(%rdi,%rsi,8)
movupd %xmm0,-0x10(%rbp,%rsi,8)
movupd %xmm0,0x0(%rbp,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1c20 <elemhess+0xb10>
cmpq   $0x0,0x58(%rsp)
mov    0x38(%rsp),%r9
je     1cbf <elemhess+0xbaf>
lea    (%rax,%rsi,8),%rdx
lea    (%r10,%rsi,8),%rsi
xor    %ebx,%ebx
movupd %xmm0,-0x10(%rsi,%rbx,1)
movupd %xmm0,(%rsi,%rbx,1)
movupd %xmm0,-0x10(%rdx,%rbx,1)
movupd %xmm0,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r15
jne    1ca0 <elemhess+0xb90>
mov    0x18(%rsp),%rdx
mov    %rdx,%r15
cmp    %rcx,%rdx
mov    0x1d0(%rsp),%rbx
je     1ae0 <elemhess+0x9d0>
jmp    1b5e <elemhess+0xa4e>
mov    0x30(%rsp),%rbx
lea    -0x1(%rbx),%eax
cmp    0x90(%rsp),%eax
jle    20bd <elemhess+0xfad>
movslq 0x4(%rsp),%rcx
lea    0x1(%rbx),%r11d
movslq %eax,%rsi
movslq %ebx,%rax
mov    %rax,0x50(%rsp)
movslq 0x90(%rsp),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%rcx),%rax
imul   %rsi,%rax
lea    (%r9,%rax,8),%rdx
mov    %rdx,0x48(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,%rdi
xor    $0xfffffffffffffff8,%rdi
mov    %rdi,0x18(%rsp)
mov    %rcx,%r12
shl    $0x4,%r12
lea    -0x2(%rbx),%edi
mov    %edi,0x40(%rsp)
lea    (%r9,%rsi,8),%rdi
mov    %rdi,0x38(%rsp)
lea    (%r9,%rax,8),%r14
add    $0x30,%r14
add    $0x2,%rax
mov    %rax,0x80(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0x78(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rcx,%rax
imul   %rsi,%rax
lea    (%r9,%rax,8),%r13
add    $0x8,%r13
neg    %rdx
mov    %rdx,0x58(%rsp)
xorpd  %xmm0,%xmm0
lea    0x8(%r9),%rax
mov    %rax,0x88(%rsp)
mov    $0xfffffffffffffffe,%r8
xor    %r15d,%r15d
mov    %ebx,%r10d
mov    %r11,0x20(%rsp)
jmp    1df3 <elemhess+0xce3>
nopl   0x0(%rax)
cltq
add    %rsi,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r9,%rax,8)
add    $0xffffffffffffffff,%rsi
add    $0xffffffff,%r10d
add    $0x1,%r15
addl   $0xffffffff,0x40(%rsp)
addq   $0xfffffffffffffff8,0x38(%rsp)
add    0x18(%rsp),%r14
add    $0x1,%r8
add    0x58(%rsp),%r13
cmp    0x60(%rsp),%rsi
jle    20bd <elemhess+0xfad>
cmp    %ebx,%r10d
jg     1e9d <elemhess+0xd8d>
movslq %r10d,%rax
test   $0x1,%r15b
jne    1e2f <elemhess+0xd1f>
lea    -0x2(%r10),%ecx
movslq %ecx,%rcx
mov    %rax,%rdx
imul   0x8(%rsp),%rdx
add    %rdx,%rcx
mov    0x10(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm1
add    %rsi,%rdx
movsd  %xmm1,(%r9,%rdx,8)
add    $0x1,%rax
test   %r15d,%r15d
je     1e9d <elemhess+0xd8d>
movslq 0x40(%rsp),%rcx
mov    %r11d,%edx
sub    %eax,%edx
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
imul   %rax,%rdi
lea    (%rsi,%rdi,1),%rbp
lea    (%r9,%rbp,8),%rbp
add    %rcx,%rdi
mov    0x10(%rsp),%r11
lea    (%r11,%rdi,8),%rdi
add    $0x1,%rax
imul   %rbx,%rax
mov    0x38(%rsp),%rbx
lea    (%rbx,%rax,8),%rbx
add    %rcx,%rax
lea    (%r11,%rax,8),%rax
mov    0x20(%rsp),%r11
xor    %ecx,%ecx
nopl   (%rax)
movsd  (%rdi,%rcx,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,1)
movsd  (%rax,%rcx,1),%xmm1
movsd  %xmm1,(%rbx,%rcx,1)
add    %r12,%rcx
add    $0xfffffffe,%edx
jne    1e80 <elemhess+0xd70>
mov    0x1d8(%rsp),%rax
mov    (%rax,%rsi,4),%eax
cmp    %esi,%eax
mov    0x30(%rsp),%rbx
je     1dc3 <elemhess+0xcb3>
imul   0x4(%rsp),%eax
cmp    0x50(%rsp),%rsi
jg     1db0 <elemhess+0xca0>
lea    0x2(%r15),%r9
mov    %rsi,%rbx
imul   0x8(%rsp),%rbx
cltq
mov    %rsi,%rdi
cmp    $0x4,%r9
jb     2030 <elemhess+0xf20>
mov    0x18(%rsp),%rcx
imul   %r15,%rcx
add    0x48(%rsp),%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%r15,8),%rdx
add    $0x10,%rdx
lea    (%rsi,%rax,1),%r11
lea    (%rdx,%r11,8),%rdx
cmp    %rdx,%rcx
jae    1f36 <elemhess+0xe26>
mov    %r15,%rcx
imul   0x8(%rsp),%rcx
mov    0x80(%rsp),%rdx
sub    %rcx,%rdx
mov    0x28(%rsp),%rdi
lea    (%rdi,%rdx,8),%rcx
lea    (%rdi,%r11,8),%rdx
mov    %rsi,%rdi
cmp    %rcx,%rdx
jb     2030 <elemhess+0xf20>
lea    -0x2(%r15),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rdx,0x68(%rsp)
cmp    $0x4,%rcx
jae    1f55 <elemhess+0xe45>
xor    %r11d,%r11d
jmp    1fc9 <elemhess+0xeb9>
mov    %r8,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x78(%rsp),%rcx
lea    (%rcx,%r11,8),%rbp
xor    %r11d,%r11d
movups -0x10(%rbp,%r11,8),%xmm1
movups 0x0(%rbp,%r11,8),%xmm2
movups %xmm1,-0x30(%r14,%r11,8)
movups %xmm2,-0x20(%r14,%r11,8)
movupd %xmm0,-0x10(%rbp,%r11,8)
movupd %xmm0,0x0(%rbp,%r11,8)
movupd 0x10(%rbp,%r11,8),%xmm1
movupd 0x20(%rbp,%r11,8),%xmm2
movupd %xmm1,-0x10(%r14,%r11,8)
movupd %xmm2,(%r14,%r11,8)
movupd %xmm0,0x10(%rbp,%r11,8)
movupd %xmm0,0x20(%rbp,%r11,8)
add    $0x8,%r11
add    $0xfffffffffffffffe,%rdx
jne    1f70 <elemhess+0xe60>
mov    %r9,%rdi
and    $0xfffffffffffffffc,%rdi
testb  $0x1,0x68(%rsp)
je     2009 <elemhess+0xef9>
add    %rsi,%r11
lea    (%r11,%rax,1),%rcx
mov    0x28(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm1
movupd 0x10(%rdx,%rcx,8),%xmm2
add    %rbx,%r11
movupd %xmm1,(%rdx,%r11,8)
movupd %xmm2,0x10(%rdx,%r11,8)
movupd %xmm0,(%rdx,%rcx,8)
movupd %xmm0,0x10(%rdx,%rcx,8)
cmp    %rdi,%r9
jne    2022 <elemhess+0xf12>
mov    0x28(%rsp),%r9
mov    0x30(%rsp),%rbx
mov    0x20(%rsp),%r11
jmp    1db2 <elemhess+0xca2>
add    %rsi,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%r11
mov    %r11d,%ecx
sub    %edi,%ecx
test   $0x1,%cl
jne    2044 <elemhess+0xf34>
mov    %rdi,%rdx
jmp    2069 <elemhess+0xf59>
lea    (%rdi,%rax,1),%rcx
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
add    %rdi,%rbx
movsd  %xmm1,(%rdx,%rbx,8)
movq   $0x0,(%rdx,%rcx,8)
mov    %rdi,%rdx
add    $0x1,%rdx
mov    0x30(%rsp),%rbx
cmp    %ebx,%edi
je     20b3 <elemhess+0xfa3>
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
xchg   %ax,%ax
movsd  -0x8(%rcx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdx,8)
movq   $0x0,-0x8(%rcx,%rdx,8)
movsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%r11d
jne    2080 <elemhess+0xf70>
mov    0x28(%rsp),%r9
jmp    1db2 <elemhess+0xca2>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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