void OneMatmat(double *B, double *A, double *C, long n1, long n2, long n3,
               long n4, long n5) {
  long i, j, k;
  double a_j0k0, a_j0k1, a_j0k2, a_j0k3;
  double a_j0k4, a_j0k5, a_j0k6, a_j0k7;
  double a_j1k0, a_j1k1, a_j1k2, a_j1k3;
  double a_j1k4, a_j1k5, a_j1k6, a_j1k7;
  double *b0, *b1, *b2, *b3, *b4, *b5, *b6, *b7;
  double *dest0, *dest1, *last;
  double *tmp;
  double t0, t1, tmp0, tmp1;
  for (j = 0; j < n1 - 1; j += 2) {
    k = 0;
    for (; k < n2 - 7; k += 8) {
      tmp = &A[j + n5 * k];
      a_j0k0 = *tmp;
      a_j1k0 = *(tmp + 1);
      tmp += n5;
      a_j0k1 = *tmp;
      a_j1k1 = *(tmp + 1);
      tmp += n5;
      a_j0k2 = *tmp;
      a_j1k2 = *(tmp + 1);
      tmp += n5;
      a_j0k3 = *tmp;
      a_j1k3 = *(tmp + 1);
      tmp += n5;
      a_j0k4 = *tmp;
      a_j1k4 = *(tmp + 1);
      tmp += n5;
      a_j0k5 = *tmp;
      a_j1k5 = *(tmp + 1);
      tmp += n5;
      a_j0k6 = *tmp;
      a_j1k6 = *(tmp + 1);
      tmp += n5;
      a_j0k7 = *tmp;
      a_j1k7 = *(tmp + 1);
      dest0 = &C[n4 * j];
      dest1 = dest0 + n4;
      last = dest0 + n3;
      b0 = &B[n3 * k];
      b1 = b0 + n3;
      b2 = b1 + n3;
      b3 = b2 + n3;
      b4 = b3 + n3;
      b5 = b4 + n3;
      b6 = b5 + n3;
      b7 = b6 + n3;
      while (dest0 != last) {
        t0 = *dest0;
        t1 = *dest1;
        tmp0 = *b0++;
        t0 -= a_j0k0 * tmp0;
        t1 -= a_j1k0 * tmp0;
        tmp1 = *b1++;
        t0 -= a_j0k1 * tmp1;
        t1 -= a_j1k1 * tmp1;
        tmp0 = *b2++;
        t0 -= a_j0k2 * tmp0;
        t1 -= a_j1k2 * tmp0;
        tmp1 = *b3++;
        t0 -= a_j0k3 * tmp1;
        t1 -= a_j1k3 * tmp1;
        tmp0 = *b4++;
        t0 -= a_j0k4 * tmp0;
        t1 -= a_j1k4 * tmp0;
        tmp1 = *b5++;
        t0 -= a_j0k5 * tmp1;
        t1 -= a_j1k5 * tmp1;
        tmp0 = *b6++;
        t0 -= a_j0k6 * tmp0;
        t1 -= a_j1k6 * tmp0;
        tmp1 = *b7++;
        t0 -= a_j0k7 * tmp1;
        t1 -= a_j1k7 * tmp1;
        *dest0++ = t0;
        *dest1++ = t1;
      }
    }
    for (; k < n2 - 3; k += 4) {
      tmp = &A[j + n5 * k];
      a_j0k0 = *tmp;
      a_j1k0 = *(tmp + 1);
      tmp += n5;
      a_j0k1 = *tmp;
      a_j1k1 = *(tmp + 1);
      tmp += n5;
      a_j0k2 = *tmp;
      a_j1k2 = *(tmp + 1);
      tmp += n5;
      a_j0k3 = *tmp;
      a_j1k3 = *(tmp + 1);
      dest0 = &C[n4 * j];
      dest1 = dest0 + n4;
      last = dest0 + n3;
      b0 = &B[n3 * k];
      b1 = b0 + n3;
      b2 = b1 + n3;
      b3 = b2 + n3;
      while (dest0 != last) {
        t0 = *dest0;
        t1 = *dest1;
        tmp0 = *b0++;
        t0 -= a_j0k0 * tmp0;
        t1 -= a_j1k0 * tmp0;
        tmp1 = *b1++;
        t0 -= a_j0k1 * tmp1;
        t1 -= a_j1k1 * tmp1;
        tmp0 = *b2++;
        t0 -= a_j0k2 * tmp0;
        t1 -= a_j1k2 * tmp0;
        tmp1 = *b3++;
        t0 -= a_j0k3 * tmp1;
        t1 -= a_j1k3 * tmp1;
        *dest0++ = t0;
        *dest1++ = t1;
      }
    }
    for (; k < n2; k++) {
      a_j0k0 = A[j + n5 * k];
      a_j1k0 = A[j + 1 + n5 * k];
      for (i = 0; i < n3; i++) {
        t0 = B[i + n3 * k];
        C[i + n4 * j] -= a_j0k0 * t0;
        C[i + n4 * (j + 1)] -= a_j1k0 * t0;
      }
    }
  }
  for (; j < n1; j++) {
    for (k = 0; k < n2 - 3; k += 4) {
      tmp = &A[j + n5 * k];
      a_j0k0 = *tmp;
      tmp += n5;
      a_j0k1 = *tmp;
      tmp += n5;
      a_j0k2 = *tmp;
      tmp += n5;
      a_j0k3 = *tmp;
      tmp += n5;
      b0 = &B[n3 * k];
      b1 = b0 + n3;
      b2 = b1 + n3;
      b3 = b2 + n3;
      dest0 = &C[n4 * j];
      last = dest0 + n3;
      while (dest0 != last) {
        t0 = *dest0;
        t0 -= a_j0k0 * (*b0++);
        t0 -= a_j0k1 * (*b1++);
        t0 -= a_j0k2 * (*b2++);
        t0 -= a_j0k3 * (*b3++);
        *dest0++ = t0;
      }
    }
    for (; k < n2; k++) {
      a_j0k0 = A[j + n5 * k];
      for (i = 0; i < n3; i++)
        C[i + n4 * j] -= a_j0k0 * B[i + n3 * k];
    }
  }
}


x86 assembly (clang, -O0):
<OneMatmat>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc8,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    2005 <OneMatmat+0xf05>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x7,%rcx
cmp    %rcx,%rax
jge    19d5 <OneMatmat+0x8d5>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x110(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x120(%rbp),%rax
je     19bf <OneMatmat+0x8bf>
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xf0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xf8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xf8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x100(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x100(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x108(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x108(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x110(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x118(%rbp)
movsd  %xmm0,(%rax)
jmp    145b <OneMatmat+0x35b>
jmp    19c4 <OneMatmat+0x8c4>
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
jmp    1150 <OneMatmat+0x50>
jmp    19da <OneMatmat+0x8da>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
jge    1e9d <OneMatmat+0xd9d>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x128(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x118(%rbp)
mov    -0x110(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x120(%rbp),%rax
je     1e87 <OneMatmat+0xd87>
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x118(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x110(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x118(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x118(%rbp)
movsd  %xmm0,(%rax)
jmp    1b96 <OneMatmat+0xa96>
jmp    1e8c <OneMatmat+0xd8c>
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
jmp    19da <OneMatmat+0x8da>
jmp    1ea2 <OneMatmat+0xda2>
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1fef <OneMatmat+0xeef>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0x1,%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1fd9 <OneMatmat+0xed9>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x130(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    0x10(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    0x10(%rbp),%rdx
mov    -0x40(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1efb <OneMatmat+0xdfb>
jmp    1fde <OneMatmat+0xede>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1ea2 <OneMatmat+0xda2>
jmp    1ff4 <OneMatmat+0xef4>
mov    -0x40(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x40(%rbp)
jmp    1133 <OneMatmat+0x33>
jmp    200a <OneMatmat+0xf0a>
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    23ff <OneMatmat+0x12ff>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
jge    2320 <OneMatmat+0x1220>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x120(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x120(%rbp),%rax
je     230a <OneMatmat+0x120a>
mov    -0x110(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  (%rax),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0xe0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe0(%rbp)
movsd  (%rax),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mov    -0xe8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xe8(%rbp)
movsd  (%rax),%xmm2
movsd  -0x130(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x110(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x110(%rbp)
movsd  %xmm0,(%rax)
jmp    2189 <OneMatmat+0x1089>
jmp    230f <OneMatmat+0x120f>
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
jmp    2020 <OneMatmat+0xf20>
jmp    2325 <OneMatmat+0x1225>
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    23e9 <OneMatmat+0x12e9>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    0x18(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    23d3 <OneMatmat+0x12d3>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    0x10(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    2359 <OneMatmat+0x1259>
jmp    23d8 <OneMatmat+0x12d8>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    2325 <OneMatmat+0x1225>
jmp    23ee <OneMatmat+0x12ee>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    200a <OneMatmat+0xf0a>
add    $0xc8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<OneMatmat>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    0x160(%rsp),%rax
cmp    $0x2,%rcx
mov    %r8,-0x18(%rsp)
mov    %rcx,0xb0(%rsp)
mov    %rdx,-0x48(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rdi,-0x68(%rsp)
jl     1963 <OneMatmat+0x863>
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x28(%rsp)
lea    -0x7(%r8),%rcx
mov    %rcx,-0x20(%rsp)
lea    -0x3(%r8),%rcx
mov    %rcx,-0x50(%rsp)
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x18(%rsp)
lea    (%rax,%r9,1),%rcx
mov    %rcx,-0x40(%rsp)
lea    -0x2(%r9),%rcx
mov    %rcx,-0x28(%rsp)
mov    %rcx,%rbp
shr    %rbp
add    $0x1,%rbp
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x70(%rsp)
mov    %rbp,%rcx
mov    %rbp,0x40(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x30(%rsp)
lea    (%rdx,%rax,8),%rcx
shl    $0x4,%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%r9,8),%r13
mov    %r9,%rax
shl    $0x6,%rax
mov    %rax,0x50(%rsp)
mov    %r9,%rax
shl    $0x5,%rax
mov    %rax,0x48(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,0x10(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,-0x30(%rsp)
xor    %eax,%eax
mov    %rax,-0x38(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
jmp    122c <OneMatmat+0x12c>
nopl   0x0(%rax,%rax,1)
mov    -0x78(%rsp),%rdi
add    $0x2,%rdi
addq   $0x1,-0x38(%rsp)
mov    0x20(%rsp),%rax
add    %rax,%rcx
add    %rax,%rdx
add    %rax,-0x30(%rsp)
mov    %rdi,%rax
mov    %rdi,-0x78(%rsp)
cmp    0x28(%rsp),%rdi
mov    -0x18(%rsp),%r8
mov    -0x68(%rsp),%rdi
jge    196a <OneMatmat+0x86a>
cmp    $0x8,%r8
jl     14c0 <OneMatmat+0x3c0>
mov    %rdi,%rbx
xor    %r12d,%r12d
jmp    1254 <OneMatmat+0x154>
xchg   %ax,%ax
add    $0x8,%r12
add    0x50(%rsp),%rbx
cmp    -0x20(%rsp),%r12
jge    14c3 <OneMatmat+0x3c3>
test   %r9,%r9
je     1240 <OneMatmat+0x140>
mov    %r12,%rax
mov    0x168(%rsp),%r14
imul   %r14,%rax
add    -0x78(%rsp),%rax
lea    (%rsi,%rax,8),%rdi
lea    (%rdi,%r14,8),%rbp
lea    0x0(,%r14,8),%rax
add    %rbp,%rax
lea    (%rax,%r14,8),%r15
lea    (%r15,%r14,8),%r11
lea    (%r11,%r14,8),%r10
lea    (%r10,%r14,8),%r8
movsd  (%rdi),%xmm0
movsd  0x8(%rdi),%xmm2
movapd 0x1d5f(%rip),%xmm1
xorpd  %xmm1,%xmm0
movapd %xmm0,-0x60(%rsp)
xorpd  %xmm1,%xmm2
movapd %xmm2,-0x10(%rsp)
movsd  (%rdi,%r14,8),%xmm0
movsd  0x8(%rdi,%r14,8),%xmm2
xorpd  %xmm1,%xmm0
movapd %xmm0,0xa0(%rsp)
xorpd  %xmm1,%xmm2
movapd %xmm2,0x90(%rsp)
movsd  0x0(%rbp,%r14,8),%xmm0
movsd  0x8(%rbp,%r14,8),%xmm2
xorpd  %xmm1,%xmm0
movapd %xmm0,0x80(%rsp)
xorpd  %xmm1,%xmm2
movapd %xmm2,0x70(%rsp)
movsd  (%rax,%r14,8),%xmm0
movsd  0x8(%rax,%r14,8),%xmm2
xorpd  %xmm1,%xmm0
movapd %xmm0,0x60(%rsp)
xorpd  %xmm1,%xmm2
movapd %xmm2,(%rsp)
movsd  (%r15,%r14,8),%xmm15
movsd  0x8(%r15,%r14,8),%xmm14
xorpd  %xmm1,%xmm15
xorpd  %xmm1,%xmm14
movsd  (%r11,%r14,8),%xmm4
movsd  0x8(%r11,%r14,8),%xmm13
xorpd  %xmm1,%xmm4
xorpd  %xmm1,%xmm13
movsd  (%r10,%r14,8),%xmm6
movsd  0x8(%r10,%r14,8),%xmm5
xorpd  %xmm1,%xmm6
xorpd  %xmm1,%xmm5
movsd  (%r8,%r14,8),%xmm0
movsd  0x8(%r8,%r14,8),%xmm8
xorpd  %xmm1,%xmm0
xorpd  %xmm1,%xmm8
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rdi,1),%rbp
movsd  (%rbx,%rdi,1),%xmm9
movapd -0x60(%rsp),%xmm10
mulsd  %xmm9,%xmm10
addsd  (%rdx,%rdi,1),%xmm10
mulsd  -0x10(%rsp),%xmm9
addsd  (%rcx,%rdi,1),%xmm9
movsd  0x0(%r13,%rbp,1),%xmm11
add    %r13,%rbp
movapd 0xa0(%rsp),%xmm12
mulsd  %xmm11,%xmm12
addsd  %xmm10,%xmm12
mulsd  0x90(%rsp),%xmm11
addsd  %xmm9,%xmm11
movsd  0x0(%r13,%rbp,1),%xmm7
add    %r13,%rbp
movapd 0x80(%rsp),%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm12,%xmm1
mulsd  0x70(%rsp),%xmm7
addsd  %xmm11,%xmm7
movsd  0x0(%r13,%rbp,1),%xmm2
add    %r13,%rbp
movapd 0x60(%rsp),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
mulsd  (%rsp),%xmm2
addsd  %xmm7,%xmm2
movsd  0x0(%r13,%rbp,1),%xmm1
add    %r13,%rbp
movapd %xmm15,%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm14,%xmm1
addsd  %xmm2,%xmm1
movsd  0x0(%r13,%rbp,1),%xmm2
add    %r13,%rbp
movapd %xmm4,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm13,%xmm2
addsd  %xmm1,%xmm2
movsd  0x0(%r13,%rbp,1),%xmm1
add    %r13,%rbp
movapd %xmm6,%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm3,%xmm7
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
movsd  0x0(%r13,%rbp,1),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm8,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm3,(%rdx,%rdi,1)
movsd  %xmm2,(%rcx,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%r13
jne    1380 <OneMatmat+0x280>
jmp    1240 <OneMatmat+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %r12d,%r12d
cmp    -0x50(%rsp),%r12
jge    1660 <OneMatmat+0x560>
lea    0x18(,%r12,8),%r11
imul   %r9,%r11
mov    -0x68(%rsp),%rbx
add    %rbx,%r11
lea    0x10(,%r12,8),%rdi
imul   %r9,%rdi
add    %rbx,%rdi
lea    0x8(,%r12,8),%rbp
imul   %r9,%rbp
add    %rbx,%rbp
mov    %r9,%rax
imul   %r12,%rax
lea    (%rbx,%rax,8),%rbx
movapd 0x1aec(%rip),%xmm12
jmp    1540 <OneMatmat+0x440>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%r12
mov    0x48(%rsp),%rax
add    %rax,%r11
add    %rax,%rdi
add    %rax,%rbp
add    %rax,%rbx
cmp    -0x50(%rsp),%r12
jge    1669 <OneMatmat+0x569>
test   %r9,%r9
je     1520 <OneMatmat+0x420>
mov    %r12,%rax
mov    0x168(%rsp),%r14
imul   %r14,%rax
add    -0x78(%rsp),%rax
lea    (%rsi,%rax,8),%rax
lea    (%rax,%r14,8),%r8
lea    (%r8,%r14,8),%r10
movsd  (%rax),%xmm9
movsd  0x8(%rax),%xmm8
xorpd  %xmm12,%xmm9
xorpd  %xmm12,%xmm8
movsd  (%rax,%r14,8),%xmm10
movsd  0x8(%rax,%r14,8),%xmm11
xorpd  %xmm12,%xmm10
xorpd  %xmm12,%xmm11
movsd  (%r8,%r14,8),%xmm4
movsd  0x8(%r8,%r14,8),%xmm5
xorpd  %xmm12,%xmm4
xorpd  %xmm12,%xmm5
movsd  (%r10,%r14,8),%xmm6
movsd  0x8(%r10,%r14,8),%xmm7
xorpd  %xmm12,%xmm6
xorpd  %xmm12,%xmm7
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,1),%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rdx,%rax,1),%xmm0
mulsd  %xmm8,%xmm1
addsd  (%rcx,%rax,1),%xmm1
movsd  0x0(%rbp,%rax,1),%xmm2
movapd %xmm10,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movsd  (%rdi,%rax,1),%xmm0
movapd %xmm4,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movsd  (%r11,%rax,1),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm7,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm3,(%rdx,%rax,1)
movsd  %xmm2,(%rcx,%rax,1)
add    $0x8,%rax
cmp    %rax,%r13
jne    15d0 <OneMatmat+0x4d0>
jmp    1520 <OneMatmat+0x420>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd 0x1997(%rip),%xmm12
cmp    -0x18(%rsp),%r12
jge    11f0 <OneMatmat+0xf0>
mov    0x18(%rsp),%rax
imul   -0x38(%rsp),%rax
lea    (%rax,%r9,1),%r8
mov    0x160(%rsp),%rdi
add    %rax,%rdi
mov    -0x40(%rsp),%rbp
lea    0x0(%rbp,%rax,1),%r10
mov    -0x48(%rsp),%rbx
lea    (%rbx,%rax,8),%r15
lea    (%rbx,%r8,8),%r8
lea    (%rbx,%rdi,8),%rbp
mov    0x160(%rsp),%r11
lea    (%rbx,%r10,8),%rbx
mov    -0x78(%rsp),%rax
mov    %rax,%rdi
or     $0x1,%rdi
imul   %r11,%rax
mov    %rax,(%rsp)
mov    %rdi,%r14
imul   %r11,%rdi
mov    %rdi,0x38(%rsp)
mov    %r12,%rdi
imul   %r9,%rdi
lea    0x8(,%r12,8),%rax
imul   %r9,%rax
mov    %rax,0x70(%rsp)
mov    %rbx,0xa0(%rsp)
mov    %r15,0x90(%rsp)
cmp    %rbx,%r15
setb   %al
mov    %r8,-0x60(%rsp)
mov    %rbp,-0x10(%rsp)
cmp    %r8,%rbp
setb   %bl
and    %al,%bl
mov    %bl,0x60(%rsp)
mov    0x10(%rsp),%rax
lea    (%rax,%rdi,8),%r8
mov    -0x68(%rsp),%rax
mov    %rdi,0x80(%rsp)
lea    (%rax,%rdi,8),%rbx
xor    %r10d,%r10d
jmp    1759 <OneMatmat+0x659>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x1,%r10
add    %r13,%r8
add    %r13,%rbx
cmp    -0x18(%rsp),%r12
je     11f0 <OneMatmat+0xf0>
test   %r9,%r9
jle    1740 <OneMatmat+0x640>
mov    %r12,%rax
imul   0x168(%rsp),%rax
lea    (%rax,%r14,1),%rbp
add    -0x78(%rsp),%rax
movsd  (%rsi,%rax,8),%xmm1
xorpd  %xmm12,%xmm1
movsd  (%rsi,%rbp,8),%xmm2
xorpd  %xmm12,%xmm2
cmp    $0x1,%r9
jne    17a0 <OneMatmat+0x6a0>
xor    %eax,%eax
jmp    1930 <OneMatmat+0x830>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r10,%rax
imul   %r9,%rax
mov    0x80(%rsp),%rdi
lea    (%rdi,%rax,1),%r15
mov    -0x68(%rsp),%rbp
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
add    0x70(%rsp),%rdi
cmp    0x90(%rsp),%rdi
seta   %r11b
lea    0x0(%rbp,%r15,8),%rbp
cmp    -0x60(%rsp),%rbp
setb   %al
and    %r11b,%al
or     0x60(%rsp),%al
cmp    -0x10(%rsp),%rdi
seta   %r15b
cmp    0xa0(%rsp),%rbp
setb   %r11b
test   %al,%al
jne    1837 <OneMatmat+0x737>
mov    $0x0,%eax
and    %r11b,%r15b
mov    0x160(%rsp),%rdi
jne    1930 <OneMatmat+0x830>
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
cmpq   $0x2,-0x28(%rsp)
jae    183e <OneMatmat+0x73e>
xor    %r11d,%r11d
jmp    18c4 <OneMatmat+0x7c4>
xor    %eax,%eax
jmp    1930 <OneMatmat+0x830>
mov    0x30(%rsp),%rsi
mov    -0x30(%rsp),%r15
mov    %r8,%rbp
xor    %r11d,%r11d
xchg   %ax,%ax
movupd -0x10(%rbp),%xmm4
movupd -0x10(%r15),%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,-0x10(%r15)
movupd -0x10(%r15,%rdi,8),%xmm5
mulpd  %xmm0,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%r15,%rdi,8)
movupd 0x0(%rbp),%xmm4
movupd (%r15),%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r15)
movupd (%r15,%rdi,8),%xmm5
mulpd  %xmm0,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r15,%rdi,8)
add    $0x4,%r11
add    $0x20,%rbp
add    $0x20,%r15
add    $0xfffffffffffffffe,%rsi
jne    1850 <OneMatmat+0x750>
testb  $0x1,0x40(%rsp)
mov    0x58(%rsp),%rsi
je     191b <OneMatmat+0x81b>
mov    %r12,%rax
imul   %r9,%rax
add    %r11,%rax
mov    -0x68(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm4
mov    (%rsp),%rax
add    %r11,%rax
mov    -0x48(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm5
mulpd  %xmm4,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm3,(%rdi,%rax,8)
add    0x38(%rsp),%r11
movupd (%rdi,%r11,8),%xmm3
mulpd  %xmm4,%xmm0
addpd  %xmm3,%xmm0
movupd %xmm0,(%rdi,%r11,8)
mov    -0x70(%rsp),%rdi
mov    %rdi,%rax
cmp    %r9,%rdi
je     1740 <OneMatmat+0x640>
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
addsd  (%rdx,%rax,8),%xmm3
movsd  %xmm3,(%rdx,%rax,8)
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1930 <OneMatmat+0x830>
jmp    1740 <OneMatmat+0x640>
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
mov    -0x78(%rsp),%rax
cmp    0xb0(%rsp),%rax
mov    -0x48(%rsp),%r14
jge    2106 <OneMatmat+0x1006>
lea    -0x3(%r8),%rax
mov    %rax,0xa0(%rsp)
mov    -0x78(%rsp),%rdx
mov    0x160(%rsp),%rcx
imul   %rcx,%rdx
lea    (%rdx,%r9,1),%rax
mov    %rax,0xd0(%rsp)
lea    -0x1(%r9),%rax
movabs $0x1fffffffffffffff,%rsi
ff ff 1f
and    %rax,%rsi
lea    (%rsi,%rdx,1),%rax
add    $0x1,%rax
mov    %rax,0xc8(%rsp)
lea    (%r9,%r9,2),%rax
lea    0x1(%rsi),%rbp
lea    -0x4(%r9),%rbx
mov    %rbx,0x110(%rsp)
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbp,-0x28(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x40(%rsp)
mov    %r9,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %rbp,0x100(%rsp)
mov    %rbx,%rbp
mov    %rbx,0x108(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xe8(%rsp)
mov    %r9,%rbp
neg    %rbp
mov    %rbp,0x40(%rsp)
mov    %r9,%rbp
shl    $0x5,%rbp
mov    %rbp,0x90(%rsp)
mov    %r9,%rbp
shl    $0x4,%rbp
mov    %rbp,0x120(%rsp)
movapd 0x15b2(%rip),%xmm9
movapd 0x15a9(%rip),%xmm8
lea    0x0(,%r9,4),%rbp
mov    %rbp,-0x38(%rsp)
mov    %rax,0x38(%rsp)
lea    0x1(%rsi,%rax,1),%rax
mov    %rax,0x30(%rsp)
lea    (%r9,%r9,1),%rax
mov    %rax,0x28(%rsp)
lea    0x1(%rsi,%r9,2),%rax
mov    %rax,0x20(%rsp)
mov    %rsi,0x48(%rsp)
lea    0x1(%rsi,%r9,1),%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0x80(%rsp)
lea    (%rax,%rax,2),%rax
mov    %rax,0x118(%rsp)
mov    %rdx,0xe0(%rsp)
lea    (%r14,%rdx,8),%r15
lea    0x0(,%rcx,8),%rax
mov    %rax,0xd8(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,0xc0(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0xb8(%rsp)
xor    %edx,%edx
jmp    1b23 <OneMatmat+0xa23>
nopl   0x0(%rax)
mov    -0x78(%rsp),%rcx
add    $0x1,%rcx
mov    0xf8(%rsp),%rdx
add    $0x1,%rdx
add    0xd8(%rsp),%r15
mov    %rcx,%rax
mov    %rcx,-0x78(%rsp)
cmp    0xb0(%rsp),%rcx
je     2106 <OneMatmat+0x1006>
mov    %rdx,%rsi
mov    0x160(%rsp),%rcx
imul   %rcx,%rsi
mov    0xe0(%rsp),%rax
add    %rsi,%rax
lea    (%r14,%rax,8),%rax
mov    %rax,-0x20(%rsp)
cmp    $0x4,%r8
mov    %rdx,0xf8(%rsp)
mov    %rsi,0xf0(%rsp)
jl     1e90 <OneMatmat+0xd90>
mov    0xc8(%rsp),%rax
add    %rsi,%rax
lea    (%r14,%rax,8),%rax
mov    %rax,-0x30(%rsp)
mov    -0x78(%rsp),%rax
imul   %rcx,%rax
lea    (%r14,%rax,8),%rcx
lea    (%rcx,%r9,8),%r8
mov    -0x40(%rsp),%rax
mov    %rcx,-0x70(%rsp)
lea    (%rcx,%rax,8),%rax
mov    %rax,0x10(%rsp)
mov    %rdi,%r14
xor    %ecx,%ecx
xor    %r12d,%r12d
jmp    1bce <OneMatmat+0xace>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x4,%r12
add    $0x1,%rcx
add    0x90(%rsp),%r14
cmp    0xa0(%rsp),%r12
jge    1e93 <OneMatmat+0xd93>
test   %r9,%r9
je     1bb0 <OneMatmat+0xab0>
mov    %rcx,-0x60(%rsp)
mov    %r14,-0x10(%rsp)
mov    %r12,%rax
mov    0x168(%rsp),%rcx
imul   %rcx,%rax
add    -0x78(%rsp),%rax
mov    %r12,%rdx
imul   %r9,%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
lea    (%rax,%rcx,8),%rdi
lea    (%rdi,%rcx,8),%rsi
mov    -0x68(%rsp),%r14
lea    (%r14,%rdx,8),%rbx
lea    (%rbx,%r9,8),%rbp
lea    0x0(%rbp,%r9,8),%r10
lea    (%r10,%r9,8),%r11
movsd  (%rax),%xmm10
xorpd  %xmm9,%xmm10
movsd  (%rax,%rcx,8),%xmm11
xorpd  %xmm9,%xmm11
movsd  (%rdi,%rcx,8),%xmm1
xorpd  %xmm9,%xmm1
movsd  (%rsi,%rcx,8),%xmm0
xorpd  %xmm9,%xmm0
cmpq   $0x0,0x48(%rsp)
je     1e00 <OneMatmat+0xd00>
mov    %r12,-0x50(%rsp)
mov    -0x38(%rsp),%rdi
imul   -0x60(%rsp),%rdi
mov    0x38(%rsp),%rax
add    %rdi,%rax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdi,1),%rdx
mov    0x28(%rsp),%rcx
lea    (%rcx,%rdi,1),%r13
mov    0x20(%rsp),%rcx
add    %rdi,%rcx
lea    (%r14,%rax,8),%rax
lea    (%r14,%rdx,8),%rdx
mov    -0x20(%rsp),%rsi
cmp    %rdx,%rsi
setb   0x70(%rsp)
mov    -0x30(%rsp),%r12
cmp    %r12,%rax
lea    (%rdi,%r9,1),%rax
mov    %rax,(%rsp)
lea    (%r14,%r13,8),%rdx
lea    (%r14,%rcx,8),%rax
setb   0x60(%rsp)
cmp    %rax,%rsi
setb   %r13b
cmp    %r12,%rdx
mov    0x18(%rsp),%rax
lea    (%rax,%rdi,1),%rax
mov    (%rsp),%rcx
lea    (%r14,%rcx,8),%rdx
lea    (%r14,%rax,8),%rax
setb   (%rsp)
cmp    %rax,%rsi
setb   %al
cmp    %r12,%rdx
mov    -0x28(%rsp),%rcx
lea    (%rcx,%rdi,1),%rdx
lea    (%r14,%rdx,8),%rdx
setb   0x50(%rsp)
cmp    %rdx,%rsi
lea    (%r14,%rdi,8),%rdx
setb   %cl
cmp    %r12,%rdx
setb   %sil
mov    0x60(%rsp),%dl
test   %dl,0x70(%rsp)
jne    1e79 <OneMatmat+0xd79>
and    (%rsp),%r13b
jne    1e79 <OneMatmat+0xd79>
and    0x50(%rsp),%al
mov    -0x50(%rsp),%r12
mov    -0x10(%rsp),%r14
jne    1e0c <OneMatmat+0xd0c>
and    %sil,%cl
jne    1e0c <OneMatmat+0xd0c>
mov    -0x40(%rsp),%rcx
lea    (%r11,%rcx,8),%r11
lea    (%r10,%rcx,8),%r10
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%rbx,%rcx,8),%rbx
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
movapd %xmm11,%xmm7
unpcklpd %xmm11,%xmm7
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
mov    %r14,%rax
xor    %edx,%edx
mov    0x120(%rsp),%rsi
mov    0x118(%rsp),%rdi
nopl   0x0(%rax,%rax,1)
movupd (%r15,%rdx,8),%xmm2
movupd (%rax),%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm2,%xmm3
movupd (%rax,%r9,8),%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm3,%xmm2
movupd (%rax,%rsi,1),%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm2,%xmm3
movupd (%rax,%rdi,1),%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm2,(%r15,%rdx,8)
add    $0x2,%rdx
add    $0x10,%rax
cmp    %rdx,%rcx
jne    1d90 <OneMatmat+0xc90>
mov    0x10(%rsp),%r13
cmp    %rcx,-0x28(%rsp)
mov    -0x60(%rsp),%rcx
je     1bb0 <OneMatmat+0xab0>
jmp    1e16 <OneMatmat+0xd16>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x70(%rsp),%r13
mov    -0x10(%rsp),%r14
jmp    1e11 <OneMatmat+0xd11>
mov    -0x70(%rsp),%r13
mov    -0x60(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,1),%xmm2
mulsd  %xmm10,%xmm2
addsd  0x0(%r13,%rax,1),%xmm2
movsd  0x0(%rbp,%rax,1),%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm2,%xmm3
movsd  (%r10,%rax,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  (%r11,%rax,1),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%r13,%rax,1)
lea    (%rax,%r13,1),%rdx
add    $0x8,%rdx
add    $0x8,%rax
cmp    %r8,%rdx
jne    1e20 <OneMatmat+0xd20>
jmp    1bb0 <OneMatmat+0xab0>
mov    -0x70(%rsp),%r13
mov    -0x50(%rsp),%r12
jmp    1e05 <OneMatmat+0xd05>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r12d,%r12d
mov    -0x18(%rsp),%r8
cmp    %r8,%r12
mov    -0x48(%rsp),%r14
mov    -0x68(%rsp),%rdi
jge    1af0 <OneMatmat+0x9f0>
mov    0xf0(%rsp),%rax
add    0xd0(%rsp),%rax
lea    (%r14,%rax,8),%rax
mov    %rax,-0x60(%rsp)
mov    -0x78(%rsp),%r13
imul   0x160(%rsp),%r13
mov    %r12,%r10
imul   %r9,%r10
lea    0x8(,%r12,8),%r11
imul   %r9,%r11
mov    0xc0(%rsp),%rax
lea    (%rax,%r10,8),%rsi
mov    0xb8(%rsp),%rax
lea    (%rax,%r10,8),%rbx
xor    %ebp,%ebp
jmp    1f2f <OneMatmat+0xe2f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x1,%rbp
mov    0x80(%rsp),%rax
add    %rax,%rsi
add    %rax,%rbx
cmp    %r8,%r12
je     1af0 <OneMatmat+0x9f0>
test   %r9,%r9
jle    1f10 <OneMatmat+0xe10>
mov    %r12,%rax
imul   0x168(%rsp),%rax
add    -0x78(%rsp),%rax
mov    %r12,%rcx
imul   %r9,%rcx
mov    0x58(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm2
xorpd  %xmm8,%xmm2
cmp    $0x4,%r9
jb     1f8c <OneMatmat+0xe8c>
mov    %rbp,%rax
imul   %r9,%rax
lea    (%rdi,%rax,8),%rdx
add    %r11,%rdx
cmp    -0x20(%rsp),%rdx
jbe    200b <OneMatmat+0xf0b>
add    %r10,%rax
lea    (%rdi,%rax,8),%rax
cmp    -0x60(%rsp),%rax
jae    200b <OneMatmat+0xf0b>
xor    %edx,%edx
mov    %rdx,%rax
test   $0x1,%r9b
je     1fba <OneMatmat+0xeba>
add    %rdx,%rcx
lea    (%rdx,%r13,1),%rax
movsd  (%rdi,%rcx,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x1,%rax
not    %rdx
cmp    0x40(%rsp),%rdx
je     1f10 <OneMatmat+0xe10>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1fd0 <OneMatmat+0xed0>
jmp    1f10 <OneMatmat+0xe10>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
cmpq   $0x4,0x110(%rsp)
jae    2025 <OneMatmat+0xf25>
xor    %edx,%edx
jmp    20a7 <OneMatmat+0xfa7>
mov    0xe8(%rsp),%rax
xor    %edx,%edx
nop
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm0
movupd (%r15,%rdx,8),%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%r15,%rdx,8),%xmm0
movupd 0x20(%r15,%rdx,8),%xmm5
movupd 0x30(%r15,%rdx,8),%xmm6
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm4,(%r15,%rdx,8)
movupd %xmm1,0x10(%r15,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
mulpd  %xmm3,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm0,0x20(%r15,%rdx,8)
movupd %xmm1,0x30(%r15,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    2030 <OneMatmat+0xf30>
testb  $0x1,0x108(%rsp)
01
je     20ed <OneMatmat+0xfed>
lea    (%rdx,%rcx,1),%rax
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
add    %r13,%rdx
movupd (%r14,%rdx,8),%xmm4
movupd 0x10(%r14,%rdx,8),%xmm5
mulpd  %xmm3,%xmm0
addpd  %xmm4,%xmm0
mulpd  %xmm3,%xmm1
addpd  %xmm5,%xmm1
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
mov    0x100(%rsp),%rax
mov    %rax,%rdx
cmp    %r9,%rax
je     1f10 <OneMatmat+0xe10>
jmp    1f8e <OneMatmat+0xe8e>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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