void Mvm(m, n, alpha, A, j0, x, beta, y) int m, n, j0;
double alpha, beta;
double **A, *x, *y;
{
  register int i, j, m4, n2;
  register double *Aref;
  register double tmp;
  register double *Aref0, *Aref1;
  register double tmp0, tmp1;
  register double yval0, yval1, yval2, yval3;
  if (beta != 1.0)
    Mscale(m, beta, y);
  m4 = n2 = 0;
  m4 = m / 4;
  m = m % 4;
  n2 = n / 2;
  n = n % 2;
  for (j = 0; j < n2; j++) {
    tmp0 = alpha * x[2 * j];
    tmp1 = alpha * x[2 * j + 1];
    Aref0 = &(A[2 * j][j0]);
    Aref1 = &(A[2 * j + 1][j0]);
    for (i = 0; i < m4; i++) {
      yval0 = y[4 * i] + tmp0 * Aref0[4 * i];
      yval1 = y[4 * i + 1] + tmp0 * Aref0[4 * i + 1];
      yval2 = y[4 * i + 2] + tmp0 * Aref0[4 * i + 2];
      yval3 = y[4 * i + 3] + tmp0 * Aref0[4 * i + 3];
      y[4 * i] = yval0 + tmp1 * Aref1[4 * i];
      y[4 * i + 1] = yval1 + tmp1 * Aref1[4 * i + 1];
      y[4 * i + 2] = yval2 + tmp1 * Aref1[4 * i + 2];
      y[4 * i + 3] = yval3 + tmp1 * Aref1[4 * i + 3];
    }
    y += 4 * m4;
    Aref0 += 4 * m4;
    Aref1 += 4 * m4;
    for (i = 0; i < m; i++)
      y[i] += tmp0 * Aref0[i] + tmp1 * Aref1[i];
  }
  for (j = 0; j < n; j++) {
    tmp = alpha * x[2 * n2 + j];
    Aref = &(A[2 * n2 + j][j0]);
    for (i = 0; i < m4; i++) {
      y[4 * i] += tmp * Aref[4 * i];
      y[4 * i + 1] += tmp * Aref[4 * i + 1];
      y[4 * i + 2] += tmp * Aref[4 * i + 2];
      y[4 * i + 3] += tmp * Aref[4 * i + 3];
    }
    y += 4 * m4;
    Aref += 4 * m4;
    for (i = 0; i < m; i++)
      y[i] += tmp * Aref[i];
  }
}


x86 assembly (clang, -O0):
<Mvm>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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)
movsd  -0x30(%rbp),%xmm0
movsd  0xeb9(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    115c <Mvm+0x4c>
jp     115c <Mvm+0x4c>
jmp    116f <Mvm+0x5f>
mov    -0x4(%rbp),%edi
movsd  -0x30(%rbp),%xmm0
mov    -0x38(%rbp),%rsi
mov    $0x1,%al
call   1030 <Mscale@plt>
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    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x8(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1507 <Mvm+0x3f7>
movsd  -0x10(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    144d <Mvm+0x33d>
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
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  -0x88(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
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  -0x90(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
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  -0x98(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
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    124d <Mvm+0x13d>
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14f4 <Mvm+0x3e4>
movsd  -0x70(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    149c <Mvm+0x38c>
jmp    14f9 <Mvm+0x3e9>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11bc <Mvm+0xac>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16f7 <Mvm+0x5e7>
movsd  -0x10(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1667 <Mvm+0x557>
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1563 <Mvm+0x453>
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16e4 <Mvm+0x5d4>
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    169e <Mvm+0x58e>
jmp    16e9 <Mvm+0x5d9>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    150e <Mvm+0x3fe>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mvm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%r14
mov    %r8,0x38(%rsp)
mov    %ecx,%r15d
mov    %rdx,0x30(%rsp)
movapd %xmm0,%xmm13
mov    %esi,%ebp
mov    %edi,%ebx
ucomisd 0xebe(%rip),%xmm1
jne    1146 <Mvm+0x36>
jnp    1164 <Mvm+0x54>
mov    %ebx,%edi
movapd %xmm1,%xmm0
mov    %r14,%rsi
mov    $0x1,%al
movapd %xmm13,0x40(%rsp)
call   1030 <Mscale@plt>
movapd 0x40(%rsp),%xmm13
lea    0x3(%rbx),%eax
test   %ebx,%ebx
cmovns %ebx,%eax
mov    %eax,%edx
sar    $0x2,%edx
and    $0xfffffffc,%eax
mov    %ebx,%ecx
sub    %eax,%ecx
mov    %ebp,%esi
shr    $0x1f,%esi
add    %ebp,%esi
sar    %esi
mov    %ebp,0x24(%rsp)
cmp    $0x2,%ebp
mov    %ecx,0xc(%rsp)
mov    %rdx,0x10(%rsp)
mov    %r15d,0x20(%rsp)
mov    %esi,0x1c(%rsp)
jl     1590 <Mvm+0x480>
movslq %r15d,%rdi
lea    0x0(,%rdx,4),%eax
movslq %eax,%r11
mov    %esi,%eax
mov    %rax,0x40(%rsp)
mov    %edx,%r10d
lea    0x0(,%r10,4),%rax
mov    %rax,0x68(%rsp)
lea    (%rdi,%r10,4),%rax
mov    %rax,0x60(%rsp)
mov    %r10d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x58(%rsp)
lea    0x0(,%r11,8),%rax
mov    %rax,0x80(%rsp)
mov    %r10,0x28(%rsp)
shl    $0x5,%r10
and    $0xffffffffffffffc0,%r10
lea    0x3(%rdi),%rax
mov    %rax,0x78(%rsp)
xor    %r8d,%r8d
mov    %r14,0x70(%rsp)
mov    %r14,%rdx
jmp    1222 <Mvm+0x112>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
cmp    0x40(%rsp),%r8
mov    %r14,%rbx
je     1593 <Mvm+0x483>
mov    %r8,%rax
shl    $0x4,%rax
mov    0x38(%rsp),%rsi
movsd  (%rsi,%rax,1),%xmm10
mulsd  %xmm13,%xmm10
movsd  0x8(%rsi,%rax,1),%xmm11
mulsd  %xmm13,%xmm11
mov    0x30(%rsp),%rsi
mov    (%rsi,%rax,1),%r12
mov    0x8(%rsi,%rax,1),%r13
lea    (%r12,%rdi,8),%r9
lea    0x0(,%rdi,8),%r15
add    %r13,%r15
mov    %rbx,%r14
cmp    $0x4,%ebx
jl     1502 <Mvm+0x3f2>
cmpl   $0x2,0x10(%rsp)
jae    1280 <Mvm+0x170>
xor    %esi,%esi
jmp    1440 <Mvm+0x330>
nopl   0x0(%rax)
mov    %r8,%rax
imul   %r11,%rax
add    0x68(%rsp),%rax
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    0x60(%rsp),%rcx
lea    (%r12,%rcx,8),%rax
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
cmp    %rax,%rdx
setb   %bpl
cmp    %rsi,%r9
setb   %cl
cmp    %rbx,%rdx
setb   %al
cmp    %rsi,%r15
setb   %bl
test   %cl,%bpl
jne    142e <Mvm+0x31e>
mov    $0x0,%esi
and    %bl,%al
mov    0xc(%rsp),%ecx
jne    1440 <Mvm+0x330>
movapd %xmm10,%xmm8
unpcklpd %xmm10,%xmm8
movapd %xmm11,%xmm9
unpcklpd %xmm11,%xmm9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%rsi,1),%xmm3
movupd 0x10(%rdx,%rsi,1),%xmm2
movupd 0x20(%rdx,%rsi,1),%xmm4
movupd 0x30(%rdx,%rsi,1),%xmm5
movapd %xmm3,%xmm0
unpcklpd %xmm4,%xmm0
unpckhpd %xmm4,%xmm3
movapd %xmm2,%xmm12
unpcklpd %xmm5,%xmm12
unpckhpd %xmm5,%xmm2
movupd (%r9,%rsi,1),%xmm5
movupd 0x10(%r9,%rsi,1),%xmm4
movupd 0x20(%r9,%rsi,1),%xmm6
movupd 0x30(%r9,%rsi,1),%xmm1
movapd %xmm5,%xmm7
unpcklpd %xmm6,%xmm7
unpckhpd %xmm6,%xmm5
movapd %xmm4,%xmm6
unpcklpd %xmm1,%xmm6
unpckhpd %xmm1,%xmm4
mulpd  %xmm8,%xmm7
addpd  %xmm0,%xmm7
mulpd  %xmm8,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm8,%xmm6
addpd  %xmm12,%xmm6
mulpd  %xmm8,%xmm4
addpd  %xmm2,%xmm4
movupd (%r15,%rsi,1),%xmm2
movupd 0x10(%r15,%rsi,1),%xmm3
movupd 0x20(%r15,%rsi,1),%xmm0
movupd 0x30(%r15,%rsi,1),%xmm12
movapd %xmm2,%xmm1
unpcklpd %xmm0,%xmm1
unpckhpd %xmm0,%xmm2
movapd %xmm3,%xmm0
unpcklpd %xmm12,%xmm0
unpckhpd %xmm12,%xmm3
mulpd  %xmm9,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm9,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm9,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm9,%xmm3
addpd  %xmm4,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm1,%xmm5
unpcklpd %xmm2,%xmm5
movhlps %xmm0,%xmm3
movhlps %xmm1,%xmm2
movups %xmm2,0x20(%rdx,%rsi,1)
movups %xmm3,0x30(%rdx,%rsi,1)
movupd %xmm5,(%rdx,%rsi,1)
movupd %xmm4,0x10(%rdx,%rsi,1)
add    $0x40,%rsi
cmp    %rsi,%r10
jne    1300 <Mvm+0x1f0>
mov    0x58(%rsp),%rax
mov    %rax,%rsi
cmp    0x28(%rsp),%rax
jne    1440 <Mvm+0x330>
jmp    1502 <Mvm+0x3f2>
xor    %esi,%esi
mov    0xc(%rsp),%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x78(%rsp),%rbx
lea    0x0(,%rbx,8),%rax
add    %r13,%rax
lea    (%r12,%rbx,8),%rbx
mov    0x28(%rsp),%rbp
sub    %rsi,%rbp
shl    $0x5,%rsi
movsd  -0x18(%rbx,%rsi,1),%xmm0
mulsd  %xmm10,%xmm0
addsd  (%rdx,%rsi,1),%xmm0
movsd  -0x10(%rbx,%rsi,1),%xmm1
mulsd  %xmm10,%xmm1
addsd  0x8(%rdx,%rsi,1),%xmm1
movsd  -0x8(%rbx,%rsi,1),%xmm2
mulsd  %xmm10,%xmm2
addsd  0x10(%rdx,%rsi,1),%xmm2
movsd  (%rbx,%rsi,1),%xmm3
mulsd  %xmm10,%xmm3
addsd  0x18(%rdx,%rsi,1),%xmm3
movsd  -0x18(%rax,%rsi,1),%xmm4
mulsd  %xmm11,%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,(%rdx,%rsi,1)
movsd  -0x10(%rax,%rsi,1),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,1)
movsd  -0x8(%rax,%rsi,1),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x10(%rdx,%rsi,1)
movsd  (%rax,%rsi,1),%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x18(%rdx,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rbp
jne    1460 <Mvm+0x350>
add    0x80(%rsp),%rdx
test   %ecx,%ecx
jle    1210 <Mvm+0x100>
movsd  (%r15,%r11,8),%xmm0
mulsd  %xmm11,%xmm0
movsd  (%r9,%r11,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
cmp    $0x1,%ecx
je     1210 <Mvm+0x100>
movsd  0x8(%r15,%r11,8),%xmm0
mulsd  %xmm11,%xmm0
movsd  0x8(%r9,%r11,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
addsd  0x8(%rdx),%xmm1
movsd  %xmm1,0x8(%rdx)
cmp    $0x2,%ecx
je     1210 <Mvm+0x100>
mulsd  0x10(%r15,%r11,8),%xmm11
mulsd  0x10(%r9,%r11,8),%xmm10
addsd  %xmm11,%xmm10
addsd  0x10(%rdx),%xmm10
movsd  %xmm10,0x10(%rdx)
jmp    1210 <Mvm+0x100>
mov    %r14,%rdx
mov    0x24(%rsp),%eax
and    $0x80000001,%eax
cmp    $0x1,%eax
jne    16e2 <Mvm+0x5d2>
mov    0x1c(%rsp),%eax
add    %eax,%eax
movslq %eax,%rsi
mov    0x30(%rsp),%rax
mov    (%rax,%rsi,8),%rax
movslq 0x20(%rsp),%rdi
lea    (%rax,%rdi,8),%rcx
mov    0x38(%rsp),%rbp
mulsd  0x0(%rbp,%rsi,8),%xmm13
cmp    $0x3,%ebx
jle    1683 <Mvm+0x573>
mov    0x10(%rsp),%rbp
mov    %ebp,%esi
cmp    $0x2,%ebp
jb     1606 <Mvm+0x4f6>
mov    %rsi,%rbp
shl    $0x5,%rbp
lea    (%rdi,%rsi,4),%rdi
lea    (%rax,%rdi,8),%rax
cmp    %rax,%rdx
jae    16f4 <Mvm+0x5e4>
lea    (%rdx,%rbp,1),%rax
cmp    %rax,%rcx
jae    16f4 <Mvm+0x5e4>
xor    %edi,%edi
sub    %rdi,%rsi
shl    $0x5,%rdi
or     $0x18,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%rcx,%rdi,1),%xmm0
mulsd  %xmm13,%xmm0
addsd  -0x18(%rdx,%rdi,1),%xmm0
movsd  %xmm0,-0x18(%rdx,%rdi,1)
movsd  -0x10(%rcx,%rdi,1),%xmm0
mulsd  %xmm13,%xmm0
addsd  -0x10(%rdx,%rdi,1),%xmm0
movsd  %xmm0,-0x10(%rdx,%rdi,1)
movsd  -0x8(%rcx,%rdi,1),%xmm0
mulsd  %xmm13,%xmm0
addsd  -0x8(%rdx,%rdi,1),%xmm0
movsd  %xmm0,-0x8(%rdx,%rdi,1)
movsd  (%rcx,%rdi,1),%xmm0
mulsd  %xmm13,%xmm0
addsd  (%rdx,%rdi,1),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffff,%rsi
jne    1620 <Mvm+0x510>
cmpl   $0x0,0xc(%rsp)
jle    16e2 <Mvm+0x5d2>
mov    0x10(%rsp),%rax
shl    $0x2,%eax
cltq
movsd  (%rcx,%rax,8),%xmm0
mulsd  %xmm13,%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
cmpl   $0x1,0xc(%rsp)
je     16e2 <Mvm+0x5d2>
movsd  0x8(%rcx,%rax,8),%xmm0
mulsd  %xmm13,%xmm0
addsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
cmpl   $0x2,0xc(%rsp)
je     16e2 <Mvm+0x5d2>
mulsd  0x10(%rcx,%rax,8),%xmm13
addsd  0x10(%rdx,%rax,8),%xmm13
movsd  %xmm13,0x10(%rdx,%rax,8)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%edi
and    $0xfffffffe,%edi
movapd %xmm13,%xmm8
unpcklpd %xmm13,%xmm8
and    $0xffffffffffffffc0,%rbp
xor    %eax,%eax
nopl   0x0(%rax)
movupd (%rcx,%rax,1),%xmm1
movupd 0x10(%rcx,%rax,1),%xmm2
movupd 0x20(%rcx,%rax,1),%xmm4
movupd 0x30(%rcx,%rax,1),%xmm5
movapd %xmm1,%xmm3
unpcklpd %xmm4,%xmm3
unpckhpd %xmm4,%xmm1
movapd %xmm2,%xmm4
unpcklpd %xmm5,%xmm4
unpckhpd %xmm5,%xmm2
movupd (%rdx,%rax,1),%xmm5
movupd 0x10(%rdx,%rax,1),%xmm6
movupd 0x20(%rdx,%rax,1),%xmm7
movupd 0x30(%rdx,%rax,1),%xmm9
movapd %xmm5,%xmm0
unpcklpd %xmm7,%xmm0
unpckhpd %xmm7,%xmm5
movapd %xmm6,%xmm7
unpcklpd %xmm9,%xmm7
unpckhpd %xmm9,%xmm6
mulpd  %xmm8,%xmm3
addpd  %xmm0,%xmm3
mulpd  %xmm8,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm8,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm8,%xmm2
addpd  %xmm6,%xmm2
movapd %xmm4,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm3,%xmm5
unpcklpd %xmm1,%xmm5
movhlps %xmm4,%xmm2
movhlps %xmm3,%xmm1
movups %xmm1,0x20(%rdx,%rax,1)
movups %xmm2,0x30(%rdx,%rax,1)
movupd %xmm5,(%rdx,%rax,1)
movupd %xmm0,0x10(%rdx,%rax,1)
add    $0x40,%rax
cmp    %rax,%rbp
jne    1710 <Mvm+0x600>
cmp    %rsi,%rdi
je     1683 <Mvm+0x573>
jmp    1608 <Mvm+0x4f8>

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

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