#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 inverse_mod26(int);
int /*<<< orphan*/ printf(char *, ...);
void invert_hill3_key(int *key, int *invkey) {
  int det = (key[0] * key[4] * key[8] + key[1] * key[5] * key[6] +
             key[2] * key[3] * key[7]) -
            (key[2] * key[4] * key[6] + key[1] * key[3] * key[8] +
             key[0] * key[5] * key[7]);
  int idet = inverse_mod26(det);
  if (idet == 0)
    printf("Warning: key is not invertible, choose a different key.\n");
  invkey[0] = (idet * ((key[4] * key[8]) - (key[5] * key[7])) + 17576) % 26;
  invkey[1] = (idet * ((key[2] * key[7]) - (key[1] * key[8])) + 17576) % 26;
  invkey[2] = (idet * ((key[1] * key[5]) - (key[2] * key[4])) + 17576) % 26;
  invkey[3] = (idet * ((key[5] * key[6]) - (key[3] * key[8])) + 17576) % 26;
  invkey[4] = (idet * ((key[0] * key[8]) - (key[2] * key[6])) + 17576) % 26;
  invkey[5] = (idet * ((key[2] * key[3]) - (key[0] * key[5])) + 17576) % 26;
  invkey[6] = (idet * ((key[3] * key[7]) - (key[4] * key[6])) + 17576) % 26;
  invkey[7] = (idet * ((key[1] * key[6]) - (key[0] * key[7])) + 17576) % 26;
  invkey[8] = (idet * ((key[0] * key[4]) - (key[1] * key[3])) + 17576) % 26;
  printf("%d %d %d\n", invkey[0], invkey[1], invkey[2]);
  printf("%d %d %d\n", invkey[3], invkey[4], invkey[5]);
  printf("%d %d %d\n", invkey[6], invkey[7], invkey[8]);
}


x86 assembly (clang, -O0):
<invert_hill3_key>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
imul   0x10(%rcx),%eax
mov    -0x8(%rbp),%rcx
imul   0x20(%rcx),%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x14(%rdx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x18(%rdx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0xc(%rdx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x1c(%rdx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x10(%rdx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x18(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0xc(%rsi),%edx
mov    -0x8(%rbp),%rsi
imul   0x20(%rsi),%edx
add    %edx,%ecx
mov    -0x8(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x14(%rsi),%edx
mov    -0x8(%rbp),%rsi
imul   0x1c(%rsi),%edx
add    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <inverse_mod26@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jne    11e8 <invert_hill3_key+0xc8>
lea    0xe1f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x20(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x14(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x1c(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x1c(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x20(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x4(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x14(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x10(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x8(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x18(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0xc(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x20(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0xc(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x20(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x18(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x10(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0xc(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x14(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x14(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x1c(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x10(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x18(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x18(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x18(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0x1c(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x1c(%rax)
mov    -0x18(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x8(%rbp),%rdx
imul   0x10(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x8(%rbp),%rsi
imul   0xc(%rsi),%edx
sub    %edx,%ecx
imul   %ecx,%eax
add    $0x44a8,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x10(%rbp),%rax
mov    %edx,0x20(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%esi
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%ecx
lea    0xc31(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%esi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%edx
mov    -0x10(%rbp),%rax
mov    0x14(%rax),%ecx
lea    0xc0e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%esi
mov    -0x10(%rbp),%rax
mov    0x1c(%rax),%edx
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%ecx
lea    0xbeb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invert_hill3_key>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
mov    0x10(%rdi),%esi
mov    (%rdi),%r8d
mov    0x4(%rdi),%eax
mov    0x14(%rdi),%ebp
mov    %ebp,%edx
imul   %eax,%edx
mov    0x18(%rdi),%ecx
imul   %ecx,%edx
imul   %esi,%ecx
imul   %r8d,%esi
mov    0x20(%rdi),%r9d
imul   %r9d,%esi
add    %esi,%edx
mov    0x8(%rdi),%r10d
mov    0xc(%rdi),%edi
imul   %r9d,%eax
imul   %edi,%eax
imul   %r10d,%edi
mov    0x1c(%rbx),%esi
imul   %esi,%edi
add    %edx,%edi
imul   %r8d,%ebp
imul   %esi,%ebp
imul   %r10d,%ecx
add    %ecx,%eax
add    %ebp,%eax
sub    %eax,%edi
call   1030 <inverse_mod26@plt>
mov    %eax,%r15d
test   %eax,%eax
jne    11a8 <invert_hill3_key+0x78>
lea    0xe67(%rip),%rdi
call   1040 <puts@plt>
mov    0x1c(%rbx),%eax
mov    0x20(%rbx),%ecx
imul   0x10(%rbx),%ecx
imul   0x14(%rbx),%eax
sub    %eax,%ecx
imul   %r15d,%ecx
add    $0x44a8,%ecx
movslq %ecx,%rsi
imul   $0x4ec4ec4f,%rsi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
sar    $0x3,%eax
add    %ecx,%eax
lea    (%rax,%rax,4),%ecx
lea    (%rcx,%rcx,4),%ecx
add    %eax,%ecx
sub    %ecx,%esi
mov    %esi,(%r14)
mov    0x1c(%rbx),%eax
mov    0x20(%rbx),%ecx
imul   0x8(%rbx),%eax
imul   0x4(%rbx),%ecx
sub    %ecx,%eax
imul   %r15d,%eax
add    $0x44a8,%eax
movslq %eax,%rdx
imul   $0x4ec4ec4f,%rdx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
sar    $0x3,%eax
add    %ecx,%eax
lea    (%rax,%rax,4),%ecx
lea    (%rcx,%rcx,4),%ecx
add    %eax,%ecx
sub    %ecx,%edx
mov    %edx,0x4(%r14)
mov    0x10(%rbx),%eax
mov    0x14(%rbx),%ecx
imul   0x4(%rbx),%ecx
imul   0x8(%rbx),%eax
sub    %eax,%ecx
imul   %r15d,%ecx
add    $0x44a8,%ecx
movslq %ecx,%rcx
imul   $0x4ec4ec4f,%rcx,%rax
mov    %rax,%rdi
shr    $0x3f,%rdi
shr    $0x20,%rax
sar    $0x3,%eax
add    %edi,%eax
lea    (%rax,%rax,4),%edi
lea    (%rdi,%rdi,4),%edi
add    %eax,%edi
sub    %edi,%ecx
mov    %ecx,0x8(%r14)
mov    0x18(%rbx),%eax
mov    0x20(%rbx),%edi
imul   0x14(%rbx),%eax
imul   0xc(%rbx),%edi
sub    %edi,%eax
imul   %r15d,%eax
add    $0x44a8,%eax
cltq
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0xc(%r14)
mov    0x18(%rbx),%eax
mov    0x20(%rbx),%edi
imul   (%rbx),%edi
imul   0x8(%rbx),%eax
sub    %eax,%edi
imul   %r15d,%edi
add    $0x44a8,%edi
movslq %edi,%rax
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0x10(%r14)
mov    0xc(%rbx),%eax
mov    0x14(%rbx),%edi
imul   0x8(%rbx),%eax
imul   (%rbx),%edi
sub    %edi,%eax
imul   %r15d,%eax
add    $0x44a8,%eax
cltq
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0x14(%r14)
mov    0x18(%rbx),%eax
mov    0x1c(%rbx),%edi
imul   0xc(%rbx),%edi
imul   0x10(%rbx),%eax
sub    %eax,%edi
imul   %r15d,%edi
add    $0x44a8,%edi
movslq %edi,%rax
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0x18(%r14)
mov    0x18(%rbx),%eax
mov    0x1c(%rbx),%edi
imul   0x4(%rbx),%eax
imul   (%rbx),%edi
sub    %edi,%eax
imul   %r15d,%eax
add    $0x44a8,%eax
cltq
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0x1c(%r14)
mov    0xc(%rbx),%eax
mov    0x10(%rbx),%edi
imul   (%rbx),%edi
imul   0x4(%rbx),%eax
sub    %eax,%edi
imul   %r15d,%edi
add    $0x44a8,%edi
movslq %edi,%rax
imul   $0x4ec4ec4f,%rax,%rdi
mov    %rdi,%rbp
shr    $0x3f,%rbp
shr    $0x20,%rdi
sar    $0x3,%edi
add    %ebp,%edi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
sub    %ebp,%eax
mov    %eax,0x20(%r14)
lea    0xc05(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%r14),%esi
mov    0x10(%r14),%edx
mov    0x14(%r14),%ecx
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x18(%r14),%esi
mov    0x1c(%r14),%edx
mov    0x20(%r14),%ecx
mov    %rbx,%rdi
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <printf@plt>

LLVM IR (-O0):
@.str = [57 x i8] c"Warning: key is not invertible, choose a different key.\0A\00"
@.str.1 = [10 x i8] c"%d %d %d\0A\00"
define void @invert_hill3_key(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
store i32* %0, i32** %3
store i32* %1, i32** %4
%7 = load i32*, i32** %3
%8 = getelementptr inbounds i32, i32* %7, i64 0
%9 = load i32, i32* %8
%10 = load i32*, i32** %3
%11 = getelementptr inbounds i32, i32* %10, i64 4
%12 = load i32, i32* %11
%13 = mul nsw i32 %9, %12
%14 = load i32*, i32** %3
%15 = getelementptr inbounds i32, i32* %14, i64 8
%16 = load i32, i32* %15
%17 = mul nsw i32 %13, %16
%18 = load i32*, i32** %3
%19 = getelementptr inbounds i32, i32* %18, i64 1
%20 = load i32, i32* %19
%21 = load i32*, i32** %3
%22 = getelementptr inbounds i32, i32* %21, i64 5
%23 = load i32, i32* %22
%24 = mul nsw i32 %20, %23
%25 = load i32*, i32** %3
%26 = getelementptr inbounds i32, i32* %25, i64 6
%27 = load i32, i32* %26
%28 = mul nsw i32 %24, %27
%29 = add nsw i32 %17, %28
%30 = load i32*, i32** %3
%31 = getelementptr inbounds i32, i32* %30, i64 2
%32 = load i32, i32* %31
%33 = load i32*, i32** %3
%34 = getelementptr inbounds i32, i32* %33, i64 3
%35 = load i32, i32* %34
%36 = mul nsw i32 %32, %35
%37 = load i32*, i32** %3
%38 = getelementptr inbounds i32, i32* %37, i64 7
%39 = load i32, i32* %38
%40 = mul nsw i32 %36, %39
%41 = add nsw i32 %29, %40
%42 = load i32*, i32** %3
%43 = getelementptr inbounds i32, i32* %42, i64 2
%44 = load i32, i32* %43
%45 = load i32*, i32** %3
%46 = getelementptr inbounds i32, i32* %45, i64 4
%47 = load i32, i32* %46
%48 = mul nsw i32 %44, %47
%49 = load i32*, i32** %3
%50 = getelementptr inbounds i32, i32* %49, i64 6
%51 = load i32, i32* %50
%52 = mul nsw i32 %48, %51
%53 = load i32*, i32** %3
%54 = getelementptr inbounds i32, i32* %53, i64 1
%55 = load i32, i32* %54
%56 = load i32*, i32** %3
%57 = getelementptr inbounds i32, i32* %56, i64 3
%58 = load i32, i32* %57
%59 = mul nsw i32 %55, %58
%60 = load i32*, i32** %3
%61 = getelementptr inbounds i32, i32* %60, i64 8
%62 = load i32, i32* %61
%63 = mul nsw i32 %59, %62
%64 = add nsw i32 %52, %63
%65 = load i32*, i32** %3
%66 = getelementptr inbounds i32, i32* %65, i64 0
%67 = load i32, i32* %66
%68 = load i32*, i32** %3
%69 = getelementptr inbounds i32, i32* %68, i64 5
%70 = load i32, i32* %69
%71 = mul nsw i32 %67, %70
%72 = load i32*, i32** %3
%73 = getelementptr inbounds i32, i32* %72, i64 7
%74 = load i32, i32* %73
%75 = mul nsw i32 %71, %74
%76 = add nsw i32 %64, %75
%77 = sub nsw i32 %41, %76
store i32 %77, i32* %5
%78 = load i32, i32* %5
%79 = call i32 @inverse_mod26(i32 %78)
store i32 %79, i32* %6
%80 = load i32, i32* %6
%81 = icmp eq i32 %80, 0
br i1 %81, label %82, label %84
82: ; preds = %2
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str, i64 0, i64 0))
br label %84
84: ; preds = %82, %2
%85 = load i32, i32* %6
%86 = load i32*, i32** %3
%87 = getelementptr inbounds i32, i32* %86, i64 4
%88 = load i32, i32* %87
%89 = load i32*, i32** %3
%90 = getelementptr inbounds i32, i32* %89, i64 8
%91 = load i32, i32* %90
%92 = mul nsw i32 %88, %91
%93 = load i32*, i32** %3
%94 = getelementptr inbounds i32, i32* %93, i64 5
%95 = load i32, i32* %94
%96 = load i32*, i32** %3
%97 = getelementptr inbounds i32, i32* %96, i64 7
%98 = load i32, i32* %97
%99 = mul nsw i32 %95, %98
%100 = sub nsw i32 %92, %99
%101 = mul nsw i32 %85, %100
%102 = add nsw i32 %101, 17576
%103 = srem i32 %102, 26
%104 = load i32*, i32** %4
%105 = getelementptr inbounds i32, i32* %104, i64 0
store i32 %103, i32* %105
%106 = load i32, i32* %6
%107 = load i32*, i32** %3
%108 = getelementptr inbounds i32, i32* %107, i64 2
%109 = load i32, i32* %108
%110 = load i32*, i32** %3
%111 = getelementptr inbounds i32, i32* %110, i64 7
%112 = load i32, i32* %111
%113 = mul nsw i32 %109, %112
%114 = load i32*, i32** %3
%115 = getelementptr inbounds i32, i32* %114, i64 1
%116 = load i32, i32* %115
%117 = load i32*, i32** %3
%118 = getelementptr inbounds i32, i32* %117, i64 8
%119 = load i32, i32* %118
%120 = mul nsw i32 %116, %119
%121 = sub nsw i32 %113, %120
%122 = mul nsw i32 %106, %121
%123 = add nsw i32 %122, 17576
%124 = srem i32 %123, 26
%125 = load i32*, i32** %4
%126 = getelementptr inbounds i32, i32* %125, i64 1
store i32 %124, i32* %126
%127 = load i32, i32* %6
%128 = load i32*, i32** %3
%129 = getelementptr inbounds i32, i32* %128, i64 1
%130 = load i32, i32* %129
%131 = load i32*, i32** %3
%132 = getelementptr inbounds i32, i32* %131, i64 5
%133 = load i32, i32* %132
%134 = mul nsw i32 %130, %133
%135 = load i32*, i32** %3
%136 = getelementptr inbounds i32, i32* %135, i64 2
%137 = load i32, i32* %136
%138 = load i32*, i32** %3
%139 = getelementptr inbounds i32, i32* %138, i64 4
%140 = load i32, i32* %139
%141 = mul nsw i32 %137, %140
%142 = sub nsw i32 %134, %141
%143 = mul nsw i32 %127, %142
%144 = add nsw i32 %143, 17576
%145 = srem i32 %144, 26
%146 = load i32*, i32** %4
%147 = getelementptr inbounds i32, i32* %146, i64 2
store i32 %145, i32* %147
%148 = load i32, i32* %6
%149 = load i32*, i32** %3
%150 = getelementptr inbounds i32, i32* %149, i64 5
%151 = load i32, i32* %150
%152 = load i32*, i32** %3
%153 = getelementptr inbounds i32, i32* %152, i64 6
%154 = load i32, i32* %153
%155 = mul nsw i32 %151, %154
%156 = load i32*, i32** %3
%157 = getelementptr inbounds i32, i32* %156, i64 3
%158 = load i32, i32* %157
%159 = load i32*, i32** %3
%160 = getelementptr inbounds i32, i32* %159, i64 8
%161 = load i32, i32* %160
%162 = mul nsw i32 %158, %161
%163 = sub nsw i32 %155, %162
%164 = mul nsw i32 %148, %163
%165 = add nsw i32 %164, 17576
%166 = srem i32 %165, 26
%167 = load i32*, i32** %4
%168 = getelementptr inbounds i32, i32* %167, i64 3
store i32 %166, i32* %168
%169 = load i32, i32* %6
%170 = load i32*, i32** %3
%171 = getelementptr inbounds i32, i32* %170, i64 0
%172 = load i32, i32* %171
%173 = load i32*, i32** %3
%174 = getelementptr inbounds i32, i32* %173, i64 8
%175 = load i32, i32* %174
%176 = mul nsw i32 %172, %175
%177 = load i32*, i32** %3
%178 = getelementptr inbounds i32, i32* %177, i64 2
%179 = load i32, i32* %178
%180 = load i32*, i32** %3
%181 = getelementptr inbounds i32, i32* %180, i64 6
%182 = load i32, i32* %181
%183 = mul nsw i32 %179, %182
%184 = sub nsw i32 %176, %183
%185 = mul nsw i32 %169, %184
%186 = add nsw i32 %185, 17576
%187 = srem i32 %186, 26
%188 = load i32*, i32** %4
%189 = getelementptr inbounds i32, i32* %188, i64 4
store i32 %187, i32* %189
%190 = load i32, i32* %6
%191 = load i32*, i32** %3
%192 = getelementptr inbounds i32, i32* %191, i64 2
%193 = load i32, i32* %192
%194 = load i32*, i32** %3
%195 = getelementptr inbounds i32, i32* %194, i64 3
%196 = load i32, i32* %195
%197 = mul nsw i32 %193, %196
%198 = load i32*, i32** %3
%199 = getelementptr inbounds i32, i32* %198, i64 0
%200 = load i32, i32* %199
%201 = load i32*, i32** %3
%202 = getelementptr inbounds i32, i32* %201, i64 5
%203 = load i32, i32* %202
%204 = mul nsw i32 %200, %203
%205 = sub nsw i32 %197, %204
%206 = mul nsw i32 %190, %205
%207 = add nsw i32 %206, 17576
%208 = srem i32 %207, 26
%209 = load i32*, i32** %4
%210 = getelementptr inbounds i32, i32* %209, i64 5
store i32 %208, i32* %210
%211 = load i32, i32* %6
%212 = load i32*, i32** %3
%213 = getelementptr inbounds i32, i32* %212, i64 3
%214 = load i32, i32* %213
%215 = load i32*, i32** %3
%216 = getelementptr inbounds i32, i32* %215, i64 7
%217 = load i32, i32* %216
%218 = mul nsw i32 %214, %217
%219 = load i32*, i32** %3
%220 = getelementptr inbounds i32, i32* %219, i64 4
%221 = load i32, i32* %220
%222 = load i32*, i32** %3
%223 = getelementptr inbounds i32, i32* %222, i64 6
%224 = load i32, i32* %223
%225 = mul nsw i32 %221, %224
%226 = sub nsw i32 %218, %225
%227 = mul nsw i32 %211, %226
%228 = add nsw i32 %227, 17576
%229 = srem i32 %228, 26
%230 = load i32*, i32** %4
%231 = getelementptr inbounds i32, i32* %230, i64 6
store i32 %229, i32* %231
%232 = load i32, i32* %6
%233 = load i32*, i32** %3
%234 = getelementptr inbounds i32, i32* %233, i64 1
%235 = load i32, i32* %234
%236 = load i32*, i32** %3
%237 = getelementptr inbounds i32, i32* %236, i64 6
%238 = load i32, i32* %237
%239 = mul nsw i32 %235, %238
%240 = load i32*, i32** %3
%241 = getelementptr inbounds i32, i32* %240, i64 0
%242 = load i32, i32* %241
%243 = load i32*, i32** %3
%244 = getelementptr inbounds i32, i32* %243, i64 7
%245 = load i32, i32* %244
%246 = mul nsw i32 %242, %245
%247 = sub nsw i32 %239, %246
%248 = mul nsw i32 %232, %247
%249 = add nsw i32 %248, 17576
%250 = srem i32 %249, 26
%251 = load i32*, i32** %4
%252 = getelementptr inbounds i32, i32* %251, i64 7
store i32 %250, i32* %252
%253 = load i32, i32* %6
%254 = load i32*, i32** %3
%255 = getelementptr inbounds i32, i32* %254, i64 0
%256 = load i32, i32* %255
%257 = load i32*, i32** %3
%258 = getelementptr inbounds i32, i32* %257, i64 4
%259 = load i32, i32* %258
%260 = mul nsw i32 %256, %259
%261 = load i32*, i32** %3
%262 = getelementptr inbounds i32, i32* %261, i64 1
%263 = load i32, i32* %262
%264 = load i32*, i32** %3
%265 = getelementptr inbounds i32, i32* %264, i64 3
%266 = load i32, i32* %265
%267 = mul nsw i32 %263, %266
%268 = sub nsw i32 %260, %267
%269 = mul nsw i32 %253, %268
%270 = add nsw i32 %269, 17576
%271 = srem i32 %270, 26
%272 = load i32*, i32** %4
%273 = getelementptr inbounds i32, i32* %272, i64 8
store i32 %271, i32* %273
%274 = load i32*, i32** %4
%275 = getelementptr inbounds i32, i32* %274, i64 0
%276 = load i32, i32* %275
%277 = load i32*, i32** %4
%278 = getelementptr inbounds i32, i32* %277, i64 1
%279 = load i32, i32* %278
%280 = load i32*, i32** %4
%281 = getelementptr inbounds i32, i32* %280, i64 2
%282 = load i32, i32* %281
%283 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %276, i32 %279, i32 %282)
%284 = load i32*, i32** %4
%285 = getelementptr inbounds i32, i32* %284, i64 3
%286 = load i32, i32* %285
%287 = load i32*, i32** %4
%288 = getelementptr inbounds i32, i32* %287, i64 4
%289 = load i32, i32* %288
%290 = load i32*, i32** %4
%291 = getelementptr inbounds i32, i32* %290, i64 5
%292 = load i32, i32* %291
%293 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %286, i32 %289, i32 %292)
%294 = load i32*, i32** %4
%295 = getelementptr inbounds i32, i32* %294, i64 6
%296 = load i32, i32* %295
%297 = load i32*, i32** %4
%298 = getelementptr inbounds i32, i32* %297, i64 7
%299 = load i32, i32* %298
%300 = load i32*, i32** %4
%301 = getelementptr inbounds i32, i32* %300, i64 8
%302 = load i32, i32* %301
%303 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %296, i32 %299, i32 %302)
ret void
}

LLVM IR (-O2):
@.str.1 = [10 x i8] c"%d %d %d\0A\00"
@str = [56 x i8] c"Warning: key is not invertible, choose a different key.\00"
define void @invert_hill3_key(i32* nocapture %0, i32* nocapture %1) {
%3 = load i32, i32* %0
%4 = getelementptr inbounds i32, i32* %0, i64 4
%5 = load i32, i32* %4
%6 = mul nsw i32 %5, %3
%7 = getelementptr inbounds i32, i32* %0, i64 8
%8 = load i32, i32* %7
%9 = mul nsw i32 %6, %8
%10 = getelementptr inbounds i32, i32* %0, i64 1
%11 = load i32, i32* %10
%12 = getelementptr inbounds i32, i32* %0, i64 5
%13 = load i32, i32* %12
%14 = mul nsw i32 %13, %11
%15 = getelementptr inbounds i32, i32* %0, i64 6
%16 = load i32, i32* %15
%17 = mul nsw i32 %14, %16
%18 = getelementptr inbounds i32, i32* %0, i64 2
%19 = load i32, i32* %18
%20 = getelementptr inbounds i32, i32* %0, i64 3
%21 = load i32, i32* %20
%22 = mul nsw i32 %21, %19
%23 = getelementptr inbounds i32, i32* %0, i64 7
%24 = load i32, i32* %23
%25 = mul nsw i32 %22, %24
%26 = mul i32 %13, %3
%27 = mul i32 %26, %24
%28 = mul i32 %16, %5
%29 = mul i32 %28, %19
%30 = mul i32 %11, %8
%31 = mul i32 %30, %21
%32 = add i32 %31, %29
%33 = add i32 %32, %27
%34 = add i32 %17, %9
%35 = add i32 %34, %25
%36 = sub i32 %35, %33
%37 = tail call i32 @inverse_mod26(i32 %36)
%38 = icmp eq i32 %37, 0
br i1 %38, label %39, label %41
39: ; preds = %2
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str, i64 0, i64 0))
br label %41
41: ; preds = %39, %2
%42 = load i32, i32* %4
%43 = load i32, i32* %7
%44 = mul nsw i32 %43, %42
%45 = load i32, i32* %12
%46 = load i32, i32* %23
%47 = mul nsw i32 %46, %45
%48 = sub nsw i32 %44, %47
%49 = mul nsw i32 %48, %37
%50 = add nsw i32 %49, 17576
%51 = srem i32 %50, 26
store i32 %51, i32* %1
%52 = load i32, i32* %18
%53 = load i32, i32* %23
%54 = mul nsw i32 %53, %52
%55 = load i32, i32* %10
%56 = load i32, i32* %7
%57 = mul nsw i32 %56, %55
%58 = sub nsw i32 %54, %57
%59 = mul nsw i32 %58, %37
%60 = add nsw i32 %59, 17576
%61 = srem i32 %60, 26
%62 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %61, i32* %62
%63 = load i32, i32* %10
%64 = load i32, i32* %12
%65 = mul nsw i32 %64, %63
%66 = load i32, i32* %18
%67 = load i32, i32* %4
%68 = mul nsw i32 %67, %66
%69 = sub nsw i32 %65, %68
%70 = mul nsw i32 %69, %37
%71 = add nsw i32 %70, 17576
%72 = srem i32 %71, 26
%73 = getelementptr inbounds i32, i32* %1, i64 2
store i32 %72, i32* %73
%74 = load i32, i32* %12
%75 = load i32, i32* %15
%76 = mul nsw i32 %75, %74
%77 = load i32, i32* %20
%78 = load i32, i32* %7
%79 = mul nsw i32 %78, %77
%80 = sub nsw i32 %76, %79
%81 = mul nsw i32 %80, %37
%82 = add nsw i32 %81, 17576
%83 = srem i32 %82, 26
%84 = getelementptr inbounds i32, i32* %1, i64 3
store i32 %83, i32* %84
%85 = load i32, i32* %0
%86 = load i32, i32* %7
%87 = mul nsw i32 %86, %85
%88 = load i32, i32* %18
%89 = load i32, i32* %15
%90 = mul nsw i32 %89, %88
%91 = sub nsw i32 %87, %90
%92 = mul nsw i32 %91, %37
%93 = add nsw i32 %92, 17576
%94 = srem i32 %93, 26
%95 = getelementptr inbounds i32, i32* %1, i64 4
store i32 %94, i32* %95
%96 = load i32, i32* %18
%97 = load i32, i32* %20
%98 = mul nsw i32 %97, %96
%99 = load i32, i32* %0
%100 = load i32, i32* %12
%101 = mul nsw i32 %100, %99
%102 = sub nsw i32 %98, %101
%103 = mul nsw i32 %102, %37
%104 = add nsw i32 %103, 17576
%105 = srem i32 %104, 26
%106 = getelementptr inbounds i32, i32* %1, i64 5
store i32 %105, i32* %106
%107 = load i32, i32* %20
%108 = load i32, i32* %23
%109 = mul nsw i32 %108, %107
%110 = load i32, i32* %4
%111 = load i32, i32* %15
%112 = mul nsw i32 %111, %110
%113 = sub nsw i32 %109, %112
%114 = mul nsw i32 %113, %37
%115 = add nsw i32 %114, 17576
%116 = srem i32 %115, 26
%117 = getelementptr inbounds i32, i32* %1, i64 6
store i32 %116, i32* %117
%118 = load i32, i32* %10
%119 = load i32, i32* %15
%120 = mul nsw i32 %119, %118
%121 = load i32, i32* %0
%122 = load i32, i32* %23
%123 = mul nsw i32 %122, %121
%124 = sub nsw i32 %120, %123
%125 = mul nsw i32 %124, %37
%126 = add nsw i32 %125, 17576
%127 = srem i32 %126, 26
%128 = getelementptr inbounds i32, i32* %1, i64 7
store i32 %127, i32* %128
%129 = load i32, i32* %0
%130 = load i32, i32* %4
%131 = mul nsw i32 %130, %129
%132 = load i32, i32* %10
%133 = load i32, i32* %20
%134 = mul nsw i32 %133, %132
%135 = sub nsw i32 %131, %134
%136 = mul nsw i32 %135, %37
%137 = add nsw i32 %136, 17576
%138 = srem i32 %137, 26
%139 = getelementptr inbounds i32, i32* %1, i64 8
store i32 %138, i32* %139
%140 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %51, i32 %61, i32 %72)
%141 = load i32, i32* %84
%142 = load i32, i32* %95
%143 = load i32, i32* %106
%144 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %141, i32 %142, i32 %143)
%145 = load i32, i32* %117
%146 = load i32, i32* %128
%147 = load i32, i32* %139
%148 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %145, i32 %146, i32 %147)
ret void
}