#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*/ InverseRotMx(int const *, int *);
int deterRotMx(int const *);
int FindInvertableMx(const int *Mx, int *InvMx, int *nActive, int *irActive,
                     int *icActive) {
  int Init, deterMx, i;
  if (*nActive == 0 || *nActive == 3)
    return 0;
  if (*nActive == -1) {
    Init = 1;
    deterMx = deterRotMx(Mx);
    if (deterMx) {
      InverseRotMx(Mx, InvMx);
      *nActive = 3;
      return deterMx;
    }
  } else
    Init = 0;
  if (Init || *nActive == 2) {
    for (;;) {
      if (Init) {
        irActive[0] = 0;
        irActive[1] = 1;
        icActive[0] = 0;
        icActive[1] = 1;
        Init = 0;
      } else {
        if (++icActive[1] == 3) {
          if (++icActive[0] == 2) {
            if (++irActive[1] == 3) {
              if (++irActive[0] == 2) {
                Init = 1;
                break;
              } else {
                irActive[1] = irActive[0] + 1;
                icActive[0] = 0;
                icActive[1] = 1;
              }
            } else {
              icActive[0] = 0;
              icActive[1] = 1;
            }
          } else {
            icActive[1] = icActive[0] + 1;
          }
        }
      }
      InvMx[0] = Mx[irActive[1] * 3 + icActive[1]];
      InvMx[1] = -Mx[irActive[0] * 3 + icActive[1]];
      InvMx[2] = -Mx[irActive[1] * 3 + icActive[0]];
      InvMx[3] = Mx[irActive[0] * 3 + icActive[0]];
      deterMx = InvMx[3] * InvMx[0] - InvMx[1] * InvMx[2];
      if (deterMx) {
        *nActive = 2;
        return deterMx;
      }
    }
  }
  if (*nActive == 2)
    return 0;
  if (Init)
    i = 0;
  else
    i = irActive[0] * 3 + icActive[0] + 1;
  for (; i < 9; i++) {
    if (Mx[i]) {
      irActive[0] = i / 3;
      icActive[0] = i % 3;
      *nActive = 1;
      return Mx[i];
    }
  }
  if (*nActive == 1)
    return 0;
  *nActive = 0;
  return 1;
}


x86 assembly (clang, -O0):
<FindInvertableMx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x20(%rbp),%rax
cmpl   $0x0,(%rax)
je     1156 <FindInvertableMx+0x36>
mov    -0x20(%rbp),%rax
cmpl   $0x3,(%rax)
jne    1162 <FindInvertableMx+0x42>
movl   $0x0,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
mov    -0x20(%rbp),%rax
cmpl   $0xffffffff,(%rax)
jne    11b3 <FindInvertableMx+0x93>
movl   $0x1,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <deterRotMx@plt>
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     11ae <FindInvertableMx+0x8e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1040 <InverseRotMx@plt>
mov    -0x20(%rbp),%rax
movl   $0x3,(%rax)
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
jmp    11ba <FindInvertableMx+0x9a>
movl   $0x0,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    11d1 <FindInvertableMx+0xb1>
mov    -0x20(%rbp),%rax
cmpl   $0x2,(%rax)
jne    139e <FindInvertableMx+0x27e>
jmp    11d6 <FindInvertableMx+0xb6>
cmpl   $0x0,-0x34(%rbp)
je     1216 <FindInvertableMx+0xf6>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x1,0x4(%rax)
movl   $0x0,-0x34(%rbp)
jmp    12d4 <FindInvertableMx+0x1b4>
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%eax
add    $0x1,%eax
mov    %eax,0x4(%rcx)
cmp    $0x3,%eax
jne    12cf <FindInvertableMx+0x1af>
mov    -0x30(%rbp),%rcx
mov    (%rcx),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
cmp    $0x2,%eax
jne    12ba <FindInvertableMx+0x19a>
mov    -0x28(%rbp),%rcx
mov    0x4(%rcx),%eax
add    $0x1,%eax
mov    %eax,0x4(%rcx)
cmp    $0x3,%eax
jne    12a0 <FindInvertableMx+0x180>
mov    -0x28(%rbp),%rcx
mov    (%rcx),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
cmp    $0x2,%eax
jne    1276 <FindInvertableMx+0x156>
movl   $0x1,-0x34(%rbp)
jmp    1399 <FindInvertableMx+0x279>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x1,0x4(%rax)
jmp    12b5 <FindInvertableMx+0x195>
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x1,0x4(%rax)
jmp    12ca <FindInvertableMx+0x1aa>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    12cf <FindInvertableMx+0x1af>
jmp    12d4 <FindInvertableMx+0x1b4>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
add    0x4(%rdx),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
mov    -0x30(%rbp),%rdx
add    0x4(%rdx),%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   $0x3,0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    (%rax,%rdx,4),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
imul   $0x3,(%rcx),%ecx
mov    -0x30(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%eax
mov    -0x18(%rbp),%rcx
imul   (%rcx),%eax
mov    -0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x18(%rbp),%rdx
imul   0x8(%rdx),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     1394 <FindInvertableMx+0x274>
mov    -0x20(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
jmp    11d6 <FindInvertableMx+0xb6>
jmp    139e <FindInvertableMx+0x27e>
mov    -0x20(%rbp),%rax
cmpl   $0x2,(%rax)
jne    13b7 <FindInvertableMx+0x297>
movl   $0x0,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
cmpl   $0x0,-0x34(%rbp)
je     13cd <FindInvertableMx+0x2ad>
movl   $0x0,-0x3c(%rbp)
jmp    13e0 <FindInvertableMx+0x2c0>
mov    -0x28(%rbp),%rax
imul   $0x3,(%rax),%eax
mov    -0x30(%rbp),%rcx
add    (%rcx),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13e5 <FindInvertableMx+0x2c5>
cmpl   $0x9,-0x3c(%rbp)
jge    1455 <FindInvertableMx+0x335>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1442 <FindInvertableMx+0x322>
mov    -0x3c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x30(%rbp),%rax
mov    %edx,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
jmp    1447 <FindInvertableMx+0x327>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13e5 <FindInvertableMx+0x2c5>
mov    -0x20(%rbp),%rax
cmpl   $0x1,(%rax)
jne    146e <FindInvertableMx+0x34e>
movl   $0x0,-0x4(%rbp)
jmp    147f <FindInvertableMx+0x35f>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<FindInvertableMx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r8,%rbx
mov    %rcx,%r15
mov    %rdx,%r14
mov    %rdi,%r12
mov    (%rdx),%eax
lea    0x1(%rax),%ecx
cmp    $0x4,%ecx
ja     117d <FindInvertableMx+0x5d>
mov    %rsi,%r13
lea    0xeb5(%rip),%rdx
movslq (%rdx,%rcx,4),%rsi
add    %rdx,%rsi
xor    %ecx,%ecx
xor    %ebp,%ebp
jmp    *%rsi
mov    %r12,%rdi
call   1030 <deterRotMx@plt>
test   %eax,%eax
je     11d4 <FindInvertableMx+0xb4>
mov    %eax,%ebp
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <InverseRotMx@plt>
movl   $0x3,(%r14)
jmp    12d0 <FindInvertableMx+0x1b0>
mov    (%r15),%ecx
lea    (%rcx,%rcx,2),%ecx
mov    (%rbx),%edx
lea    (%rdx,%rcx,1),%ebp
add    $0x1,%ebp
cmp    $0x8,%ebp
jg     11b5 <FindInvertableMx+0x95>
movslq %ebp,%rcx
lea    (%r12,%rcx,4),%rcx
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,(%rcx)
jne    12e1 <FindInvertableMx+0x1c1>
add    $0x4,%rcx
add    $0x1,%ebp
cmp    $0x9,%ebp
jne    11a0 <FindInvertableMx+0x80>
mov    $0x0,%ebp
cmp    $0x1,%eax
je     12d0 <FindInvertableMx+0x1b0>
movl   $0x0,(%r14)
mov    $0x1,%ebp
jmp    12d0 <FindInvertableMx+0x1b0>
mov    $0x1,%ecx
movabs $0x100000000,%rax
jmp    125e <FindInvertableMx+0x13e>
add    $0x2,%ecx
nopl   0x0(%rax,%rax,1)
mov    %ecx,0x4(%rbx)
movslq 0x4(%r15),%rdx
lea    (%rdx,%rdx,2),%rdx
movslq %ecx,%rcx
add    %rdx,%rcx
mov    (%r12,%rcx,4),%ecx
mov    %ecx,0x0(%r13)
movslq (%r15),%rdx
lea    (%rdx,%rdx,2),%rdx
movslq 0x4(%rbx),%rsi
add    %rdx,%rsi
mov    (%r12,%rsi,4),%edx
mov    %edx,%esi
neg    %esi
mov    %esi,0x4(%r13)
movslq 0x4(%r15),%rsi
lea    (%rsi,%rsi,2),%rsi
movslq (%rbx),%rdi
add    %rsi,%rdi
mov    (%r12,%rdi,4),%esi
mov    %esi,%edi
neg    %edi
mov    %edi,0x8(%r13)
movslq (%r15),%rdi
lea    (%rdi,%rdi,2),%rdi
movslq (%rbx),%rbp
add    %rdi,%rbp
mov    (%r12,%rbp,4),%ebp
mov    %ebp,0xc(%r13)
imul   %ecx,%ebp
imul   %edx,%esi
xor    %ecx,%ecx
sub    %esi,%ebp
jne    12c9 <FindInvertableMx+0x1a9>
test   %ecx,%ecx
je     1280 <FindInvertableMx+0x160>
mov    %rax,(%r15)
movl   $0x0,(%rbx)
mov    $0x1,%ecx
jmp    11f0 <FindInvertableMx+0xd0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rbx),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rbx)
cmp    $0x3,%ecx
jne    11f3 <FindInvertableMx+0xd3>
mov    (%rbx),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rbx)
cmp    $0x2,%edx
jne    11e5 <FindInvertableMx+0xc5>
mov    0x4(%r15),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%r15)
cmp    $0x3,%ecx
jne    1265 <FindInvertableMx+0x145>
mov    (%r15),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%r15)
cmp    $0x2,%edx
je     130d <FindInvertableMx+0x1ed>
add    $0x2,%ecx
mov    %ecx,0x4(%r15)
jmp    1265 <FindInvertableMx+0x145>
movl   $0x2,(%r14)
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %ebp,%rax
imul   $0x55555556,%rax,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
shr    $0x20,%rdx
add    %esi,%edx
mov    %edx,(%r15)
lea    (%rdx,%rdx,2),%edx
sub    %edx,%eax
mov    %eax,(%rbx)
movl   $0x1,(%r14)
mov    (%rcx),%ebp
jmp    12d0 <FindInvertableMx+0x1b0>
mov    (%r14),%eax
xor    %ebp,%ebp
cmp    $0x2,%eax
jne    1190 <FindInvertableMx+0x70>
jmp    12d0 <FindInvertableMx+0x1b0>

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

LLVM IR (-O2):
define i32 @FindInvertableMx(i32* %0, i32* %1, i32* nocapture %2, i32* nocapture %3, i32* nocapture %4) {
%6 = load i32, i32* %2
switch i32 %6, label %85 [
i32 0, label %115
i32 3, label %115
i32 -1, label %7
i32 2, label %12
]
7: ; preds = %5
%8 = tail call i32 @deterRotMx(i32* %0)
%9 = icmp eq i32 %8, 0
br i1 %9, label %12, label %10
10: ; preds = %7
%11 = tail call i32 @InverseRotMx(i32* %0, i32* %1)
store i32 3, i32* %2
br label %115
12: ; preds = %5, %7
%13 = phi i32 [ 1, %7 ], [ 0, %5 ]
%14 = getelementptr inbounds i32, i32* %3, i64 1
%15 = getelementptr inbounds i32, i32* %4, i64 1
%16 = getelementptr inbounds i32, i32* %1, i64 1
%17 = getelementptr inbounds i32, i32* %1, i64 2
%18 = getelementptr inbounds i32, i32* %1, i64 3
br label %19
19: ; preds = %46, %12
%20 = phi i32 [ %13, %12 ], [ 0, %46 ]
%21 = icmp eq i32 %20, 0
br i1 %21, label %23, label %22
22: ; preds = %19
store i32 0, i32* %3
store i32 1, i32* %14
store i32 0, i32* %4
br label %44
23: ; preds = %19
%24 = load i32, i32* %15
%25 = add nsw i32 %24, 1
store i32 %25, i32* %15
%26 = icmp eq i32 %25, 3
br i1 %26, label %27, label %46
27: ; preds = %23
%28 = load i32, i32* %4
%29 = add nsw i32 %28, 1
store i32 %29, i32* %4
%30 = icmp eq i32 %29, 2
br i1 %30, label %31, label %42
31: ; preds = %27
%32 = load i32, i32* %14
%33 = add nsw i32 %32, 1
store i32 %33, i32* %14
%34 = icmp eq i32 %33, 3
br i1 %34, label %35, label %41
35: ; preds = %31
%36 = load i32, i32* %3
%37 = add nsw i32 %36, 1
store i32 %37, i32* %3
%38 = icmp eq i32 %37, 2
br i1 %38, label %82, label %39
39: ; preds = %35
%40 = add nsw i32 %36, 2
store i32 %40, i32* %14
store i32 0, i32* %4
br label %44
41: ; preds = %31
store i32 0, i32* %4
br label %44
42: ; preds = %27
%43 = add nsw i32 %28, 2
br label %44
44: ; preds = %22, %42, %41, %39
%45 = phi i32 [ 1, %39 ], [ 1, %41 ], [ %43, %42 ], [ 1, %22 ]
store i32 %45, i32* %15
br label %46
46: ; preds = %44, %23
%47 = phi i32 [ %25, %23 ], [ %45, %44 ]
%48 = load i32, i32* %14
%49 = mul nsw i32 %48, 3
%50 = add nsw i32 %49, %47
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %0, i64 %51
%53 = load i32, i32* %52
store i32 %53, i32* %1
%54 = load i32, i32* %3
%55 = mul nsw i32 %54, 3
%56 = load i32, i32* %15
%57 = add nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %0, i64 %58
%60 = load i32, i32* %59
%61 = sub nsw i32 0, %60
store i32 %61, i32* %16
%62 = load i32, i32* %14
%63 = mul nsw i32 %62, 3
%64 = load i32, i32* %4
%65 = add nsw i32 %63, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %0, i64 %66
%68 = load i32, i32* %67
%69 = sub nsw i32 0, %68
store i32 %69, i32* %17
%70 = load i32, i32* %3
%71 = mul nsw i32 %70, 3
%72 = load i32, i32* %4
%73 = add nsw i32 %71, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %0, i64 %74
%76 = load i32, i32* %75
store i32 %76, i32* %18
%77 = mul nsw i32 %76, %53
%78 = mul nsw i32 %68, %60
%79 = sub nsw i32 %77, %78
%80 = icmp eq i32 %79, 0
br i1 %80, label %19, label %81
81: ; preds = %46
store i32 2, i32* %2
br label %115
82: ; preds = %35
%83 = load i32, i32* %2
%84 = icmp eq i32 %83, 2
br i1 %84, label %115, label %92
85: ; preds = %5
%86 = load i32, i32* %3
%87 = mul nsw i32 %86, 3
%88 = load i32, i32* %4
%89 = add i32 %88, 1
%90 = add i32 %89, %87
%91 = icmp slt i32 %90, 9
br i1 %91, label %92, label %111
92: ; preds = %82, %85
%93 = phi i32 [ %90, %85 ], [ 0, %82 ]
%94 = phi i32 [ %6, %85 ], [ %83, %82 ]
%95 = sext i32 %93 to i64
br label %96
96: ; preds = %92, %107
%97 = phi i64 [ %95, %92 ], [ %108, %107 ]
%98 = getelementptr inbounds i32, i32* %0, i64 %97
%99 = load i32, i32* %98
%100 = icmp eq i32 %99, 0
br i1 %100, label %107, label %101
101: ; preds = %96
%102 = getelementptr inbounds i32, i32* %0, i64 %97
%103 = trunc i64 %97 to i32
%104 = sdiv i32 %103, 3
store i32 %104, i32* %3
%105 = srem i32 %103, 3
store i32 %105, i32* %4
store i32 1, i32* %2
%106 = load i32, i32* %102
br label %115
107: ; preds = %96
%108 = add nsw i64 %97, 1
%109 = trunc i64 %108 to i32
%110 = icmp eq i32 %109, 9
br i1 %110, label %111, label %96
111: ; preds = %107, %85
%112 = phi i32 [ %6, %85 ], [ %94, %107 ]
%113 = icmp eq i32 %112, 1
br i1 %113, label %115, label %114
114: ; preds = %111
store i32 0, i32* %2
br label %115
115: ; preds = %5, %5, %111, %82, %114, %101, %81, %10
%116 = phi i32 [ %8, %10 ], [ %79, %81 ], [ %106, %101 ], [ 1, %114 ], [ 0, %5 ], [ 0, %5 ], [ 0, %82 ], [ 0, %111 ]
ret i32 %116
}