void kernel_dgetrf_pivot_4_vs_lib4(int m, int n, double *pA, int sda,
                                   double *inv_diag_A, int *ipiv) {
  if (m <= 0 || n <= 0)
    return;
  const int bs = 4;
  int ma = m - 4;
  double tmp0, tmp1, tmp2, tmp3, u_00, u_01, u_02, u_03, u_11, u_12, u_13, u_22,
      u_23, u_33;
  double *pB;
  int k, idamax;
  idamax_lib4(m - 0, 0, &pA[0 + bs * 0], sda, &idamax, &tmp0);
  ipiv[0] = idamax;
  if (tmp0 != 0.0) {
    if (ipiv[0] != 0)
      drowsw_lib(4, pA + 0, pA + ipiv[0] / bs * bs * sda + ipiv[0] % bs);
    tmp0 = 1.0 / pA[0 + bs * 0];
    inv_diag_A[0] = tmp0;
    if (m >= 4) {
      pA[1 + bs * 0] *= tmp0;
      pA[2 + bs * 0] *= tmp0;
      pA[3 + bs * 0] *= tmp0;
      pB = pA + bs * sda;
      for (k = 0; k < ma - 3; k += 4) {
        pB[0 + bs * 0] *= tmp0;
        pB[1 + bs * 0] *= tmp0;
        pB[2 + bs * 0] *= tmp0;
        pB[3 + bs * 0] *= tmp0;
        pB += bs * sda;
      }
      for (; k < ma; k++) {
        pB[0 + bs * 0] *= tmp0;
        pB += 1;
      }
    } else {
      if (m > 1) {
        pA[1 + bs * 0] *= tmp0;
        if (m > 2)
          pA[2 + bs * 0] *= tmp0;
      }
    }
  } else {
    inv_diag_A[0] = 0.0;
  }
  if (n == 1 || m == 1)
    return;
  if (m >= 4) {
    u_01 = pA[0 + bs * 1];
    tmp1 = pA[1 + bs * 1];
    tmp2 = pA[2 + bs * 1];
    tmp3 = pA[3 + bs * 1];
    tmp1 -= pA[1 + bs * 0] * u_01;
    tmp2 -= pA[2 + bs * 0] * u_01;
    tmp3 -= pA[3 + bs * 0] * u_01;
    pA[1 + bs * 1] = tmp1;
    pA[2 + bs * 1] = tmp2;
    pA[3 + bs * 1] = tmp3;
    pB = pA + bs * sda;
    for (k = 0; k < ma - 3; k += 4) {
      tmp0 = pB[0 + bs * 1];
      tmp1 = pB[1 + bs * 1];
      tmp2 = pB[2 + bs * 1];
      tmp3 = pB[3 + bs * 1];
      tmp0 -= pB[0 + bs * 0] * u_01;
      tmp1 -= pB[1 + bs * 0] * u_01;
      tmp2 -= pB[2 + bs * 0] * u_01;
      tmp3 -= pB[3 + bs * 0] * u_01;
      pB[0 + bs * 1] = tmp0;
      pB[1 + bs * 1] = tmp1;
      pB[2 + bs * 1] = tmp2;
      pB[3 + bs * 1] = tmp3;
      pB += bs * sda;
    }
    for (; k < ma; k++) {
      tmp0 = pB[0 + bs * 1];
      tmp0 -= pB[0 + bs * 0] * u_01;
      pB[0 + bs * 1] = tmp0;
      pB += 1;
    }
  } else {
    u_01 = pA[0 + bs * 1];
    tmp1 = pA[1 + bs * 1];
    tmp1 -= pA[1 + bs * 0] * u_01;
    pA[1 + bs * 1] = tmp1;
    if (m > 2) {
      tmp2 = pA[2 + bs * 1];
      tmp2 -= pA[2 + bs * 0] * u_01;
      pA[2 + bs * 1] = tmp2;
    }
  }
  idamax_lib4(m - 1, 1, &pA[1 + bs * 1], sda, &idamax, &tmp1);
  ipiv[1] = idamax + 1;
  if (tmp1 != 0) {
    if (ipiv[1] != 1)
      drowsw_lib(4, pA + 1, pA + ipiv[1] / bs * bs * sda + ipiv[1] % bs);
    tmp1 = 1.0 / pA[1 + bs * 1];
    inv_diag_A[1] = tmp1;
    if (m >= 4) {
      pA[2 + bs * 1] *= tmp1;
      pA[3 + bs * 1] *= tmp1;
      pB = pA + bs * sda;
      for (k = 0; k < ma - 3; k += 4) {
        pB[0 + bs * 1] *= tmp1;
        pB[1 + bs * 1] *= tmp1;
        pB[2 + bs * 1] *= tmp1;
        pB[3 + bs * 1] *= tmp1;
        pB += bs * sda;
      }
      for (; k < ma; k++) {
        pB[0 + bs * 1] *= tmp1;
        pB += 1;
      }
    } else {
      if (m > 2)
        pA[2 + bs * 1] *= tmp1;
    }
  } else {
    inv_diag_A[1] = 0.0;
  }
  if (n == 2)
    return;
  if (m >= 4) {
    u_02 = pA[0 + bs * 2];
    u_12 = pA[1 + bs * 2];
    u_12 -= pA[1 + bs * 0] * u_02;
    pA[1 + bs * 2] = u_12;
    tmp2 = pA[2 + bs * 2];
    tmp3 = pA[3 + bs * 2];
    tmp2 -= pA[2 + bs * 0] * u_02;
    tmp3 -= pA[3 + bs * 0] * u_02;
    tmp2 -= pA[2 + bs * 1] * u_12;
    tmp3 -= pA[3 + bs * 1] * u_12;
    pA[2 + bs * 2] = tmp2;
    pA[3 + bs * 2] = tmp3;
    pB = pA + bs * sda;
    for (k = 0; k < ma - 3; k += 4) {
      tmp0 = pB[0 + bs * 2];
      tmp1 = pB[1 + bs * 2];
      tmp2 = pB[2 + bs * 2];
      tmp3 = pB[3 + bs * 2];
      tmp0 -= pB[0 + bs * 0] * u_02;
      tmp1 -= pB[1 + bs * 0] * u_02;
      tmp2 -= pB[2 + bs * 0] * u_02;
      tmp3 -= pB[3 + bs * 0] * u_02;
      tmp0 -= pB[0 + bs * 1] * u_12;
      tmp1 -= pB[1 + bs * 1] * u_12;
      tmp2 -= pB[2 + bs * 1] * u_12;
      tmp3 -= pB[3 + bs * 1] * u_12;
      pB[0 + bs * 2] = tmp0;
      pB[1 + bs * 2] = tmp1;
      pB[2 + bs * 2] = tmp2;
      pB[3 + bs * 2] = tmp3;
      pB += bs * sda;
    }
    for (; k < ma; k++) {
      tmp0 = pB[0 + bs * 2];
      tmp0 -= pB[0 + bs * 0] * u_02;
      tmp0 -= pB[0 + bs * 1] * u_12;
      pB[0 + bs * 2] = tmp0;
      pB += 1;
    }
  } else {
    u_02 = pA[0 + bs * 2];
    u_12 = pA[1 + bs * 2];
    u_12 -= pA[1 + bs * 0] * u_02;
    pA[1 + bs * 2] = u_12;
    if (m > 2) {
      tmp2 = pA[2 + bs * 2];
      tmp2 -= pA[2 + bs * 0] * u_02;
      tmp2 -= pA[2 + bs * 1] * u_12;
      pA[2 + bs * 2] = tmp2;
    }
  }
  if (m > 2) {
    idamax_lib4(m - 2, 2, &pA[2 + bs * 2], sda, &idamax, &tmp2);
    ipiv[2] = idamax + 2;
    if (tmp2 != 0) {
      if (ipiv[2] != 2)
        drowsw_lib(4, pA + 2, pA + ipiv[2] / bs * bs * sda + ipiv[2] % bs);
      tmp2 = 1.0 / pA[2 + bs * 2];
      inv_diag_A[2] = tmp2;
      if (m >= 4) {
        pA[3 + bs * 2] *= tmp2;
        pB = pA + bs * sda;
        for (k = 0; k < ma - 3; k += 4) {
          pB[0 + bs * 2] *= tmp2;
          pB[1 + bs * 2] *= tmp2;
          pB[2 + bs * 2] *= tmp2;
          pB[3 + bs * 2] *= tmp2;
          pB += bs * sda;
        }
        for (; k < ma; k++) {
          pB[0 + bs * 2] *= tmp2;
          pB += 1;
        }
      }
    } else {
      inv_diag_A[2] = 0.0;
    }
  }
  if (n < 4)
    return;
  if (m >= 4) {
    u_03 = pA[0 + bs * 3];
    u_13 = pA[1 + bs * 3];
    u_13 -= pA[1 + bs * 0] * u_03;
    pA[1 + bs * 3] = u_13;
    u_23 = pA[2 + bs * 3];
    u_23 -= pA[2 + bs * 0] * u_03;
    u_23 -= pA[2 + bs * 1] * u_13;
    pA[2 + bs * 3] = u_23;
    tmp3 = pA[3 + bs * 3];
    tmp3 -= pA[3 + bs * 0] * u_03;
    tmp3 -= pA[3 + bs * 1] * u_13;
    tmp3 -= pA[3 + bs * 2] * u_23;
    pA[3 + bs * 3] = tmp3;
    pB = pA + bs * sda;
    for (k = 0; k < ma - 3; k += 4) {
      tmp0 = pB[0 + bs * 3];
      tmp1 = pB[1 + bs * 3];
      tmp2 = pB[2 + bs * 3];
      tmp3 = pB[3 + bs * 3];
      tmp0 -= pB[0 + bs * 0] * u_03;
      tmp1 -= pB[1 + bs * 0] * u_03;
      tmp2 -= pB[2 + bs * 0] * u_03;
      tmp3 -= pB[3 + bs * 0] * u_03;
      tmp0 -= pB[0 + bs * 1] * u_13;
      tmp1 -= pB[1 + bs * 1] * u_13;
      tmp2 -= pB[2 + bs * 1] * u_13;
      tmp3 -= pB[3 + bs * 1] * u_13;
      tmp0 -= pB[0 + bs * 2] * u_23;
      tmp1 -= pB[1 + bs * 2] * u_23;
      tmp2 -= pB[2 + bs * 2] * u_23;
      tmp3 -= pB[3 + bs * 2] * u_23;
      pB[0 + bs * 3] = tmp0;
      pB[1 + bs * 3] = tmp1;
      pB[2 + bs * 3] = tmp2;
      pB[3 + bs * 3] = tmp3;
      pB += bs * sda;
    }
    for (; k < ma; k++) {
      tmp0 = pB[0 + bs * 3];
      tmp0 -= pB[0 + bs * 0] * u_03;
      tmp0 -= pB[0 + bs * 1] * u_13;
      tmp0 -= pB[0 + bs * 2] * u_23;
      pB[0 + bs * 3] = tmp0;
      pB += 1;
    }
  } else {
    u_03 = pA[0 + bs * 3];
    u_13 = pA[1 + bs * 3];
    u_13 -= pA[1 + bs * 0] * u_03;
    pA[1 + bs * 3] = u_13;
    if (m > 2) {
      u_23 = pA[2 + bs * 3];
      u_23 -= pA[2 + bs * 0] * u_03;
      u_23 -= pA[2 + bs * 1] * u_13;
      pA[2 + bs * 3] = u_23;
    }
  }
  if (m > 3) {
    idamax_lib4(m - 3, 3, &pA[3 + bs * 3], sda, &idamax, &tmp3);
    ipiv[3] = idamax + 3;
    if (tmp3 != 0) {
      if (ipiv[3] != 3)
        drowsw_lib(4, pA + 3, pA + ipiv[3] / bs * bs * sda + ipiv[3] % bs);
      tmp3 = 1.0 / pA[3 + bs * 3];
      inv_diag_A[3] = tmp3;
      pB = pA + bs * sda;
      for (k = 0; k < ma - 3; k += 4) {
        pB[0 + bs * 3] *= tmp3;
        pB[1 + bs * 3] *= tmp3;
        pB[2 + bs * 3] *= tmp3;
        pB[3 + bs * 3] *= tmp3;
        pB += bs * sda;
      }
      for (; k < ma; k++) {
        pB[0 + bs * 3] *= tmp3;
        pB += 1;
      }
    } else {
      inv_diag_A[3] = 0.0;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<kernel_dgetrf_pivot_4_vs_lib4>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1154 <kernel_dgetrf_pivot_4_vs_lib4+0x34>
cmpl   $0x0,-0x8(%rbp)
jg     1159 <kernel_dgetrf_pivot_4_vs_lib4+0x39>
jmp    2d40 <kernel_dgetrf_pivot_4_vs_lib4+0x1c20>
movl   $0x4,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x30(%rbp)
mov    -0x4(%rbp),%edi
sub    $0x0,%edi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%ecx
xor    %esi,%esi
lea    -0xb0(%rbp),%r8
lea    -0x38(%rbp),%r9
mov    $0x0,%al
call   1030 <idamax_lib4@plt>
mov    -0xb0(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11b3 <kernel_dgetrf_pivot_4_vs_lib4+0x93>
jp     11b3 <kernel_dgetrf_pivot_4_vs_lib4+0x93>
jmp    13ec <kernel_dgetrf_pivot_4_vs_lib4+0x2cc>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     122a <kernel_dgetrf_pivot_4_vs_lib4+0x10a>
mov    -0x10(%rbp),%rsi
mov    -0x10(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xc0(%rbp),%rax
shl    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    -0xb8(%rbp),%rdx
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <drowsw_lib@plt>
mov    -0x10(%rbp),%rax
movsd  0x1dca(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x4,-0x4(%rbp)
jl     13a3 <kernel_dgetrf_pivot_4_vs_lib4+0x283>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1350 <kernel_dgetrf_pivot_4_vs_lib4+0x230>
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  %xmm0,0x18(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    12b4 <kernel_dgetrf_pivot_4_vs_lib4+0x194>
jmp    1355 <kernel_dgetrf_pivot_4_vs_lib4+0x235>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    139e <kernel_dgetrf_pivot_4_vs_lib4+0x27e>
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1355 <kernel_dgetrf_pivot_4_vs_lib4+0x235>
jmp    13e7 <kernel_dgetrf_pivot_4_vs_lib4+0x2c7>
cmpl   $0x1,-0x4(%rbp)
jle    13e2 <kernel_dgetrf_pivot_4_vs_lib4+0x2c2>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
cmpl   $0x2,-0x4(%rbp)
jle    13dd <kernel_dgetrf_pivot_4_vs_lib4+0x2bd>
movsd  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
jmp    13e2 <kernel_dgetrf_pivot_4_vs_lib4+0x2c2>
jmp    13e7 <kernel_dgetrf_pivot_4_vs_lib4+0x2c7>
jmp    13f7 <kernel_dgetrf_pivot_4_vs_lib4+0x2d7>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x1,-0x8(%rbp)
je     140b <kernel_dgetrf_pivot_4_vs_lib4+0x2eb>
cmpl   $0x1,-0x4(%rbp)
jne    1410 <kernel_dgetrf_pivot_4_vs_lib4+0x2f0>
jmp    2d40 <kernel_dgetrf_pivot_4_vs_lib4+0x1c20>
cmpl   $0x4,-0x4(%rbp)
jl     1795 <kernel_dgetrf_pivot_4_vs_lib4+0x675>
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    16fb <kernel_dgetrf_pivot_4_vs_lib4+0x5db>
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x38(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    1546 <kernel_dgetrf_pivot_4_vs_lib4+0x426>
jmp    1700 <kernel_dgetrf_pivot_4_vs_lib4+0x5e0>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1790 <kernel_dgetrf_pivot_4_vs_lib4+0x670>
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1700 <kernel_dgetrf_pivot_4_vs_lib4+0x5e0>
jmp    1858 <kernel_dgetrf_pivot_4_vs_lib4+0x738>
mov    -0x10(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x28(%rax)
cmpl   $0x2,-0x4(%rbp)
jle    1853 <kernel_dgetrf_pivot_4_vs_lib4+0x733>
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x30(%rax)
jmp    1858 <kernel_dgetrf_pivot_4_vs_lib4+0x738>
mov    -0x4(%rbp),%edi
sub    $0x1,%edi
mov    -0x10(%rbp),%rdx
add    $0x28,%rdx
mov    -0x14(%rbp),%ecx
mov    $0x1,%esi
lea    -0xb0(%rbp),%r8
lea    -0x40(%rbp),%r9
mov    $0x0,%al
call   1030 <idamax_lib4@plt>
mov    -0xb0(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x4(%rax)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18ad <kernel_dgetrf_pivot_4_vs_lib4+0x78d>
jp     18ad <kernel_dgetrf_pivot_4_vs_lib4+0x78d>
jmp    1abe <kernel_dgetrf_pivot_4_vs_lib4+0x99e>
mov    -0x28(%rbp),%rax
cmpl   $0x1,0x4(%rax)
je     192b <kernel_dgetrf_pivot_4_vs_lib4+0x80b>
mov    -0x10(%rbp),%rsi
add    $0x8,%rsi
mov    -0x10(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd0(%rbp),%rax
shl    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    -0xc8(%rbp),%rdx
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <drowsw_lib@plt>
mov    -0x10(%rbp),%rax
movsd  0x16c9(%rip),%xmm0
divsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
cmpl   $0x4,-0x4(%rbp)
jl     1a97 <kernel_dgetrf_pivot_4_vs_lib4+0x977>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x38(%rax),%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1a42 <kernel_dgetrf_pivot_4_vs_lib4+0x922>
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  %xmm0,0x20(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x28(%rax),%xmm0
movsd  %xmm0,0x28(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x38(%rax),%xmm0
movsd  %xmm0,0x38(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    19a4 <kernel_dgetrf_pivot_4_vs_lib4+0x884>
jmp    1a47 <kernel_dgetrf_pivot_4_vs_lib4+0x927>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1a92 <kernel_dgetrf_pivot_4_vs_lib4+0x972>
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x20(%rax),%xmm0
movsd  %xmm0,0x20(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1a47 <kernel_dgetrf_pivot_4_vs_lib4+0x927>
jmp    1ab9 <kernel_dgetrf_pivot_4_vs_lib4+0x999>
cmpl   $0x2,-0x4(%rbp)
jle    1ab4 <kernel_dgetrf_pivot_4_vs_lib4+0x994>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x30(%rax),%xmm0
movsd  %xmm0,0x30(%rax)
jmp    1ab9 <kernel_dgetrf_pivot_4_vs_lib4+0x999>
jmp    1aca <kernel_dgetrf_pivot_4_vs_lib4+0x9aa>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
cmpl   $0x2,-0x8(%rbp)
jne    1ad9 <kernel_dgetrf_pivot_4_vs_lib4+0x9b9>
jmp    2d40 <kernel_dgetrf_pivot_4_vs_lib4+0x1c20>
cmpl   $0x4,-0x4(%rbp)
jl     1fee <kernel_dgetrf_pivot_4_vs_lib4+0xece>
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1f1a <kernel_dgetrf_pivot_4_vs_lib4+0xdfa>
mov    -0xa8(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x58(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    1c7d <kernel_dgetrf_pivot_4_vs_lib4+0xb5d>
jmp    1f1f <kernel_dgetrf_pivot_4_vs_lib4+0xdff>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1fe9 <kernel_dgetrf_pivot_4_vs_lib4+0xec9>
mov    -0xa8(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x40(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1f1f <kernel_dgetrf_pivot_4_vs_lib4+0xdff>
jmp    20e8 <kernel_dgetrf_pivot_4_vs_lib4+0xfc8>
mov    -0x10(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x48(%rax)
cmpl   $0x2,-0x4(%rbp)
jle    20e3 <kernel_dgetrf_pivot_4_vs_lib4+0xfc3>
mov    -0x10(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x50(%rax)
jmp    20e8 <kernel_dgetrf_pivot_4_vs_lib4+0xfc8>
cmpl   $0x2,-0x4(%rbp)
jle    2334 <kernel_dgetrf_pivot_4_vs_lib4+0x1214>
mov    -0x4(%rbp),%edi
sub    $0x2,%edi
mov    -0x10(%rbp),%rdx
add    $0x50,%rdx
mov    -0x14(%rbp),%ecx
mov    $0x2,%esi
lea    -0xb0(%rbp),%r8
lea    -0x48(%rbp),%r9
mov    $0x0,%al
call   1030 <idamax_lib4@plt>
mov    -0xb0(%rbp),%ecx
add    $0x2,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x8(%rax)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2147 <kernel_dgetrf_pivot_4_vs_lib4+0x1027>
jp     2147 <kernel_dgetrf_pivot_4_vs_lib4+0x1027>
jmp    2323 <kernel_dgetrf_pivot_4_vs_lib4+0x1203>
mov    -0x28(%rbp),%rax
cmpl   $0x2,0x8(%rax)
je     21c5 <kernel_dgetrf_pivot_4_vs_lib4+0x10a5>
mov    -0x10(%rbp),%rsi
add    $0x10,%rsi
mov    -0x10(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xe0(%rbp),%rax
shl    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    -0xd8(%rbp),%rdx
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <drowsw_lib@plt>
mov    -0x10(%rbp),%rax
movsd  0xe2f(%rip),%xmm0
divsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
cmpl   $0x4,-0x4(%rbp)
jl     231e <kernel_dgetrf_pivot_4_vs_lib4+0x11fe>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x58(%rax),%xmm0
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    22c9 <kernel_dgetrf_pivot_4_vs_lib4+0x11a9>
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x40(%rax),%xmm0
movsd  %xmm0,0x40(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x48(%rax),%xmm0
movsd  %xmm0,0x48(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x50(%rax),%xmm0
movsd  %xmm0,0x50(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x58(%rax),%xmm0
movsd  %xmm0,0x58(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    222b <kernel_dgetrf_pivot_4_vs_lib4+0x110b>
jmp    22ce <kernel_dgetrf_pivot_4_vs_lib4+0x11ae>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2319 <kernel_dgetrf_pivot_4_vs_lib4+0x11f9>
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x40(%rax),%xmm0
movsd  %xmm0,0x40(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    22ce <kernel_dgetrf_pivot_4_vs_lib4+0x11ae>
jmp    231e <kernel_dgetrf_pivot_4_vs_lib4+0x11fe>
jmp    232f <kernel_dgetrf_pivot_4_vs_lib4+0x120f>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
jmp    2334 <kernel_dgetrf_pivot_4_vs_lib4+0x1214>
cmpl   $0x4,-0x8(%rbp)
jge    2343 <kernel_dgetrf_pivot_4_vs_lib4+0x1223>
jmp    2d40 <kernel_dgetrf_pivot_4_vs_lib4+0x1c20>
cmpl   $0x4,-0x4(%rbp)
jl     29f6 <kernel_dgetrf_pivot_4_vs_lib4+0x18d6>
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x68(%rax)
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x70(%rax)
mov    -0x10(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    28e2 <kernel_dgetrf_pivot_4_vs_lib4+0x17c2>
mov    -0xa8(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x48(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x40(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x50(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x58(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x68(%rax)
movsd  -0x48(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x70(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x78(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    2545 <kernel_dgetrf_pivot_4_vs_lib4+0x1425>
jmp    28e7 <kernel_dgetrf_pivot_4_vs_lib4+0x17c7>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    29f1 <kernel_dgetrf_pivot_4_vs_lib4+0x18d1>
mov    -0xa8(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0xa8(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
movsd  %xmm0,0x60(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    28e7 <kernel_dgetrf_pivot_4_vs_lib4+0x17c7>
jmp    2b11 <kernel_dgetrf_pivot_4_vs_lib4+0x19f1>
mov    -0x10(%rbp),%rax
movsd  0x60(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x68(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x68(%rax)
cmpl   $0x2,-0x4(%rbp)
jle    2b0c <kernel_dgetrf_pivot_4_vs_lib4+0x19ec>
mov    -0x10(%rbp),%rax
movsd  0x70(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x70(%rax)
jmp    2b11 <kernel_dgetrf_pivot_4_vs_lib4+0x19f1>
cmpl   $0x3,-0x4(%rbp)
jle    2d3b <kernel_dgetrf_pivot_4_vs_lib4+0x1c1b>
mov    -0x4(%rbp),%edi
sub    $0x3,%edi
mov    -0x10(%rbp),%rdx
add    $0x78,%rdx
mov    -0x14(%rbp),%ecx
mov    $0x3,%esi
lea    -0xb0(%rbp),%r8
lea    -0x50(%rbp),%r9
mov    $0x0,%al
call   1030 <idamax_lib4@plt>
mov    -0xb0(%rbp),%ecx
add    $0x3,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0xc(%rax)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2b70 <kernel_dgetrf_pivot_4_vs_lib4+0x1a50>
jp     2b70 <kernel_dgetrf_pivot_4_vs_lib4+0x1a50>
jmp    2d2a <kernel_dgetrf_pivot_4_vs_lib4+0x1c0a>
mov    -0x28(%rbp),%rax
cmpl   $0x3,0xc(%rax)
je     2bee <kernel_dgetrf_pivot_4_vs_lib4+0x1ace>
mov    -0x10(%rbp),%rsi
add    $0x18,%rsi
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf0(%rbp),%rax
shl    $0x2,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    -0xe8(%rbp),%rdx
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    $0x4,%edi
mov    $0x0,%al
call   1040 <drowsw_lib@plt>
mov    -0x10(%rbp),%rax
movsd  0x406(%rip),%xmm0
divsd  0x78(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    2cd5 <kernel_dgetrf_pivot_4_vs_lib4+0x1bb5>
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x60(%rax),%xmm0
movsd  %xmm0,0x60(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x68(%rax),%xmm0
movsd  %xmm0,0x68(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x70(%rax),%xmm0
movsd  %xmm0,0x70(%rax)
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x78(%rax),%xmm0
movsd  %xmm0,0x78(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x2,%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xac(%rbp)
jmp    2c37 <kernel_dgetrf_pivot_4_vs_lib4+0x1b17>
jmp    2cda <kernel_dgetrf_pivot_4_vs_lib4+0x1bba>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2d25 <kernel_dgetrf_pivot_4_vs_lib4+0x1c05>
movsd  -0x50(%rbp),%xmm0
mov    -0xa8(%rbp),%rax
mulsd  0x60(%rax),%xmm0
movsd  %xmm0,0x60(%rax)
mov    -0xa8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2cda <kernel_dgetrf_pivot_4_vs_lib4+0x1bba>
jmp    2d36 <kernel_dgetrf_pivot_4_vs_lib4+0x1c16>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
jmp    2d3b <kernel_dgetrf_pivot_4_vs_lib4+0x1c1b>
jmp    2d40 <kernel_dgetrf_pivot_4_vs_lib4+0x1c20>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_dgetrf_pivot_4_vs_lib4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x30(%rsp)
test   %edi,%edi
jle    20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
mov    %esi,%r12d
test   %esi,%esi
jle    20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
mov    %ecx,%r13d
mov    %rdx,%rbx
mov    %edi,%r15d
mov    %r8,0x18(%rsp)
lea    -0x4(%r15),%ebp
lea    0xc(%rsp),%r8
mov    %rsp,%r14
xor    %esi,%esi
mov    %r14,%r9
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%eax
mov    0x30(%rsp),%rcx
mov    %eax,(%rcx)
movsd  (%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    118c <kernel_dgetrf_pivot_4_vs_lib4+0x6c>
jnp    132b <kernel_dgetrf_pivot_4_vs_lib4+0x20b>
test   %eax,%eax
je     11c5 <kernel_dgetrf_pivot_4_vs_lib4+0xa5>
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   %r13d,%edx
shl    $0x2,%edx
movslq %edx,%rdx
lea    (%rbx,%rdx,8),%rdx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    (%rdx,%rax,8),%rdx
mov    $0x4,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <drowsw_lib@plt>
movsd  0x1e33(%rip),%xmm0
divsd  (%rbx),%xmm0
movsd  %xmm0,(%rsp)
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax)
cmp    $0x4,%r15d
jb     143c <kernel_dgetrf_pivot_4_vs_lib4+0x31c>
movupd 0x8(%rbx),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rbx)
movsd  0x18(%rbx),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%rbx)
lea    0x0(,%r13,4),%eax
movslq %eax,%rcx
lea    (%rbx,%rcx,8),%rax
xor    %esi,%esi
cmp    $0x8,%r15d
jb     1259 <kernel_dgetrf_pivot_4_vs_lib4+0x139>
lea    -0x7(%r15),%edx
shl    $0x3,%rcx
xor    %esi,%esi
xchg   %ax,%ax
movupd (%rax),%xmm2
movupd 0x10(%rax),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,(%rax)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax)
add    $0x4,%esi
add    %rcx,%rax
cmp    %edx,%esi
jl     1230 <kernel_dgetrf_pivot_4_vs_lib4+0x110>
mov    %ebp,%esi
and    $0xfffffffc,%esi
cmp    %ebp,%esi
jge    1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    %esi,%ecx
or     $0x1,%ecx
cmp    %ebp,%ecx
je     1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
mov    %r15d,%edx
sub    %esi,%edx
add    $0xfffffffa,%edx
cmp    $0x3,%edx
jb     1b96 <kernel_dgetrf_pivot_4_vs_lib4+0xa76>
lea    (%rax,%rdx,8),%rsi
add    $0x10,%rsi
cmp    %rsi,%r14
setb   %sil
cmp    %r14,%rax
jae    12a4 <kernel_dgetrf_pivot_4_vs_lib4+0x184>
test   %sil,%sil
jne    1b96 <kernel_dgetrf_pivot_4_vs_lib4+0xa76>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %ebp,%r9d
test   %rdi,%rdi
je     1b52 <kernel_dgetrf_pivot_4_vs_lib4+0xa32>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
movsd  (%rsp),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edi,%edi
movupd 0x8(%rax,%rdi,8),%xmm1
movupd 0x18(%rax,%rdi,8),%xmm2
movupd 0x28(%rax,%rdi,8),%xmm3
movupd 0x38(%rax,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x8(%rax,%rdi,8)
movupd %xmm2,0x18(%rax,%rdi,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x28(%rax,%rdi,8)
movupd %xmm4,0x38(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    12dc <kernel_dgetrf_pivot_4_vs_lib4+0x1bc>
jmp    1b54 <kernel_dgetrf_pivot_4_vs_lib4+0xa34>
mov    0x18(%rsp),%rax
movq   $0x0,(%rax)
cmp    $0x1,%r15d
je     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
cmp    $0x1,%r12d
je     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
movsd  0x20(%rbx),%xmm0
movsd  0x28(%rbx),%xmm2
cmp    $0x4,%r15d
jl     1469 <kernel_dgetrf_pivot_4_vs_lib4+0x349>
movsd  0x38(%rbx),%xmm3
movupd 0x8(%rbx),%xmm4
movapd %xmm0,%xmm1
movhpd 0x30(%rbx),%xmm2
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
movlpd %xmm2,0x28(%rsp)
movhpd %xmm2,0x10(%rsp)
movsd  0x18(%rbx),%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x20(%rsp)
movupd %xmm2,0x28(%rbx)
movsd  %xmm3,0x38(%rbx)
lea    0x0(,%r13,4),%eax
movslq %eax,%rdx
lea    (%rbx,%rdx,8),%rax
xor    %ecx,%ecx
cmp    $0x8,%r15d
jb     1423 <kernel_dgetrf_pivot_4_vs_lib4+0x303>
lea    -0x7(%r15),%ecx
shl    $0x3,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd (%rax),%xmm4
movupd 0x10(%rax),%xmm5
movupd 0x20(%rax),%xmm3
movupd 0x30(%rax),%xmm2
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm3
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm2
movupd %xmm3,0x20(%rax)
movupd %xmm2,0x30(%rax)
add    $0x4,%esi
add    %rdx,%rax
cmp    %ecx,%esi
jl     13d0 <kernel_dgetrf_pivot_4_vs_lib4+0x2b0>
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
movlpd %xmm3,(%rsp)
movhpd %xmm3,0x28(%rsp)
movlpd %xmm2,0x10(%rsp)
movhpd %xmm2,0x20(%rsp)
cmp    %ebp,%ecx
jge    152f <kernel_dgetrf_pivot_4_vs_lib4+0x40f>
lea    -0x5(%r15),%edx
test   $0x1,%r15b
jne    14a9 <kernel_dgetrf_pivot_4_vs_lib4+0x389>
mov    %ecx,%esi
jmp    14d2 <kernel_dgetrf_pivot_4_vs_lib4+0x3b2>
cmp    $0x2,%r15d
jb     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx)
je     1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
mulsd  0x10(%rbx),%xmm0
movsd  %xmm0,0x10(%rbx)
jmp    1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
movsd  0x8(%rbx),%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  %xmm2,0x28(%rsp)
movsd  %xmm2,0x28(%rbx)
cmp    $0x3,%r15d
jne    152f <kernel_dgetrf_pivot_4_vs_lib4+0x40f>
mulsd  0x10(%rbx),%xmm0
movsd  0x30(%rbx),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  %xmm1,0x30(%rbx)
jmp    152f <kernel_dgetrf_pivot_4_vs_lib4+0x40f>
movsd  0x20(%rax),%xmm1
movsd  %xmm1,(%rsp)
movsd  (%rax),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x20(%rax)
add    $0x8,%rax
mov    %ecx,%esi
or     $0x1,%esi
cmp    %ecx,%edx
je     152f <kernel_dgetrf_pivot_4_vs_lib4+0x40f>
mov    %r15d,%ecx
sub    %esi,%ecx
add    $0xfffffffc,%ecx
xor    %edx,%edx
movsd  0x20(%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rsp)
movsd  (%rax,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x20(%rax,%rdx,8)
movsd  0x28(%rax,%rdx,8),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x8(%rax,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x28(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%ecx
jne    14e0 <kernel_dgetrf_pivot_4_vs_lib4+0x3c0>
mov    %ebp,0x8(%rsp)
lea    -0x1(%r15),%edi
lea    0x28(%rbx),%rbp
lea    0xc(%rsp),%r8
lea    0x28(%rsp),%r9
mov    $0x1,%esi
mov    %rbp,%rdx
mov    %r13d,%ecx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x1(%rcx),%eax
mov    0x30(%rsp),%rdx
mov    %eax,0x4(%rdx)
movsd  0x28(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    157c <kernel_dgetrf_pivot_4_vs_lib4+0x45c>
jnp    16dc <kernel_dgetrf_pivot_4_vs_lib4+0x5bc>
test   %ecx,%ecx
je     15b6 <kernel_dgetrf_pivot_4_vs_lib4+0x496>
lea    0x8(%rbx),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   %r13d,%edx
shl    $0x2,%edx
movslq %edx,%rdx
lea    (%rbx,%rdx,8),%rdx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    (%rdx,%rax,8),%rdx
mov    $0x4,%edi
xor    %eax,%eax
call   1040 <drowsw_lib@plt>
movsd  0x1a42(%rip),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x18(%rsp),%rax
movsd  %xmm0,0x8(%rax)
cmp    $0x4,%r15d
jl     16ef <kernel_dgetrf_pivot_4_vs_lib4+0x5cf>
movupd 0x30(%rbx),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm2
movupd %xmm2,0x30(%rbx)
lea    0x0(,%r13,4),%eax
movslq %eax,%rdx
lea    (%rbx,%rdx,8),%rax
xor    %ecx,%ecx
cmp    $0x8,%r15d
mov    0x8(%rsp),%edi
jb     164b <kernel_dgetrf_pivot_4_vs_lib4+0x52b>
lea    -0x7(%r15),%ecx
shl    $0x3,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x20(%rax),%xmm2
movupd 0x30(%rax),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x20(%rax)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x30(%rax)
add    $0x4,%esi
add    %rdx,%rax
cmp    %ecx,%esi
jl     1620 <kernel_dgetrf_pivot_4_vs_lib4+0x500>
mov    %edi,%ecx
and    $0xfffffffc,%ecx
cmp    %edi,%ecx
jge    1766 <kernel_dgetrf_pivot_4_vs_lib4+0x646>
mov    %r15d,%edx
sub    %ecx,%edx
add    $0xfffffffb,%edx
cmp    $0x3,%edx
jb     173d <kernel_dgetrf_pivot_4_vs_lib4+0x61d>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     1705 <kernel_dgetrf_pivot_4_vs_lib4+0x5e5>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
movupd 0x20(%rax,%rdi,8),%xmm2
movupd 0x30(%rax,%rdi,8),%xmm3
movupd 0x40(%rax,%rdi,8),%xmm4
movupd 0x50(%rax,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rax,%rdi,8)
movupd %xmm3,0x30(%rax,%rdi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x40(%rax,%rdi,8)
movupd %xmm5,0x50(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1690 <kernel_dgetrf_pivot_4_vs_lib4+0x570>
jmp    1707 <kernel_dgetrf_pivot_4_vs_lib4+0x5e7>
mov    0x18(%rsp),%rax
movq   $0x0,0x8(%rax)
mov    0x8(%rsp),%edi
jmp    1766 <kernel_dgetrf_pivot_4_vs_lib4+0x646>
cmp    $0x3,%r15d
mov    0x8(%rsp),%edi
jne    1766 <kernel_dgetrf_pivot_4_vs_lib4+0x646>
mulsd  0x30(%rbx),%xmm0
movsd  %xmm0,0x30(%rbx)
jmp    1766 <kernel_dgetrf_pivot_4_vs_lib4+0x646>
xor    %edi,%edi
test   $0x1,%sil
je     172d <kernel_dgetrf_pivot_4_vs_lib4+0x60d>
movupd 0x20(%rax,%rdi,8),%xmm2
movupd 0x30(%rax,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rax,%rdi,8)
movupd %xmm3,0x30(%rax,%rdi,8)
cmp    %r8,%rdx
mov    0x8(%rsp),%edi
je     1766 <kernel_dgetrf_pivot_4_vs_lib4+0x646>
add    %r8d,%ecx
lea    (%rax,%r8,8),%rax
mov    %r15d,%edx
sub    %ecx,%edx
mov    $0x4,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%edx
jne    1750 <kernel_dgetrf_pivot_4_vs_lib4+0x630>
cmp    $0x2,%r12d
je     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
movsd  0x40(%rbx),%xmm8
movsd  0x48(%rbx),%xmm9
movsd  0x8(%rbx),%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm2,%xmm9
movsd  %xmm9,0x48(%rbx)
cmp    $0x4,%r15d
jl     1883 <kernel_dgetrf_pivot_4_vs_lib4+0x763>
movupd 0x10(%rbx),%xmm3
movupd 0x30(%rbx),%xmm4
movupd 0x50(%rbx),%xmm5
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
mulpd  %xmm2,%xmm3
subpd  %xmm3,%xmm5
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
mulpd  %xmm3,%xmm4
subpd  %xmm4,%xmm5
movlpd %xmm5,0x10(%rsp)
movhpd %xmm5,0x20(%rsp)
movupd %xmm5,0x50(%rbx)
lea    0x0(,%r13,4),%eax
movslq %eax,%rdx
lea    (%rbx,%rdx,8),%rax
xor    %ecx,%ecx
cmp    $0x8,%r15d
jb     186d <kernel_dgetrf_pivot_4_vs_lib4+0x74d>
lea    -0x7(%r15),%ecx
shl    $0x3,%rdx
xor    %esi,%esi
movupd 0x40(%rax),%xmm5
movupd 0x50(%rax),%xmm4
movupd (%rax),%xmm6
movupd 0x10(%rax),%xmm7
movupd 0x20(%rax),%xmm1
movupd 0x30(%rax),%xmm0
mulpd  %xmm2,%xmm6
subpd  %xmm6,%xmm5
mulpd  %xmm2,%xmm7
subpd  %xmm7,%xmm4
mulpd  %xmm3,%xmm1
subpd  %xmm1,%xmm5
mulpd  %xmm3,%xmm0
subpd  %xmm0,%xmm4
movupd %xmm5,0x40(%rax)
movupd %xmm4,0x50(%rax)
add    $0x4,%esi
add    %rdx,%rax
cmp    %ecx,%esi
jl     1800 <kernel_dgetrf_pivot_4_vs_lib4+0x6e0>
mov    %edi,%ecx
and    $0xfffffffc,%ecx
movlpd %xmm5,(%rsp)
movhpd %xmm5,0x28(%rsp)
movlpd %xmm4,0x10(%rsp)
movhpd %xmm4,0x20(%rsp)
cmp    %edi,%ecx
jge    197f <kernel_dgetrf_pivot_4_vs_lib4+0x85f>
lea    -0x5(%r15),%edx
test   $0x1,%r15b
jne    18b8 <kernel_dgetrf_pivot_4_vs_lib4+0x798>
mov    %ecx,%esi
jmp    18f0 <kernel_dgetrf_pivot_4_vs_lib4+0x7d0>
cmp    $0x3,%r15d
jne    1b37 <kernel_dgetrf_pivot_4_vs_lib4+0xa17>
movsd  0x50(%rbx),%xmm0
mulsd  0x10(%rbx),%xmm8
mulsd  0x30(%rbx),%xmm9
subsd  %xmm8,%xmm0
subsd  %xmm9,%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  %xmm0,0x50(%rbx)
jmp    1989 <kernel_dgetrf_pivot_4_vs_lib4+0x869>
movsd  0x40(%rax),%xmm2
movsd  %xmm2,(%rsp)
movsd  (%rax),%xmm3
mulsd  %xmm8,%xmm3
subsd  %xmm3,%xmm2
movsd  0x20(%rax),%xmm3
mulsd  %xmm9,%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,(%rsp)
movsd  %xmm2,0x40(%rax)
add    $0x8,%rax
mov    %ecx,%esi
or     $0x1,%esi
cmp    %ecx,%edx
je     197f <kernel_dgetrf_pivot_4_vs_lib4+0x85f>
mov    %r15d,%ecx
sub    %esi,%ecx
add    $0xfffffffc,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x40(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm1,%xmm0
movsd  0x20(%rax,%rdx,8),%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x40(%rax,%rdx,8)
movsd  0x48(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm1,%xmm0
movsd  0x28(%rax,%rdx,8),%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x48(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%ecx
jne    1910 <kernel_dgetrf_pivot_4_vs_lib4+0x7f0>
cmp    $0x3,%r15d
jl     1b37 <kernel_dgetrf_pivot_4_vs_lib4+0xa17>
lea    -0x2(%r15),%edi
lea    0x50(%rbx),%rbp
lea    0xc(%rsp),%r8
lea    0x10(%rsp),%r9
mov    $0x2,%esi
mov    %rbp,%rdx
mov    %r13d,%ecx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x2(%rcx),%eax
mov    0x30(%rsp),%rdx
mov    %eax,0x8(%rdx)
movsd  0x10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19d2 <kernel_dgetrf_pivot_4_vs_lib4+0x8b2>
jnp    1b3e <kernel_dgetrf_pivot_4_vs_lib4+0xa1e>
test   %ecx,%ecx
je     1a0c <kernel_dgetrf_pivot_4_vs_lib4+0x8ec>
lea    0x10(%rbx),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   %r13d,%edx
shl    $0x2,%edx
movslq %edx,%rdx
lea    (%rbx,%rdx,8),%rdx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    (%rdx,%rax,8),%rdx
mov    $0x4,%edi
xor    %eax,%eax
call   1040 <drowsw_lib@plt>
movsd  0x15ec(%rip),%xmm0
divsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x18(%rsp),%rax
movsd  %xmm0,0x10(%rax)
mov    $0x1,%al
cmp    $0x4,%r15d
jl     1c91 <kernel_dgetrf_pivot_4_vs_lib4+0xb71>
movsd  0x58(%rbx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%rbx)
lea    0x0(,%r13,4),%ecx
movslq %ecx,%rsi
lea    (%rbx,%rsi,8),%rcx
xor    %edx,%edx
cmp    $0x8,%r15d
mov    0x8(%rsp),%ebp
jb     1a9b <kernel_dgetrf_pivot_4_vs_lib4+0x97b>
lea    -0x7(%r15),%edx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
shl    $0x3,%rsi
xor    %edi,%edi
movupd 0x40(%rcx),%xmm2
movupd 0x50(%rcx),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x40(%rcx)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x50(%rcx)
add    $0x4,%edi
add    %rsi,%rcx
cmp    %edx,%edi
jl     1a70 <kernel_dgetrf_pivot_4_vs_lib4+0x950>
mov    %ebp,%edx
and    $0xfffffffc,%edx
cmp    %ebp,%edx
jge    1c91 <kernel_dgetrf_pivot_4_vs_lib4+0xb71>
mov    %r15d,%esi
sub    %edx,%esi
add    $0xfffffffb,%esi
cmp    $0x3,%esi
jb     1c6f <kernel_dgetrf_pivot_4_vs_lib4+0xb4f>
add    $0x1,%rsi
mov    %rsi,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     1c3b <kernel_dgetrf_pivot_4_vs_lib4+0xb1b>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
movupd 0x40(%rcx,%rbp,8),%xmm2
movupd 0x50(%rcx,%rbp,8),%xmm3
movupd 0x60(%rcx,%rbp,8),%xmm4
movupd 0x70(%rcx,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x40(%rcx,%rbp,8)
movupd %xmm3,0x50(%rcx,%rbp,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x60(%rcx,%rbp,8)
movupd %xmm5,0x70(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1ae8 <kernel_dgetrf_pivot_4_vs_lib4+0x9c8>
jmp    1c3d <kernel_dgetrf_pivot_4_vs_lib4+0xb1d>
xor    %eax,%eax
jmp    1c91 <kernel_dgetrf_pivot_4_vs_lib4+0xb71>
mov    0x18(%rsp),%rax
movq   $0x0,0x10(%rax)
mov    $0x1,%al
jmp    1c91 <kernel_dgetrf_pivot_4_vs_lib4+0xb71>
xor    %edi,%edi
test   $0x1,%sil
je     1b83 <kernel_dgetrf_pivot_4_vs_lib4+0xa63>
movsd  (%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movupd 0x8(%rax,%rdi,8),%xmm1
movupd 0x18(%rax,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x8(%rax,%rdi,8)
movupd %xmm2,0x18(%rax,%rdi,8)
cmp    %r8,%rdx
mov    %r9d,%ebp
je     1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
add    %r8d,%ecx
lea    (%rax,%r8,8),%rax
mov    %r15d,%esi
sub    %ecx,%esi
lea    -0x5(%rsi),%edx
and    $0x3,%esi
je     1bcb <kernel_dgetrf_pivot_4_vs_lib4+0xaab>
movsd  (%rsp),%xmm0
neg    %esi
xor    %edi,%edi
nopl   0x0(%rax)
movsd  0x8(%rax),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rax)
add    $0x8,%rax
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1bb0 <kernel_dgetrf_pivot_4_vs_lib4+0xa90>
sub    %edi,%ecx
cmp    $0x3,%edx
jb     1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
movsd  (%rsp),%xmm0
mov    %r15d,%edx
sub    %ecx,%edx
mov    $0x4,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%rax,%rcx,8)
movsd  -0x10(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rax,%rcx,8)
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rax,%rcx,8)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %ecx,%edx
jne    1bf0 <kernel_dgetrf_pivot_4_vs_lib4+0xad0>
jmp    1337 <kernel_dgetrf_pivot_4_vs_lib4+0x217>
xor    %ebp,%ebp
test   $0x1,%r9b
je     1c63 <kernel_dgetrf_pivot_4_vs_lib4+0xb43>
movupd 0x40(%rcx,%rbp,8),%xmm2
movupd 0x50(%rcx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x40(%rcx,%rbp,8)
movupd %xmm3,0x50(%rcx,%rbp,8)
cmp    %r8,%rsi
je     1c91 <kernel_dgetrf_pivot_4_vs_lib4+0xb71>
add    %r8d,%edx
lea    (%rcx,%r8,8),%rcx
mov    %r15d,%esi
sub    %edx,%esi
add    $0xfffffffc,%esi
xor    %edx,%edx
movsd  0x40(%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%esi
jne    1c79 <kernel_dgetrf_pivot_4_vs_lib4+0xb59>
cmp    $0x4,%r12d
jl     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
movsd  0x60(%rbx),%xmm8
movsd  0x68(%rbx),%xmm10
movsd  0x8(%rbx),%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm2,%xmm10
movsd  %xmm10,0x68(%rbx)
cmp    $0x4,%r15d
jl     1f72 <kernel_dgetrf_pivot_4_vs_lib4+0xe52>
movsd  0x10(%rbx),%xmm3
mulsd  %xmm8,%xmm3
movsd  0x70(%rbx),%xmm9
subsd  %xmm3,%xmm9
movsd  0x78(%rbx),%xmm3
movsd  0x30(%rbx),%xmm4
mulsd  %xmm10,%xmm4
subsd  %xmm4,%xmm9
movsd  %xmm9,0x70(%rbx)
movsd  0x18(%rbx),%xmm4
mulsd  %xmm8,%xmm4
subsd  %xmm4,%xmm3
movsd  0x38(%rbx),%xmm4
mulsd  %xmm10,%xmm4
subsd  %xmm4,%xmm3
movsd  0x58(%rbx),%xmm4
mulsd  %xmm9,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x78(%rbx)
lea    0x0(,%r13,4),%eax
mov    %eax,0x3c(%rsp)
movslq %eax,%r12
lea    -0x7(%r15),%r14d
lea    (%rbx,%r12,8),%rbp
xor    %esi,%esi
mov    %rbp,%rax
cmp    $0x8,%r15d
jb     1e0a <kernel_dgetrf_pivot_4_vs_lib4+0xcea>
movapd %xmm8,%xmm11
unpcklpd %xmm8,%xmm11
movapd %xmm10,%xmm5
unpcklpd %xmm10,%xmm5
movapd %xmm9,%xmm6
unpcklpd %xmm9,%xmm6
lea    0x0(,%r12,8),%rcx
xor    %edx,%edx
mov    %rbp,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x60(%rax),%xmm7
movupd 0x70(%rax),%xmm3
movupd (%rax),%xmm1
movupd 0x10(%rax),%xmm2
movupd 0x20(%rax),%xmm0
movupd 0x30(%rax),%xmm4
mulpd  %xmm11,%xmm1
subpd  %xmm1,%xmm7
mulpd  %xmm11,%xmm2
subpd  %xmm2,%xmm3
mulpd  %xmm5,%xmm0
subpd  %xmm0,%xmm7
mulpd  %xmm5,%xmm4
subpd  %xmm4,%xmm3
movupd 0x40(%rax),%xmm0
mulpd  %xmm6,%xmm0
subpd  %xmm0,%xmm7
movupd 0x50(%rax),%xmm0
mulpd  %xmm6,%xmm0
subpd  %xmm0,%xmm3
movupd %xmm7,0x60(%rax)
movupd %xmm3,0x70(%rax)
add    $0x4,%edx
add    %rcx,%rax
cmp    %r14d,%edx
jl     1d80 <kernel_dgetrf_pivot_4_vs_lib4+0xc60>
mov    0x8(%rsp),%esi
and    $0xfffffffc,%esi
movlpd %xmm7,(%rsp)
movhpd %xmm7,0x28(%rsp)
movlpd %xmm3,0x10(%rsp)
unpckhpd %xmm3,%xmm3
lea    0x78(%rbx),%rdx
movsd  %xmm3,0x20(%rsp)
cmp    0x8(%rsp),%esi
jge    1e7a <kernel_dgetrf_pivot_4_vs_lib4+0xd5a>
mov    %r15d,%ecx
sub    %esi,%ecx
add    $0xfffffffc,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x60(%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm1,%xmm0
movsd  0x20(%rax,%rsi,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  0x40(%rax,%rsi,8),%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x60(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %esi,%ecx
jne    1e30 <kernel_dgetrf_pivot_4_vs_lib4+0xd10>
lea    -0x3(%r15),%edi
lea    0xc(%rsp),%r8
lea    0x20(%rsp),%r9
mov    $0x3,%esi
mov    %rdx,0x40(%rsp)
mov    %r13d,%ecx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x3(%rcx),%eax
mov    0x30(%rsp),%rdx
mov    %eax,0xc(%rdx)
movsd  0x20(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ec1 <kernel_dgetrf_pivot_4_vs_lib4+0xda1>
jnp    1f9f <kernel_dgetrf_pivot_4_vs_lib4+0xe7f>
test   %ecx,%ecx
je     1efb <kernel_dgetrf_pivot_4_vs_lib4+0xddb>
lea    0x18(%rbx),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
mov    0x3c(%rsp),%edi
imul   %edx,%edi
movslq %edi,%rdx
lea    (%rbx,%rdx,8),%rdx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    (%rdx,%rax,8),%rdx
mov    $0x4,%edi
xor    %eax,%eax
call   1040 <drowsw_lib@plt>
movsd  0x10fd(%rip),%xmm0
mov    0x40(%rsp),%rax
divsd  (%rax),%xmm0
xor    %eax,%eax
movsd  %xmm0,0x20(%rsp)
mov    0x18(%rsp),%rcx
movsd  %xmm0,0x18(%rcx)
cmp    $0x8,%r15d
jb     1fb1 <kernel_dgetrf_pivot_4_vs_lib4+0xe91>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
shl    $0x3,%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd 0x60(%rbp),%xmm2
movupd 0x70(%rbp),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x60(%rbp)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x70(%rbp)
add    $0x4,%eax
add    %r12,%rbp
cmp    %r14d,%eax
jl     1f40 <kernel_dgetrf_pivot_4_vs_lib4+0xe20>
mov    0x8(%rsp),%ecx
mov    %ecx,%eax
and    $0xfffffffc,%eax
jmp    1fb5 <kernel_dgetrf_pivot_4_vs_lib4+0xe95>
test   %al,%al
je     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
movsd  0x70(%rbx),%xmm0
mulsd  0x10(%rbx),%xmm8
subsd  %xmm8,%xmm0
mulsd  0x30(%rbx),%xmm10
subsd  %xmm10,%xmm0
movsd  %xmm0,0x70(%rbx)
jmp    20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
mov    0x18(%rsp),%rax
movq   $0x0,0x18(%rax)
jmp    20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
mov    0x8(%rsp),%ecx
cmp    %ecx,%eax
jge    20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
mov    %r15d,%ecx
sub    %eax,%ecx
add    $0xfffffffb,%ecx
cmp    $0x3,%ecx
jb     2089 <kernel_dgetrf_pivot_4_vs_lib4+0xf69>
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     2056 <kernel_dgetrf_pivot_4_vs_lib4+0xf36>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movupd 0x60(%rbp,%rsi,8),%xmm2
movupd 0x70(%rbp,%rsi,8),%xmm3
movupd 0x80(%rbp,%rsi,8),%xmm4
movupd 0x90(%rbp,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x60(%rbp,%rsi,8)
movupd %xmm3,0x70(%rbp,%rsi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x80(%rbp,%rsi,8)
movupd %xmm5,0x90(%rbp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1ffe <kernel_dgetrf_pivot_4_vs_lib4+0xede>
jmp    2058 <kernel_dgetrf_pivot_4_vs_lib4+0xf38>
xor    %esi,%esi
test   $0x1,%bl
je     207d <kernel_dgetrf_pivot_4_vs_lib4+0xf5d>
movupd 0x60(%rbp,%rsi,8),%xmm2
movupd 0x70(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x60(%rbp,%rsi,8)
movupd %xmm3,0x70(%rbp,%rsi,8)
cmp    %rdx,%rcx
je     20ab <kernel_dgetrf_pivot_4_vs_lib4+0xf8b>
add    %edx,%eax
lea    0x0(%rbp,%rdx,8),%rbp
sub    %eax,%r15d
add    $0xfffffffc,%r15d
xor    %eax,%eax
movsd  0x60(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%rbp,%rax,8)
add    $0x1,%rax
cmp    %eax,%r15d
jne    2092 <kernel_dgetrf_pivot_4_vs_lib4+0xf72>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kernel_dgetrf_pivot_4_vs_lib4(i32 %0, i32 %1, double* %2, i32 %3, double* %4, i32* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca double*
%10 = alloca i32
%11 = alloca double*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32
%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 i32
%31 = alloca i32
store i32 %0, i32* %7
store i32 %1, i32* %8
store double* %2, double** %9
store i32 %3, i32* %10
store double* %4, double** %11
store i32* %5, i32** %12
%32 = load i32, i32* %7
%33 = icmp sle i32 %32, 0
br i1 %33, label %37, label %34
34: ; preds = %6
%35 = load i32, i32* %8
%36 = icmp sle i32 %35, 0
br i1 %36, label %37, label %38
37: ; preds = %34, %6
br label %1236
38: ; preds = %34
store i32 4, i32* %13
%39 = load i32, i32* %7
%40 = sub nsw i32 %39, 4
store i32 %40, i32* %14
%41 = load i32, i32* %7
%42 = sub nsw i32 %41, 0
%43 = load double*, double** %9
%44 = getelementptr inbounds double, double* %43, i64 0
%45 = load i32, i32* %10
%46 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %42, i32 0, double* %44, i32 %45, i32* %31, double* %15)
%47 = load i32, i32* %31
%48 = load i32*, i32** %12
%49 = getelementptr inbounds i32, i32* %48, i64 0
store i32 %47, i32* %49
%50 = load double, double* %15
%51 = fcmp une double %50, 0.000000e+00
br i1 %51, label %52, label %179
52: ; preds = %38
%53 = load i32*, i32** %12
%54 = getelementptr inbounds i32, i32* %53, i64 0
%55 = load i32, i32* %54
%56 = icmp ne i32 %55, 0
br i1 %56, label %57, label %77
57: ; preds = %52
%58 = load double*, double** %9
%59 = getelementptr inbounds double, double* %58, i64 0
%60 = load double*, double** %9
%61 = load i32*, i32** %12
%62 = getelementptr inbounds i32, i32* %61, i64 0
%63 = load i32, i32* %62
%64 = sdiv i32 %63, 4
%65 = mul nsw i32 %64, 4
%66 = load i32, i32* %10
%67 = mul nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %60, i64 %68
%70 = load i32*, i32** %12
%71 = getelementptr inbounds i32, i32* %70, i64 0
%72 = load i32, i32* %71
%73 = srem i32 %72, 4
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %69, i64 %74
%76 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %59, double* %75)
br label %77
77: ; preds = %57, %52
%78 = load double*, double** %9
%79 = getelementptr inbounds double, double* %78, i64 0
%80 = load double, double* %79
%81 = fdiv double 1.000000e+00, %80
store double %81, double* %15
%82 = load double, double* %15
%83 = load double*, double** %11
%84 = getelementptr inbounds double, double* %83, i64 0
store double %82, double* %84
%85 = load i32, i32* %7
%86 = icmp sge i32 %85, 4
br i1 %86, label %87, label %159
87: ; preds = %77
%88 = load double, double* %15
%89 = load double*, double** %9
%90 = getelementptr inbounds double, double* %89, i64 1
%91 = load double, double* %90
%92 = fmul double %91, %88
store double %92, double* %90
%93 = load double, double* %15
%94 = load double*, double** %9
%95 = getelementptr inbounds double, double* %94, i64 2
%96 = load double, double* %95
%97 = fmul double %96, %93
store double %97, double* %95
%98 = load double, double* %15
%99 = load double*, double** %9
%100 = getelementptr inbounds double, double* %99, i64 3
%101 = load double, double* %100
%102 = fmul double %101, %98
store double %102, double* %100
%103 = load double*, double** %9
%104 = load i32, i32* %10
%105 = mul nsw i32 4, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %103, i64 %106
store double* %107, double** %29
store i32 0, i32* %30
br label %108
108: ; preds = %139, %87
%109 = load i32, i32* %30
%110 = load i32, i32* %14
%111 = sub nsw i32 %110, 3
%112 = icmp slt i32 %109, %111
br i1 %112, label %113, label %142
113: ; preds = %108
%114 = load double, double* %15
%115 = load double*, double** %29
%116 = getelementptr inbounds double, double* %115, i64 0
%117 = load double, double* %116
%118 = fmul double %117, %114
store double %118, double* %116
%119 = load double, double* %15
%120 = load double*, double** %29
%121 = getelementptr inbounds double, double* %120, i64 1
%122 = load double, double* %121
%123 = fmul double %122, %119
store double %123, double* %121
%124 = load double, double* %15
%125 = load double*, double** %29
%126 = getelementptr inbounds double, double* %125, i64 2
%127 = load double, double* %126
%128 = fmul double %127, %124
store double %128, double* %126
%129 = load double, double* %15
%130 = load double*, double** %29
%131 = getelementptr inbounds double, double* %130, i64 3
%132 = load double, double* %131
%133 = fmul double %132, %129
store double %133, double* %131
%134 = load i32, i32* %10
%135 = mul nsw i32 4, %134
%136 = load double*, double** %29
%137 = sext i32 %135 to i64
%138 = getelementptr inbounds double, double* %136, i64 %137
store double* %138, double** %29
br label %139
139: ; preds = %113
%140 = load i32, i32* %30
%141 = add nsw i32 %140, 4
store i32 %141, i32* %30
br label %108
142: ; preds = %108
br label %143
143: ; preds = %155, %142
%144 = load i32, i32* %30
%145 = load i32, i32* %14
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %158
147: ; preds = %143
%148 = load double, double* %15
%149 = load double*, double** %29
%150 = getelementptr inbounds double, double* %149, i64 0
%151 = load double, double* %150
%152 = fmul double %151, %148
store double %152, double* %150
%153 = load double*, double** %29
%154 = getelementptr inbounds double, double* %153, i64 1
store double* %154, double** %29
br label %155
155: ; preds = %147
%156 = load i32, i32* %30
%157 = add nsw i32 %156, 1
store i32 %157, i32* %30
br label %143
158: ; preds = %143
br label %178
159: ; preds = %77
%160 = load i32, i32* %7
%161 = icmp sgt i32 %160, 1
br i1 %161, label %162, label %177
162: ; preds = %159
%163 = load double, double* %15
%164 = load double*, double** %9
%165 = getelementptr inbounds double, double* %164, i64 1
%166 = load double, double* %165
%167 = fmul double %166, %163
store double %167, double* %165
%168 = load i32, i32* %7
%169 = icmp sgt i32 %168, 2
br i1 %169, label %170, label %176
170: ; preds = %162
%171 = load double, double* %15
%172 = load double*, double** %9
%173 = getelementptr inbounds double, double* %172, i64 2
%174 = load double, double* %173
%175 = fmul double %174, %171
store double %175, double* %173
br label %176
176: ; preds = %170, %162
br label %177
177: ; preds = %176, %159
br label %178
178: ; preds = %177, %158
br label %182
179: ; preds = %38
%180 = load double*, double** %11
%181 = getelementptr inbounds double, double* %180, i64 0
store double 0.000000e+00, double* %181
br label %182
182: ; preds = %179, %178
%183 = load i32, i32* %8
%184 = icmp eq i32 %183, 1
br i1 %184, label %188, label %185
185: ; preds = %182
%186 = load i32, i32* %7
%187 = icmp eq i32 %186, 1
br i1 %187, label %188, label %189
188: ; preds = %185, %182
br label %1236
189: ; preds = %185
%190 = load i32, i32* %7
%191 = icmp sge i32 %190, 4
br i1 %191, label %192, label %331
192: ; preds = %189
%193 = load double*, double** %9
%194 = getelementptr inbounds double, double* %193, i64 4
%195 = load double, double* %194
store double %195, double* %20
%196 = load double*, double** %9
%197 = getelementptr inbounds double, double* %196, i64 5
%198 = load double, double* %197
store double %198, double* %16
%199 = load double*, double** %9
%200 = getelementptr inbounds double, double* %199, i64 6
%201 = load double, double* %200
store double %201, double* %17
%202 = load double*, double** %9
%203 = getelementptr inbounds double, double* %202, i64 7
%204 = load double, double* %203
store double %204, double* %18
%205 = load double*, double** %9
%206 = getelementptr inbounds double, double* %205, i64 1
%207 = load double, double* %206
%208 = load double, double* %20
%209 = load double, double* %16
%210 = fneg double %207
%211 = call double @llvm.fmuladd.f64(double %210, double %208, double %209)
store double %211, double* %16
%212 = load double*, double** %9
%213 = getelementptr inbounds double, double* %212, i64 2
%214 = load double, double* %213
%215 = load double, double* %20
%216 = load double, double* %17
%217 = fneg double %214
%218 = call double @llvm.fmuladd.f64(double %217, double %215, double %216)
store double %218, double* %17
%219 = load double*, double** %9
%220 = getelementptr inbounds double, double* %219, i64 3
%221 = load double, double* %220
%222 = load double, double* %20
%223 = load double, double* %18
%224 = fneg double %221
%225 = call double @llvm.fmuladd.f64(double %224, double %222, double %223)
store double %225, double* %18
%226 = load double, double* %16
%227 = load double*, double** %9
%228 = getelementptr inbounds double, double* %227, i64 5
store double %226, double* %228
%229 = load double, double* %17
%230 = load double*, double** %9
%231 = getelementptr inbounds double, double* %230, i64 6
store double %229, double* %231
%232 = load double, double* %18
%233 = load double*, double** %9
%234 = getelementptr inbounds double, double* %233, i64 7
store double %232, double* %234
%235 = load double*, double** %9
%236 = load i32, i32* %10
%237 = mul nsw i32 4, %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %235, i64 %238
store double* %239, double** %29
store i32 0, i32* %30
br label %240
240: ; preds = %303, %192
%241 = load i32, i32* %30
%242 = load i32, i32* %14
%243 = sub nsw i32 %242, 3
%244 = icmp slt i32 %241, %243
br i1 %244, label %245, label %306
245: ; preds = %240
%246 = load double*, double** %29
%247 = getelementptr inbounds double, double* %246, i64 4
%248 = load double, double* %247
store double %248, double* %15
%249 = load double*, double** %29
%250 = getelementptr inbounds double, double* %249, i64 5
%251 = load double, double* %250
store double %251, double* %16
%252 = load double*, double** %29
%253 = getelementptr inbounds double, double* %252, i64 6
%254 = load double, double* %253
store double %254, double* %17
%255 = load double*, double** %29
%256 = getelementptr inbounds double, double* %255, i64 7
%257 = load double, double* %256
store double %257, double* %18
%258 = load double*, double** %29
%259 = getelementptr inbounds double, double* %258, i64 0
%260 = load double, double* %259
%261 = load double, double* %20
%262 = load double, double* %15
%263 = fneg double %260
%264 = call double @llvm.fmuladd.f64(double %263, double %261, double %262)
store double %264, double* %15
%265 = load double*, double** %29
%266 = getelementptr inbounds double, double* %265, i64 1
%267 = load double, double* %266
%268 = load double, double* %20
%269 = load double, double* %16
%270 = fneg double %267
%271 = call double @llvm.fmuladd.f64(double %270, double %268, double %269)
store double %271, double* %16
%272 = load double*, double** %29
%273 = getelementptr inbounds double, double* %272, i64 2
%274 = load double, double* %273
%275 = load double, double* %20
%276 = load double, double* %17
%277 = fneg double %274
%278 = call double @llvm.fmuladd.f64(double %277, double %275, double %276)
store double %278, double* %17
%279 = load double*, double** %29
%280 = getelementptr inbounds double, double* %279, i64 3
%281 = load double, double* %280
%282 = load double, double* %20
%283 = load double, double* %18
%284 = fneg double %281
%285 = call double @llvm.fmuladd.f64(double %284, double %282, double %283)
store double %285, double* %18
%286 = load double, double* %15
%287 = load double*, double** %29
%288 = getelementptr inbounds double, double* %287, i64 4
store double %286, double* %288
%289 = load double, double* %16
%290 = load double*, double** %29
%291 = getelementptr inbounds double, double* %290, i64 5
store double %289, double* %291
%292 = load double, double* %17
%293 = load double*, double** %29
%294 = getelementptr inbounds double, double* %293, i64 6
store double %292, double* %294
%295 = load double, double* %18
%296 = load double*, double** %29
%297 = getelementptr inbounds double, double* %296, i64 7
store double %295, double* %297
%298 = load i32, i32* %10
%299 = mul nsw i32 4, %298
%300 = load double*, double** %29
%301 = sext i32 %299 to i64
%302 = getelementptr inbounds double, double* %300, i64 %301
store double* %302, double** %29
br label %303
303: ; preds = %245
%304 = load i32, i32* %30
%305 = add nsw i32 %304, 4
store i32 %305, i32* %30
br label %240
306: ; preds = %240
br label %307
307: ; preds = %327, %306
%308 = load i32, i32* %30
%309 = load i32, i32* %14
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %330
311: ; preds = %307
%312 = load double*, double** %29
%313 = getelementptr inbounds double, double* %312, i64 4
%314 = load double, double* %313
store double %314, double* %15
%315 = load double*, double** %29
%316 = getelementptr inbounds double, double* %315, i64 0
%317 = load double, double* %316
%318 = load double, double* %20
%319 = load double, double* %15
%320 = fneg double %317
%321 = call double @llvm.fmuladd.f64(double %320, double %318, double %319)
store double %321, double* %15
%322 = load double, double* %15
%323 = load double*, double** %29
%324 = getelementptr inbounds double, double* %323, i64 4
store double %322, double* %324
%325 = load double*, double** %29
%326 = getelementptr inbounds double, double* %325, i64 1
store double* %326, double** %29
br label %327
327: ; preds = %311
%328 = load i32, i32* %30
%329 = add nsw i32 %328, 1
store i32 %329, i32* %30
br label %307
330: ; preds = %307
br label %365
331: ; preds = %189
%332 = load double*, double** %9
%333 = getelementptr inbounds double, double* %332, i64 4
%334 = load double, double* %333
store double %334, double* %20
%335 = load double*, double** %9
%336 = getelementptr inbounds double, double* %335, i64 5
%337 = load double, double* %336
store double %337, double* %16
%338 = load double*, double** %9
%339 = getelementptr inbounds double, double* %338, i64 1
%340 = load double, double* %339
%341 = load double, double* %20
%342 = load double, double* %16
%343 = fneg double %340
%344 = call double @llvm.fmuladd.f64(double %343, double %341, double %342)
store double %344, double* %16
%345 = load double, double* %16
%346 = load double*, double** %9
%347 = getelementptr inbounds double, double* %346, i64 5
store double %345, double* %347
%348 = load i32, i32* %7
%349 = icmp sgt i32 %348, 2
br i1 %349, label %350, label %364
350: ; preds = %331
%351 = load double*, double** %9
%352 = getelementptr inbounds double, double* %351, i64 6
%353 = load double, double* %352
store double %353, double* %17
%354 = load double*, double** %9
%355 = getelementptr inbounds double, double* %354, i64 2
%356 = load double, double* %355
%357 = load double, double* %20
%358 = load double, double* %17
%359 = fneg double %356
%360 = call double @llvm.fmuladd.f64(double %359, double %357, double %358)
store double %360, double* %17
%361 = load double, double* %17
%362 = load double*, double** %9
%363 = getelementptr inbounds double, double* %362, i64 6
store double %361, double* %363
br label %364
364: ; preds = %350, %331
br label %365
365: ; preds = %364, %330
%366 = load i32, i32* %7
%367 = sub nsw i32 %366, 1
%368 = load double*, double** %9
%369 = getelementptr inbounds double, double* %368, i64 5
%370 = load i32, i32* %10
%371 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %367, i32 1, double* %369, i32 %370, i32* %31, double* %16)
%372 = load i32, i32* %31
%373 = add nsw i32 %372, 1
%374 = load i32*, i32** %12
%375 = getelementptr inbounds i32, i32* %374, i64 1
store i32 %373, i32* %375
%376 = load double, double* %16
%377 = fcmp une double %376, 0.000000e+00
br i1 %377, label %378, label %491
378: ; preds = %365
%379 = load i32*, i32** %12
%380 = getelementptr inbounds i32, i32* %379, i64 1
%381 = load i32, i32* %380
%382 = icmp ne i32 %381, 1
br i1 %382, label %383, label %403
383: ; preds = %378
%384 = load double*, double** %9
%385 = getelementptr inbounds double, double* %384, i64 1
%386 = load double*, double** %9
%387 = load i32*, i32** %12
%388 = getelementptr inbounds i32, i32* %387, i64 1
%389 = load i32, i32* %388
%390 = sdiv i32 %389, 4
%391 = mul nsw i32 %390, 4
%392 = load i32, i32* %10
%393 = mul nsw i32 %391, %392
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %386, i64 %394
%396 = load i32*, i32** %12
%397 = getelementptr inbounds i32, i32* %396, i64 1
%398 = load i32, i32* %397
%399 = srem i32 %398, 4
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %395, i64 %400
%402 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %385, double* %401)
br label %403
403: ; preds = %383, %378
%404 = load double*, double** %9
%405 = getelementptr inbounds double, double* %404, i64 5
%406 = load double, double* %405
%407 = fdiv double 1.000000e+00, %406
store double %407, double* %16
%408 = load double, double* %16
%409 = load double*, double** %11
%410 = getelementptr inbounds double, double* %409, i64 1
store double %408, double* %410
%411 = load i32, i32* %7
%412 = icmp sge i32 %411, 4
br i1 %412, label %413, label %480
413: ; preds = %403
%414 = load double, double* %16
%415 = load double*, double** %9
%416 = getelementptr inbounds double, double* %415, i64 6
%417 = load double, double* %416
%418 = fmul double %417, %414
store double %418, double* %416
%419 = load double, double* %16
%420 = load double*, double** %9
%421 = getelementptr inbounds double, double* %420, i64 7
%422 = load double, double* %421
%423 = fmul double %422, %419
store double %423, double* %421
%424 = load double*, double** %9
%425 = load i32, i32* %10
%426 = mul nsw i32 4, %425
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %424, i64 %427
store double* %428, double** %29
store i32 0, i32* %30
br label %429
429: ; preds = %460, %413
%430 = load i32, i32* %30
%431 = load i32, i32* %14
%432 = sub nsw i32 %431, 3
%433 = icmp slt i32 %430, %432
br i1 %433, label %434, label %463
434: ; preds = %429
%435 = load double, double* %16
%436 = load double*, double** %29
%437 = getelementptr inbounds double, double* %436, i64 4
%438 = load double, double* %437
%439 = fmul double %438, %435
store double %439, double* %437
%440 = load double, double* %16
%441 = load double*, double** %29
%442 = getelementptr inbounds double, double* %441, i64 5
%443 = load double, double* %442
%444 = fmul double %443, %440
store double %444, double* %442
%445 = load double, double* %16
%446 = load double*, double** %29
%447 = getelementptr inbounds double, double* %446, i64 6
%448 = load double, double* %447
%449 = fmul double %448, %445
store double %449, double* %447
%450 = load double, double* %16
%451 = load double*, double** %29
%452 = getelementptr inbounds double, double* %451, i64 7
%453 = load double, double* %452
%454 = fmul double %453, %450
store double %454, double* %452
%455 = load i32, i32* %10
%456 = mul nsw i32 4, %455
%457 = load double*, double** %29
%458 = sext i32 %456 to i64
%459 = getelementptr inbounds double, double* %457, i64 %458
store double* %459, double** %29
br label %460
460: ; preds = %434
%461 = load i32, i32* %30
%462 = add nsw i32 %461, 4
store i32 %462, i32* %30
br label %429
463: ; preds = %429
br label %464
464: ; preds = %476, %463
%465 = load i32, i32* %30
%466 = load i32, i32* %14
%467 = icmp slt i32 %465, %466
br i1 %467, label %468, label %479
468: ; preds = %464
%469 = load double, double* %16
%470 = load double*, double** %29
%471 = getelementptr inbounds double, double* %470, i64 4
%472 = load double, double* %471
%473 = fmul double %472, %469
store double %473, double* %471
%474 = load double*, double** %29
%475 = getelementptr inbounds double, double* %474, i64 1
store double* %475, double** %29
br label %476
476: ; preds = %468
%477 = load i32, i32* %30
%478 = add nsw i32 %477, 1
store i32 %478, i32* %30
br label %464
479: ; preds = %464
br label %490
480: ; preds = %403
%481 = load i32, i32* %7
%482 = icmp sgt i32 %481, 2
br i1 %482, label %483, label %489
483: ; preds = %480
%484 = load double, double* %16
%485 = load double*, double** %9
%486 = getelementptr inbounds double, double* %485, i64 6
%487 = load double, double* %486
%488 = fmul double %487, %484
store double %488, double* %486
br label %489
489: ; preds = %483, %480
br label %490
490: ; preds = %489, %479
br label %494
491: ; preds = %365
%492 = load double*, double** %11
%493 = getelementptr inbounds double, double* %492, i64 1
store double 0.000000e+00, double* %493
br label %494
494: ; preds = %491, %490
%495 = load i32, i32* %8
%496 = icmp eq i32 %495, 2
br i1 %496, label %497, label %498
497: ; preds = %494
br label %1236
498: ; preds = %494
%499 = load i32, i32* %7
%500 = icmp sge i32 %499, 4
br i1 %500, label %501, label %689
501: ; preds = %498
%502 = load double*, double** %9
%503 = getelementptr inbounds double, double* %502, i64 8
%504 = load double, double* %503
store double %504, double* %21
%505 = load double*, double** %9
%506 = getelementptr inbounds double, double* %505, i64 9
%507 = load double, double* %506
store double %507, double* %24
%508 = load double*, double** %9
%509 = getelementptr inbounds double, double* %508, i64 1
%510 = load double, double* %509
%511 = load double, double* %21
%512 = load double, double* %24
%513 = fneg double %510
%514 = call double @llvm.fmuladd.f64(double %513, double %511, double %512)
store double %514, double* %24
%515 = load double, double* %24
%516 = load double*, double** %9
%517 = getelementptr inbounds double, double* %516, i64 9
store double %515, double* %517
%518 = load double*, double** %9
%519 = getelementptr inbounds double, double* %518, i64 10
%520 = load double, double* %519
store double %520, double* %17
%521 = load double*, double** %9
%522 = getelementptr inbounds double, double* %521, i64 11
%523 = load double, double* %522
store double %523, double* %18
%524 = load double*, double** %9
%525 = getelementptr inbounds double, double* %524, i64 2
%526 = load double, double* %525
%527 = load double, double* %21
%528 = load double, double* %17
%529 = fneg double %526
%530 = call double @llvm.fmuladd.f64(double %529, double %527, double %528)
store double %530, double* %17
%531 = load double*, double** %9
%532 = getelementptr inbounds double, double* %531, i64 3
%533 = load double, double* %532
%534 = load double, double* %21
%535 = load double, double* %18
%536 = fneg double %533
%537 = call double @llvm.fmuladd.f64(double %536, double %534, double %535)
store double %537, double* %18
%538 = load double*, double** %9
%539 = getelementptr inbounds double, double* %538, i64 6
%540 = load double, double* %539
%541 = load double, double* %24
%542 = load double, double* %17
%543 = fneg double %540
%544 = call double @llvm.fmuladd.f64(double %543, double %541, double %542)
store double %544, double* %17
%545 = load double*, double** %9
%546 = getelementptr inbounds double, double* %545, i64 7
%547 = load double, double* %546
%548 = load double, double* %24
%549 = load double, double* %18
%550 = fneg double %547
%551 = call double @llvm.fmuladd.f64(double %550, double %548, double %549)
store double %551, double* %18
%552 = load double, double* %17
%553 = load double*, double** %9
%554 = getelementptr inbounds double, double* %553, i64 10
store double %552, double* %554
%555 = load double, double* %18
%556 = load double*, double** %9
%557 = getelementptr inbounds double, double* %556, i64 11
store double %555, double* %557
%558 = load double*, double** %9
%559 = load i32, i32* %10
%560 = mul nsw i32 4, %559
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double, double* %558, i64 %561
store double* %562, double** %29
store i32 0, i32* %30
br label %563
563: ; preds = %654, %501
%564 = load i32, i32* %30
%565 = load i32, i32* %14
%566 = sub nsw i32 %565, 3
%567 = icmp slt i32 %564, %566
br i1 %567, label %568, label %657
568: ; preds = %563
%569 = load double*, double** %29
%570 = getelementptr inbounds double, double* %569, i64 8
%571 = load double, double* %570
store double %571, double* %15
%572 = load double*, double** %29
%573 = getelementptr inbounds double, double* %572, i64 9
%574 = load double, double* %573
store double %574, double* %16
%575 = load double*, double** %29
%576 = getelementptr inbounds double, double* %575, i64 10
%577 = load double, double* %576
store double %577, double* %17
%578 = load double*, double** %29
%579 = getelementptr inbounds double, double* %578, i64 11
%580 = load double, double* %579
store double %580, double* %18
%581 = load double*, double** %29
%582 = getelementptr inbounds double, double* %581, i64 0
%583 = load double, double* %582
%584 = load double, double* %21
%585 = load double, double* %15
%586 = fneg double %583
%587 = call double @llvm.fmuladd.f64(double %586, double %584, double %585)
store double %587, double* %15
%588 = load double*, double** %29
%589 = getelementptr inbounds double, double* %588, i64 1
%590 = load double, double* %589
%591 = load double, double* %21
%592 = load double, double* %16
%593 = fneg double %590
%594 = call double @llvm.fmuladd.f64(double %593, double %591, double %592)
store double %594, double* %16
%595 = load double*, double** %29
%596 = getelementptr inbounds double, double* %595, i64 2
%597 = load double, double* %596
%598 = load double, double* %21
%599 = load double, double* %17
%600 = fneg double %597
%601 = call double @llvm.fmuladd.f64(double %600, double %598, double %599)
store double %601, double* %17
%602 = load double*, double** %29
%603 = getelementptr inbounds double, double* %602, i64 3
%604 = load double, double* %603
%605 = load double, double* %21
%606 = load double, double* %18
%607 = fneg double %604
%608 = call double @llvm.fmuladd.f64(double %607, double %605, double %606)
store double %608, double* %18
%609 = load double*, double** %29
%610 = getelementptr inbounds double, double* %609, i64 4
%611 = load double, double* %610
%612 = load double, double* %24
%613 = load double, double* %15
%614 = fneg double %611
%615 = call double @llvm.fmuladd.f64(double %614, double %612, double %613)
store double %615, double* %15
%616 = load double*, double** %29
%617 = getelementptr inbounds double, double* %616, i64 5
%618 = load double, double* %617
%619 = load double, double* %24
%620 = load double, double* %16
%621 = fneg double %618
%622 = call double @llvm.fmuladd.f64(double %621, double %619, double %620)
store double %622, double* %16
%623 = load double*, double** %29
%624 = getelementptr inbounds double, double* %623, i64 6
%625 = load double, double* %624
%626 = load double, double* %24
%627 = load double, double* %17
%628 = fneg double %625
%629 = call double @llvm.fmuladd.f64(double %628, double %626, double %627)
store double %629, double* %17
%630 = load double*, double** %29
%631 = getelementptr inbounds double, double* %630, i64 7
%632 = load double, double* %631
%633 = load double, double* %24
%634 = load double, double* %18
%635 = fneg double %632
%636 = call double @llvm.fmuladd.f64(double %635, double %633, double %634)
store double %636, double* %18
%637 = load double, double* %15
%638 = load double*, double** %29
%639 = getelementptr inbounds double, double* %638, i64 8
store double %637, double* %639
%640 = load double, double* %16
%641 = load double*, double** %29
%642 = getelementptr inbounds double, double* %641, i64 9
store double %640, double* %642
%643 = load double, double* %17
%644 = load double*, double** %29
%645 = getelementptr inbounds double, double* %644, i64 10
store double %643, double* %645
%646 = load double, double* %18
%647 = load double*, double** %29
%648 = getelementptr inbounds double, double* %647, i64 11
store double %646, double* %648
%649 = load i32, i32* %10
%650 = mul nsw i32 4, %649
%651 = load double*, double** %29
%652 = sext i32 %650 to i64
%653 = getelementptr inbounds double, double* %651, i64 %652
store double* %653, double** %29
br label %654
654: ; preds = %568
%655 = load i32, i32* %30
%656 = add nsw i32 %655, 4
store i32 %656, i32* %30
br label %563
657: ; preds = %563
br label %658
658: ; preds = %685, %657
%659 = load i32, i32* %30
%660 = load i32, i32* %14
%661 = icmp slt i32 %659, %660
br i1 %661, label %662, label %688
662: ; preds = %658
%663 = load double*, double** %29
%664 = getelementptr inbounds double, double* %663, i64 8
%665 = load double, double* %664
store double %665, double* %15
%666 = load double*, double** %29
%667 = getelementptr inbounds double, double* %666, i64 0
%668 = load double, double* %667
%669 = load double, double* %21
%670 = load double, double* %15
%671 = fneg double %668
%672 = call double @llvm.fmuladd.f64(double %671, double %669, double %670)
store double %672, double* %15
%673 = load double*, double** %29
%674 = getelementptr inbounds double, double* %673, i64 4
%675 = load double, double* %674
%676 = load double, double* %24
%677 = load double, double* %15
%678 = fneg double %675
%679 = call double @llvm.fmuladd.f64(double %678, double %676, double %677)
store double %679, double* %15
%680 = load double, double* %15
%681 = load double*, double** %29
%682 = getelementptr inbounds double, double* %681, i64 8
store double %680, double* %682
%683 = load double*, double** %29
%684 = getelementptr inbounds double, double* %683, i64 1
store double* %684, double** %29
br label %685
685: ; preds = %662
%686 = load i32, i32* %30
%687 = add nsw i32 %686, 1
store i32 %687, i32* %30
br label %658
688: ; preds = %658
br label %730
689: ; preds = %498
%690 = load double*, double** %9
%691 = getelementptr inbounds double, double* %690, i64 8
%692 = load double, double* %691
store double %692, double* %21
%693 = load double*, double** %9
%694 = getelementptr inbounds double, double* %693, i64 9
%695 = load double, double* %694
store double %695, double* %24
%696 = load double*, double** %9
%697 = getelementptr inbounds double, double* %696, i64 1
%698 = load double, double* %697
%699 = load double, double* %21
%700 = load double, double* %24
%701 = fneg double %698
%702 = call double @llvm.fmuladd.f64(double %701, double %699, double %700)
store double %702, double* %24
%703 = load double, double* %24
%704 = load double*, double** %9
%705 = getelementptr inbounds double, double* %704, i64 9
store double %703, double* %705
%706 = load i32, i32* %7
%707 = icmp sgt i32 %706, 2
br i1 %707, label %708, label %729
708: ; preds = %689
%709 = load double*, double** %9
%710 = getelementptr inbounds double, double* %709, i64 10
%711 = load double, double* %710
store double %711, double* %17
%712 = load double*, double** %9
%713 = getelementptr inbounds double, double* %712, i64 2
%714 = load double, double* %713
%715 = load double, double* %21
%716 = load double, double* %17
%717 = fneg double %714
%718 = call double @llvm.fmuladd.f64(double %717, double %715, double %716)
store double %718, double* %17
%719 = load double*, double** %9
%720 = getelementptr inbounds double, double* %719, i64 6
%721 = load double, double* %720
%722 = load double, double* %24
%723 = load double, double* %17
%724 = fneg double %721
%725 = call double @llvm.fmuladd.f64(double %724, double %722, double %723)
store double %725, double* %17
%726 = load double, double* %17
%727 = load double*, double** %9
%728 = getelementptr inbounds double, double* %727, i64 10
store double %726, double* %728
br label %729
729: ; preds = %708, %689
br label %730
730: ; preds = %729, %688
%731 = load i32, i32* %7
%732 = icmp sgt i32 %731, 2
br i1 %732, label %733, label %848
733: ; preds = %730
%734 = load i32, i32* %7
%735 = sub nsw i32 %734, 2
%736 = load double*, double** %9
%737 = getelementptr inbounds double, double* %736, i64 10
%738 = load i32, i32* %10
%739 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %735, i32 2, double* %737, i32 %738, i32* %31, double* %17)
%740 = load i32, i32* %31
%741 = add nsw i32 %740, 2
%742 = load i32*, i32** %12
%743 = getelementptr inbounds i32, i32* %742, i64 2
store i32 %741, i32* %743
%744 = load double, double* %17
%745 = fcmp une double %744, 0.000000e+00
br i1 %745, label %746, label %844
746: ; preds = %733
%747 = load i32*, i32** %12
%748 = getelementptr inbounds i32, i32* %747, i64 2
%749 = load i32, i32* %748
%750 = icmp ne i32 %749, 2
br i1 %750, label %751, label %771
751: ; preds = %746
%752 = load double*, double** %9
%753 = getelementptr inbounds double, double* %752, i64 2
%754 = load double*, double** %9
%755 = load i32*, i32** %12
%756 = getelementptr inbounds i32, i32* %755, i64 2
%757 = load i32, i32* %756
%758 = sdiv i32 %757, 4
%759 = mul nsw i32 %758, 4
%760 = load i32, i32* %10
%761 = mul nsw i32 %759, %760
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds double, double* %754, i64 %762
%764 = load i32*, i32** %12
%765 = getelementptr inbounds i32, i32* %764, i64 2
%766 = load i32, i32* %765
%767 = srem i32 %766, 4
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds double, double* %763, i64 %768
%770 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %753, double* %769)
br label %771
771: ; preds = %751, %746
%772 = load double*, double** %9
%773 = getelementptr inbounds double, double* %772, i64 10
%774 = load double, double* %773
%775 = fdiv double 1.000000e+00, %774
store double %775, double* %17
%776 = load double, double* %17
%777 = load double*, double** %11
%778 = getelementptr inbounds double, double* %777, i64 2
store double %776, double* %778
%779 = load i32, i32* %7
%780 = icmp sge i32 %779, 4
br i1 %780, label %781, label %843
781: ; preds = %771
%782 = load double, double* %17
%783 = load double*, double** %9
%784 = getelementptr inbounds double, double* %783, i64 11
%785 = load double, double* %784
%786 = fmul double %785, %782
store double %786, double* %784
%787 = load double*, double** %9
%788 = load i32, i32* %10
%789 = mul nsw i32 4, %788
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds double, double* %787, i64 %790
store double* %791, double** %29
store i32 0, i32* %30
br label %792
792: ; preds = %823, %781
%793 = load i32, i32* %30
%794 = load i32, i32* %14
%795 = sub nsw i32 %794, 3
%796 = icmp slt i32 %793, %795
br i1 %796, label %797, label %826
797: ; preds = %792
%798 = load double, double* %17
%799 = load double*, double** %29
%800 = getelementptr inbounds double, double* %799, i64 8
%801 = load double, double* %800
%802 = fmul double %801, %798
store double %802, double* %800
%803 = load double, double* %17
%804 = load double*, double** %29
%805 = getelementptr inbounds double, double* %804, i64 9
%806 = load double, double* %805
%807 = fmul double %806, %803
store double %807, double* %805
%808 = load double, double* %17
%809 = load double*, double** %29
%810 = getelementptr inbounds double, double* %809, i64 10
%811 = load double, double* %810
%812 = fmul double %811, %808
store double %812, double* %810
%813 = load double, double* %17
%814 = load double*, double** %29
%815 = getelementptr inbounds double, double* %814, i64 11
%816 = load double, double* %815
%817 = fmul double %816, %813
store double %817, double* %815
%818 = load i32, i32* %10
%819 = mul nsw i32 4, %818
%820 = load double*, double** %29
%821 = sext i32 %819 to i64
%822 = getelementptr inbounds double, double* %820, i64 %821
store double* %822, double** %29
br label %823
823: ; preds = %797
%824 = load i32, i32* %30
%825 = add nsw i32 %824, 4
store i32 %825, i32* %30
br label %792
826: ; preds = %792
br label %827
827: ; preds = %839, %826
%828 = load i32, i32* %30
%829 = load i32, i32* %14
%830 = icmp slt i32 %828, %829
br i1 %830, label %831, label %842
831: ; preds = %827
%832 = load double, double* %17
%833 = load double*, double** %29
%834 = getelementptr inbounds double, double* %833, i64 8
%835 = load double, double* %834
%836 = fmul double %835, %832
store double %836, double* %834
%837 = load double*, double** %29
%838 = getelementptr inbounds double, double* %837, i64 1
store double* %838, double** %29
br label %839
839: ; preds = %831
%840 = load i32, i32* %30
%841 = add nsw i32 %840, 1
store i32 %841, i32* %30
br label %827
842: ; preds = %827
br label %843
843: ; preds = %842, %771
br label %847
844: ; preds = %733
%845 = load double*, double** %11
%846 = getelementptr inbounds double, double* %845, i64 2
store double 0.000000e+00, double* %846
br label %847
847: ; preds = %844, %843
br label %848
848: ; preds = %847, %730
%849 = load i32, i32* %8
%850 = icmp slt i32 %849, 4
br i1 %850, label %851, label %852
851: ; preds = %848
br label %1236
852: ; preds = %848
%853 = load i32, i32* %7
%854 = icmp sge i32 %853, 4
br i1 %854, label %855, label %1085
855: ; preds = %852
%856 = load double*, double** %9
%857 = getelementptr inbounds double, double* %856, i64 12
%858 = load double, double* %857
store double %858, double* %22
%859 = load double*, double** %9
%860 = getelementptr inbounds double, double* %859, i64 13
%861 = load double, double* %860
store double %861, double* %25
%862 = load double*, double** %9
%863 = getelementptr inbounds double, double* %862, i64 1
%864 = load double, double* %863
%865 = load double, double* %22
%866 = load double, double* %25
%867 = fneg double %864
%868 = call double @llvm.fmuladd.f64(double %867, double %865, double %866)
store double %868, double* %25
%869 = load double, double* %25
%870 = load double*, double** %9
%871 = getelementptr inbounds double, double* %870, i64 13
store double %869, double* %871
%872 = load double*, double** %9
%873 = getelementptr inbounds double, double* %872, i64 14
%874 = load double, double* %873
store double %874, double* %27
%875 = load double*, double** %9
%876 = getelementptr inbounds double, double* %875, i64 2
%877 = load double, double* %876
%878 = load double, double* %22
%879 = load double, double* %27
%880 = fneg double %877
%881 = call double @llvm.fmuladd.f64(double %880, double %878, double %879)
store double %881, double* %27
%882 = load double*, double** %9
%883 = getelementptr inbounds double, double* %882, i64 6
%884 = load double, double* %883
%885 = load double, double* %25
%886 = load double, double* %27
%887 = fneg double %884
%888 = call double @llvm.fmuladd.f64(double %887, double %885, double %886)
store double %888, double* %27
%889 = load double, double* %27
%890 = load double*, double** %9
%891 = getelementptr inbounds double, double* %890, i64 14
store double %889, double* %891
%892 = load double*, double** %9
%893 = getelementptr inbounds double, double* %892, i64 15
%894 = load double, double* %893
store double %894, double* %18
%895 = load double*, double** %9
%896 = getelementptr inbounds double, double* %895, i64 3
%897 = load double, double* %896
%898 = load double, double* %22
%899 = load double, double* %18
%900 = fneg double %897
%901 = call double @llvm.fmuladd.f64(double %900, double %898, double %899)
store double %901, double* %18
%902 = load double*, double** %9
%903 = getelementptr inbounds double, double* %902, i64 7
%904 = load double, double* %903
%905 = load double, double* %25
%906 = load double, double* %18
%907 = fneg double %904
%908 = call double @llvm.fmuladd.f64(double %907, double %905, double %906)
store double %908, double* %18
%909 = load double*, double** %9
%910 = getelementptr inbounds double, double* %909, i64 11
%911 = load double, double* %910
%912 = load double, double* %27
%913 = load double, double* %18
%914 = fneg double %911
%915 = call double @llvm.fmuladd.f64(double %914, double %912, double %913)
store double %915, double* %18
%916 = load double, double* %18
%917 = load double*, double** %9
%918 = getelementptr inbounds double, double* %917, i64 15
store double %916, double* %918
%919 = load double*, double** %9
%920 = load i32, i32* %10
%921 = mul nsw i32 4, %920
%922 = sext i32 %921 to i64
%923 = getelementptr inbounds double, double* %919, i64 %922
store double* %923, double** %29
store i32 0, i32* %30
br label %924
924: ; preds = %1043, %855
%925 = load i32, i32* %30
%926 = load i32, i32* %14
%927 = sub nsw i32 %926, 3
%928 = icmp slt i32 %925, %927
br i1 %928, label %929, label %1046
929: ; preds = %924
%930 = load double*, double** %29
%931 = getelementptr inbounds double, double* %930, i64 12
%932 = load double, double* %931
store double %932, double* %15
%933 = load double*, double** %29
%934 = getelementptr inbounds double, double* %933, i64 13
%935 = load double, double* %934
store double %935, double* %16
%936 = load double*, double** %29
%937 = getelementptr inbounds double, double* %936, i64 14
%938 = load double, double* %937
store double %938, double* %17
%939 = load double*, double** %29
%940 = getelementptr inbounds double, double* %939, i64 15
%941 = load double, double* %940
store double %941, double* %18
%942 = load double*, double** %29
%943 = getelementptr inbounds double, double* %942, i64 0
%944 = load double, double* %943
%945 = load double, double* %22
%946 = load double, double* %15
%947 = fneg double %944
%948 = call double @llvm.fmuladd.f64(double %947, double %945, double %946)
store double %948, double* %15
%949 = load double*, double** %29
%950 = getelementptr inbounds double, double* %949, i64 1
%951 = load double, double* %950
%952 = load double, double* %22
%953 = load double, double* %16
%954 = fneg double %951
%955 = call double @llvm.fmuladd.f64(double %954, double %952, double %953)
store double %955, double* %16
%956 = load double*, double** %29
%957 = getelementptr inbounds double, double* %956, i64 2
%958 = load double, double* %957
%959 = load double, double* %22
%960 = load double, double* %17
%961 = fneg double %958
%962 = call double @llvm.fmuladd.f64(double %961, double %959, double %960)
store double %962, double* %17
%963 = load double*, double** %29
%964 = getelementptr inbounds double, double* %963, i64 3
%965 = load double, double* %964
%966 = load double, double* %22
%967 = load double, double* %18
%968 = fneg double %965
%969 = call double @llvm.fmuladd.f64(double %968, double %966, double %967)
store double %969, double* %18
%970 = load double*, double** %29
%971 = getelementptr inbounds double, double* %970, i64 4
%972 = load double, double* %971
%973 = load double, double* %25
%974 = load double, double* %15
%975 = fneg double %972
%976 = call double @llvm.fmuladd.f64(double %975, double %973, double %974)
store double %976, double* %15
%977 = load double*, double** %29
%978 = getelementptr inbounds double, double* %977, i64 5
%979 = load double, double* %978
%980 = load double, double* %25
%981 = load double, double* %16
%982 = fneg double %979
%983 = call double @llvm.fmuladd.f64(double %982, double %980, double %981)
store double %983, double* %16
%984 = load double*, double** %29
%985 = getelementptr inbounds double, double* %984, i64 6
%986 = load double, double* %985
%987 = load double, double* %25
%988 = load double, double* %17
%989 = fneg double %986
%990 = call double @llvm.fmuladd.f64(double %989, double %987, double %988)
store double %990, double* %17
%991 = load double*, double** %29
%992 = getelementptr inbounds double, double* %991, i64 7
%993 = load double, double* %992
%994 = load double, double* %25
%995 = load double, double* %18
%996 = fneg double %993
%997 = call double @llvm.fmuladd.f64(double %996, double %994, double %995)
store double %997, double* %18
%998 = load double*, double** %29
%999 = getelementptr inbounds double, double* %998, i64 8
%1000 = load double, double* %999
%1001 = load double, double* %27
%1002 = load double, double* %15
%1003 = fneg double %1000
%1004 = call double @llvm.fmuladd.f64(double %1003, double %1001, double %1002)
store double %1004, double* %15
%1005 = load double*, double** %29
%1006 = getelementptr inbounds double, double* %1005, i64 9
%1007 = load double, double* %1006
%1008 = load double, double* %27
%1009 = load double, double* %16
%1010 = fneg double %1007
%1011 = call double @llvm.fmuladd.f64(double %1010, double %1008, double %1009)
store double %1011, double* %16
%1012 = load double*, double** %29
%1013 = getelementptr inbounds double, double* %1012, i64 10
%1014 = load double, double* %1013
%1015 = load double, double* %27
%1016 = load double, double* %17
%1017 = fneg double %1014
%1018 = call double @llvm.fmuladd.f64(double %1017, double %1015, double %1016)
store double %1018, double* %17
%1019 = load double*, double** %29
%1020 = getelementptr inbounds double, double* %1019, i64 11
%1021 = load double, double* %1020
%1022 = load double, double* %27
%1023 = load double, double* %18
%1024 = fneg double %1021
%1025 = call double @llvm.fmuladd.f64(double %1024, double %1022, double %1023)
store double %1025, double* %18
%1026 = load double, double* %15
%1027 = load double*, double** %29
%1028 = getelementptr inbounds double, double* %1027, i64 12
store double %1026, double* %1028
%1029 = load double, double* %16
%1030 = load double*, double** %29
%1031 = getelementptr inbounds double, double* %1030, i64 13
store double %1029, double* %1031
%1032 = load double, double* %17
%1033 = load double*, double** %29
%1034 = getelementptr inbounds double, double* %1033, i64 14
store double %1032, double* %1034
%1035 = load double, double* %18
%1036 = load double*, double** %29
%1037 = getelementptr inbounds double, double* %1036, i64 15
store double %1035, double* %1037
%1038 = load i32, i32* %10
%1039 = mul nsw i32 4, %1038
%1040 = load double*, double** %29
%1041 = sext i32 %1039 to i64
%1042 = getelementptr inbounds double, double* %1040, i64 %1041
store double* %1042, double** %29
br label %1043
1043: ; preds = %929
%1044 = load i32, i32* %30
%1045 = add nsw i32 %1044, 4
store i32 %1045, i32* %30
br label %924
1046: ; preds = %924
br label %1047
1047: ; preds = %1081, %1046
%1048 = load i32, i32* %30
%1049 = load i32, i32* %14
%1050 = icmp slt i32 %1048, %1049
br i1 %1050, label %1051, label %1084
1051: ; preds = %1047
%1052 = load double*, double** %29
%1053 = getelementptr inbounds double, double* %1052, i64 12
%1054 = load double, double* %1053
store double %1054, double* %15
%1055 = load double*, double** %29
%1056 = getelementptr inbounds double, double* %1055, i64 0
%1057 = load double, double* %1056
%1058 = load double, double* %22
%1059 = load double, double* %15
%1060 = fneg double %1057
%1061 = call double @llvm.fmuladd.f64(double %1060, double %1058, double %1059)
store double %1061, double* %15
%1062 = load double*, double** %29
%1063 = getelementptr inbounds double, double* %1062, i64 4
%1064 = load double, double* %1063
%1065 = load double, double* %25
%1066 = load double, double* %15
%1067 = fneg double %1064
%1068 = call double @llvm.fmuladd.f64(double %1067, double %1065, double %1066)
store double %1068, double* %15
%1069 = load double*, double** %29
%1070 = getelementptr inbounds double, double* %1069, i64 8
%1071 = load double, double* %1070
%1072 = load double, double* %27
%1073 = load double, double* %15
%1074 = fneg double %1071
%1075 = call double @llvm.fmuladd.f64(double %1074, double %1072, double %1073)
store double %1075, double* %15
%1076 = load double, double* %15
%1077 = load double*, double** %29
%1078 = getelementptr inbounds double, double* %1077, i64 12
store double %1076, double* %1078
%1079 = load double*, double** %29
%1080 = getelementptr inbounds double, double* %1079, i64 1
store double* %1080, double** %29
br label %1081
1081: ; preds = %1051
%1082 = load i32, i32* %30
%1083 = add nsw i32 %1082, 1
store i32 %1083, i32* %30
br label %1047
1084: ; preds = %1047
br label %1126
1085: ; preds = %852
%1086 = load double*, double** %9
%1087 = getelementptr inbounds double, double* %1086, i64 12
%1088 = load double, double* %1087
store double %1088, double* %22
%1089 = load double*, double** %9
%1090 = getelementptr inbounds double, double* %1089, i64 13
%1091 = load double, double* %1090
store double %1091, double* %25
%1092 = load double*, double** %9
%1093 = getelementptr inbounds double, double* %1092, i64 1
%1094 = load double, double* %1093
%1095 = load double, double* %22
%1096 = load double, double* %25
%1097 = fneg double %1094
%1098 = call double @llvm.fmuladd.f64(double %1097, double %1095, double %1096)
store double %1098, double* %25
%1099 = load double, double* %25
%1100 = load double*, double** %9
%1101 = getelementptr inbounds double, double* %1100, i64 13
store double %1099, double* %1101
%1102 = load i32, i32* %7
%1103 = icmp sgt i32 %1102, 2
br i1 %1103, label %1104, label %1125
1104: ; preds = %1085
%1105 = load double*, double** %9
%1106 = getelementptr inbounds double, double* %1105, i64 14
%1107 = load double, double* %1106
store double %1107, double* %27
%1108 = load double*, double** %9
%1109 = getelementptr inbounds double, double* %1108, i64 2
%1110 = load double, double* %1109
%1111 = load double, double* %22
%1112 = load double, double* %27
%1113 = fneg double %1110
%1114 = call double @llvm.fmuladd.f64(double %1113, double %1111, double %1112)
store double %1114, double* %27
%1115 = load double*, double** %9
%1116 = getelementptr inbounds double, double* %1115, i64 6
%1117 = load double, double* %1116
%1118 = load double, double* %25
%1119 = load double, double* %27
%1120 = fneg double %1117
%1121 = call double @llvm.fmuladd.f64(double %1120, double %1118, double %1119)
store double %1121, double* %27
%1122 = load double, double* %27
%1123 = load double*, double** %9
%1124 = getelementptr inbounds double, double* %1123, i64 14
store double %1122, double* %1124
br label %1125
1125: ; preds = %1104, %1085
br label %1126
1126: ; preds = %1125, %1084
%1127 = load i32, i32* %7
%1128 = icmp sgt i32 %1127, 3
br i1 %1128, label %1129, label %1235
1129: ; preds = %1126
%1130 = load i32, i32* %7
%1131 = sub nsw i32 %1130, 3
%1132 = load double*, double** %9
%1133 = getelementptr inbounds double, double* %1132, i64 15
%1134 = load i32, i32* %10
%1135 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %1131, i32 3, double* %1133, i32 %1134, i32* %31, double* %18)
%1136 = load i32, i32* %31
%1137 = add nsw i32 %1136, 3
%1138 = load i32*, i32** %12
%1139 = getelementptr inbounds i32, i32* %1138, i64 3
store i32 %1137, i32* %1139
%1140 = load double, double* %18
%1141 = fcmp une double %1140, 0.000000e+00
br i1 %1141, label %1142, label %1231
1142: ; preds = %1129
%1143 = load i32*, i32** %12
%1144 = getelementptr inbounds i32, i32* %1143, i64 3
%1145 = load i32, i32* %1144
%1146 = icmp ne i32 %1145, 3
br i1 %1146, label %1147, label %1167
1147: ; preds = %1142
%1148 = load double*, double** %9
%1149 = getelementptr inbounds double, double* %1148, i64 3
%1150 = load double*, double** %9
%1151 = load i32*, i32** %12
%1152 = getelementptr inbounds i32, i32* %1151, i64 3
%1153 = load i32, i32* %1152
%1154 = sdiv i32 %1153, 4
%1155 = mul nsw i32 %1154, 4
%1156 = load i32, i32* %10
%1157 = mul nsw i32 %1155, %1156
%1158 = sext i32 %1157 to i64
%1159 = getelementptr inbounds double, double* %1150, i64 %1158
%1160 = load i32*, i32** %12
%1161 = getelementptr inbounds i32, i32* %1160, i64 3
%1162 = load i32, i32* %1161
%1163 = srem i32 %1162, 4
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds double, double* %1159, i64 %1164
%1166 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %1149, double* %1165)
br label %1167
1167: ; preds = %1147, %1142
%1168 = load double*, double** %9
%1169 = getelementptr inbounds double, double* %1168, i64 15
%1170 = load double, double* %1169
%1171 = fdiv double 1.000000e+00, %1170
store double %1171, double* %18
%1172 = load double, double* %18
%1173 = load double*, double** %11
%1174 = getelementptr inbounds double, double* %1173, i64 3
store double %1172, double* %1174
%1175 = load double*, double** %9
%1176 = load i32, i32* %10
%1177 = mul nsw i32 4, %1176
%1178 = sext i32 %1177 to i64
%1179 = getelementptr inbounds double, double* %1175, i64 %1178
store double* %1179, double** %29
store i32 0, i32* %30
br label %1180
1180: ; preds = %1211, %1167
%1181 = load i32, i32* %30
%1182 = load i32, i32* %14
%1183 = sub nsw i32 %1182, 3
%1184 = icmp slt i32 %1181, %1183
br i1 %1184, label %1185, label %1214
1185: ; preds = %1180
%1186 = load double, double* %18
%1187 = load double*, double** %29
%1188 = getelementptr inbounds double, double* %1187, i64 12
%1189 = load double, double* %1188
%1190 = fmul double %1189, %1186
store double %1190, double* %1188
%1191 = load double, double* %18
%1192 = load double*, double** %29
%1193 = getelementptr inbounds double, double* %1192, i64 13
%1194 = load double, double* %1193
%1195 = fmul double %1194, %1191
store double %1195, double* %1193
%1196 = load double, double* %18
%1197 = load double*, double** %29
%1198 = getelementptr inbounds double, double* %1197, i64 14
%1199 = load double, double* %1198
%1200 = fmul double %1199, %1196
store double %1200, double* %1198
%1201 = load double, double* %18
%1202 = load double*, double** %29
%1203 = getelementptr inbounds double, double* %1202, i64 15
%1204 = load double, double* %1203
%1205 = fmul double %1204, %1201
store double %1205, double* %1203
%1206 = load i32, i32* %10
%1207 = mul nsw i32 4, %1206
%1208 = load double*, double** %29
%1209 = sext i32 %1207 to i64
%1210 = getelementptr inbounds double, double* %1208, i64 %1209
store double* %1210, double** %29
br label %1211
1211: ; preds = %1185
%1212 = load i32, i32* %30
%1213 = add nsw i32 %1212, 4
store i32 %1213, i32* %30
br label %1180
1214: ; preds = %1180
br label %1215
1215: ; preds = %1227, %1214
%1216 = load i32, i32* %30
%1217 = load i32, i32* %14
%1218 = icmp slt i32 %1216, %1217
br i1 %1218, label %1219, label %1230
1219: ; preds = %1215
%1220 = load double, double* %18
%1221 = load double*, double** %29
%1222 = getelementptr inbounds double, double* %1221, i64 12
%1223 = load double, double* %1222
%1224 = fmul double %1223, %1220
store double %1224, double* %1222
%1225 = load double*, double** %29
%1226 = getelementptr inbounds double, double* %1225, i64 1
store double* %1226, double** %29
br label %1227
1227: ; preds = %1219
%1228 = load i32, i32* %30
%1229 = add nsw i32 %1228, 1
store i32 %1229, i32* %30
br label %1215
1230: ; preds = %1215
br label %1234
1231: ; preds = %1129
%1232 = load double*, double** %11
%1233 = getelementptr inbounds double, double* %1232, i64 3
store double 0.000000e+00, double* %1233
br label %1234
1234: ; preds = %1231, %1230
br label %1235
1235: ; preds = %1234, %1126
br label %1236
1236: ; preds = %1235, %851, %497, %188, %37
ret void
}

LLVM IR (-O2):
define void @kernel_dgetrf_pivot_4_vs_lib4(i32 %0, i32 %1, double* %2, i32 %3, double* nocapture writeonly %4, i32* nocapture writeonly %5) {
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca i32
%12 = icmp slt i32 %0, 1
%13 = icmp slt i32 %1, 1
%14 = or i1 %12, %13
br i1 %14, label %1046, label %15
15: ; preds = %6
%16 = add nsw i32 %0, -4
%17 = bitcast double* %7 to i8*
%18 = bitcast double* %8 to i8*
%19 = bitcast double* %9 to i8*
%20 = bitcast double* %10 to i8*
%21 = bitcast i32* %11 to i8*
%22 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %0, i32 0, double* %2, i32 %3, i32* %11, double* %7)
%23 = load i32, i32* %11
store i32 %23, i32* %5
%24 = load double, double* %7
%25 = fcmp une double %24, 0.000000e+00
br i1 %25, label %26, label %228
26: ; preds = %15
%27 = icmp eq i32 %23, 0
br i1 %27, label %38, label %28
28: ; preds = %26
%29 = sdiv i32 %23, 4
%30 = shl i32 %3, 2
%31 = mul i32 %30, %29
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds double, double* %2, i64 %32
%34 = srem i32 %23, 4
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %33, i64 %35
%37 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %2, double* %36)
br label %38
38: ; preds = %28, %26
%39 = load double, double* %2
%40 = fdiv double 1.000000e+00, %39
store double %40, double* %7
store double %40, double* %4
%41 = icmp ugt i32 %0, 3
br i1 %41, label %42, label %217
42: ; preds = %38
%43 = getelementptr inbounds double, double* %2, i64 1
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = insertelement <2 x double> poison, double %40, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = fmul <2 x double> %47, %45
%49 = bitcast double* %43 to <2 x double>*
store <2 x double> %48, <2 x double>* %49
%50 = getelementptr inbounds double, double* %2, i64 3
%51 = load double, double* %50
%52 = fmul double %40, %51
store double %52, double* %50
%53 = shl nsw i32 %3, 2
%54 = sext i32 %53 to i64
%55 = add nsw i32 %0, -7
%56 = getelementptr inbounds double, double* %2, i64 %54
%57 = icmp ugt i32 %0, 7
br i1 %57, label %185, label %61
58: ; preds = %185
%59 = add i32 %0, -4
%60 = and i32 %59, -4
br label %61
61: ; preds = %58, %42
%62 = phi i32 [ 0, %42 ], [ %60, %58 ]
%63 = phi double* [ %56, %42 ], [ %198, %58 ]
%64 = icmp slt i32 %62, %16
br i1 %64, label %65, label %229
65: ; preds = %61
%66 = load double, double* %63
%67 = fmul double %40, %66
store double %67, double* %63
%68 = or i32 %62, 1
%69 = icmp eq i32 %68, %16
br i1 %69, label %229, label %70
70: ; preds = %65
%71 = add i32 %0, -6
%72 = sub i32 %71, %62
%73 = zext i32 %72 to i64
%74 = add nuw nsw i64 %73, 1
%75 = icmp ult i32 %72, 3
br i1 %75, label %158, label %76
76: ; preds = %70
%77 = add i32 %0, -6
%78 = sub i32 %77, %62
%79 = zext i32 %78 to i64
%80 = add nuw nsw i64 %79, 2
%81 = getelementptr double, double* %63, i64 %80
%82 = icmp ult double* %63, %7
%83 = icmp ult double* %7, %81
%84 = and i1 %82, %83
br i1 %84, label %158, label %85
85: ; preds = %76
%86 = and i64 %74, 8589934588
%87 = trunc i64 %86 to i32
%88 = add i32 %68, %87
%89 = getelementptr double, double* %63, i64 %86
%90 = add nsw i64 %86, -4
%91 = lshr exact i64 %90, 2
%92 = add nuw nsw i64 %91, 1
%93 = and i64 %92, 1
%94 = icmp eq i64 %90, 0
br i1 %94, label %136, label %95
95: ; preds = %85
%96 = and i64 %92, 9223372036854775806
%97 = getelementptr double, double* %63, i64 1
%98 = load double, double* %7
%99 = insertelement <2 x double> poison, double %98, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = insertelement <2 x double> poison, double %98, i64 0
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> zeroinitializer
%103 = getelementptr double, double* %63, i64 1
%104 = load double, double* %7
%105 = insertelement <2 x double> poison, double %104, i64 0
%106 = shufflevector <2 x double> %105, <2 x double> poison, <2 x i32> zeroinitializer
%107 = insertelement <2 x double> poison, double %104, i64 0
%108 = shufflevector <2 x double> %107, <2 x double> poison, <2 x i32> zeroinitializer
br label %109
109: ; preds = %109, %95
%110 = phi i64 [ 0, %95 ], [ %133, %109 ]
%111 = phi i64 [ 0, %95 ], [ %134, %109 ]
%112 = getelementptr inbounds double, double* %97, i64 %110
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %112, i64 2
%116 = bitcast double* %115 to <2 x double>*
%117 = load <2 x double>, <2 x double>* %116
%118 = fmul <2 x double> %100, %114
%119 = fmul <2 x double> %102, %117
%120 = bitcast double* %112 to <2 x double>*
store <2 x double> %118, <2 x double>* %120
%121 = bitcast double* %115 to <2 x double>*
store <2 x double> %119, <2 x double>* %121
%122 = or i64 %110, 4
%123 = getelementptr inbounds double, double* %103, i64 %122
%124 = bitcast double* %123 to <2 x double>*
%125 = load <2 x double>, <2 x double>* %124
%126 = getelementptr inbounds double, double* %123, i64 2
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = fmul <2 x double> %106, %125
%130 = fmul <2 x double> %108, %128
%131 = bitcast double* %123 to <2 x double>*
store <2 x double> %129, <2 x double>* %131
%132 = bitcast double* %126 to <2 x double>*
store <2 x double> %130, <2 x double>* %132
%133 = add nuw i64 %110, 8
%134 = add i64 %111, 2
%135 = icmp eq i64 %134, %96
br i1 %135, label %136, label %109
136: ; preds = %109, %85
%137 = phi i64 [ 0, %85 ], [ %133, %109 ]
%138 = icmp eq i64 %93, 0
br i1 %138, label %156, label %139
139: ; preds = %136
%140 = getelementptr double, double* %63, i64 1
%141 = getelementptr inbounds double, double* %140, i64 %137
%142 = load double, double* %7
%143 = insertelement <2 x double> poison, double %142, i64 0
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = insertelement <2 x double> poison, double %142, i64 0
%146 = shufflevector <2 x double> %145, <2 x double> poison, <2 x i32> zeroinitializer
%147 = bitcast double* %141 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = getelementptr inbounds double, double* %141, i64 2
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = fmul <2 x double> %144, %148
%153 = fmul <2 x double> %146, %151
%154 = bitcast double* %141 to <2 x double>*
store <2 x double> %152, <2 x double>* %154
%155 = bitcast double* %149 to <2 x double>*
store <2 x double> %153, <2 x double>* %155
br label %156
156: ; preds = %136, %139
%157 = icmp eq i64 %74, %86
br i1 %157, label %229, label %158
158: ; preds = %76, %70, %156
%159 = phi i32 [ %68, %76 ], [ %68, %70 ], [ %88, %156 ]
%160 = phi double* [ %63, %76 ], [ %63, %70 ], [ %89, %156 ]
%161 = sub i32 %0, %159
%162 = add i32 %0, -5
%163 = sub i32 %162, %159
%164 = and i32 %161, 3
%165 = icmp eq i32 %164, 0
br i1 %165, label %178, label %166
166: ; preds = %158
%167 = load double, double* %7
br label %168
168: ; preds = %168, %166
%169 = phi i32 [ %175, %168 ], [ %159, %166 ]
%170 = phi double* [ %172, %168 ], [ %160, %166 ]
%171 = phi i32 [ %176, %168 ], [ 0, %166 ]
%172 = getelementptr inbounds double, double* %170, i64 1
%173 = load double, double* %172
%174 = fmul double %167, %173
store double %174, double* %172
%175 = add nuw nsw i32 %169, 1
%176 = add i32 %171, 1
%177 = icmp eq i32 %176, %164
br i1 %177, label %178, label %168
178: ; preds = %168, %158
%179 = phi i32 [ %159, %158 ], [ %175, %168 ]
%180 = phi double* [ %160, %158 ], [ %172, %168 ]
%181 = icmp ult i32 %163, 3
br i1 %181, label %229, label %182
182: ; preds = %178
%183 = load double, double* %7
%184 = load double, double* %7
br label %200
185: ; preds = %42, %185
%186 = phi double* [ %198, %185 ], [ %56, %42 ]
%187 = phi i32 [ %197, %185 ], [ 0, %42 ]
%188 = bitcast double* %186 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = fmul <2 x double> %47, %189
%191 = bitcast double* %186 to <2 x double>*
store <2 x double> %190, <2 x double>* %191
%192 = getelementptr inbounds double, double* %186, i64 2
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = fmul <2 x double> %47, %194
%196 = bitcast double* %192 to <2 x double>*
store <2 x double> %195, <2 x double>* %196
%197 = add nuw nsw i32 %187, 4
%198 = getelementptr inbounds double, double* %186, i64 %54
%199 = icmp slt i32 %197, %55
br i1 %199, label %185, label %58
200: ; preds = %200, %182
%201 = phi i32 [ %179, %182 ], [ %215, %200 ]
%202 = phi double* [ %180, %182 ], [ %212, %200 ]
%203 = getelementptr inbounds double, double* %202, i64 1
%204 = load double, double* %203
%205 = fmul double %183, %204
store double %205, double* %203
%206 = getelementptr inbounds double, double* %202, i64 2
%207 = load double, double* %206
%208 = fmul double %183, %207
store double %208, double* %206
%209 = getelementptr inbounds double, double* %202, i64 3
%210 = load double, double* %209
%211 = fmul double %184, %210
store double %211, double* %209
%212 = getelementptr inbounds double, double* %202, i64 4
%213 = load double, double* %212
%214 = fmul double %184, %213
store double %214, double* %212
%215 = add nuw nsw i32 %201, 4
%216 = icmp eq i32 %215, %16
br i1 %216, label %229, label %200
217: ; preds = %38
%218 = icmp ugt i32 %0, 1
br i1 %218, label %219, label %1045
219: ; preds = %217
%220 = getelementptr inbounds double, double* %2, i64 1
%221 = load double, double* %220
%222 = fmul double %40, %221
store double %222, double* %220
%223 = icmp eq i32 %0, 2
br i1 %223, label %229, label %224
224: ; preds = %219
%225 = getelementptr inbounds double, double* %2, i64 2
%226 = load double, double* %225
%227 = fmul double %40, %226
store double %227, double* %225
br label %229
228: ; preds = %15
store double 0.000000e+00, double* %4
br label %229
229: ; preds = %178, %200, %65, %156, %61, %219, %224, %228
%230 = icmp eq i32 %1, 1
%231 = icmp eq i32 %0, 1
%232 = or i1 %231, %230
br i1 %232, label %1045, label %233
233: ; preds = %229
%234 = icmp sgt i32 %0, 3
%235 = getelementptr inbounds double, double* %2, i64 4
%236 = load double, double* %235
%237 = getelementptr inbounds double, double* %2, i64 5
%238 = load double, double* %237
br i1 %234, label %239, label %332
239: ; preds = %233
%240 = getelementptr inbounds double, double* %2, i64 6
%241 = load double, double* %240
%242 = getelementptr inbounds double, double* %2, i64 7
%243 = load double, double* %242
%244 = getelementptr inbounds double, double* %2, i64 1
%245 = bitcast double* %244 to <2 x double>*
%246 = load <2 x double>, <2 x double>* %245
%247 = fneg <2 x double> %246
%248 = insertelement <2 x double> poison, double %236, i64 0
%249 = shufflevector <2 x double> %248, <2 x double> poison, <2 x i32> zeroinitializer
%250 = insertelement <2 x double> poison, double %238, i64 0
%251 = insertelement <2 x double> %250, double %241, i64 1
%252 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %247, <2 x double> %249, <2 x double> %251)
%253 = extractelement <2 x double> %252, i64 0
store double %253, double* %8
%254 = extractelement <2 x double> %252, i64 1
store double %254, double* %9
%255 = getelementptr inbounds double, double* %2, i64 3
%256 = load double, double* %255
%257 = fneg double %256
%258 = call double @llvm.fmuladd.f64(double %257, double %236, double %243)
store double %258, double* %10
%259 = bitcast double* %237 to <2 x double>*
store <2 x double> %252, <2 x double>* %259
store double %258, double* %242
%260 = shl nsw i32 %3, 2
%261 = sext i32 %260 to i64
%262 = add nsw i32 %0, -7
%263 = getelementptr inbounds double, double* %2, i64 %261
%264 = icmp ugt i32 %0, 7
br i1 %264, label %292, label %272
265: ; preds = %292
%266 = add i32 %0, -4
%267 = and i32 %266, -4
%268 = extractelement <2 x double> %304, i64 0
store double %268, double* %7
%269 = extractelement <2 x double> %304, i64 1
store double %269, double* %8
%270 = extractelement <2 x double> %309, i64 0
store double %270, double* %9
%271 = extractelement <2 x double> %309, i64 1
store double %271, double* %10
br label %272
272: ; preds = %265, %239
%273 = phi i32 [ %267, %265 ], [ 0, %239 ]
%274 = phi double* [ %313, %265 ], [ %263, %239 ]
%275 = icmp slt i32 %273, %16
br i1 %275, label %276, label %345
276: ; preds = %272
%277 = add i32 %0, -5
%278 = and i32 %0, 1
%279 = icmp eq i32 %278, 0
br i1 %279, label %288, label %280
280: ; preds = %276
%281 = getelementptr inbounds double, double* %274, i64 4
%282 = load double, double* %281
store double %282, double* %7
%283 = load double, double* %274
%284 = fneg double %283
%285 = call double @llvm.fmuladd.f64(double %284, double %236, double %282)
store double %285, double* %7
store double %285, double* %281
%286 = getelementptr inbounds double, double* %274, i64 1
%287 = or i32 %273, 1
br label %288
288: ; preds = %280, %276
%289 = phi i32 [ %273, %276 ], [ %287, %280 ]
%290 = phi double* [ %274, %276 ], [ %286, %280 ]
%291 = icmp eq i32 %277, %273
br i1 %291, label %345, label %315
292: ; preds = %239, %292
%293 = phi double* [ %313, %292 ], [ %263, %239 ]
%294 = phi i32 [ %312, %292 ], [ 0, %239 ]
%295 = getelementptr inbounds double, double* %293, i64 4
%296 = bitcast double* %295 to <2 x double>*
%297 = load <2 x double>, <2 x double>* %296
%298 = getelementptr inbounds double, double* %293, i64 6
%299 = bitcast double* %298 to <2 x double>*
%300 = load <2 x double>, <2 x double>* %299
%301 = bitcast double* %293 to <2 x double>*
%302 = load <2 x double>, <2 x double>* %301
%303 = fneg <2 x double> %302
%304 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %303, <2 x double> %249, <2 x double> %297)
%305 = getelementptr inbounds double, double* %293, i64 2
%306 = bitcast double* %305 to <2 x double>*
%307 = load <2 x double>, <2 x double>* %306
%308 = fneg <2 x double> %307
%309 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %308, <2 x double> %249, <2 x double> %300)
%310 = bitcast double* %295 to <2 x double>*
store <2 x double> %304, <2 x double>* %310
%311 = bitcast double* %298 to <2 x double>*
store <2 x double> %309, <2 x double>* %311
%312 = add nuw nsw i32 %294, 4
%313 = getelementptr inbounds double, double* %293, i64 %261
%314 = icmp slt i32 %312, %262
br i1 %314, label %292, label %265
315: ; preds = %288, %315
%316 = phi i32 [ %330, %315 ], [ %289, %288 ]
%317 = phi double* [ %329, %315 ], [ %290, %288 ]
%318 = getelementptr inbounds double, double* %317, i64 4
%319 = load double, double* %318
store double %319, double* %7
%320 = load double, double* %317
%321 = fneg double %320
%322 = call double @llvm.fmuladd.f64(double %321, double %236, double %319)
store double %322, double* %7
store double %322, double* %318
%323 = getelementptr inbounds double, double* %317, i64 1
%324 = getelementptr inbounds double, double* %317, i64 5
%325 = load double, double* %324
store double %325, double* %7
%326 = load double, double* %323
%327 = fneg double %326
%328 = call double @llvm.fmuladd.f64(double %327, double %236, double %325)
store double %328, double* %7
store double %328, double* %324
%329 = getelementptr inbounds double, double* %317, i64 2
%330 = add nuw nsw i32 %316, 2
%331 = icmp eq i32 %330, %16
br i1 %331, label %345, label %315
332: ; preds = %233
%333 = getelementptr inbounds double, double* %2, i64 1
%334 = load double, double* %333
%335 = fneg double %334
%336 = call double @llvm.fmuladd.f64(double %335, double %236, double %238)
store double %336, double* %8
store double %336, double* %237
%337 = icmp eq i32 %0, 3
br i1 %337, label %338, label %345
338: ; preds = %332
%339 = getelementptr inbounds double, double* %2, i64 6
%340 = load double, double* %339
%341 = getelementptr inbounds double, double* %2, i64 2
%342 = load double, double* %341
%343 = fneg double %342
%344 = call double @llvm.fmuladd.f64(double %343, double %236, double %340)
store double %344, double* %9
store double %344, double* %339
br label %345
345: ; preds = %288, %315, %272, %332, %338
%346 = add nsw i32 %0, -1
%347 = getelementptr inbounds double, double* %2, i64 5
%348 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %346, i32 1, double* %347, i32 %3, i32* %11, double* %8)
%349 = load i32, i32* %11
%350 = add nsw i32 %349, 1
%351 = getelementptr inbounds i32, i32* %5, i64 1
store i32 %350, i32* %351
%352 = load double, double* %8
%353 = fcmp une double %352, 0.000000e+00
br i1 %353, label %354, label %493
354: ; preds = %345
%355 = icmp eq i32 %349, 0
br i1 %355, label %367, label %356
356: ; preds = %354
%357 = getelementptr inbounds double, double* %2, i64 1
%358 = sdiv i32 %350, 4
%359 = shl i32 %3, 2
%360 = mul i32 %359, %358
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %2, i64 %361
%363 = srem i32 %350, 4
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds double, double* %362, i64 %364
%366 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %357, double* %365)
br label %367
367: ; preds = %356, %354
%368 = load double, double* %347
%369 = fdiv double 1.000000e+00, %368
store double %369, double* %8
%370 = getelementptr inbounds double, double* %4, i64 1
store double %369, double* %370
br i1 %234, label %371, label %487
371: ; preds = %367
%372 = getelementptr inbounds double, double* %2, i64 6
%373 = bitcast double* %372 to <2 x double>*
%374 = load <2 x double>, <2 x double>* %373
%375 = insertelement <2 x double> poison, double %369, i64 0
%376 = shufflevector <2 x double> %375, <2 x double> poison, <2 x i32> zeroinitializer
%377 = fmul <2 x double> %376, %374
%378 = bitcast double* %372 to <2 x double>*
store <2 x double> %377, <2 x double>* %378
%379 = shl nsw i32 %3, 2
%380 = sext i32 %379 to i64
%381 = add nsw i32 %0, -7
%382 = getelementptr inbounds double, double* %2, i64 %380
%383 = icmp ugt i32 %0, 7
br i1 %383, label %462, label %387
384: ; preds = %462
%385 = add i32 %0, -4
%386 = and i32 %385, -4
br label %387
387: ; preds = %384, %371
%388 = phi i32 [ 0, %371 ], [ %386, %384 ]
%389 = phi double* [ %382, %371 ], [ %476, %384 ]
%390 = icmp slt i32 %388, %16
br i1 %390, label %391, label %495
391: ; preds = %387
%392 = add i32 %0, -5
%393 = sub i32 %392, %388
%394 = zext i32 %393 to i64
%395 = add nuw nsw i64 %394, 1
%396 = icmp ult i32 %393, 3
br i1 %396, label %459, label %397
397: ; preds = %391
%398 = and i64 %395, 8589934588
%399 = trunc i64 %398 to i32
%400 = add i32 %388, %399
%401 = getelementptr double, double* %389, i64 %398
%402 = insertelement <2 x double> poison, double %369, i64 0
%403 = shufflevector <2 x double> %402, <2 x double> poison, <2 x i32> zeroinitializer
%404 = insertelement <2 x double> poison, double %369, i64 0
%405 = shufflevector <2 x double> %404, <2 x double> poison, <2 x i32> zeroinitializer
%406 = add nsw i64 %398, -4
%407 = lshr exact i64 %406, 2
%408 = add nuw nsw i64 %407, 1
%409 = and i64 %408, 1
%410 = icmp eq i64 %406, 0
br i1 %410, label %442, label %411
411: ; preds = %397
%412 = and i64 %408, 9223372036854775806
%413 = getelementptr double, double* %389, i64 4
%414 = getelementptr double, double* %389, i64 4
br label %415
415: ; preds = %415, %411
%416 = phi i64 [ 0, %411 ], [ %439, %415 ]
%417 = phi i64 [ 0, %411 ], [ %440, %415 ]
%418 = getelementptr inbounds double, double* %413, i64 %416
%419 = bitcast double* %418 to <2 x double>*
%420 = load <2 x double>, <2 x double>* %419
%421 = getelementptr inbounds double, double* %418, i64 2
%422 = bitcast double* %421 to <2 x double>*
%423 = load <2 x double>, <2 x double>* %422
%424 = fmul <2 x double> %403, %420
%425 = fmul <2 x double> %405, %423
%426 = bitcast double* %418 to <2 x double>*
store <2 x double> %424, <2 x double>* %426
%427 = bitcast double* %421 to <2 x double>*
store <2 x double> %425, <2 x double>* %427
%428 = or i64 %416, 4
%429 = getelementptr inbounds double, double* %414, i64 %428
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = getelementptr inbounds double, double* %429, i64 2
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = fmul <2 x double> %403, %431
%436 = fmul <2 x double> %405, %434
%437 = bitcast double* %429 to <2 x double>*
store <2 x double> %435, <2 x double>* %437
%438 = bitcast double* %432 to <2 x double>*
store <2 x double> %436, <2 x double>* %438
%439 = add nuw i64 %416, 8
%440 = add i64 %417, 2
%441 = icmp eq i64 %440, %412
br i1 %441, label %442, label %415
442: ; preds = %415, %397
%443 = phi i64 [ 0, %397 ], [ %439, %415 ]
%444 = icmp eq i64 %409, 0
br i1 %444, label %457, label %445
445: ; preds = %442
%446 = getelementptr double, double* %389, i64 4
%447 = getelementptr inbounds double, double* %446, i64 %443
%448 = bitcast double* %447 to <2 x double>*
%449 = load <2 x double>, <2 x double>* %448
%450 = getelementptr inbounds double, double* %447, i64 2
%451 = bitcast double* %450 to <2 x double>*
%452 = load <2 x double>, <2 x double>* %451
%453 = fmul <2 x double> %403, %449
%454 = fmul <2 x double> %405, %452
%455 = bitcast double* %447 to <2 x double>*
store <2 x double> %453, <2 x double>* %455
%456 = bitcast double* %450 to <2 x double>*
store <2 x double> %454, <2 x double>* %456
br label %457
457: ; preds = %442, %445
%458 = icmp eq i64 %395, %398
br i1 %458, label %495, label %459
459: ; preds = %391, %457
%460 = phi i32 [ %388, %391 ], [ %400, %457 ]
%461 = phi double* [ %389, %391 ], [ %401, %457 ]
br label %478
462: ; preds = %371, %462
%463 = phi double* [ %476, %462 ], [ %382, %371 ]
%464 = phi i32 [ %475, %462 ], [ 0, %371 ]
%465 = getelementptr inbounds double, double* %463, i64 4
%466 = bitcast double* %465 to <2 x double>*
%467 = load <2 x double>, <2 x double>* %466
%468 = fmul <2 x double> %376, %467
%469 = bitcast double* %465 to <2 x double>*
store <2 x double> %468, <2 x double>* %469
%470 = getelementptr inbounds double, double* %463, i64 6
%471 = bitcast double* %470 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = fmul <2 x double> %376, %472
%474 = bitcast double* %470 to <2 x double>*
store <2 x double> %473, <2 x double>* %474
%475 = add nuw nsw i32 %464, 4
%476 = getelementptr inbounds double, double* %463, i64 %380
%477 = icmp slt i32 %475, %381
br i1 %477, label %462, label %384
478: ; preds = %459, %478
%479 = phi i32 [ %485, %478 ], [ %460, %459 ]
%480 = phi double* [ %484, %478 ], [ %461, %459 ]
%481 = getelementptr inbounds double, double* %480, i64 4
%482 = load double, double* %481
%483 = fmul double %369, %482
store double %483, double* %481
%484 = getelementptr inbounds double, double* %480, i64 1
%485 = add nuw nsw i32 %479, 1
%486 = icmp eq i32 %485, %16
br i1 %486, label %495, label %478
487: ; preds = %367
%488 = icmp eq i32 %0, 3
br i1 %488, label %489, label %495
489: ; preds = %487
%490 = getelementptr inbounds double, double* %2, i64 6
%491 = load double, double* %490
%492 = fmul double %369, %491
store double %492, double* %490
br label %495
493: ; preds = %345
%494 = getelementptr inbounds double, double* %4, i64 1
store double 0.000000e+00, double* %494
br label %495
495: ; preds = %478, %457, %387, %489, %487, %493
%496 = icmp eq i32 %1, 2
br i1 %496, label %1045, label %497
497: ; preds = %495
%498 = getelementptr inbounds double, double* %2, i64 8
%499 = load double, double* %498
%500 = getelementptr inbounds double, double* %2, i64 9
%501 = load double, double* %500
%502 = getelementptr inbounds double, double* %2, i64 1
%503 = load double, double* %502
%504 = fneg double %503
%505 = call double @llvm.fmuladd.f64(double %504, double %499, double %501)
store double %505, double* %500
br i1 %234, label %506, label %621
506: ; preds = %497
%507 = getelementptr inbounds double, double* %2, i64 10
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = getelementptr inbounds double, double* %2, i64 2
%511 = bitcast double* %510 to <2 x double>*
%512 = load <2 x double>, <2 x double>* %511
%513 = fneg <2 x double> %512
%514 = insertelement <2 x double> poison, double %499, i64 0
%515 = shufflevector <2 x double> %514, <2 x double> poison, <2 x i32> zeroinitializer
%516 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %513, <2 x double> %515, <2 x double> %509)
%517 = getelementptr inbounds double, double* %2, i64 6
%518 = bitcast double* %517 to <2 x double>*
%519 = load <2 x double>, <2 x double>* %518
%520 = fneg <2 x double> %519
%521 = insertelement <2 x double> poison, double %505, i64 0
%522 = shufflevector <2 x double> %521, <2 x double> poison, <2 x i32> zeroinitializer
%523 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %520, <2 x double> %522, <2 x double> %516)
%524 = extractelement <2 x double> %523, i64 0
store double %524, double* %9
%525 = extractelement <2 x double> %523, i64 1
store double %525, double* %10
%526 = bitcast double* %507 to <2 x double>*
store <2 x double> %523, <2 x double>* %526
%527 = shl nsw i32 %3, 2
%528 = sext i32 %527 to i64
%529 = add nsw i32 %0, -7
%530 = getelementptr inbounds double, double* %2, i64 %528
%531 = icmp ugt i32 %0, 7
br i1 %531, label %563, label %539
532: ; preds = %563
%533 = add i32 %0, -4
%534 = and i32 %533, -4
%535 = extractelement <2 x double> %585, i64 0
store double %535, double* %7
%536 = extractelement <2 x double> %585, i64 1
store double %536, double* %8
%537 = extractelement <2 x double> %590, i64 0
store double %537, double* %9
%538 = extractelement <2 x double> %590, i64 1
store double %538, double* %10
br label %539
539: ; preds = %532, %506
%540 = phi i32 [ %534, %532 ], [ 0, %506 ]
%541 = phi double* [ %594, %532 ], [ %530, %506 ]
%542 = icmp slt i32 %540, %16
br i1 %542, label %543, label %634
543: ; preds = %539
%544 = add i32 %0, -5
%545 = and i32 %0, 1
%546 = icmp eq i32 %545, 0
br i1 %546, label %559, label %547
547: ; preds = %543
%548 = getelementptr inbounds double, double* %541, i64 8
%549 = load double, double* %548
store double %549, double* %7
%550 = load double, double* %541
%551 = fneg double %550
%552 = call double @llvm.fmuladd.f64(double %551, double %499, double %549)
%553 = getelementptr inbounds double, double* %541, i64 4
%554 = load double, double* %553
%555 = fneg double %554
%556 = call double @llvm.fmuladd.f64(double %555, double %505, double %552)
store double %556, double* %7
store double %556, double* %548
%557 = getelementptr inbounds double, double* %541, i64 1
%558 = or i32 %540, 1
br label %559
559: ; preds = %547, %543
%560 = phi i32 [ %540, %543 ], [ %558, %547 ]
%561 = phi double* [ %541, %543 ], [ %557, %547 ]
%562 = icmp eq i32 %544, %540
br i1 %562, label %634, label %596
563: ; preds = %506, %563
%564 = phi double* [ %594, %563 ], [ %530, %506 ]
%565 = phi i32 [ %593, %563 ], [ 0, %506 ]
%566 = getelementptr inbounds double, double* %564, i64 8
%567 = bitcast double* %566 to <2 x double>*
%568 = load <2 x double>, <2 x double>* %567
%569 = getelementptr inbounds double, double* %564, i64 10
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = bitcast double* %564 to <2 x double>*
%573 = load <2 x double>, <2 x double>* %572
%574 = fneg <2 x double> %573
%575 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %574, <2 x double> %515, <2 x double> %568)
%576 = getelementptr inbounds double, double* %564, i64 2
%577 = bitcast double* %576 to <2 x double>*
%578 = load <2 x double>, <2 x double>* %577
%579 = fneg <2 x double> %578
%580 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %579, <2 x double> %515, <2 x double> %571)
%581 = getelementptr inbounds double, double* %564, i64 4
%582 = bitcast double* %581 to <2 x double>*
%583 = load <2 x double>, <2 x double>* %582
%584 = fneg <2 x double> %583
%585 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %584, <2 x double> %522, <2 x double> %575)
%586 = getelementptr inbounds double, double* %564, i64 6
%587 = bitcast double* %586 to <2 x double>*
%588 = load <2 x double>, <2 x double>* %587
%589 = fneg <2 x double> %588
%590 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %589, <2 x double> %522, <2 x double> %580)
%591 = bitcast double* %566 to <2 x double>*
store <2 x double> %585, <2 x double>* %591
%592 = bitcast double* %569 to <2 x double>*
store <2 x double> %590, <2 x double>* %592
%593 = add nuw nsw i32 %565, 4
%594 = getelementptr inbounds double, double* %564, i64 %528
%595 = icmp slt i32 %593, %529
br i1 %595, label %563, label %532
596: ; preds = %559, %596
%597 = phi i32 [ %619, %596 ], [ %560, %559 ]
%598 = phi double* [ %618, %596 ], [ %561, %559 ]
%599 = getelementptr inbounds double, double* %598, i64 8
%600 = load double, double* %599
store double %600, double* %7
%601 = load double, double* %598
%602 = fneg double %601
%603 = call double @llvm.fmuladd.f64(double %602, double %499, double %600)
%604 = getelementptr inbounds double, double* %598, i64 4
%605 = load double, double* %604
%606 = fneg double %605
%607 = call double @llvm.fmuladd.f64(double %606, double %505, double %603)
store double %607, double* %7
store double %607, double* %599
%608 = getelementptr inbounds double, double* %598, i64 1
%609 = getelementptr inbounds double, double* %598, i64 9
%610 = load double, double* %609
store double %610, double* %7
%611 = load double, double* %608
%612 = fneg double %611
%613 = call double @llvm.fmuladd.f64(double %612, double %499, double %610)
%614 = getelementptr inbounds double, double* %598, i64 5
%615 = load double, double* %614
%616 = fneg double %615
%617 = call double @llvm.fmuladd.f64(double %616, double %505, double %613)
store double %617, double* %7
store double %617, double* %609
%618 = getelementptr inbounds double, double* %598, i64 2
%619 = add nuw nsw i32 %597, 2
%620 = icmp eq i32 %619, %16
br i1 %620, label %634, label %596
621: ; preds = %497
%622 = icmp eq i32 %0, 3
br i1 %622, label %623, label %779
623: ; preds = %621
%624 = getelementptr inbounds double, double* %2, i64 10
%625 = load double, double* %624
%626 = getelementptr inbounds double, double* %2, i64 2
%627 = load double, double* %626
%628 = fneg double %627
%629 = call double @llvm.fmuladd.f64(double %628, double %499, double %625)
%630 = getelementptr inbounds double, double* %2, i64 6
%631 = load double, double* %630
%632 = fneg double %631
%633 = call double @llvm.fmuladd.f64(double %632, double %505, double %629)
store double %633, double* %9
store double %633, double* %624
br label %636
634: ; preds = %559, %596, %539
%635 = icmp sgt i32 %0, 2
br i1 %635, label %636, label %779
636: ; preds = %623, %634
%637 = add nsw i32 %0, -2
%638 = getelementptr inbounds double, double* %2, i64 10
%639 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %637, i32 2, double* %638, i32 %3, i32* %11, double* %9)
%640 = load i32, i32* %11
%641 = add nsw i32 %640, 2
%642 = getelementptr inbounds i32, i32* %5, i64 2
store i32 %641, i32* %642
%643 = load double, double* %9
%644 = fcmp une double %643, 0.000000e+00
br i1 %644, label %645, label %777
645: ; preds = %636
%646 = icmp eq i32 %640, 0
br i1 %646, label %658, label %647
647: ; preds = %645
%648 = getelementptr inbounds double, double* %2, i64 2
%649 = sdiv i32 %641, 4
%650 = shl i32 %3, 2
%651 = mul i32 %650, %649
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %2, i64 %652
%654 = srem i32 %641, 4
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds double, double* %653, i64 %655
%657 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %648, double* %656)
br label %658
658: ; preds = %647, %645
%659 = load double, double* %638
%660 = fdiv double 1.000000e+00, %659
store double %660, double* %9
%661 = getelementptr inbounds double, double* %4, i64 2
store double %660, double* %661
br i1 %234, label %662, label %779
662: ; preds = %658
%663 = getelementptr inbounds double, double* %2, i64 11
%664 = load double, double* %663
%665 = fmul double %660, %664
store double %665, double* %663
%666 = shl nsw i32 %3, 2
%667 = sext i32 %666 to i64
%668 = add nsw i32 %0, -7
%669 = getelementptr inbounds double, double* %2, i64 %667
%670 = icmp ugt i32 %0, 7
br i1 %670, label %671, label %677
671: ; preds = %662
%672 = insertelement <2 x double> poison, double %660, i64 0
%673 = shufflevector <2 x double> %672, <2 x double> poison, <2 x i32> zeroinitializer
br label %752
674: ; preds = %752
%675 = add i32 %0, -4
%676 = and i32 %675, -4
br label %677
677: ; preds = %674, %662
%678 = phi i32 [ 0, %662 ], [ %676, %674 ]
%679 = phi double* [ %669, %662 ], [ %766, %674 ]
%680 = icmp slt i32 %678, %16
br i1 %680, label %681, label %779
681: ; preds = %677
%682 = add i32 %0, -5
%683 = sub i32 %682, %678
%684 = zext i32 %683 to i64
%685 = add nuw nsw i64 %684, 1
%686 = icmp ult i32 %683, 3
br i1 %686, label %749, label %687
687: ; preds = %681
%688 = and i64 %685, 8589934588
%689 = trunc i64 %688 to i32
%690 = add i32 %678, %689
%691 = getelementptr double, double* %679, i64 %688
%692 = insertelement <2 x double> poison, double %660, i64 0
%693 = shufflevector <2 x double> %692, <2 x double> poison, <2 x i32> zeroinitializer
%694 = insertelement <2 x double> poison, double %660, i64 0
%695 = shufflevector <2 x double> %694, <2 x double> poison, <2 x i32> zeroinitializer
%696 = add nsw i64 %688, -4
%697 = lshr exact i64 %696, 2
%698 = add nuw nsw i64 %697, 1
%699 = and i64 %698, 1
%700 = icmp eq i64 %696, 0
br i1 %700, label %732, label %701
701: ; preds = %687
%702 = and i64 %698, 9223372036854775806
%703 = getelementptr double, double* %679, i64 8
%704 = getelementptr double, double* %679, i64 8
br label %705
705: ; preds = %705, %701
%706 = phi i64 [ 0, %701 ], [ %729, %705 ]
%707 = phi i64 [ 0, %701 ], [ %730, %705 ]
%708 = getelementptr inbounds double, double* %703, i64 %706
%709 = bitcast double* %708 to <2 x double>*
%710 = load <2 x double>, <2 x double>* %709
%711 = getelementptr inbounds double, double* %708, i64 2
%712 = bitcast double* %711 to <2 x double>*
%713 = load <2 x double>, <2 x double>* %712
%714 = fmul <2 x double> %693, %710
%715 = fmul <2 x double> %695, %713
%716 = bitcast double* %708 to <2 x double>*
store <2 x double> %714, <2 x double>* %716
%717 = bitcast double* %711 to <2 x double>*
store <2 x double> %715, <2 x double>* %717
%718 = or i64 %706, 4
%719 = getelementptr inbounds double, double* %704, i64 %718
%720 = bitcast double* %719 to <2 x double>*
%721 = load <2 x double>, <2 x double>* %720
%722 = getelementptr inbounds double, double* %719, i64 2
%723 = bitcast double* %722 to <2 x double>*
%724 = load <2 x double>, <2 x double>* %723
%725 = fmul <2 x double> %693, %721
%726 = fmul <2 x double> %695, %724
%727 = bitcast double* %719 to <2 x double>*
store <2 x double> %725, <2 x double>* %727
%728 = bitcast double* %722 to <2 x double>*
store <2 x double> %726, <2 x double>* %728
%729 = add nuw i64 %706, 8
%730 = add i64 %707, 2
%731 = icmp eq i64 %730, %702
br i1 %731, label %732, label %705
732: ; preds = %705, %687
%733 = phi i64 [ 0, %687 ], [ %729, %705 ]
%734 = icmp eq i64 %699, 0
br i1 %734, label %747, label %735
735: ; preds = %732
%736 = getelementptr double, double* %679, i64 8
%737 = getelementptr inbounds double, double* %736, i64 %733
%738 = bitcast double* %737 to <2 x double>*
%739 = load <2 x double>, <2 x double>* %738
%740 = getelementptr inbounds double, double* %737, i64 2
%741 = bitcast double* %740 to <2 x double>*
%742 = load <2 x double>, <2 x double>* %741
%743 = fmul <2 x double> %693, %739
%744 = fmul <2 x double> %695, %742
%745 = bitcast double* %737 to <2 x double>*
store <2 x double> %743, <2 x double>* %745
%746 = bitcast double* %740 to <2 x double>*
store <2 x double> %744, <2 x double>* %746
br label %747
747: ; preds = %732, %735
%748 = icmp eq i64 %685, %688
br i1 %748, label %779, label %749
749: ; preds = %681, %747
%750 = phi i32 [ %678, %681 ], [ %690, %747 ]
%751 = phi double* [ %679, %681 ], [ %691, %747 ]
br label %768
752: ; preds = %671, %752
%753 = phi double* [ %766, %752 ], [ %669, %671 ]
%754 = phi i32 [ %765, %752 ], [ 0, %671 ]
%755 = getelementptr inbounds double, double* %753, i64 8
%756 = bitcast double* %755 to <2 x double>*
%757 = load <2 x double>, <2 x double>* %756
%758 = fmul <2 x double> %673, %757
%759 = bitcast double* %755 to <2 x double>*
store <2 x double> %758, <2 x double>* %759
%760 = getelementptr inbounds double, double* %753, i64 10
%761 = bitcast double* %760 to <2 x double>*
%762 = load <2 x double>, <2 x double>* %761
%763 = fmul <2 x double> %673, %762
%764 = bitcast double* %760 to <2 x double>*
store <2 x double> %763, <2 x double>* %764
%765 = add nuw nsw i32 %754, 4
%766 = getelementptr inbounds double, double* %753, i64 %667
%767 = icmp slt i32 %765, %668
br i1 %767, label %752, label %674
768: ; preds = %749, %768
%769 = phi i32 [ %775, %768 ], [ %750, %749 ]
%770 = phi double* [ %774, %768 ], [ %751, %749 ]
%771 = getelementptr inbounds double, double* %770, i64 8
%772 = load double, double* %771
%773 = fmul double %660, %772
store double %773, double* %771
%774 = getelementptr inbounds double, double* %770, i64 1
%775 = add nuw nsw i32 %769, 1
%776 = icmp eq i32 %775, %16
br i1 %776, label %779, label %768
777: ; preds = %636
%778 = getelementptr inbounds double, double* %4, i64 2
store double 0.000000e+00, double* %778
br label %779
779: ; preds = %768, %747, %677, %621, %777, %658, %634
%780 = phi i1 [ true, %777 ], [ true, %658 ], [ false, %634 ], [ false, %621 ], [ true, %677 ], [ true, %747 ], [ true, %768 ]
%781 = icmp slt i32 %1, 4
br i1 %781, label %1045, label %782
782: ; preds = %779
%783 = getelementptr inbounds double, double* %2, i64 12
%784 = load double, double* %783
%785 = getelementptr inbounds double, double* %2, i64 13
%786 = load double, double* %785
%787 = getelementptr inbounds double, double* %2, i64 1
%788 = load double, double* %787
%789 = fneg double %788
%790 = call double @llvm.fmuladd.f64(double %789, double %784, double %786)
store double %790, double* %785
br i1 %234, label %791, label %902
791: ; preds = %782
%792 = getelementptr inbounds double, double* %2, i64 14
%793 = load double, double* %792
%794 = getelementptr inbounds double, double* %2, i64 2
%795 = load double, double* %794
%796 = fneg double %795
%797 = call double @llvm.fmuladd.f64(double %796, double %784, double %793)
%798 = getelementptr inbounds double, double* %2, i64 6
%799 = load double, double* %798
%800 = fneg double %799
%801 = call double @llvm.fmuladd.f64(double %800, double %790, double %797)
store double %801, double* %792
%802 = getelementptr inbounds double, double* %2, i64 15
%803 = load double, double* %802
%804 = getelementptr inbounds double, double* %2, i64 3
%805 = load double, double* %804
%806 = fneg double %805
%807 = call double @llvm.fmuladd.f64(double %806, double %784, double %803)
%808 = getelementptr inbounds double, double* %2, i64 7
%809 = load double, double* %808
%810 = fneg double %809
%811 = call double @llvm.fmuladd.f64(double %810, double %790, double %807)
%812 = getelementptr inbounds double, double* %2, i64 11
%813 = load double, double* %812
%814 = fneg double %813
%815 = call double @llvm.fmuladd.f64(double %814, double %801, double %811)
store double %815, double* %802
%816 = shl i32 %3, 2
%817 = sext i32 %816 to i64
%818 = add nsw i32 %0, -7
%819 = getelementptr inbounds double, double* %2, i64 %817
%820 = icmp ugt i32 %0, 7
br i1 %820, label %821, label %835
821: ; preds = %791
%822 = insertelement <2 x double> poison, double %784, i64 0
%823 = shufflevector <2 x double> %822, <2 x double> poison, <2 x i32> zeroinitializer
%824 = insertelement <2 x double> poison, double %790, i64 0
%825 = shufflevector <2 x double> %824, <2 x double> poison, <2 x i32> zeroinitializer
%826 = insertelement <2 x double> poison, double %801, i64 0
%827 = shufflevector <2 x double> %826, <2 x double> poison, <2 x i32> zeroinitializer
br label %840
828: ; preds = %840
%829 = add i32 %0, -4
%830 = and i32 %829, -4
%831 = extractelement <2 x double> %872, i64 0
store double %831, double* %7
%832 = extractelement <2 x double> %872, i64 1
store double %832, double* %8
%833 = extractelement <2 x double> %877, i64 0
store double %833, double* %9
%834 = extractelement <2 x double> %877, i64 1
br label %835
835: ; preds = %828, %791
%836 = phi double [ %834, %828 ], [ %815, %791 ]
%837 = phi i32 [ %830, %828 ], [ 0, %791 ]
%838 = phi double* [ %881, %828 ], [ %819, %791 ]
store double %836, double* %10
%839 = icmp slt i32 %837, %16
br i1 %839, label %883, label %914
840: ; preds = %821, %840
%841 = phi double* [ %881, %840 ], [ %819, %821 ]
%842 = phi i32 [ %880, %840 ], [ 0, %821 ]
%843 = getelementptr inbounds double, double* %841, i64 12
%844 = bitcast double* %843 to <2 x double>*
%845 = load <2 x double>, <2 x double>* %844
%846 = getelementptr inbounds double, double* %841, i64 14
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = bitcast double* %841 to <2 x double>*
%850 = load <2 x double>, <2 x double>* %849
%851 = fneg <2 x double> %850
%852 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %851, <2 x double> %823, <2 x double> %845)
%853 = getelementptr inbounds double, double* %841, i64 2
%854 = bitcast double* %853 to <2 x double>*
%855 = load <2 x double>, <2 x double>* %854
%856 = fneg <2 x double> %855
%857 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %856, <2 x double> %823, <2 x double> %848)
%858 = getelementptr inbounds double, double* %841, i64 4
%859 = bitcast double* %858 to <2 x double>*
%860 = load <2 x double>, <2 x double>* %859
%861 = fneg <2 x double> %860
%862 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %861, <2 x double> %825, <2 x double> %852)
%863 = getelementptr inbounds double, double* %841, i64 6
%864 = bitcast double* %863 to <2 x double>*
%865 = load <2 x double>, <2 x double>* %864
%866 = fneg <2 x double> %865
%867 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %866, <2 x double> %825, <2 x double> %857)
%868 = getelementptr inbounds double, double* %841, i64 8
%869 = bitcast double* %868 to <2 x double>*
%870 = load <2 x double>, <2 x double>* %869
%871 = fneg <2 x double> %870
%872 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %871, <2 x double> %827, <2 x double> %862)
%873 = getelementptr inbounds double, double* %841, i64 10
%874 = bitcast double* %873 to <2 x double>*
%875 = load <2 x double>, <2 x double>* %874
%876 = fneg <2 x double> %875
%877 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %876, <2 x double> %827, <2 x double> %867)
%878 = bitcast double* %843 to <2 x double>*
store <2 x double> %872, <2 x double>* %878
%879 = bitcast double* %846 to <2 x double>*
store <2 x double> %877, <2 x double>* %879
%880 = add nuw nsw i32 %842, 4
%881 = getelementptr inbounds double, double* %841, i64 %817
%882 = icmp slt i32 %880, %818
br i1 %882, label %840, label %828
883: ; preds = %835, %883
%884 = phi i32 [ %900, %883 ], [ %837, %835 ]
%885 = phi double* [ %899, %883 ], [ %838, %835 ]
%886 = getelementptr inbounds double, double* %885, i64 12
%887 = load double, double* %886
store double %887, double* %7
%888 = load double, double* %885
%889 = fneg double %888
%890 = call double @llvm.fmuladd.f64(double %889, double %784, double %887)
%891 = getelementptr inbounds double, double* %885, i64 4
%892 = load double, double* %891
%893 = fneg double %892
%894 = call double @llvm.fmuladd.f64(double %893, double %790, double %890)
%895 = getelementptr inbounds double, double* %885, i64 8
%896 = load double, double* %895
%897 = fneg double %896
%898 = call double @llvm.fmuladd.f64(double %897, double %801, double %894)
store double %898, double* %7
store double %898, double* %886
%899 = getelementptr inbounds double, double* %885, i64 1
%900 = add nuw nsw i32 %884, 1
%901 = icmp eq i32 %900, %16
br i1 %901, label %914, label %883
902: ; preds = %782
br i1 %780, label %903, label %1045
903: ; preds = %902
%904 = getelementptr inbounds double, double* %2, i64 14
%905 = load double, double* %904
%906 = getelementptr inbounds double, double* %2, i64 2
%907 = load double, double* %906
%908 = fneg double %907
%909 = call double @llvm.fmuladd.f64(double %908, double %784, double %905)
%910 = getelementptr inbounds double, double* %2, i64 6
%911 = load double, double* %910
%912 = fneg double %911
%913 = call double @llvm.fmuladd.f64(double %912, double %790, double %909)
store double %913, double* %904
br label %1045
914: ; preds = %883, %835
%915 = add nsw i32 %0, -3
%916 = call i32 (i32, i32, double*, i32, i32*, double*, ...) bitcast (i32 (...)* @idamax_lib4 to i32 (i32, i32, double*, i32, i32*, double*, ...)*)(i32 %915, i32 3, double* %802, i32 %3, i32* %11, double* %10)
%917 = load i32, i32* %11
%918 = add nsw i32 %917, 3
%919 = getelementptr inbounds i32, i32* %5, i64 3
store i32 %918, i32* %919
%920 = load double, double* %10
%921 = fcmp une double %920, 0.000000e+00
br i1 %921, label %922, label %1043
922: ; preds = %914
%923 = icmp eq i32 %917, 0
br i1 %923, label %933, label %924
924: ; preds = %922
%925 = sdiv i32 %918, 4
%926 = mul i32 %816, %925
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds double, double* %2, i64 %927
%929 = srem i32 %918, 4
%930 = sext i32 %929 to i64
%931 = getelementptr inbounds double, double* %928, i64 %930
%932 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @drowsw_lib to i32 (i32, double*, double*, ...)*)(i32 4, double* %804, double* %931)
br label %933
933: ; preds = %924, %922
%934 = load double, double* %802
%935 = fdiv double 1.000000e+00, %934
store double %935, double* %10
%936 = getelementptr inbounds double, double* %4, i64 3
store double %935, double* %936
br i1 %820, label %937, label %943
937: ; preds = %933
%938 = insertelement <2 x double> poison, double %935, i64 0
%939 = shufflevector <2 x double> %938, <2 x double> poison, <2 x i32> zeroinitializer
br label %1018
940: ; preds = %1018
%941 = add i32 %0, -4
%942 = and i32 %941, -4
br label %943
943: ; preds = %940, %933
%944 = phi i32 [ 0, %933 ], [ %942, %940 ]
%945 = phi double* [ %819, %933 ], [ %1032, %940 ]
%946 = icmp slt i32 %944, %16
br i1 %946, label %947, label %1045
947: ; preds = %943
%948 = add i32 %0, -5
%949 = sub i32 %948, %944
%950 = zext i32 %949 to i64
%951 = add nuw nsw i64 %950, 1
%952 = icmp ult i32 %949, 3
br i1 %952, label %1015, label %953
953: ; preds = %947
%954 = and i64 %951, 8589934588
%955 = trunc i64 %954 to i32
%956 = add i32 %944, %955
%957 = getelementptr double, double* %945, i64 %954
%958 = insertelement <2 x double> poison, double %935, i64 0
%959 = shufflevector <2 x double> %958, <2 x double> poison, <2 x i32> zeroinitializer
%960 = insertelement <2 x double> poison, double %935, i64 0
%961 = shufflevector <2 x double> %960, <2 x double> poison, <2 x i32> zeroinitializer
%962 = add nsw i64 %954, -4
%963 = lshr exact i64 %962, 2
%964 = add nuw nsw i64 %963, 1
%965 = and i64 %964, 1
%966 = icmp eq i64 %962, 0
br i1 %966, label %998, label %967
967: ; preds = %953
%968 = and i64 %964, 9223372036854775806
%969 = getelementptr double, double* %945, i64 12
%970 = getelementptr double, double* %945, i64 12
br label %971
971: ; preds = %971, %967
%972 = phi i64 [ 0, %967 ], [ %995, %971 ]
%973 = phi i64 [ 0, %967 ], [ %996, %971 ]
%974 = getelementptr inbounds double, double* %969, i64 %972
%975 = bitcast double* %974 to <2 x double>*
%976 = load <2 x double>, <2 x double>* %975
%977 = getelementptr inbounds double, double* %974, i64 2
%978 = bitcast double* %977 to <2 x double>*
%979 = load <2 x double>, <2 x double>* %978
%980 = fmul <2 x double> %959, %976
%981 = fmul <2 x double> %961, %979
%982 = bitcast double* %974 to <2 x double>*
store <2 x double> %980, <2 x double>* %982
%983 = bitcast double* %977 to <2 x double>*
store <2 x double> %981, <2 x double>* %983
%984 = or i64 %972, 4
%985 = getelementptr inbounds double, double* %970, i64 %984
%986 = bitcast double* %985 to <2 x double>*
%987 = load <2 x double>, <2 x double>* %986
%988 = getelementptr inbounds double, double* %985, i64 2
%989 = bitcast double* %988 to <2 x double>*
%990 = load <2 x double>, <2 x double>* %989
%991 = fmul <2 x double> %959, %987
%992 = fmul <2 x double> %961, %990
%993 = bitcast double* %985 to <2 x double>*
store <2 x double> %991, <2 x double>* %993
%994 = bitcast double* %988 to <2 x double>*
store <2 x double> %992, <2 x double>* %994
%995 = add nuw i64 %972, 8
%996 = add i64 %973, 2
%997 = icmp eq i64 %996, %968
br i1 %997, label %998, label %971
998: ; preds = %971, %953
%999 = phi i64 [ 0, %953 ], [ %995, %971 ]
%1000 = icmp eq i64 %965, 0
br i1 %1000, label %1013, label %1001
1001: ; preds = %998
%1002 = getelementptr double, double* %945, i64 12
%1003 = getelementptr inbounds double, double* %1002, i64 %999
%1004 = bitcast double* %1003 to <2 x double>*
%1005 = load <2 x double>, <2 x double>* %1004
%1006 = getelementptr inbounds double, double* %1003, i64 2
%1007 = bitcast double* %1006 to <2 x double>*
%1008 = load <2 x double>, <2 x double>* %1007
%1009 = fmul <2 x double> %959, %1005
%1010 = fmul <2 x double> %961, %1008
%1011 = bitcast double* %1003 to <2 x double>*
store <2 x double> %1009, <2 x double>* %1011
%1012 = bitcast double* %1006 to <2 x double>*
store <2 x double> %1010, <2 x double>* %1012
br label %1013
1013: ; preds = %998, %1001
%1014 = icmp eq i64 %951, %954
br i1 %1014, label %1045, label %1015
1015: ; preds = %947, %1013
%1016 = phi i32 [ %944, %947 ], [ %956, %1013 ]
%1017 = phi double* [ %945, %947 ], [ %957, %1013 ]
br label %1034
1018: ; preds = %937, %1018
%1019 = phi double* [ %1032, %1018 ], [ %819, %937 ]
%1020 = phi i32 [ %1031, %1018 ], [ 0, %937 ]
%1021 = getelementptr inbounds double, double* %1019, i64 12
%1022 = bitcast double* %1021 to <2 x double>*
%1023 = load <2 x double>, <2 x double>* %1022
%1024 = fmul <2 x double> %939, %1023
%1025 = bitcast double* %1021 to <2 x double>*
store <2 x double> %1024, <2 x double>* %1025
%1026 = getelementptr inbounds double, double* %1019, i64 14
%1027 = bitcast double* %1026 to <2 x double>*
%1028 = load <2 x double>, <2 x double>* %1027
%1029 = fmul <2 x double> %939, %1028
%1030 = bitcast double* %1026 to <2 x double>*
store <2 x double> %1029, <2 x double>* %1030
%1031 = add nuw nsw i32 %1020, 4
%1032 = getelementptr inbounds double, double* %1019, i64 %817
%1033 = icmp slt i32 %1031, %818
br i1 %1033, label %1018, label %940
1034: ; preds = %1015, %1034
%1035 = phi i32 [ %1041, %1034 ], [ %1016, %1015 ]
%1036 = phi double* [ %1040, %1034 ], [ %1017, %1015 ]
%1037 = getelementptr inbounds double, double* %1036, i64 12
%1038 = load double, double* %1037
%1039 = fmul double %935, %1038
store double %1039, double* %1037
%1040 = getelementptr inbounds double, double* %1036, i64 1
%1041 = add nuw nsw i32 %1035, 1
%1042 = icmp eq i32 %1041, %16
br i1 %1042, label %1045, label %1034
1043: ; preds = %914
%1044 = getelementptr inbounds double, double* %4, i64 3
store double 0.000000e+00, double* %1044
br label %1045
1045: ; preds = %1034, %1013, %943, %903, %902, %217, %1043, %779, %495, %229
br label %1046
1046: ; preds = %6, %1045
ret void
}