#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 *malloc(int);
int /*<<< orphan*/ square_matrix_add(int *, int *, int *, int);
void square_matrix_multiply(int *a1, int *b1, int num, int *c) {
  int n = num, i, j;
  int *a11, *a12, *a21, *a22;
  int *b11, *b12, *b21, *b22;
  int *c11, *c12, *c21, *c22;
  int *c11a, *c11b, *c12a, *c12b, *c21a, *c21b, *c22a, *c22b;
  if (n == 1)
    *c = *a1 * *b1;
  else {
    a11 = malloc(sizeof(int) * num * num / 4);
    a12 = malloc(sizeof(int) * num * num / 4);
    a21 = malloc(sizeof(int) * num * num / 4);
    a22 = malloc(sizeof(int) * num * num / 4);
    b11 = malloc(sizeof(int) * num * num / 4);
    b12 = malloc(sizeof(int) * num * num / 4);
    b21 = malloc(sizeof(int) * num * num / 4);
    b22 = malloc(sizeof(int) * num * num / 4);
    for (i = 0; i < num; i++) {
      for (j = 0; j < num; j++) {
        if (i + 1 <= num / 2 && j + 1 <= num / 2) {
          *(a11 + i * num / 2 + j) = *(a1 + i * num + j);
          *(b11 + i * num / 2 + j) = *(b1 + i * num + j);
        }
        if (i + 1 <= num / 2 && j + 1 > num / 2) {
          *(a12 + i * num / 2 + (j - num / 2)) = *(a1 + i * num + j);
          *(b12 + i * num / 2 + (j - num / 2)) = *(b1 + i * num + j);
        }
        if (i + 1 > num / 2 && j + 1 <= num / 2) {
          *(a21 + (i - num / 2) * num / 2 + j) = *(a1 + i * num + j);
          *(b21 + (i - num / 2) * num / 2 + j) = *(b1 + i * num + j);
        }
        if (i + 1 > num / 2 && j + 1 > num / 2) {
          *(a22 + (i - num / 2) * num / 2 + (j - num / 2)) =
              *(a1 + i * num + j);
          *(b22 + (i - num / 2) * num / 2 + (j - num / 2)) =
              *(b1 + i * num + j);
        }
      }
    }
    c11a = malloc(sizeof(int) * (num / 2) * (num / 2));
    c11b = malloc(sizeof(int) * (num / 2) * (num / 2));
    c11 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_multiply(a11, b11, num / 2, c11a);
    square_matrix_multiply(a12, b21, num / 2, c11b);
    square_matrix_add(c11a, c11b, c11, num / 2);
    c12a = malloc(sizeof(int) * (num / 2) * (num / 2));
    c12b = malloc(sizeof(int) * (num / 2) * (num / 2));
    c12 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_multiply(a11, b12, num / 2, c12a);
    square_matrix_multiply(a12, b22, num / 2, c12b);
    square_matrix_add(c12a, c12b, c12, num / 2);
    c21a = malloc(sizeof(int) * (num / 2) * (num / 2));
    c21b = malloc(sizeof(int) * (num / 2) * (num / 2));
    c21 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_multiply(a21, b11, num / 2, c21a);
    square_matrix_multiply(a22, b21, num / 2, c21b);
    square_matrix_add(c21a, c21b, c21, num / 2);
    c22a = malloc(sizeof(int) * (num / 2) * (num / 2));
    c22b = malloc(sizeof(int) * (num / 2) * (num / 2));
    c22 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_multiply(a21, b12, num / 2, c22a);
    square_matrix_multiply(a22, b22, num / 2, c22b);
    square_matrix_add(c22a, c22b, c22, num / 2);
    for (i = 0; i < num; i++)
      for (j = 0; j < num; j++) {
        if (i + 1 <= num / 2 && j + 1 <= num / 2)
          *(c + i * num + j) = *(c11 + i * num / 2 + j);
        if (i + 1 <= num / 2 && j + 1 > num / 2)
          *(c + i * num + j) = *(c12 + i * num / 2 + (j - num / 2));
        if (i + 1 > num / 2 && j + 1 <= num / 2)
          *(c + i * num + j) = *(c21 + (i - num / 2) * num / 2 + j);
        if (i + 1 > num / 2 && j + 1 > num / 2)
          *(c + i * num + j) = *(c22 + (i - num / 2) * num / 2 + (j - num / 2));
      }
  }
}


x86 assembly (clang, -O0):
<square_matrix_multiply>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jne    1172 <square_matrix_multiply+0x42>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
imul   (%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1fd5 <square_matrix_multiply+0xea5>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17b6 <square_matrix_multiply+0x686>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17a3 <square_matrix_multiply+0x673>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
cmp    %ecx,%eax
jg     1396 <square_matrix_multiply+0x266>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
cmp    %ecx,%eax
jg     1396 <square_matrix_multiply+0x266>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0xf4(%rbp),%edx
mov    %eax,%ecx
mov    -0xf0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0xe4(%rbp),%edx
mov    %eax,%ecx
mov    -0xe0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf8(%rbp),%eax
cmp    %ecx,%eax
jg     14da <square_matrix_multiply+0x3aa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
cmp    %ecx,%eax
jle    14da <square_matrix_multiply+0x3aa>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x130(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x124(%rbp),%edx
mov    %eax,%esi
mov    -0x120(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x118(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x10c(%rbp),%edx
mov    %eax,%esi
mov    -0x108(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x134(%rbp),%eax
cmp    %ecx,%eax
jle    1616 <square_matrix_multiply+0x4e6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x138(%rbp),%eax
cmp    %ecx,%eax
jg     1616 <square_matrix_multiply+0x4e6>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x154(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x158(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x154(%rbp),%edx
mov    %eax,%ecx
mov    -0x150(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x148(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x148(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x144(%rbp),%edx
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x15c(%rbp),%eax
cmp    %ecx,%eax
jle    1790 <square_matrix_multiply+0x660>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x160(%rbp),%eax
cmp    %ecx,%eax
jle    1790 <square_matrix_multiply+0x660>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x18c(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x19c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x19c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x198(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x18c(%rbp),%edx
mov    %eax,%esi
mov    -0x188(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x17c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x17c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x178(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x168(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x16c(%rbp),%edx
mov    %eax,%esi
mov    -0x168(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1795 <square_matrix_multiply+0x665>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1284 <square_matrix_multiply+0x154>
jmp    17a8 <square_matrix_multiply+0x678>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1271 <square_matrix_multiply+0x141>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x220(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x220(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x218(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x218(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x210(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x210(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x98(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0x40(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xa0(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0x98(%rbp),%rdi
mov    -0xa0(%rbp),%rsi
mov    -0x78(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x208(%rbp),%rdx
mov    %eax,%ecx
call   1050 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x200(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x200(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1f8(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1f0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xa8(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0x40(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xb0(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0xa8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x80(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x1e8(%rbp),%rdx
mov    %eax,%ecx
call   1050 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1e0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d8(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xb8(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0x50(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xc0(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0xb8(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
mov    -0x88(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x1c8(%rbp),%rdx
mov    %eax,%ecx
call   1050 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1b8(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1b0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xc8(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0x50(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0xd0(%rbp),%rcx
call   1030 <square_matrix_multiply@plt>
mov    -0xc8(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
mov    -0x90(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x1a8(%rbp),%rdx
mov    %eax,%ecx
call   1050 <square_matrix_add@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1fd0 <square_matrix_multiply+0xea0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1fbd <square_matrix_multiply+0xe8d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x224(%rbp),%eax
cmp    %ecx,%eax
jg     1d56 <square_matrix_multiply+0xc26>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x228(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x228(%rbp),%eax
cmp    %ecx,%eax
jg     1d56 <square_matrix_multiply+0xc26>
mov    -0x78(%rbp),%rax
mov    %rax,-0x230(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x230(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x234(%rbp),%eax
cmp    %ecx,%eax
jg     1e13 <square_matrix_multiply+0xce3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x238(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x238(%rbp),%eax
cmp    %ecx,%eax
jle    1e13 <square_matrix_multiply+0xce3>
mov    -0x80(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x248(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x240(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x240(%rbp),%rax
sub    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x24c(%rbp),%eax
cmp    %ecx,%eax
jle    1ecf <square_matrix_multiply+0xd9f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x250(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x250(%rbp),%eax
cmp    %ecx,%eax
jg     1ecf <square_matrix_multiply+0xd9f>
mov    -0x88(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x25c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x25c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x258(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x260(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x260(%rbp),%eax
cmp    %ecx,%eax
jle    1faa <square_matrix_multiply+0xe7a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x264(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x264(%rbp),%eax
cmp    %ecx,%eax
jle    1faa <square_matrix_multiply+0xe7a>
mov    -0x90(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x27c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x27c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x278(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x270(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x270(%rbp),%rax
sub    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1faf <square_matrix_multiply+0xe7f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cac <square_matrix_multiply+0xb7c>
jmp    1fc2 <square_matrix_multiply+0xe92>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c99 <square_matrix_multiply+0xb69>
jmp    1fd5 <square_matrix_multiply+0xea5>
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<square_matrix_multiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,%r12
mov    %rsi,%rbx
mov    %rdi,%r15
cmp    $0x1,%edx
jne    115e <square_matrix_multiply+0x2e>
mov    (%rbx),%eax
imul   (%r15),%eax
mov    %eax,(%r12)
jmp    15e7 <square_matrix_multiply+0x4b7>
movslq %edx,%rax
mov    %rax,0x58(%rsp)
mov    %edx,%ebp
imul   %edx,%ebp
mov    %ebp,%edi
mov    %edx,0xc(%rsp)
call   1040 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    0xc(%rsp),%r13d
mov    %rax,%rcx
mov    %r13d,%eax
mov    %rax,0x20(%rsp)
test   %r13d,%r13d
mov    %r14,0x68(%rsp)
mov    %rcx,0x60(%rsp)
jle    1387 <square_matrix_multiply+0x257>
mov    %r12,0x70(%rsp)
mov    %r13d,%ebp
shr    %ebp
mov    0x58(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x38(%rsp)
lea    0x0(,%rbp,4),%rax
mov    0x30(%rsp),%rdx
sub    %rax,%rdx
mov    %rdx,0x90(%rsp)
sub    %rax,%rcx
mov    %rcx,0x88(%rsp)
mov    0x28(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x80(%rsp)
sub    %rax,%r14
mov    %r14,0x78(%rsp)
xor    %ecx,%ecx
jmp    126a <square_matrix_multiply+0x13a>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
mov    0x38(%rsp),%rax
add    %rax,%rbx
add    %rax,%r15
cmp    0x20(%rsp),%rcx
je     1380 <square_matrix_multiply+0x250>
cmp    %rbp,%rcx
setae  %dl
mov    %ecx,%eax
mov    0xc(%rsp),%r8d
imul   %r8d,%eax
mov    %eax,%esi
shr    $0x1f,%esi
add    %eax,%esi
sar    %esi
movslq %esi,%r13
mov    0x40(%rsp),%rax
lea    (%rax,%r13,4),%rax
mov    %rax,0x18(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%r13,4),%rdi
mov    %ecx,%esi
sub    %ebp,%esi
imul   %r8d,%esi
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
sar    %eax
cltq
mov    0x50(%rsp),%rsi
lea    (%rsi,%rax,4),%r8
mov    0x48(%rsp),%rsi
lea    (%rsi,%rax,4),%r9
mov    0x90(%rsp),%rsi
lea    (%rsi,%rax,4),%r10
mov    0x88(%rsp),%rsi
lea    (%rsi,%rax,4),%r11
mov    0x80(%rsp),%rax
lea    (%rax,%r13,4),%r14
mov    0x78(%rsp),%rax
lea    (%rax,%r13,4),%r12
xor    %r13d,%r13d
jmp    130f <square_matrix_multiply+0x1df>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
cmp    %r13,0x20(%rsp)
je     1250 <square_matrix_multiply+0x120>
cmp    %rbp,%rcx
jae    132e <square_matrix_multiply+0x1fe>
cmp    %rbp,%r13
jae    132e <square_matrix_multiply+0x1fe>
mov    (%r15,%r13,4),%esi
mov    0x18(%rsp),%rax
mov    %esi,(%rax,%r13,4)
mov    (%rbx,%r13,4),%esi
mov    %esi,(%rdi,%r13,4)
cmp    %rbp,%r13
setb   %al
or     %dl,%al
jne    1348 <square_matrix_multiply+0x218>
mov    (%r15,%r13,4),%eax
mov    %eax,(%r14,%r13,4)
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r12,%r13,4)
cmp    %rbp,%r13
setb   %al
and    %dl,%al
cmp    $0x1,%al
jne    1364 <square_matrix_multiply+0x234>
mov    (%r15,%r13,4),%eax
mov    %eax,(%r8,%r13,4)
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r9,%r13,4)
cmp    %rbp,%rcx
jb     1300 <square_matrix_multiply+0x1d0>
cmp    %rbp,%r13
jb     1300 <square_matrix_multiply+0x1d0>
mov    (%r15,%r13,4),%eax
mov    %eax,(%r10,%r13,4)
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r11,%r13,4)
jmp    1300 <square_matrix_multiply+0x1d0>
mov    0x70(%rsp),%r12
jmp    1390 <square_matrix_multiply+0x260>
mov    %r13d,%ebp
neg    %ebp
shr    %ebp
neg    %ebp
mov    %ebp,%ebx
imul   %ebp,%ebx
shl    $0x2,%ebx
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    0x40(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    %ebp,%edx
mov    %r13,%rcx
call   1030 <square_matrix_multiply@plt>
mov    0x28(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    %ebp,%edx
mov    %r15,%rcx
call   1030 <square_matrix_multiply@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r14,0x38(%rsp)
mov    %r14,%rdx
mov    %ebp,%ecx
call   1050 <square_matrix_add@plt>
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    0x40(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    %ebp,%edx
mov    %r15,%rcx
call   1030 <square_matrix_multiply@plt>
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    %ebp,%edx
mov    %r13,%rcx
call   1030 <square_matrix_multiply@plt>
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r14,0x18(%rsp)
mov    %r14,%rdx
mov    %ebp,%ecx
call   1050 <square_matrix_add@plt>
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    0x50(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    %ebp,%edx
mov    %r14,%rcx
call   1030 <square_matrix_multiply@plt>
mov    0x30(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    %ebp,%edx
mov    %r13,%rcx
call   1030 <square_matrix_multiply@plt>
mov    %r14,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
mov    %ebp,%ecx
call   1050 <square_matrix_add@plt>
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    0x50(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    %ebp,%edx
mov    0x10(%rsp),%rbx
mov    %rbx,%rcx
call   1030 <square_matrix_multiply@plt>
mov    0x30(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    %ebp,%edx
mov    %r13,%rcx
call   1030 <square_matrix_multiply@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    %ebp,%ecx
call   1050 <square_matrix_add@plt>
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
mov    0x58(%rsp),%r11
jle    15e7 <square_matrix_multiply+0x4b7>
movslq %ebp,%rax
shl    $0x2,%r11
lea    0x0(,%rax,4),%rcx
sub    %rcx,%r14
sub    %rcx,0x18(%rsp)
xor    %ecx,%ecx
jmp    1542 <square_matrix_multiply+0x412>
nop
add    $0x1,%rcx
add    %r11,%r12
cmp    0x20(%rsp),%rcx
je     15e7 <square_matrix_multiply+0x4b7>
cmp    %rax,%rcx
setge  %dl
mov    %ecx,%esi
imul   %r13d,%esi
mov    %esi,%edi
shr    $0x1f,%edi
add    %esi,%edi
sar    %edi
movslq %edi,%rsi
mov    0x38(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
mov    %ecx,%ebx
sub    %ebp,%ebx
imul   %r13d,%ebx
mov    %ebx,%edi
shr    $0x1f,%edi
add    %ebx,%edi
sar    %edi
movslq %edi,%rdi
lea    (%r15,%rdi,4),%r9
lea    (%r14,%rdi,4),%r10
mov    0x18(%rsp),%rdi
lea    (%rdi,%rsi,4),%rsi
xor    %edi,%edi
jmp    159b <square_matrix_multiply+0x46b>
nopl   0x0(%rax)
add    $0x1,%rdi
cmp    %rdi,0x20(%rsp)
je     1530 <square_matrix_multiply+0x400>
cmp    %rax,%rcx
jge    15ad <square_matrix_multiply+0x47d>
cmp    %rax,%rdi
jge    15ad <square_matrix_multiply+0x47d>
mov    (%r8,%rdi,4),%ebx
mov    %ebx,(%r12,%rdi,4)
cmp    %rax,%rdi
setl   %bl
or     %dl,%bl
jne    15be <square_matrix_multiply+0x48e>
mov    (%rsi,%rdi,4),%ebx
mov    %ebx,(%r12,%rdi,4)
cmp    %rax,%rdi
setl   %bl
and    %dl,%bl
cmp    $0x1,%bl
jne    15d3 <square_matrix_multiply+0x4a3>
mov    (%r9,%rdi,4),%ebx
mov    %ebx,(%r12,%rdi,4)
cmp    %rax,%rcx
jl     1590 <square_matrix_multiply+0x460>
cmp    %rax,%rdi
jl     1590 <square_matrix_multiply+0x460>
mov    (%r10,%rdi,4),%ebx
mov    %ebx,(%r12,%rdi,4)
jmp    1590 <square_matrix_multiply+0x460>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @square_matrix_multiply(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*
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca i32*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32*
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32* %3, i32** %8
%32 = load i32, i32* %7
store i32 %32, i32* %9
%33 = load i32, i32* %9
%34 = icmp eq i32 %33, 1
br i1 %34, label %35, label %42
35: ; preds = %4
%36 = load i32*, i32** %5
%37 = load i32, i32* %36
%38 = load i32*, i32** %6
%39 = load i32, i32* %38
%40 = mul nsw i32 %37, %39
%41 = load i32*, i32** %8
store i32 %40, i32* %41
br label %715
42: ; preds = %4
%43 = load i32, i32* %7
%44 = sext i32 %43 to i64
%45 = mul i64 4, %44
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = mul i64 %45, %47
%49 = udiv i64 %48, 4
%50 = trunc i64 %49 to i32
%51 = call i32* @malloc(i32 %50)
store i32* %51, i32** %12
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = mul i64 4, %53
%55 = load i32, i32* %7
%56 = sext i32 %55 to i64
%57 = mul i64 %54, %56
%58 = udiv i64 %57, 4
%59 = trunc i64 %58 to i32
%60 = call i32* @malloc(i32 %59)
store i32* %60, i32** %13
%61 = load i32, i32* %7
%62 = sext i32 %61 to i64
%63 = mul i64 4, %62
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = mul i64 %63, %65
%67 = udiv i64 %66, 4
%68 = trunc i64 %67 to i32
%69 = call i32* @malloc(i32 %68)
store i32* %69, i32** %14
%70 = load i32, i32* %7
%71 = sext i32 %70 to i64
%72 = mul i64 4, %71
%73 = load i32, i32* %7
%74 = sext i32 %73 to i64
%75 = mul i64 %72, %74
%76 = udiv i64 %75, 4
%77 = trunc i64 %76 to i32
%78 = call i32* @malloc(i32 %77)
store i32* %78, i32** %15
%79 = load i32, i32* %7
%80 = sext i32 %79 to i64
%81 = mul i64 4, %80
%82 = load i32, i32* %7
%83 = sext i32 %82 to i64
%84 = mul i64 %81, %83
%85 = udiv i64 %84, 4
%86 = trunc i64 %85 to i32
%87 = call i32* @malloc(i32 %86)
store i32* %87, i32** %16
%88 = load i32, i32* %7
%89 = sext i32 %88 to i64
%90 = mul i64 4, %89
%91 = load i32, i32* %7
%92 = sext i32 %91 to i64
%93 = mul i64 %90, %92
%94 = udiv i64 %93, 4
%95 = trunc i64 %94 to i32
%96 = call i32* @malloc(i32 %95)
store i32* %96, i32** %17
%97 = load i32, i32* %7
%98 = sext i32 %97 to i64
%99 = mul i64 4, %98
%100 = load i32, i32* %7
%101 = sext i32 %100 to i64
%102 = mul i64 %99, %101
%103 = udiv i64 %102, 4
%104 = trunc i64 %103 to i32
%105 = call i32* @malloc(i32 %104)
store i32* %105, i32** %18
%106 = load i32, i32* %7
%107 = sext i32 %106 to i64
%108 = mul i64 4, %107
%109 = load i32, i32* %7
%110 = sext i32 %109 to i64
%111 = mul i64 %108, %110
%112 = udiv i64 %111, 4
%113 = trunc i64 %112 to i32
%114 = call i32* @malloc(i32 %113)
store i32* %114, i32** %19
store i32 0, i32* %10
br label %115
115: ; preds = %365, %42
%116 = load i32, i32* %10
%117 = load i32, i32* %7
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %368
119: ; preds = %115
store i32 0, i32* %11
br label %120
120: ; preds = %361, %119
%121 = load i32, i32* %11
%122 = load i32, i32* %7
%123 = icmp slt i32 %121, %122
br i1 %123, label %124, label %364
124: ; preds = %120
%125 = load i32, i32* %10
%126 = add nsw i32 %125, 1
%127 = load i32, i32* %7
%128 = sdiv i32 %127, 2
%129 = icmp sle i32 %126, %128
br i1 %129, label %130, label %177
130: ; preds = %124
%131 = load i32, i32* %11
%132 = add nsw i32 %131, 1
%133 = load i32, i32* %7
%134 = sdiv i32 %133, 2
%135 = icmp sle i32 %132, %134
br i1 %135, label %136, label %177
136: ; preds = %130
%137 = load i32*, i32** %5
%138 = load i32, i32* %10
%139 = load i32, i32* %7
%140 = mul nsw i32 %138, %139
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %137, i64 %141
%143 = load i32, i32* %11
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %142, i64 %144
%146 = load i32, i32* %145
%147 = load i32*, i32** %12
%148 = load i32, i32* %10
%149 = load i32, i32* %7
%150 = mul nsw i32 %148, %149
%151 = sdiv i32 %150, 2
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %147, i64 %152
%154 = load i32, i32* %11
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
store i32 %146, i32* %156
%157 = load i32*, i32** %6
%158 = load i32, i32* %10
%159 = load i32, i32* %7
%160 = mul nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %157, i64 %161
%163 = load i32, i32* %11
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
%166 = load i32, i32* %165
%167 = load i32*, i32** %16
%168 = load i32, i32* %10
%169 = load i32, i32* %7
%170 = mul nsw i32 %168, %169
%171 = sdiv i32 %170, 2
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %167, i64 %172
%174 = load i32, i32* %11
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %173, i64 %175
store i32 %166, i32* %176
br label %177
177: ; preds = %136, %130, %124
%178 = load i32, i32* %10
%179 = add nsw i32 %178, 1
%180 = load i32, i32* %7
%181 = sdiv i32 %180, 2
%182 = icmp sle i32 %179, %181
br i1 %182, label %183, label %236
183: ; preds = %177
%184 = load i32, i32* %11
%185 = add nsw i32 %184, 1
%186 = load i32, i32* %7
%187 = sdiv i32 %186, 2
%188 = icmp sgt i32 %185, %187
br i1 %188, label %189, label %236
189: ; preds = %183
%190 = load i32*, i32** %5
%191 = load i32, i32* %10
%192 = load i32, i32* %7
%193 = mul nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %190, i64 %194
%196 = load i32, i32* %11
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
%200 = load i32*, i32** %13
%201 = load i32, i32* %10
%202 = load i32, i32* %7
%203 = mul nsw i32 %201, %202
%204 = sdiv i32 %203, 2
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %200, i64 %205
%207 = load i32, i32* %11
%208 = load i32, i32* %7
%209 = sdiv i32 %208, 2
%210 = sub nsw i32 %207, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %206, i64 %211
store i32 %199, i32* %212
%213 = load i32*, i32** %6
%214 = load i32, i32* %10
%215 = load i32, i32* %7
%216 = mul nsw i32 %214, %215
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32, i32* %213, i64 %217
%219 = load i32, i32* %11
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %218, i64 %220
%222 = load i32, i32* %221
%223 = load i32*, i32** %17
%224 = load i32, i32* %10
%225 = load i32, i32* %7
%226 = mul nsw i32 %224, %225
%227 = sdiv i32 %226, 2
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32, i32* %223, i64 %228
%230 = load i32, i32* %11
%231 = load i32, i32* %7
%232 = sdiv i32 %231, 2
%233 = sub nsw i32 %230, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %229, i64 %234
store i32 %222, i32* %235
br label %236
236: ; preds = %189, %183, %177
%237 = load i32, i32* %10
%238 = add nsw i32 %237, 1
%239 = load i32, i32* %7
%240 = sdiv i32 %239, 2
%241 = icmp sgt i32 %238, %240
br i1 %241, label %242, label %295
242: ; preds = %236
%243 = load i32, i32* %11
%244 = add nsw i32 %243, 1
%245 = load i32, i32* %7
%246 = sdiv i32 %245, 2
%247 = icmp sle i32 %244, %246
br i1 %247, label %248, label %295
248: ; preds = %242
%249 = load i32*, i32** %5
%250 = load i32, i32* %10
%251 = load i32, i32* %7
%252 = mul nsw i32 %250, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i32, i32* %249, i64 %253
%255 = load i32, i32* %11
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds i32, i32* %254, i64 %256
%258 = load i32, i32* %257
%259 = load i32*, i32** %14
%260 = load i32, i32* %10
%261 = load i32, i32* %7
%262 = sdiv i32 %261, 2
%263 = sub nsw i32 %260, %262
%264 = load i32, i32* %7
%265 = mul nsw i32 %263, %264
%266 = sdiv i32 %265, 2
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %259, i64 %267
%269 = load i32, i32* %11
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %268, i64 %270
store i32 %258, i32* %271
%272 = load i32*, i32** %6
%273 = load i32, i32* %10
%274 = load i32, i32* %7
%275 = mul nsw i32 %273, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %272, i64 %276
%278 = load i32, i32* %11
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i32, i32* %277, i64 %279
%281 = load i32, i32* %280
%282 = load i32*, i32** %18
%283 = load i32, i32* %10
%284 = load i32, i32* %7
%285 = sdiv i32 %284, 2
%286 = sub nsw i32 %283, %285
%287 = load i32, i32* %7
%288 = mul nsw i32 %286, %287
%289 = sdiv i32 %288, 2
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i32, i32* %282, i64 %290
%292 = load i32, i32* %11
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
store i32 %281, i32* %294
br label %295
295: ; preds = %248, %242, %236
%296 = load i32, i32* %10
%297 = add nsw i32 %296, 1
%298 = load i32, i32* %7
%299 = sdiv i32 %298, 2
%300 = icmp sgt i32 %297, %299
br i1 %300, label %301, label %360
301: ; preds = %295
%302 = load i32, i32* %11
%303 = add nsw i32 %302, 1
%304 = load i32, i32* %7
%305 = sdiv i32 %304, 2
%306 = icmp sgt i32 %303, %305
br i1 %306, label %307, label %360
307: ; preds = %301
%308 = load i32*, i32** %5
%309 = load i32, i32* %10
%310 = load i32, i32* %7
%311 = mul nsw i32 %309, %310
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i32, i32* %308, i64 %312
%314 = load i32, i32* %11
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i32, i32* %313, i64 %315
%317 = load i32, i32* %316
%318 = load i32*, i32** %15
%319 = load i32, i32* %10
%320 = load i32, i32* %7
%321 = sdiv i32 %320, 2
%322 = sub nsw i32 %319, %321
%323 = load i32, i32* %7
%324 = mul nsw i32 %322, %323
%325 = sdiv i32 %324, 2
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds i32, i32* %318, i64 %326
%328 = load i32, i32* %11
%329 = load i32, i32* %7
%330 = sdiv i32 %329, 2
%331 = sub nsw i32 %328, %330
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i32, i32* %327, i64 %332
store i32 %317, i32* %333
%334 = load i32*, i32** %6
%335 = load i32, i32* %10
%336 = load i32, i32* %7
%337 = mul nsw i32 %335, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %334, i64 %338
%340 = load i32, i32* %11
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %339, i64 %341
%343 = load i32, i32* %342
%344 = load i32*, i32** %19
%345 = load i32, i32* %10
%346 = load i32, i32* %7
%347 = sdiv i32 %346, 2
%348 = sub nsw i32 %345, %347
%349 = load i32, i32* %7
%350 = mul nsw i32 %348, %349
%351 = sdiv i32 %350, 2
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32, i32* %344, i64 %352
%354 = load i32, i32* %11
%355 = load i32, i32* %7
%356 = sdiv i32 %355, 2
%357 = sub nsw i32 %354, %356
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32, i32* %353, i64 %358
store i32 %343, i32* %359
br label %360
360: ; preds = %307, %301, %295
br label %361
361: ; preds = %360
%362 = load i32, i32* %11
%363 = add nsw i32 %362, 1
store i32 %363, i32* %11
br label %120
364: ; preds = %120
br label %365
365: ; preds = %364
%366 = load i32, i32* %10
%367 = add nsw i32 %366, 1
store i32 %367, i32* %10
br label %115
368: ; preds = %115
%369 = load i32, i32* %7
%370 = sdiv i32 %369, 2
%371 = sext i32 %370 to i64
%372 = mul i64 4, %371
%373 = load i32, i32* %7
%374 = sdiv i32 %373, 2
%375 = sext i32 %374 to i64
%376 = mul i64 %372, %375
%377 = trunc i64 %376 to i32
%378 = call i32* @malloc(i32 %377)
store i32* %378, i32** %24
%379 = load i32, i32* %7
%380 = sdiv i32 %379, 2
%381 = sext i32 %380 to i64
%382 = mul i64 4, %381
%383 = load i32, i32* %7
%384 = sdiv i32 %383, 2
%385 = sext i32 %384 to i64
%386 = mul i64 %382, %385
%387 = trunc i64 %386 to i32
%388 = call i32* @malloc(i32 %387)
store i32* %388, i32** %25
%389 = load i32, i32* %7
%390 = sdiv i32 %389, 2
%391 = sext i32 %390 to i64
%392 = mul i64 4, %391
%393 = load i32, i32* %7
%394 = sdiv i32 %393, 2
%395 = sext i32 %394 to i64
%396 = mul i64 %392, %395
%397 = trunc i64 %396 to i32
%398 = call i32* @malloc(i32 %397)
store i32* %398, i32** %20
%399 = load i32*, i32** %12
%400 = load i32*, i32** %16
%401 = load i32, i32* %7
%402 = sdiv i32 %401, 2
%403 = load i32*, i32** %24
%404 = load i32*, i32** %13
%405 = load i32*, i32** %18
%406 = load i32, i32* %7
%407 = sdiv i32 %406, 2
%408 = load i32*, i32** %25
%409 = load i32*, i32** %24
%410 = load i32*, i32** %25
%411 = load i32*, i32** %20
%412 = load i32, i32* %7
%413 = sdiv i32 %412, 2
%414 = call i32 @square_matrix_add(i32* %409, i32* %410, i32* %411, i32 %413)
%415 = load i32, i32* %7
%416 = sdiv i32 %415, 2
%417 = sext i32 %416 to i64
%418 = mul i64 4, %417
%419 = load i32, i32* %7
%420 = sdiv i32 %419, 2
%421 = sext i32 %420 to i64
%422 = mul i64 %418, %421
%423 = trunc i64 %422 to i32
%424 = call i32* @malloc(i32 %423)
store i32* %424, i32** %26
%425 = load i32, i32* %7
%426 = sdiv i32 %425, 2
%427 = sext i32 %426 to i64
%428 = mul i64 4, %427
%429 = load i32, i32* %7
%430 = sdiv i32 %429, 2
%431 = sext i32 %430 to i64
%432 = mul i64 %428, %431
%433 = trunc i64 %432 to i32
%434 = call i32* @malloc(i32 %433)
store i32* %434, i32** %27
%435 = load i32, i32* %7
%436 = sdiv i32 %435, 2
%437 = sext i32 %436 to i64
%438 = mul i64 4, %437
%439 = load i32, i32* %7
%440 = sdiv i32 %439, 2
%441 = sext i32 %440 to i64
%442 = mul i64 %438, %441
%443 = trunc i64 %442 to i32
%444 = call i32* @malloc(i32 %443)
store i32* %444, i32** %21
%445 = load i32*, i32** %12
%446 = load i32*, i32** %17
%447 = load i32, i32* %7
%448 = sdiv i32 %447, 2
%449 = load i32*, i32** %26
%450 = load i32*, i32** %13
%451 = load i32*, i32** %19
%452 = load i32, i32* %7
%453 = sdiv i32 %452, 2
%454 = load i32*, i32** %27
%455 = load i32*, i32** %26
%456 = load i32*, i32** %27
%457 = load i32*, i32** %21
%458 = load i32, i32* %7
%459 = sdiv i32 %458, 2
%460 = call i32 @square_matrix_add(i32* %455, i32* %456, i32* %457, i32 %459)
%461 = load i32, i32* %7
%462 = sdiv i32 %461, 2
%463 = sext i32 %462 to i64
%464 = mul i64 4, %463
%465 = load i32, i32* %7
%466 = sdiv i32 %465, 2
%467 = sext i32 %466 to i64
%468 = mul i64 %464, %467
%469 = trunc i64 %468 to i32
%470 = call i32* @malloc(i32 %469)
store i32* %470, i32** %28
%471 = load i32, i32* %7
%472 = sdiv i32 %471, 2
%473 = sext i32 %472 to i64
%474 = mul i64 4, %473
%475 = load i32, i32* %7
%476 = sdiv i32 %475, 2
%477 = sext i32 %476 to i64
%478 = mul i64 %474, %477
%479 = trunc i64 %478 to i32
%480 = call i32* @malloc(i32 %479)
store i32* %480, i32** %29
%481 = load i32, i32* %7
%482 = sdiv i32 %481, 2
%483 = sext i32 %482 to i64
%484 = mul i64 4, %483
%485 = load i32, i32* %7
%486 = sdiv i32 %485, 2
%487 = sext i32 %486 to i64
%488 = mul i64 %484, %487
%489 = trunc i64 %488 to i32
%490 = call i32* @malloc(i32 %489)
store i32* %490, i32** %22
%491 = load i32*, i32** %14
%492 = load i32*, i32** %16
%493 = load i32, i32* %7
%494 = sdiv i32 %493, 2
%495 = load i32*, i32** %28
%496 = load i32*, i32** %15
%497 = load i32*, i32** %18
%498 = load i32, i32* %7
%499 = sdiv i32 %498, 2
%500 = load i32*, i32** %29
%501 = load i32*, i32** %28
%502 = load i32*, i32** %29
%503 = load i32*, i32** %22
%504 = load i32, i32* %7
%505 = sdiv i32 %504, 2
%506 = call i32 @square_matrix_add(i32* %501, i32* %502, i32* %503, i32 %505)
%507 = load i32, i32* %7
%508 = sdiv i32 %507, 2
%509 = sext i32 %508 to i64
%510 = mul i64 4, %509
%511 = load i32, i32* %7
%512 = sdiv i32 %511, 2
%513 = sext i32 %512 to i64
%514 = mul i64 %510, %513
%515 = trunc i64 %514 to i32
%516 = call i32* @malloc(i32 %515)
store i32* %516, i32** %30
%517 = load i32, i32* %7
%518 = sdiv i32 %517, 2
%519 = sext i32 %518 to i64
%520 = mul i64 4, %519
%521 = load i32, i32* %7
%522 = sdiv i32 %521, 2
%523 = sext i32 %522 to i64
%524 = mul i64 %520, %523
%525 = trunc i64 %524 to i32
%526 = call i32* @malloc(i32 %525)
store i32* %526, i32** %31
%527 = load i32, i32* %7
%528 = sdiv i32 %527, 2
%529 = sext i32 %528 to i64
%530 = mul i64 4, %529
%531 = load i32, i32* %7
%532 = sdiv i32 %531, 2
%533 = sext i32 %532 to i64
%534 = mul i64 %530, %533
%535 = trunc i64 %534 to i32
%536 = call i32* @malloc(i32 %535)
store i32* %536, i32** %23
%537 = load i32*, i32** %14
%538 = load i32*, i32** %17
%539 = load i32, i32* %7
%540 = sdiv i32 %539, 2
%541 = load i32*, i32** %30
%542 = load i32*, i32** %15
%543 = load i32*, i32** %19
%544 = load i32, i32* %7
%545 = sdiv i32 %544, 2
%546 = load i32*, i32** %31
%547 = load i32*, i32** %30
%548 = load i32*, i32** %31
%549 = load i32*, i32** %23
%550 = load i32, i32* %7
%551 = sdiv i32 %550, 2
%552 = call i32 @square_matrix_add(i32* %547, i32* %548, i32* %549, i32 %551)
store i32 0, i32* %10
br label %553
553: ; preds = %711, %368
%554 = load i32, i32* %10
%555 = load i32, i32* %7
%556 = icmp slt i32 %554, %555
br i1 %556, label %557, label %714
557: ; preds = %553
store i32 0, i32* %11
br label %558
558: ; preds = %707, %557
%559 = load i32, i32* %11
%560 = load i32, i32* %7
%561 = icmp slt i32 %559, %560
br i1 %561, label %562, label %710
562: ; preds = %558
%563 = load i32, i32* %10
%564 = add nsw i32 %563, 1
%565 = load i32, i32* %7
%566 = sdiv i32 %565, 2
%567 = icmp sle i32 %564, %566
br i1 %567, label %568, label %595
568: ; preds = %562
%569 = load i32, i32* %11
%570 = add nsw i32 %569, 1
%571 = load i32, i32* %7
%572 = sdiv i32 %571, 2
%573 = icmp sle i32 %570, %572
br i1 %573, label %574, label %595
574: ; preds = %568
%575 = load i32*, i32** %20
%576 = load i32, i32* %10
%577 = load i32, i32* %7
%578 = mul nsw i32 %576, %577
%579 = sdiv i32 %578, 2
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds i32, i32* %575, i64 %580
%582 = load i32, i32* %11
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds i32, i32* %581, i64 %583
%585 = load i32, i32* %584
%586 = load i32*, i32** %8
%587 = load i32, i32* %10
%588 = load i32, i32* %7
%589 = mul nsw i32 %587, %588
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds i32, i32* %586, i64 %590
%592 = load i32, i32* %11
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds i32, i32* %591, i64 %593
store i32 %585, i32* %594
br label %595
595: ; preds = %574, %568, %562
%596 = load i32, i32* %10
%597 = add nsw i32 %596, 1
%598 = load i32, i32* %7
%599 = sdiv i32 %598, 2
%600 = icmp sle i32 %597, %599
br i1 %600, label %601, label %631
601: ; preds = %595
%602 = load i32, i32* %11
%603 = add nsw i32 %602, 1
%604 = load i32, i32* %7
%605 = sdiv i32 %604, 2
%606 = icmp sgt i32 %603, %605
br i1 %606, label %607, label %631
607: ; preds = %601
%608 = load i32*, i32** %21
%609 = load i32, i32* %10
%610 = load i32, i32* %7
%611 = mul nsw i32 %609, %610
%612 = sdiv i32 %611, 2
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds i32, i32* %608, i64 %613
%615 = load i32, i32* %11
%616 = load i32, i32* %7
%617 = sdiv i32 %616, 2
%618 = sub nsw i32 %615, %617
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i32, i32* %614, i64 %619
%621 = load i32, i32* %620
%622 = load i32*, i32** %8
%623 = load i32, i32* %10
%624 = load i32, i32* %7
%625 = mul nsw i32 %623, %624
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds i32, i32* %622, i64 %626
%628 = load i32, i32* %11
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i32, i32* %627, i64 %629
store i32 %621, i32* %630
br label %631
631: ; preds = %607, %601, %595
%632 = load i32, i32* %10
%633 = add nsw i32 %632, 1
%634 = load i32, i32* %7
%635 = sdiv i32 %634, 2
%636 = icmp sgt i32 %633, %635
br i1 %636, label %637, label %667
637: ; preds = %631
%638 = load i32, i32* %11
%639 = add nsw i32 %638, 1
%640 = load i32, i32* %7
%641 = sdiv i32 %640, 2
%642 = icmp sle i32 %639, %641
br i1 %642, label %643, label %667
643: ; preds = %637
%644 = load i32*, i32** %22
%645 = load i32, i32* %10
%646 = load i32, i32* %7
%647 = sdiv i32 %646, 2
%648 = sub nsw i32 %645, %647
%649 = load i32, i32* %7
%650 = mul nsw i32 %648, %649
%651 = sdiv i32 %650, 2
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds i32, i32* %644, i64 %652
%654 = load i32, i32* %11
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds i32, i32* %653, i64 %655
%657 = load i32, i32* %656
%658 = load i32*, i32** %8
%659 = load i32, i32* %10
%660 = load i32, i32* %7
%661 = mul nsw i32 %659, %660
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds i32, i32* %658, i64 %662
%664 = load i32, i32* %11
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds i32, i32* %663, i64 %665
store i32 %657, i32* %666
br label %667
667: ; preds = %643, %637, %631
%668 = load i32, i32* %10
%669 = add nsw i32 %668, 1
%670 = load i32, i32* %7
%671 = sdiv i32 %670, 2
%672 = icmp sgt i32 %669, %671
br i1 %672, label %673, label %706
673: ; preds = %667
%674 = load i32, i32* %11
%675 = add nsw i32 %674, 1
%676 = load i32, i32* %7
%677 = sdiv i32 %676, 2
%678 = icmp sgt i32 %675, %677
br i1 %678, label %679, label %706
679: ; preds = %673
%680 = load i32*, i32** %23
%681 = load i32, i32* %10
%682 = load i32, i32* %7
%683 = sdiv i32 %682, 2
%684 = sub nsw i32 %681, %683
%685 = load i32, i32* %7
%686 = mul nsw i32 %684, %685
%687 = sdiv i32 %686, 2
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds i32, i32* %680, i64 %688
%690 = load i32, i32* %11
%691 = load i32, i32* %7
%692 = sdiv i32 %691, 2
%693 = sub nsw i32 %690, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i32, i32* %689, i64 %694
%696 = load i32, i32* %695
%697 = load i32*, i32** %8
%698 = load i32, i32* %10
%699 = load i32, i32* %7
%700 = mul nsw i32 %698, %699
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds i32, i32* %697, i64 %701
%703 = load i32, i32* %11
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds i32, i32* %702, i64 %704
store i32 %696, i32* %705
br label %706
706: ; preds = %679, %673, %667
br label %707
707: ; preds = %706
%708 = load i32, i32* %11
%709 = add nsw i32 %708, 1
store i32 %709, i32* %11
br label %558
710: ; preds = %558
br label %711
711: ; preds = %710
%712 = load i32, i32* %10
%713 = add nsw i32 %712, 1
store i32 %713, i32* %10
br label %553
714: ; preds = %553
br label %715
715: ; preds = %714, %35
ret void
}

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