#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_inv6(double mat[6][6], double id[6][6]) {
  const double Epsilon = 0.0000001;
  int i, j, s = 0, pindex, pivot = 1;
  double f, Maximum, h;
  for (i = 0; i < 6; i++)
    for (j = 0; j < 6; 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 < 6; 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 < 6; j++) {
          h = mat[s][j];
          mat[s][j] = mat[pindex][j];
          mat[pindex][j] = h;
        }
        for (j = 0; j < 6; j++) {
          h = id[s][j];
          id[s][j] = id[pindex][j];
          id[pindex][j] = h;
        }
      }
    }
    f = mat[s][s];
    for (j = s; j < 6; j++)
      mat[s][j] = mat[s][j] / f;
    for (j = 0; j < 6; j++)
      id[s][j] = id[s][j] / f;
    for (i = 0; i < 6; i++) {
      if (i != s) {
        f = -mat[i][s];
        for (j = s; j < 6; j++)
          mat[i][j] += f * mat[s][j];
        for (j = 0; j < 6; j++)
          id[i][j] += f * id[s][j];
      }
    }
    s++;
  } while (s < 6);
}


x86 assembly (clang, -O0):
<m_inv6>:
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   $0x6,-0x1c(%rbp)
jge    11bb <m_inv6+0xbb>
movl   $0x0,-0x20(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    11a8 <m_inv6+0xa8>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jne    117a <m_inv6+0x7a>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  0xe98(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1195 <m_inv6+0x95>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    119a <m_inv6+0x9a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113f <m_inv6+0x3f>
jmp    11ad <m_inv6+0xad>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112e <m_inv6+0x2e>
jmp    11c0 <m_inv6+0xc0>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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_inv6+0x17f>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x6,-0x1c(%rbp)
jge    127a <m_inv6+0x17a>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%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_inv6+0x167>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%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_inv6+0x16c>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1201 <m_inv6+0x101>
jmp    127f <m_inv6+0x17f>
movsd  0xd79(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1297 <m_inv6+0x197>
jmp    15c9 <m_inv6+0x4c9>
cmpl   $0x0,-0x2c(%rbp)
je     13c8 <m_inv6+0x2c8>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     13c3 <m_inv6+0x2c3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    1335 <m_inv6+0x235>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%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_inv6+0x1b3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    13be <m_inv6+0x2be>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%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_inv6+0x23c>
jmp    13c3 <m_inv6+0x2c3>
jmp    13c8 <m_inv6+0x2c8>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x6,-0x20(%rbp)
jge    1438 <m_inv6+0x338>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%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_inv6+0x2eb>
movl   $0x0,-0x20(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    148c <m_inv6+0x38c>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%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   $0x30,%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_inv6+0x33f>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x6,-0x1c(%rbp)
jge    15b6 <m_inv6+0x4b6>
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     15a3 <m_inv6+0x4a3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%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   $0x6,-0x20(%rbp)
jge    153d <m_inv6+0x43d>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%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_inv6+0x3e3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x6,-0x20(%rbp)
jge    159e <m_inv6+0x49e>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x30,%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_inv6+0x444>
jmp    15a3 <m_inv6+0x4a3>
jmp    15a8 <m_inv6+0x4a8>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1493 <m_inv6+0x393>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x6,-0x24(%rbp)
jl     11c0 <m_inv6+0xc0>
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_inv6>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rsi)
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsi)
movups %xmm0,0x18(%rsi)
movups %xmm0,0x28(%rsi)
mov    %rax,0x38(%rsi)
movups %xmm0,0x40(%rsi)
movups %xmm0,0x50(%rsi)
movups %xmm0,0x60(%rsi)
mov    %rax,0x70(%rsi)
movups %xmm0,0x78(%rsi)
movups %xmm0,0x88(%rsi)
movups %xmm0,0x98(%rsi)
mov    %rax,0xa8(%rsi)
movups %xmm0,0xb0(%rsi)
movups %xmm0,0xc0(%rsi)
movups %xmm0,0xd0(%rsi)
mov    %rax,0xe0(%rsi)
movups %xmm0,0x108(%rsi)
movups %xmm0,0xf8(%rsi)
movups %xmm0,0xe8(%rsi)
mov    %rax,0x118(%rsi)
lea    0x30(%rdi),%r8
lea    0x38(%rdi),%r11
lea    0x18(%rdi),%r14
mov    $0xfffffffffffffffb,%r10
mov    $0x1,%r15d
mov    $0x3,%eax
mov    %rax,-0x38(%rsp)
mov    $0x5,%r12d
xor    %ebp,%ebp
movapd 0xe3e(%rip),%xmm0
movsd  0xe55(%rip),%xmm8
movapd 0xe3d(%rip),%xmm2
mov    %r14,%rdx
mov    %rdi,%rax
mov    %r11,-0x40(%rsp)
mov    %rdi,-0x70(%rsp)
jmp    1248 <m_inv6+0x148>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
mov    -0x20(%rsp),%r10
add    $0x1,%r10
mov    -0x8(%rsp),%r8
add    $0x38,%r8
mov    -0x28(%rsp),%r15
add    $0xffffffffffffffff,%r15
addq   $0x8,-0x40(%rsp)
mov    -0x10(%rsp),%r11
add    $0x38,%r11
add    $0x30,%rax
add    $0x38,%rdx
addq   $0xffffffffffffffff,-0x38(%rsp)
mov    -0x30(%rsp),%r12
add    $0xffffffffffffffff,%r12
mov    -0x18(%rsp),%r14
add    $0x8,%r14
cmp    $0x6,%rbp
je     192e <m_inv6+0x82e>
lea    0x0(,%rbp,2),%r9
add    %rbp,%r9
shl    $0x4,%r9
lea    (%rdi,%r9,1),%rcx
mov    %rcx,-0x78(%rsp)
movsd  (%rcx,%rbp,8),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm0,%xmm4
cmp    $0x4,%rbp
mov    %rbp,-0x80(%rsp)
ja     12c0 <m_inv6+0x1c0>
mov    %r8,%rdi
mov    %rbp,%rcx
mov    %r10,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm5
andpd  %xmm0,%xmm5
ucomisd %xmm4,%xmm5
lea    0x6(%rbp),%ebx
cmova  %ebx,%ecx
maxsd  %xmm4,%xmm5
add    $0x30,%rdi
movapd %xmm5,%xmm4
inc    %rbp
jne    1290 <m_inv6+0x190>
jmp    12c6 <m_inv6+0x1c6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,%ecx
movapd %xmm4,%xmm5
ucomisd %xmm5,%xmm8
mov    -0x70(%rsp),%rdi
ja     192e <m_inv6+0x82e>
imul   $0x38,-0x80(%rsp),%rbp
mov    $0x5,%ebx
sub    -0x80(%rsp),%rbx
mov    %rbx,-0x60(%rsp)
lea    (%rdi,%rbp,1),%rbx
add    $0x8,%rbx
mov    %rbx,-0x48(%rsp)
mov    -0x80(%rsp),%rbx
lea    0x1(%rbx),%r13
lea    (%rdi,%r9,1),%rbx
add    $0x30,%rbx
mov    %rbx,-0x50(%rsp)
mov    %ecx,%ebp
cmp    %rbp,-0x80(%rsp)
mov    -0x80(%rsp),%rbp
mov    %r13,%rbx
mov    %r13,-0x68(%rsp)
mov    %r8,-0x8(%rsp)
mov    %r10,-0x20(%rsp)
jne    1340 <m_inv6+0x240>
mov    -0x78(%rsp),%rbx
jmp    15a7 <m_inv6+0x4a7>
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
lea    (%rcx,%rcx,2),%r10
shl    $0x4,%r10
lea    (%rdi,%r10,1),%rbx
movsd  (%rbx,%rbp,8),%xmm4
mov    -0x78(%rsp),%rdi
movsd  %xmm4,(%rdi,%rbp,8)
movsd  %xmm3,(%rbx,%rbp,8)
cmp    $0x6,%r13
je     1546 <m_inv6+0x446>
mov    %r13,%rbp
cmpq   $0x4,-0x60(%rsp)
jb     14e0 <m_inv6+0x3e0>
mov    -0x70(%rsp),%rbp
mov    -0x80(%rsp),%rdi
lea    0x8(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x4,%rcx
lea    (%rcx,%rcx,2),%rcx
add    %rcx,%rdi
add    %rbp,%rcx
add    $0x30,%rcx
cmp    %rcx,-0x48(%rsp)
setb   %r8b
cmp    -0x50(%rsp),%rdi
mov    -0x68(%rsp),%r13
setb   %cl
mov    %r13,%rbp
and    %r8b,%cl
jne    14e0 <m_inv6+0x3e0>
mov    %r13,%rbp
mov    -0x50(%rsp),%rdi
cmp    %rdi,-0x48(%rsp)
jb     14e0 <m_inv6+0x3e0>
mov    %r13,%rbp
test   %cl,%cl
jne    14e0 <m_inv6+0x3e0>
mov    $0x1,%ecx
sub    -0x80(%rsp),%rcx
mov    %rcx,%r8
shr    $0x2,%r8
add    $0x1,%r8
cmp    $0x4,%rcx
jae    1405 <m_inv6+0x305>
xor    %ecx,%ecx
jmp    1486 <m_inv6+0x386>
mov    %r15,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
mov    -0x40(%rsp),%rcx
lea    (%rcx,%r10,1),%rdi
xor    %ecx,%ecx
nop
movups -0x30(%r11,%rcx,8),%xmm3
movups -0x20(%r11,%rcx,8),%xmm4
movups -0x30(%rdi,%rcx,8),%xmm5
movups -0x20(%rdi,%rcx,8),%xmm6
movups %xmm5,-0x30(%r11,%rcx,8)
movups %xmm6,-0x20(%r11,%rcx,8)
movups %xmm3,-0x30(%rdi,%rcx,8)
movups %xmm4,-0x20(%rdi,%rcx,8)
movupd -0x10(%r11,%rcx,8),%xmm3
movupd (%r11,%rcx,8),%xmm4
movupd -0x10(%rdi,%rcx,8),%xmm5
movupd (%rdi,%rcx,8),%xmm6
movupd %xmm5,-0x10(%r11,%rcx,8)
movupd %xmm6,(%r11,%rcx,8)
movupd %xmm3,-0x10(%rdi,%rcx,8)
movupd %xmm4,(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1420 <m_inv6+0x320>
mov    -0x60(%rsp),%r13
mov    %r13,%rbp
and    $0xfffffffffffffffc,%rbp
test   $0x1,%r8b
mov    -0x68(%rsp),%rdi
je     14d6 <m_inv6+0x3d6>
add    %rdi,%rcx
mov    -0x78(%rsp),%rdi
movupd (%rdi,%rcx,8),%xmm3
movupd 0x10(%rdi,%rcx,8),%xmm4
movupd (%rbx,%rcx,8),%xmm5
movupd 0x10(%rbx,%rcx,8),%xmm6
movupd %xmm5,(%rdi,%rcx,8)
movupd %xmm6,0x10(%rdi,%rcx,8)
mov    -0x68(%rsp),%rdi
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
cmp    %rbp,%r13
je     1546 <m_inv6+0x446>
add    %rdi,%rbp
xchg   %ax,%ax
mov    %rbp,%rcx
test   $0x1,%bpl
je     1506 <m_inv6+0x406>
mov    -0x78(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm3
movsd  (%rbx,%rbp,8),%xmm4
movsd  %xmm4,(%rcx,%rbp,8)
movsd  %xmm3,(%rbx,%rbp,8)
lea    0x1(%rbp),%rcx
cmp    $0x5,%rbp
je     1546 <m_inv6+0x446>
add    $0x1,%rcx
movsd  -0x8(%rax,%rcx,8),%xmm3
movsd  -0x8(%rbx,%rcx,8),%xmm4
movsd  %xmm4,-0x8(%rax,%rcx,8)
movsd  %xmm3,-0x8(%rbx,%rcx,8)
movsd  (%rax,%rcx,8),%xmm3
movsd  (%rbx,%rcx,8),%xmm4
movsd  %xmm4,(%rax,%rcx,8)
movsd  %xmm3,(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    $0x7,%rcx
jne    1510 <m_inv6+0x410>
mov    -0x80(%rsp),%rbp
mov    -0x78(%rsp),%rbx
lea    (%rbx,%rbp,8),%rcx
movups (%rsi,%r10,1),%xmm3
movupd 0x10(%rsi,%r10,1),%xmm4
movupd 0x20(%rsi,%r10,1),%xmm5
movupd (%rsi,%r9,1),%xmm6
movups %xmm3,(%rsi,%r9,1)
movupd %xmm6,(%rsi,%r10,1)
movups 0x10(%rsi,%r9,1),%xmm3
movupd %xmm4,0x10(%rsi,%r9,1)
movups %xmm3,0x10(%rsi,%r10,1)
movups 0x20(%rsi,%r9,1),%xmm3
movupd %xmm5,0x20(%rsi,%r9,1)
movups %xmm3,0x20(%rsi,%r10,1)
movsd  (%rcx),%xmm3
mov    -0x70(%rsp),%rdi
mov    %r15,-0x28(%rsp)
mov    %r11,-0x10(%rsp)
movapd %xmm3,%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rbp,8)
lea    0x1(%rbp),%rcx
cmp    $0x6,%rcx
mov    -0x60(%rsp),%r11
je     1698 <m_inv6+0x598>
cmp    $0x2,%r11
jb     1680 <m_inv6+0x580>
mov    $0x3,%edi
sub    %rbp,%rdi
mov    %rdi,%r8
shr    %r8
add    $0x1,%r8
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmp    $0x2,%rdi
jae    15ff <m_inv6+0x4ff>
xor    %ebp,%ebp
jmp    1648 <m_inv6+0x548>
mov    -0x38(%rsp),%rdi
shr    %rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rbp,8),%xmm5
movupd (%rdx,%rbp,8),%xmm6
divpd  %xmm4,%xmm5
movupd %xmm5,-0x10(%rdx,%rbp,8)
divpd  %xmm4,%xmm6
movupd %xmm6,(%rdx,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1620 <m_inv6+0x520>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
test   $0x1,%r8b
je     166b <m_inv6+0x56b>
add    %rcx,%rbp
mov    -0x78(%rsp),%rdi
movupd (%rdi,%rbp,8),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%rdi,%rbp,8)
cmp    %rbx,%r11
mov    -0x70(%rsp),%rdi
je     1698 <m_inv6+0x598>
add    %rbx,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    $0x6,%rcx
jne    1680 <m_inv6+0x580>
mov    %r12,-0x30(%rsp)
mov    %r12,%rcx
and    $0xfffffffffffffffc,%rcx
mov    -0x80(%rsp),%rbp
shl    $0x4,%rbp
lea    0x0(%rbp,%rbp,2),%rbp
lea    (%rsi,%rbp,1),%rbx
mov    %rbx,0x20(%rsp)
unpcklpd %xmm3,%xmm3
movupd (%rsi,%rbp,1),%xmm4
movupd 0x10(%rsi,%rbp,1),%xmm5
movupd 0x20(%rsi,%rbp,1),%xmm6
divpd  %xmm3,%xmm4
movupd %xmm4,(%rsi,%rbp,1)
lea    0x10(%rsi,%rbp,1),%rbx
mov    %rbx,0x18(%rsp)
divpd  %xmm3,%xmm5
movupd %xmm5,0x10(%rsi,%rbp,1)
divpd  %xmm3,%xmm6
movupd %xmm6,0x20(%rsi,%rbp,1)
add    %rdi,%rbp
mov    -0x80(%rsp),%rbx
lea    0x0(%rbp,%rbx,8),%rbp
mov    %rbp,0x10(%rsp)
mov    -0x80(%rsp),%rbp
lea    0x1(%rbp),%rbx
mov    %rbx,-0x58(%rsp)
mov    %r11,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rbx,0x8(%rsp)
add    %rbp,%rbx
add    $0x1,%rbx
mov    %rbx,(%rsp)
mov    %rdi,%r9
mov    %r14,-0x18(%rsp)
mov    %r14,%r10
xor    %r12d,%r12d
jmp    17b1 <m_inv6+0x6b1>
xchg   %ax,%ax
mov    0x20(%rsp),%rbx
movupd (%rbx),%xmm1
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm1
movupd (%rsi,%r15,1),%xmm4
addpd  %xmm1,%xmm4
movupd 0x10(%rsi,%r15,1),%xmm1
movupd 0x20(%rsi,%r15,1),%xmm5
movupd %xmm4,(%rsi,%r15,1)
mov    0x18(%rsp),%rbx
movupd (%rbx),%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,0x10(%rsi,%r15,1)
movupd 0x10(%rbx),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
movupd %xmm1,0x20(%rsi,%r15,1)
add    $0x1,%r12
add    $0x30,%r10
add    $0x30,%r9
cmp    $0x6,%r12
je     11f0 <m_inv6+0xf0>
cmp    %rbp,%r12
je     179b <m_inv6+0x69b>
lea    (%r12,%r12,2),%r15
shl    $0x4,%r15
lea    (%rdi,%r15,1),%r8
movsd  (%r8,%rbp,8),%xmm4
movapd %xmm4,%xmm3
xorpd  %xmm2,%xmm3
mov    0x10(%rsp),%rbx
movsd  (%rbx),%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r8,%rbp,8)
cmpq   $0x6,-0x58(%rsp)
je     1740 <m_inv6+0x640>
mov    -0x58(%rsp),%r14
cmp    $0x4,%r11
jb     18b0 <m_inv6+0x7b0>
mov    -0x68(%rsp),%rdi
lea    (%r8,%rdi,8),%r11
mov    -0x70(%rsp),%rdi
lea    (%rdi,%r15,1),%rbp
add    $0x30,%rbp
cmp    -0x50(%rsp),%r11
setb   %bl
cmp    %rbp,-0x48(%rsp)
setb   %r13b
mov    -0x58(%rsp),%r14
cmp    %rbp,%r11
mov    -0x60(%rsp),%r11
mov    -0x80(%rsp),%rbp
mov    -0x70(%rsp),%rdi
jb     18b0 <m_inv6+0x7b0>
mov    -0x58(%rsp),%r14
and    %r13b,%bl
jne    18b0 <m_inv6+0x7b0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%r10,%rbx,8),%xmm5
movupd (%r10,%rbx,8),%xmm6
movupd -0x10(%rdx,%rbx,8),%xmm7
movupd (%rdx,%rbx,8),%xmm1
mulpd  %xmm4,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm4,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm7,-0x10(%r10,%rbx,8)
movupd %xmm1,(%r10,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rcx
jne    1860 <m_inv6+0x760>
mov    (%rsp),%r14
cmp    0x8(%rsp),%r11
je     1740 <m_inv6+0x640>
nopl   (%rax)
mov    %r14,%r13
test   $0x1,%r14b
je     18d8 <m_inv6+0x7d8>
mov    -0x78(%rsp),%rbx
movsd  (%rbx,%r14,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%r8,%r14,8),%xmm1
movsd  %xmm1,(%r8,%r14,8)
lea    0x1(%r14),%r13
cmp    $0x5,%r14
je     1740 <m_inv6+0x640>
add    $0x1,%r13
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rax,%r13,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  -0x8(%r9,%r13,8),%xmm1
movsd  %xmm1,-0x8(%r9,%r13,8)
movsd  (%rax,%r13,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%r9,%r13,8),%xmm1
movsd  %xmm1,(%r9,%r13,8)
add    $0x2,%r13
cmp    $0x7,%r13
jne    18f0 <m_inv6+0x7f0>
jmp    1740 <m_inv6+0x640>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @m_inv6([6 x double]* %0, [6 x double]* %1) {
%3 = alloca [6 x double]*
%4 = alloca [6 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 [6 x double]* %0, [6 x double]** %3
store [6 x double]* %1, [6 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, 6
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, 6
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 [6 x double]*, [6 x double]** %4
%27 = load i32, i32* %6
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [6 x double], [6 x double]* %26, i64 %28
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [6 x double], [6 x double]* %29, i64 0, i64 %31
store double 1.000000e+00, double* %32
br label %41
33: ; preds = %21
%34 = load [6 x double]*, [6 x double]** %4
%35 = load i32, i32* %6
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [6 x double], [6 x double]* %34, i64 %36
%38 = load i32, i32* %7
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [6 x double], [6 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 [6 x double]*, [6 x double]** %3
%52 = load i32, i32* %8
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [6 x double], [6 x double]* %51, i64 %53
%55 = load i32, i32* %8
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %68, label %69, label %96
69: ; preds = %66
%70 = load [6 x double]*, [6 x double]** %3
%71 = load i32, i32* %6
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [6 x double], [6 x double]* %70, i64 %72
%74 = load i32, i32* %8
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [6 x double], [6 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 [6 x double]*, [6 x double]** %3
%83 = load i32, i32* %6
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [6 x double], [6 x double]* %82, i64 %84
%86 = load i32, i32* %8
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %112, label %113, label %148
113: ; preds = %110
%114 = load [6 x double]*, [6 x double]** %3
%115 = load i32, i32* %8
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [6 x double], [6 x double]* %114, i64 %116
%118 = load i32, i32* %7
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [6 x double], [6 x double]* %117, i64 0, i64 %119
%121 = load double, double* %120
store double %121, double* %13
%122 = load [6 x double]*, [6 x double]** %3
%123 = load i32, i32* %9
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [6 x double], [6 x double]* %122, i64 %124
%126 = load i32, i32* %7
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [6 x double], [6 x double]* %125, i64 0, i64 %127
%129 = load double, double* %128
%130 = load [6 x double]*, [6 x double]** %3
%131 = load i32, i32* %8
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [6 x double], [6 x double]* %130, i64 %132
%134 = load i32, i32* %7
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [6 x double], [6 x double]* %133, i64 0, i64 %135
store double %129, double* %136
%137 = load double, double* %13
%138 = load [6 x double]*, [6 x double]** %3
%139 = load i32, i32* %9
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [6 x double], [6 x double]* %138, i64 %140
%142 = load i32, i32* %7
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %151, label %152, label %187
152: ; preds = %149
%153 = load [6 x double]*, [6 x double]** %4
%154 = load i32, i32* %8
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [6 x double], [6 x double]* %153, i64 %155
%157 = load i32, i32* %7
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [6 x double], [6 x double]* %156, i64 0, i64 %158
%160 = load double, double* %159
store double %160, double* %13
%161 = load [6 x double]*, [6 x double]** %4
%162 = load i32, i32* %9
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [6 x double], [6 x double]* %161, i64 %163
%165 = load i32, i32* %7
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [6 x double], [6 x double]* %164, i64 0, i64 %166
%168 = load double, double* %167
%169 = load [6 x double]*, [6 x double]** %4
%170 = load i32, i32* %8
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [6 x double], [6 x double]* %169, i64 %171
%173 = load i32, i32* %7
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [6 x double], [6 x double]* %172, i64 0, i64 %174
store double %168, double* %175
%176 = load double, double* %13
%177 = load [6 x double]*, [6 x double]** %4
%178 = load i32, i32* %9
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [6 x double], [6 x double]* %177, i64 %179
%181 = load i32, i32* %7
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [6 x double], [6 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 [6 x double]*, [6 x double]** %3
%191 = load i32, i32* %8
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [6 x double], [6 x double]* %190, i64 %192
%194 = load i32, i32* %8
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %201, label %202, label %223
202: ; preds = %199
%203 = load [6 x double]*, [6 x double]** %3
%204 = load i32, i32* %8
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [6 x double], [6 x double]* %203, i64 %205
%207 = load i32, i32* %7
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [6 x double], [6 x double]* %206, i64 0, i64 %208
%210 = load double, double* %209
%211 = load double, double* %11
%212 = fdiv double %210, %211
%213 = load [6 x double]*, [6 x double]** %3
%214 = load i32, i32* %8
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [6 x double], [6 x double]* %213, i64 %215
%217 = load i32, i32* %7
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %226, label %227, label %248
227: ; preds = %224
%228 = load [6 x double]*, [6 x double]** %4
%229 = load i32, i32* %8
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [6 x double], [6 x double]* %228, i64 %230
%232 = load i32, i32* %7
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds [6 x double], [6 x double]* %231, i64 0, i64 %233
%235 = load double, double* %234
%236 = load double, double* %11
%237 = fdiv double %235, %236
%238 = load [6 x double]*, [6 x double]** %4
%239 = load i32, i32* %8
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [6 x double], [6 x double]* %238, i64 %240
%242 = load i32, i32* %7
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [6 x double], [6 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, 6
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 [6 x double]*, [6 x double]** %3
%258 = load i32, i32* %6
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [6 x double], [6 x double]* %257, i64 %259
%261 = load i32, i32* %8
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %269, label %270, label %292
270: ; preds = %267
%271 = load double, double* %11
%272 = load [6 x double]*, [6 x double]** %3
%273 = load i32, i32* %8
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [6 x double], [6 x double]* %272, i64 %274
%276 = load i32, i32* %7
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds [6 x double], [6 x double]* %275, i64 0, i64 %277
%279 = load double, double* %278
%280 = load [6 x double]*, [6 x double]** %3
%281 = load i32, i32* %6
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [6 x double], [6 x double]* %280, i64 %282
%284 = load i32, i32* %7
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %295, label %296, label %318
296: ; preds = %293
%297 = load double, double* %11
%298 = load [6 x double]*, [6 x double]** %4
%299 = load i32, i32* %8
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [6 x double], [6 x double]* %298, i64 %300
%302 = load i32, i32* %7
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [6 x double], [6 x double]* %301, i64 0, i64 %303
%305 = load double, double* %304
%306 = load [6 x double]*, [6 x double]** %4
%307 = load i32, i32* %6
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [6 x double], [6 x double]* %306, i64 %308
%310 = load i32, i32* %7
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [6 x double], [6 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, 6
br i1 %328, label %50, label %329
329: ; preds = %326, %100
ret void
}

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