void OneLower(double *A, double *C, long n1, long n2, long n3) {
  long i, j, k;
  double *tmp;
  double a_j0k0, a_j0k1, a_j0k2, a_j0k3;
  double a_j1k0, a_j1k1, a_j1k2, a_j1k3;
  double *b0, *b1, *b2, *b3;
  double t0, t1, tmp0, tmp1;
  double *dest0, *dest1, *last;
  for (j = 0; j < n1 - 1; j += 2) {
    for (k = 0; k < n2 - 3; k += 4) {
      tmp = &A[j + n1 * k];
      a_j0k0 = *tmp;
      a_j1k0 = *(tmp + 1);
      tmp += n1;
      a_j0k1 = *tmp;
      a_j1k1 = *(tmp + 1);
      tmp += n1;
      a_j0k2 = *tmp;
      a_j1k2 = *(tmp + 1);
      tmp += n1;
      a_j0k3 = *tmp;
      a_j1k3 = *(tmp + 1);
      b0 = &A[j + n1 * k];
      b1 = b0 + n1;
      b2 = b1 + n1;
      b3 = b2 + n1;
      dest0 = &C[j + n3 * j];
      last = dest0 + n1 - j;
      *dest0++ -=
          a_j0k0 * *b0++ + a_j0k1 * *b1++ + a_j0k2 * *b2++ + a_j0k3 * *b3++;
      dest1 = dest0 + 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 + n1 * k];
      a_j1k0 = A[j + 1 + n1 * k];
      C[j + n3 * j] -= a_j0k0 * A[j + n1 * k];
      for (i = j + 1; i < n1; i++) {
        C[i + n3 * j] -= a_j0k0 * A[i + n1 * k];
        C[i + n3 * (j + 1)] -= a_j1k0 * A[i + n1 * k];
      }
    }
  }
  for (; j < n1; j++)
    for (k = 0; k < n2; k++) {
      a_j0k0 = A[j + n1 * k];
      for (i = j; i < n1; i++)
        C[i + n3 * j] -= a_j0k0 * A[i + n1 * k];
    }
}


x86 assembly (clang, -O0):
<OneLower>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1853 <OneLower+0x753>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
jge    1691 <OneLower+0x591>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
xor    %ecx,%ecx
sub    -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
movsd  -0x50(%rbp),%xmm1
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm2
movsd  -0x58(%rbp),%xmm0
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x98(%rbp)
mulsd  (%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa0(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm1
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa8(%rbp)
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0xd0(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd0(%rbp),%rax
cmp    -0xe0(%rbp),%rax
je     167b <OneLower+0x57b>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x98(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa8(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd0(%rbp)
movsd  %xmm0,(%rax)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0xd8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xd8(%rbp)
movsd  %xmm0,(%rax)
jmp    1393 <OneLower+0x293>
jmp    1680 <OneLower+0x580>
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
jmp    1141 <OneLower+0x41>
jmp    1696 <OneLower+0x596>
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    183d <OneLower+0x73d>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%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,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1827 <OneLower+0x727>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%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  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    -0x38(%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    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    174b <OneLower+0x64b>
jmp    182c <OneLower+0x72c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1696 <OneLower+0x596>
jmp    1842 <OneLower+0x742>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    1124 <OneLower+0x24>
jmp    1858 <OneLower+0x758>
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1948 <OneLower+0x848>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1932 <OneLower+0x832>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    191c <OneLower+0x81c>
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%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    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    18a2 <OneLower+0x7a2>
jmp    1921 <OneLower+0x821>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    186e <OneLower+0x76e>
jmp    1937 <OneLower+0x837>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1858 <OneLower+0x758>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<OneLower>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
cmp    $0x2,%rdx
mov    %rcx,-0x38(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %r8,-0x30(%rsp)
jl     16fb <OneLower+0x5fb>
lea    -0x1(%rdx),%rbx
lea    -0x3(%rcx),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rsi),%r12
mov    %r8,%rax
shl    $0x4,%rax
mov    %rax,0x68(%rsp)
add    $0x10,%rax
mov    %rax,0x28(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,0x58(%rsp)
lea    0x8(%rsi,%r8,8),%r11
lea    (%r8,%rdx,1),%rax
mov    %rax,0x48(%rsp)
lea    0x8(%rdi),%r10
mov    %rdx,%rax
shl    $0x5,%rax
mov    %rax,-0x48(%rsp)
lea    (%rdi,%rdx,8),%rbp
add    $0x8,%rbp
mov    %rdx,%rax
shl    $0x4,%rax
lea    (%rax,%rdi,1),%r9
add    $0x8,%r9
lea    (%rdx,%rdx,2),%rax
lea    0x8(%rdi,%rax,8),%rdi
lea    0x0(,%rdx,8),%rax
mov    %rax,(%rsp)
lea    -0x8(,%rdx,8),%rax
ff
mov    %rax,-0x40(%rsp)
movapd 0xe42(%rip),%xmm9
movapd 0xe39(%rip),%xmm8
lea    0x0(,%r8,8),%rax
mov    %rax,0x40(%rsp)
lea    (%rsi,%r8,8),%r14
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    %rsi,%r8
mov    %r9,%rsi
mov    %rbx,0x30(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r12,0x60(%rsp)
mov    %r11,0x50(%rsp)
xor    %eax,%eax
mov    %rax,-0x80(%rsp)
jmp    1280 <OneLower+0x180>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x80(%rsp),%rcx
add    $0x2,%rcx
addq   $0x1,0x20(%rsp)
mov    0x38(%rsp),%r10
add    $0x10,%r10
mov    0x80(%rsp),%rbp
add    $0x10,%rbp
mov    0x78(%rsp),%rsi
add    $0x10,%rsi
mov    0x70(%rsp),%rdi
add    $0x10,%rdi
mov    0x28(%rsp),%rax
add    %rax,%r11
add    %rax,%r12
addq   $0xfffffffffffffff0,-0x40(%rsp)
addq   $0xfffffffffffffffe,0x18(%rsp)
mov    0x68(%rsp),%rax
add    %rax,%r14
add    %rax,%r8
mov    %rcx,%rax
mov    %rcx,-0x80(%rsp)
cmp    0x30(%rsp),%rcx
mov    -0x38(%rsp),%rcx
jge    1702 <OneLower+0x602>
cmp    $0x4,%rcx
mov    -0x78(%rsp),%r13
mov    %r10,0x38(%rsp)
mov    %rbp,0x80(%rsp)
mov    %rsi,0x78(%rsp)
mov    %rdi,0x70(%rsp)
jl     1450 <OneLower+0x350>
mov    -0x80(%rsp),%rax
mov    %rax,%r15
imul   -0x30(%rsp),%r15
add    %rax,%r15
mov    %rdx,%r9
sub    %rax,%r9
mov    %rdi,%rbx
mov    %rsi,%rcx
mov    %rbp,%rax
mov    %r10,%rbp
xor    %r10d,%r10d
jmp    12f0 <OneLower+0x1f0>
xchg   %ax,%ax
add    $0x4,%r10
mov    -0x48(%rsp),%rsi
add    %rsi,%rbp
add    %rsi,%rax
add    %rsi,%rcx
add    %rsi,%rbx
cmp    0x8(%rsp),%r10
jge    1453 <OneLower+0x353>
mov    %r10,%rdi
imul   %rdx,%rdi
add    -0x80(%rsp),%rdi
lea    0x0(,%rdi,8),%rsi
add    %r13,%rsi
movsd  0x0(%r13,%rdi,8),%xmm14
movsd  0x8(%r13,%rdi,8),%xmm11
lea    (%rsi,%rdx,8),%rdi
movsd  (%rsi,%rdx,8),%xmm3
movsd  0x8(%rsi,%rdx,8),%xmm12
lea    (%rdi,%rdx,8),%rsi
movsd  (%rdi,%rdx,8),%xmm5
movsd  0x8(%rdi,%rdx,8),%xmm13
movsd  (%rsi,%rdx,8),%xmm1
movsd  0x8(%rsi,%rdx,8),%xmm0
movapd %xmm3,%xmm10
mulsd  %xmm3,%xmm10
movapd %xmm14,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm10,%xmm2
movapd %xmm5,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm2,%xmm6
movapd %xmm1,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm6,%xmm2
mov    -0x68(%rsp),%rsi
movsd  (%rsi,%r15,8),%xmm6
subsd  %xmm2,%xmm6
movsd  %xmm6,(%rsi,%r15,8)
cmp    $0x1,%r9
mov    -0x40(%rsp),%rsi
je     12d0 <OneLower+0x1d0>
xorpd  %xmm9,%xmm14
xorpd  %xmm9,%xmm11
xorpd  %xmm9,%xmm3
xorpd  %xmm9,%xmm12
xorpd  %xmm9,%xmm5
xorpd  %xmm9,%xmm13
xorpd  %xmm9,%xmm1
xorpd  %xmm9,%xmm0
xor    %edi,%edi
nop
movsd  0x0(%rbp,%rdi,1),%xmm2
movapd %xmm14,%xmm6
mulsd  %xmm2,%xmm6
addsd  (%r12,%rdi,1),%xmm6
mulsd  %xmm11,%xmm2
addsd  (%r11,%rdi,1),%xmm2
movsd  (%rax,%rdi,1),%xmm7
movapd %xmm3,%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm12,%xmm7
addsd  %xmm2,%xmm7
movsd  (%rcx,%rdi,1),%xmm2
movapd %xmm5,%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm13,%xmm2
addsd  %xmm7,%xmm2
movsd  (%rbx,%rdi,1),%xmm4
movapd %xmm1,%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
mulsd  %xmm0,%xmm4
addsd  %xmm2,%xmm4
movsd  %xmm7,(%r12,%rdi,1)
movsd  %xmm4,(%r11,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rsi
jne    13c0 <OneLower+0x2c0>
jmp    12d0 <OneLower+0x1d0>
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
cmp    -0x38(%rsp),%r10
jge    1210 <OneLower+0x110>
mov    0x58(%rsp),%rcx
mov    0x20(%rsp),%rsi
imul   %rsi,%rcx
lea    (%rsi,%rsi,1),%rax
mov    0x28(%rsp),%rdi
imul   %rsi,%rdi
mov    0x48(%rsp),%rsi
add    %rcx,%rsi
mov    %rsi,-0x70(%rsp)
add    %rdx,%rcx
mov    0x18(%rsp),%rbp
and    $0xfffffffffffffffe,%rbp
mov    0x30(%rsp),%r13
sub    %rax,%r13
mov    0x60(%rsp),%rax
lea    (%rax,%rdi,1),%r15
add    0x50(%rsp),%rdi
mov    -0x80(%rsp),%rbx
mov    %rbx,%rax
or     $0x1,%rax
mov    -0x68(%rsp),%rsi
lea    (%rsi,%rcx,8),%r9
mov    -0x70(%rsp),%rcx
lea    (%rsi,%rcx,8),%rsi
mov    %rbx,%rcx
imul   -0x30(%rsp),%rcx
add    %rbx,%rcx
mov    %rcx,0x10(%rsp)
mov    %r10,%rcx
imul   %rdx,%rcx
lea    (%rax,%rcx,1),%rbx
mov    %rbx,-0x18(%rsp)
lea    0x1(%r10),%rbx
imul   %rdx,%rbx
mov    %rbx,-0x20(%rsp)
mov    %r15,-0x58(%rsp)
mov    %rsi,-0x10(%rsp)
cmp    %rsi,%r15
setb   %sil
mov    %rdi,-0x50(%rsp)
mov    %r9,-0x8(%rsp)
cmp    %r9,%rdi
setb   %bl
and    %sil,%bl
mov    %bl,-0x28(%rsp)
mov    %r13,-0x60(%rsp)
and    $0xfffffffffffffffe,%r13
mov    %rax,-0x70(%rsp)
mov    %r13,0x90(%rsp)
add    %r13,%rax
mov    %rax,0x88(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rcx,8),%rbx
mov    -0x78(%rsp),%rax
lea    (%rax,%rcx,8),%r9
mov    0x40(%rsp),%rax
lea    (%r12,%rax,1),%r15
xor    %r13d,%r13d
jmp    157d <OneLower+0x47d>
nopl   (%rax)
add    $0x1,%r10
add    $0x1,%r13
mov    (%rsp),%rax
add    %rax,%rbx
add    %rax,%r9
cmp    -0x38(%rsp),%r10
je     1210 <OneLower+0x110>
mov    %r10,%rcx
imul   %rdx,%rcx
mov    -0x80(%rsp),%rax
lea    (%rcx,%rax,1),%rsi
mov    -0x70(%rsp),%rdi
add    %rdi,%rcx
mov    -0x78(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm2
movsd  (%rax,%rcx,8),%xmm3
mov    -0x68(%rsp),%rax
mov    0x10(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movapd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmp    %rdx,%rdi
jge    1560 <OneLower+0x460>
xorpd  %xmm8,%xmm2
xorpd  %xmm8,%xmm3
mov    -0x70(%rsp),%rdi
cmpq   $0x2,-0x60(%rsp)
jae    1620 <OneLower+0x520>
movsd  (%r9,%rdi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%r8,%rdi,8),%xmm0
movsd  %xmm0,(%r8,%rdi,8)
movsd  (%r9,%rdi,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%r14,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
add    $0x1,%rdi
cmp    %rdx,%rdi
jl     15e0 <OneLower+0x4e0>
jmp    1560 <OneLower+0x460>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rcx
imul   %rdx,%rcx
mov    -0x18(%rsp),%rax
lea    (%rax,%rcx,1),%rsi
add    -0x20(%rsp),%rcx
mov    -0x78(%rsp),%rax
lea    (%rax,%rsi,8),%rsi
lea    (%rax,%rcx,8),%rcx
cmp    %rcx,-0x58(%rsp)
setb   %dil
cmp    -0x8(%rsp),%rsi
setb   %al
and    %dil,%al
or     -0x28(%rsp),%al
cmp    %rcx,-0x50(%rsp)
setb   %cl
cmp    -0x10(%rsp),%rsi
setb   %sil
mov    -0x70(%rsp),%rdi
test   %al,%al
jne    15e0 <OneLower+0x4e0>
mov    -0x70(%rsp),%rdi
and    %sil,%cl
jne    15e0 <OneLower+0x4e0>
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rdi,8),%xmm4
mulpd  %xmm0,%xmm4
movupd (%r12,%rdi,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r12,%rdi,8)
movupd (%rbx,%rdi,8),%xmm4
mulpd  %xmm1,%xmm4
movupd (%r15,%rdi,8),%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r15,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbp
jne    16a0 <OneLower+0x5a0>
mov    0x88(%rsp),%rdi
mov    0x90(%rsp),%rax
cmp    %rax,-0x60(%rsp)
jne    15e0 <OneLower+0x4e0>
jmp    1560 <OneLower+0x460>
xor    %eax,%eax
mov    %rax,-0x80(%rsp)
cmp    %rdx,-0x80(%rsp)
jge    1984 <OneLower+0x884>
mov    -0x30(%rsp),%rdi
lea    0x1(%rdi),%rax
mov    -0x80(%rsp),%r11
imul   %r11,%rax
mov    -0x68(%rsp),%rbx
lea    (%rbx,%rax,8),%rsi
mov    %rsi,-0x18(%rsp)
lea    0x0(,%rdi,8),%rsi
mov    %rsi,-0x8(%rsp)
lea    0x8(,%rdi,8),%rsi
mov    %rsi,-0x60(%rsp)
lea    0x8(%rbx,%rax,8),%rsi
mov    %rsi,-0x20(%rsp)
lea    0x1(%r11),%r8
mov    %r11,%rsi
not    %rsi
mov    %rsi,-0x28(%rsp)
mov    %r11,%rsi
neg    %rsi
mov    %rsi,-0x50(%rsp)
mov    -0x78(%rsp),%rsi
lea    (%rsi,%r11,8),%rsi
add    $0x10,%rsi
mov    %rsi,-0x58(%rsp)
lea    0x0(,%rdx,8),%r9
lea    (%rbx,%rax,8),%rbp
add    $0x10,%rbp
imul   %r11,%rdi
lea    (%rbx,%rdi,8),%rsi
xor    %ebx,%ebx
movapd 0x861(%rip),%xmm0
mov    %r8,-0x10(%rsp)
mov    %r8,%rax
jmp    17e4 <OneLower+0x6e4>
nopl   0x0(%rax)
add    $0x1,%r11
mov    -0x48(%rsp),%rbx
add    $0x1,%rbx
mov    (%rsp),%rax
add    $0x1,%rax
addq   $0xffffffffffffffff,-0x50(%rsp)
addq   $0x8,-0x58(%rsp)
add    -0x60(%rsp),%rbp
add    -0x8(%rsp),%rsi
cmp    %rdx,%r11
je     1984 <OneLower+0x884>
cmp    %rax,%rdx
mov    %rax,(%rsp)
cmovg  %rdx,%rax
mov    -0x10(%rsp),%rdi
mov    %rbx,-0x48(%rsp)
add    %rbx,%rdi
cmp    %rdi,%rdx
mov    %rdi,%r10
cmovg  %rdx,%r10
cmovg  %rdx,%rdi
mov    %rdi,-0x68(%rsp)
test   %rcx,%rcx
jle    17b0 <OneLower+0x6b0>
add    -0x50(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    -0x80(%rsp),%rdi
mov    -0x48(%rsp),%r8
add    %r8,%rdi
sub    %rdi,%r10
mov    -0x60(%rsp),%rbx
imul   %r8,%rbx
mov    -0x18(%rsp),%rdi
add    %rbx,%rdi
mov    %rdi,-0x70(%rsp)
add    -0x20(%rsp),%rbx
mov    -0x28(%rsp),%rdi
sub    %r8,%rdi
add    -0x68(%rsp),%rdi
lea    (%rbx,%rdi,8),%rdi
mov    %rdi,-0x40(%rsp)
mov    %r10,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdi,0x10(%rsp)
add    %r11,%rdi
mov    %rdi,0x8(%rsp)
mov    -0x78(%rsp),%rdi
mov    -0x58(%rsp),%r14
xor    %r12d,%r12d
jmp    18a3 <OneLower+0x7a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %r9,%r14
add    %r9,%rdi
cmp    %rcx,%r12
je     17b0 <OneLower+0x6b0>
mov    %r12,%r15
imul   %rdx,%r15
lea    (%r15,%r11,1),%r13
mov    -0x78(%rsp),%rbx
movsd  (%rbx,%r13,8),%xmm1
xorpd  %xmm0,%xmm1
mov    %r11,%r8
cmp    $0x4,%r10
jb     1960 <OneLower+0x860>
add    -0x68(%rsp),%r15
mov    -0x78(%rsp),%rbx
lea    (%rbx,%r15,8),%rbx
cmp    %rbx,-0x70(%rsp)
jae    18f7 <OneLower+0x7f7>
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r13,8),%rbx
mov    %r11,%r8
cmp    %rbx,-0x40(%rsp)
mov    -0x38(%rsp),%rcx
ja     1960 <OneLower+0x860>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r14,%rbx,8),%xmm3
movupd (%r14,%rbx,8),%xmm4
movupd -0x10(%rbp,%rbx,8),%xmm5
movupd 0x0(%rbp,%rbx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,-0x10(%rbp,%rbx,8)
movupd %xmm4,0x0(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1910 <OneLower+0x810>
mov    0x8(%rsp),%r8
cmp    0x10(%rsp),%r10
je     1890 <OneLower+0x790>
xchg   %ax,%ax
movsd  (%rdi,%r8,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%r8,8),%xmm2
movsd  %xmm2,(%rsi,%r8,8)
add    $0x1,%r8
cmp    %rdx,%r8
jl     1960 <OneLower+0x860>
jmp    1890 <OneLower+0x790>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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