#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 */
int /*<<< orphan*/ gauss_elim(double **);
void invert(double a[4][4]) {
  int i, j, k;
  double e[4][8];
  for (i = 0; i < 4; ++i)
    for (j = 0; j < 4; ++j) {
      e[i][j] = a[i][j];
      e[i][4 + j] = i == j ? 1 : 0;
    }
  gauss_elim(e);
  for (i = 4 - 1; i >= 0; --i)
    for (j = 0; j < 4; ++j) {
      for (k = i + 1; k < 4; ++k)
        e[i][4 + j] -= e[i][k] * e[k][4 + j];
      e[i][4 + j] /= e[i][i];
      a[i][j] = e[i][j + 4];
    }
}


x86 assembly (clang, -O0):
<invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    11cb <invert+0xbb>
movl   $0x0,-0x10(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    11b8 <invert+0xa8>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
cvtsi2sd %eax,%xmm0
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1137 <invert+0x27>
jmp    11bd <invert+0xad>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1126 <invert+0x16>
lea    -0x120(%rbp),%rdi
call   1030 <gauss_elim@plt>
movl   $0x3,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     1336 <invert+0x226>
movl   $0x0,-0x10(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    1323 <invert+0x213>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    1299 <invert+0x189>
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x14(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%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    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1202 <invert+0xf2>
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0xc(%rbp),%rcx
lea    -0x120(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ef <invert+0xdf>
jmp    1328 <invert+0x218>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    11de <invert+0xce>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rdi,%r12
movups (%rdi),%xmm0
movaps %xmm0,(%rsp)
movsd  0xecd(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movupd 0x10(%rdi),%xmm1
movapd %xmm1,0x10(%rsp)
xorpd  %xmm1,%xmm1
movapd %xmm1,0x30(%rsp)
movups 0x20(%rdi),%xmm2
movaps %xmm2,0x40(%rsp)
xorps  %xmm2,%xmm2
movhps 0xea0(%rip),%xmm2
movaps %xmm2,0x60(%rsp)
movups 0x30(%rdi),%xmm3
movaps %xmm3,0x50(%rsp)
movapd %xmm1,0x70(%rsp)
lea    0xa0(%rsp),%r14
movups 0x40(%rdi),%xmm3
movaps %xmm3,0x80(%rsp)
movapd %xmm1,0xa0(%rsp)
lea    0xb0(%rsp),%r15
movups 0x50(%rdi),%xmm3
movaps %xmm3,0x90(%rsp)
movaps %xmm0,0xb0(%rsp)
movups 0x60(%rdi),%xmm0
movaps %xmm0,0xc0(%rsp)
movapd %xmm1,0xe0(%rsp)
movupd 0x70(%rdi),%xmm0
movapd %xmm0,0xd0(%rsp)
movaps %xmm2,0xf0(%rsp)
mov    %rsp,%rdi
call   1030 <gauss_elim@plt>
lea    0xc8(%rsp),%rax
lea    0xa8(%rsp),%r9
mov    $0x3,%ebp
lea    0xb8(%rsp),%r8
xor    %edi,%edi
nop
mov    %rbp,%rcx
shl    $0x6,%rcx
lea    (%rsp,%rcx,1),%r10
lea    (%r10,%rbp,8),%r13
movsd  0x20(%rsp,%rcx,1),%xmm0
cmp    $0x2,%rbp
ja     1240 <invert+0x130>
lea    (%rsp,%rcx,1),%rbx
add    $0x20,%rbx
test   $0x1,%dil
jne    1260 <invert+0x150>
mov    %rbp,%rsi
cmp    $0x1,%rdi
jne    1286 <invert+0x176>
jmp    12c2 <invert+0x1b2>
nopw   0x0(%rax,%rax,1)
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x20(%rsp,%rcx,1)
mov    %rbp,%rdx
shl    $0x5,%rdx
movsd  %xmm0,(%r12,%rdx,1)
jmp    1310 <invert+0x200>
xchg   %ax,%ax
lea    0x1(%rbp),%rsi
movsd  0x8(%r10,%rbp,8),%xmm1
mov    %rsi,%rdx
shl    $0x6,%rdx
mulsd  0x20(%rsp,%rdx,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x1,%rdi
je     12c2 <invert+0x1b2>
mov    %rsi,%rdx
shl    $0x6,%rdx
add    %r14,%rdx
movsd  (%rax,%rsi,8),%xmm1
mulsd  -0x40(%rdx),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%rax,%rsi,8),%xmm1
add    $0x2,%rsi
mulsd  (%rdx),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
sub    $0xffffffffffffff80,%rdx
cmp    $0x3,%rsi
jne    1290 <invert+0x180>
mov    %rbp,%r11
divsd  0x0(%r13),%xmm0
shl    $0x5,%r11
movsd  %xmm0,0x20(%rsp,%rcx,1)
movsd  %xmm0,(%r12,%r11,1)
cmp    $0x3,%rbp
jae    1310 <invert+0x200>
lea    (%rsp,%rcx,1),%rbx
add    $0x28,%rbx
movsd  0x28(%rsp,%rcx,1),%xmm0
test   $0x1,%dil
jne    1387 <invert+0x277>
mov    %rbp,%rdx
cmp    $0x1,%rdi
jne    13ad <invert+0x29d>
jmp    13f2 <invert+0x2e2>
nopl   0x0(%rax,%rax,1)
movsd  0x28(%rsp,%rcx,1),%xmm0
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x28(%rsp,%rcx,1)
mov    %rbp,%rdx
shl    $0x5,%rdx
movsd  %xmm0,0x8(%r12,%rdx,1)
movsd  0x30(%rsp,%rcx,1),%xmm0
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x30(%rsp,%rcx,1)
mov    %rbp,%rdx
shl    $0x5,%rdx
movsd  %xmm0,0x10(%r12,%rdx,1)
movsd  0x38(%rsp,%rcx,1),%xmm0
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x38(%rsp,%rcx,1)
mov    %rbp,%rcx
shl    $0x5,%rcx
movsd  %xmm0,0x18(%r12,%rcx,1)
add    $0x1,%rdi
add    $0xffffffffffffffc0,%rax
sub    $0x1,%rbp
jae    1200 <invert+0xf0>
jmp    1547 <invert+0x437>
lea    0x1(%rbp),%rdx
movsd  0x8(%r10,%rbp,8),%xmm1
mov    %rdx,%rsi
shl    $0x6,%rsi
mulsd  0x28(%rsp,%rsi,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x1,%rdi
je     13f2 <invert+0x2e2>
mov    %rdx,%rsi
shl    $0x6,%rsi
add    %r9,%rsi
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
mulsd  -0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%rax,%rdx,8),%xmm1
add    $0x2,%rdx
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
sub    $0xffffffffffffff80,%rsi
cmp    $0x3,%rdx
jne    13c0 <invert+0x2b0>
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x28(%rsp,%rcx,1)
movsd  %xmm0,0x8(%r12,%r11,1)
cmp    $0x3,%rbp
jae    1330 <invert+0x220>
lea    (%rsp,%rcx,1),%rbx
add    $0x30,%rbx
movsd  0x30(%rsp,%rcx,1),%xmm0
test   $0x1,%dil
jne    142e <invert+0x31e>
mov    %rbp,%rdx
cmp    $0x1,%rdi
jne    1454 <invert+0x344>
jmp    1492 <invert+0x382>
lea    0x1(%rbp),%rdx
movsd  0x8(%r10,%rbp,8),%xmm1
mov    %rdx,%rsi
shl    $0x6,%rsi
mulsd  0x30(%rsp,%rsi,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x1,%rdi
je     1492 <invert+0x382>
mov    %rdx,%rsi
shl    $0x6,%rsi
add    %r15,%rsi
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm1
mulsd  -0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%rax,%rdx,8),%xmm1
add    $0x2,%rdx
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
sub    $0xffffffffffffff80,%rsi
cmp    $0x3,%rdx
jne    1460 <invert+0x350>
divsd  0x0(%r13),%xmm0
movsd  %xmm0,0x30(%rsp,%rcx,1)
movsd  %xmm0,0x10(%r12,%r11,1)
cmp    $0x3,%rbp
jae    1350 <invert+0x240>
lea    (%rsp,%rcx,1),%rbx
add    $0x38,%rbx
movsd  0x38(%rsp,%rcx,1),%xmm0
test   $0x1,%dil
jne    14d2 <invert+0x3c2>
mov    %rbp,%rdx
cmp    $0x1,%rdi
je     1356 <invert+0x246>
jmp    14fc <invert+0x3ec>
lea    0x1(%rbp),%rdx
movsd  0x8(%r10,%rbp,8),%xmm1
mov    %rdx,%rsi
shl    $0x6,%rsi
mulsd  0x38(%rsp,%rsi,1),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
cmp    $0x1,%rdi
je     1356 <invert+0x246>
mov    %rdx,%rsi
shl    $0x6,%rsi
add    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm1
mulsd  -0x40(%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%rax,%rdx,8),%xmm1
add    $0x2,%rdx
mulsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
sub    $0xffffffffffffff80,%rsi
cmp    $0x3,%rdx
jne    1510 <invert+0x400>
jmp    1356 <invert+0x246>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @invert([4 x double]* %0) {
%2 = alloca [4 x double]*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [4 x [8 x double]]
store [4 x double]* %0, [4 x double]** %2
store i32 0, i32* %3
br label %7
7: ; preds = %46, %1
%8 = load i32, i32* %3
%9 = icmp slt i32 %8, 4
br i1 %9, label %10, label %49
10: ; preds = %7
store i32 0, i32* %4
br label %11
11: ; preds = %42, %10
%12 = load i32, i32* %4
%13 = icmp slt i32 %12, 4
br i1 %13, label %14, label %45
14: ; preds = %11
%15 = load [4 x double]*, [4 x double]** %2
%16 = load i32, i32* %3
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [4 x double], [4 x double]* %15, i64 %17
%19 = load i32, i32* %4
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [4 x double], [4 x double]* %18, i64 0, i64 %20
%22 = load double, double* %21
%23 = load i32, i32* %3
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %24
%26 = load i32, i32* %4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [8 x double], [8 x double]* %25, i64 0, i64 %27
store double %22, double* %28
%29 = load i32, i32* %3
%30 = load i32, i32* %4
%31 = icmp eq i32 %29, %30
%32 = zext i1 %31 to i64
%33 = select i1 %31, i32 1, i32 0
%34 = sitofp i32 %33 to double
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %36
%38 = load i32, i32* %4
%39 = add nsw i32 4, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [8 x double], [8 x double]* %37, i64 0, i64 %40
store double %34, double* %41
br label %42
42: ; preds = %14
%43 = load i32, i32* %4
%44 = add nsw i32 %43, 1
store i32 %44, i32* %4
br label %11
45: ; preds = %11
br label %46
46: ; preds = %45
%47 = load i32, i32* %3
%48 = add nsw i32 %47, 1
store i32 %48, i32* %3
br label %7
49: ; preds = %7
%50 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 0
%51 = bitcast [8 x double]* %50 to double**
%52 = call i32 @gauss_elim(double** %51)
store i32 3, i32* %3
br label %53
53: ; preds = %131, %49
%54 = load i32, i32* %3
%55 = icmp sge i32 %54, 0
br i1 %55, label %56, label %134
56: ; preds = %53
store i32 0, i32* %4
br label %57
57: ; preds = %127, %56
%58 = load i32, i32* %4
%59 = icmp slt i32 %58, 4
br i1 %59, label %60, label %130
60: ; preds = %57
%61 = load i32, i32* %3
%62 = add nsw i32 %61, 1
store i32 %62, i32* %5
br label %63
63: ; preds = %92, %60
%64 = load i32, i32* %5
%65 = icmp slt i32 %64, 4
br i1 %65, label %66, label %95
66: ; preds = %63
%67 = load i32, i32* %3
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %68
%70 = load i32, i32* %5
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [8 x double], [8 x double]* %69, i64 0, i64 %71
%73 = load double, double* %72
%74 = load i32, i32* %5
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %75
%77 = load i32, i32* %4
%78 = add nsw i32 4, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [8 x double], [8 x double]* %76, i64 0, i64 %79
%81 = load double, double* %80
%82 = load i32, i32* %3
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %83
%85 = load i32, i32* %4
%86 = add nsw i32 4, %85
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [8 x double], [8 x double]* %84, i64 0, i64 %87
%89 = load double, double* %88
%90 = fneg double %73
%91 = call double @llvm.fmuladd.f64(double %90, double %81, double %89)
store double %91, double* %88
br label %92
92: ; preds = %66
%93 = load i32, i32* %5
%94 = add nsw i32 %93, 1
store i32 %94, i32* %5
br label %63
95: ; preds = %63
%96 = load i32, i32* %3
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %97
%99 = load i32, i32* %3
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [8 x double], [8 x double]* %98, i64 0, i64 %100
%102 = load double, double* %101
%103 = load i32, i32* %3
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %104
%106 = load i32, i32* %4
%107 = add nsw i32 4, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [8 x double], [8 x double]* %105, i64 0, i64 %108
%110 = load double, double* %109
%111 = fdiv double %110, %102
store double %111, double* %109
%112 = load i32, i32* %3
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [4 x [8 x double]], [4 x [8 x double]]* %6, i64 0, i64 %113
%115 = load i32, i32* %4
%116 = add nsw i32 %115, 4
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [8 x double], [8 x double]* %114, i64 0, i64 %117
%119 = load double, double* %118
%120 = load [4 x double]*, [4 x double]** %2
%121 = load i32, i32* %3
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [4 x double], [4 x double]* %120, i64 %122
%124 = load i32, i32* %4
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [4 x double], [4 x double]* %123, i64 0, i64 %125
store double %119, double* %126
br label %127
127: ; preds = %95
%128 = load i32, i32* %4
%129 = add nsw i32 %128, 1
store i32 %129, i32* %4
br label %57
130: ; preds = %57
br label %131
131: ; preds = %130
%132 = load i32, i32* %3
%133 = add nsw i32 %132, -1
store i32 %133, i32* %3
br label %53
134: ; preds = %53
ret void
}

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