#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*/ forward4x4(int **, int **, int /*<<< orphan*/,
                              int /*<<< orphan*/);
int /*<<< orphan*/ inverse4x4(int **, int **, int /*<<< orphan*/,
                              int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  int out[4][4];
  int in3[4][4] = {{31, 201, 251, 130},
                   {170, 211, 5, 129},
                   {150, 14, 37, 249},
                   {236, 18, 17, 129}};
  int in[4][4] = {{31, 201, 251, 130},
                  {170, 211, 5, 129},
                  {150, 14, 37, 249},
                  {236, 18, 17, 129}};
  int in2[4][4] = {{0, 1, 1, 0}, {2, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
  forward4x4(in, out, 0, 0);
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      printf("%2d ", out[i][j]);
    }
    printf("\n");
  }
  int coeffs[4][4] = {{1978, 34, 470, -318},
                      {491, -417, -1507, -526},
                      {48, -100, -392, 530},
                      {83, -1481, -91, 532}};
  inverse4x4(coeffs, out, 0, 0);
  printf("Inverse: \n");
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      printf("%5d ", out[i][j]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x90(%rbp),%rdi
lea    0xe90(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
lea    -0xd0(%rbp),%rdi
lea    0xeb8(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1050 <memset@plt>
movl   $0x1,-0x10c(%rbp)
movl   $0x1,-0x108(%rbp)
movl   $0x2,-0x100(%rbp)
lea    -0xd0(%rbp),%rdi
lea    -0x50(%rbp),%rsi
xor    %ecx,%ecx
mov    %ecx,%edx
call   1030 <forward4x4@plt>
movl   $0x0,-0x114(%rbp)
cmpl   $0x4,-0x114(%rbp)
jge    1265 <main+0x115>
movl   $0x0,-0x118(%rbp)
cmpl   $0x4,-0x118(%rbp)
jge    1243 <main+0xf3>
movslq -0x114(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x118(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe98(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    11f8 <main+0xa8>
lea    0xe84(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    11e1 <main+0x91>
lea    -0x160(%rbp),%rdi
lea    0xe0d(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
lea    -0x160(%rbp),%rdi
lea    -0x50(%rbp),%rsi
xor    %ecx,%ecx
mov    %ecx,%edx
call   1070 <inverse4x4@plt>
lea    0xe2d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x164(%rbp)
cmpl   $0x4,-0x164(%rbp)
jge    132d <main+0x1dd>
movl   $0x0,-0x168(%rbp)
cmpl   $0x4,-0x168(%rbp)
jge    130b <main+0x1bb>
movslq -0x164(%rbp),%rcx
lea    -0x50(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x168(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xde0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    12c0 <main+0x170>
lea    0xdbc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    12a9 <main+0x159>
xor    %eax,%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0xc8,%rsp
movaps 0xecf(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movaps 0xeb0(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xe91(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xe72(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
lea    0x80(%rsp),%rdi
mov    %rsp,%r14
mov    %r14,%rsi
xor    %edx,%edx
xor    %ecx,%ecx
call   1040 <forward4x4@plt>
mov    (%rsp),%esi
lea    0xec9(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movaps 0xdae(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
movaps 0xd92(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xd76(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xd5a(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
lea    0x40(%rsp),%rdi
mov    %r14,%rsi
xor    %edx,%edx
xor    %ecx,%ecx
call   1070 <inverse4x4@plt>
lea    0xd87(%rip),%rdi
call   1050 <puts@plt>
mov    (%rsp),%esi
lea    0xd73(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@__const.main.in3 = [4 x [4 x i32]] [[4 x i32] [i32 31, i32 201, i32 251, i32 130], [4 x i32] [i32 170, i32 211, i32 5, i32 129], [4 x i32] [i32 150, i32 14, i32 37, i32 249], [4 x i32] [i32 236, i32 18, i32 17, i32 129]]
@__const.main.in = [4 x [4 x i32]] [[4 x i32] [i32 31, i32 201, i32 251, i32 130], [4 x i32] [i32 170, i32 211, i32 5, i32 129], [4 x i32] [i32 150, i32 14, i32 37, i32 249], [4 x i32] [i32 236, i32 18, i32 17, i32 129]]
@.str = [5 x i8] c"%2d \00"
@.str.1 = [2 x i8] c"\0A\00"
@__const.main.coeffs = [4 x [4 x i32]] [[4 x i32] [i32 1978, i32 34, i32 470, i32 -318], [4 x i32] [i32 491, i32 -417, i32 -1507, i32 -526], [4 x i32] [i32 48, i32 -100, i32 -392, i32 530], [4 x i32] [i32 83, i32 -1481, i32 -91, i32 532]]
@.str.2 = [11 x i8] c"Inverse: \0A\00"
@.str.3 = [5 x i8] c"%5d \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [4 x [4 x i32]]
%3 = alloca [4 x [4 x i32]]
%4 = alloca [4 x [4 x i32]]
%5 = alloca [4 x [4 x i32]]
%6 = alloca i32
%7 = alloca i32
%8 = alloca [4 x [4 x i32]]
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %1
%11 = bitcast [4 x [4 x i32]]* %3 to i8*
%12 = bitcast [4 x [4 x i32]]* %4 to i8*
%13 = bitcast [4 x [4 x i32]]* %5 to i8*
%14 = bitcast i8* %13 to [4 x [4 x i32]]*
%15 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %14, i32 0, i32 0
%16 = getelementptr inbounds [4 x i32], [4 x i32]* %15, i32 0, i32 1
store i32 1, i32* %16
%17 = getelementptr inbounds [4 x i32], [4 x i32]* %15, i32 0, i32 2
store i32 1, i32* %17
%18 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %14, i32 0, i32 1
%19 = getelementptr inbounds [4 x i32], [4 x i32]* %18, i32 0, i32 0
store i32 2, i32* %19
%20 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %4, i64 0, i64 0
%21 = bitcast [4 x i32]* %20 to i32**
%22 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %2, i64 0, i64 0
%23 = bitcast [4 x i32]* %22 to i32**
%24 = call i32 @forward4x4(i32** %21, i32** %23, i32 0, i32 0)
store i32 0, i32* %6
br label %25
25: ; preds = %46, %0
%26 = load i32, i32* %6
%27 = icmp slt i32 %26, 4
br i1 %27, label %28, label %49
28: ; preds = %25
store i32 0, i32* %7
br label %29
29: ; preds = %41, %28
%30 = load i32, i32* %7
%31 = icmp slt i32 %30, 4
br i1 %31, label %32, label %44
32: ; preds = %29
%33 = load i32, i32* %6
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %2, i64 0, i64 %34
%36 = load i32, i32* %7
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [4 x i32], [4 x i32]* %35, i64 0, i64 %37
%39 = load i32, i32* %38
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %39)
br label %41
41: ; preds = %32
%42 = load i32, i32* %7
%43 = add nsw i32 %42, 1
store i32 %43, i32* %7
br label %29
44: ; preds = %29
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %46
46: ; preds = %44
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
br label %25
49: ; preds = %25
%50 = bitcast [4 x [4 x i32]]* %8 to i8*
%51 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %8, i64 0, i64 0
%52 = bitcast [4 x i32]* %51 to i32**
%53 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %2, i64 0, i64 0
%54 = bitcast [4 x i32]* %53 to i32**
%55 = call i32 @inverse4x4(i32** %52, i32** %54, i32 0, i32 0)
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %9
br label %57
57: ; preds = %78, %49
%58 = load i32, i32* %9
%59 = icmp slt i32 %58, 4
br i1 %59, label %60, label %81
60: ; preds = %57
store i32 0, i32* %10
br label %61
61: ; preds = %73, %60
%62 = load i32, i32* %10
%63 = icmp slt i32 %62, 4
br i1 %63, label %64, label %76
64: ; preds = %61
%65 = load i32, i32* %9
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %2, i64 0, i64 %66
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [4 x i32], [4 x i32]* %67, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %71)
br label %73
73: ; preds = %64
%74 = load i32, i32* %10
%75 = add nsw i32 %74, 1
store i32 %75, i32* %10
br label %61
76: ; preds = %61
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %78
78: ; preds = %76
%79 = load i32, i32* %9
%80 = add nsw i32 %79, 1
store i32 %80, i32* %9
br label %57
81: ; preds = %57
ret i32 0
}

LLVM IR (-O2):
@__const.main.in = [4 x [4 x i32]] [[4 x i32] [i32 31, i32 201, i32 251, i32 130], [4 x i32] [i32 170, i32 211, i32 5, i32 129], [4 x i32] [i32 150, i32 14, i32 37, i32 249], [4 x i32] [i32 236, i32 18, i32 17, i32 129]]
@.str = [5 x i8] c"%2d \00"
@__const.main.coeffs = [4 x [4 x i32]] [[4 x i32] [i32 1978, i32 34, i32 470, i32 -318], [4 x i32] [i32 491, i32 -417, i32 -1507, i32 -526], [4 x i32] [i32 48, i32 -100, i32 -392, i32 530], [4 x i32] [i32 83, i32 -1481, i32 -91, i32 532]]
@.str.3 = [5 x i8] c"%5d \00"
@str = [10 x i8] c"Inverse: \00"
define i32 @main() {
%1 = alloca [4 x [4 x i32]]
%2 = alloca [4 x [4 x i32]]
%3 = alloca [4 x [4 x i32]]
%4 = bitcast [4 x [4 x i32]]* %1 to i8*
%5 = bitcast [4 x [4 x i32]]* %2 to i8*
%6 = bitcast [4 x [4 x i32]]* %2 to i32**
%7 = bitcast [4 x [4 x i32]]* %1 to i32**
%8 = call i32 @forward4x4(i32** %6, i32** %7, i32 0, i32 0)
%9 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 0, i64 0
%10 = load i32, i32* %9
%11 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %10)
%12 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 0, i64 1
%13 = load i32, i32* %12
%14 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %13)
%15 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 0, i64 2
%16 = load i32, i32* %15
%17 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %16)
%18 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 0, i64 3
%19 = load i32, i32* %18
%20 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %19)
%21 = call i32 @putchar(i32 10)
%22 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 1, i64 0
%23 = load i32, i32* %22
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %23)
%25 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 1, i64 1
%26 = load i32, i32* %25
%27 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %26)
%28 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 1, i64 2
%29 = load i32, i32* %28
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %29)
%31 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 1, i64 3
%32 = load i32, i32* %31
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %32)
%34 = call i32 @putchar(i32 10)
%35 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 2, i64 0
%36 = load i32, i32* %35
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %36)
%38 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 2, i64 1
%39 = load i32, i32* %38
%40 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %39)
%41 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 2, i64 2
%42 = load i32, i32* %41
%43 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %42)
%44 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 2, i64 3
%45 = load i32, i32* %44
%46 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %45)
%47 = call i32 @putchar(i32 10)
%48 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 3, i64 0
%49 = load i32, i32* %48
%50 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %49)
%51 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 3, i64 1
%52 = load i32, i32* %51
%53 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %52)
%54 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 3, i64 2
%55 = load i32, i32* %54
%56 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %55)
%57 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %1, i64 0, i64 3, i64 3
%58 = load i32, i32* %57
%59 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %58)
%60 = call i32 @putchar(i32 10)
%61 = bitcast [4 x [4 x i32]]* %3 to i8*
%62 = bitcast [4 x [4 x i32]]* %3 to i32**
%63 = call i32 @inverse4x4(i32** %62, i32** %7, i32 0, i32 0)
%64 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
%65 = load i32, i32* %9
%66 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %65)
%67 = load i32, i32* %12
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %67)
%69 = load i32, i32* %15
%70 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %69)
%71 = load i32, i32* %18
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %71)
%73 = call i32 @putchar(i32 10)
%74 = load i32, i32* %22
%75 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %74)
%76 = load i32, i32* %25
%77 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %76)
%78 = load i32, i32* %28
%79 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %78)
%80 = load i32, i32* %31
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %80)
%82 = call i32 @putchar(i32 10)
%83 = load i32, i32* %35
%84 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %83)
%85 = load i32, i32* %38
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %85)
%87 = load i32, i32* %41
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %87)
%89 = load i32, i32* %44
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %89)
%91 = call i32 @putchar(i32 10)
%92 = load i32, i32* %48
%93 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %92)
%94 = load i32, i32* %51
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %94)
%96 = load i32, i32* %54
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %96)
%98 = load i32, i32* %57
%99 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %98)
%100 = call i32 @putchar(i32 10)
ret i32 0
}