#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 **zeros(int, int);
int /*<<< orphan*/ zerosfree(double **, int);
double **MatrixOpp(double **a, int N) {
  double t;
  double **b, **c;
  int i, j, m;
  b = zeros(N, 2 * N);
  c = zeros(N, N);
  for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
      b[i][j] = a[i][j];
  for (i = 0; i < N; i++)
    b[i][N + i] = 1;
  for (m = 0; m < N; m++) {
    t = b[m][m];
    i = m;
    while (b[m][m] == 0) {
      b[m][m] = b[i + 1][m];
      i++;
    }
    if (i > m) {
      b[i][m] = t;
      for (j = 0; j < m; j++) {
        t = b[m][j];
        b[m][j] = b[i][j];
        b[i][j] = t;
      }
      for (j = m + 1; j < 2 * N; j++) {
        t = b[m][j];
        b[m][j] = b[i][j];
        b[i][j] = t;
      }
    }
    for (i = m + 1; i < N; i++) {
      for (j = 2 * N - 1; j >= m; j--)
        b[i][j] = b[i][j] - b[i][m] * b[m][j] / b[m][m];
    }
    for (j = 2 * N - 1; j >= m; j--) {
      b[m][j] = b[m][j] / b[m][m];
    }
  }
  m = N - 1;
  while (m > 0) {
    for (i = 0; i < m; i++)
      for (j = 2 * N - 1; j >= m; j--)
        b[i][j] -= b[i][m] * b[m][j];
    m--;
  }
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; j++) {
      c[i][j] = b[i][N + j];
    }
  }
  zerosfree(b, N);
  return c;
}


x86 assembly (clang, -O0):
<MatrixOpp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%edi
mov    -0xc(%rbp),%esi
shl    $0x1,%esi
call   1040 <zeros@plt>
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%edi
mov    -0xc(%rbp),%esi
call   1040 <zeros@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11c1 <MatrixOpp+0xa1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ae <MatrixOpp+0x8e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116a <MatrixOpp+0x4a>
jmp    11b3 <MatrixOpp+0x93>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1157 <MatrixOpp+0x37>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1204 <MatrixOpp+0xe4>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xe0f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c8 <MatrixOpp+0xa8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ff <MatrixOpp+0x3df>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    129c <MatrixOpp+0x17c>
jp     129c <MatrixOpp+0x17c>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1237 <MatrixOpp+0x117>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    13cc <MatrixOpp+0x2ac>
movsd  -0x18(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1341 <MatrixOpp+0x221>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12c9 <MatrixOpp+0x1a9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    13c7 <MatrixOpp+0x2a7>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x18(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    134a <MatrixOpp+0x22a>
jmp    13cc <MatrixOpp+0x2ac>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1487 <MatrixOpp+0x367>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     1474 <MatrixOpp+0x354>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13ed <MatrixOpp+0x2cd>
jmp    1479 <MatrixOpp+0x359>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d5 <MatrixOpp+0x2b5>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     14ec <MatrixOpp+0x3cc>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1493 <MatrixOpp+0x373>
jmp    14f1 <MatrixOpp+0x3d1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120b <MatrixOpp+0xeb>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    15cf <MatrixOpp+0x4af>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    15c1 <MatrixOpp+0x4a1>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     15ae <MatrixOpp+0x48e>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%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    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1531 <MatrixOpp+0x411>
jmp    15b3 <MatrixOpp+0x493>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1519 <MatrixOpp+0x3f9>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1508 <MatrixOpp+0x3e8>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1645 <MatrixOpp+0x525>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1632 <MatrixOpp+0x512>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15e9 <MatrixOpp+0x4c9>
jmp    1637 <MatrixOpp+0x517>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d6 <MatrixOpp+0x4b6>
mov    -0x20(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <zerosfree@plt>
mov    -0x28(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatrixOpp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %esi,%ebx
mov    %rdi,%r14
lea    (%rbx,%rbx,1),%esi
mov    %ebx,%edi
mov    %esi,0x1c(%rsp)
call   1040 <zeros@plt>
mov    %rax,%r12
mov    %ebx,%edi
mov    %ebx,%esi
call   1040 <zeros@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,0x8(%rsp)
test   %ebx,%ebx
jle    1c30 <MatrixOpp+0xb10>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%r15d
mov    %r15d,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rax
mov    %rax,0x38(%rsp)
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
lea    -0x1(%r15),%r11
mov    %r8d,%r9d
and    $0x3,%r9d
mov    %r8,0x58(%rsp)
and    $0xfffffffffffffffc,%r8
mov    %r15d,%r13d
and    $0x3,%r13d
mov    %r9,%rsi
shl    $0x5,%rsi
xor    %eax,%eax
jmp    11cd <MatrixOpp+0xad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %r15,%rax
je     1340 <MatrixOpp+0x220>
mov    (%r14,%rax,8),%rdx
mov    (%r12,%rax,8),%rbp
cmpl   $0x4,0x8(%rsp)
jb     11f9 <MatrixOpp+0xd9>
lea    (%rdx,%r15,8),%rcx
cmp    %rcx,%rbp
jae    1270 <MatrixOpp+0x150>
lea    0x0(,%r15,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rdx
jae    1270 <MatrixOpp+0x150>
xor    %edi,%edi
mov    %r11,%rcx
sub    %rdi,%rcx
test   %r13,%r13
je     1225 <MatrixOpp+0x105>
mov    %r13,%rbx
nopl   0x0(%rax)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    1210 <MatrixOpp+0xf0>
cmp    $0x3,%rcx
jb     11c0 <MatrixOpp+0xa0>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
movsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rdi,8)
movsd  0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rdi,8)
movsd  0x18(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r15
jne    1230 <MatrixOpp+0x110>
jmp    11c0 <MatrixOpp+0xa0>
nopl   (%rax)
cmpq   $0xc,0x38(%rsp)
jae    127c <MatrixOpp+0x15c>
xor    %edi,%edi
jmp    12ed <MatrixOpp+0x1cd>
mov    %r8,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,8),%xmm0
movups 0x10(%rdx,%rdi,8),%xmm1
movups %xmm0,0x0(%rbp,%rdi,8)
movups %xmm1,0x10(%rbp,%rdi,8)
movups 0x20(%rdx,%rdi,8),%xmm0
movups 0x30(%rdx,%rdi,8),%xmm1
movups %xmm0,0x20(%rbp,%rdi,8)
movups %xmm1,0x30(%rbp,%rdi,8)
movups 0x40(%rdx,%rdi,8),%xmm0
movups 0x50(%rdx,%rdi,8),%xmm1
movups %xmm0,0x40(%rbp,%rdi,8)
movups %xmm1,0x50(%rbp,%rdi,8)
movupd 0x60(%rdx,%rdi,8),%xmm0
movupd 0x70(%rdx,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbp,%rdi,8)
movupd %xmm1,0x70(%rbp,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rcx
jne    1290 <MatrixOpp+0x170>
test   %r9,%r9
je     132f <MatrixOpp+0x20f>
lea    0x10(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%rdx,%rdi,8),%rdi
add    $0x10,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbx,1),%xmm0
movupd (%rdi,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rbx,1)
movupd %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1310 <MatrixOpp+0x1f0>
mov    %r10,%rdi
cmp    %r15,%r10
je     11c0 <MatrixOpp+0xa0>
jmp    11fb <MatrixOpp+0xdb>
cmpl   $0x0,0x8(%rsp)
jle    1c30 <MatrixOpp+0xb10>
mov    %r15d,%eax
and    $0x3,%eax
movabs $0x3ff0000000000000,%rdx
cmp    $0x3,%r11
jae    1365 <MatrixOpp+0x245>
xor    %esi,%esi
jmp    13ab <MatrixOpp+0x28b>
lea    0x0(,%r15,8),%rcx
xor    %esi,%esi
nop
mov    (%r12,%rsi,8),%rdi
add    %rcx,%rdi
mov    %rdx,(%rdi,%rsi,8)
mov    0x8(%r12,%rsi,8),%rdi
add    %rcx,%rdi
mov    %rdx,0x8(%rdi,%rsi,8)
mov    0x10(%r12,%rsi,8),%rdi
add    %rcx,%rdi
mov    %rdx,0x10(%rdi,%rsi,8)
mov    0x18(%r12,%rsi,8),%rdi
add    %rcx,%rdi
mov    %rdx,0x18(%rdi,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    1370 <MatrixOpp+0x250>
test   %rax,%rax
je     13e5 <MatrixOpp+0x2c5>
lea    0x0(,%r15,8),%rcx
lea    (%rcx,%rsi,8),%rcx
lea    (%r12,%rsi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rdi,8),%rbp
add    %rcx,%rbp
mov    %rdx,0x0(%rbp,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    13d0 <MatrixOpp+0x2b0>
cmpl   $0x0,0x8(%rsp)
jle    1c30 <MatrixOpp+0xb10>
mov    0x1c(%rsp),%eax
movslq %eax,%rsi
mov    %eax,%r13d
mov    %r13,%rax
neg    %rax
mov    %rax,0x60(%rsp)
lea    -0x1(%rsi),%r14
mov    %rsi,%r8
neg    %r8
lea    -0x5(%r13),%rax
mov    %rax,0x50(%rsp)
mov    $0x1,%ebp
mov    $0x7,%eax
mov    %rax,0x48(%rsp)
xor    %edi,%edi
xorpd  %xmm0,%xmm0
xor    %r11d,%r11d
mov    %r13,0x30(%rsp)
mov    %r14,0x20(%rsp)
jmp    145d <MatrixOpp+0x33d>
nopl   0x0(%rax)
add    $0x1,%rbp
add    $0x1,%rdi
addq   $0x1,0x48(%rsp)
addq   $0xffffffffffffffff,0x50(%rsp)
cmp    %r15,%r11
je     19a7 <MatrixOpp+0x887>
mov    %r11,%r9
mov    (%r12,%r11,8),%r10
lea    (%r10,%r11,8),%rcx
movsd  (%r10,%r11,8),%xmm1
ucomisd %xmm0,%xmm1
mov    %r11,%rax
jne    149b <MatrixOpp+0x37b>
jp     149b <MatrixOpp+0x37b>
mov    %r9,%rax
nopl   0x0(%rax)
mov    0x8(%r12,%rax,8),%rdx
add    $0x1,%rax
movsd  (%rdx,%r9,8),%xmm2
movsd  %xmm2,(%rcx)
ucomisd %xmm0,%xmm2
jne    149b <MatrixOpp+0x37b>
jnp    1480 <MatrixOpp+0x360>
mov    %eax,%eax
cmp    %r9,%rax
mov    %rbp,0x10(%rsp)
mov    %rdi,0x70(%rsp)
jbe    1570 <MatrixOpp+0x450>
mov    (%r12,%rax,8),%r14
movsd  %xmm1,(%r14,%r9,8)
test   %r9,%r9
je     1680 <MatrixOpp+0x560>
cmp    $0x4,%r9
jb     14df <MatrixOpp+0x3bf>
lea    (%r14,%r9,8),%rax
cmp    %rax,%r10
jae    1582 <MatrixOpp+0x462>
cmp    %rcx,%r14
jae    1582 <MatrixOpp+0x462>
xor    %eax,%eax
mov    %rax,%rdx
or     $0x1,%rdx
test   $0x1,%r9b
je     1509 <MatrixOpp+0x3e9>
movsd  (%r10,%rax,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
movsd  %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
cmp    %rdx,%r9
je     1680 <MatrixOpp+0x560>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r10,%rax,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm1
movsd  0x8(%r14,%rax,8),%xmm2
movsd  %xmm2,0x8(%r10,%rax,8)
movsd  %xmm1,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1520 <MatrixOpp+0x400>
jmp    1680 <MatrixOpp+0x560>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%r9),%r11
cmp    %r15,%r11
jl     185b <MatrixOpp+0x73b>
jmp    1920 <MatrixOpp+0x800>
mov    %rdi,%r11
mov    %rbp,%rbx
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     1996 <MatrixOpp+0x876>
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
lea    0x2(%rdx),%rdi
and    %rbp,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups (%r10,%rdx,8),%xmm1
movups 0x10(%r10,%rdx,8),%xmm2
movups (%r14,%rdx,8),%xmm3
movups 0x10(%r14,%rdx,8),%xmm4
movups %xmm3,(%r10,%rdx,8)
movups %xmm4,0x10(%r10,%rdx,8)
movups %xmm1,(%r14,%rdx,8)
movups %xmm2,0x10(%r14,%rdx,8)
movupd 0x20(%r10,%rdx,8),%xmm1
movupd 0x30(%r10,%rdx,8),%xmm2
movupd 0x20(%r14,%rdx,8),%xmm3
movups 0x30(%r14,%rdx,8),%xmm4
movupd %xmm3,0x20(%r10,%rdx,8)
movups %xmm4,0x30(%r10,%rdx,8)
movupd %xmm1,0x20(%r14,%rdx,8)
movupd %xmm2,0x30(%r14,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    15c0 <MatrixOpp+0x4a0>
test   $0x1,%bpl
je     1664 <MatrixOpp+0x544>
movupd (%r10,%rdx,8),%xmm1
movupd 0x10(%r10,%rdx,8),%xmm2
movupd (%r14,%rdx,8),%xmm3
movups 0x10(%r14,%rdx,8),%xmm4
movupd %xmm3,(%r10,%rdx,8)
movups %xmm4,0x10(%r10,%rdx,8)
movupd %xmm1,(%r14,%rdx,8)
movupd %xmm2,0x10(%r14,%rdx,8)
cmp    %rax,%r9
mov    %rbx,%rbp
mov    %r11,%rdi
jne    14e1 <MatrixOpp+0x3c1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r9),%r11
cmp    %rsi,%r11
jge    184d <MatrixOpp+0x72d>
mov    %rdi,%rax
not    %rax
lea    (%rax,%r13,1),%rdx
mov    %r13,%rbx
mov    %rbp,%r13
mov    %rdx,0x68(%rsp)
cmp    $0x4,%rdx
jb     17d0 <MatrixOpp+0x6b0>
lea    (%r10,%rbp,8),%rdx
lea    (%r14,%rbx,8),%rdi
cmp    %rdi,%rdx
jae    16cd <MatrixOpp+0x5ad>
lea    (%r10,%rbx,8),%rdx
lea    (%r14,%rbp,8),%rdi
mov    %rbp,%r13
cmp    %rdx,%rdi
jb     17d0 <MatrixOpp+0x6b0>
add    %rbx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
cmp    $0x4,%rax
jae    16ec <MatrixOpp+0x5cc>
xor    %ebp,%ebp
jmp    176c <MatrixOpp+0x64c>
mov    0x50(%rsp),%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x48(%rsp),%rax
lea    (%r14,%rax,8),%rdi
lea    (%r10,%rax,8),%rax
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x30(%rax,%rbp,8),%xmm1
movups -0x20(%rax,%rbp,8),%xmm2
movups -0x30(%rdi,%rbp,8),%xmm3
movups -0x20(%rdi,%rbp,8),%xmm4
movups %xmm3,-0x30(%rax,%rbp,8)
movups %xmm4,-0x20(%rax,%rbp,8)
movups %xmm1,-0x30(%rdi,%rbp,8)
movups %xmm2,-0x20(%rdi,%rbp,8)
movupd -0x10(%rax,%rbp,8),%xmm1
movupd (%rax,%rbp,8),%xmm2
movupd -0x10(%rdi,%rbp,8),%xmm3
movups (%rdi,%rbp,8),%xmm4
movupd %xmm3,-0x10(%rax,%rbp,8)
movups %xmm4,(%rax,%rbp,8)
movupd %xmm1,-0x10(%rdi,%rbp,8)
movupd %xmm2,(%rdi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1710 <MatrixOpp+0x5f0>
mov    0x68(%rsp),%rax
mov    %rax,%r13
and    $0xfffffffffffffffc,%r13
test   $0x1,%bl
je     17b4 <MatrixOpp+0x694>
add    0x10(%rsp),%rbp
movupd (%r10,%rbp,8),%xmm1
movupd 0x10(%r10,%rbp,8),%xmm2
movupd (%r14,%rbp,8),%xmm3
movups 0x10(%r14,%rbp,8),%xmm4
movupd %xmm3,(%r10,%rbp,8)
movups %xmm4,0x10(%r10,%rbp,8)
movupd %xmm1,(%r14,%rbp,8)
movupd %xmm2,0x10(%r14,%rbp,8)
cmp    %r13,%rax
jne    17c3 <MatrixOpp+0x6a3>
mov    0x30(%rsp),%r13
jmp    184d <MatrixOpp+0x72d>
mov    0x10(%rsp),%rbp
add    %rbp,%r13
nopl   0x0(%rax,%rax,1)
mov    %r13,%rax
test   $0x1,%r13b
je     17f5 <MatrixOpp+0x6d5>
movsd  (%r10,%r13,8),%xmm1
movsd  (%r14,%r13,8),%xmm2
movsd  %xmm2,(%r10,%r13,8)
movsd  %xmm1,(%r14,%r13,8)
lea    0x1(%r13),%rax
not    %r13
cmp    0x60(%rsp),%r13
mov    0x30(%rsp),%r13
je     184d <MatrixOpp+0x72d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r10,%rax,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
movsd  %xmm2,(%r10,%rax,8)
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm1
movsd  0x8(%r14,%rax,8),%xmm2
movsd  %xmm2,0x8(%r10,%rax,8)
movsd  %xmm1,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1810 <MatrixOpp+0x6f0>
mov    0x20(%rsp),%r14
cmp    %r15,%r11
jge    1920 <MatrixOpp+0x800>
mov    %r9,%rax
not    %rax
mov    0x10(%rsp),%rbp
jmp    187d <MatrixOpp+0x75d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r15,%rbp
je     1920 <MatrixOpp+0x800>
cmp    %rsi,%r9
jge    1870 <MatrixOpp+0x750>
mov    (%r12,%rbp,8),%rdx
mov    %rsi,%rdi
test   $0x1,%r9b
je     18b5 <MatrixOpp+0x795>
movsd  -0x8(%rdx,%rsi,8),%xmm1
movsd  (%rdx,%r9,8),%xmm2
mulsd  -0x8(%r10,%rsi,8),%xmm2
divsd  (%r10,%r9,8),%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%rdx,%rsi,8)
mov    %r14,%rdi
cmp    %r8,%rax
je     1870 <MatrixOpp+0x750>
nopw   0x0(%rax,%rax,1)
movsd  -0x10(%rdx,%rdi,8),%xmm1
movsd  (%rdx,%r9,8),%xmm2
mulsd  -0x8(%r10,%rdi,8),%xmm2
divsd  (%r10,%r9,8),%xmm2
movsd  -0x8(%rdx,%rdi,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rdx,%rdi,8)
movsd  (%rdx,%r9,8),%xmm2
mulsd  -0x10(%r10,%rdi,8),%xmm2
divsd  (%r10,%r9,8),%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,-0x10(%rdx,%rdi,8)
lea    -0x2(%rdi),%rbx
mov    %rbx,%rdi
cmp    %r9,%rbx
jg     18c0 <MatrixOpp+0x7a0>
jmp    1870 <MatrixOpp+0x750>
nopw   0x0(%rax,%rax,1)
cmp    %rsi,%r9
mov    0x10(%rsp),%rbp
mov    0x70(%rsp),%rdi
jge    1440 <MatrixOpp+0x320>
mov    %rsi,%rax
test   $0x1,%r9b
je     1951 <MatrixOpp+0x831>
movsd  -0x8(%r10,%rsi,8),%xmm1
divsd  (%rcx),%xmm1
movsd  %xmm1,-0x8(%r10,%rsi,8)
mov    %r14,%rax
mov    %r9,%rcx
not    %rcx
cmp    %r8,%rcx
je     1440 <MatrixOpp+0x320>
movsd  -0x8(%r10,%rax,8),%xmm1
divsd  (%r10,%r9,8),%xmm1
movsd  -0x10(%r10,%rax,8),%xmm2
movsd  %xmm1,-0x8(%r10,%rax,8)
divsd  (%r10,%r9,8),%xmm2
movsd  %xmm2,-0x10(%r10,%rax,8)
add    $0xfffffffffffffffe,%rax
cmp    %r9,%rax
jg     1960 <MatrixOpp+0x840>
jmp    1440 <MatrixOpp+0x320>
xor    %edx,%edx
test   $0x1,%bpl
jne    1632 <MatrixOpp+0x512>
jmp    1664 <MatrixOpp+0x544>
cmpl   $0x2,0x8(%rsp)
jl     1a36 <MatrixOpp+0x916>
movslq 0x1c(%rsp),%r9
mov    0x8(%rsp),%rax
lea    -0x1(%rax),%edx
lea    0x1(%r9),%r8
mov    %r15,%rcx
jmp    19da <MatrixOpp+0x8ba>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdx
cmp    $0x3,%rdi
jl     1a36 <MatrixOpp+0x916>
mov    %rcx,%rdi
add    $0xffffffffffffffff,%rcx
xor    %ebp,%ebp
jmp    19f9 <MatrixOpp+0x8d9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rdx,%rbp
je     19d0 <MatrixOpp+0x8b0>
cmp    %r9,%rdi
jg     19f0 <MatrixOpp+0x8d0>
mov    (%r12,%rbp,8),%rbx
mov    (%r12,%rcx,8),%rsi
mov    %r8,%rax
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm0
movsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  -0x10(%rsi,%rax,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rbx,%rax,8)
add    $0xffffffffffffffff,%rax
cmp    %rdi,%rax
jg     1a10 <MatrixOpp+0x8f0>
jmp    19f0 <MatrixOpp+0x8d0>
cmpl   $0x0,0x8(%rsp)
jle    1c30 <MatrixOpp+0xb10>
lea    (%r15,%r15,1),%r11
mov    %r15d,%r14d
and    $0xfffffffc,%r14d
mov    0x58(%rsp),%rax
mov    %eax,%r9d
and    $0x3,%r9d
and    %rax,0x28(%rsp)
mov    %r15d,%r8d
and    $0x3,%r8d
lea    0xe(%r15),%rax
mov    %rax,0x10(%rsp)
mov    %r9,%rsi
shl    $0x5,%rsi
lea    0x3(%r15),%r10
xor    %ebp,%ebp
jmp    1a8d <MatrixOpp+0x96d>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    %r15,%rbp
je     1c30 <MatrixOpp+0xb10>
mov    (%r12,%rbp,8),%r13
mov    0x40(%rsp),%rax
mov    (%rax,%rbp,8),%rax
cmpl   $0x4,0x8(%rsp)
jb     1abe <MatrixOpp+0x99e>
lea    0x0(,%r11,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rax
jae    1b50 <MatrixOpp+0xa30>
cmp    %rax,%r13
jae    1b50 <MatrixOpp+0xa30>
xor    %edi,%edi
mov    %rdi,%rcx
not    %rcx
add    %r15,%rcx
test   %r8,%r8
je     1af4 <MatrixOpp+0x9d4>
lea    0x0(,%r15,8),%rdx
add    %r13,%rdx
mov    %r8,%rbx
nopl   0x0(%rax)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbx
jne    1ae0 <MatrixOpp+0x9c0>
cmp    $0x3,%rcx
jb     1a80 <MatrixOpp+0x960>
lea    0x0(,%r10,8),%rcx
add    %r13,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x18(%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rdi,8)
movsd  -0x10(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rax,%rdi,8)
movsd  -0x8(%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x10(%rax,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,0x18(%rax,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r15
jne    1b10 <MatrixOpp+0x9f0>
jmp    1a80 <MatrixOpp+0x960>
nopl   0x0(%rax)
cmpq   $0xc,0x38(%rsp)
jae    1b5f <MatrixOpp+0xa3f>
xor    %edi,%edi
jmp    1bdc <MatrixOpp+0xabc>
mov    0x10(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
mov    0x28(%rsp),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x70(%rcx,%rdi,8),%xmm0
movups -0x60(%rcx,%rdi,8),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
movups -0x50(%rcx,%rdi,8),%xmm0
movups -0x40(%rcx,%rdi,8),%xmm1
movups %xmm0,0x20(%rax,%rdi,8)
movups %xmm1,0x30(%rax,%rdi,8)
movups -0x30(%rcx,%rdi,8),%xmm0
movups -0x20(%rcx,%rdi,8),%xmm1
movups %xmm0,0x40(%rax,%rdi,8)
movups %xmm1,0x50(%rax,%rdi,8)
movupd -0x10(%rcx,%rdi,8),%xmm0
movupd (%rcx,%rdi,8),%xmm1
movupd %xmm0,0x60(%rax,%rdi,8)
movupd %xmm1,0x70(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rdx
jne    1b80 <MatrixOpp+0xa60>
test   %r9,%r9
je     1c1f <MatrixOpp+0xaff>
lea    (%rax,%rdi,8),%rcx
add    $0x10,%rcx
add    %r15,%rdi
lea    0x10(,%rdi,8),%rdx
add    %r13,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdi,1)
movupd %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1c00 <MatrixOpp+0xae0>
mov    %r14,%rdi
cmp    %r15,%r14
je     1a80 <MatrixOpp+0x960>
jmp    1ac0 <MatrixOpp+0x9a0>
mov    %r12,%rdi
mov    0x8(%rsp),%rsi
call   1030 <zerosfree@plt>
mov    0x40(%rsp),%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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