void Mmv(m, n, alpha, A, j0, x, beta, y) int m, n, j0;
double alpha, beta;
double **A, *x, *y;
{
  register int i, j, m4, n4;
  register double sum0, sum1, sum2, sum3, tmp0, tmp1, tmp2, tmp3;
  register double *dp0, *dp1, *dp2, *dp3;
  m4 = n4 = 0;
  m4 = m / 4;
  m = m % 4;
  n4 = n / 4;
  n = n % 4;
  for (i = 0; i < m4; i++) {
    sum0 = sum1 = sum2 = sum3 = 0.0;
    dp0 = &(A[4 * i][j0]);
    dp1 = &(A[4 * i + 1][j0]);
    dp2 = &(A[4 * i + 2][j0]);
    dp3 = &(A[4 * i + 3][j0]);
    for (j = 0; j < n4; j++) {
      tmp0 = x[4 * j];
      tmp1 = x[4 * j + 1];
      tmp2 = x[4 * j + 2];
      tmp3 = x[4 * j + 3];
      sum0 = sum0 + dp0[j] * tmp0 + dp0[j + 1] * tmp1 + dp0[j + 2] * tmp2 +
             dp0[j + 3] * tmp3;
      sum1 = sum1 + dp1[j] * tmp0 + dp1[j + 1] * tmp1 + dp1[j + 2] * tmp2 +
             dp1[j + 3] * tmp3;
      sum2 = sum2 + dp2[j] * tmp0 + dp2[j + 1] * tmp1 + dp2[j + 2] * tmp2 +
             dp2[j + 3] * tmp3;
      sum3 = sum3 + dp3[j] * tmp0 + dp3[j + 1] * tmp2 + dp3[j + 2] * tmp2 +
             dp3[j + 3] * tmp3;
    }
    for (j = 0; j < n; j++) {
      sum0 += dp0[4 * n4 + j] * x[4 * n4 + j];
      sum1 += dp1[4 * n4 + j] * x[4 * n4 + j];
      sum2 += dp2[4 * n4 + j] * x[4 * n4 + j];
      sum3 += dp3[4 * n4 + j] * x[4 * n4 + j];
    }
    y[4 * i] = beta * y[4 * i] + alpha * sum0;
    y[4 * i + 1] = beta * y[4 * i + 1] + alpha * sum1;
    y[4 * i + 2] = beta * y[4 * i + 2] + alpha * sum2;
    y[4 * i + 3] = beta * y[4 * i + 3] + alpha * sum3;
  }
  for (i = 0; i < m; i++)
    y[4 * m4 + i] =
        beta * y[i] + alpha * Mdot(4 * n4 + n, &(A[4 * m4 + i][j0]), x);
}


x86 assembly (clang, -O0):
<Mmv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x4(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x8(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    173a <Mmv+0x62a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1511 <Mmv+0x401>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    124f <Mmv+0x13f>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    162e <Mmv+0x51e>
mov    -0x90(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1518 <Mmv+0x408>
movsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x10(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1187 <Mmv+0x77>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17fa <Mmv+0x6ea>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%edi
shl    $0x2,%edi
add    -0x8(%rbp),%edi
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x28(%rbp),%rdx
mov    $0x0,%al
call   1030 <Mdot@plt>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
cvtsi2sd %eax,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1741 <Mmv+0x631>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mmv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,%rbx
mov    %rdx,0x18(%rsp)
lea    0x3(%rdi),%ebp
test   %edi,%edi
cmovns %edi,%ebp
mov    %ebp,%eax
sar    $0x2,%eax
mov    %eax,0xc(%rsp)
and    $0xfffffffc,%ebp
mov    %edi,%eax
sub    %ebp,%eax
mov    %eax,0x2c(%rsp)
lea    0x3(%rsi),%eax
test   %esi,%esi
cmovns %esi,%eax
mov    %eax,%ebp
sar    $0x2,%ebp
mov    %rbp,0x30(%rsp)
and    $0xfffffffc,%eax
mov    %esi,%ebp
sub    %eax,%ebp
movslq %ecx,%r14
cmp    $0x4,%edi
movapd %xmm1,0x70(%rsp)
movapd %xmm0,0x80(%rsp)
jl     149e <Mmv+0x38e>
mov    0x30(%rsp),%rcx
lea    0x0(,%rcx,4),%eax
cltq
mov    0xc(%rsp),%edi
mov    %rdi,0x10(%rsp)
mov    %ecx,%ecx
mov    %rcx,0x50(%rsp)
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
lea    0x1(%rax),%rcx
mov    %rcx,0x40(%rsp)
mov    %rax,0x68(%rsp)
add    $0x2,%rax
mov    %rax,0x38(%rsp)
lea    0x3(%r14),%rax
mov    %rax,0x48(%rsp)
xor    %r8d,%r8d
mov    %r14,0x60(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rbp,0x20(%rsp)
jmp    1270 <Mmv+0x160>
addpd  %xmm0,%xmm4
addpd  %xmm15,%xmm2
mov    0x38(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm15
movhpd (%r12,%rax,8),%xmm15
movsd  (%rbx,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm15
addpd  %xmm2,%xmm15
movsd  (%r10,%rax,8),%xmm0
movhpd (%r11,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm4,%xmm0
lea    0x2(,%r8,4),%rax
movupd (%r9,%rdx,8),%xmm2
mulpd  %xmm9,%xmm15
mulpd  %xmm8,%xmm2
addpd  %xmm15,%xmm2
movupd %xmm2,(%r9,%rdx,8)
movupd (%r9,%rax,8),%xmm2
mulpd  %xmm9,%xmm0
mulpd  %xmm8,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm2,(%r9,%rax,8)
add    $0x1,%r8
cmp    0x10(%rsp),%r8
je     149e <Mmv+0x38e>
lea    0x0(,%r8,4),%rdx
mov    %r8,%rax
shl    $0x5,%rax
mov    0x18(%rsp),%rcx
mov    (%rcx,%rax,1),%r15
mov    0x8(%rcx,%rax,1),%rdi
lea    (%r15,%r14,8),%r13
lea    (%rdi,%r14,8),%r12
mov    0x10(%rcx,%rdx,8),%rbp
lea    0x0(%rbp,%r14,8),%r10
mov    0x18(%rcx,%rax,1),%rax
lea    (%rax,%r14,8),%r11
xorpd  %xmm15,%xmm15
xorpd  %xmm0,%xmm0
cmp    $0x4,%esi
jl     140e <Mmv+0x2fe>
movsd  0x8(%r13),%xmm10
movsd  0x10(%r13),%xmm13
movhpd 0x10(%r12),%xmm13
movhpd 0x8(%r12),%xmm10
movsd  0x0(%r13),%xmm4
movhpd (%r12),%xmm4
movsd  (%r10),%xmm11
movsd  0x8(%r10),%xmm12
movsd  0x10(%r10),%xmm5
movhpd 0x10(%r11),%xmm5
movhpd 0x8(%r11),%xmm12
movhpd (%r11),%xmm11
mov    0x48(%rsp),%rcx
lea    (%rax,%rcx,8),%rax
lea    0x0(%rbp,%rcx,8),%rsi
lea    (%rdi,%rcx,8),%rbp
lea    (%r15,%rcx,8),%rdi
xorpd  %xmm14,%xmm14
mov    0x50(%rsp),%rcx
xor    %r14d,%r14d
xorpd  %xmm1,%xmm1
nopl   0x0(%rax)
movapd %xmm12,%xmm0
movsd  (%rbx,%r14,4),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm11,%xmm3
movapd %xmm12,%xmm11
movapd %xmm12,%xmm7
movapd %xmm5,%xmm12
movupd 0x8(%rbx,%r14,4),%xmm2
addpd  %xmm14,%xmm4
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm10,%xmm0
addpd  %xmm4,%xmm0
movapd %xmm10,%xmm4
movapd %xmm13,%xmm10
mulpd  %xmm2,%xmm7
unpckhpd %xmm2,%xmm2
movapd %xmm13,%xmm6
mulpd  %xmm2,%xmm6
movsd  (%rdi,%r14,1),%xmm13
movhpd 0x0(%rbp,%r14,1),%xmm13
addpd  %xmm0,%xmm6
movsd  0x18(%rbx,%r14,4),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm13,%xmm15
mulpd  %xmm0,%xmm15
movapd %xmm15,%xmm14
addpd  %xmm6,%xmm14
addpd  %xmm1,%xmm3
addpd  %xmm7,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm3,%xmm2
movsd  (%rsi,%r14,1),%xmm5
movhpd (%rax,%r14,1),%xmm5
mulpd  %xmm5,%xmm0
movapd %xmm0,%xmm1
addpd  %xmm2,%xmm1
add    $0x8,%r14
add    $0xffffffffffffffff,%rcx
jne    1330 <Mmv+0x220>
addpd  %xmm2,%xmm0
addpd  %xmm6,%xmm15
movapd 0x70(%rsp),%xmm1
mov    0x60(%rsp),%r14
mov    0x58(%rsp),%rsi
mov    0x20(%rsp),%rbp
test   %ebp,%ebp
jle    1224 <Mmv+0x114>
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm4
movhpd (%r12,%rax,8),%xmm4
movsd  (%rbx,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm2,%xmm4
movsd  (%r10,%rax,8),%xmm3
movhpd (%r11,%rax,8),%xmm3
addpd  %xmm4,%xmm15
mulpd  %xmm2,%xmm3
addpd  %xmm3,%xmm0
cmp    $0x1,%ebp
je     1224 <Mmv+0x114>
mov    0x40(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
movhpd (%r12,%rax,8),%xmm2
movsd  (%rbx,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm2
movsd  (%r10,%rax,8),%xmm4
movhpd (%r11,%rax,8),%xmm4
mulpd  %xmm3,%xmm4
cmp    $0x2,%ebp
jne    11e2 <Mmv+0xd2>
addpd  %xmm2,%xmm15
jmp    1220 <Mmv+0x110>
mov    0x2c(%rsp),%ecx
test   %ecx,%ecx
mov    %r9,0x10(%rsp)
jle    1547 <Mmv+0x437>
mov    0x30(%rsp),%rax
lea    0x0(%rbp,%rax,4),%eax
mov    %eax,0x20(%rsp)
mov    0xc(%rsp),%eax
shl    $0x2,%eax
cltq
mov    %ecx,%r12d
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r13
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
shl    $0x3,%r14
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%r15,8),%rsi
add    %r14,%rsi
mov    0x10(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x20(%rsp),%edi
mov    %rbx,%rdx
xor    %eax,%eax
call   1030 <Mdot@plt>
movapd 0x70(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x80(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp,%r15,8)
add    $0x1,%r15
cmp    %r15,%r12
jne    14f0 <Mmv+0x3e0>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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