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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
void m_inv3(double mat[3][3], double id[3][3]) {
  const double Epsilon = 0.0000001;
  int i, j, s = 0, pindex, pivot = 1;
  double f, Maximum, h;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++) {
      if (i == j)
        id[i][j] = 1.0;
      else
        id[i][j] = 0.;
    }
  do {
    Maximum = fabs(mat[s][s]);
    if (pivot) {
      pindex = s;
      for (i = s + 1; i < 3; i++)
        if (fabs(mat[i][s]) > Maximum) {
          Maximum = fabs(mat[i][s]);
          pindex = i;
        }
    }
    if (Maximum < Epsilon)
      break;
    if (pivot) {
      if (pindex != s) {
        for (j = s; j < 3; j++) {
          h = mat[s][j];
          mat[s][j] = mat[pindex][j];
          mat[pindex][j] = h;
        }
        for (j = 0; j < 3; j++) {
          h = id[s][j];
          id[s][j] = id[pindex][j];
          id[pindex][j] = h;
        }
      }
    }
    f = mat[s][s];
    for (j = s; j < 3; j++)
      mat[s][j] = mat[s][j] / f;
    for (j = 0; j < 3; j++)
      id[s][j] = id[s][j] / f;
    for (i = 0; i < 3; i++) {
      if (i != s) {
        f = -mat[i][s];
        for (j = s; j < 3; j++)
          mat[i][j] += f * mat[s][j];
        for (j = 0; j < 3; j++)
          id[i][j] += f * id[s][j];
      }
    }
    s++;
  } while (s < 3);
}


x86 assembly (clang, -O0):
<m_inv3>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  0xeec(%rip),%xmm0
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    11bb <m_inv3+0xbb>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    11a8 <m_inv3+0xa8>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    117a <m_inv3+0x7a>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  0xe98(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1195 <m_inv3+0x95>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    119a <m_inv3+0x9a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113f <m_inv3+0x3f>
jmp    11ad <m_inv3+0xad>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112e <m_inv3+0x2e>
jmp    11c0 <m_inv3+0xc0>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe31(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     127f <m_inv3+0x17f>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    127a <m_inv3+0x17a>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xde6(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1267 <m_inv3+0x167>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xdb8(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    126c <m_inv3+0x16c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1201 <m_inv3+0x101>
jmp    127f <m_inv3+0x17f>
movsd  0xd79(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1297 <m_inv3+0x197>
jmp    15c9 <m_inv3+0x4c9>
cmpl   $0x0,-0x2c(%rbp)
je     13c8 <m_inv3+0x2c8>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     13c3 <m_inv3+0x2c3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1335 <m_inv3+0x235>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12b3 <m_inv3+0x1b3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    13be <m_inv3+0x2be>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    133c <m_inv3+0x23c>
jmp    13c3 <m_inv3+0x2c3>
jmp    13c8 <m_inv3+0x2c8>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    1438 <m_inv3+0x338>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13eb <m_inv3+0x2eb>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    148c <m_inv3+0x38c>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    143f <m_inv3+0x33f>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    15b6 <m_inv3+0x4b6>
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     15a3 <m_inv3+0x4a3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    153d <m_inv3+0x43d>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14e3 <m_inv3+0x3e3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    159e <m_inv3+0x49e>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1544 <m_inv3+0x444>
jmp    15a3 <m_inv3+0x4a3>
jmp    15a8 <m_inv3+0x4a8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1493 <m_inv3+0x393>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jl     11c0 <m_inv3+0xc0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_inv3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%r15
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rsi)
xorpd  %xmm0,%xmm0
movupd %xmm0,0x8(%rsi)
movq   $0x0,0x18(%rsi)
mov    %rax,0x20(%rsi)
movupd %xmm0,0x28(%rsi)
movq   $0x0,0x38(%rsi)
mov    %rax,0x40(%rsi)
lea    0x30(%rdi),%rax
mov    %rax,-0x10(%rsp)
lea    0x18(%rdi),%rax
mov    %rax,-0x18(%rsp)
lea    0x38(%rdi),%rdx
lea    0x8(%rdi),%r13
lea    0x20(%rdi),%r12
mov    %r12,-0x8(%rsp)
movq   $0xfffffffffffffffe,-0x20(%rsp)
ff ff
xor    %eax,%eax
mov    %rax,-0x38(%rsp)
movapd 0xe84(%rip),%xmm9
movsd  0xe9b(%rip),%xmm8
movapd 0xe83(%rip),%xmm2
mov    %r13,%rcx
xor    %r9d,%r9d
mov    %r13,-0x68(%rsp)
mov    %rsi,-0x28(%rsp)
jmp    11f9 <m_inv3+0xf9>
nop
movupd (%r11),%xmm0
movupd 0x30(%rsi),%xmm1
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,0x30(%rsi)
mulsd  0x10(%r11),%xmm3
addsd  0x40(%rsi),%xmm3
movsd  %xmm3,0x40(%rsi)
add    $0x1,%r9
addq   $0xffffffffffffffff,-0x20(%rsp)
add    $0x8,%rdx
add    $0x20,%rcx
add    $0x18,%rdi
addq   $0xffffffffffffffff,-0x38(%rsp)
add    $0x8,%r12
cmp    $0x3,%r9
je     1bb6 <m_inv3+0xab6>
lea    (%r9,%r9,2),%r14
lea    (%r15,%r14,8),%rax
mov    %rax,-0x70(%rsp)
movsd  (%rax,%r9,8),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm9,%xmm4
cmp    $0x1,%r9
ja     1260 <m_inv3+0x160>
lea    0x1(%r9),%rax
lea    (%rax,%rax,2),%rbp
lea    (%r15,%rbp,8),%rbp
movsd  0x0(%rbp,%r9,8),%xmm5
andpd  %xmm9,%xmm5
ucomisd %xmm4,%xmm5
cmovbe %r9d,%eax
maxsd  %xmm4,%xmm5
test   %r9,%r9
je     126f <m_inv3+0x16f>
movapd %xmm5,%xmm4
ucomisd %xmm4,%xmm8
jbe    12a0 <m_inv3+0x1a0>
jmp    1bb6 <m_inv3+0xab6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9d,%eax
ucomisd %xmm4,%xmm8
jbe    12a0 <m_inv3+0x1a0>
jmp    1bb6 <m_inv3+0xab6>
movsd  0x30(%r15,%r9,8),%xmm4
andpd  %xmm9,%xmm4
ucomisd %xmm5,%xmm4
mov    $0x2,%ebp
cmova  %ebp,%eax
maxsd  %xmm5,%xmm4
ucomisd %xmm4,%xmm8
ja     1bb6 <m_inv3+0xab6>
cs nopw 0x0(%rax,%rax,1)
mov    -0x20(%rsp),%r10
shr    $0x2,%r10
mov    $0xfffffffffffffffe,%rbp
sub    %r9,%rbp
add    $0x1,%r10
shr    $0x2,%rbp
and    $0xfffffffffffffffe,%r10
add    $0x1,%rbp
mov    %rbp,-0x60(%rsp)
mov    %r9,%rbp
shl    $0x5,%rbp
mov    $0x2,%r8d
sub    %r9,%r8
add    %r15,%rbp
add    $0x8,%rbp
mov    %rbp,-0x50(%rsp)
lea    0x18(%r15,%r14,8),%rbp
mov    %rbp,-0x58(%rsp)
lea    (%r15,%r9,8),%rbp
add    $0x8,%rbp
mov    %rbp,-0x30(%rsp)
mov    %eax,%ebp
cmp    %rbp,%r9
mov    %r8,-0x78(%rsp)
jne    1320 <m_inv3+0x220>
mov    -0x70(%rsp),%rsi
jmp    1551 <m_inv3+0x451>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cltq
lea    (%rax,%rax,2),%rbp
mov    %rbp,-0x40(%rsp)
lea    (%r15,%rbp,8),%r13
movsd  0x0(%r13,%r9,8),%xmm4
mov    -0x70(%rsp),%rsi
movsd  %xmm4,(%rsi,%r9,8)
movsd  %xmm3,0x0(%r13,%r9,8)
lea    0x1(%r9),%r11
mov    %r11,-0x48(%rsp)
cmp    $0x3,%r11
je     150c <m_inv3+0x40c>
cmp    $0x4,%r8
jb     1480 <m_inv3+0x380>
shl    $0x3,%rax
lea    (%rax,%rax,2),%rax
mov    -0x30(%rsp),%rbx
lea    (%rbx,%rax,1),%rsi
add    %r15,%rax
add    $0x18,%rax
mov    -0x50(%rsp),%rbx
cmp    %rax,%rbx
setb   %r8b
mov    -0x58(%rsp),%rbp
cmp    %rbp,%rsi
setb   %al
and    %r8b,%al
jne    1477 <m_inv3+0x377>
cmp    %rbp,%rbx
mov    -0x70(%rsp),%rsi
jb     1480 <m_inv3+0x380>
test   %al,%al
jne    1480 <m_inv3+0x380>
mov    -0x78(%rsp),%r11
and    $0xfffffffffffffffc,%r11
add    %r11,-0x48(%rsp)
mov    -0x40(%rsp),%rax
lea    (%rdx,%rax,8),%rbx
xor    %eax,%eax
mov    %r10,%rbp
nop
movups (%rcx,%rax,1),%xmm3
movups 0x10(%rcx,%rax,1),%xmm4
movups -0x30(%rbx,%rax,1),%xmm5
movups -0x20(%rbx,%rax,1),%xmm6
movups %xmm5,(%rcx,%rax,1)
movups %xmm6,0x10(%rcx,%rax,1)
movups %xmm3,-0x30(%rbx,%rax,1)
movups %xmm4,-0x20(%rbx,%rax,1)
movupd 0x20(%rcx,%rax,1),%xmm3
movupd 0x30(%rcx,%rax,1),%xmm4
movupd -0x10(%rbx,%rax,1),%xmm5
movupd (%rbx,%rax,1),%xmm6
movupd %xmm5,0x20(%rcx,%rax,1)
movupd %xmm6,0x30(%rcx,%rax,1)
movupd %xmm3,-0x10(%rbx,%rax,1)
movupd %xmm4,(%rbx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbp
jne    13d0 <m_inv3+0x2d0>
testb  $0x1,-0x60(%rsp)
mov    -0x70(%rsp),%rsi
je     1468 <m_inv3+0x368>
movupd (%rcx,%rax,1),%xmm3
movupd 0x10(%rcx,%rax,1),%xmm4
movupd -0x30(%rax,%rbx,1),%xmm5
movupd -0x20(%rax,%rbx,1),%xmm6
movupd %xmm5,(%rcx,%rax,1)
movupd %xmm6,0x10(%rcx,%rax,1)
movupd %xmm3,-0x30(%rax,%rbx,1)
movupd %xmm4,-0x20(%rax,%rbx,1)
mov    -0x78(%rsp),%r8
cmp    %r11,%r8
jne    1480 <m_inv3+0x380>
jmp    150c <m_inv3+0x40c>
mov    -0x70(%rsp),%rsi
nopl   0x0(%rax)
mov    $0x1,%ebx
mov    -0x48(%rsp),%r11
sub    %r11d,%ebx
mov    %r11,%rax
test   $0x1,%bl
je     14b3 <m_inv3+0x3b3>
movsd  (%rsi,%r11,8),%xmm3
movsd  0x0(%r13,%r11,8),%xmm4
movsd  %xmm4,(%rsi,%r11,8)
movsd  %xmm3,0x0(%r13,%r11,8)
lea    0x1(%r11),%rax
cmp    $0x2,%r11
mov    -0x78(%rsp),%r8
je     150c <m_inv3+0x40c>
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rdi,%rax,8),%xmm3
movsd  -0x8(%r13,%rax,8),%xmm4
movsd  %xmm4,-0x8(%rdi,%rax,8)
movsd  %xmm3,-0x8(%r13,%rax,8)
movsd  (%rdi,%rax,8),%xmm3
movsd  0x0(%r13,%rax,8),%xmm4
movsd  %xmm4,(%rdi,%rax,8)
movsd  %xmm3,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    $0x4,%rax
jne    14d0 <m_inv3+0x3d0>
lea    (%rsi,%r9,8),%rax
mov    -0x40(%rsp),%rbp
mov    -0x28(%rsp),%rbx
movsd  0x10(%rbx,%rbp,8),%xmm3
movups (%rbx,%rbp,8),%xmm4
movupd (%rbx,%r14,8),%xmm5
movups %xmm4,(%rbx,%r14,8)
movupd %xmm5,(%rbx,%rbp,8)
movsd  0x10(%rbx,%r14,8),%xmm4
movsd  %xmm3,0x10(%rbx,%r14,8)
movsd  %xmm4,0x10(%rbx,%rbp,8)
movsd  (%rax),%xmm3
mov    -0x68(%rsp),%r13
movapd %xmm3,%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%r9,8)
lea    0x1(%r9),%rax
cmp    $0x3,%rax
mov    -0x28(%rsp),%rsi
je     1628 <m_inv3+0x528>
cmp    $0x2,%r8
jb     1610 <m_inv3+0x510>
mov    %r9,%rbx
neg    %rbx
mov    %rbx,%r11
shr    %r11
add    $0x1,%r11
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmp    $0x2,%rbx
jae    159e <m_inv3+0x49e>
xor    %ebx,%ebx
jmp    15d8 <m_inv3+0x4d8>
mov    -0x38(%rsp),%rbp
shr    %rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
movupd (%rcx,%rbx,8),%xmm5
movupd 0x10(%rcx,%rbx,8),%xmm6
divpd  %xmm4,%xmm5
movupd %xmm5,(%rcx,%rbx,8)
divpd  %xmm4,%xmm6
movupd %xmm6,0x10(%rcx,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rbp
jne    15b0 <m_inv3+0x4b0>
mov    -0x78(%rsp),%rbp
and    $0xfffffffffffffffe,%rbp
test   $0x1,%r11b
je     15ff <m_inv3+0x4ff>
add    %rax,%rbx
mov    -0x70(%rsp),%r11
movupd (%r11,%rbx,8),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%r11,%rbx,8)
mov    -0x78(%rsp),%r8
cmp    %rbp,%r8
je     1628 <m_inv3+0x528>
add    %rbp,%rax
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rdi,%rax,8)
add    $0x1,%rax
cmp    $0x3,%rax
jne    1610 <m_inv3+0x510>
lea    (%rsi,%r14,8),%r11
movupd (%rsi,%r14,8),%xmm4
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
divpd  %xmm5,%xmm4
movupd %xmm4,(%rsi,%r14,8)
movsd  0x10(%rsi,%r14,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,0x10(%rsi,%r14,8)
test   %r9,%r9
mov    -0x70(%rsp),%r14
je     1860 <m_inv3+0x760>
movsd  (%r15,%r9,8),%xmm4
movapd %xmm4,%xmm3
xorpd  %xmm2,%xmm3
movsd  (%r14,%r9,8),%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r15,%r9,8)
lea    0x1(%r9),%rbp
cmp    $0x3,%rbp
je     1829 <m_inv3+0x729>
cmp    $0x4,%r8
jb     17b0 <m_inv3+0x6b0>
mov    -0x30(%rsp),%rbx
cmp    -0x58(%rsp),%rbx
setb   %r8b
mov    -0x18(%rsp),%rax
cmp    %rax,-0x50(%rsp)
setb   %r14b
cmp    %rax,%rbx
jb     17aa <m_inv3+0x6aa>
and    %r14b,%r8b
mov    -0x70(%rsp),%r14
jne    17b0 <m_inv3+0x6b0>
mov    -0x78(%rsp),%r13
and    $0xfffffffffffffffc,%r13
add    %r13,%rbp
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    %r10,%rbx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rax,1),%xmm5
movupd 0x10(%rcx,%rax,1),%xmm6
mulpd  %xmm4,%xmm5
movupd -0x30(%rdx,%rax,1),%xmm7
addpd  %xmm5,%xmm7
movupd -0x20(%rdx,%rax,1),%xmm5
movupd -0x10(%rdx,%rax,1),%xmm1
movupd (%rdx,%rax,1),%xmm0
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm7,-0x30(%rdx,%rax,1)
movupd %xmm6,-0x20(%rdx,%rax,1)
movupd 0x20(%rcx,%rax,1),%xmm5
movupd 0x30(%rcx,%rax,1),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm0,%xmm6
movupd %xmm5,-0x10(%rdx,%rax,1)
movupd %xmm6,(%rdx,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbx
jne    16f0 <m_inv3+0x5f0>
testb  $0x1,-0x60(%rsp)
je     1799 <m_inv3+0x699>
movupd -0x30(%rdx,%rax,1),%xmm0
movupd -0x20(%rdx,%rax,1),%xmm1
movupd (%rcx,%rax,1),%xmm5
movupd 0x10(%rcx,%rax,1),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm0,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm5,-0x30(%rdx,%rax,1)
movupd %xmm6,-0x20(%rdx,%rax,1)
mov    -0x78(%rsp),%r8
cmp    %r13,%r8
mov    -0x68(%rsp),%r13
jne    17b0 <m_inv3+0x6b0>
jmp    1829 <m_inv3+0x729>
mov    -0x70(%rsp),%r14
nop
mov    $0x1,%ebx
sub    %ebp,%ebx
mov    %rbp,%rax
test   $0x1,%bl
je     17d9 <m_inv3+0x6d9>
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
lea    0x1(%rbp),%rax
cmp    $0x2,%rbp
mov    -0x78(%rsp),%r8
je     1829 <m_inv3+0x729>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  -0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    $0x3,%rax
jne    17f0 <m_inv3+0x6f0>
movupd (%r11),%xmm0
movupd (%rsi),%xmm1
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
mulsd  0x10(%r11),%xmm3
movupd %xmm4,(%rsi)
addsd  0x10(%rsi),%xmm3
movsd  %xmm3,0x10(%rsi)
cmp    $0x1,%r9
je     1a7c <m_inv3+0x97c>
movsd  0x18(%r15,%r9,8),%xmm0
movapd %xmm0,%xmm3
xorpd  %xmm2,%xmm3
movsd  (%r14,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%r15,%r9,8)
lea    0x1(%r9),%rbp
cmp    $0x3,%rbp
je     1a43 <m_inv3+0x943>
cmp    $0x4,%r8
jb     19d0 <m_inv3+0x8d0>
lea    (%r15,%r9,8),%rax
add    $0x20,%rax
cmp    -0x58(%rsp),%rax
setb   %r8b
mov    -0x10(%rsp),%rbx
cmp    %rbx,-0x50(%rsp)
setb   %r13b
cmp    %rbx,%rax
jb     19be <m_inv3+0x8be>
and    %r13b,%r8b
mov    -0x78(%rsp),%r13
mov    -0x70(%rsp),%r14
jne    19b7 <m_inv3+0x8b7>
and    $0xfffffffffffffffc,%r13
add    %r13,%rbp
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mov    %r10,%rbx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rax,1),%xmm0
movupd 0x10(%rcx,%rax,1),%xmm1
mulpd  %xmm4,%xmm0
movupd (%r12,%rax,1),%xmm5
addpd  %xmm0,%xmm5
movupd 0x10(%r12,%rax,1),%xmm0
movupd 0x20(%r12,%rax,1),%xmm6
movupd 0x30(%r12,%rax,1),%xmm7
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm5,(%r12,%rax,1)
movupd %xmm1,0x10(%r12,%rax,1)
movupd 0x20(%rcx,%rax,1),%xmm0
movupd 0x30(%rcx,%rax,1),%xmm1
mulpd  %xmm4,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm0,0x20(%r12,%rax,1)
movupd %xmm1,0x30(%r12,%rax,1)
add    $0x40,%rax
add    $0xfffffffffffffffe,%rbx
jne    18f0 <m_inv3+0x7f0>
testb  $0x1,-0x60(%rsp)
je     19a3 <m_inv3+0x8a3>
movupd (%r12,%rax,1),%xmm0
movupd 0x10(%r12,%rax,1),%xmm1
movupd (%rcx,%rax,1),%xmm5
movupd 0x10(%rcx,%rax,1),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm0,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm5,(%r12,%rax,1)
movupd %xmm6,0x10(%r12,%rax,1)
mov    -0x78(%rsp),%r8
cmp    %r13,%r8
mov    -0x68(%rsp),%r13
jne    19d0 <m_inv3+0x8d0>
jmp    1a43 <m_inv3+0x943>
mov    -0x68(%rsp),%r13
jmp    19d0 <m_inv3+0x8d0>
mov    -0x68(%rsp),%r13
mov    -0x70(%rsp),%r14
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ebx
sub    %ebp,%ebx
mov    %rbp,%rax
test   $0x1,%bl
je     19fb <m_inv3+0x8fb>
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x18(%r15,%rbp,8),%xmm0
movsd  %xmm0,0x18(%r15,%rbp,8)
lea    0x1(%rbp),%rax
cmp    $0x2,%rbp
mov    -0x78(%rsp),%r8
mov    -0x8(%rsp),%rbx
je     1a43 <m_inv3+0x943>
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x2,%rax
cmp    $0x3,%rax
jne    1a10 <m_inv3+0x910>
movupd (%r11),%xmm0
movupd 0x18(%rsi),%xmm1
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,0x18(%rsi)
mulsd  0x10(%r11),%xmm3
addsd  0x28(%rsi),%xmm3
movsd  %xmm3,0x28(%rsi)
cmp    $0x2,%r9
je     1bb6 <m_inv3+0xab6>
movsd  0x30(%r15,%r9,8),%xmm0
movapd %xmm0,%xmm3
xorpd  %xmm2,%xmm3
movsd  (%r14,%r9,8),%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%r15,%r9,8)
lea    0x1(%r9),%rax
cmp    $0x3,%rax
je     11a0 <m_inv3+0xa0>
cmp    $0x4,%r8
jb     1b90 <m_inv3+0xa90>
and    $0xfffffffffffffffc,%r8
add    %r8,%rax
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd (%rcx,%rbx,1),%xmm0
movupd 0x10(%rcx,%rbx,1),%xmm1
mulpd  %xmm4,%xmm0
movupd (%rdx,%rbx,1),%xmm5
addpd  %xmm0,%xmm5
movupd 0x10(%rdx,%rbx,1),%xmm0
movupd 0x20(%rdx,%rbx,1),%xmm6
movupd 0x30(%rdx,%rbx,1),%xmm7
mulpd  %xmm4,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm5,(%rdx,%rbx,1)
movupd %xmm1,0x10(%rdx,%rbx,1)
movupd 0x20(%rcx,%rbx,1),%xmm0
movupd 0x30(%rcx,%rbx,1),%xmm1
mulpd  %xmm4,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm0,0x20(%rdx,%rbx,1)
movupd %xmm1,0x30(%rdx,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%r10
jne    1ad0 <m_inv3+0x9d0>
testb  $0x1,-0x60(%rsp)
je     1b77 <m_inv3+0xa77>
movupd (%rdx,%rbx,1),%xmm0
movupd 0x10(%rdx,%rbx,1),%xmm1
movupd (%rcx,%rbx,1),%xmm5
movupd 0x10(%rcx,%rbx,1),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm0,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm5,(%rdx,%rbx,1)
movupd %xmm6,0x10(%rdx,%rbx,1)
cmp    %r8,-0x78(%rsp)
je     11a0 <m_inv3+0xa0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x30(%r15,%rax,8),%xmm0
movsd  %xmm0,0x30(%r15,%rax,8)
add    $0x1,%rax
cmp    $0x3,%rax
jne    1b90 <m_inv3+0xa90>
jmp    11a0 <m_inv3+0xa0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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