#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);
int /*<<< orphan*/ square_matrix_sub(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 *c5a4, *c5a4s2, *c5a1, *c5a1s3;
  int *s[10];
  int *p[7];
  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);
        }
      }
    }
    for (i = 0; i < 10; i++)
      s[i] = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_sub(b12, b22, s[0], num / 2);
    square_matrix_add(a11, a12, s[1], num / 2);
    square_matrix_add(a21, a22, s[2], num / 2);
    square_matrix_sub(b21, b11, s[3], num / 2);
    square_matrix_add(a11, a22, s[4], num / 2);
    square_matrix_add(b11, b22, s[5], num / 2);
    square_matrix_sub(a12, a22, s[6], num / 2);
    square_matrix_add(b21, b22, s[7], num / 2);
    square_matrix_sub(a11, a21, s[8], num / 2);
    square_matrix_add(b11, b12, s[9], num / 2);
    for (i = 0; i < 7; i++)
      p[i] = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_multiply(a11, s[0], num / 2, p[0]);
    square_matrix_multiply(s[1], b22, num / 2, p[1]);
    square_matrix_multiply(s[2], b11, num / 2, p[2]);
    square_matrix_multiply(a22, s[3], num / 2, p[3]);
    square_matrix_multiply(s[4], s[5], num / 2, p[4]);
    square_matrix_multiply(s[6], s[7], num / 2, p[5]);
    square_matrix_multiply(s[8], s[9], num / 2, p[6]);
    c11 = malloc(sizeof(int) * (num / 2) * (num / 2));
    c5a4 = malloc(sizeof(int) * (num / 2) * (num / 2));
    c5a4s2 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_add(p[4], p[3], c5a4, num / 2);
    square_matrix_sub(c5a4, p[1], c5a4s2, num / 2);
    square_matrix_add(c5a4s2, p[5], c11, num / 2);
    c12 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_add(p[0], p[1], c12, num / 2);
    c21 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_add(p[2], p[3], c21, num / 2);
    c22 = malloc(sizeof(int) * (num / 2) * (num / 2));
    c5a1 = malloc(sizeof(int) * (num / 2) * (num / 2));
    c5a1s3 = malloc(sizeof(int) * (num / 2) * (num / 2));
    square_matrix_add(p[4], p[0], c5a1, num / 2);
    square_matrix_sub(c5a1, p[2], c5a1s3, num / 2);
    square_matrix_sub(c5a1s3, p[6], 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    $0x350,%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    1182 <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    2258 <square_matrix_multiply+0x1118>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
movslq -0x14(%rbp),%rcx
imul   %rcx,%rax
shr    $0x2,%rax
mov    %eax,%edi
call   1050 <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   1050 <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   1050 <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   1050 <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   1050 <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   1050 <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   1050 <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   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17c6 <square_matrix_multiply+0x686>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17b3 <square_matrix_multiply+0x673>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x144(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x144(%rbp),%eax
cmp    %ecx,%eax
jg     13a6 <square_matrix_multiply+0x266>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x148(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x148(%rbp),%eax
cmp    %ecx,%eax
jg     13a6 <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,-0x164(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x164(%rbp),%edx
mov    %eax,%ecx
mov    -0x160(%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,-0x154(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x28(%rbp),%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    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x168(%rbp),%eax
cmp    %ecx,%eax
jg     14ea <square_matrix_multiply+0x3aa>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x16c(%rbp),%eax
cmp    %ecx,%eax
jle    14ea <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,-0x194(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1a0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x190(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x194(%rbp),%edx
mov    %eax,%esi
mov    -0x190(%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,-0x17c(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x188(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x17c(%rbp),%edx
mov    %eax,%esi
mov    -0x178(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1a4(%rbp),%eax
cmp    %ecx,%eax
jle    1626 <square_matrix_multiply+0x4e6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1a8(%rbp),%eax
cmp    %ecx,%eax
jg     1626 <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,-0x1c4(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c8(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x1c4(%rbp),%edx
mov    %eax,%ecx
mov    -0x1c0(%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,-0x1b4(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1b8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1b8(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x1b4(%rbp),%edx
mov    %eax,%ecx
mov    -0x1b0(%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,-0x1cc(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1cc(%rbp),%eax
cmp    %ecx,%eax
jle    17a0 <square_matrix_multiply+0x660>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d0(%rbp),%eax
cmp    %ecx,%eax
jle    17a0 <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,-0x1fc(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x20c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x208(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x1fc(%rbp),%edx
mov    %eax,%esi
mov    -0x1f8(%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,-0x1dc(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1ec(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1e8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x1dc(%rbp),%edx
mov    %eax,%esi
mov    -0x1d8(%rbp),%rax
sub    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    17a5 <square_matrix_multiply+0x665>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1294 <square_matrix_multiply+0x154>
jmp    17b8 <square_matrix_multiply+0x678>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1281 <square_matrix_multiply+0x141>
movl   $0x0,-0x28(%rbp)
cmpl   $0xa,-0x28(%rbp)
jge    182e <square_matrix_multiply+0x6ee>
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   1050 <malloc@plt>
mov    %rax,%rcx
movslq -0x28(%rbp),%rax
mov    %rcx,-0x100(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17cd <square_matrix_multiply+0x68d>
mov    -0x60(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x100(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x268(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0xf8(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x260(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0xf0(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x258(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x68(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0xe8(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x250(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0x38(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0xe0(%rbp),%rax
mov    %rax,-0x248(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x248(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x58(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0xd8(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x240(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0xd0(%rbp),%rax
mov    %rax,-0x238(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x238(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0x68(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0xc8(%rbp),%rax
mov    %rax,-0x230(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x230(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0xc0(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x228(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0xb8(%rbp),%rax
mov    %rax,-0x220(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x220(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x7,-0x28(%rbp)
jge    1a6c <square_matrix_multiply+0x92c>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x270(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x270(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
movslq -0x28(%rbp),%rax
mov    %rcx,-0x140(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a0b <square_matrix_multiply+0x8cb>
mov    -0x38(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x140(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0xf8(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x138(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0xf0(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x130(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0x50(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x128(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0xe0(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x120(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0xd0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x118(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0xc0(%rbp),%rdi
mov    -0xb8(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x110(%rbp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2f0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2e8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2e8(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2e0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2e0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x98(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x2d8(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x98(%rbp),%rdi
mov    -0x138(%rbp),%rsi
mov    -0xa0(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x2d0(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x118(%rbp),%rsi
mov    -0x78(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x2c8(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2c0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x140(%rbp),%rdi
mov    -0x138(%rbp),%rsi
mov    -0x80(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x2b8(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2b0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x88(%rbp),%rax
mov    %rax,-0x2a8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x2a8(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x2a0(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2a0(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x298(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x298(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
mov    %rax,-0x290(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x290(%rbp),%rax
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x140(%rbp),%rsi
mov    -0xa8(%rbp),%rax
mov    %rax,-0x288(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x288(%rbp),%rdx
mov    %eax,%ecx
call   1060 <square_matrix_add@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x130(%rbp),%rsi
mov    -0xb0(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x280(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    -0x90(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x278(%rbp),%rdx
mov    %eax,%ecx
call   1030 <square_matrix_sub@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2253 <square_matrix_multiply+0x1113>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2240 <square_matrix_multiply+0x1100>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f4(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2f4(%rbp),%eax
cmp    %ecx,%eax
jg     1fd9 <square_matrix_multiply+0xe99>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f8(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2f8(%rbp),%eax
cmp    %ecx,%eax
jg     1fd9 <square_matrix_multiply+0xe99>
mov    -0x78(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x300(%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,-0x304(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x304(%rbp),%eax
cmp    %ecx,%eax
jg     2096 <square_matrix_multiply+0xf56>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x308(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x308(%rbp),%eax
cmp    %ecx,%eax
jle    2096 <square_matrix_multiply+0xf56>
mov    -0x80(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x318(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x310(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x310(%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,-0x31c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x31c(%rbp),%eax
cmp    %ecx,%eax
jle    2152 <square_matrix_multiply+0x1012>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x320(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x320(%rbp),%eax
cmp    %ecx,%eax
jg     2152 <square_matrix_multiply+0x1012>
mov    -0x88(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x32c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x32c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x328(%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,-0x330(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x330(%rbp),%eax
cmp    %ecx,%eax
jle    222d <square_matrix_multiply+0x10ed>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x334(%rbp),%eax
cmp    %ecx,%eax
jle    222d <square_matrix_multiply+0x10ed>
mov    -0x90(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x34c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34c(%rbp),%eax
sub    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x348(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x340(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x340(%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    2232 <square_matrix_multiply+0x10f2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1f2f <square_matrix_multiply+0xdef>
jmp    2245 <square_matrix_multiply+0x1105>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1f1c <square_matrix_multiply+0xddc>
jmp    2258 <square_matrix_multiply+0x1118>
add    $0x350,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<square_matrix_multiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rcx,%r12
mov    %rsi,%rbp
mov    %rdi,%rbx
cmp    $0x1,%edx
jne    116e <square_matrix_multiply+0x2e>
mov    0x0(%rbp),%eax
imul   (%rbx),%eax
mov    %eax,(%r12)
jmp    1838 <square_matrix_multiply+0x6f8>
movslq %edx,%rax
mov    %rax,0x78(%rsp)
mov    %edx,%r15d
imul   %edx,%r15d
mov    %r15d,%edi
mov    %edx,0xc(%rsp)
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,0x80(%rsp)
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%rsp)
mov    %r15d,%edi
call   1050 <malloc@plt>
mov    0xc(%rsp),%ecx
mov    %rax,%rdx
mov    %ecx,%eax
mov    %rax,0x68(%rsp)
test   %ecx,%ecx
mov    %r13,0x98(%rsp)
mov    %rdx,0x70(%rsp)
mov    %r14,0x28(%rsp)
jle    138d <square_matrix_multiply+0x24d>
mov    %r12,0x40(%rsp)
mov    %ecx,%r15d
shr    %r15d
mov    0x78(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x30(%rsp)
lea    0x0(,%r15,4),%rax
sub    %rax,%r13
mov    %r13,0x60(%rsp)
sub    %rax,%rdx
mov    %rdx,0x58(%rsp)
mov    0x10(%rsp),%rcx
sub    %rax,%rcx
mov    %rcx,0x50(%rsp)
sub    %rax,%r14
mov    %r14,0x48(%rsp)
xor    %ecx,%ecx
jmp    127a <square_matrix_multiply+0x13a>
nopl   0x0(%rax)
add    $0x1,%rcx
mov    0x30(%rsp),%rax
add    %rax,%rbp
add    %rax,%rbx
cmp    0x68(%rsp),%rcx
je     1386 <square_matrix_multiply+0x246>
cmp    %r15,%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    0x20(%rsp),%rax
lea    (%rax,%r13,4),%rax
mov    %rax,(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%r13,4),%rdi
mov    %ecx,%esi
sub    %r15d,%esi
imul   %r8d,%esi
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
sar    %eax
cltq
mov    0x18(%rsp),%rsi
lea    (%rsi,%rax,4),%r14
mov    0x38(%rsp),%rsi
lea    (%rsi,%rax,4),%r8
mov    0x60(%rsp),%rsi
lea    (%rsi,%rax,4),%r9
mov    0x58(%rsp),%rsi
lea    (%rsi,%rax,4),%r10
mov    0x50(%rsp),%rax
lea    (%rax,%r13,4),%r11
mov    0x48(%rsp),%rax
lea    (%rax,%r13,4),%r12
xor    %r13d,%r13d
jmp    130f <square_matrix_multiply+0x1cf>
nop
add    $0x1,%r13
cmp    %r13,0x68(%rsp)
je     1260 <square_matrix_multiply+0x120>
cmp    %r15,%rcx
jae    132e <square_matrix_multiply+0x1ee>
cmp    %r15,%r13
jae    132e <square_matrix_multiply+0x1ee>
mov    (%rbx,%r13,4),%esi
mov    (%rsp),%rax
mov    %esi,(%rax,%r13,4)
mov    0x0(%rbp,%r13,4),%esi
mov    %esi,(%rdi,%r13,4)
cmp    %r15,%r13
setb   %al
or     %dl,%al
jne    1349 <square_matrix_multiply+0x209>
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r11,%r13,4)
mov    0x0(%rbp,%r13,4),%eax
mov    %eax,(%r12,%r13,4)
cmp    %r15,%r13
setb   %al
and    %dl,%al
cmp    $0x1,%al
jne    1366 <square_matrix_multiply+0x226>
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r14,%r13,4)
mov    0x0(%rbp,%r13,4),%eax
mov    %eax,(%r8,%r13,4)
cmp    %r15,%rcx
jb     1300 <square_matrix_multiply+0x1c0>
cmp    %r15,%r13
jb     1300 <square_matrix_multiply+0x1c0>
mov    (%rbx,%r13,4),%eax
mov    %eax,(%r9,%r13,4)
mov    0x0(%rbp,%r13,4),%eax
mov    %eax,(%r10,%r13,4)
jmp    1300 <square_matrix_multiply+0x1c0>
mov    0x40(%rsp),%r12
jmp    1399 <square_matrix_multiply+0x259>
mov    %ecx,%r15d
neg    %r15d
shr    %r15d
neg    %r15d
mov    %r15d,%ebx
imul   %r15d,%ebx
shl    $0x2,%ebx
mov    %ebx,0x30(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %rax,0xc0(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %rax,0xb0(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rax,0xb8(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x60(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x90(%rsp)
mov    0x28(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %rbp,%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    0x10(%rsp),%rsi
mov    %r13,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x18(%rsp),%rdi
mov    0x98(%rsp),%rbp
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x38(%rsp),%r14
mov    %r14,%rdi
mov    0x80(%rsp),%r13
mov    %r13,%rsi
mov    0x60(%rsp),%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    (%rsp),%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    %r13,%rdi
mov    0x70(%rsp),%rbx
mov    %rbx,%rsi
mov    0x50(%rsp),%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x10(%rsp),%rdi
mov    %rbp,%rsi
mov    0x58(%rsp),%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    0x48(%rsp),%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0x40(%rsp),%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    %r13,%rdi
mov    0x28(%rsp),%rsi
mov    0x90(%rsp),%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x30(%rsp),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %rax,0xa0(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rax,0x10(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x88(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %rax,0xa8(%rsp)
mov    0x20(%rsp),%rdi
mov    0xc0(%rsp),%rsi
mov    %r15d,%edx
mov    %rbp,%rcx
call   1040 <square_matrix_multiply@plt>
mov    0xb0(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r15d,%edx
mov    %r13,%rcx
call   1040 <square_matrix_multiply@plt>
mov    0xb8(%rsp),%rdi
mov    0x80(%rsp),%rsi
mov    %r15d,%edx
mov    %r14,%rcx
call   1040 <square_matrix_multiply@plt>
mov    0x98(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    %r15d,%edx
mov    0x28(%rsp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    (%rsp),%rdi
mov    0x50(%rsp),%rsi
mov    %r15d,%edx
mov    0x88(%rsp),%r13
mov    %r13,%rcx
call   1040 <square_matrix_multiply@plt>
mov    0x58(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    %r15d,%edx
mov    0x18(%rsp),%rcx
call   1040 <square_matrix_multiply@plt>
mov    0x40(%rsp),%rdi
mov    0x90(%rsp),%rsi
mov    %r15d,%edx
mov    %rbx,%rcx
call   1040 <square_matrix_multiply@plt>
mov    0x30(%rsp),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r13,%rdi
mov    0x28(%rsp),%r13
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    %rbp,%rdi
mov    0xa0(%rsp),%rbp
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
mov    %r14,0x20(%rsp)
mov    %r14,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    0x30(%rsp),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    0x38(%rsp),%rdi
mov    %rbp,%rsi
mov    %rax,(%rsp)
mov    %rax,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    0x10(%rsp),%rdi
mov    %r13,%rsi
mov    %rax,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    0x88(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    %rbp,%rdx
mov    %r15d,%ecx
call   1060 <square_matrix_add@plt>
mov    %rbp,%rdi
mov    0x10(%rsp),%rsi
mov    %rbx,%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    %rbx,%rdi
mov    0xa8(%rsp),%rsi
mov    %r13,%rdx
mov    %r15d,%ecx
call   1030 <square_matrix_sub@plt>
mov    0xc(%rsp),%r11d
test   %r11d,%r11d
jle    1838 <square_matrix_multiply+0x6f8>
movslq %r15d,%rax
shlq   $0x2,0x78(%rsp)
lea    0x0(,%rax,4),%rcx
sub    %rcx,%r13
sub    %rcx,(%rsp)
xor    %ecx,%ecx
jmp    1784 <square_matrix_multiply+0x644>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    0x78(%rsp),%r12
cmp    0x68(%rsp),%rcx
je     1838 <square_matrix_multiply+0x6f8>
cmp    %rax,%rcx
setge  %dl
mov    %ecx,%esi
imul   %r11d,%esi
mov    %esi,%edi
shr    $0x1f,%edi
add    %esi,%edi
sar    %edi
movslq %edi,%rsi
mov    0x20(%rsp),%rdi
lea    (%rdi,%rsi,4),%r8
mov    %ecx,%ebp
sub    %r15d,%ebp
imul   %r11d,%ebp
mov    %ebp,%edi
shr    $0x1f,%edi
add    %ebp,%edi
sar    %edi
movslq %edi,%rbp
lea    (%r14,%rbp,4),%r9
lea    0x0(,%rbp,4),%r10
add    %r13,%r10
mov    (%rsp),%rdi
lea    (%rdi,%rsi,4),%rbp
xor    %esi,%esi
jmp    17eb <square_matrix_multiply+0x6ab>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
cmp    %rsi,0x68(%rsp)
je     1770 <square_matrix_multiply+0x630>
cmp    %rax,%rcx
jge    17fd <square_matrix_multiply+0x6bd>
cmp    %rax,%rsi
jge    17fd <square_matrix_multiply+0x6bd>
mov    (%r8,%rsi,4),%edi
mov    %edi,(%r12,%rsi,4)
cmp    %rax,%rsi
setl   %bl
or     %dl,%bl
jne    180f <square_matrix_multiply+0x6cf>
mov    0x0(%rbp,%rsi,4),%edi
mov    %edi,(%r12,%rsi,4)
cmp    %rax,%rsi
setl   %bl
and    %dl,%bl
cmp    $0x1,%bl
jne    1824 <square_matrix_multiply+0x6e4>
mov    (%r9,%rsi,4),%edi
mov    %edi,(%r12,%rsi,4)
cmp    %rax,%rcx
jl     17e0 <square_matrix_multiply+0x6a0>
cmp    %rax,%rsi
jl     17e0 <square_matrix_multiply+0x6a0>
mov    (%r10,%rsi,4),%edi
mov    %edi,(%r12,%rsi,4)
jmp    17e0 <square_matrix_multiply+0x6a0>
add    $0xc8,%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 [10 x i32*]
%29 = alloca [7 x i32*]
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32 %2, i32* %7
store i32* %3, i32** %8
%30 = load i32, i32* %7
store i32 %30, i32* %9
%31 = load i32, i32* %9
%32 = icmp eq i32 %31, 1
br i1 %32, label %33, label %40
33: ; preds = %4
%34 = load i32*, i32** %5
%35 = load i32, i32* %34
%36 = load i32*, i32** %6
%37 = load i32, i32* %36
%38 = mul nsw i32 %35, %37
%39 = load i32*, i32** %8
store i32 %38, i32* %39
br label %833
40: ; preds = %4
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = mul i64 4, %42
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = mul i64 %43, %45
%47 = udiv i64 %46, 4
%48 = trunc i64 %47 to i32
%49 = call i32* @malloc(i32 %48)
store i32* %49, i32** %12
%50 = load i32, i32* %7
%51 = sext i32 %50 to i64
%52 = mul i64 4, %51
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = mul i64 %52, %54
%56 = udiv i64 %55, 4
%57 = trunc i64 %56 to i32
%58 = call i32* @malloc(i32 %57)
store i32* %58, i32** %13
%59 = load i32, i32* %7
%60 = sext i32 %59 to i64
%61 = mul i64 4, %60
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = mul i64 %61, %63
%65 = udiv i64 %64, 4
%66 = trunc i64 %65 to i32
%67 = call i32* @malloc(i32 %66)
store i32* %67, i32** %14
%68 = load i32, i32* %7
%69 = sext i32 %68 to i64
%70 = mul i64 4, %69
%71 = load i32, i32* %7
%72 = sext i32 %71 to i64
%73 = mul i64 %70, %72
%74 = udiv i64 %73, 4
%75 = trunc i64 %74 to i32
%76 = call i32* @malloc(i32 %75)
store i32* %76, i32** %15
%77 = load i32, i32* %7
%78 = sext i32 %77 to i64
%79 = mul i64 4, %78
%80 = load i32, i32* %7
%81 = sext i32 %80 to i64
%82 = mul i64 %79, %81
%83 = udiv i64 %82, 4
%84 = trunc i64 %83 to i32
%85 = call i32* @malloc(i32 %84)
store i32* %85, i32** %16
%86 = load i32, i32* %7
%87 = sext i32 %86 to i64
%88 = mul i64 4, %87
%89 = load i32, i32* %7
%90 = sext i32 %89 to i64
%91 = mul i64 %88, %90
%92 = udiv i64 %91, 4
%93 = trunc i64 %92 to i32
%94 = call i32* @malloc(i32 %93)
store i32* %94, i32** %17
%95 = load i32, i32* %7
%96 = sext i32 %95 to i64
%97 = mul i64 4, %96
%98 = load i32, i32* %7
%99 = sext i32 %98 to i64
%100 = mul i64 %97, %99
%101 = udiv i64 %100, 4
%102 = trunc i64 %101 to i32
%103 = call i32* @malloc(i32 %102)
store i32* %103, i32** %18
%104 = load i32, i32* %7
%105 = sext i32 %104 to i64
%106 = mul i64 4, %105
%107 = load i32, i32* %7
%108 = sext i32 %107 to i64
%109 = mul i64 %106, %108
%110 = udiv i64 %109, 4
%111 = trunc i64 %110 to i32
%112 = call i32* @malloc(i32 %111)
store i32* %112, i32** %19
store i32 0, i32* %10
br label %113
113: ; preds = %363, %40
%114 = load i32, i32* %10
%115 = load i32, i32* %7
%116 = icmp slt i32 %114, %115
br i1 %116, label %117, label %366
117: ; preds = %113
store i32 0, i32* %11
br label %118
118: ; preds = %359, %117
%119 = load i32, i32* %11
%120 = load i32, i32* %7
%121 = icmp slt i32 %119, %120
br i1 %121, label %122, label %362
122: ; preds = %118
%123 = load i32, i32* %10
%124 = add nsw i32 %123, 1
%125 = load i32, i32* %7
%126 = sdiv i32 %125, 2
%127 = icmp sle i32 %124, %126
br i1 %127, label %128, label %175
128: ; preds = %122
%129 = load i32, i32* %11
%130 = add nsw i32 %129, 1
%131 = load i32, i32* %7
%132 = sdiv i32 %131, 2
%133 = icmp sle i32 %130, %132
br i1 %133, label %134, label %175
134: ; preds = %128
%135 = load i32*, i32** %5
%136 = load i32, i32* %10
%137 = load i32, i32* %7
%138 = mul nsw i32 %136, %137
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %135, i64 %139
%141 = load i32, i32* %11
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
%144 = load i32, i32* %143
%145 = load i32*, i32** %12
%146 = load i32, i32* %10
%147 = load i32, i32* %7
%148 = mul nsw i32 %146, %147
%149 = sdiv i32 %148, 2
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %145, i64 %150
%152 = load i32, i32* %11
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i32, i32* %151, i64 %153
store i32 %144, i32* %154
%155 = load i32*, i32** %6
%156 = load i32, i32* %10
%157 = load i32, i32* %7
%158 = mul nsw i32 %156, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %155, i64 %159
%161 = load i32, i32* %11
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %160, i64 %162
%164 = load i32, i32* %163
%165 = load i32*, i32** %16
%166 = load i32, i32* %10
%167 = load i32, i32* %7
%168 = mul nsw i32 %166, %167
%169 = sdiv i32 %168, 2
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %165, i64 %170
%172 = load i32, i32* %11
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32, i32* %171, i64 %173
store i32 %164, i32* %174
br label %175
175: ; preds = %134, %128, %122
%176 = load i32, i32* %10
%177 = add nsw i32 %176, 1
%178 = load i32, i32* %7
%179 = sdiv i32 %178, 2
%180 = icmp sle i32 %177, %179
br i1 %180, label %181, label %234
181: ; preds = %175
%182 = load i32, i32* %11
%183 = add nsw i32 %182, 1
%184 = load i32, i32* %7
%185 = sdiv i32 %184, 2
%186 = icmp sgt i32 %183, %185
br i1 %186, label %187, label %234
187: ; preds = %181
%188 = load i32*, i32** %5
%189 = load i32, i32* %10
%190 = load i32, i32* %7
%191 = mul nsw i32 %189, %190
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %188, i64 %192
%194 = load i32, i32* %11
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i32, i32* %193, i64 %195
%197 = load i32, i32* %196
%198 = load i32*, i32** %13
%199 = load i32, i32* %10
%200 = load i32, i32* %7
%201 = mul nsw i32 %199, %200
%202 = sdiv i32 %201, 2
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32, i32* %198, i64 %203
%205 = load i32, i32* %11
%206 = load i32, i32* %7
%207 = sdiv i32 %206, 2
%208 = sub nsw i32 %205, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i32, i32* %204, i64 %209
store i32 %197, i32* %210
%211 = load i32*, i32** %6
%212 = load i32, i32* %10
%213 = load i32, i32* %7
%214 = mul nsw i32 %212, %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32, i32* %211, i64 %215
%217 = load i32, i32* %11
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i32, i32* %216, i64 %218
%220 = load i32, i32* %219
%221 = load i32*, i32** %17
%222 = load i32, i32* %10
%223 = load i32, i32* %7
%224 = mul nsw i32 %222, %223
%225 = sdiv i32 %224, 2
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32, i32* %221, i64 %226
%228 = load i32, i32* %11
%229 = load i32, i32* %7
%230 = sdiv i32 %229, 2
%231 = sub nsw i32 %228, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %227, i64 %232
store i32 %220, i32* %233
br label %234
234: ; preds = %187, %181, %175
%235 = load i32, i32* %10
%236 = add nsw i32 %235, 1
%237 = load i32, i32* %7
%238 = sdiv i32 %237, 2
%239 = icmp sgt i32 %236, %238
br i1 %239, label %240, label %293
240: ; preds = %234
%241 = load i32, i32* %11
%242 = add nsw i32 %241, 1
%243 = load i32, i32* %7
%244 = sdiv i32 %243, 2
%245 = icmp sle i32 %242, %244
br i1 %245, label %246, label %293
246: ; preds = %240
%247 = load i32*, i32** %5
%248 = load i32, i32* %10
%249 = load i32, i32* %7
%250 = mul nsw i32 %248, %249
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %247, i64 %251
%253 = load i32, i32* %11
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
%256 = load i32, i32* %255
%257 = load i32*, i32** %14
%258 = load i32, i32* %10
%259 = load i32, i32* %7
%260 = sdiv i32 %259, 2
%261 = sub nsw i32 %258, %260
%262 = load i32, i32* %7
%263 = mul nsw i32 %261, %262
%264 = sdiv i32 %263, 2
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %257, i64 %265
%267 = load i32, i32* %11
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds i32, i32* %266, i64 %268
store i32 %256, i32* %269
%270 = load i32*, i32** %6
%271 = load i32, i32* %10
%272 = load i32, i32* %7
%273 = mul nsw i32 %271, %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i32, i32* %270, i64 %274
%276 = load i32, i32* %11
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i32, i32* %275, i64 %277
%279 = load i32, i32* %278
%280 = load i32*, i32** %18
%281 = load i32, i32* %10
%282 = load i32, i32* %7
%283 = sdiv i32 %282, 2
%284 = sub nsw i32 %281, %283
%285 = load i32, i32* %7
%286 = mul nsw i32 %284, %285
%287 = sdiv i32 %286, 2
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %280, i64 %288
%290 = load i32, i32* %11
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds i32, i32* %289, i64 %291
store i32 %279, i32* %292
br label %293
293: ; preds = %246, %240, %234
%294 = load i32, i32* %10
%295 = add nsw i32 %294, 1
%296 = load i32, i32* %7
%297 = sdiv i32 %296, 2
%298 = icmp sgt i32 %295, %297
br i1 %298, label %299, label %358
299: ; preds = %293
%300 = load i32, i32* %11
%301 = add nsw i32 %300, 1
%302 = load i32, i32* %7
%303 = sdiv i32 %302, 2
%304 = icmp sgt i32 %301, %303
br i1 %304, label %305, label %358
305: ; preds = %299
%306 = load i32*, i32** %5
%307 = load i32, i32* %10
%308 = load i32, i32* %7
%309 = mul nsw i32 %307, %308
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %306, i64 %310
%312 = load i32, i32* %11
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i32, i32* %311, i64 %313
%315 = load i32, i32* %314
%316 = load i32*, i32** %15
%317 = load i32, i32* %10
%318 = load i32, i32* %7
%319 = sdiv i32 %318, 2
%320 = sub nsw i32 %317, %319
%321 = load i32, i32* %7
%322 = mul nsw i32 %320, %321
%323 = sdiv i32 %322, 2
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds i32, i32* %316, i64 %324
%326 = load i32, i32* %11
%327 = load i32, i32* %7
%328 = sdiv i32 %327, 2
%329 = sub nsw i32 %326, %328
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i32, i32* %325, i64 %330
store i32 %315, i32* %331
%332 = load i32*, i32** %6
%333 = load i32, i32* %10
%334 = load i32, i32* %7
%335 = mul nsw i32 %333, %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds i32, i32* %332, i64 %336
%338 = load i32, i32* %11
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %337, i64 %339
%341 = load i32, i32* %340
%342 = load i32*, i32** %19
%343 = load i32, i32* %10
%344 = load i32, i32* %7
%345 = sdiv i32 %344, 2
%346 = sub nsw i32 %343, %345
%347 = load i32, i32* %7
%348 = mul nsw i32 %346, %347
%349 = sdiv i32 %348, 2
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds i32, i32* %342, i64 %350
%352 = load i32, i32* %11
%353 = load i32, i32* %7
%354 = sdiv i32 %353, 2
%355 = sub nsw i32 %352, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i32, i32* %351, i64 %356
store i32 %341, i32* %357
br label %358
358: ; preds = %305, %299, %293
br label %359
359: ; preds = %358
%360 = load i32, i32* %11
%361 = add nsw i32 %360, 1
store i32 %361, i32* %11
br label %118
362: ; preds = %118
br label %363
363: ; preds = %362
%364 = load i32, i32* %10
%365 = add nsw i32 %364, 1
store i32 %365, i32* %10
br label %113
366: ; preds = %113
store i32 0, i32* %10
br label %367
367: ; preds = %384, %366
%368 = load i32, i32* %10
%369 = icmp slt i32 %368, 10
br i1 %369, label %370, label %387
370: ; preds = %367
%371 = load i32, i32* %7
%372 = sdiv i32 %371, 2
%373 = sext i32 %372 to i64
%374 = mul i64 4, %373
%375 = load i32, i32* %7
%376 = sdiv i32 %375, 2
%377 = sext i32 %376 to i64
%378 = mul i64 %374, %377
%379 = trunc i64 %378 to i32
%380 = call i32* @malloc(i32 %379)
%381 = load i32, i32* %10
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 %382
store i32* %380, i32** %383
br label %384
384: ; preds = %370
%385 = load i32, i32* %10
%386 = add nsw i32 %385, 1
store i32 %386, i32* %10
br label %367
387: ; preds = %367
%388 = load i32*, i32** %17
%389 = load i32*, i32** %19
%390 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 0
%391 = load i32*, i32** %390
%392 = load i32, i32* %7
%393 = sdiv i32 %392, 2
%394 = call i32 @square_matrix_sub(i32* %388, i32* %389, i32* %391, i32 %393)
%395 = load i32*, i32** %12
%396 = load i32*, i32** %13
%397 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 1
%398 = load i32*, i32** %397
%399 = load i32, i32* %7
%400 = sdiv i32 %399, 2
%401 = call i32 @square_matrix_add(i32* %395, i32* %396, i32* %398, i32 %400)
%402 = load i32*, i32** %14
%403 = load i32*, i32** %15
%404 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 2
%405 = load i32*, i32** %404
%406 = load i32, i32* %7
%407 = sdiv i32 %406, 2
%408 = call i32 @square_matrix_add(i32* %402, i32* %403, i32* %405, i32 %407)
%409 = load i32*, i32** %18
%410 = load i32*, i32** %16
%411 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 3
%412 = load i32*, i32** %411
%413 = load i32, i32* %7
%414 = sdiv i32 %413, 2
%415 = call i32 @square_matrix_sub(i32* %409, i32* %410, i32* %412, i32 %414)
%416 = load i32*, i32** %12
%417 = load i32*, i32** %15
%418 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 4
%419 = load i32*, i32** %418
%420 = load i32, i32* %7
%421 = sdiv i32 %420, 2
%422 = call i32 @square_matrix_add(i32* %416, i32* %417, i32* %419, i32 %421)
%423 = load i32*, i32** %16
%424 = load i32*, i32** %19
%425 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 5
%426 = load i32*, i32** %425
%427 = load i32, i32* %7
%428 = sdiv i32 %427, 2
%429 = call i32 @square_matrix_add(i32* %423, i32* %424, i32* %426, i32 %428)
%430 = load i32*, i32** %13
%431 = load i32*, i32** %15
%432 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 6
%433 = load i32*, i32** %432
%434 = load i32, i32* %7
%435 = sdiv i32 %434, 2
%436 = call i32 @square_matrix_sub(i32* %430, i32* %431, i32* %433, i32 %435)
%437 = load i32*, i32** %18
%438 = load i32*, i32** %19
%439 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 7
%440 = load i32*, i32** %439
%441 = load i32, i32* %7
%442 = sdiv i32 %441, 2
%443 = call i32 @square_matrix_add(i32* %437, i32* %438, i32* %440, i32 %442)
%444 = load i32*, i32** %12
%445 = load i32*, i32** %14
%446 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 8
%447 = load i32*, i32** %446
%448 = load i32, i32* %7
%449 = sdiv i32 %448, 2
%450 = call i32 @square_matrix_sub(i32* %444, i32* %445, i32* %447, i32 %449)
%451 = load i32*, i32** %16
%452 = load i32*, i32** %17
%453 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 9
%454 = load i32*, i32** %453
%455 = load i32, i32* %7
%456 = sdiv i32 %455, 2
%457 = call i32 @square_matrix_add(i32* %451, i32* %452, i32* %454, i32 %456)
store i32 0, i32* %10
br label %458
458: ; preds = %475, %387
%459 = load i32, i32* %10
%460 = icmp slt i32 %459, 7
br i1 %460, label %461, label %478
461: ; preds = %458
%462 = load i32, i32* %7
%463 = sdiv i32 %462, 2
%464 = sext i32 %463 to i64
%465 = mul i64 4, %464
%466 = load i32, i32* %7
%467 = sdiv i32 %466, 2
%468 = sext i32 %467 to i64
%469 = mul i64 %465, %468
%470 = trunc i64 %469 to i32
%471 = call i32* @malloc(i32 %470)
%472 = load i32, i32* %10
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 %473
store i32* %471, i32** %474
br label %475
475: ; preds = %461
%476 = load i32, i32* %10
%477 = add nsw i32 %476, 1
store i32 %477, i32* %10
br label %458
478: ; preds = %458
%479 = load i32*, i32** %12
%480 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 0
%481 = load i32*, i32** %480
%482 = load i32, i32* %7
%483 = sdiv i32 %482, 2
%484 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 0
%485 = load i32*, i32** %484
%486 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 1
%487 = load i32*, i32** %486
%488 = load i32*, i32** %19
%489 = load i32, i32* %7
%490 = sdiv i32 %489, 2
%491 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 1
%492 = load i32*, i32** %491
%493 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 2
%494 = load i32*, i32** %493
%495 = load i32*, i32** %16
%496 = load i32, i32* %7
%497 = sdiv i32 %496, 2
%498 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 2
%499 = load i32*, i32** %498
%500 = load i32*, i32** %15
%501 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 3
%502 = load i32*, i32** %501
%503 = load i32, i32* %7
%504 = sdiv i32 %503, 2
%505 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 3
%506 = load i32*, i32** %505
%507 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 4
%508 = load i32*, i32** %507
%509 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 5
%510 = load i32*, i32** %509
%511 = load i32, i32* %7
%512 = sdiv i32 %511, 2
%513 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 4
%514 = load i32*, i32** %513
%515 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 6
%516 = load i32*, i32** %515
%517 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 7
%518 = load i32*, i32** %517
%519 = load i32, i32* %7
%520 = sdiv i32 %519, 2
%521 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 5
%522 = load i32*, i32** %521
%523 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 8
%524 = load i32*, i32** %523
%525 = getelementptr inbounds [10 x i32*], [10 x i32*]* %28, i64 0, i64 9
%526 = load i32*, i32** %525
%527 = load i32, i32* %7
%528 = sdiv i32 %527, 2
%529 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 6
%530 = load i32*, i32** %529
%531 = load i32, i32* %7
%532 = sdiv i32 %531, 2
%533 = sext i32 %532 to i64
%534 = mul i64 4, %533
%535 = load i32, i32* %7
%536 = sdiv i32 %535, 2
%537 = sext i32 %536 to i64
%538 = mul i64 %534, %537
%539 = trunc i64 %538 to i32
%540 = call i32* @malloc(i32 %539)
store i32* %540, i32** %20
%541 = load i32, i32* %7
%542 = sdiv i32 %541, 2
%543 = sext i32 %542 to i64
%544 = mul i64 4, %543
%545 = load i32, i32* %7
%546 = sdiv i32 %545, 2
%547 = sext i32 %546 to i64
%548 = mul i64 %544, %547
%549 = trunc i64 %548 to i32
%550 = call i32* @malloc(i32 %549)
store i32* %550, i32** %24
%551 = load i32, i32* %7
%552 = sdiv i32 %551, 2
%553 = sext i32 %552 to i64
%554 = mul i64 4, %553
%555 = load i32, i32* %7
%556 = sdiv i32 %555, 2
%557 = sext i32 %556 to i64
%558 = mul i64 %554, %557
%559 = trunc i64 %558 to i32
%560 = call i32* @malloc(i32 %559)
store i32* %560, i32** %25
%561 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 4
%562 = load i32*, i32** %561
%563 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 3
%564 = load i32*, i32** %563
%565 = load i32*, i32** %24
%566 = load i32, i32* %7
%567 = sdiv i32 %566, 2
%568 = call i32 @square_matrix_add(i32* %562, i32* %564, i32* %565, i32 %567)
%569 = load i32*, i32** %24
%570 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 1
%571 = load i32*, i32** %570
%572 = load i32*, i32** %25
%573 = load i32, i32* %7
%574 = sdiv i32 %573, 2
%575 = call i32 @square_matrix_sub(i32* %569, i32* %571, i32* %572, i32 %574)
%576 = load i32*, i32** %25
%577 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 5
%578 = load i32*, i32** %577
%579 = load i32*, i32** %20
%580 = load i32, i32* %7
%581 = sdiv i32 %580, 2
%582 = call i32 @square_matrix_add(i32* %576, i32* %578, i32* %579, i32 %581)
%583 = load i32, i32* %7
%584 = sdiv i32 %583, 2
%585 = sext i32 %584 to i64
%586 = mul i64 4, %585
%587 = load i32, i32* %7
%588 = sdiv i32 %587, 2
%589 = sext i32 %588 to i64
%590 = mul i64 %586, %589
%591 = trunc i64 %590 to i32
%592 = call i32* @malloc(i32 %591)
store i32* %592, i32** %21
%593 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 0
%594 = load i32*, i32** %593
%595 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 1
%596 = load i32*, i32** %595
%597 = load i32*, i32** %21
%598 = load i32, i32* %7
%599 = sdiv i32 %598, 2
%600 = call i32 @square_matrix_add(i32* %594, i32* %596, i32* %597, i32 %599)
%601 = load i32, i32* %7
%602 = sdiv i32 %601, 2
%603 = sext i32 %602 to i64
%604 = mul i64 4, %603
%605 = load i32, i32* %7
%606 = sdiv i32 %605, 2
%607 = sext i32 %606 to i64
%608 = mul i64 %604, %607
%609 = trunc i64 %608 to i32
%610 = call i32* @malloc(i32 %609)
store i32* %610, i32** %22
%611 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 2
%612 = load i32*, i32** %611
%613 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 3
%614 = load i32*, i32** %613
%615 = load i32*, i32** %22
%616 = load i32, i32* %7
%617 = sdiv i32 %616, 2
%618 = call i32 @square_matrix_add(i32* %612, i32* %614, i32* %615, i32 %617)
%619 = load i32, i32* %7
%620 = sdiv i32 %619, 2
%621 = sext i32 %620 to i64
%622 = mul i64 4, %621
%623 = load i32, i32* %7
%624 = sdiv i32 %623, 2
%625 = sext i32 %624 to i64
%626 = mul i64 %622, %625
%627 = trunc i64 %626 to i32
%628 = call i32* @malloc(i32 %627)
store i32* %628, i32** %23
%629 = load i32, i32* %7
%630 = sdiv i32 %629, 2
%631 = sext i32 %630 to i64
%632 = mul i64 4, %631
%633 = load i32, i32* %7
%634 = sdiv i32 %633, 2
%635 = sext i32 %634 to i64
%636 = mul i64 %632, %635
%637 = trunc i64 %636 to i32
%638 = call i32* @malloc(i32 %637)
store i32* %638, i32** %26
%639 = load i32, i32* %7
%640 = sdiv i32 %639, 2
%641 = sext i32 %640 to i64
%642 = mul i64 4, %641
%643 = load i32, i32* %7
%644 = sdiv i32 %643, 2
%645 = sext i32 %644 to i64
%646 = mul i64 %642, %645
%647 = trunc i64 %646 to i32
%648 = call i32* @malloc(i32 %647)
store i32* %648, i32** %27
%649 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 4
%650 = load i32*, i32** %649
%651 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 0
%652 = load i32*, i32** %651
%653 = load i32*, i32** %26
%654 = load i32, i32* %7
%655 = sdiv i32 %654, 2
%656 = call i32 @square_matrix_add(i32* %650, i32* %652, i32* %653, i32 %655)
%657 = load i32*, i32** %26
%658 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 2
%659 = load i32*, i32** %658
%660 = load i32*, i32** %27
%661 = load i32, i32* %7
%662 = sdiv i32 %661, 2
%663 = call i32 @square_matrix_sub(i32* %657, i32* %659, i32* %660, i32 %662)
%664 = load i32*, i32** %27
%665 = getelementptr inbounds [7 x i32*], [7 x i32*]* %29, i64 0, i64 6
%666 = load i32*, i32** %665
%667 = load i32*, i32** %23
%668 = load i32, i32* %7
%669 = sdiv i32 %668, 2
%670 = call i32 @square_matrix_sub(i32* %664, i32* %666, i32* %667, i32 %669)
store i32 0, i32* %10
br label %671
671: ; preds = %829, %478
%672 = load i32, i32* %10
%673 = load i32, i32* %7
%674 = icmp slt i32 %672, %673
br i1 %674, label %675, label %832
675: ; preds = %671
store i32 0, i32* %11
br label %676
676: ; preds = %825, %675
%677 = load i32, i32* %11
%678 = load i32, i32* %7
%679 = icmp slt i32 %677, %678
br i1 %679, label %680, label %828
680: ; preds = %676
%681 = load i32, i32* %10
%682 = add nsw i32 %681, 1
%683 = load i32, i32* %7
%684 = sdiv i32 %683, 2
%685 = icmp sle i32 %682, %684
br i1 %685, label %686, label %713
686: ; preds = %680
%687 = load i32, i32* %11
%688 = add nsw i32 %687, 1
%689 = load i32, i32* %7
%690 = sdiv i32 %689, 2
%691 = icmp sle i32 %688, %690
br i1 %691, label %692, label %713
692: ; preds = %686
%693 = load i32*, i32** %20
%694 = load i32, i32* %10
%695 = load i32, i32* %7
%696 = mul nsw i32 %694, %695
%697 = sdiv i32 %696, 2
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds i32, i32* %693, i64 %698
%700 = load i32, i32* %11
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds i32, i32* %699, i64 %701
%703 = load i32, i32* %702
%704 = load i32*, i32** %8
%705 = load i32, i32* %10
%706 = load i32, i32* %7
%707 = mul nsw i32 %705, %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds i32, i32* %704, i64 %708
%710 = load i32, i32* %11
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds i32, i32* %709, i64 %711
store i32 %703, i32* %712
br label %713
713: ; preds = %692, %686, %680
%714 = load i32, i32* %10
%715 = add nsw i32 %714, 1
%716 = load i32, i32* %7
%717 = sdiv i32 %716, 2
%718 = icmp sle i32 %715, %717
br i1 %718, label %719, label %749
719: ; preds = %713
%720 = load i32, i32* %11
%721 = add nsw i32 %720, 1
%722 = load i32, i32* %7
%723 = sdiv i32 %722, 2
%724 = icmp sgt i32 %721, %723
br i1 %724, label %725, label %749
725: ; preds = %719
%726 = load i32*, i32** %21
%727 = load i32, i32* %10
%728 = load i32, i32* %7
%729 = mul nsw i32 %727, %728
%730 = sdiv i32 %729, 2
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds i32, i32* %726, i64 %731
%733 = load i32, i32* %11
%734 = load i32, i32* %7
%735 = sdiv i32 %734, 2
%736 = sub nsw i32 %733, %735
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds i32, i32* %732, i64 %737
%739 = load i32, i32* %738
%740 = load i32*, i32** %8
%741 = load i32, i32* %10
%742 = load i32, i32* %7
%743 = mul nsw i32 %741, %742
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds i32, i32* %740, i64 %744
%746 = load i32, i32* %11
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds i32, i32* %745, i64 %747
store i32 %739, i32* %748
br label %749
749: ; preds = %725, %719, %713
%750 = load i32, i32* %10
%751 = add nsw i32 %750, 1
%752 = load i32, i32* %7
%753 = sdiv i32 %752, 2
%754 = icmp sgt i32 %751, %753
br i1 %754, label %755, label %785
755: ; preds = %749
%756 = load i32, i32* %11
%757 = add nsw i32 %756, 1
%758 = load i32, i32* %7
%759 = sdiv i32 %758, 2
%760 = icmp sle i32 %757, %759
br i1 %760, label %761, label %785
761: ; preds = %755
%762 = load i32*, i32** %22
%763 = load i32, i32* %10
%764 = load i32, i32* %7
%765 = sdiv i32 %764, 2
%766 = sub nsw i32 %763, %765
%767 = load i32, i32* %7
%768 = mul nsw i32 %766, %767
%769 = sdiv i32 %768, 2
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds i32, i32* %762, i64 %770
%772 = load i32, i32* %11
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds i32, i32* %771, i64 %773
%775 = load i32, i32* %774
%776 = load i32*, i32** %8
%777 = load i32, i32* %10
%778 = load i32, i32* %7
%779 = mul nsw i32 %777, %778
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds i32, i32* %776, i64 %780
%782 = load i32, i32* %11
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds i32, i32* %781, i64 %783
store i32 %775, i32* %784
br label %785
785: ; preds = %761, %755, %749
%786 = load i32, i32* %10
%787 = add nsw i32 %786, 1
%788 = load i32, i32* %7
%789 = sdiv i32 %788, 2
%790 = icmp sgt i32 %787, %789
br i1 %790, label %791, label %824
791: ; preds = %785
%792 = load i32, i32* %11
%793 = add nsw i32 %792, 1
%794 = load i32, i32* %7
%795 = sdiv i32 %794, 2
%796 = icmp sgt i32 %793, %795
br i1 %796, label %797, label %824
797: ; preds = %791
%798 = load i32*, i32** %23
%799 = load i32, i32* %10
%800 = load i32, i32* %7
%801 = sdiv i32 %800, 2
%802 = sub nsw i32 %799, %801
%803 = load i32, i32* %7
%804 = mul nsw i32 %802, %803
%805 = sdiv i32 %804, 2
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds i32, i32* %798, i64 %806
%808 = load i32, i32* %11
%809 = load i32, i32* %7
%810 = sdiv i32 %809, 2
%811 = sub nsw i32 %808, %810
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds i32, i32* %807, i64 %812
%814 = load i32, i32* %813
%815 = load i32*, i32** %8
%816 = load i32, i32* %10
%817 = load i32, i32* %7
%818 = mul nsw i32 %816, %817
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds i32, i32* %815, i64 %819
%821 = load i32, i32* %11
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds i32, i32* %820, i64 %822
store i32 %814, i32* %823
br label %824
824: ; preds = %797, %791, %785
br label %825
825: ; preds = %824
%826 = load i32, i32* %11
%827 = add nsw i32 %826, 1
store i32 %827, i32* %11
br label %676
828: ; preds = %676
br label %829
829: ; preds = %828
%830 = load i32, i32* %10
%831 = add nsw i32 %830, 1
store i32 %831, i32* %10
br label %671
832: ; preds = %671
br label %833
833: ; preds = %832, %33
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 %204
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 %56
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 = %146, %29
%34 = phi i64 [ 0, %29 ], [ %147, %146 ]
%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 %103
56: ; preds = %146, %25
%57 = phi i32 [ %28, %25 ], [ %30, %146 ]
%58 = shl i32 %57, 2
%59 = mul i32 %58, %57
%60 = tail call i32* @malloc(i32 %59)
%61 = tail call i32* @malloc(i32 %59)
%62 = tail call i32* @malloc(i32 %59)
%63 = tail call i32* @malloc(i32 %59)
%64 = tail call i32* @malloc(i32 %59)
%65 = tail call i32* @malloc(i32 %59)
%66 = tail call i32* @malloc(i32 %59)
%67 = tail call i32* @malloc(i32 %59)
%68 = tail call i32* @malloc(i32 %59)
%69 = tail call i32* @malloc(i32 %59)
%70 = tail call i32 @square_matrix_sub(i32* %21, i32* %23, i32* %60, i32 %57)
%71 = tail call i32 @square_matrix_add(i32* %16, i32* %17, i32* %61, i32 %57)
%72 = tail call i32 @square_matrix_add(i32* %18, i32* %19, i32* %62, i32 %57)
%73 = tail call i32 @square_matrix_sub(i32* %22, i32* %20, i32* %63, i32 %57)
%74 = tail call i32 @square_matrix_add(i32* %16, i32* %19, i32* %64, i32 %57)
%75 = tail call i32 @square_matrix_add(i32* %20, i32* %23, i32* %65, i32 %57)
%76 = tail call i32 @square_matrix_sub(i32* %17, i32* %19, i32* %66, i32 %57)
%77 = tail call i32 @square_matrix_add(i32* %22, i32* %23, i32* %67, i32 %57)
%78 = tail call i32 @square_matrix_sub(i32* %16, i32* %18, i32* %68, i32 %57)
%79 = tail call i32 @square_matrix_add(i32* %20, i32* %21, i32* %69, i32 %57)
%80 = tail call i32* @malloc(i32 %59)
%81 = tail call i32* @malloc(i32 %59)
%82 = tail call i32* @malloc(i32 %59)
%83 = tail call i32* @malloc(i32 %59)
%84 = tail call i32* @malloc(i32 %59)
%85 = tail call i32* @malloc(i32 %59)
%86 = tail call i32* @malloc(i32 %59)
tail call void @square_matrix_multiply(i32* %16, i32* %60, i32 %57, i32* %80)
tail call void @square_matrix_multiply(i32* %61, i32* %23, i32 %57, i32* %81)
tail call void @square_matrix_multiply(i32* %62, i32* %20, i32 %57, i32* %82)
tail call void @square_matrix_multiply(i32* %19, i32* %63, i32 %57, i32* %83)
tail call void @square_matrix_multiply(i32* %64, i32* %65, i32 %57, i32* %84)
tail call void @square_matrix_multiply(i32* %66, i32* %67, i32 %57, i32* %85)
tail call void @square_matrix_multiply(i32* %68, i32* %69, i32 %57, i32* %86)
%87 = tail call i32* @malloc(i32 %59)
%88 = tail call i32* @malloc(i32 %59)
%89 = tail call i32* @malloc(i32 %59)
%90 = tail call i32 @square_matrix_add(i32* %84, i32* %83, i32* %88, i32 %57)
%91 = tail call i32 @square_matrix_sub(i32* %88, i32* %81, i32* %89, i32 %57)
%92 = tail call i32 @square_matrix_add(i32* %89, i32* %85, i32* %87, i32 %57)
%93 = tail call i32* @malloc(i32 %59)
%94 = tail call i32 @square_matrix_add(i32* %80, i32* %81, i32* %93, i32 %57)
%95 = tail call i32* @malloc(i32 %59)
%96 = tail call i32 @square_matrix_add(i32* %82, i32* %83, i32* %95, i32 %57)
%97 = tail call i32* @malloc(i32 %59)
%98 = tail call i32* @malloc(i32 %59)
%99 = tail call i32* @malloc(i32 %59)
%100 = tail call i32 @square_matrix_add(i32* %84, i32* %80, i32* %98, i32 %57)
%101 = tail call i32 @square_matrix_sub(i32* %98, i32* %82, i32* %99, i32 %57)
%102 = tail call i32 @square_matrix_sub(i32* %99, i32* %86, i32* %97, i32 %57)
br i1 %24, label %149, label %204
103: ; preds = %33, %143
%104 = phi i64 [ 0, %33 ], [ %144, %143 ]
%105 = icmp ult i64 %104, %31
%106 = select i1 %35, i1 %105, i1 false
br i1 %106, label %107, label %114
107: ; preds = %103
%108 = getelementptr inbounds i32, i32* %37, i64 %104
%109 = load i32, i32* %108
%110 = getelementptr inbounds i32, i32* %41, i64 %104
store i32 %109, i32* %110
%111 = getelementptr inbounds i32, i32* %42, i64 %104
%112 = load i32, i32* %111
%113 = getelementptr inbounds i32, i32* %43, i64 %104
store i32 %112, i32* %113
br label %114
114: ; preds = %107, %103
%115 = select i1 %44, i1 true, i1 %105
br i1 %115, label %124, label %116
116: ; preds = %114
%117 = getelementptr inbounds i32, i32* %37, i64 %104
%118 = load i32, i32* %117
%119 = sub nsw i64 %104, %31
%120 = getelementptr inbounds i32, i32* %45, i64 %119
store i32 %118, i32* %120
%121 = getelementptr inbounds i32, i32* %42, i64 %104
%122 = load i32, i32* %121
%123 = getelementptr inbounds i32, i32* %46, i64 %119
store i32 %122, i32* %123
br label %124
124: ; preds = %116, %114
%125 = select i1 %44, i1 %105, i1 false
br i1 %125, label %126, label %133
126: ; preds = %124
%127 = getelementptr inbounds i32, i32* %37, i64 %104
%128 = load i32, i32* %127
%129 = getelementptr inbounds i32, i32* %52, i64 %104
store i32 %128, i32* %129
%130 = getelementptr inbounds i32, i32* %42, i64 %104
%131 = load i32, i32* %130
%132 = getelementptr inbounds i32, i32* %53, i64 %104
store i32 %131, i32* %132
br label %133
133: ; preds = %126, %124
%134 = select i1 %35, i1 true, i1 %105
br i1 %134, label %143, label %135
135: ; preds = %133
%136 = getelementptr inbounds i32, i32* %37, i64 %104
%137 = load i32, i32* %136
%138 = sub nsw i64 %104, %31
%139 = getelementptr inbounds i32, i32* %54, i64 %138
store i32 %137, i32* %139
%140 = getelementptr inbounds i32, i32* %42, i64 %104
%141 = load i32, i32* %140
%142 = getelementptr inbounds i32, i32* %55, i64 %138
store i32 %141, i32* %142
br label %143
143: ; preds = %133, %135
%144 = add nuw nsw i64 %104, 1
%145 = icmp eq i64 %144, %32
br i1 %145, label %146, label %103
146: ; preds = %143
%147 = add nuw nsw i64 %34, 1
%148 = icmp eq i64 %147, %32
br i1 %148, label %56, label %33
149: ; preds = %56
%150 = sext i32 %57 to i64
%151 = zext i32 %2 to i64
br label %152
152: ; preds = %201, %149
%153 = phi i64 [ 0, %149 ], [ %202, %201 ]
%154 = icmp slt i64 %153, %150
%155 = mul nsw i64 %153, %11
%156 = trunc i64 %155 to i32
%157 = sdiv i32 %156, 2
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %87, i64 %158
%160 = getelementptr inbounds i32, i32* %3, i64 %155
%161 = xor i1 %154, true
%162 = getelementptr inbounds i32, i32* %93, i64 %158
%163 = trunc i64 %153 to i32
%164 = sub i32 %163, %57
%165 = mul i32 %164, %2
%166 = sdiv i32 %165, 2
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %95, i64 %167
%169 = getelementptr inbounds i32, i32* %97, i64 %167
br label %170
170: ; preds = %152, %198
%171 = phi i64 [ 0, %152 ], [ %199, %198 ]
%172 = icmp slt i64 %171, %150
%173 = select i1 %154, i1 %172, i1 false
br i1 %173, label %174, label %178
174: ; preds = %170
%175 = getelementptr inbounds i32, i32* %159, i64 %171
%176 = load i32, i32* %175
%177 = getelementptr inbounds i32, i32* %160, i64 %171
store i32 %176, i32* %177
br label %178
178: ; preds = %174, %170
%179 = select i1 %161, i1 true, i1 %172
br i1 %179, label %185, label %180
180: ; preds = %178
%181 = sub nsw i64 %171, %150
%182 = getelementptr inbounds i32, i32* %162, i64 %181
%183 = load i32, i32* %182
%184 = getelementptr inbounds i32, i32* %160, i64 %171
store i32 %183, i32* %184
br label %185
185: ; preds = %180, %178
%186 = select i1 %161, i1 %172, i1 false
br i1 %186, label %187, label %191
187: ; preds = %185
%188 = getelementptr inbounds i32, i32* %168, i64 %171
%189 = load i32, i32* %188
%190 = getelementptr inbounds i32, i32* %160, i64 %171
store i32 %189, i32* %190
br label %191
191: ; preds = %187, %185
%192 = select i1 %154, i1 true, i1 %172
br i1 %192, label %198, label %193
193: ; preds = %191
%194 = sub nsw i64 %171, %150
%195 = getelementptr inbounds i32, i32* %169, i64 %194
%196 = load i32, i32* %195
%197 = getelementptr inbounds i32, i32* %160, i64 %171
store i32 %196, i32* %197
br label %198
198: ; preds = %191, %193
%199 = add nuw nsw i64 %171, 1
%200 = icmp eq i64 %199, %151
br i1 %200, label %201, label %170
201: ; preds = %198
%202 = add nuw nsw i64 %153, 1
%203 = icmp eq i64 %202, %151
br i1 %203, label %204, label %152
204: ; preds = %201, %56, %6
ret void
}