void dgemm(const int M, const int N, const int K, const double alpha,
           const double *A, const int lda, const double *B, const int ldb,
           const double beta, double *C, const int ldc) {
  int ib, jb, kb;
  int i, j, k;
  double Ab[240 * 240];
  double Bb[240 * 3000];
  double Cb[240 * 3000];
  double copytime = 0.;
  double computetime = 0.;
  for (kb = 0; kb < K; kb += 240) {
    int Kb = (((240) < (K - kb)) ? (240) : (K - kb));
    for (ib = 0; ib < M; ib += 240) {
      int Mb = (((240) < (M - ib)) ? (240) : (M - ib));
      for (k = 0; k < Kb; ++k)
        for (i = 0; i < Mb; i = i + 1) {
          Ab[(i + 0) * 240 + k] = A[(k + kb) * lda + i + ib];
        }
      for (jb = 0; jb < N; jb += 3000) {
        int Nb = (((3000) < (N - jb)) ? (3000) : (N - jb));
        for (j = 0; j < Nb; j = j + 1)
          for (k = 0; k < Kb; k = k + 1) {
            Bb[j * 240 + k] = B[(j + jb) * ldb + k + kb];
          }
        for (i = 0; i < Mb - Mb % 4; i = i + 4) {
          for (j = 0; j < Nb - Nb % 2; j = j + 2) {
            double c00 = 0.;
            double c01 = 0.;
            double c02 = 0.;
            double c03 = 0.;
            double c10 = 0.;
            double c11 = 0.;
            double c12 = 0.;
            double c13 = 0.;
            double *pA = &Ab[(i + 0) * 240];
            double *pB = &Bb[(j + 0) * 240];
            for (k = 0; k < Kb; k = k + 1) {
              double b00 = Bb[(j + 0) * 240 + k];
              double b10 = Bb[(j + 1) * 240 + k];
              double a00 = Ab[(i + 0) * 240 + k];
              double a01 = Ab[(i + 0) * 240 + k];
              double a02 = Ab[(i + 0) * 240 + k];
              double a03 = Ab[(i + 0) * 240 + k];
              double a10 = Ab[(i + 0) * 240 + k];
              double a11 = Ab[(i + 0) * 240 + k];
              double a12 = Ab[(i + 0) * 240 + k];
              double a13 = Ab[(i + 0) * 240 + k];
              c00 += Ab[(i + 0) * 240 + k] * b00;
              c01 += Ab[(i + 1) * 240 + k] * b00;
              c02 += Ab[(i + 2) * 240 + k] * b00;
              c03 += Ab[(i + 3) * 240 + k] * b00;
              c10 += Ab[(i + 0) * 240 + k] * b10;
              c11 += Ab[(i + 1) * 240 + k] * b10;
              c12 += Ab[(i + 2) * 240 + k] * b10;
              c13 += Ab[(i + 3) * 240 + k] * b10;
            }
            C[(j + jb + 0) * ldc + i + ib + 0] += c00;
            C[(j + jb + 0) * ldc + i + ib + 1] += c01;
            C[(j + jb + 0) * ldc + i + ib + 2] += c02;
            C[(j + jb + 0) * ldc + i + ib + 3] += c03;
            C[(j + jb + 1) * ldc + i + ib + 0] += c10;
            C[(j + jb + 1) * ldc + i + ib + 1] += c11;
            C[(j + jb + 1) * ldc + i + ib + 2] += c12;
            C[(j + jb + 1) * ldc + i + ib + 3] += c13;
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<dgemm>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb6d0b0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d058(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d060(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    195d <dgemm+0x85d>
mov    -0xc(%rbp),%ecx
sub    -0x44(%rbp),%ecx
mov    $0xf0,%eax
cmp    %ecx,%eax
jge    1180 <dgemm+0x80>
mov    $0xf0,%eax
mov    %eax,-0xb6d114(%rbp)
jmp    118c <dgemm+0x8c>
mov    -0xc(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xb6d114(%rbp)
mov    -0xb6d114(%rbp),%eax
mov    %eax,-0xb6d064(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1948 <dgemm+0x848>
mov    -0x4(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
mov    $0xf0,%eax
cmp    %ecx,%eax
jge    11ce <dgemm+0xce>
mov    $0xf0,%eax
mov    %eax,-0xb6d118(%rbp)
jmp    11da <dgemm+0xda>
mov    -0x4(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0xb6d118(%rbp)
mov    -0xb6d118(%rbp),%eax
mov    %eax,-0xb6d068(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xb6d064(%rbp),%eax
jge    1269 <dgemm+0x169>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xb6d068(%rbp),%eax
jge    1256 <dgemm+0x156>
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x44(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  %xmm0,-0x70850(%rbp,%rax,8)
f8 ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1203 <dgemm+0x103>
jmp    125b <dgemm+0x15b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11ed <dgemm+0xed>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1933 <dgemm+0x833>
mov    -0x8(%rbp),%ecx
sub    -0x40(%rbp),%ecx
mov    $0xbb8,%eax
cmp    %ecx,%eax
jge    129f <dgemm+0x19f>
mov    $0xbb8,%eax
mov    %eax,-0xb6d11c(%rbp)
jmp    12ab <dgemm+0x1ab>
mov    -0x8(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xb6d11c(%rbp)
mov    -0xb6d11c(%rbp),%eax
mov    %eax,-0xb6d06c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xb6d06c(%rbp),%eax
jge    1335 <dgemm+0x235>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xb6d064(%rbp),%eax
jge    1322 <dgemm+0x222>
mov    -0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
imul   $0xf0,-0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
cltq
movsd  %xmm0,-0x5eec50(%rbp,%rax,8)
a1 ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12d4 <dgemm+0x1d4>
jmp    1327 <dgemm+0x227>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12be <dgemm+0x1be>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0xb6d120(%rbp)
mov    -0xb6d068(%rbp),%ecx
mov    -0xb6d068(%rbp),%eax
mov    $0x4,%esi
cltd
idiv   %esi
mov    -0xb6d120(%rbp),%eax
sub    %edx,%ecx
cmp    %ecx,%eax
jge    191e <dgemm+0x81e>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0xb6d124(%rbp)
mov    -0xb6d06c(%rbp),%ecx
mov    -0xb6d06c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0xb6d124(%rbp),%eax
sub    %edx,%ecx
cmp    %ecx,%eax
jge    190b <dgemm+0x80b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d078(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d080(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d088(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d090(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d098(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d0a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d0a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb6d0b0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
movslq %eax,%rcx
lea    -0x70850(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb6d0b8(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
movslq %eax,%rcx
lea    -0x5eec50(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb6d0c0(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0xb6d064(%rbp),%eax
jge    1785 <dgemm+0x685>
mov    -0x4c(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x5eec50(%rbp,%rax,8),%xmm0
a1 ff
movsd  %xmm0,-0xb6d0c8(%rbp)
ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x5eec50(%rbp,%rax,8),%xmm0
a1 ff
movsd  %xmm0,-0xb6d0d0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d0d8(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d0e0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d0e8(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d0f0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d0f8(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d100(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d108(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  %xmm0,-0xb6d110(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0c8(%rbp),%xmm2
ff
movsd  -0xb6d078(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d078(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0c8(%rbp),%xmm2
ff
movsd  -0xb6d080(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d080(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x2,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0c8(%rbp),%xmm2
ff
movsd  -0xb6d088(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d088(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x3,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0c8(%rbp),%xmm2
ff
movsd  -0xb6d090(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d090(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x0,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0d0(%rbp),%xmm2
ff
movsd  -0xb6d098(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d098(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0d0(%rbp),%xmm2
ff
movsd  -0xb6d0a0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d0a0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x2,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0d0(%rbp),%xmm2
ff
movsd  -0xb6d0a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d0a8(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x3,%eax
imul   $0xf0,%eax,%eax
add    -0x50(%rbp),%eax
cltq
movsd  -0x70850(%rbp,%rax,8),%xmm0
f8 ff
movsd  -0xb6d0d0(%rbp),%xmm2
ff
movsd  -0xb6d0b0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb6d0b0(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1444 <dgemm+0x344>
movsd  -0xb6d078(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d080(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d088(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d090(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d098(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d0a0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d0a8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb6d0b0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
imul   0x20(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    1370 <dgemm+0x270>
jmp    1910 <dgemm+0x810>
mov    -0x48(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x48(%rbp)
jmp    133c <dgemm+0x23c>
jmp    1923 <dgemm+0x823>
mov    -0x40(%rbp),%eax
add    $0xbb8,%eax
mov    %eax,-0x40(%rbp)
jmp    1270 <dgemm+0x170>
jmp    1938 <dgemm+0x838>
mov    -0x3c(%rbp),%eax
add    $0xf0,%eax
mov    %eax,-0x3c(%rbp)
jmp    119f <dgemm+0x9f>
jmp    194d <dgemm+0x84d>
mov    -0x44(%rbp),%eax
add    $0xf0,%eax
mov    %eax,-0x44(%rbp)
jmp    1151 <dgemm+0x51>
add    $0xb6d0b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dgemm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x5eec78,%rsp
mov    %r9,0x38(%rsp)
mov    %r8d,-0x64(%rsp)
mov    %esi,-0x5c(%rsp)
mov    %edi,-0x7c(%rsp)
test   %edx,%edx
jle    1904 <dgemm+0x804>
mov    %rcx,%r9
mov    0x5eecb8(%rsp),%rax
mov    0x5eecb0(%rsp),%r11d
movslq -0x5c(%rsp),%rsi
movslq -0x7c(%rsp),%rcx
mov    %rcx,0x20(%rsp)
mov    %edx,%edi
imul   $0xbb8,%r11d,%ecx
mov    %rcx,-0x8(%rsp)
mov    %r11d,%ebp
imul   $0xf0,-0x64(%rsp),%ecx
mov    %ecx,-0x24(%rsp)
movl   $0x4,-0x60(%rsp)
xor    %ebx,%ebx
mov    %rdi,%rdx
movl   $0x1,-0x68(%rsp)
xor    %ecx,%ecx
mov    %rcx,-0x78(%rsp)
mov    %rbp,-0x50(%rsp)
mov    %r9,0x28(%rsp)
mov    %rsi,-0x10(%rsp)
mov    %rdi,-0x18(%rsp)
jmp    11eb <dgemm+0xeb>
nopl   0x0(%rax)
mov    -0x78(%rsp),%r8
add    $0xf0,%r8
mov    0x18(%rsp),%rbx
add    $0x1,%rbx
mov    -0x68(%rsp),%ecx
add    -0x24(%rsp),%ecx
mov    %ecx,-0x68(%rsp)
addl   $0xf0,-0x60(%rsp)
mov    0x10(%rsp),%rdx
add    $0xffffffffffffff10,%rdx
mov    -0x18(%rsp),%rdi
mov    %r8,%rcx
mov    %r8,-0x78(%rsp)
cmp    %rdi,%r8
jae    1904 <dgemm+0x804>
cmp    $0xf0,%rdx
mov    $0xf0,%ecx
mov    %rdx,0x10(%rsp)
cmovl  %rdx,%rcx
movslq %ecx,%r10
cmp    $0x2,%r10
mov    $0x1,%r8d
cmovl  %r8,%r10
mov    %rbx,0x18(%rsp)
imul   $0xffffffffffffff10,%rbx,%rcx
add    %rdi,%rcx
cmp    $0xf0,%rcx
mov    $0xf0,%edx
cmovge %rdx,%rcx
movslq %ecx,%rcx
cmp    $0x2,%rcx
cmovl  %r8,%rcx
mov    %rcx,-0x38(%rsp)
cmpl   $0x0,-0x7c(%rsp)
jle    11a0 <dgemm+0xa0>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%r10
add    $0xfffffffffffffffc,%r10
shr    $0x2,%r10
add    $0x1,%r10
and    $0xfffffffffffffffe,%r10
mov    %r10,0x40(%rsp)
mov    -0x38(%rsp),%rbx
mov    %rbx,%rdx
and    %rcx,%rdx
mov    %rdx,0x58(%rsp)
lea    -0x4(%rdx),%rcx
mov    %rcx,0x50(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x48(%rsp)
mov    -0x18(%rsp),%rdx
sub    -0x78(%rsp),%rdx
cmp    $0xf0,%rdx
mov    $0xf0,%ecx
mov    %rdx,-0x30(%rsp)
cmovl  %rdx,%rcx
lea    -0x1(%rbx),%r10
movslq %ecx,%rdx
xor    %ebx,%ebx
mov    -0x7c(%rsp),%edi
mov    -0x68(%rsp),%ecx
mov    %ecx,-0x58(%rsp)
xor    %r8d,%r8d
mov    %r10,0x60(%rsp)
jmp    1316 <dgemm+0x216>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rsp),%r8
add    $0xf0,%r8
mov    0x30(%rsp),%rbx
add    $0x1,%ebx
addl   $0xf0,-0x58(%rsp)
mov    -0x20(%rsp),%edi
add    $0xffffff10,%edi
cmp    0x20(%rsp),%r8
mov    0x28(%rsp),%r9
jge    11a0 <dgemm+0xa0>
cmp    $0xf0,%edi
mov    $0xf0,%ecx
mov    %edi,-0x20(%rsp)
cmovl  %edi,%ecx
cmp    $0x2,%ecx
mov    $0x1,%esi
cmovl  %esi,%ecx
mov    %rbx,0x30(%rsp)
imul   $0xffffff10,%ebx,%r15d
mov    -0x7c(%rsp),%r10d
add    %r10d,%r15d
cmp    $0xf0,%r15d
mov    $0xf0,%esi
cmovge %esi,%r15d
cmp    $0x2,%r15d
mov    $0x1,%r14d
cmovge %r15d,%r14d
mov    %r8,%rsi
mov    %r8,-0x40(%rsp)
sub    %r8d,%r10d
cmp    $0xf0,%r10d
mov    $0xf0,%esi
cmovl  %r10d,%esi
mov    %rsi,-0x70(%rsp)
cmpq   $0x0,-0x30(%rsp)
jle    1470 <dgemm+0x370>
and    $0xfe,%ecx
lea    0x70(%rsp),%r8
mov    -0x58(%rsp),%r12d
xor    %r13d,%r13d
jmp    13c6 <dgemm+0x2c6>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    -0x64(%rsp),%r12d
add    $0x8,%r8
cmp    %rdx,%r13
jge    1470 <dgemm+0x370>
test   %r10d,%r10d
jle    13b0 <dgemm+0x2b0>
cmp    $0x2,%r15d
jge    13e0 <dgemm+0x2e0>
xor    %ebx,%ebx
jmp    1424 <dgemm+0x324>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8,%rdi
mov    %r12d,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbp),%esi
movslq %esi,%rsi
movsd  (%r9,%rsi,8),%xmm0
movsd  %xmm0,(%rdi)
movslq %ebp,%rbp
movsd  (%r9,%rbp,8),%xmm0
movsd  %xmm0,0x780(%rdi)
add    $0x2,%rbx
add    $0x2,%ebp
add    $0xf00,%rdi
cmp    %rbx,%rcx
jne    13f0 <dgemm+0x2f0>
test   $0x1,%r14b
mov    0x5eecb0(%rsp),%r11d
mov    -0x50(%rsp),%rbp
je     13b0 <dgemm+0x2b0>
mov    -0x78(%rsp),%rsi
add    %r13d,%esi
imul   -0x64(%rsp),%esi
add    -0x40(%rsp),%esi
add    %ebx,%esi
movslq %esi,%rsi
movsd  (%r9,%rsi,8),%xmm0
imul   $0xf0,%rbx,%rsi
add    %r13,%rsi
movsd  %xmm0,0x70(%rsp,%rsi,8)
jmp    13b0 <dgemm+0x2b0>
nopl   0x0(%rax)
cmpl   $0x0,-0x5c(%rsp)
mov    -0x10(%rsp),%rsi
jle    12e0 <dgemm+0x1e0>
mov    -0x70(%rsp),%rdi
lea    0x3(%rdi),%ecx
test   %edi,%edi
cmovns %edi,%ecx
and    $0xfffffffc,%ecx
mov    %ecx,-0x1c(%rsp)
movslq %ecx,%rcx
mov    %rcx,0x68(%rsp)
mov    -0x78(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    -0x60(%rsp),%ecx
mov    %ecx,-0x54(%rsp)
xor    %ecx,%ecx
mov    %rcx,(%rsp)
xor    %r9d,%r9d
jmp    14f5 <dgemm+0x3f5>
nopl   0x0(%rax)
add    $0xbb8,%r9
addq   $0x1,(%rsp)
mov    -0x8(%rsp),%rcx
add    %ecx,-0x54(%rsp)
add    %rcx,0x8(%rsp)
mov    -0x10(%rsp),%rsi
cmp    %rsi,%r9
mov    0x5eecb0(%rsp),%r11d
mov    -0x50(%rsp),%rbp
jge    12e0 <dgemm+0x1e0>
mov    %rsi,%rcx
sub    %r9,%rcx
cmp    $0xbb8,%rcx
mov    $0xbb8,%esi
cmovl  %rcx,%rsi
mov    %rsi,-0x48(%rsp)
test   %rcx,%rcx
mov    0x38(%rsp),%rcx
jle    16b0 <dgemm+0x5b0>
mov    (%rsp),%rsi
imul   -0x8(%rsp),%rsi
add    -0x78(%rsp),%rsi
mov    %rsi,-0x70(%rsp)
movslq -0x48(%rsp),%r15
mov    0x8(%rsp),%r14
lea    0x70870(%rsp),%r8
lea    0x708a0(%rsp),%r12
mov    -0x54(%rsp),%r13d
xor    %r10d,%r10d
jmp    1581 <dgemm+0x481>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r11d,%r13d
add    $0x780,%r12
add    $0x780,%r8
add    %rbp,%r14
cmp    %r15,%r10
jge    16b0 <dgemm+0x5b0>
cmpq   $0x0,-0x30(%rsp)
jle    1560 <dgemm+0x460>
cmpq   $0x4,-0x38(%rsp)
jae    15a0 <dgemm+0x4a0>
xor    %esi,%esi
jmp    1690 <dgemm+0x590>
nopl   0x0(%rax,%rax,1)
mov    %r10d,%esi
imul   %ebp,%esi
add    -0x70(%rsp),%esi
mov    0x60(%rsp),%rbx
lea    (%rsi,%rbx,1),%edi
cmp    %esi,%edi
jl     1626 <dgemm+0x526>
mov    %rbx,%rsi
shr    $0x20,%rsi
mov    $0x0,%esi
jne    1690 <dgemm+0x590>
cmpq   $0x0,0x50(%rsp)
je     162a <dgemm+0x52a>
mov    0x40(%rsp),%rbp
mov    %r13d,%esi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
lea    -0x4(%rsi),%r11d
movslq %r11d,%rbx
movups (%rcx,%rbx,8),%xmm0
movups 0x10(%rcx,%rbx,8),%xmm1
movaps %xmm0,-0x30(%r12,%rdi,8)
movaps %xmm1,-0x20(%r12,%rdi,8)
movslq %esi,%rsi
movupd (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm1
movapd %xmm0,-0x10(%r12,%rdi,8)
movapd %xmm1,(%r12,%rdi,8)
add    $0x8,%rdi
add    $0x8,%esi
add    $0xfffffffffffffffe,%rbp
jne    15e0 <dgemm+0x4e0>
jmp    162c <dgemm+0x52c>
xor    %esi,%esi
jmp    1690 <dgemm+0x590>
xor    %edi,%edi
testb  $0x1,0x48(%rsp)
mov    0x5eecb0(%rsp),%r11d
mov    -0x50(%rsp),%rbp
je     167d <dgemm+0x57d>
lea    (%r10,%r9,1),%esi
imul   %r11d,%esi
add    -0x78(%rsp),%esi
imul   $0xf0,%r10,%rbp
add    %edi,%esi
movslq %esi,%rsi
movupd (%rcx,%rsi,8),%xmm0
movupd 0x10(%rcx,%rsi,8),%xmm1
add    %rdi,%rbp
movapd %xmm0,0x70870(%rsp,%rbp,8)
movapd %xmm1,0x70880(%rsp,%rbp,8)
mov    -0x50(%rsp),%rbp
mov    0x58(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rdi,-0x38(%rsp)
je     1560 <dgemm+0x460>
lea    (%r14,%rsi,1),%edi
movslq %edi,%rdi
movsd  (%rcx,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rsi,8)
add    $0x1,%rsi
cmp    %rdx,%rsi
jl     1690 <dgemm+0x590>
jmp    1560 <dgemm+0x460>
cmpl   $0x0,-0x1c(%rsp)
jle    14c0 <dgemm+0x3c0>
mov    -0x48(%rsp),%rsi
mov    %esi,%ecx
shr    $0x1f,%ecx
add    %esi,%ecx
and    $0xfffffffe,%ecx
mov    %ecx,-0x48(%rsp)
movslq %ecx,%r11
lea    0x16f0(%rsp),%r14
xor    %ecx,%ecx
mov    %rcx,-0x70(%rsp)
jmp    1713 <dgemm+0x613>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x70(%rsp),%rsi
add    $0x4,%rsi
add    $0x1e00,%r14
mov    %rsi,%rcx
mov    %rsi,-0x70(%rsp)
cmp    0x68(%rsp),%rsi
jge    14c0 <dgemm+0x3c0>
cmpl   $0x0,-0x48(%rsp)
jle    16f0 <dgemm+0x5f0>
mov    -0x40(%rsp),%rcx
mov    -0x70(%rsp),%rsi
lea    (%rsi,%rcx,1),%r8d
mov    $0xe,%r15d
xor    %ebp,%ebp
xor    %r13d,%r13d
jmp    180a <dgemm+0x70a>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm9,%xmm9
xorpd  %xmm8,%xmm8
xorpd  %xmm10,%xmm10
xorpd  %xmm11,%xmm11
xorpd  %xmm12,%xmm12
xorpd  %xmm13,%xmm13
xorpd  %xmm6,%xmm6
xorpd  %xmm7,%xmm7
lea    (%r9,%r13,1),%ebx
mov    %ebx,%ecx
mov    0x5eecc0(%rsp),%edi
imul   %edi,%ecx
add    %r8d,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm7
movsd  %xmm7,(%rax,%rcx,8)
mov    %ecx,%esi
or     $0x1,%esi
movslq %esi,%rsi
addsd  (%rax,%rsi,8),%xmm6
movsd  %xmm6,(%rax,%rsi,8)
addsd  0x10(%rax,%rcx,8),%xmm13
movsd  %xmm13,0x10(%rax,%rcx,8)
addsd  0x18(%rax,%rcx,8),%xmm12
movsd  %xmm12,0x18(%rax,%rcx,8)
or     $0x1,%ebx
imul   %edi,%ebx
add    %r8d,%ebx
movslq %ebx,%rcx
addsd  (%rax,%rcx,8),%xmm11
movsd  %xmm11,(%rax,%rcx,8)
addsd  0x8(%rax,%rcx,8),%xmm10
movsd  %xmm10,0x8(%rax,%rcx,8)
addsd  0x10(%rax,%rcx,8),%xmm9
movsd  %xmm9,0x10(%rax,%rcx,8)
addsd  0x18(%rax,%rcx,8),%xmm8
movsd  %xmm8,0x18(%rax,%rcx,8)
add    $0x2,%r13
add    $0x1e,%r15d
add    $0xf,%ebp
cmp    %r11,%r13
jge    16f0 <dgemm+0x5f0>
cmpq   $0x0,-0x30(%rsp)
jle    1740 <dgemm+0x640>
mov    %r15d,%ebx
and    $0xfffffff,%ebx
shl    $0x7,%rbx
lea    0x708f0(%rsp),%rcx
add    %rcx,%rbx
mov    %ebp,%ecx
and    $0x7ffffff,%ecx
shl    $0x8,%rcx
lea    (%rsp,%rcx,1),%r12
add    $0x70870,%r12
xorpd  %xmm7,%xmm7
xor    %r10d,%r10d
xorpd  %xmm6,%xmm6
xorpd  %xmm13,%xmm13
xorpd  %xmm12,%xmm12
xorpd  %xmm11,%xmm11
xorpd  %xmm10,%xmm10
xorpd  %xmm8,%xmm8
xorpd  %xmm9,%xmm9
xchg   %ax,%ax
movsd  (%r12,%r10,8),%xmm1
movsd  (%rbx,%r10,8),%xmm0
movsd  -0x1680(%r14,%r10,8),%xmm3
e9 ff ff
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm7
movsd  -0xf00(%r14,%r10,8),%xmm4
f1 ff ff
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm6
movsd  -0x780(%r14,%r10,8),%xmm5
f8 ff ff
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm13
movsd  (%r14,%r10,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm12
mulsd  %xmm0,%xmm3
addsd  %xmm3,%xmm11
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm10
mulsd  %xmm0,%xmm5
addsd  %xmm5,%xmm9
mulsd  %xmm0,%xmm2
addsd  %xmm2,%xmm8
add    $0x1,%r10
cmp    %rdx,%r10
jl     1870 <dgemm+0x770>
jmp    1766 <dgemm+0x666>
add    $0x5eec78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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