#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 */
scalar_t__ _mm_malloc(int, int);
int /*<<< orphan*/ block_to_row(int const, int, double *, double *);
int /*<<< orphan*/ do_block(int const, int, double *, double *, double *, int,
                            int, int);
int /*<<< orphan*/ row_to_block(int const, int, double const *, double *);
int /*<<< orphan*/ row_to_block_transpose(int const, int, double const *,
                                          double *);
void square_dgemm(const int M, const double *A, const double *B, double *C) {
  int pad_size, bi, bj, bk, L2bi, L2bj, L2bk, nblock, L2nblock, rem;
  if (M % ((int)16) == 0) {
    nblock = M / ((int)16);
    pad_size = M;
  } else {
    pad_size = ((M / ((int)16)) + 1) * ((int)16);
    nblock = M / ((int)16) + 1;
  }
  if (pad_size % (((int)8) * ((int)16)) == 0) {
    L2nblock = pad_size / (((int)8) * ((int)16));
    rem = ((int)8);
  } else {
    L2nblock = pad_size / (((int)8) * ((int)16)) + 1;
    rem = (pad_size % (((int)8) * ((int)16))) / ((int)16);
  }
  double *restrict bA =
      (double *)_mm_malloc(pad_size * pad_size * sizeof(double), 64);
  double *restrict bB =
      (double *)_mm_malloc(pad_size * pad_size * sizeof(double), 64);
  double *restrict bC =
      (double *)_mm_malloc(pad_size * pad_size * sizeof(double), 64);
  row_to_block(M, nblock, A, bA);
  row_to_block_transpose(M, nblock, B, bB);
  row_to_block(M, nblock, C, bC);
  for (L2bk = 0; L2bk < L2nblock - 1; ++L2bk) {
    for (L2bj = 0; L2bj < L2nblock - 1; ++L2bj) {
      for (L2bi = 0; L2bi < L2nblock - 1; ++L2bi) {
        for (bk = 0; bk < ((int)8); ++bk) {
          int Ak = L2bk * ((int)8) + bk;
          for (bj = 0; bj < ((int)8); ++bj) {
            int Aj = L2bj * ((int)8) + bj;
            for (bi = 0; bi < ((int)8); ++bi) {
              int Ai = L2bi * ((int)8) + bi;
              do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
            }
          }
        }
      }
    }
  }
  L2bk = L2nblock - 1;
  for (L2bj = 0; L2bj < L2nblock - 1; ++L2bj) {
    for (L2bi = 0; L2bi < L2nblock - 1; ++L2bi) {
      for (bk = 0; bk < rem; ++bk) {
        int Ak = L2bk * ((int)8) + bk;
        for (bj = 0; bj < ((int)8); ++bj) {
          int Aj = L2bj * ((int)8) + bj;
          for (bi = 0; bi < ((int)8); ++bi) {
            int Ai = L2bi * ((int)8) + bi;
            do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
          }
        }
      }
    }
  }
  L2bj = L2nblock - 1;
  for (L2bk = 0; L2bk < L2nblock - 1; ++L2bk) {
    for (L2bi = 0; L2bi < L2nblock - 1; ++L2bi) {
      for (bk = 0; bk < ((int)8); ++bk) {
        int Ak = L2bk * ((int)8) + bk;
        for (bj = 0; bj < rem; ++bj) {
          int Aj = L2bj * ((int)8) + bj;
          for (bi = 0; bi < ((int)8); ++bi) {
            int Ai = L2bi * ((int)8) + bi;
            do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
          }
        }
      }
    }
  }
  L2bi = L2nblock - 1;
  for (L2bk = 0; L2bk < L2nblock - 1; ++L2bk) {
    for (L2bj = 0; L2bj < L2nblock - 1; ++L2bj) {
      for (bk = 0; bk < ((int)8); ++bk) {
        int Ak = L2bk * ((int)8) + bk;
        for (bj = 0; bj < ((int)8); ++bj) {
          int Aj = L2bj * ((int)8) + bj;
          for (bi = 0; bi < rem; ++bi) {
            int Ai = L2bi * ((int)8) + bi;
            do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
          }
        }
      }
    }
  }
  L2bj = L2nblock - 1;
  L2bk = L2nblock - 1;
  for (L2bi = 0; L2bi < L2nblock - 1; ++L2bi) {
    for (bk = 0; bk < rem; ++bk) {
      int Ak = L2bk * ((int)8) + bk;
      for (bj = 0; bj < rem; ++bj) {
        int Aj = L2bj * ((int)8) + bj;
        for (bi = 0; bi < ((int)8); ++bi) {
          int Ai = L2bi * ((int)8) + bi;
          do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
        }
      }
    }
  }
  L2bi = L2nblock - 1;
  L2bk = L2nblock - 1;
  for (L2bj = 0; L2bj < L2nblock - 1; ++L2bj) {
    for (bk = 0; bk < rem; ++bk) {
      int Ak = L2bk * ((int)8) + bk;
      for (bj = 0; bj < ((int)8); ++bj) {
        int Aj = L2bj * ((int)8) + bj;
        for (bi = 0; bi < rem; ++bi) {
          int Ai = L2bi * ((int)8) + bi;
          do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
        }
      }
    }
  }
  L2bj = L2nblock - 1;
  L2bi = L2nblock - 1;
  for (L2bk = 0; L2bk < L2nblock - 1; ++L2bk) {
    for (bk = 0; bk < ((int)8); ++bk) {
      int Ak = L2bk * ((int)8) + bk;
      for (bj = 0; bj < rem; ++bj) {
        int Aj = L2bj * ((int)8) + bj;
        for (bi = 0; bi < rem; ++bi) {
          int Ai = L2bi * ((int)8) + bi;
          do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
        }
      }
    }
  }
  L2bj = L2nblock - 1;
  L2bj = L2nblock - 1;
  L2bi = L2nblock - 1;
  for (bk = 0; bk < rem; ++bk) {
    int Ak = L2bk * ((int)8) + bk;
    for (bj = 0; bj < rem; ++bj) {
      int Aj = L2bj * ((int)8) + bj;
      for (bi = 0; bi < rem; ++bi) {
        int Ai = L2bi * ((int)8) + bi;
        do_block(M, nblock, bA, bB, bC, Ai, Aj, Ak);
      }
    }
  }
  block_to_row(M, nblock, C, bC);
}


x86 assembly (clang, -O0):
<square_dgemm>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1197 <square_dgemm+0x47>
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11bc <square_dgemm+0x6c>
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
shl    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x80,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11ea <square_dgemm+0x9a>
mov    -0x24(%rbp),%eax
mov    $0x80,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
movl   $0x8,-0x48(%rbp)
jmp    1213 <square_dgemm+0xc3>
mov    -0x24(%rbp),%eax
mov    $0x80,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x80,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1060 <row_to_block@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rcx
call   1050 <row_to_block_transpose@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x60(%rbp),%rcx
call   1060 <row_to_block@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13d9 <square_dgemm+0x289>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13c6 <square_dgemm+0x276>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13b3 <square_dgemm+0x263>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    13a0 <square_dgemm+0x250>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    138d <square_dgemm+0x23d>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jge    137a <square_dgemm+0x22a>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x6c(%rbp),%r9d
mov    -0x68(%rbp),%r10d
mov    -0x64(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    132c <square_dgemm+0x1dc>
jmp    137f <square_dgemm+0x22f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130f <square_dgemm+0x1bf>
jmp    1392 <square_dgemm+0x242>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f2 <square_dgemm+0x1a2>
jmp    13a5 <square_dgemm+0x255>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12da <square_dgemm+0x18a>
jmp    13b8 <square_dgemm+0x268>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c2 <square_dgemm+0x172>
jmp    13cb <square_dgemm+0x27b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12aa <square_dgemm+0x15a>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14ef <square_dgemm+0x39f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14dc <square_dgemm+0x38c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    14c9 <square_dgemm+0x379>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    14b6 <square_dgemm+0x366>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jge    14a3 <square_dgemm+0x353>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x78(%rbp),%r9d
mov    -0x74(%rbp),%r10d
mov    -0x70(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1455 <square_dgemm+0x305>
jmp    14a8 <square_dgemm+0x358>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1438 <square_dgemm+0x2e8>
jmp    14bb <square_dgemm+0x36b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1419 <square_dgemm+0x2c9>
jmp    14ce <square_dgemm+0x37e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1401 <square_dgemm+0x2b1>
jmp    14e1 <square_dgemm+0x391>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13e9 <square_dgemm+0x299>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    160b <square_dgemm+0x4bb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15f8 <square_dgemm+0x4a8>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    15e5 <square_dgemm+0x495>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    15d2 <square_dgemm+0x482>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x80(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jge    15bf <square_dgemm+0x46f>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x84(%rbp),%r9d
mov    -0x80(%rbp),%r10d
mov    -0x7c(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    156b <square_dgemm+0x41b>
jmp    15c4 <square_dgemm+0x474>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    154c <square_dgemm+0x3fc>
jmp    15d7 <square_dgemm+0x487>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    152f <square_dgemm+0x3df>
jmp    15ea <square_dgemm+0x49a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1517 <square_dgemm+0x3c7>
jmp    15fd <square_dgemm+0x4ad>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ff <square_dgemm+0x3af>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1733 <square_dgemm+0x5e3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1720 <square_dgemm+0x5d0>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    170d <square_dgemm+0x5bd>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x88(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    16fa <square_dgemm+0x5aa>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    16e7 <square_dgemm+0x597>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x90(%rbp),%r9d
mov    -0x8c(%rbp),%r10d
mov    -0x88(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    168b <square_dgemm+0x53b>
jmp    16ec <square_dgemm+0x59c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    166b <square_dgemm+0x51b>
jmp    16ff <square_dgemm+0x5af>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    164b <square_dgemm+0x4fb>
jmp    1712 <square_dgemm+0x5c2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1633 <square_dgemm+0x4e3>
jmp    1725 <square_dgemm+0x5d5>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    161b <square_dgemm+0x4cb>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    183b <square_dgemm+0x6eb>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1828 <square_dgemm+0x6d8>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1815 <square_dgemm+0x6c5>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x8,-0x28(%rbp)
jge    1802 <square_dgemm+0x6b2>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x9c(%rbp),%r9d
mov    -0x98(%rbp),%r10d
mov    -0x94(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17a8 <square_dgemm+0x658>
jmp    1807 <square_dgemm+0x6b7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1786 <square_dgemm+0x636>
jmp    181a <square_dgemm+0x6ca>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1764 <square_dgemm+0x614>
jmp    182d <square_dgemm+0x6dd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    174c <square_dgemm+0x5fc>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1943 <square_dgemm+0x7f3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1930 <square_dgemm+0x7e0>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0xa0(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    191d <square_dgemm+0x7cd>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    190a <square_dgemm+0x7ba>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0xa8(%rbp),%r9d
mov    -0xa4(%rbp),%r10d
mov    -0xa0(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18ae <square_dgemm+0x75e>
jmp    190f <square_dgemm+0x7bf>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    188e <square_dgemm+0x73e>
jmp    1922 <square_dgemm+0x7d2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    186c <square_dgemm+0x71c>
jmp    1935 <square_dgemm+0x7e5>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1854 <square_dgemm+0x704>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a4b <square_dgemm+0x8fb>
movl   $0x0,-0x30(%rbp)
cmpl   $0x8,-0x30(%rbp)
jge    1a38 <square_dgemm+0x8e8>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0xac(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1a25 <square_dgemm+0x8d5>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1a12 <square_dgemm+0x8c2>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0xb4(%rbp),%r9d
mov    -0xb0(%rbp),%r10d
mov    -0xac(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    19b6 <square_dgemm+0x866>
jmp    1a17 <square_dgemm+0x8c7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1994 <square_dgemm+0x844>
jmp    1a2a <square_dgemm+0x8da>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1974 <square_dgemm+0x824>
jmp    1a3d <square_dgemm+0x8ed>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    195c <square_dgemm+0x80c>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1b33 <square_dgemm+0x9e3>
mov    -0x3c(%rbp),%eax
shl    $0x3,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0xb8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1b20 <square_dgemm+0x9d0>
mov    -0x38(%rbp),%eax
shl    $0x3,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0xbc(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1b0d <square_dgemm+0x9bd>
mov    -0x34(%rbp),%eax
shl    $0x3,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0xc0(%rbp),%r9d
mov    -0xbc(%rbp),%r10d
mov    -0xb8(%rbp),%eax
mov    %r10d,(%rsp)
mov    %eax,0x8(%rsp)
call   1030 <do_block@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1ab1 <square_dgemm+0x961>
jmp    1b12 <square_dgemm+0x9c2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a8f <square_dgemm+0x93f>
jmp    1b25 <square_dgemm+0x9d5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a6d <square_dgemm+0x91d>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x60(%rbp),%rcx
call   1040 <block_to_row@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<square_dgemm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %edi,%ebx
lea    0xf(%rbx),%eax
test   %edi,%edi
cmovns %edi,%eax
sar    $0x4,%eax
lea    0x1(%rax),%r12d
mov    %r12d,%ebp
shl    $0x4,%ebp
test   $0xf,%bl
cmove  %eax,%r12d
cmove  %edi,%ebp
lea    0x7f(%rbp),%edi
test   %ebp,%ebp
cmovns %ebp,%edi
mov    %rcx,0xb8(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,0x28(%rsp)
mov    %edi,%r13d
sar    $0x7,%r13d
and    $0xffffff80,%edi
mov    %ebp,%eax
sub    %edi,%eax
je     11c5 <square_dgemm+0x75>
add    $0x1,%r13d
mov    %eax,%ecx
sar    $0x7,%cl
shr    $0x4,%cl
add    %al,%cl
sar    $0x4,%cl
movsbl %cl,%eax
mov    %eax,(%rsp)
jmp    11cc <square_dgemm+0x7c>
movl   $0x8,(%rsp)
imul   %ebp,%ebp
shl    $0x3,%ebp
mov    %ebp,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,%r14
mov    %ebp,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
mov    $0x40,%esi
call   1070 <_mm_malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
mov    %r12d,%esi
mov    0x28(%rsp),%rdx
mov    %r14,0x10(%rsp)
mov    %r14,%rcx
call   1060 <row_to_block@plt>
mov    %ebx,%edi
mov    %r12d,%esi
mov    0x8(%rsp),%rdx
mov    %r15,0x18(%rsp)
mov    %r15,%rcx
call   1050 <row_to_block_transpose@plt>
mov    %rbx,0x38(%rsp)
mov    %ebx,%edi
mov    %r12d,0x4(%rsp)
mov    %r12d,%esi
mov    0xb8(%rsp),%rdx
mov    %rbp,0x30(%rsp)
mov    %rbp,%rcx
call   1060 <row_to_block@plt>
lea    -0x1(%r13),%ecx
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmp    $0x2,%r13d
jl     2493 <square_dgemm+0x1343>
mov    %r13,0xb0(%rsp)
xor    %eax,%eax
mov    %rcx,0x98(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rax,0xc0(%rsp)
lea    0x0(,%rax,8),%eax
mov    %rax,0x90(%rsp)
xor    %edx,%edx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    %eax,0xac(%rsp)
xor    %eax,%eax
mov    %rdx,0x48(%rsp)
xchg   %ax,%ax
lea    0x0(,%rax,8),%ecx
lea    0x1(,%rax,8),%esi
mov    %esi,0x60(%rsp)
lea    0x2(,%rax,8),%esi
mov    %esi,0x58(%rsp)
lea    0x3(,%rax,8),%esi
mov    %esi,0x80(%rsp)
lea    0x4(,%rax,8),%esi
mov    %esi,0x78(%rsp)
lea    0x5(,%rax,8),%esi
mov    %esi,0x70(%rsp)
lea    0x6(,%rax,8),%esi
mov    %esi,0x68(%rsp)
mov    %rax,0xa0(%rsp)
lea    0x7(,%rax,8),%eax
mov    %eax,0x50(%rsp)
xor    %esi,%esi
mov    %ecx,0x20(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x90(%rsp),%rax
mov    %rsi,0x88(%rsp)
add    %esi,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
mov    %rax,0x40(%rsp)
add    %edx,%eax
mov    %rax,0x28(%rsp)
mov    0x38(%rsp),%r13
mov    %r13d,%edi
mov    0x4(%rsp),%r12d
mov    %r12d,%esi
mov    0x10(%rsp),%rbp
mov    %rbp,%rdx
mov    0x18(%rsp),%r14
mov    %r14,%rcx
mov    0x30(%rsp),%r15
mov    %r15,%r8
mov    0x20(%rsp),%r9d
mov    0x8(%rsp),%rbx
push   %rbx
push   %rax
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r13d,%edi
mov    %r12d,%esi
mov    %rbp,%rdx
mov    %rbp,%r12
mov    %r14,%rcx
mov    %r15,%r8
mov    0x60(%rsp),%r9d
push   %rbx
mov    0x30(%rsp),%rbx
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r13d,%edi
mov    0x4(%rsp),%ebp
mov    %ebp,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r15,%r8
mov    0x58(%rsp),%r9d
push   0x8(%rsp)
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r13d,%edi
mov    %ebp,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    %r15,%r8
mov    0x80(%rsp),%r9d
mov    0x8(%rsp),%rbx
push   %rbx
mov    0x30(%rsp),%r15
push   %r15
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r13d,%edi
mov    %ebp,%r13d
mov    %ebp,%esi
mov    %r12,%rdx
mov    %r14,%rcx
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r9d
push   %rbx
mov    %r15,%r14
push   %r15
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    0x38(%rsp),%rbp
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r12,%r13
mov    %r12,%rdx
mov    0x18(%rsp),%r12
mov    %r12,%rcx
mov    0x30(%rsp),%r15
mov    %r15,%r8
mov    0x70(%rsp),%r9d
push   %rbx
push   %r14
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %ebp,%edi
mov    0x4(%rsp),%ebp
mov    %ebp,%esi
mov    %r13,%rdx
mov    %r12,%rcx
mov    %r15,%r8
mov    0x68(%rsp),%r9d
push   %rbx
push   %r14
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    0x38(%rsp),%rdi
mov    %ebp,%esi
mov    %r13,%rdx
mov    %r12,%rcx
mov    %r15,%r8
mov    0x50(%rsp),%r9d
push   %rbx
push   %r14
call   1030 <do_block@plt>
mov    0x50(%rsp),%rax
mov    0x58(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%eax
cmp    $0x8,%eax
jne    1340 <square_dgemm+0x1f0>
mov    0x88(%rsp),%rsi
add    $0x1,%esi
cmp    $0x8,%esi
jne    1320 <square_dgemm+0x1d0>
mov    0xa0(%rsp),%rax
add    $0x1,%eax
mov    0x98(%rsp),%rcx
cmp    %ecx,%eax
jne    12b0 <square_dgemm+0x160>
mov    0xac(%rsp),%eax
add    $0x1,%eax
add    $0x8,%edx
cmp    %ecx,%eax
jne    12a0 <square_dgemm+0x150>
mov    0xc0(%rsp),%rax
add    $0x1,%eax
cmp    %ecx,%eax
jne    1280 <square_dgemm+0x130>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
lea    0x0(,%rcx,8),%eax
mov    %rax,0x90(%rsp)
xor    %edx,%edx
xor    %esi,%esi
mov    (%rsp),%eax
jmp    1555 <square_dgemm+0x405>
cs nopw 0x0(%rax,%rax,1)
mov    0xac(%rsp),%esi
add    $0x1,%esi
add    $0x8,%edx
cmp    %ecx,%esi
je     17af <square_dgemm+0x65f>
mov    %esi,0xac(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
mov    %rdx,0x48(%rsp)
jmp    158f <square_dgemm+0x43f>
nopl   (%rax)
mov    0xa0(%rsp),%rsi
add    $0x1,%esi
mov    0x98(%rsp),%rcx
mov    %rsi,0xa0(%rsp)
cmp    %ecx,%esi
je     1540 <square_dgemm+0x3f0>
test   %eax,%eax
jle    1570 <square_dgemm+0x420>
mov    0xa0(%rsp),%rax
lea    0x0(,%rax,8),%ecx
lea    0x1(,%rax,8),%esi
mov    %esi,0x60(%rsp)
lea    0x2(,%rax,8),%esi
mov    %esi,0x58(%rsp)
lea    0x3(,%rax,8),%esi
mov    %esi,0x80(%rsp)
lea    0x4(,%rax,8),%esi
mov    %esi,0x78(%rsp)
lea    0x5(,%rax,8),%esi
mov    %esi,0x70(%rsp)
lea    0x6(,%rax,8),%esi
mov    %esi,0x68(%rsp)
lea    0x7(,%rax,8),%eax
mov    %eax,0x50(%rsp)
xor    %esi,%esi
mov    %ecx,0x20(%rsp)
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rax
mov    %rsi,0x88(%rsp)
add    %esi,%eax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
mov    %rax,0x40(%rsp)
add    %edx,%eax
mov    %rax,0x8(%rsp)
mov    0x38(%rsp),%r15
mov    %r15d,%edi
mov    0x4(%rsp),%r13d
mov    %r13d,%esi
mov    0x10(%rsp),%rbp
mov    %rbp,%rdx
mov    0x18(%rsp),%r14
mov    %r14,%rcx
mov    0x30(%rsp),%r12
mov    %r12,%r8
mov    0x20(%rsp),%r9d
mov    0x28(%rsp),%rbx
push   %rbx
push   %rax
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbp,%rdx
mov    %rbp,%r13
mov    %r14,%rcx
mov    %r12,%r8
mov    0x60(%rsp),%r9d
push   %rbx
mov    0x10(%rsp),%rbx
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    0x4(%rsp),%ebp
mov    %ebp,%esi
mov    %r13,%rdx
mov    %r14,%rcx
mov    %r12,%r8
mov    0x58(%rsp),%r9d
push   0x28(%rsp)
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13,%rdx
mov    %r14,%rcx
mov    %r12,%r8
mov    %r12,%rbp
mov    0x80(%rsp),%r9d
mov    0x28(%rsp),%rbx
push   %rbx
push   0x10(%rsp)
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    0x4(%rsp),%r12d
mov    %r12d,%esi
mov    %r13,%rdx
mov    %r13,%r15
mov    %r14,%rcx
mov    %rbp,%r8
mov    %rbp,%r14
mov    0x78(%rsp),%r9d
push   %rbx
mov    0x10(%rsp),%rbp
push   %rbp
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    0x38(%rsp),%r13
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15,%rdx
mov    0x18(%rsp),%r12
mov    %r12,%rcx
mov    %r14,%r8
mov    0x70(%rsp),%r9d
push   %rbx
push   %rbp
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r13d,%edi
mov    0x4(%rsp),%r13d
mov    %r13d,%esi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    0x68(%rsp),%r9d
push   %rbx
push   %rbp
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    0x38(%rsp),%rdi
mov    %r13d,%esi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r14,%r8
mov    0x50(%rsp),%r9d
push   %rbx
push   %rbp
call   1030 <do_block@plt>
mov    0x50(%rsp),%rax
mov    0x58(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%eax
cmp    $0x8,%eax
jne    1620 <square_dgemm+0x4d0>
mov    0x88(%rsp),%rsi
add    $0x1,%esi
mov    (%rsp),%eax
cmp    %eax,%esi
jne    1600 <square_dgemm+0x4b0>
jmp    1570 <square_dgemm+0x420>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
xor    %edx,%edx
mov    (%rsp),%eax
mov    0x38(%rsp),%r12
mov    0x4(%rsp),%ebp
mov    0x18(%rsp),%r15
mov    0x30(%rsp),%r13
jmp    17f3 <square_dgemm+0x6a3>
xchg   %ax,%ax
mov    0xa0(%rsp),%rdx
add    $0x1,%edx
cmp    %ecx,%edx
je     1a0c <square_dgemm+0x8bc>
mov    %rdx,0xa0(%rsp)
lea    0x0(,%rdx,8),%ecx
mov    %rcx,0x48(%rsp)
xor    %edx,%edx
jmp    1827 <square_dgemm+0x6d7>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%rdx
add    $0x1,%edx
mov    0x98(%rsp),%rcx
cmp    %ecx,%edx
je     17e0 <square_dgemm+0x690>
lea    0x0(,%rdx,8),%edi
lea    0x1(,%rdx,8),%esi
mov    %esi,0x20(%rsp)
lea    0x2(,%rdx,8),%esi
mov    %esi,0x60(%rsp)
lea    0x3(,%rdx,8),%esi
mov    %esi,0x58(%rsp)
lea    0x4(,%rdx,8),%esi
mov    %esi,0x80(%rsp)
lea    0x5(,%rdx,8),%esi
mov    %esi,0x78(%rsp)
lea    0x6(,%rdx,8),%esi
mov    %esi,0x70(%rsp)
mov    %rdx,0x88(%rsp)
lea    0x7(,%rdx,8),%edx
mov    %edx,0x68(%rsp)
xor    %edx,%edx
mov    %rdx,0x50(%rsp)
mov    %edi,0x40(%rsp)
jmp    18b9 <square_dgemm+0x769>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x50(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x50(%rsp)
cmp    $0x8,%eax
mov    (%rsp),%eax
je     1810 <square_dgemm+0x6c0>
test   %eax,%eax
mov    0x10(%rsp),%rcx
jle    18a0 <square_dgemm+0x750>
mov    0x48(%rsp),%rax
mov    0x50(%rsp),%rdx
add    %edx,%eax
mov    %rax,0x28(%rsp)
mov    0x90(%rsp),%rbx
mov    (%rsp),%eax
xchg   %ax,%ax
mov    %eax,0x8(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %rcx,%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x40(%rsp),%r9d
mov    0x28(%rsp),%r14
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x20(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x60(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x58(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x80(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x78(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x70(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r12d,%edi
mov    %ebp,%esi
mov    0x10(%rsp),%rdx
mov    %r15,%rcx
mov    %r13,%r8
mov    0x68(%rsp),%r9d
push   %r14
push   %rbx
call   1030 <do_block@plt>
mov    0x18(%rsp),%eax
mov    0x20(%rsp),%rcx
add    $0x10,%rsp
add    $0x1,%ebx
add    $0xffffffff,%eax
jne    18e0 <square_dgemm+0x790>
jmp    18a0 <square_dgemm+0x750>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
lea    0x0(,%rcx,8),%edx
xor    %esi,%esi
mov    (%rsp),%eax
mov    %rdx,0x8(%rsp)
jmp    1a53 <square_dgemm+0x903>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x88(%rsp),%rsi
add    $0x1,%esi
cmp    %ecx,%esi
je     1dc1 <square_dgemm+0xc71>
mov    %rsi,0x88(%rsp)
lea    0x0(,%rsi,8),%ecx
mov    %rcx,0x60(%rsp)
xor    %esi,%esi
jmp    1a84 <square_dgemm+0x934>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rsi
add    $0x1,%esi
mov    0x98(%rsp),%rcx
cmp    %ecx,%esi
je     1a40 <square_dgemm+0x8f0>
lea    0x0(,%rsi,8),%ecx
mov    %rcx,0x20(%rsp)
lea    0x1(,%rsi,8),%ecx
mov    %rcx,0x58(%rsp)
lea    0x2(,%rsi,8),%ecx
mov    %rcx,0x80(%rsp)
lea    0x3(,%rsi,8),%ecx
mov    %rcx,0x78(%rsp)
lea    0x4(,%rsi,8),%ecx
mov    %rcx,0x70(%rsp)
lea    0x5(,%rsi,8),%ecx
mov    %rcx,0x68(%rsp)
lea    0x6(,%rsi,8),%ecx
mov    %rcx,0x50(%rsp)
mov    %rsi,0x48(%rsp)
lea    0x7(,%rsi,8),%ecx
mov    %rcx,0x40(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x28(%rsp)
jmp    1b16 <square_dgemm+0x9c6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x28(%rsp)
cmp    $0x8,%ecx
je     1a70 <square_dgemm+0x920>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
mov    0x60(%rsp),%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,1),%ebp
xor    %ebx,%ebx
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x20(%rsp),%r12
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r13,%rdx
mov    %r14,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r12
mov    %rbp,%r15
call   1030 <do_block@plt>
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1b40 <square_dgemm+0x9f0>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x58(%rsp),%r13
nopl   0x0(%rax)
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1b90 <square_dgemm+0xa40>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x80(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1bf0 <square_dgemm+0xaa0>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x78(%rsp),%r13
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1c40 <square_dgemm+0xaf0>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x70(%rsp),%r13
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1c90 <square_dgemm+0xb40>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x68(%rsp),%r13
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1ce0 <square_dgemm+0xb90>
test   %eax,%eax
jle    1b00 <square_dgemm+0x9b0>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x50(%rsp),%r13
lea    (%rdx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r14,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
push   %rbp
push   %r13
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    1d30 <square_dgemm+0xbe0>
test   %eax,%eax
mov    0x30(%rsp),%r13
jle    1b00 <square_dgemm+0x9b0>
mov    %edx,%ebx
mov    %eax,%r12d
nopl   0x0(%rax)
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    %r13,%r8
mov    %ebx,%r9d
push   %rbp
push   0x48(%rsp)
call   1030 <do_block@plt>
mov    %r15,%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
add    $0xffffffff,%r12d
jne    1d80 <square_dgemm+0xc30>
jmp    1b00 <square_dgemm+0x9b0>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
lea    0x0(,%rcx,8),%r15d
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    (%rsp),%eax
mov    %r15,0x8(%rsp)
mov    0x10(%rsp),%r13
jmp    1e23 <square_dgemm+0xcd3>
nopw   0x0(%rax,%rax,1)
mov    0x90(%rsp),%rdx
add    $0x1,%edx
mov    0x98(%rsp),%rcx
mov    %rdx,0x90(%rsp)
cmp    %ecx,%edx
je     2040 <square_dgemm+0xef0>
test   %eax,%eax
jle    1e00 <square_dgemm+0xcb0>
mov    0x90(%rsp),%rax
lea    0x0(,%rax,8),%ecx
lea    0x1(,%rax,8),%edx
mov    %edx,0x58(%rsp)
lea    0x2(,%rax,8),%edx
mov    %edx,0x80(%rsp)
lea    0x3(,%rax,8),%edx
mov    %edx,0x78(%rsp)
lea    0x4(,%rax,8),%edx
mov    %edx,0x70(%rsp)
lea    0x5(,%rax,8),%edx
mov    %edx,0x68(%rsp)
lea    0x6(,%rax,8),%edx
mov    %edx,0x50(%rsp)
lea    0x7(,%rax,8),%eax
mov    %eax,0x48(%rsp)
xor    %edx,%edx
mov    %ecx,0x60(%rsp)
nopl   0x0(%rax)
mov    %rdx,0x88(%rsp)
lea    (%rdx,%r15,1),%eax
mov    %rax,0x40(%rsp)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,0x20(%rsp)
mov    0x8(%rsp),%rax
add    %edx,%eax
mov    %rax,0x28(%rsp)
mov    0x38(%rsp),%r15
mov    %r15d,%edi
mov    0x4(%rsp),%ebp
mov    %ebp,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%r14
mov    %r14,%rcx
mov    0x30(%rsp),%rbx
mov    %rbx,%r8
mov    0x60(%rsp),%r9d
mov    0x40(%rsp),%r12
push   %r12
push   %rax
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13,%rdx
mov    %r14,%rcx
mov    %rbx,%r8
mov    0x58(%rsp),%r9d
push   %r12
mov    %r12,%r14
mov    0x30(%rsp),%r12
push   %r12
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%rcx
mov    %rbx,%r8
mov    0x80(%rsp),%r9d
push   %r14
push   %r12
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%rbx
mov    %rbx,%rcx
mov    0x30(%rsp),%r8
mov    0x78(%rsp),%r9d
push   %r14
push   %r12
mov    %r12,%r14
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13,%rdx
mov    %rbx,%r12
mov    %rbx,%rcx
mov    0x30(%rsp),%rbx
mov    %rbx,%r8
mov    0x70(%rsp),%r9d
mov    0x40(%rsp),%rbp
push   %rbp
push   %r14
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    0x4(%rsp),%r14d
mov    %r14d,%esi
mov    %r13,%rdx
mov    %r12,%rcx
mov    %rbx,%r8
mov    %rbx,%r12
mov    0x68(%rsp),%r9d
push   %rbp
mov    0x30(%rsp),%rbx
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    %r15d,%edi
mov    %r14d,%r15d
mov    %r14d,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%r14
mov    %r14,%rcx
mov    %r12,%r8
mov    0x50(%rsp),%r9d
push   %rbp
push   %rbx
call   1030 <do_block@plt>
add    $0x10,%rsp
mov    0x38(%rsp),%rdi
mov    %r15d,%esi
mov    %r13,%rdx
mov    %r14,%rcx
mov    %r12,%r8
mov    0x48(%rsp),%r9d
push   %rbp
push   %rbx
call   1030 <do_block@plt>
mov    0x30(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%edx
cmp    %edx,%eax
jne    1eb0 <square_dgemm+0xd60>
mov    0x88(%rsp),%rdx
add    $0x1,%edx
cmp    %eax,%edx
mov    0x8(%rsp),%r15
jne    1e90 <square_dgemm+0xd40>
jmp    1e00 <square_dgemm+0xcb0>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
xor    %eax,%eax
mov    %rax,0x48(%rsp)
mov    (%rsp),%eax
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rbx
jmp    208d <square_dgemm+0xf3d>
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rsi
add    $0x1,%esi
mov    0x98(%rsp),%rcx
mov    %rsi,0x48(%rsp)
cmp    %ecx,%esi
je     237e <square_dgemm+0x122e>
test   %eax,%eax
jle    2070 <square_dgemm+0xf20>
mov    0x48(%rsp),%rax
lea    0x0(,%rax,8),%r14d
lea    0x1(,%rax,8),%ecx
mov    %rcx,0x50(%rsp)
lea    0x2(,%rax,8),%ecx
mov    %rcx,0x40(%rsp)
lea    0x3(,%rax,8),%ecx
mov    %rcx,0x20(%rsp)
lea    0x4(,%rax,8),%ecx
mov    %rcx,0x60(%rsp)
lea    0x5(,%rax,8),%ecx
mov    %rcx,0x58(%rsp)
lea    0x6(,%rax,8),%ecx
mov    %rcx,0x80(%rsp)
lea    0x7(,%rax,8),%eax
mov    %rax,0x78(%rsp)
xor    %ecx,%ecx
mov    %r14,0x68(%rsp)
nopl   0x0(%rax)
mov    %rcx,0x70(%rsp)
lea    (%rcx,%r15,1),%eax
mov    %rax,0x28(%rsp)
xor    %ebp,%ebp
mov    0x38(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%rbp,1),%r9d
mov    %r13d,%edi
mov    0x4(%rsp),%esi
mov    %rbx,%rcx
mov    %rdx,%r12
mov    0x30(%rsp),%r8
push   0x28(%rsp)
push   %r14
call   1030 <do_block@plt>
mov    %r12,%rdx
add    $0x10,%rsp
add    $0x1,%ebp
cmp    %ebp,(%rsp)
jne    2120 <square_dgemm+0xfd0>
mov    %r15,%r12
xor    %r14d,%r14d
mov    0x50(%rsp),%rbp
mov    0x28(%rsp),%rbx
mov    0x4(%rsp),%r15d
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r12,%r14,1),%r9d
mov    %r13d,%edi
mov    %r15d,%esi
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x30(%rsp),%r8
push   %rbx
push   %rbp
call   1030 <do_block@plt>
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    2170 <square_dgemm+0x1020>
mov    0x30(%rsp),%r8
xor    %r14d,%r14d
mov    0x10(%rsp),%rdx
mov    %rbx,%rbp
mov    0x18(%rsp),%rbx
mov    %r12,%rdi
mov    %r13,%rax
mov    %r15d,%esi
nopl   0x0(%rax)
lea    (%rdi,%r14,1),%r9d
mov    %rax,%r12
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r8,%r15
push   %rbp
push   0x48(%rsp)
mov    %rbp,%r13
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r12,%rax
mov    %r15,%r8
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    21c0 <square_dgemm+0x1070>
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%r14,1),%r9d
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r15,%r8
push   %rbp
push   0x28(%rsp)
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r13,%rbp
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    2210 <square_dgemm+0x10c0>
xor    %r14d,%r14d
xchg   %ax,%ax
lea    (%rdi,%r14,1),%r9d
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r15,%r8
push   %rbp
push   0x68(%rsp)
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r13,%rbp
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    2250 <square_dgemm+0x1100>
xor    %r14d,%r14d
xchg   %ax,%ax
lea    (%rdi,%r14,1),%r9d
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r15,%r8
push   %rbp
push   0x60(%rsp)
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r13,%rbp
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    2290 <square_dgemm+0x1140>
xor    %r14d,%r14d
xchg   %ax,%ax
lea    (%rdi,%r14,1),%r9d
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r15,%r8
push   %rbp
push   0x88(%rsp)
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r13,%rbp
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,(%rsp)
jne    22d0 <square_dgemm+0x1180>
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%r14,1),%r9d
mov    %r12d,%edi
mov    %rbx,%rcx
mov    %r15,%r8
push   %rbp
push   0x80(%rsp)
call   1030 <do_block@plt>
mov    0x14(%rsp),%esi
mov    %r13,%rbp
mov    0x18(%rsp),%rdi
mov    0x28(%rsp),%rbx
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%r14d
cmp    %r14d,%eax
jne    2320 <square_dgemm+0x11d0>
mov    0x70(%rsp),%rcx
add    $0x1,%ecx
cmp    %eax,%ecx
mov    %rdi,%r15
mov    0x68(%rsp),%r14
jne    2100 <square_dgemm+0xfb0>
jmp    2070 <square_dgemm+0xf20>
xor    %eax,%eax
mov    %rax,0x20(%rsp)
cmpl   $0x2,0xb0(%rsp)
02
jl     2493 <square_dgemm+0x1343>
xor    %edx,%edx
mov    (%rsp),%eax
mov    0x4(%rsp),%r12d
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r14
jmp    23c8 <square_dgemm+0x1278>
xchg   %ax,%ax
mov    0x58(%rsp),%rdx
add    $0x1,%edx
mov    0x98(%rsp),%rcx
cmp    %ecx,%edx
je     248b <square_dgemm+0x133b>
mov    %rdx,0x58(%rsp)
lea    0x0(,%rdx,8),%ecx
mov    %rcx,0x60(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x20(%rsp)
jmp    2402 <square_dgemm+0x12b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x20(%rsp)
cmp    $0x8,%ecx
je     23b0 <square_dgemm+0x1260>
test   %eax,%eax
jle    23f0 <square_dgemm+0x12a0>
mov    0x60(%rsp),%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,1),%ebx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,0x40(%rsp)
lea    (%rcx,%r15,1),%eax
mov    %rax,0x28(%rsp)
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
lea    (%rax,%r15,1),%r9d
mov    0x38(%rsp),%rdi
mov    %r12d,%esi
mov    %r13,%rdx
mov    %rbp,%rcx
mov    %r14,%r8
push   %rbx
push   0x30(%rsp)
call   1030 <do_block@plt>
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%r15d
cmp    %r15d,%eax
jne    2440 <square_dgemm+0x12f0>
mov    0x40(%rsp),%rcx
add    $0x1,%ecx
cmp    %eax,%ecx
mov    0x8(%rsp),%r15
jne    2420 <square_dgemm+0x12d0>
jmp    23f0 <square_dgemm+0x12a0>
mov    %r15d,%r14d
mov    %r14,0x20(%rsp)
cmpl   $0x0,(%rsp)
jle    252d <square_dgemm+0x13dd>
shl    $0x3,%ecx
xor    %edx,%edx
mov    0x10(%rsp),%r12
mov    0x18(%rsp),%r13
mov    0x30(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rax
mov    %rdx,0x40(%rsp)
lea    (%rdx,%rax,1),%ebp
xor    %edx,%edx
nop
mov    %rdx,0x28(%rsp)
lea    (%rdx,%rcx,1),%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
nop
lea    (%rcx,%rbx,1),%r9d
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    %r12,%rdx
mov    %rcx,%r14
mov    %r13,%rcx
mov    %r15,%r8
push   %rbp
push   0x10(%rsp)
call   1030 <do_block@plt>
mov    %r14,%rcx
mov    0x10(%rsp),%eax
add    $0x10,%rsp
add    $0x1,%ebx
cmp    %ebx,%eax
jne    24e0 <square_dgemm+0x1390>
mov    0x28(%rsp),%rdx
add    $0x1,%edx
cmp    %eax,%edx
jne    24d0 <square_dgemm+0x1380>
mov    0x40(%rsp),%rdx
add    $0x1,%edx
cmp    %eax,%edx
jne    24c0 <square_dgemm+0x1370>
mov    0x38(%rsp),%rdi
mov    0x4(%rsp),%esi
mov    0xb8(%rsp),%rdx
mov    0x30(%rsp),%rcx
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <block_to_row@plt>

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

LLVM IR (-O2):
define void @square_dgemm(i32 %0, double* %1, double* %2, double* %3) {
%5 = and i32 %0, 15
%6 = icmp eq i32 %5, 0
%7 = sdiv i32 %0, 16
%8 = add nsw i32 %7, 1
%9 = shl nsw i32 %8, 4
%10 = select i1 %6, i32 %7, i32 %8
%11 = select i1 %6, i32 %0, i32 %9
%12 = srem i32 %11, 128
%13 = icmp eq i32 %12, 0
%14 = sdiv i32 %11, 128
br i1 %13, label %20, label %15
15: ; preds = %4
%16 = add nsw i32 %14, 1
%17 = trunc i32 %12 to i8
%18 = sdiv i8 %17, 16
%19 = sext i8 %18 to i32
br label %20
20: ; preds = %4, %15
%21 = phi i32 [ %19, %15 ], [ 8, %4 ]
%22 = phi i32 [ %16, %15 ], [ %14, %4 ]
%23 = shl i32 %11, 3
%24 = mul i32 %23, %11
%25 = tail call i64 @_mm_malloc(i32 %24, i32 64)
%26 = inttoptr i64 %25 to double*
%27 = tail call i64 @_mm_malloc(i32 %24, i32 64)
%28 = inttoptr i64 %27 to double*
%29 = tail call i64 @_mm_malloc(i32 %24, i32 64)
%30 = inttoptr i64 %29 to double*
%31 = tail call i32 @row_to_block(i32 %0, i32 %10, double* %1, double* %26)
%32 = tail call i32 @row_to_block_transpose(i32 %0, i32 %10, double* %2, double* %28)
%33 = tail call i32 @row_to_block(i32 %0, i32 %10, double* %3, double* %30)
%34 = add nsw i32 %22, -1
%35 = icmp sgt i32 %22, 1
br i1 %35, label %36, label %367
36: ; preds = %20, %81
%37 = phi i32 [ %82, %81 ], [ 0, %20 ]
%38 = shl nsw i32 %37, 3
br label %43
39: ; preds = %81
br i1 %35, label %40, label %367
40: ; preds = %39
%41 = icmp sgt i32 %21, 0
%42 = shl nsw i32 %34, 3
br label %84
43: ; preds = %78, %36
%44 = phi i32 [ 0, %36 ], [ %79, %78 ]
%45 = shl nsw i32 %44, 3
br label %46
46: ; preds = %43, %75
%47 = phi i32 [ 0, %43 ], [ %76, %75 ]
%48 = shl nsw i32 %47, 3
%49 = or i32 %48, 1
%50 = or i32 %48, 2
%51 = or i32 %48, 3
%52 = or i32 %48, 4
%53 = or i32 %48, 5
%54 = or i32 %48, 6
%55 = or i32 %48, 7
br label %56
56: ; preds = %46, %72
%57 = phi i32 [ 0, %46 ], [ %73, %72 ]
%58 = add nuw nsw i32 %57, %38
br label %59
59: ; preds = %56, %59
%60 = phi i32 [ 0, %56 ], [ %70, %59 ]
%61 = add nuw nsw i32 %60, %45
%62 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %48, i32 %61, i32 %58)
%63 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %49, i32 %61, i32 %58)
%64 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %50, i32 %61, i32 %58)
%65 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %51, i32 %61, i32 %58)
%66 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %52, i32 %61, i32 %58)
%67 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %53, i32 %61, i32 %58)
%68 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %54, i32 %61, i32 %58)
%69 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %55, i32 %61, i32 %58)
%70 = add nuw nsw i32 %60, 1
%71 = icmp eq i32 %70, 8
br i1 %71, label %72, label %59
72: ; preds = %59
%73 = add nuw nsw i32 %57, 1
%74 = icmp eq i32 %73, 8
br i1 %74, label %75, label %56
75: ; preds = %72
%76 = add nuw i32 %47, 1
%77 = icmp eq i32 %76, %34
br i1 %77, label %78, label %46
78: ; preds = %75
%79 = add nuw nsw i32 %44, 1
%80 = icmp eq i32 %79, %34
br i1 %80, label %81, label %43
81: ; preds = %78
%82 = add nuw nsw i32 %37, 1
%83 = icmp eq i32 %82, %34
br i1 %83, label %39, label %36
84: ; preds = %124, %40
%85 = phi i32 [ 0, %40 ], [ %125, %124 ]
%86 = shl nsw i32 %85, 3
br label %91
87: ; preds = %124
br i1 %35, label %88, label %367
88: ; preds = %87
%89 = icmp sgt i32 %21, 0
%90 = shl nsw i32 %34, 3
br label %127
91: ; preds = %84, %121
%92 = phi i32 [ 0, %84 ], [ %122, %121 ]
br i1 %41, label %93, label %121
93: ; preds = %91
%94 = shl nsw i32 %92, 3
%95 = or i32 %94, 1
%96 = or i32 %94, 2
%97 = or i32 %94, 3
%98 = or i32 %94, 4
%99 = or i32 %94, 5
%100 = or i32 %94, 6
%101 = or i32 %94, 7
br label %102
102: ; preds = %93, %118
%103 = phi i32 [ 0, %93 ], [ %119, %118 ]
%104 = add nuw nsw i32 %103, %42
br label %105
105: ; preds = %102, %105
%106 = phi i32 [ 0, %102 ], [ %116, %105 ]
%107 = add nuw nsw i32 %106, %86
%108 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %94, i32 %107, i32 %104)
%109 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %95, i32 %107, i32 %104)
%110 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %96, i32 %107, i32 %104)
%111 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %97, i32 %107, i32 %104)
%112 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %98, i32 %107, i32 %104)
%113 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %99, i32 %107, i32 %104)
%114 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %100, i32 %107, i32 %104)
%115 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %101, i32 %107, i32 %104)
%116 = add nuw nsw i32 %106, 1
%117 = icmp eq i32 %116, 8
br i1 %117, label %118, label %105
118: ; preds = %105
%119 = add nuw nsw i32 %103, 1
%120 = icmp eq i32 %119, %21
br i1 %120, label %121, label %102
121: ; preds = %118, %91
%122 = add nuw i32 %92, 1
%123 = icmp eq i32 %122, %34
br i1 %123, label %124, label %91
124: ; preds = %121
%125 = add nuw nsw i32 %85, 1
%126 = icmp eq i32 %125, %34
br i1 %126, label %87, label %84
127: ; preds = %166, %88
%128 = phi i32 [ 0, %88 ], [ %167, %166 ]
%129 = shl nsw i32 %128, 3
br label %134
130: ; preds = %166
br i1 %35, label %131, label %367
131: ; preds = %130
%132 = icmp sgt i32 %21, 0
%133 = shl nsw i32 %34, 3
br label %169
134: ; preds = %127, %163
%135 = phi i32 [ 0, %127 ], [ %164, %163 ]
%136 = shl nsw i32 %135, 3
%137 = or i32 %136, 1
%138 = or i32 %136, 2
%139 = or i32 %136, 3
%140 = or i32 %136, 4
%141 = or i32 %136, 5
%142 = or i32 %136, 6
%143 = or i32 %136, 7
br label %144
144: ; preds = %134, %160
%145 = phi i32 [ 0, %134 ], [ %161, %160 ]
%146 = add nuw nsw i32 %145, %129
br i1 %89, label %147, label %160
147: ; preds = %144, %147
%148 = phi i32 [ %158, %147 ], [ 0, %144 ]
%149 = add nuw nsw i32 %148, %90
%150 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %136, i32 %149, i32 %146)
%151 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %137, i32 %149, i32 %146)
%152 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %138, i32 %149, i32 %146)
%153 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %139, i32 %149, i32 %146)
%154 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %140, i32 %149, i32 %146)
%155 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %141, i32 %149, i32 %146)
%156 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %142, i32 %149, i32 %146)
%157 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %143, i32 %149, i32 %146)
%158 = add nuw nsw i32 %148, 1
%159 = icmp eq i32 %158, %21
br i1 %159, label %160, label %147
160: ; preds = %147, %144
%161 = add nuw nsw i32 %145, 1
%162 = icmp eq i32 %161, 8
br i1 %162, label %163, label %144
163: ; preds = %160
%164 = add nuw i32 %135, 1
%165 = icmp eq i32 %164, %34
br i1 %165, label %166, label %134
166: ; preds = %163
%167 = add nuw nsw i32 %128, 1
%168 = icmp eq i32 %167, %34
br i1 %168, label %130, label %127
169: ; preds = %250, %131
%170 = phi i32 [ 0, %131 ], [ %251, %250 ]
%171 = shl nsw i32 %170, 3
br label %176
172: ; preds = %250
br i1 %35, label %173, label %367
173: ; preds = %172
%174 = icmp sgt i32 %21, 0
%175 = shl nsw i32 %34, 3
br label %253
176: ; preds = %169, %247
%177 = phi i32 [ 0, %169 ], [ %248, %247 ]
%178 = shl nsw i32 %177, 3
%179 = or i32 %178, 1
%180 = or i32 %178, 2
%181 = or i32 %178, 3
%182 = or i32 %178, 4
%183 = or i32 %178, 5
%184 = or i32 %178, 6
%185 = or i32 %178, 7
br label %186
186: ; preds = %176, %244
%187 = phi i32 [ 0, %176 ], [ %245, %244 ]
%188 = add nuw nsw i32 %187, %171
br i1 %132, label %189, label %244
189: ; preds = %186, %189
%190 = phi i32 [ %193, %189 ], [ 0, %186 ]
%191 = add nuw nsw i32 %190, %133
%192 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %191, i32 %178, i32 %188)
%193 = add nuw nsw i32 %190, 1
%194 = icmp eq i32 %193, %21
br i1 %194, label %195, label %189
195: ; preds = %189
br i1 %132, label %196, label %244
196: ; preds = %195, %196
%197 = phi i32 [ %200, %196 ], [ 0, %195 ]
%198 = add nuw nsw i32 %197, %133
%199 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %198, i32 %179, i32 %188)
%200 = add nuw nsw i32 %197, 1
%201 = icmp eq i32 %200, %21
br i1 %201, label %202, label %196
202: ; preds = %196
br i1 %132, label %203, label %244
203: ; preds = %202, %203
%204 = phi i32 [ %207, %203 ], [ 0, %202 ]
%205 = add nuw nsw i32 %204, %133
%206 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %205, i32 %180, i32 %188)
%207 = add nuw nsw i32 %204, 1
%208 = icmp eq i32 %207, %21
br i1 %208, label %209, label %203
209: ; preds = %203
br i1 %132, label %210, label %244
210: ; preds = %209, %210
%211 = phi i32 [ %214, %210 ], [ 0, %209 ]
%212 = add nuw nsw i32 %211, %133
%213 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %212, i32 %181, i32 %188)
%214 = add nuw nsw i32 %211, 1
%215 = icmp eq i32 %214, %21
br i1 %215, label %216, label %210
216: ; preds = %210
br i1 %132, label %217, label %244
217: ; preds = %216, %217
%218 = phi i32 [ %221, %217 ], [ 0, %216 ]
%219 = add nuw nsw i32 %218, %133
%220 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %219, i32 %182, i32 %188)
%221 = add nuw nsw i32 %218, 1
%222 = icmp eq i32 %221, %21
br i1 %222, label %223, label %217
223: ; preds = %217
br i1 %132, label %224, label %244
224: ; preds = %223, %224
%225 = phi i32 [ %228, %224 ], [ 0, %223 ]
%226 = add nuw nsw i32 %225, %133
%227 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %226, i32 %183, i32 %188)
%228 = add nuw nsw i32 %225, 1
%229 = icmp eq i32 %228, %21
br i1 %229, label %230, label %224
230: ; preds = %224
br i1 %132, label %231, label %244
231: ; preds = %230, %231
%232 = phi i32 [ %235, %231 ], [ 0, %230 ]
%233 = add nuw nsw i32 %232, %133
%234 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %233, i32 %184, i32 %188)
%235 = add nuw nsw i32 %232, 1
%236 = icmp eq i32 %235, %21
br i1 %236, label %237, label %231
237: ; preds = %231
br i1 %132, label %238, label %244
238: ; preds = %237, %238
%239 = phi i32 [ %242, %238 ], [ 0, %237 ]
%240 = add nuw nsw i32 %239, %133
%241 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %240, i32 %185, i32 %188)
%242 = add nuw nsw i32 %239, 1
%243 = icmp eq i32 %242, %21
br i1 %243, label %244, label %238
244: ; preds = %238, %186, %195, %202, %209, %216, %223, %230, %237
%245 = add nuw nsw i32 %187, 1
%246 = icmp eq i32 %245, 8
br i1 %246, label %247, label %186
247: ; preds = %244
%248 = add nuw i32 %177, 1
%249 = icmp eq i32 %248, %34
br i1 %249, label %250, label %176
250: ; preds = %247
%251 = add nuw nsw i32 %170, 1
%252 = icmp eq i32 %251, %34
br i1 %252, label %172, label %169
253: ; preds = %173, %287
%254 = phi i32 [ 0, %173 ], [ %288, %287 ]
br i1 %174, label %255, label %287
255: ; preds = %253
%256 = shl nsw i32 %254, 3
%257 = or i32 %256, 1
%258 = or i32 %256, 2
%259 = or i32 %256, 3
%260 = or i32 %256, 4
%261 = or i32 %256, 5
%262 = or i32 %256, 6
%263 = or i32 %256, 7
br label %268
264: ; preds = %287
br i1 %35, label %265, label %367
265: ; preds = %264
%266 = icmp sgt i32 %21, 0
%267 = shl nsw i32 %34, 3
br label %290
268: ; preds = %284, %255
%269 = phi i32 [ 0, %255 ], [ %285, %284 ]
%270 = add nuw nsw i32 %269, %175
br label %271
271: ; preds = %268, %271
%272 = phi i32 [ %282, %271 ], [ 0, %268 ]
%273 = add nuw nsw i32 %272, %175
%274 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %256, i32 %273, i32 %270)
%275 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %257, i32 %273, i32 %270)
%276 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %258, i32 %273, i32 %270)
%277 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %259, i32 %273, i32 %270)
%278 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %260, i32 %273, i32 %270)
%279 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %261, i32 %273, i32 %270)
%280 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %262, i32 %273, i32 %270)
%281 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %263, i32 %273, i32 %270)
%282 = add nuw nsw i32 %272, 1
%283 = icmp eq i32 %282, %21
br i1 %283, label %284, label %271
284: ; preds = %271
%285 = add nuw nsw i32 %269, 1
%286 = icmp eq i32 %285, %21
br i1 %286, label %287, label %268
287: ; preds = %284, %253
%288 = add nuw i32 %254, 1
%289 = icmp eq i32 %288, %34
br i1 %289, label %264, label %253
290: ; preds = %265, %359
%291 = phi i32 [ 0, %265 ], [ %360, %359 ]
br i1 %266, label %292, label %359
292: ; preds = %290
%293 = shl nsw i32 %291, 3
%294 = or i32 %293, 1
%295 = or i32 %293, 2
%296 = or i32 %293, 3
%297 = or i32 %293, 4
%298 = or i32 %293, 5
%299 = or i32 %293, 6
%300 = or i32 %293, 7
br label %305
301: ; preds = %359
br i1 %35, label %302, label %367
302: ; preds = %301
%303 = icmp sgt i32 %21, 0
%304 = shl nsw i32 %34, 3
br label %362
305: ; preds = %356, %292
%306 = phi i32 [ 0, %292 ], [ %357, %356 ]
%307 = add nuw nsw i32 %306, %267
br label %308
308: ; preds = %305, %308
%309 = phi i32 [ %312, %308 ], [ 0, %305 ]
%310 = add nuw nsw i32 %309, %267
%311 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %310, i32 %293, i32 %307)
%312 = add nuw nsw i32 %309, 1
%313 = icmp eq i32 %312, %21
br i1 %313, label %314, label %308
314: ; preds = %308, %314
%315 = phi i32 [ %318, %314 ], [ 0, %308 ]
%316 = add nuw nsw i32 %315, %267
%317 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %316, i32 %294, i32 %307)
%318 = add nuw nsw i32 %315, 1
%319 = icmp eq i32 %318, %21
br i1 %319, label %320, label %314
320: ; preds = %314, %320
%321 = phi i32 [ %324, %320 ], [ 0, %314 ]
%322 = add nuw nsw i32 %321, %267
%323 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %322, i32 %295, i32 %307)
%324 = add nuw nsw i32 %321, 1
%325 = icmp eq i32 %324, %21
br i1 %325, label %326, label %320
326: ; preds = %320, %326
%327 = phi i32 [ %330, %326 ], [ 0, %320 ]
%328 = add nuw nsw i32 %327, %267
%329 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %328, i32 %296, i32 %307)
%330 = add nuw nsw i32 %327, 1
%331 = icmp eq i32 %330, %21
br i1 %331, label %332, label %326
332: ; preds = %326, %332
%333 = phi i32 [ %336, %332 ], [ 0, %326 ]
%334 = add nuw nsw i32 %333, %267
%335 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %334, i32 %297, i32 %307)
%336 = add nuw nsw i32 %333, 1
%337 = icmp eq i32 %336, %21
br i1 %337, label %338, label %332
338: ; preds = %332, %338
%339 = phi i32 [ %342, %338 ], [ 0, %332 ]
%340 = add nuw nsw i32 %339, %267
%341 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %340, i32 %298, i32 %307)
%342 = add nuw nsw i32 %339, 1
%343 = icmp eq i32 %342, %21
br i1 %343, label %344, label %338
344: ; preds = %338, %344
%345 = phi i32 [ %348, %344 ], [ 0, %338 ]
%346 = add nuw nsw i32 %345, %267
%347 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %346, i32 %299, i32 %307)
%348 = add nuw nsw i32 %345, 1
%349 = icmp eq i32 %348, %21
br i1 %349, label %350, label %344
350: ; preds = %344, %350
%351 = phi i32 [ %354, %350 ], [ 0, %344 ]
%352 = add nuw nsw i32 %351, %267
%353 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %352, i32 %300, i32 %307)
%354 = add nuw nsw i32 %351, 1
%355 = icmp eq i32 %354, %21
br i1 %355, label %356, label %350
356: ; preds = %350
%357 = add nuw nsw i32 %306, 1
%358 = icmp eq i32 %357, %21
br i1 %358, label %359, label %305
359: ; preds = %356, %290
%360 = add nuw i32 %291, 1
%361 = icmp eq i32 %360, %34
br i1 %361, label %301, label %290
362: ; preds = %302, %390
%363 = phi i32 [ 0, %302 ], [ %391, %390 ]
%364 = shl nsw i32 %363, 3
br label %372
365: ; preds = %390
%366 = shl nsw i32 %34, 3
br label %367
367: ; preds = %20, %39, %87, %130, %172, %264, %365, %301
%368 = phi i32 [ 0, %301 ], [ %366, %365 ], [ 0, %264 ], [ 0, %172 ], [ 0, %130 ], [ 0, %87 ], [ 0, %39 ], [ 0, %20 ]
%369 = icmp sgt i32 %21, 0
br i1 %369, label %370, label %411
370: ; preds = %367
%371 = shl nsw i32 %34, 3
br label %393
372: ; preds = %362, %387
%373 = phi i32 [ 0, %362 ], [ %388, %387 ]
%374 = add nuw nsw i32 %373, %364
br i1 %303, label %375, label %387
375: ; preds = %372, %384
%376 = phi i32 [ %385, %384 ], [ 0, %372 ]
%377 = add nuw nsw i32 %376, %304
br label %378
378: ; preds = %375, %378
%379 = phi i32 [ %382, %378 ], [ 0, %375 ]
%380 = add nuw nsw i32 %379, %304
%381 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %380, i32 %377, i32 %374)
%382 = add nuw nsw i32 %379, 1
%383 = icmp eq i32 %382, %21
br i1 %383, label %384, label %378
384: ; preds = %378
%385 = add nuw nsw i32 %376, 1
%386 = icmp eq i32 %385, %21
br i1 %386, label %387, label %375
387: ; preds = %384, %372
%388 = add nuw nsw i32 %373, 1
%389 = icmp eq i32 %388, 8
br i1 %389, label %390, label %372
390: ; preds = %387
%391 = add nuw nsw i32 %363, 1
%392 = icmp eq i32 %391, %34
br i1 %392, label %365, label %362
393: ; preds = %408, %370
%394 = phi i32 [ 0, %370 ], [ %409, %408 ]
%395 = add nuw nsw i32 %394, %368
br label %396
396: ; preds = %405, %393
%397 = phi i32 [ %406, %405 ], [ 0, %393 ]
%398 = add nuw nsw i32 %397, %371
br label %399
399: ; preds = %396, %399
%400 = phi i32 [ %403, %399 ], [ 0, %396 ]
%401 = add nuw nsw i32 %400, %371
%402 = tail call i32 @do_block(i32 %0, i32 %10, double* %26, double* %28, double* %30, i32 %401, i32 %398, i32 %395)
%403 = add nuw nsw i32 %400, 1
%404 = icmp eq i32 %403, %21
br i1 %404, label %405, label %399
405: ; preds = %399
%406 = add nuw nsw i32 %397, 1
%407 = icmp eq i32 %406, %21
br i1 %407, label %408, label %396
408: ; preds = %405
%409 = add nuw nsw i32 %394, 1
%410 = icmp eq i32 %409, %21
br i1 %410, label %411, label %393
411: ; preds = %408, %367
%412 = tail call i32 @block_to_row(i32 %0, i32 %10, double* %3, double* %30)
ret void
}