#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);
bool matrix_invert(double mat[4][4], double inverse[4][4]) {
  double Det2_12_01 = mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0];
  double Det2_12_02 = mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0];
  double Det2_12_12 = mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1];
  double Det2_13_01 = mat[1][0] * mat[3][1] - mat[1][1] * mat[3][0];
  double Det2_13_03 = mat[1][0] * mat[3][3] - mat[1][3] * mat[3][0];
  double Det2_13_13 = mat[1][1] * mat[3][3] - mat[1][3] * mat[3][1];
  double Det2_23_01 = mat[2][0] * mat[3][1] - mat[2][1] * mat[3][0];
  double Det2_23_02 = mat[2][0] * mat[3][2] - mat[2][2] * mat[3][0];
  double Det2_23_03 = mat[2][0] * mat[3][3] - mat[2][3] * mat[3][0];
  double Det2_23_12 = mat[2][1] * mat[3][2] - mat[2][2] * mat[3][1];
  double Det2_23_13 = mat[2][1] * mat[3][3] - mat[2][3] * mat[3][1];
  double Det2_23_23 = mat[2][2] * mat[3][3] - mat[2][3] * mat[3][2];
  double Det3_012_012 =
      mat[0][0] * Det2_12_12 - mat[0][1] * Det2_12_02 + mat[0][2] * Det2_12_01;
  double Det3_013_013 =
      mat[0][0] * Det2_13_13 - mat[0][1] * Det2_13_03 + mat[0][3] * Det2_13_01;
  double Det3_023_023 =
      mat[0][0] * Det2_23_23 - mat[0][2] * Det2_23_03 + mat[0][3] * Det2_23_02;
  double Det3_123_012 =
      mat[1][0] * Det2_23_12 - mat[1][1] * Det2_23_02 + mat[1][2] * Det2_23_01;
  double Det3_123_013 =
      mat[1][0] * Det2_23_13 - mat[1][1] * Det2_23_03 + mat[1][3] * Det2_23_01;
  double Det3_123_023 =
      mat[1][0] * Det2_23_23 - mat[1][2] * Det2_23_03 + mat[1][3] * Det2_23_02;
  double Det3_123_123 =
      mat[1][1] * Det2_23_23 - mat[1][2] * Det2_23_13 + mat[1][3] * Det2_23_12;
  static double det;
  det = mat[0][0] * Det3_123_123 - mat[0][1] * Det3_123_023 +
        mat[0][2] * Det3_123_013 - mat[0][3] * Det3_123_012;
  if (fabs(det) < 0.0001)
    return false;
  inverse[0][0] = Det3_123_123 / det;
  inverse[1][1] = Det3_023_023 / det;
  inverse[2][2] = Det3_013_013 / det;
  inverse[3][3] = Det3_012_012 / det;
  return true;
}


x86 assembly (clang, -O0):
<matrix_invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x40(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x40(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x48(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x60(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x68(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x70(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x20(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x40(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x78(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x68(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mulsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x70(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm1
movsd  -0x78(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mulsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm1
movsd  -0x78(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
mulsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28be(%rip)
movsd  0x28b6(%rip),%xmm1
movaps 0x897(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x87b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    179b <matrix_invert+0x69b>
movl   $0x0,-0x4(%rbp)
jmp    1802 <matrix_invert+0x702>
movsd  -0xb0(%rbp),%xmm0
ff
divsd  0x287d(%rip),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
divsd  0x2865(%rip),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x88(%rbp),%xmm0
ff
divsd  0x284c(%rip),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x80(%rbp),%xmm0
divsd  0x2836(%rip),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,0x78(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix_invert>:
movsd  0x20(%rdi),%xmm15
movsd  0x48(%rdi),%xmm7
movsd  0x28(%rdi),%xmm13
movsd  0x40(%rdi),%xmm6
movsd  0x50(%rdi),%xmm8
movsd  0x68(%rdi),%xmm12
movsd  0x60(%rdi),%xmm5
movsd  0x78(%rdi),%xmm11
movapd %xmm5,%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm6,%xmm0
mulsd  %xmm12,%xmm0
subsd  %xmm1,%xmm0
movsd  0x70(%rdi),%xmm4
movapd %xmm5,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm6,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm1,%xmm3
movsd  0x58(%rdi),%xmm2
movsd  %xmm5,-0x20(%rsp)
movapd %xmm5,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm6,-0x8(%rsp)
mulsd  %xmm11,%xmm6
subsd  %xmm1,%xmm6
movapd %xmm12,%xmm1
mulsd  %xmm8,%xmm1
movapd %xmm7,%xmm9
mulsd  %xmm4,%xmm9
subsd  %xmm1,%xmm9
movapd %xmm12,%xmm5
mulsd  %xmm2,%xmm5
movsd  %xmm7,-0x18(%rsp)
movapd %xmm7,%xmm1
mulsd  %xmm11,%xmm1
subsd  %xmm5,%xmm1
mulsd  %xmm2,%xmm4
movsd  %xmm8,-0x10(%rsp)
mulsd  %xmm11,%xmm8
subsd  %xmm4,%xmm8
movapd %xmm3,%xmm2
mulsd  %xmm13,%xmm2
movapd %xmm15,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm2,%xmm5
movsd  0x30(%rdi),%xmm10
movapd %xmm10,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm6,%xmm2
mulsd  %xmm13,%xmm2
movapd %xmm15,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm2,%xmm5
movsd  0x38(%rdi),%xmm14
mulsd  %xmm14,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm6,%xmm2
mulsd  %xmm10,%xmm2
movapd %xmm15,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm2,%xmm5
movapd %xmm14,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm10,%xmm1
movapd %xmm13,%xmm5
mulsd  %xmm8,%xmm5
subsd  %xmm1,%xmm5
mulsd  %xmm14,%xmm9
addsd  %xmm5,%xmm9
movsd  0x8(%rdi),%xmm5
mulsd  %xmm5,%xmm2
movsd  (%rdi),%xmm1
movsd  %xmm1,-0x28(%rsp)
mulsd  %xmm9,%xmm1
subsd  %xmm2,%xmm1
movsd  0x10(%rdi),%xmm2
movsd  %xmm2,-0x30(%rsp)
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18(%rdi),%xmm7
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm0
movapd 0xd74(%rip),%xmm1
andpd  %xmm0,%xmm1
xor    %eax,%eax
movsd  0xd76(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     13cb <matrix_invert+0x2cb>
movapd 0xd44(%rip),%xmm2
movapd %xmm13,%xmm1
xorpd  %xmm2,%xmm1
xorpd  %xmm2,%xmm10
xorpd  %xmm2,%xmm5
mulsd  -0x30(%rsp),%xmm6
mulsd  -0x28(%rsp),%xmm8
subsd  %xmm6,%xmm8
mulsd  %xmm7,%xmm3
addsd  %xmm8,%xmm3
movsd  -0x20(%rsp),%xmm4
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm15,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm2,%xmm6
mulsd  %xmm14,%xmm12
movapd %xmm13,%xmm2
mulsd  %xmm11,%xmm2
subsd  %xmm12,%xmm2
mulsd  %xmm14,%xmm4
mulsd  %xmm15,%xmm11
subsd  %xmm4,%xmm11
mulsd  %xmm5,%xmm11
movsd  -0x28(%rsp),%xmm8
mulsd  %xmm8,%xmm2
addsd  %xmm11,%xmm2
mulsd  %xmm7,%xmm6
addsd  %xmm2,%xmm6
movsd  -0x8(%rsp),%xmm2
mulsd  %xmm2,%xmm1
movapd %xmm15,%xmm4
movsd  -0x18(%rsp),%xmm7
mulsd  %xmm7,%xmm4
addsd  %xmm1,%xmm4
mulsd  %xmm10,%xmm7
movsd  -0x10(%rsp),%xmm1
mulsd  %xmm1,%xmm13
addsd  %xmm7,%xmm13
mulsd  %xmm10,%xmm2
mulsd  %xmm1,%xmm15
addsd  %xmm2,%xmm15
mulsd  %xmm5,%xmm15
mulsd  %xmm8,%xmm13
addsd  %xmm15,%xmm13
mulsd  -0x30(%rsp),%xmm4
addsd  %xmm13,%xmm4
divsd  %xmm0,%xmm9
movsd  %xmm9,(%rsi)
divsd  %xmm0,%xmm3
movsd  %xmm3,0x28(%rsi)
divsd  %xmm0,%xmm6
movsd  %xmm6,0x50(%rsi)
divsd  %xmm0,%xmm4
movsd  %xmm4,0x78(%rsi)
mov    $0x1,%eax
ret

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

LLVM IR (-O2):
define i32 @matrix_invert([4 x double]* nocapture %0, [4 x double]* nocapture writeonly %1) {
%3 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 0
%4 = load double, double* %3
%5 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 1
%6 = load double, double* %5
%7 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 1
%8 = load double, double* %7
%9 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 0
%10 = load double, double* %9
%11 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 2
%12 = load double, double* %11
%13 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 2
%14 = load double, double* %13
%15 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 1
%16 = load double, double* %15
%17 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 0
%18 = load double, double* %17
%19 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 3
%20 = load double, double* %19
%21 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 3
%22 = load double, double* %21
%23 = fneg double %6
%24 = fmul double %18, %23
%25 = tail call double @llvm.fmuladd.f64(double %10, double %16, double %24)
%26 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 2
%27 = load double, double* %26
%28 = fneg double %12
%29 = fmul double %18, %28
%30 = tail call double @llvm.fmuladd.f64(double %10, double %27, double %29)
%31 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 3
%32 = load double, double* %31
%33 = fneg double %32
%34 = fmul double %18, %33
%35 = tail call double @llvm.fmuladd.f64(double %10, double %20, double %34)
%36 = fmul double %16, %28
%37 = tail call double @llvm.fmuladd.f64(double %6, double %27, double %36)
%38 = fmul double %16, %33
%39 = tail call double @llvm.fmuladd.f64(double %6, double %20, double %38)
%40 = fmul double %27, %33
%41 = tail call double @llvm.fmuladd.f64(double %12, double %20, double %40)
%42 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 0
%43 = load double, double* %42
%44 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 1
%45 = load double, double* %44
%46 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 2
%47 = load double, double* %46
%48 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 3
%49 = load double, double* %48
%50 = fneg double %8
%51 = fmul double %30, %50
%52 = tail call double @llvm.fmuladd.f64(double %4, double %37, double %51)
%53 = tail call double @llvm.fmuladd.f64(double %14, double %25, double %52)
%54 = fmul double %35, %50
%55 = tail call double @llvm.fmuladd.f64(double %4, double %39, double %54)
%56 = tail call double @llvm.fmuladd.f64(double %22, double %25, double %55)
%57 = fneg double %14
%58 = fmul double %35, %57
%59 = tail call double @llvm.fmuladd.f64(double %4, double %41, double %58)
%60 = tail call double @llvm.fmuladd.f64(double %22, double %30, double %59)
%61 = fmul double %39, %57
%62 = tail call double @llvm.fmuladd.f64(double %8, double %41, double %61)
%63 = tail call double @llvm.fmuladd.f64(double %22, double %37, double %62)
%64 = fneg double %45
%65 = fmul double %60, %64
%66 = tail call double @llvm.fmuladd.f64(double %43, double %63, double %65)
%67 = tail call double @llvm.fmuladd.f64(double %47, double %56, double %66)
%68 = fneg double %49
%69 = tail call double @llvm.fmuladd.f64(double %68, double %53, double %67)
%70 = tail call double @llvm.fabs.f64(double %69)
%71 = fcmp olt double %70, 1.000000e-04
br i1 %71, label %104, label %72
72: ; preds = %2
%73 = fneg double %47
%74 = fmul double %35, %73
%75 = tail call double @llvm.fmuladd.f64(double %43, double %41, double %74)
%76 = tail call double @llvm.fmuladd.f64(double %49, double %30, double %75)
%77 = fmul double %18, %50
%78 = tail call double @llvm.fmuladd.f64(double %4, double %16, double %77)
%79 = fneg double %22
%80 = fmul double %16, %79
%81 = tail call double @llvm.fmuladd.f64(double %8, double %20, double %80)
%82 = fmul double %18, %79
%83 = tail call double @llvm.fmuladd.f64(double %4, double %20, double %82)
%84 = fmul double %83, %64
%85 = tail call double @llvm.fmuladd.f64(double %43, double %81, double %84)
%86 = tail call double @llvm.fmuladd.f64(double %49, double %78, double %85)
%87 = fmul double %10, %50
%88 = tail call double @llvm.fmuladd.f64(double %4, double %6, double %87)
%89 = fmul double %6, %57
%90 = tail call double @llvm.fmuladd.f64(double %8, double %12, double %89)
%91 = fmul double %10, %57
%92 = tail call double @llvm.fmuladd.f64(double %4, double %12, double %91)
%93 = fmul double %92, %64
%94 = tail call double @llvm.fmuladd.f64(double %43, double %90, double %93)
%95 = tail call double @llvm.fmuladd.f64(double %47, double %88, double %94)
%96 = fdiv double %63, %69
%97 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 0
store double %96, double* %97
%98 = fdiv double %76, %69
%99 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 1
store double %98, double* %99
%100 = fdiv double %86, %69
%101 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 2
store double %100, double* %101
%102 = fdiv double %95, %69
%103 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 3
store double %102, double* %103
br label %104
104: ; preds = %2, %72
%105 = phi i32 [ 1, %72 ], [ 0, %2 ]
ret i32 %105
}