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


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

x86 assembly (clang, -O2):
<m_inv4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
movabs $0x3ff0000000000000,%rax
mov    %rax,(%rsi)
xorps  %xmm0,%xmm0
movups %xmm0,0x8(%rsi)
movups %xmm0,0x18(%rsi)
mov    %rax,0x28(%rsi)
movups %xmm0,0x30(%rsi)
movups %xmm0,0x40(%rsi)
mov    %rax,0x50(%rsi)
movups %xmm0,0x58(%rsi)
movups %xmm0,0x68(%rsi)
mov    %rax,0x78(%rsi)
lea    0x20(%rdi),%r8
lea    0x38(%rdi),%r10
lea    0x8(%rdi),%rsi
lea    0x18(%rdi),%r11
mov    $0xfffffffffffffffd,%r15
mov    $0xffffffffffffffff,%r12
mov    $0x1,%eax
mov    %rax,-0x50(%rsp)
mov    $0x3,%r13d
xor    %edx,%edx
movapd 0xe83(%rip),%xmm0
movsd  0xe9a(%rip),%xmm8
movapd 0xe82(%rip),%xmm2
mov    %rdi,%rcx
jmp    11f2 <m_inv4+0xf2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
mov    -0x28(%rsp),%r15
add    $0x1,%r15
mov    -0x18(%rsp),%r8
add    $0x28,%r8
mov    -0x30(%rsp),%r12
add    $0xffffffffffffffff,%r12
mov    -0x48(%rsp),%r10
add    $0x8,%r10
add    $0x28,%rsi
add    $0x20,%rcx
addq   $0xffffffffffffffff,-0x50(%rsp)
mov    -0x40(%rsp),%r13
add    $0xffffffffffffffff,%r13
mov    -0x20(%rsp),%r11
add    $0x8,%r11
cmp    $0x4,%rdx
je     183e <m_inv4+0x73e>
mov    %rdx,%r9
shl    $0x5,%r9
lea    (%rdi,%r9,1),%rax
mov    %rax,-0x70(%rsp)
movsd  (%rax,%rdx,8),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm0,%xmm4
cmp    $0x2,%rdx
mov    %rdx,-0x58(%rsp)
ja     1250 <m_inv4+0x150>
mov    %r8,%rbp
mov    %r15,%rbx
movsd  0x0(%rbp),%xmm5
andpd  %xmm0,%xmm5
ucomisd %xmm4,%xmm5
lea    0x4(%rbx),%eax
cmova  %eax,%edx
maxsd  %xmm4,%xmm5
add    $0x20,%rbp
movapd %xmm5,%xmm4
inc    %rbx
jne    1220 <m_inv4+0x120>
jmp    1254 <m_inv4+0x154>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm4,%xmm5
ucomisd %xmm5,%xmm8
mov    -0x58(%rsp),%rbx
ja     183e <m_inv4+0x73e>
mov    %r9,-0x80(%rsp)
lea    0x1(%rbx),%rbp
mov    %rbp,%r9
shl    $0x5,%r9
mov    $0x3,%eax
sub    %rbx,%rax
mov    %rax,-0x78(%rsp)
lea    (%rbx,%rbx,4),%rax
lea    (%rdi,%rax,8),%rax
add    $0x8,%rax
mov    %rax,-0x68(%rsp)
add    %rdi,%r9
mov    %r9,-0x60(%rsp)
mov    -0x70(%rsp),%r9
lea    (%r9,%rbx,8),%rax
mov    %rax,-0x38(%rsp)
mov    %edx,%eax
cmp    %rax,%rbx
mov    %r12,-0x30(%rsp)
mov    %rbp,%rax
mov    %rbp,(%rsp)
mov    %r8,-0x18(%rsp)
mov    %r10,-0x48(%rsp)
mov    %r15,-0x28(%rsp)
mov    %r13,-0x40(%rsp)
jne    12e0 <m_inv4+0x1e0>
mov    %rbx,%rdx
mov    -0x80(%rsp),%r10
mov    %r9,%rbx
jmp    151a <m_inv4+0x41a>
nop
movslq %edx,%r15
shl    $0x5,%r15
lea    (%rdi,%r15,1),%r13
movsd  0x0(%r13,%rbx,8),%xmm4
movsd  %xmm4,(%r9,%rbx,8)
movsd  %xmm3,0x0(%r13,%rbx,8)
cmp    $0x4,%rbp
mov    %rbx,%rdx
mov    -0x80(%rsp),%r10
mov    %r9,%rbx
je     14dc <m_inv4+0x3dc>
mov    %rbp,%rax
mov    %rbp,%r9
cmpq   $0x4,-0x78(%rsp)
jb     1460 <m_inv4+0x360>
lea    (%rdi,%rdx,8),%rbp
add    $0x8,%rbp
add    %r15,%rbp
lea    (%rdi,%r15,1),%rdx
add    $0x20,%rdx
cmp    %rdx,-0x68(%rsp)
setb   %dl
cmp    -0x60(%rsp),%rbp
setb   %r8b
mov    %rax,%r9
and    %dl,%r8b
mov    -0x58(%rsp),%rdx
jne    1460 <m_inv4+0x360>
mov    %rax,%r9
mov    -0x68(%rsp),%rbp
cmp    -0x60(%rsp),%rbp
jb     1460 <m_inv4+0x360>
mov    %rax,%r9
test   %r8b,%r8b
jne    1460 <m_inv4+0x360>
mov    %r12,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rdx,%r12
not    %r12
shr    $0x2,%r12
and    $0xfffffffffffffffe,%rbp
add    $0x1,%r12
mov    %rax,%rbx
mov    -0x78(%rsp),%r8
and    $0xfffffffffffffffc,%r8
lea    (%rax,%r8,1),%r9
mov    -0x48(%rsp),%rax
add    %r15,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm3
movups 0x10(%rsi,%rbx,1),%xmm4
movups -0x30(%rax,%rbx,1),%xmm5
movups -0x20(%rax,%rbx,1),%xmm6
movups %xmm5,(%rsi,%rbx,1)
movups %xmm6,0x10(%rsi,%rbx,1)
movups %xmm3,-0x30(%rax,%rbx,1)
movups %xmm4,-0x20(%rax,%rbx,1)
movupd 0x20(%rsi,%rbx,1),%xmm3
movupd 0x30(%rsi,%rbx,1),%xmm4
movupd -0x10(%rax,%rbx,1),%xmm5
movupd (%rax,%rbx,1),%xmm6
movupd %xmm5,0x20(%rsi,%rbx,1)
movupd %xmm6,0x30(%rsi,%rbx,1)
movupd %xmm3,-0x10(%rax,%rbx,1)
movupd %xmm4,(%rax,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rbp
jne    13c0 <m_inv4+0x2c0>
test   $0x1,%r12b
je     1452 <m_inv4+0x352>
movupd (%rsi,%rbx,1),%xmm3
movupd 0x10(%rsi,%rbx,1),%xmm4
movupd -0x30(%rbx,%rax,1),%xmm5
movupd -0x20(%rbx,%rax,1),%xmm6
movupd %xmm5,(%rsi,%rbx,1)
movupd %xmm6,0x10(%rsi,%rbx,1)
movupd %xmm3,-0x30(%rbx,%rax,1)
movupd %xmm4,-0x20(%rbx,%rax,1)
cmp    %r8,-0x78(%rsp)
mov    -0x70(%rsp),%rbx
je     14dc <m_inv4+0x3dc>
xchg   %ax,%ax
mov    %r9,%rax
test   $0x1,%r9b
je     1487 <m_inv4+0x387>
movsd  (%rbx,%r9,8),%xmm3
movsd  0x0(%r13,%r9,8),%xmm4
movsd  %xmm4,(%rbx,%r9,8)
movsd  %xmm3,0x0(%r13,%r9,8)
lea    0x1(%r9),%rax
cmp    $0x3,%r9
je     14dc <m_inv4+0x3dc>
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rax,8),%xmm3
movsd  -0x8(%r13,%rax,8),%xmm4
movsd  %xmm4,-0x8(%rcx,%rax,8)
movsd  %xmm3,-0x8(%r13,%rax,8)
movsd  (%rcx,%rax,8),%xmm3
movsd  0x0(%r13,%rax,8),%xmm4
movsd  %xmm4,(%rcx,%rax,8)
movsd  %xmm3,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    $0x5,%rax
jne    14a0 <m_inv4+0x3a0>
movups (%r14,%r15,1),%xmm3
movupd 0x10(%r14,%r15,1),%xmm4
movupd (%r14,%r10,1),%xmm5
movups %xmm3,(%r14,%r10,1)
movupd %xmm5,(%r14,%r15,1)
movups 0x10(%r14,%r10,1),%xmm3
movupd %xmm4,0x10(%r14,%r10,1)
movups %xmm3,0x10(%r14,%r15,1)
mov    -0x38(%rsp),%rax
movsd  (%rax),%xmm3
mov    -0x40(%rsp),%r13
movapd %xmm3,%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rdx,8)
lea    0x1(%rdx),%rax
cmp    $0x4,%rax
mov    -0x78(%rsp),%r15
je     15f8 <m_inv4+0x4f8>
cmp    $0x2,%r15
jb     15e0 <m_inv4+0x4e0>
mov    $0x1,%ebp
sub    %rdx,%rbp
mov    %rbp,%r8
shr    %r8
add    $0x1,%r8
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmp    $0x2,%rbp
jae    1568 <m_inv4+0x468>
xor    %ebx,%ebx
jmp    15a8 <m_inv4+0x4a8>
mov    -0x50(%rsp),%rbp
shr    %rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%rsi,%rbx,8),%xmm5
movupd 0x10(%rsi,%rbx,8),%xmm6
divpd  %xmm4,%xmm5
movupd %xmm5,(%rsi,%rbx,8)
divpd  %xmm4,%xmm6
movupd %xmm6,0x10(%rsi,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1580 <m_inv4+0x480>
mov    %r15,%rbp
and    $0xfffffffffffffffe,%rbp
test   $0x1,%r8b
je     15cd <m_inv4+0x4cd>
add    %rax,%rbx
mov    -0x70(%rsp),%r8
movupd (%r8,%rbx,8),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%r8,%rbx,8)
cmp    %rbp,%r15
je     15f8 <m_inv4+0x4f8>
add    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rax,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rax,8)
add    $0x1,%rax
cmp    $0x4,%rax
jne    15e0 <m_inv4+0x4e0>
mov    %r13,%r12
and    $0xfffffffffffffffc,%r12
lea    (%r14,%r10,1),%rax
mov    %rax,0x10(%rsp)
unpcklpd %xmm3,%xmm3
movupd (%r14,%r10,1),%xmm4
movupd 0x10(%r14,%r10,1),%xmm5
divpd  %xmm3,%xmm4
movupd %xmm4,(%r14,%r10,1)
lea    0x10(%r14,%r10,1),%rax
mov    %rax,0x8(%rsp)
divpd  %xmm3,%xmm5
movupd %xmm5,0x10(%r14,%r10,1)
lea    0x1(%rdx),%rax
mov    %rax,-0x80(%rsp)
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x8(%rsp)
add    %rdx,%rax
add    $0x1,%rax
mov    %rax,-0x10(%rsp)
mov    %rdi,%r10
mov    %r11,-0x20(%rsp)
mov    %r11,%r9
xor    %r13d,%r13d
jmp    16c6 <m_inv4+0x5c6>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
movupd (%rax),%xmm1
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm1
movupd (%r14,%rbp,1),%xmm4
addpd  %xmm1,%xmm4
movupd 0x10(%r14,%rbp,1),%xmm1
movupd %xmm4,(%r14,%rbp,1)
mov    0x8(%rsp),%rax
movupd (%rax),%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,0x10(%r14,%rbp,1)
add    $0x1,%r13
add    $0x20,%r9
add    $0x20,%r10
cmp    $0x4,%r13
je     11a0 <m_inv4+0xa0>
cmp    %rdx,%r13
je     16b0 <m_inv4+0x5b0>
mov    %r13,%rbp
shl    $0x5,%rbp
lea    (%rdi,%rbp,1),%r8
movsd  (%r8,%rdx,8),%xmm4
movapd %xmm4,%xmm3
xorpd  %xmm2,%xmm3
mov    -0x38(%rsp),%rax
movsd  (%rax),%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%r8,%rdx,8)
cmpq   $0x4,-0x80(%rsp)
je     1670 <m_inv4+0x570>
mov    -0x80(%rsp),%rbx
cmp    $0x4,%r15
jb     17c0 <m_inv4+0x6c0>
mov    (%rsp),%rax
lea    (%r8,%rax,8),%r15
mov    %r14,%rdx
lea    (%rdi,%rbp,1),%r14
add    $0x20,%r14
cmp    -0x60(%rsp),%r15
setb   %al
cmp    %r14,-0x68(%rsp)
setb   %r11b
mov    -0x80(%rsp),%rbx
cmp    %r14,%r15
mov    -0x78(%rsp),%r15
mov    %rdx,%r14
mov    -0x58(%rsp),%rdx
jb     17c0 <m_inv4+0x6c0>
mov    -0x80(%rsp),%rbx
and    %r11b,%al
jne    17c0 <m_inv4+0x6c0>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%r9,%rbx,8),%xmm5
movupd (%r9,%rbx,8),%xmm6
movupd (%rsi,%rbx,8),%xmm7
movupd 0x10(%rsi,%rbx,8),%xmm1
mulpd  %xmm4,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm4,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm7,-0x10(%r9,%rbx,8)
movupd %xmm1,(%r9,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    1770 <m_inv4+0x670>
mov    -0x10(%rsp),%rbx
cmp    -0x8(%rsp),%r15
je     1670 <m_inv4+0x570>
xchg   %ax,%ax
mov    %rbx,%r11
test   $0x1,%bl
je     17e6 <m_inv4+0x6e6>
mov    -0x70(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%r8,%rbx,8),%xmm1
movsd  %xmm1,(%r8,%rbx,8)
lea    0x1(%rbx),%r11
cmp    $0x3,%rbx
je     1670 <m_inv4+0x570>
add    $0x1,%r11
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rcx,%r11,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  -0x8(%r10,%r11,8),%xmm1
movsd  %xmm1,-0x8(%r10,%r11,8)
movsd  (%rcx,%r11,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%r10,%r11,8),%xmm1
movsd  %xmm1,(%r10,%r11,8)
add    $0x2,%r11
cmp    $0x5,%r11
jne    1800 <m_inv4+0x700>
jmp    1670 <m_inv4+0x570>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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