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


x86 assembly (clang, -O0):
<OneDiv>:
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    18ed <OneDiv+0x7ed>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x3,%rcx
cmp    %rcx,%rax
jge    15da <OneDiv+0x4da>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xc0(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x3,%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xc0(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x3,%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0xc0(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x3,%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0xc0(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,-0xb0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
imul   -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0xb8(%rbp),%rax
je     15c4 <OneDiv+0x4c4>
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0xb0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x88(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x88(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x98(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x98(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0xa0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa0(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xa8(%rbp)
movsd  %xmm0,(%rax)
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0xb0(%rbp)
movsd  %xmm0,(%rax)
jmp    12df <OneDiv+0x1df>
jmp    15c9 <OneDiv+0x4c9>
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
jmp    1141 <OneDiv+0x41>
jmp    15df <OneDiv+0x4df>
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    172e <OneDiv+0x62e>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x28(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1718 <OneDiv+0x618>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x38(%rbp),%rsi
add    $0x0,%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)
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%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    1635 <OneDiv+0x535>
jmp    171d <OneDiv+0x61d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    15df <OneDiv+0x4df>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  0x8b6(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    17a4 <OneDiv+0x6a4>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    175f <OneDiv+0x65f>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    184f <OneDiv+0x74f>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x28(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%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    17ac <OneDiv+0x6ac>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x28(%rbp),%rdx
mov    -0x38(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  0x78a(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    18d7 <OneDiv+0x7d7>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x38(%rbp),%rsi
add    $0x1,%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    188b <OneDiv+0x78b>
jmp    18dc <OneDiv+0x7dc>
mov    -0x38(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x38(%rbp)
jmp    1124 <OneDiv+0x24>
jmp    18f2 <OneDiv+0x7f2>
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1a44 <OneDiv+0x944>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    19cc <OneDiv+0x8cc>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    19b6 <OneDiv+0x8b6>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x40(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%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    193c <OneDiv+0x83c>
jmp    19bb <OneDiv+0x8bb>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1908 <OneDiv+0x808>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1a2e <OneDiv+0x92e>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    19d4 <OneDiv+0x8d4>
jmp    1a33 <OneDiv+0x933>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    18f2 <OneDiv+0x7f2>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<OneDiv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
cmp    $0x2,%rdx
mov    %rdx,0x28(%rsp)
mov    %rsi,-0x78(%rsp)
mov    %rdi,-0x68(%rsp)
mov    %rax,0x30(%rsp)
jl     18fc <OneDiv+0x7fc>
add    $0xffffffffffffffff,%rdx
mov    %rdx,(%rsp)
lea    (%rcx,%rcx,1),%rdx
mov    %rdx,-0x8(%rsp)
lea    0x8(%rdi),%rdx
mov    %rdx,0x40(%rsp)
lea    -0x4(%rcx),%rdx
mov    %rdx,-0x40(%rsp)
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rcx,%r12
and    $0xfffffffffffffffe,%r12
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x10(%rsp)
mov    %rdi,%rdx
mov    %rdi,-0x48(%rsp)
and    %rax,%rdi
mov    %rdi,0x20(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x48(%rsp)
lea    (%rsi,%rcx,8),%rdx
mov    %rcx,%rdi
shl    $0x4,%rdi
lea    0x0(,%rcx,8),%r15
lea    (%rcx,%rcx,2),%rax
lea    (%rsi,%rax,8),%rax
mov    %rax,-0x28(%rsp)
mov    %rcx,%rax
shl    $0x5,%rax
mov    %rax,-0x38(%rsp)
mov    %rdi,-0x18(%rsp)
lea    (%rsi,%rdi,1),%rax
mov    %rax,-0x30(%rsp)
movapd 0xe2b(%rip),%xmm10
movsd  0xe32(%rip),%xmm9
movapd 0xe19(%rip),%xmm8
lea    0x10(,%rcx,8),%rax
mov    %rax,0x38(%rsp)
xor    %edi,%edi
mov    %rdx,-0x20(%rsp)
xor    %ebp,%ebp
mov    %r8,-0x70(%rsp)
jmp    1232 <OneDiv+0x132>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rbp
mov    0x8(%rsp),%rdi
add    $0x1,%rdi
mov    -0x18(%rsp),%rax
add    %rax,%rdx
add    %rax,%rsi
cmp    (%rsp),%rbp
jge    18fe <OneDiv+0x7fe>
mov    -0x8(%rsp),%rbx
mov    %rbx,%rax
imul   %rdi,%rax
lea    (%rax,%rcx,1),%r8
add    %rax,%rbx
cmp    $0x4,%rbp
mov    %rbp,-0x80(%rsp)
mov    %rdi,0x8(%rsp)
mov    %rax,-0x50(%rsp)
mov    %r8,-0x58(%rsp)
mov    %rbx,-0x60(%rsp)
jb     13c0 <OneDiv+0x2c0>
lea    -0x3(%rbp),%r8
mov    -0x78(%rsp),%rbp
mov    -0x20(%rsp),%r11
mov    -0x30(%rsp),%r14
mov    -0x28(%rsp),%r13
xor    %r9d,%r9d
jmp    12ae <OneDiv+0x1ae>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%r9
mov    -0x38(%rsp),%rax
add    %rax,%r13
add    %rax,%r14
add    %rax,%r11
add    %rax,%rbp
cmp    %r8,%r9
jge    13c3 <OneDiv+0x2c3>
test   %rcx,%rcx
je     1290 <OneDiv+0x190>
mov    %r9,%rbx
mov    -0x70(%rsp),%rdi
imul   %rdi,%rbx
add    -0x80(%rsp),%rbx
mov    -0x68(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
lea    (%rbx,%rdi,8),%rax
lea    (%rax,%rdi,8),%r10
movsd  (%rbx),%xmm12
movsd  0x8(%rbx),%xmm11
xorpd  %xmm10,%xmm12
xorpd  %xmm10,%xmm11
movsd  (%rbx,%rdi,8),%xmm13
movsd  0x8(%rbx,%rdi,8),%xmm14
xorpd  %xmm10,%xmm13
xorpd  %xmm10,%xmm14
movsd  (%rax,%rdi,8),%xmm7
movsd  0x8(%rax,%rdi,8),%xmm2
xorpd  %xmm10,%xmm7
xorpd  %xmm10,%xmm2
movsd  (%r10,%rdi,8),%xmm1
movsd  0x8(%r10,%rdi,8),%xmm0
xorpd  %xmm10,%xmm1
xorpd  %xmm10,%xmm0
xor    %r10d,%r10d
movsd  0x0(%rbp,%r10,1),%xmm4
movapd %xmm12,%xmm3
mulsd  %xmm4,%xmm3
addsd  (%rsi,%r10,1),%xmm3
mulsd  %xmm11,%xmm4
addsd  (%rdx,%r10,1),%xmm4
movsd  (%r11,%r10,1),%xmm5
movapd %xmm13,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm14,%xmm5
addsd  %xmm4,%xmm5
movsd  (%r14,%r10,1),%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm2,%xmm3
addsd  %xmm5,%xmm3
movsd  0x0(%r13,%r10,1),%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm0,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm6,(%rsi,%r10,1)
movsd  %xmm5,(%rdx,%r10,1)
add    $0x8,%r10
cmp    %r10,%r15
jne    1330 <OneDiv+0x230>
jmp    1290 <OneDiv+0x190>
xor    %r9d,%r9d
mov    -0x78(%rsp),%rax
mov    -0x58(%rsp),%rdi
lea    (%rax,%rdi,8),%rdi
mov    %rdi,-0x58(%rsp)
mov    -0x60(%rsp),%rdi
lea    (%rax,%rdi,8),%rdi
mov    %rdi,-0x60(%rsp)
mov    -0x80(%rsp),%rbp
cmp    %rbp,%r9
mov    -0x70(%rsp),%r8
jae    15b0 <OneDiv+0x4b0>
mov    -0x50(%rsp),%rdi
lea    (%rax,%rdi,8),%rdi
mov    %rdi,-0x50(%rsp)
mov    %rbp,%r10
or     $0x1,%r10
mov    %r9,%rdi
imul   %rcx,%rdi
lea    0x8(,%r9,8),%rbx
imul   %rcx,%rbx
mov    %rbx,0x10(%rsp)
mov    %rdi,0x18(%rsp)
lea    (%rax,%rdi,8),%r14
lea    (%rsi,%r15,1),%r13
xor    %r11d,%r11d
jmp    1454 <OneDiv+0x354>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9
add    $0x1,%r11
add    %r15,%r14
cmp    %rbp,%r9
jae    15b0 <OneDiv+0x4b0>
test   %rcx,%rcx
jle    1440 <OneDiv+0x340>
mov    %r9,%rax
imul   %r8,%rax
lea    (%rax,%r10,1),%rdi
add    %rbp,%rax
mov    -0x68(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm3
xorpd  %xmm10,%xmm3
movsd  (%rbx,%rdi,8),%xmm4
xorpd  %xmm10,%xmm4
cmp    $0x1,%rcx
jne    1490 <OneDiv+0x390>
xor    %ebx,%ebx
jmp    1570 <OneDiv+0x470>
nopl   (%rax)
mov    %r11,%rax
imul   %rcx,%rax
mov    0x18(%rsp),%rdi
add    %rax,%rdi
mov    -0x78(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
add    0x10(%rsp),%rax
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
cmp    -0x50(%rsp),%rax
seta   %r8b
mov    -0x58(%rsp),%rbp
cmp    %rbp,%rdi
setb   %bl
cmp    %rbp,%rax
seta   %al
cmp    -0x60(%rsp),%rdi
setb   %bpl
test   %bl,%r8b
jne    155f <OneDiv+0x45f>
mov    $0x0,%ebx
and    %bpl,%al
mov    -0x70(%rsp),%r8
mov    -0x80(%rsp),%rbp
jne    1570 <OneDiv+0x470>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm4,%xmm1
xor    %ebp,%ebp
nopl   (%rax)
movupd (%r14,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%rsi,%rbp,8),%xmm5
addpd  %xmm2,%xmm5
movupd %xmm5,(%rsi,%rbp,8)
movupd (%r14,%rbp,8),%xmm2
mulpd  %xmm1,%xmm2
movupd 0x0(%r13,%rbp,8),%xmm5
addpd  %xmm2,%xmm5
movupd %xmm5,0x0(%r13,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r12
jne    1510 <OneDiv+0x410>
mov    %r12,%rbx
cmp    %rcx,%r12
mov    -0x80(%rsp),%rbp
jne    1570 <OneDiv+0x470>
jmp    1440 <OneDiv+0x340>
xor    %ebx,%ebx
mov    -0x70(%rsp),%r8
mov    -0x80(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%rbx,8)
movsd  (%r14,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rcx
jne    1570 <OneDiv+0x470>
jmp    1440 <OneDiv+0x340>
cs nopw 0x0(%rax,%rax,1)
test   %rcx,%rcx
mov    -0x10(%rsp),%r11
jle    1210 <OneDiv+0x110>
mov    %rbp,%rax
imul   %r8,%rax
add    %rbp,%rax
movapd %xmm9,%xmm3
mov    -0x68(%rsp),%rdi
divsd  (%rdi,%rax,8),%xmm3
mov    %rbp,%r13
imul   %rcx,%r13
cmp    $0x4,%rcx
jae    15f0 <OneDiv+0x4f0>
xor    %eax,%eax
jmp    16a0 <OneDiv+0x5a0>
nopl   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x4,-0x40(%rsp)
jae    1604 <OneDiv+0x504>
xor    %eax,%eax
jmp    1658 <OneDiv+0x558>
mov    0x20(%rsp),%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm1
movupd 0x10(%rsi,%rax,8),%xmm2
movupd 0x20(%rsi,%rax,8),%xmm4
movupd 0x30(%rsi,%rax,8),%xmm5
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rsi,%rax,8)
movupd %xmm2,0x10(%rsi,%rax,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm5
movupd %xmm4,0x20(%rsi,%rax,8)
movupd %xmm5,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1610 <OneDiv+0x510>
testb  $0x1,-0x48(%rsp)
je     1685 <OneDiv+0x585>
add    %r13,%rax
mov    -0x78(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
mov    %r11,%rax
cmp    %rcx,%r11
mov    -0x80(%rsp),%rbp
je     16b7 <OneDiv+0x5b7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    16a0 <OneDiv+0x5a0>
test   %rcx,%rcx
jle    1210 <OneDiv+0x110>
mov    %rbp,%r10
or     $0x1,%r10
imul   %r8,%r9
add    %r10,%r9
mov    %r10,%r14
imul   %rcx,%r14
mov    -0x68(%rsp),%rax
lea    (%rax,%r9,8),%rbp
cmp    $0x4,%rcx
jb     1703 <OneDiv+0x603>
mov    0x40(%rsp),%rax
lea    (%rax,%r9,8),%rax
cmp    %rax,-0x58(%rsp)
jae    178e <OneDiv+0x68e>
cmp    -0x60(%rsp),%rbp
jae    178e <OneDiv+0x68e>
xor    %ebx,%ebx
mov    %rbx,%rax
test   $0x1,%cl
je     1739 <OneDiv+0x639>
movsd  0x0(%rbp),%xmm0
add    %rbx,%r13
lea    (%rbx,%r14,1),%rax
mov    -0x78(%rsp),%rdi
mulsd  (%rdi,%r13,8),%xmm0
movsd  (%rdi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
mov    %rbx,%rax
or     $0x1,%rax
not    %rbx
cmp    0x48(%rsp),%rbx
je     1800 <OneDiv+0x700>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x0(%rbp),%xmm1
mulsd  0x8(%rsi,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1750 <OneDiv+0x650>
jmp    1800 <OneDiv+0x700>
movsd  0x0(%rbp),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  %xmm8,%xmm0
mov    0x38(%rsp),%rax
add    %rsi,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rbx,8),%xmm1
movupd 0x10(%rsi,%rbx,8),%xmm2
movupd -0x10(%rax,%rbx,8),%xmm3
movupd (%rax,%rbx,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%rax,%rbx,8)
movupd %xmm2,(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r11
jne    17b0 <OneDiv+0x6b0>
mov    %r11,%rbx
cmp    %rcx,%r11
jne    1705 <OneDiv+0x605>
cs nopw 0x0(%rax,%rax,1)
test   %rcx,%rcx
mov    -0x80(%rsp),%rbp
jle    1210 <OneDiv+0x110>
mov    %r10,%rax
imul   %r8,%rax
add    %r10,%rax
movapd %xmm9,%xmm3
mov    -0x68(%rsp),%rdi
divsd  (%rdi,%rax,8),%xmm3
cmp    $0x4,%rcx
jae    1834 <OneDiv+0x734>
xor    %eax,%eax
jmp    18e0 <OneDiv+0x7e0>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x4,-0x40(%rsp)
jae    1848 <OneDiv+0x748>
xor    %eax,%eax
jmp    1898 <OneDiv+0x798>
mov    0x20(%rsp),%rbp
xor    %eax,%eax
nop
movupd (%rdx,%rax,8),%xmm1
movupd 0x10(%rdx,%rax,8),%xmm2
movupd 0x20(%rdx,%rax,8),%xmm4
movupd 0x30(%rdx,%rax,8),%xmm5
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdx,%rax,8)
movupd %xmm2,0x10(%rdx,%rax,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm5
movupd %xmm4,0x20(%rdx,%rax,8)
movupd %xmm5,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbp
jne    1850 <OneDiv+0x750>
testb  $0x1,-0x48(%rsp)
je     18c5 <OneDiv+0x7c5>
add    %r14,%rax
mov    -0x78(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
mov    %r11,%rax
cmp    %rcx,%r11
mov    -0x80(%rsp),%rbp
je     1210 <OneDiv+0x110>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rcx
jne    18e0 <OneDiv+0x7e0>
jmp    1210 <OneDiv+0x110>
xor    %ebp,%ebp
cmp    0x28(%rsp),%rbp
mov    -0x78(%rsp),%r15
mov    -0x68(%rsp),%rbx
jge    1d85 <OneDiv+0xc85>
mov    %rbp,%rdx
imul   %rcx,%rdx
lea    0x8(,%rbp,8),%rax
imul   %rcx,%rax
mov    %rax,0x8(%rsp)
lea    0x1(%r8),%rax
imul   %rbp,%rax
lea    (%rbx,%rax,8),%rsi
mov    %rsi,-0x20(%rsp)
lea    0x8(,%r8,8),%rsi
mov    %rsi,-0x10(%rsp)
lea    0x8(%rbx,%rax,8),%rax
mov    %rax,-0x18(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,-0x58(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
lea    -0x2(%rcx),%rsi
mov    %rsi,-0x28(%rsp)
mov    %rsi,%rdi
shr    %rdi
add    $0x1,%rdi
mov    %rcx,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %rsi,-0x50(%rsp)
mov    %rax,%rsi
mov    %rax,-0x60(%rsp)
and    %rax,0x30(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,-0x80(%rsp)
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x40(%rsp)
mov    %rdi,%rax
mov    %rdi,-0x30(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x48(%rsp)
lea    0x30(%r15),%rax
mov    %rax,(%rsp)
lea    0x0(,%rcx,8),%r14
movapd 0x630(%rip),%xmm0
lea    0x30(%r15,%rdx,8),%r12
mov    %rdx,0x10(%rsp)
lea    (%r15,%rdx,8),%r9
lea    0x8(%r15),%rax
mov    %rax,-0x8(%rsp)
xor    %esi,%esi
jmp    1a09 <OneDiv+0x909>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%rsi
add    %r14,%r12
add    %r14,%r9
cmp    0x28(%rsp),%rbp
je     1d85 <OneDiv+0xc85>
mov    %rsi,0x18(%rsp)
mov    %rsi,%rax
imul   %rcx,%rax
mov    0x10(%rsp),%rdx
add    %rax,%rdx
lea    (%r15,%rdx,8),%rdx
mov    %rdx,-0x38(%rsp)
lea    (%r15,%rax,8),%rax
add    0x8(%rsp),%rax
mov    %rax,-0x70(%rsp)
mov    %rbp,%r10
test   %rbp,%rbp
je     1c50 <OneDiv+0xb50>
mov    %r10,%r13
imul   %rcx,%r13
mov    -0x8(%rsp),%rbp
mov    (%rsp),%rsi
xor    %r11d,%r11d
jmp    1a73 <OneDiv+0x973>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
add    %r14,%rsi
add    %r14,%rbp
cmp    %r10,%r11
je     1c50 <OneDiv+0xb50>
test   %rcx,%rcx
jle    1a60 <OneDiv+0x960>
mov    %r11,%rax
imul   %rcx,%rax
mov    %r11,%rdx
imul   %r8,%rdx
add    %r10,%rdx
movsd  (%rbx,%rdx,8),%xmm1
xorpd  %xmm0,%xmm1
cmp    $0x4,%rcx
jb     1aba <OneDiv+0x9ba>
lea    (%rax,%rcx,1),%rdx
lea    (%r15,%rdx,8),%rdx
cmp    %rdx,-0x38(%rsp)
jae    1b3c <OneDiv+0xa3c>
lea    (%r15,%rax,8),%rdx
cmp    %rdx,-0x70(%rsp)
jbe    1b3c <OneDiv+0xa3c>
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%cl
je     1ae8 <OneDiv+0x9e8>
add    %rdi,%rax
lea    (%rdi,%r13,1),%rdx
movsd  (%r15,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r15,%rdx,8),%xmm2
movsd  %xmm2,(%r15,%rdx,8)
mov    %rdi,%rdx
or     $0x1,%rdx
not    %rdi
cmp    -0x80(%rsp),%rdi
je     1a60 <OneDiv+0x960>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r9,%rdx,8),%xmm2
movsd  %xmm2,(%r9,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r9,%rdx,8),%xmm2
movsd  %xmm2,0x8(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1b00 <OneDiv+0xa00>
jmp    1a60 <OneDiv+0x960>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x4,-0x58(%rsp)
jae    1b54 <OneDiv+0xa54>
xor    %r15d,%r15d
jmp    1bdb <OneDiv+0xadb>
mov    0x30(%rsp),%rdx
xor    %r15d,%r15d
nopl   0x0(%rax)
movupd -0x30(%rsi,%r15,8),%xmm3
movupd -0x20(%rsi,%r15,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%r12,%r15,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%r12,%r15,8),%xmm3
movupd -0x10(%r12,%r15,8),%xmm6
movupd (%r12,%r15,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%r12,%r15,8)
movupd %xmm4,-0x20(%r12,%r15,8)
movupd -0x10(%rsi,%r15,8),%xmm3
movupd (%rsi,%r15,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%r12,%r15,8)
movupd %xmm4,(%r12,%r15,8)
add    $0x8,%r15
add    $0xfffffffffffffffe,%rdx
jne    1b60 <OneDiv+0xa60>
testb  $0x1,-0x60(%rsp)
je     1c23 <OneDiv+0xb23>
lea    (%r15,%rax,1),%rdx
mov    -0x78(%rsp),%rdi
movupd (%rdi,%rdx,8),%xmm3
movupd 0x10(%rdi,%rdx,8),%xmm4
add    %r13,%r15
movupd (%rdi,%r15,8),%xmm5
movupd 0x10(%rdi,%r15,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rdi,%r15,8)
movupd %xmm4,0x10(%rdi,%r15,8)
mov    -0x50(%rsp),%rdx
mov    %rdx,%rdi
cmp    %rcx,%rdx
mov    -0x78(%rsp),%r15
mov    -0x68(%rsp),%rbx
je     1a60 <OneDiv+0x960>
jmp    1abc <OneDiv+0x9bc>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %rcx,%rcx
mov    %r10,%rbp
mov    0x18(%rsp),%rsi
jle    19f0 <OneDiv+0x8f0>
mov    %rbp,%rax
imul   %r8,%rax
add    %rbp,%rax
mov    %rbp,%r10
imul   %rcx,%r10
cmp    $0x1,%rcx
je     1c9c <OneDiv+0xb9c>
mov    -0x10(%rsp),%rdx
imul   %rsi,%rdx
mov    -0x18(%rsp),%rdi
add    %rdx,%rdi
cmp    -0x38(%rsp),%rdi
jbe    1d02 <OneDiv+0xc02>
add    -0x20(%rsp),%rdx
cmp    -0x70(%rsp),%rdx
jae    1d02 <OneDiv+0xc02>
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%cl
je     1cc1 <OneDiv+0xbc1>
add    %rdi,%r10
movsd  (%r15,%r10,8),%xmm1
divsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r15,%r10,8)
mov    %rdi,%rdx
or     $0x1,%rdx
not    %rdi
cmp    -0x80(%rsp),%rdi
je     19f0 <OneDiv+0x8f0>
nop
movsd  (%r9,%rdx,8),%xmm1
divsd  (%rbx,%rax,8),%xmm1
movsd  0x8(%r9,%rdx,8),%xmm2
movsd  %xmm1,(%r9,%rdx,8)
divsd  (%rbx,%rax,8),%xmm2
movsd  %xmm2,0x8(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1cd0 <OneDiv+0xbd0>
jmp    19f0 <OneDiv+0x8f0>
cmpq   $0x2,-0x28(%rsp)
jae    1d0e <OneDiv+0xc0e>
xor    %edx,%edx
jmp    1d4c <OneDiv+0xc4c>
movsd  (%rbx,%rax,8),%xmm1
unpcklpd %xmm1,%xmm1
mov    -0x48(%rsp),%rdi
xor    %edx,%edx
xchg   %ax,%ax
movupd (%r9,%rdx,8),%xmm2
movupd 0x10(%r9,%rdx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%r9,%rdx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r9,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1d20 <OneDiv+0xc20>
testb  $0x1,-0x30(%rsp)
je     1d6f <OneDiv+0xc6f>
movsd  (%rbx,%rax,8),%xmm1
unpcklpd %xmm1,%xmm1
add    %r10,%rdx
movupd (%r15,%rdx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rdx,8)
mov    -0x40(%rsp),%rdx
mov    %rdx,%rdi
cmp    %rcx,%rdx
je     19f0 <OneDiv+0x8f0>
jmp    1c9e <OneDiv+0xb9e>
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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