int multy(int **input1, int **input2, int **out, int size) {
  int i, j, k;
  int **temp = (int **)malloc(size * sizeof(int *));
  for (i = 0; i < size; i++)
    temp[i] = (int *)malloc(size * sizeof(int));
  for (i = 0; i < size; i++)
    for (j = 0; j < size; j++)
      temp[i][j] = 0;
  for (i = 0; i < size; i++)
    for (j = 0; j < size; j++)
      for (k = 0; k < size; k++)
        temp[i][j] = temp[i][j] + input1[i][k] * input2[k][j];
  for (i = 0; i < size; i++)
    for (j = 0; j < size; j++)
      out[i][j] = !(temp[i][j] == 0);
  for (i = 0; i < size; i++)
    free(temp[i]);
  free(temp);
  return 0;
}


x86 assembly (clang, -O0):
<multy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movslq -0x1c(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1185 <multy+0x65>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    114f <multy+0x2f>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11e3 <multy+0xc3>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11d0 <multy+0xb0>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119f <multy+0x7f>
jmp    11d5 <multy+0xb5>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118c <multy+0x6c>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    129f <multy+0x17f>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128c <multy+0x16c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1279 <multy+0x159>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rsi
mov    (%rcx,%rsi,8),%rcx
movslq -0x24(%rbp),%rsi
imul   (%rcx,%rsi,4),%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1210 <multy+0xf0>
jmp    127e <multy+0x15e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11fd <multy+0xdd>
jmp    1291 <multy+0x171>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ea <multy+0xca>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1317 <multy+0x1f7>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1304 <multy+0x1e4>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
sete   %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b9 <multy+0x199>
jmp    1309 <multy+0x1e9>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12a6 <multy+0x186>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1349 <multy+0x229>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    131e <multy+0x1fe>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,0x20(%rsp)
mov    %rsi,%r12
mov    %rdi,0x18(%rsp)
mov    %ecx,0x4(%rsp)
movslq %ecx,%rbx
lea    0x0(,%rbx,8),%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
test   %ebx,%ebx
jle    1523 <multy+0x3f3>
lea    0x0(,%rbx,4),%r15
mov    %ebx,%r14d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1180 <multy+0x50>
cmpl   $0x0,0x4(%rsp)
jle    1523 <multy+0x3f3>
lea    0x0(,%r14,4),%rbx
lea    -0x1(%r14),%r15
mov    %r14d,%eax
and    $0x7,%eax
mov    %rax,0x10(%rsp)
cmp    $0x7,%r15
jae    11c5 <multy+0x95>
xor    %ebp,%ebp
jmp    1267 <multy+0x137>
mov    %r14d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x8(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x10(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x18(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x20(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x28(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x30(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    0x38(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    $0x8,%rbp
cmp    %rbp,0x8(%rsp)
jne    11e0 <multy+0xb0>
mov    %r13,0x8(%rsp)
cmpq   $0x0,0x10(%rsp)
je     129a <multy+0x16a>
mov    0x8(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
xor    %r13d,%r13d
mov    0x0(%rbp,%r13,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    $0x1,%r13
cmp    %r13,0x10(%rsp)
jne    1280 <multy+0x150>
cmpl   $0x0,0x4(%rsp)
mov    0x8(%rsp),%r13
jle    1523 <multy+0x3f3>
mov    %r14d,%eax
and    $0xfffffffe,%eax
xor    %r8d,%r8d
mov    0x18(%rsp),%r9
jmp    12c9 <multy+0x199>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
cmp    %r14,%r8
je     1345 <multy+0x215>
mov    0x0(%r13,%r8,8),%rdx
mov    (%r9,%r8,8),%rsi
xor    %edi,%edi
jmp    12e9 <multy+0x1b9>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %r14,%rdi
je     12c0 <multy+0x190>
mov    (%rdx,%rdi,4),%ebx
xor    %ecx,%ecx
test   %r15,%r15
je     132c <multy+0x1fc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rcx,8),%rbp
mov    0x0(%rbp,%rdi,4),%ebp
imul   (%rsi,%rcx,4),%ebp
add    %ebx,%ebp
mov    %ebp,(%rdx,%rdi,4)
mov    0x8(%r12,%rcx,8),%rbx
mov    (%rbx,%rdi,4),%ebx
imul   0x4(%rsi,%rcx,4),%ebx
add    %ebp,%ebx
mov    %ebx,(%rdx,%rdi,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1300 <multy+0x1d0>
test   $0x1,%r14b
je     12e0 <multy+0x1b0>
mov    (%r12,%rcx,8),%rbp
mov    0x0(%rbp,%rdi,4),%ebp
imul   (%rsi,%rcx,4),%ebp
add    %ebx,%ebp
mov    %ebp,(%rdx,%rdi,4)
jmp    12e0 <multy+0x1b0>
cmpl   $0x0,0x4(%rsp)
jle    1523 <multy+0x3f3>
mov    %r14d,%r9d
and    $0xfffffff8,%r9d
add    $0xfffffffffffffff8,%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r14d,%r11d
and    $0xfffffff8,%r11d
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
mov    %r14d,%r15d
and    $0x3,%r15d
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
movdqa 0xc77(%rip),%xmm1
mov    0x4(%rsp),%r12d
jmp    139d <multy+0x26d>
add    $0x1,%rbp
cmp    %r14,%rbp
je     14ff <multy+0x3cf>
mov    0x0(%r13,%rbp,8),%rbx
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rsi
cmp    $0x8,%r12d
jb     13cb <multy+0x29b>
lea    (%rbx,%r14,4),%rcx
cmp    %rcx,%rsi
jae    1450 <multy+0x320>
lea    (%rsi,%r14,4),%rcx
cmp    %rcx,%rbx
jae    1450 <multy+0x320>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %r14,%rcx
test   %r15,%r15
je     13f6 <multy+0x2c6>
mov    %r15,%rdi
xchg   %ax,%ax
xor    %eax,%eax
cmpl   $0x0,(%rbx,%rdx,4)
setne  %al
mov    %eax,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    13e0 <multy+0x2b0>
cmp    $0x3,%rcx
jb     1390 <multy+0x260>
nopl   0x0(%rax)
xor    %eax,%eax
cmpl   $0x0,(%rbx,%rdx,4)
setne  %al
mov    %eax,(%rsi,%rdx,4)
xor    %eax,%eax
cmpl   $0x0,0x4(%rbx,%rdx,4)
setne  %al
mov    %eax,0x4(%rsi,%rdx,4)
xor    %eax,%eax
cmpl   $0x0,0x8(%rbx,%rdx,4)
setne  %al
mov    %eax,0x8(%rsi,%rdx,4)
xor    %eax,%eax
cmpl   $0x0,0xc(%rbx,%rdx,4)
setne  %al
mov    %eax,0xc(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1400 <multy+0x2d0>
jmp    1390 <multy+0x260>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r9,%r9
je     14f5 <multy+0x3c5>
mov    %r8,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movdqu (%rbx,%rdx,4),%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm3
pcmpeqd %xmm0,%xmm2
pandn  %xmm1,%xmm2
pcmpeqd %xmm0,%xmm3
pandn  %xmm1,%xmm3
movdqu %xmm2,(%rsi,%rdx,4)
movdqu %xmm3,0x10(%rsi,%rdx,4)
movdqu 0x20(%rbx,%rdx,4),%xmm2
movdqu 0x30(%rbx,%rdx,4),%xmm3
pcmpeqd %xmm0,%xmm2
pandn  %xmm1,%xmm2
pcmpeqd %xmm0,%xmm3
pandn  %xmm1,%xmm3
movdqu %xmm2,0x20(%rsi,%rdx,4)
movdqu %xmm3,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1460 <multy+0x330>
test   $0x1,%r10b
je     14e4 <multy+0x3b4>
movdqu (%rbx,%rdx,4),%xmm2
movdqu 0x10(%rbx,%rdx,4),%xmm3
pcmpeqd %xmm0,%xmm2
pandn  %xmm1,%xmm2
pcmpeqd %xmm0,%xmm3
pandn  %xmm1,%xmm3
movdqu %xmm2,(%rsi,%rdx,4)
movdqu %xmm3,0x10(%rsi,%rdx,4)
mov    %r11,%rdx
cmp    %r14,%r11
je     1390 <multy+0x260>
jmp    13cd <multy+0x29d>
xor    %edx,%edx
test   $0x1,%r10b
jne    14be <multy+0x38e>
jmp    14e4 <multy+0x3b4>
test   %r12d,%r12d
jle    1523 <multy+0x3f3>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1510 <multy+0x3e0>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @multy(i32** %0, i32** %1, i32** %2, i32 %3) {
%5 = alloca i32**
%6 = alloca i32**
%7 = alloca i32**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32**
store i32** %0, i32*** %5
store i32** %1, i32*** %6
store i32** %2, i32*** %7
store i32 %3, i32* %8
%13 = load i32, i32* %8
%14 = sext i32 %13 to i64
%15 = mul i64 %14, 8
%16 = call i8* @malloc(i64 %15)
%17 = bitcast i8* %16 to i32**
store i32** %17, i32*** %12
store i32 0, i32* %9
br label %18
18: ; preds = %32, %4
%19 = load i32, i32* %9
%20 = load i32, i32* %8
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %35
22: ; preds = %18
%23 = load i32, i32* %8
%24 = sext i32 %23 to i64
%25 = mul i64 %24, 4
%26 = call i8* @malloc(i64 %25)
%27 = bitcast i8* %26 to i32*
%28 = load i32**, i32*** %12
%29 = load i32, i32* %9
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32*, i32** %28, i64 %30
store i32* %27, i32** %31
br label %32
32: ; preds = %22
%33 = load i32, i32* %9
%34 = add nsw i32 %33, 1
store i32 %34, i32* %9
br label %18
35: ; preds = %18
store i32 0, i32* %9
br label %36
36: ; preds = %58, %35
%37 = load i32, i32* %9
%38 = load i32, i32* %8
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %61
40: ; preds = %36
store i32 0, i32* %10
br label %41
41: ; preds = %54, %40
%42 = load i32, i32* %10
%43 = load i32, i32* %8
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %57
45: ; preds = %41
%46 = load i32**, i32*** %12
%47 = load i32, i32* %9
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32*, i32** %46, i64 %48
%50 = load i32*, i32** %49
%51 = load i32, i32* %10
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %50, i64 %52
store i32 0, i32* %53
br label %54
54: ; preds = %45
%55 = load i32, i32* %10
%56 = add nsw i32 %55, 1
store i32 %56, i32* %10
br label %41
57: ; preds = %41
br label %58
58: ; preds = %57
%59 = load i32, i32* %9
%60 = add nsw i32 %59, 1
store i32 %60, i32* %9
br label %36
61: ; preds = %36
store i32 0, i32* %9
br label %62
62: ; preds = %122, %61
%63 = load i32, i32* %9
%64 = load i32, i32* %8
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %125
66: ; preds = %62
store i32 0, i32* %10
br label %67
67: ; preds = %118, %66
%68 = load i32, i32* %10
%69 = load i32, i32* %8
%70 = icmp slt i32 %68, %69
br i1 %70, label %71, label %121
71: ; preds = %67
store i32 0, i32* %11
br label %72
72: ; preds = %114, %71
%73 = load i32, i32* %11
%74 = load i32, i32* %8
%75 = icmp slt i32 %73, %74
br i1 %75, label %76, label %117
76: ; preds = %72
%77 = load i32**, i32*** %12
%78 = load i32, i32* %9
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32*, i32** %77, i64 %79
%81 = load i32*, i32** %80
%82 = load i32, i32* %10
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %81, i64 %83
%85 = load i32, i32* %84
%86 = load i32**, i32*** %5
%87 = load i32, i32* %9
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32*, i32** %86, i64 %88
%90 = load i32*, i32** %89
%91 = load i32, i32* %11
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %90, i64 %92
%94 = load i32, i32* %93
%95 = load i32**, i32*** %6
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32*, i32** %95, i64 %97
%99 = load i32*, i32** %98
%100 = load i32, i32* %10
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
%103 = load i32, i32* %102
%104 = mul nsw i32 %94, %103
%105 = add nsw i32 %85, %104
%106 = load i32**, i32*** %12
%107 = load i32, i32* %9
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32*, i32** %106, i64 %108
%110 = load i32*, i32** %109
%111 = load i32, i32* %10
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %110, i64 %112
store i32 %105, i32* %113
br label %114
114: ; preds = %76
%115 = load i32, i32* %11
%116 = add nsw i32 %115, 1
store i32 %116, i32* %11
br label %72
117: ; preds = %72
br label %118
118: ; preds = %117
%119 = load i32, i32* %10
%120 = add nsw i32 %119, 1
store i32 %120, i32* %10
br label %67
121: ; preds = %67
br label %122
122: ; preds = %121
%123 = load i32, i32* %9
%124 = add nsw i32 %123, 1
store i32 %124, i32* %9
br label %62
125: ; preds = %62
store i32 0, i32* %9
br label %126
126: ; preds = %160, %125
%127 = load i32, i32* %9
%128 = load i32, i32* %8
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %163
130: ; preds = %126
store i32 0, i32* %10
br label %131
131: ; preds = %156, %130
%132 = load i32, i32* %10
%133 = load i32, i32* %8
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %159
135: ; preds = %131
%136 = load i32**, i32*** %12
%137 = load i32, i32* %9
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32*, i32** %136, i64 %138
%140 = load i32*, i32** %139
%141 = load i32, i32* %10
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
%144 = load i32, i32* %143
%145 = icmp eq i32 %144, 0
%146 = xor i1 %145, true
%147 = zext i1 %146 to i32
%148 = load i32**, i32*** %7
%149 = load i32, i32* %9
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32*, i32** %148, i64 %150
%152 = load i32*, i32** %151
%153 = load i32, i32* %10
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i32, i32* %152, i64 %154
store i32 %147, i32* %155
br label %156
156: ; preds = %135
%157 = load i32, i32* %10
%158 = add nsw i32 %157, 1
store i32 %158, i32* %10
br label %131
159: ; preds = %131
br label %160
160: ; preds = %159
%161 = load i32, i32* %9
%162 = add nsw i32 %161, 1
store i32 %162, i32* %9
br label %126
163: ; preds = %126
store i32 0, i32* %9
br label %164
164: ; preds = %175, %163
%165 = load i32, i32* %9
%166 = load i32, i32* %8
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %178
168: ; preds = %164
%169 = load i32**, i32*** %12
%170 = load i32, i32* %9
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32*, i32** %169, i64 %171
%173 = load i32*, i32** %172
%174 = bitcast i32* %173 to i8*
br label %175
175: ; preds = %168
%176 = load i32, i32* %9
%177 = add nsw i32 %176, 1
store i32 %177, i32* %9
br label %164
178: ; preds = %164
%179 = load i32**, i32*** %12
%180 = bitcast i32** %179 to i8*
ret i32 0
}

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