void linvert_matrix(matrix, depth, inverse, lindep_sensitivity,
                    lin_dependent) double *matrix;
long depth;
double *inverse, lindep_sensitivity;
long *lin_dependent;
{
  long i, j, k;
  double factor;
  for (i = 0; i < depth; i++) {
    for (j = 0; j < depth; j++) {
      inverse[i * depth + j] = 0.0;
    }
    inverse[i * depth + i] = 1.0;
  }
  for (i = 0; i < depth; i++) {
    if (lin_dependent[i] ||
        (fabs(matrix[i * depth + i]) < lindep_sensitivity)) {
      lin_dependent[i] = 1;
    } else {
      for (j = i + 1; j < depth; j++) {
        factor = matrix[j * depth + i] / matrix[i * depth + i];
        for (k = i; k < depth; k++) {
          matrix[j * depth + k] -= (factor * matrix[i * depth + k]);
        }
        for (k = 0; k < depth; k++) {
          inverse[j * depth + k] -= (factor * inverse[i * depth + k]);
        }
      }
    }
  }
  for (i = depth - 1; i >= 0; i--) {
    if (!lin_dependent[i]) {
      factor = 1 / matrix[i * depth + i];
      for (k = 0; k < depth; k++) {
        inverse[i * depth + k] *= factor;
      }
      matrix[i * depth + i] = 1;
      for (j = i - 1; j >= 0; j--) {
        factor = matrix[j * depth + i];
        matrix[j * depth + i] = 0;
        for (k = 0; k < depth; k++) {
          inverse[j * depth + k] -= (factor * inverse[i * depth + k]);
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<linvert_matrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    119e <linvert_matrix+0x9e>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    116f <linvert_matrix+0x6f>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1137 <linvert_matrix+0x37>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  0xe78(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1121 <linvert_matrix+0x21>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1380 <linvert_matrix+0x280>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    11f7 <linvert_matrix+0xf7>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe2c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    120c <linvert_matrix+0x10c>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movq   $0x1,(%rax,%rcx,8)
jmp    136a <linvert_matrix+0x26a>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1365 <linvert_matrix+0x265>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12d3 <linvert_matrix+0x1d3>
movsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    125f <linvert_matrix+0x15f>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    134f <linvert_matrix+0x24f>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12db <linvert_matrix+0x1db>
jmp    1354 <linvert_matrix+0x254>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1218 <linvert_matrix+0x118>
jmp    136a <linvert_matrix+0x26a>
jmp    136f <linvert_matrix+0x26f>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11a6 <linvert_matrix+0xa6>
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jl     152a <linvert_matrix+0x42a>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1514 <linvert_matrix+0x414>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  0xc3d(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1414 <linvert_matrix+0x314>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13d5 <linvert_matrix+0x2d5>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  0xbd3(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jl     150f <linvert_matrix+0x40f>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    14f9 <linvert_matrix+0x3f9>
movsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1485 <linvert_matrix+0x385>
jmp    14fe <linvert_matrix+0x3fe>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    143e <linvert_matrix+0x33e>
jmp    1514 <linvert_matrix+0x414>
jmp    1519 <linvert_matrix+0x419>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    138c <linvert_matrix+0x28c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<linvert_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rcx,0x80(%rsp)
mov    %rdx,(%rsp)
test   %rsi,%rsi
jle    1cbc <linvert_matrix+0xbac>
mov    %rsi,%rbx
lea    0x0(,%rsi,8),%rcx
lea    -0x1(%rsi),%rax
mov    %ebx,%edx
and    $0x3,%edx
mov    %rdx,0x38(%rsp)
mov    %rax,0x78(%rsp)
cmp    $0x3,%rax
mov    %rdi,0x10(%rsp)
movsd  %xmm0,0x98(%rsp)
mov    %rcx,0x18(%rsp)
jae    1175 <linvert_matrix+0x65>
xor    %r13d,%r13d
jmp    12c5 <linvert_matrix+0x1b5>
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rsp)
mov    %rbx,%rax
shl    $0x4,%rax
mov    %rax,0x30(%rsp)
add    $0x10,%rax
mov    %rax,0x8(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0x48(%rsp)
add    $0x20,%rax
mov    %rax,0x40(%rsp)
lea    0x8(%rcx),%r15
lea    (%rcx,%rcx,2),%rax
mov    %rax,0x28(%rsp)
lea    (%rcx,%rcx,2),%rdx
add    $0x18,%rdx
xor    %esi,%esi
xor    %r14d,%r14d
mov    %rcx,%rbp
xor    %r13d,%r13d
mov    (%rsp),%r12
nop
mov    %rbp,0x70(%rsp)
mov    %r15,0x50(%rsp)
mov    %r14,0x58(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rdx,0x68(%rsp)
lea    (%r12,%rsi,1),%rdi
xor    %esi,%esi
mov    0x18(%rsp),%rdx
call   1030 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12,%r14,1)
lea    (%r12,%rbp,1),%rdi
xor    %esi,%esi
mov    0x18(%rsp),%rbp
mov    %rbp,%rdx
call   1030 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12,%r15,1)
mov    0x30(%rsp),%rax
lea    (%r12,%rax,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%r15
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12,%r15,1)
mov    0x28(%rsp),%r14
lea    (%r12,%r14,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
mov    0x60(%rsp),%rsi
mov    0x68(%rsp),%rdx
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r12,%rdx,1)
add    $0x4,%r13
mov    0x40(%rsp),%rcx
add    %rcx,%r15
mov    %r15,0x8(%rsp)
mov    0x70(%rsp),%rbp
mov    0x50(%rsp),%r15
mov    0x48(%rsp),%rax
add    %rax,0x30(%rsp)
add    %rcx,%r15
add    %rax,%rbp
add    %rcx,%rdx
add    %rax,%r14
mov    %r14,0x28(%rsp)
mov    0x58(%rsp),%r14
add    %rcx,%r14
add    %rax,%rsi
cmp    %r13,0x20(%rsp)
jne    11d0 <linvert_matrix+0xc0>
mov    0x38(%rsp),%r12
test   %r12,%r12
movabs $0x3ff0000000000000,%r14
mov    0x18(%rsp),%r15
je     1324 <linvert_matrix+0x214>
lea    0x1(%rbx),%rax
imul   %r13,%rax
mov    (%rsp),%rsi
lea    (%rsi,%rax,8),%rbp
lea    0x8(%r15),%rax
mov    %rax,0x30(%rsp)
imul   %rbx,%r13
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rax
lea    (%rax,%r13,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    %r14,0x0(%rbp)
add    0x30(%rsp),%rbp
add    %rbx,%r13
add    $0xffffffffffffffff,%r12
jne    1300 <linvert_matrix+0x1f0>
test   %rbx,%rbx
mov    0x10(%rsp),%rax
movsd  0x98(%rsp),%xmm9
jle    1cbc <linvert_matrix+0xbac>
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
mov    %rcx,0x88(%rsp)
lea    0x1(%rbx),%rcx
mov    %rcx,0xb8(%rsp)
lea    -0x4(%rbx),%rcx
mov    %rcx,0x70(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0xd0(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x50(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xc8(%rsp)
mov    %rbx,%rcx
neg    %rcx
mov    %rcx,0x30(%rsp)
add    $0x10,%rax
mov    %rax,0xb0(%rsp)
lea    0x0(,%rbx,8),%rax
mov    %rax,0x18(%rsp)
mov    (%rsp),%rcx
lea    0x30(%rcx),%rax
mov    %rax,0xa8(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0xa0(%rsp)
xor    %edx,%edx
movapd 0xc24(%rip),%xmm8
movapd 0xc2c(%rip),%xmm0
mov    0x80(%rsp),%rax
jmp    140b <linvert_matrix+0x2fb>
xchg   %ax,%ax
movq   $0x1,(%rax,%rdx,8)
add    $0x1,%rdx
mov    %rdx,%r12
mov    %r12,%rdx
cmp    %rbx,%r12
je     1858 <linvert_matrix+0x748>
cmpq   $0x0,(%rax,%rdx,8)
jne    13f0 <linvert_matrix+0x2e0>
mov    %rdx,%rbp
imul   %rbx,%rbp
lea    (%rdx,%rbp,1),%rsi
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm3
movapd %xmm3,%xmm2
andpd  %xmm8,%xmm2
ucomisd %xmm2,%xmm9
ja     13f0 <linvert_matrix+0x2e0>
lea    0x1(%rdx),%r12
cmp    %rbx,%r12
jge    13ff <linvert_matrix+0x2ef>
mov    %rsi,0x58(%rsp)
mov    %r12,%rax
imul   %rbx,%rax
lea    0x10(,%rdx,8),%rcx
imul   %rbx,%rcx
mov    %rcx,0x100(%rsp)
mov    (%rsp),%r9
lea    (%r9,%rbp,8),%rcx
mov    %rcx,0xf8(%rsp)
lea    0x8(,%rdx,8),%rcx
imul   %rbx,%rcx
add    %r9,%rcx
mov    %rcx,0x40(%rsp)
lea    (%rdx,%rax,1),%r8
lea    (%rax,%rbx,1),%rcx
mov    %rcx,0xf0(%rsp)
mov    0xb8(%rsp),%rsi
imul   %rdx,%rsi
mov    0x10(%rsp),%r15
lea    (%r15,%rsi,8),%rcx
mov    %rcx,0xe8(%rsp)
lea    (%rbx,%rbp,1),%rcx
lea    (%r15,%rcx,8),%rcx
mov    %rcx,0x90(%rsp)
mov    %rbx,%r13
sub    %rdx,%r13
mov    %r13,0x60(%rsp)
and    $0xfffffffffffffffc,%r13
mov    %rdx,0x68(%rsp)
mov    %r13,0xd8(%rsp)
lea    (%rdx,%r13,1),%rcx
mov    %rcx,0xe0(%rsp)
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rsi,8),%r10
mov    %r8,0x38(%rsp)
lea    (%rcx,%r8,8),%r14
lea    (%r15,%rax,8),%r11
lea    (%r15,%rbp,8),%r8
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rbp,8),%rdx
lea    (%rcx,%rax,8),%rsi
mov    %rax,0x48(%rsp)
lea    (%r9,%rax,8),%rax
mov    0xa0(%rsp),%rcx
mov    %rbp,0x20(%rsp)
lea    (%rcx,%rbp,8),%rbp
xor    %r9d,%r9d
mov    %r12,0xc0(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r9,0x8(%rsp)
imul   %rbx,%r9
mov    %r12,%rcx
imul   %rbx,%rcx
mov    0x68(%rsp),%rdi
mov    %rcx,0x28(%rsp)
add    %rdi,%rcx
movsd  (%r15,%rcx,8),%xmm2
divsd  %xmm3,%xmm2
xorpd  %xmm0,%xmm2
mov    %rdi,%rcx
cmpq   $0x4,0x60(%rsp)
jb     1620 <linvert_matrix+0x510>
mov    0x38(%rsp),%rcx
add    %r9,%rcx
mov    0x10(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
cmp    0x90(%rsp),%rcx
jae    15b8 <linvert_matrix+0x4a8>
mov    0xf0(%rsp),%rcx
add    %r9,%rcx
mov    0x10(%rsp),%rdi
lea    (%rdi,%rcx,8),%r15
mov    0x68(%rsp),%rcx
cmp    %r15,0xe8(%rsp)
jb     1620 <linvert_matrix+0x510>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
xor    %ecx,%ecx
mov    0xd8(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%r10,%rcx,8),%xmm4
movupd (%r10,%rcx,8),%xmm5
movupd -0x10(%r14,%rcx,8),%xmm6
movupd (%r14,%rcx,8),%xmm7
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm7,%xmm5
movupd %xmm4,-0x10(%r14,%rcx,8)
movupd %xmm5,(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    15d0 <linvert_matrix+0x4c0>
mov    0xe0(%rsp),%rcx
cmp    %rdi,0x60(%rsp)
je     163f <linvert_matrix+0x52f>
nop
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%r11,%rcx,8),%xmm1
movsd  %xmm1,(%r11,%rcx,8)
add    $0x1,%rcx
cmp    %rbx,%rcx
jl     1620 <linvert_matrix+0x510>
cmp    $0x4,%rbx
jb     167e <linvert_matrix+0x56e>
mov    0x48(%rsp),%rcx
add    %r9,%rcx
mov    (%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
cmp    %rcx,0x40(%rsp)
jbe    1710 <linvert_matrix+0x600>
mov    (%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
add    0x100(%rsp),%rcx
cmp    0xf8(%rsp),%rcx
jbe    1710 <linvert_matrix+0x600>
xor    %edi,%edi
mov    0x8(%rsp),%r9
mov    %rdi,%rcx
test   $0x1,%bl
je     16c1 <linvert_matrix+0x5b1>
mov    0x20(%rsp),%rcx
add    %rdi,%rcx
mov    0x28(%rsp),%r15
add    %rdi,%r15
mov    (%rsp),%r13
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x0(%r13,%r15,8),%xmm1
movsd  %xmm1,0x0(%r13,%r15,8)
mov    %rdi,%rcx
or     $0x1,%rcx
not    %rdi
cmp    0x30(%rsp),%rdi
je     1810 <linvert_matrix+0x700>
nop
movsd  -0x8(%rbp,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x8(%rax,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    16d0 <linvert_matrix+0x5c0>
jmp    1810 <linvert_matrix+0x700>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x4,0x70(%rsp)
jae    172c <linvert_matrix+0x61c>
xor    %edi,%edi
mov    0x8(%rsp),%r9
jmp    17af <linvert_matrix+0x69f>
mov    0xc8(%rsp),%rcx
xor    %edi,%edi
mov    0x8(%rsp),%r9
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm4
movupd -0x20(%rdx,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
movupd -0x30(%rsi,%rdi,8),%xmm6
addpd  %xmm4,%xmm6
movupd -0x20(%rsi,%rdi,8),%xmm4
movupd -0x10(%rsi,%rdi,8),%xmm7
movupd (%rsi,%rdi,8),%xmm1
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,-0x30(%rsi,%rdi,8)
movupd %xmm5,-0x20(%rsi,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%rsi,%rdi,8)
movupd %xmm5,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1740 <linvert_matrix+0x630>
testb  $0x1,0x50(%rsp)
je     17fb <linvert_matrix+0x6eb>
mov    0x20(%rsp),%rcx
lea    (%rdi,%rcx,1),%r15
mov    (%rsp),%rcx
movupd (%rcx,%r15,8),%xmm1
movupd 0x10(%rcx,%r15,8),%xmm4
add    0x28(%rsp),%rdi
movupd (%rcx,%rdi,8),%xmm5
movupd 0x10(%rcx,%rdi,8),%xmm6
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm1,(%rcx,%rdi,8)
movupd %xmm4,0x10(%rcx,%rdi,8)
mov    0xd0(%rsp),%rcx
mov    %rcx,%rdi
cmp    %rbx,%rcx
jne    1685 <linvert_matrix+0x575>
nop
add    $0x1,%r12
cmp    %rbx,%r12
jge    1843 <linvert_matrix+0x733>
mov    0x10(%rsp),%r15
mov    0x58(%rsp),%rcx
movsd  (%r15,%rcx,8),%xmm3
add    $0x1,%r9
mov    0x18(%rsp),%rcx
add    %rcx,%r14
add    %rcx,%r11
add    %rcx,%rsi
add    %rcx,%rax
jmp    1540 <linvert_matrix+0x430>
mov    0x80(%rsp),%rax
mov    0xc0(%rsp),%r12
jmp    13ff <linvert_matrix+0x2ef>
test   %rbx,%rbx
mov    0x10(%rsp),%r15
jle    1cbc <linvert_matrix+0xbac>
lea    -0x2(%rbx),%rsi
imul   %rbx,%rsi
lea    -0x8(,%rbx,8),%rax
ff
imul   %rbx,%rax
mov    %rax,0x60(%rsp)
mov    0x78(%rsp),%rcx
imul   %rbx,%rcx
mov    %rbx,%rax
imul   %rbx,%rax
mov    %rax,0x90(%rsp)
mov    %rbx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    0x50(%rsp),%rax
and    %rax,0x88(%rsp)
mov    (%rsp),%rax
lea    (%rax,%rcx,8),%rdx
add    $0x30,%rdx
negq   0x18(%rsp)
mov    %rcx,0x78(%rsp)
lea    (%rax,%rcx,8),%rbp
lea    (%rax,%rsi,8),%rcx
add    $0x30,%rcx
mov    %rcx,0x48(%rsp)
mov    %rsi,0x28(%rsp)
lea    (%rax,%rsi,8),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
movsd  0x72b(%rip),%xmm8
mov    %rbx,%rcx
jmp    192a <linvert_matrix+0x81a>
nopw   0x0(%rax,%rax,1)
addq   $0x1,0x38(%rsp)
mov    0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rbp
add    %rax,0x48(%rsp)
add    %rax,0x40(%rsp)
cmpq   $0x1,0x20(%rsp)
mov    %r10,%rcx
jle    1cbc <linvert_matrix+0xbac>
lea    -0x1(%rcx),%r10
mov    0x80(%rsp),%rax
mov    %rcx,0x20(%rsp)
cmpq   $0x0,-0x8(%rax,%rcx,8)
jne    1900 <linvert_matrix+0x7f0>
mov    %r10,%rax
imul   %rbx,%rax
mov    %rax,%rcx
mov    %rax,0x8(%rsp)
add    %r10,%rax
movapd %xmm8,%xmm2
divsd  (%r15,%rax,8),%xmm2
cmp    $0x4,%rbx
jae    1977 <linvert_matrix+0x867>
xor    %ecx,%ecx
movabs $0x3ff0000000000000,%r8
jmp    1a30 <linvert_matrix+0x920>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x4,0x70(%rsp)
movabs $0x3ff0000000000000,%r8
jae    1999 <linvert_matrix+0x889>
xor    %ecx,%ecx
mov    (%rsp),%rdi
jmp    19f8 <linvert_matrix+0x8e8>
mov    0x88(%rsp),%rsi
xor    %ecx,%ecx
mov    (%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rcx,8),%xmm4
movupd -0x20(%rdx,%rcx,8),%xmm5
movupd -0x10(%rdx,%rcx,8),%xmm6
movupd (%rdx,%rcx,8),%xmm7
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rdx,%rcx,8)
movupd %xmm5,-0x20(%rdx,%rcx,8)
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
movupd %xmm6,-0x10(%rdx,%rcx,8)
movupd %xmm7,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    19b0 <linvert_matrix+0x8a0>
testb  $0x1,0x50(%rsp)
je     1a22 <linvert_matrix+0x912>
add    0x8(%rsp),%rcx
movupd (%rdi,%rcx,8),%xmm4
movupd 0x10(%rdi,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%rdi,%rcx,8)
movupd %xmm5,0x10(%rdi,%rcx,8)
mov    0x58(%rsp),%rsi
mov    %rsi,%rcx
cmp    %rbx,%rsi
je     1a49 <linvert_matrix+0x939>
nop
movsd  0x0(%rbp,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1a30 <linvert_matrix+0x920>
mov    %r8,(%r15,%rax,8)
mov    0x20(%rsp),%rsi
cmp    $0x2,%rsi
jl     1cbc <linvert_matrix+0xbac>
mov    0x38(%rsp),%r11
imul   %rbx,%r11
mov    0x78(%rsp),%rax
sub    %r11,%rax
mov    0x90(%rsp),%rcx
sub    %r11,%rcx
mov    (%rsp),%rdi
lea    (%rdi,%rax,8),%rax
mov    %rax,0x68(%rsp)
lea    (%rdi,%rcx,8),%r12
lea    -0x2(%rsi),%r13
mov    0x40(%rsp),%r9
mov    0x48(%rsp),%r8
xor    %ecx,%ecx
jmp    1abf <linvert_matrix+0x9af>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r13),%rax
add    $0x1,%rcx
mov    0x18(%rsp),%rsi
add    %rsi,%r8
add    %rsi,%r9
test   %r13,%r13
mov    %rax,%r13
jle    1900 <linvert_matrix+0x7f0>
mov    %r13,%r14
imul   %rbx,%r14
lea    (%r14,%r10,1),%rax
movsd  (%r15,%rax,8),%xmm2
movq   $0x0,(%r15,%rax,8)
xorpd  %xmm0,%xmm2
cmp    $0x4,%rbx
jae    1af0 <linvert_matrix+0x9e0>
xor    %edi,%edi
jmp    1c30 <linvert_matrix+0xb20>
nopl   0x0(%rax)
mov    %rcx,%rax
imul   %rbx,%rax
add    %r11,%rax
mov    0x28(%rsp),%rdi
sub    %rax,%rdi
mov    (%rsp),%r15
lea    (%r15,%rdi,8),%rdi
cmp    %r12,%rdi
jae    1b30 <linvert_matrix+0xa20>
shl    $0x3,%rax
sub    %rax,%r15
add    0x60(%rsp),%r15
cmp    0x68(%rsp),%r15
jbe    1b30 <linvert_matrix+0xa20>
xor    %edi,%edi
mov    0x10(%rsp),%r15
jmp    1c30 <linvert_matrix+0xb20>
xchg   %ax,%ax
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x4,0x70(%rsp)
jae    1b4c <linvert_matrix+0xa3c>
xor    %edi,%edi
mov    0x10(%rsp),%r15
jmp    1bd7 <linvert_matrix+0xac7>
mov    0x88(%rsp),%rax
xor    %edi,%edi
mov    0x10(%rsp),%r15
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm4
movupd -0x20(%rdx,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
movupd -0x30(%r8,%rdi,8),%xmm6
addpd  %xmm4,%xmm6
movupd -0x20(%r8,%rdi,8),%xmm4
movupd -0x10(%r8,%rdi,8),%xmm7
movupd (%r8,%rdi,8),%xmm1
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm6,-0x30(%r8,%rdi,8)
movupd %xmm5,-0x20(%r8,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,-0x10(%r8,%rdi,8)
movupd %xmm5,(%r8,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rax
jne    1b60 <linvert_matrix+0xa50>
testb  $0x1,0x50(%rsp)
je     1c1e <linvert_matrix+0xb0e>
mov    0x8(%rsp),%rax
add    %rdi,%rax
mov    (%rsp),%rsi
movupd (%rsi,%rax,8),%xmm1
movupd 0x10(%rsi,%rax,8),%xmm4
add    %r14,%rdi
movupd (%rsi,%rdi,8),%xmm5
movupd 0x10(%rsi,%rdi,8),%xmm6
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm1,(%rsi,%rdi,8)
movupd %xmm4,0x10(%rsi,%rdi,8)
mov    0x58(%rsp),%rax
mov    %rax,%rdi
cmp    %rbx,%rax
je     1aa0 <linvert_matrix+0x990>
nop
mov    %rdi,%rax
test   $0x1,%bl
je     1c63 <linvert_matrix+0xb53>
mov    0x8(%rsp),%rax
add    %rdi,%rax
add    %rdi,%r14
mov    (%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%rsi,%r14,8),%xmm1
movsd  %xmm1,(%rsi,%r14,8)
mov    %rdi,%rax
or     $0x1,%rax
not    %rdi
cmp    0x30(%rsp),%rdi
je     1aa0 <linvert_matrix+0x990>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  (%r9,%rax,8),%xmm1
movsd  %xmm1,(%r9,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x8(%r9,%rax,8),%xmm1
movsd  %xmm1,0x8(%r9,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1c80 <linvert_matrix+0xb70>
jmp    1aa0 <linvert_matrix+0x990>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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