void kernel_dgetrf_pivot_4_lib4(int m, double *pA, int sda, double *inv_diag_A,
                                int *ipiv) {
  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;
    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 {
    inv_diag_A[0] = 0.0;
  }
  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;
  }
  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;
    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 {
    inv_diag_A[1] = 0.0;
  }
  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;
  }
  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;
    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;
  }
  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;
  }
  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_lib4>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
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    1197 <kernel_dgetrf_pivot_4_lib4+0x77>
jp     1197 <kernel_dgetrf_pivot_4_lib4+0x77>
jmp    137d <kernel_dgetrf_pivot_4_lib4+0x25d>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     120e <kernel_dgetrf_pivot_4_lib4+0xee>
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  0x1de6(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
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    132a <kernel_dgetrf_pivot_4_lib4+0x20a>
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    128e <kernel_dgetrf_pivot_4_lib4+0x16e>
jmp    132f <kernel_dgetrf_pivot_4_lib4+0x20f>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1378 <kernel_dgetrf_pivot_4_lib4+0x258>
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    132f <kernel_dgetrf_pivot_4_lib4+0x20f>
jmp    1388 <kernel_dgetrf_pivot_4_lib4+0x268>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
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    1669 <kernel_dgetrf_pivot_4_lib4+0x549>
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    14b4 <kernel_dgetrf_pivot_4_lib4+0x394>
jmp    166e <kernel_dgetrf_pivot_4_lib4+0x54e>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16fe <kernel_dgetrf_pivot_4_lib4+0x5de>
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    166e <kernel_dgetrf_pivot_4_lib4+0x54e>
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    1753 <kernel_dgetrf_pivot_4_lib4+0x633>
jp     1753 <kernel_dgetrf_pivot_4_lib4+0x633>
jmp    1933 <kernel_dgetrf_pivot_4_lib4+0x813>
mov    -0x28(%rbp),%rax
cmpl   $0x1,0x4(%rax)
je     17d1 <kernel_dgetrf_pivot_4_lib4+0x6b1>
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  0x1823(%rip),%xmm0
divsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
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    18de <kernel_dgetrf_pivot_4_lib4+0x7be>
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    1840 <kernel_dgetrf_pivot_4_lib4+0x720>
jmp    18e3 <kernel_dgetrf_pivot_4_lib4+0x7c3>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    192e <kernel_dgetrf_pivot_4_lib4+0x80e>
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    18e3 <kernel_dgetrf_pivot_4_lib4+0x7c3>
jmp    193f <kernel_dgetrf_pivot_4_lib4+0x81f>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
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    1d76 <kernel_dgetrf_pivot_4_lib4+0xc56>
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    1ad9 <kernel_dgetrf_pivot_4_lib4+0x9b9>
jmp    1d7b <kernel_dgetrf_pivot_4_lib4+0xc5b>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1e45 <kernel_dgetrf_pivot_4_lib4+0xd25>
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    1d7b <kernel_dgetrf_pivot_4_lib4+0xc5b>
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    1e9a <kernel_dgetrf_pivot_4_lib4+0xd7a>
jp     1e9a <kernel_dgetrf_pivot_4_lib4+0xd7a>
jmp    2067 <kernel_dgetrf_pivot_4_lib4+0xf47>
mov    -0x28(%rbp),%rax
cmpl   $0x2,0x8(%rax)
je     1f18 <kernel_dgetrf_pivot_4_lib4+0xdf8>
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  0x10dc(%rip),%xmm0
divsd  0x50(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
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    2012 <kernel_dgetrf_pivot_4_lib4+0xef2>
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    1f74 <kernel_dgetrf_pivot_4_lib4+0xe54>
jmp    2017 <kernel_dgetrf_pivot_4_lib4+0xef7>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2062 <kernel_dgetrf_pivot_4_lib4+0xf42>
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    2017 <kernel_dgetrf_pivot_4_lib4+0xef7>
jmp    2073 <kernel_dgetrf_pivot_4_lib4+0xf53>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x10(%rax)
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    2608 <kernel_dgetrf_pivot_4_lib4+0x14e8>
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    226b <kernel_dgetrf_pivot_4_lib4+0x114b>
jmp    260d <kernel_dgetrf_pivot_4_lib4+0x14ed>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2717 <kernel_dgetrf_pivot_4_lib4+0x15f7>
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    260d <kernel_dgetrf_pivot_4_lib4+0x14ed>
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    276c <kernel_dgetrf_pivot_4_lib4+0x164c>
jp     276c <kernel_dgetrf_pivot_4_lib4+0x164c>
jmp    2926 <kernel_dgetrf_pivot_4_lib4+0x1806>
mov    -0x28(%rbp),%rax
cmpl   $0x3,0xc(%rax)
je     27ea <kernel_dgetrf_pivot_4_lib4+0x16ca>
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  0x80a(%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    28d1 <kernel_dgetrf_pivot_4_lib4+0x17b1>
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    2833 <kernel_dgetrf_pivot_4_lib4+0x1713>
jmp    28d6 <kernel_dgetrf_pivot_4_lib4+0x17b6>
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2921 <kernel_dgetrf_pivot_4_lib4+0x1801>
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    28d6 <kernel_dgetrf_pivot_4_lib4+0x17b6>
jmp    2932 <kernel_dgetrf_pivot_4_lib4+0x1812>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x18(%rax)
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_dgetrf_pivot_4_lib4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%rbp
mov    %rcx,%r12
mov    %edx,%ebx
mov    %rsi,%r15
mov    %edi,%r14d
lea    -0x4(%r14),%eax
mov    %eax,0x8(%rsp)
lea    0xc(%rsp),%r8
mov    %rsp,%r13
xor    %esi,%esi
mov    %r15,%rdx
mov    %ebx,%ecx
mov    %r13,%r9
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%eax
mov    %rbp,0x40(%rsp)
mov    %eax,0x0(%rbp)
mov    %r12,%rbp
movsd  (%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %r12,0x10(%rsp)
mov    %rbx,0x38(%rsp)
jne    118b <kernel_dgetrf_pivot_4_lib4+0x6b>
jnp    1239 <kernel_dgetrf_pivot_4_lib4+0x119>
lea    0x0(,%rbx,4),%ebx
test   %eax,%eax
je     11c7 <kernel_dgetrf_pivot_4_lib4+0xa7>
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   %ebx,%edx
movslq %edx,%rdx
lea    (%r15,%rdx,8),%rdx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    (%rdx,%rax,8),%rdx
mov    $0x4,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <drowsw_lib@plt>
movsd  0x1e31(%rip),%xmm0
divsd  (%r15),%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x0(%rbp)
movupd 0x8(%r15),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm2
movupd %xmm2,0x8(%r15)
movsd  0x18(%r15),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%r15)
movslq %ebx,%r12
lea    (%r15,%r12,8),%rcx
xor    %esi,%esi
cmp    $0x8,%r14d
jl     1250 <kernel_dgetrf_pivot_4_lib4+0x130>
lea    -0x8(%r14),%eax
mov    %eax,%ebp
shr    $0x2,%ebp
add    $0x1,%ebp
cmp    $0x4,%eax
jae    1261 <kernel_dgetrf_pivot_4_lib4+0x141>
mov    0x8(%rsp),%edx
test   $0x1,%bpl
jne    12d2 <kernel_dgetrf_pivot_4_lib4+0x1b2>
jmp    12f0 <kernel_dgetrf_pivot_4_lib4+0x1d0>
movq   $0x0,0x0(%rbp)
lea    0x0(,%rbx,4),%ebx
movslq %ebx,%r12
jmp    14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
mov    0x8(%rsp),%edx
cmp    %edx,%esi
jl     1302 <kernel_dgetrf_pivot_4_lib4+0x1e2>
jmp    14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
mov    %ebp,%esi
and    $0xfffffffe,%esi
mov    %r12,%r8
shl    $0x4,%r8
lea    0x0(,%r12,8),%rdi
mov    0x8(%rsp),%edx
nopl   0x0(%rax)
mov    %rcx,%rax
movupd (%rcx),%xmm2
movupd 0x10(%rcx),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,(%rcx)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rcx)
add    %rdi,%rcx
movupd (%rax,%rdi,1),%xmm2
movupd 0x10(%rax,%rdi,1),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdi,1)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rax,%rdi,1)
add    %rdi,%rcx
add    $0xfffffffe,%esi
jne    1280 <kernel_dgetrf_pivot_4_lib4+0x160>
add    %r8,%rax
mov    %rax,%rcx
test   $0x1,%bpl
je     12f0 <kernel_dgetrf_pivot_4_lib4+0x1d0>
movupd (%rcx),%xmm2
movupd 0x10(%rcx),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,(%rcx)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rcx)
lea    (%rcx,%r12,8),%rcx
mov    %edx,%esi
and    $0xfffffffc,%esi
mov    0x10(%rsp),%rbp
cmp    %edx,%esi
jge    14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
mulsd  (%rcx),%xmm0
movsd  %xmm0,(%rcx)
mov    %esi,%eax
or     $0x1,%eax
cmp    %edx,%eax
je     14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
mov    %r14d,%edx
sub    %esi,%edx
add    $0xfffffffa,%edx
cmp    $0x3,%edx
jb     1412 <kernel_dgetrf_pivot_4_lib4+0x2f2>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
cmp    %rsi,%r13
setb   %sil
cmp    %r13,%rcx
jae    1345 <kernel_dgetrf_pivot_4_lib4+0x225>
test   %sil,%sil
jne    1412 <kernel_dgetrf_pivot_4_lib4+0x2f2>
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     13cc <kernel_dgetrf_pivot_4_lib4+0x2ac>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
movsd  (%rsp),%xmm0
unpcklpd %xmm0,%xmm0
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd 0x8(%rcx,%rdi,8),%xmm1
movupd 0x18(%rcx,%rdi,8),%xmm2
movupd 0x28(%rcx,%rdi,8),%xmm3
movupd 0x38(%rcx,%rdi,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x8(%rcx,%rdi,8)
movupd %xmm2,0x18(%rcx,%rdi,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x28(%rcx,%rdi,8)
movupd %xmm4,0x38(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1380 <kernel_dgetrf_pivot_4_lib4+0x260>
jmp    13ce <kernel_dgetrf_pivot_4_lib4+0x2ae>
xor    %edi,%edi
test   $0x1,%sil
je     13fd <kernel_dgetrf_pivot_4_lib4+0x2dd>
movsd  (%rsp),%xmm0
unpcklpd %xmm0,%xmm0
movupd 0x8(%rcx,%rdi,8),%xmm1
movupd 0x18(%rcx,%rdi,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x8(%rcx,%rdi,8)
movupd %xmm2,0x18(%rcx,%rdi,8)
cmp    %r8,%rdx
mov    0x10(%rsp),%rbp
je     14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
add    %r8d,%eax
lea    (%rcx,%r8,8),%rcx
mov    %r14d,%esi
sub    %eax,%esi
lea    -0x5(%rsi),%edx
and    $0x3,%esi
je     144b <kernel_dgetrf_pivot_4_lib4+0x32b>
movsd  (%rsp),%xmm0
neg    %esi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rcx),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rcx)
add    $0x8,%rcx
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1430 <kernel_dgetrf_pivot_4_lib4+0x310>
sub    %edi,%eax
cmp    $0x3,%edx
jb     14a6 <kernel_dgetrf_pivot_4_lib4+0x386>
movsd  (%rsp),%xmm0
mov    %r14d,%edx
sub    %eax,%edx
mov    $0x4,%eax
nop
movsd  -0x18(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%rcx,%rax,8)
movsd  -0x10(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%rcx,%rax,8)
movsd  -0x8(%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rcx,%rax,8)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %eax,%edx
jne    1460 <kernel_dgetrf_pivot_4_lib4+0x340>
movsd  0x20(%r15),%xmm0
movupd 0x28(%r15),%xmm2
movsd  0x38(%r15),%xmm3
movupd 0x8(%r15),%xmm4
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
movlpd %xmm2,0x20(%rsp)
movsd  0x18(%r15),%xmm4
mulsd  %xmm0,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x18(%rsp)
movupd %xmm2,0x28(%r15)
movsd  %xmm3,0x38(%r15)
lea    (%r15,%r12,8),%r13
cmp    $0x8,%r14d
jl     1520 <kernel_dgetrf_pivot_4_lib4+0x400>
lea    -0x8(%r14),%eax
mov    %eax,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
cmp    $0x4,%eax
jae    1532 <kernel_dgetrf_pivot_4_lib4+0x412>
mov    %r13,%rax
test   $0x1,%cl
jne    15cd <kernel_dgetrf_pivot_4_lib4+0x4ad>
jmp    15fe <kernel_dgetrf_pivot_4_lib4+0x4de>
xor    %ecx,%ecx
unpckhpd %xmm2,%xmm2
mov    %r13,%rax
mov    0x8(%rsp),%esi
jmp    1618 <kernel_dgetrf_pivot_4_lib4+0x4f8>
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %r12,%rdx
shl    $0x4,%rdx
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rsi,%r12,8),%xmm2
movupd 0x10(%rsi,%r12,8),%xmm3
movupd 0x20(%rsi,%r12,8),%xmm4
movupd 0x30(%rsi,%r12,8),%xmm5
mulpd  %xmm1,%xmm2
subpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
subpd  %xmm3,%xmm5
movupd %xmm4,0x20(%rsi,%r12,8)
movupd %xmm5,0x30(%rsi,%r12,8)
movupd (%rsi,%rdx,1),%xmm4
movupd 0x10(%rsi,%rdx,1),%xmm5
movupd 0x20(%rsi,%rdx,1),%xmm3
movupd 0x30(%rsi,%rdx,1),%xmm2
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm3
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm2
movupd %xmm3,0x20(%rsi,%rdx,1)
movupd %xmm2,0x30(%rsi,%rdx,1)
add    %rdx,%rsi
add    $0xfffffffe,%eax
jne    1550 <kernel_dgetrf_pivot_4_lib4+0x430>
lea    (%rsi,%r12,8),%rax
test   $0x1,%cl
je     15fe <kernel_dgetrf_pivot_4_lib4+0x4de>
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)
lea    (%rax,%r12,8),%rax
mov    0x8(%rsp),%esi
mov    %esi,%ecx
and    $0xfffffffc,%ecx
movlpd %xmm3,(%rsp)
movhpd %xmm3,0x20(%rsp)
movhpd %xmm2,0x18(%rsp)
lea    0x28(%r15),%rdx
movsd  %xmm2,0x28(%rsp)
cmp    %esi,%ecx
jge    16cf <kernel_dgetrf_pivot_4_lib4+0x5af>
lea    -0x5(%r14),%esi
test   $0x1,%r14b
jne    163f <kernel_dgetrf_pivot_4_lib4+0x51f>
mov    %ecx,%edi
cmp    %ecx,%esi
jne    166c <kernel_dgetrf_pivot_4_lib4+0x54c>
jmp    16cf <kernel_dgetrf_pivot_4_lib4+0x5af>
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,%edi
or     $0x1,%edi
cmp    %ecx,%esi
je     16cf <kernel_dgetrf_pivot_4_lib4+0x5af>
mov    %r14d,%ecx
sub    %edi,%ecx
add    $0xfffffffc,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  0x20(%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rsp)
movsd  (%rax,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x20(%rax,%rsi,8)
movsd  0x28(%rax,%rsi,8),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x8(%rax,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,0x28(%rax,%rsi,8)
add    $0x2,%rsi
cmp    %esi,%ecx
jne    1680 <kernel_dgetrf_pivot_4_lib4+0x560>
lea    -0x1(%r14),%edi
lea    0xc(%rsp),%r8
lea    0x20(%rsp),%r9
mov    $0x1,%esi
mov    0x38(%rsp),%rcx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x1(%rcx),%eax
mov    0x40(%rsp),%rdx
mov    %eax,0x4(%rdx)
movsd  0x20(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %ebx,0x34(%rsp)
jne    1717 <kernel_dgetrf_pivot_4_lib4+0x5f7>
jnp    1928 <kernel_dgetrf_pivot_4_lib4+0x808>
test   %ecx,%ecx
je     174d <kernel_dgetrf_pivot_4_lib4+0x62d>
lea    0x8(%r15),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   %ebx,%edx
movslq %edx,%rdx
lea    (%r15,%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  0x18ab(%rip),%xmm0
divsd  0x28(%r15),%xmm0
xor    %ecx,%ecx
movsd  %xmm0,0x20(%rsp)
movsd  %xmm0,0x8(%rbp)
movupd 0x30(%r15),%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  %xmm1,%xmm2
movupd %xmm2,0x30(%r15)
mov    %r13,%rax
cmp    $0x8,%r14d
mov    0x8(%rsp),%ebx
jl     183a <kernel_dgetrf_pivot_4_lib4+0x71a>
lea    -0x8(%r14),%edx
mov    %edx,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
mov    %r13,%rax
cmp    $0x4,%edx
jb     1810 <kernel_dgetrf_pivot_4_lib4+0x6f0>
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %r12,%rdx
shl    $0x4,%rdx
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x20(%rsi,%r12,8),%xmm2
movupd 0x30(%rsi,%r12,8),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x20(%rsi,%r12,8)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x30(%rsi,%r12,8)
movupd 0x20(%rsi,%rdx,1),%xmm2
movupd 0x30(%rsi,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x20(%rsi,%rdx,1)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x30(%rsi,%rdx,1)
add    %rdx,%rsi
add    $0xfffffffe,%eax
jne    17c0 <kernel_dgetrf_pivot_4_lib4+0x6a0>
lea    (%rsi,%r12,8),%rax
test   $0x1,%cl
je     1835 <kernel_dgetrf_pivot_4_lib4+0x715>
movupd 0x20(%rax),%xmm2
movupd 0x30(%rax),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x20(%rax)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x30(%rax)
lea    (%rax,%r12,8),%rax
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
cmp    %ebx,%ecx
jge    1934 <kernel_dgetrf_pivot_4_lib4+0x814>
mov    %r14d,%edx
sub    %ecx,%edx
add    $0xfffffffb,%edx
cmp    $0x3,%edx
jb     18fc <kernel_dgetrf_pivot_4_lib4+0x7dc>
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     21d9 <kernel_dgetrf_pivot_4_lib4+0x10b9>
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
nop
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    1880 <kernel_dgetrf_pivot_4_lib4+0x760>
test   $0x1,%sil
je     18f0 <kernel_dgetrf_pivot_4_lib4+0x7d0>
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
je     1934 <kernel_dgetrf_pivot_4_lib4+0x814>
add    %r8d,%ecx
lea    (%rax,%r8,8),%rax
mov    %r14d,%edx
sub    %ecx,%edx
mov    $0x4,%ecx
cs 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    1910 <kernel_dgetrf_pivot_4_lib4+0x7f0>
jmp    1934 <kernel_dgetrf_pivot_4_lib4+0x814>
movq   $0x0,0x8(%rbp)
mov    0x8(%rsp),%ebx
lea    -0x7(%r14),%ebp
movsd  0x40(%r15),%xmm8
movsd  0x48(%r15),%xmm9
movsd  0x8(%r15),%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm2,%xmm9
movsd  %xmm9,0x48(%r15)
movupd 0x50(%r15),%xmm2
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
movupd 0x10(%r15),%xmm4
movupd 0x30(%r15),%xmm5
mulpd  %xmm3,%xmm4
subpd  %xmm4,%xmm2
movapd %xmm9,%xmm4
unpcklpd %xmm9,%xmm4
mulpd  %xmm4,%xmm5
subpd  %xmm5,%xmm2
movhpd %xmm2,0x18(%rsp)
movupd %xmm2,0x50(%r15)
cmp    $0x8,%r14d
jl     1a19 <kernel_dgetrf_pivot_4_lib4+0x8f9>
lea    0x0(,%r12,8),%rcx
xor    %edx,%edx
mov    %r13,%rax
nop
movupd 0x40(%rax),%xmm5
movupd 0x50(%rax),%xmm2
movupd (%rax),%xmm6
movupd 0x10(%rax),%xmm7
movupd 0x20(%rax),%xmm0
movupd 0x30(%rax),%xmm1
mulpd  %xmm3,%xmm6
subpd  %xmm6,%xmm5
mulpd  %xmm3,%xmm7
subpd  %xmm7,%xmm2
mulpd  %xmm4,%xmm0
subpd  %xmm0,%xmm5
mulpd  %xmm4,%xmm1
subpd  %xmm1,%xmm2
movupd %xmm5,0x40(%rax)
movupd %xmm2,0x50(%rax)
add    $0x4,%edx
add    %rcx,%rax
cmp    %ebp,%edx
jl     19b0 <kernel_dgetrf_pivot_4_lib4+0x890>
mov    %ebx,%ecx
and    $0xfffffffc,%ecx
movlpd %xmm5,(%rsp)
movhpd %xmm5,0x20(%rsp)
movhpd %xmm2,0x18(%rsp)
jmp    1a1e <kernel_dgetrf_pivot_4_lib4+0x8fe>
xor    %ecx,%ecx
mov    %r13,%rax
lea    0x50(%r15),%rdx
movsd  %xmm2,0x28(%rsp)
cmp    %ebx,%ecx
jge    1aff <kernel_dgetrf_pivot_4_lib4+0x9df>
lea    -0x5(%r14),%esi
test   $0x1,%r14b
jne    1a45 <kernel_dgetrf_pivot_4_lib4+0x925>
mov    %ecx,%edi
cmp    %ecx,%esi
jne    1a85 <kernel_dgetrf_pivot_4_lib4+0x965>
jmp    1aff <kernel_dgetrf_pivot_4_lib4+0x9df>
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,%edi
or     $0x1,%edi
cmp    %ecx,%esi
je     1aff <kernel_dgetrf_pivot_4_lib4+0x9df>
mov    %r14d,%ecx
sub    %edi,%ecx
add    $0xfffffffc,%ecx
xor    %esi,%esi
nop
movsd  0x40(%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  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x40(%rax,%rsi,8)
movsd  0x48(%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm1,%xmm0
movsd  0x28(%rax,%rsi,8),%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x48(%rax,%rsi,8)
add    $0x2,%rsi
cmp    %esi,%ecx
jne    1a90 <kernel_dgetrf_pivot_4_lib4+0x970>
lea    -0x2(%r14),%edi
lea    0xc(%rsp),%r8
lea    0x28(%rsp),%r9
mov    $0x2,%esi
mov    0x38(%rsp),%rcx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x2(%rcx),%eax
mov    0x40(%rsp),%rdx
mov    %eax,0x8(%rdx)
movsd  0x28(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b43 <kernel_dgetrf_pivot_4_lib4+0xa23>
jnp    1d7a <kernel_dgetrf_pivot_4_lib4+0xc5a>
test   %ecx,%ecx
je     1b7b <kernel_dgetrf_pivot_4_lib4+0xa5b>
lea    0x10(%r15),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
imul   0x34(%rsp),%edx
movslq %edx,%rdx
lea    (%r15,%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>
xor    %ecx,%ecx
movsd  0x147b(%rip),%xmm0
divsd  0x50(%r15),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x10(%rsp),%rax
movsd  %xmm0,0x10(%rax)
movsd  0x58(%r15),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x58(%r15)
mov    %r13,%rax
cmp    $0x8,%r14d
mov    %ebx,%r10d
jl     1c73 <kernel_dgetrf_pivot_4_lib4+0xb53>
lea    -0x8(%r14),%edx
mov    %edx,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
mov    %r13,%rax
cmp    $0x4,%edx
jb     1c40 <kernel_dgetrf_pivot_4_lib4+0xb20>
mov    %ecx,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r12,%rdx
shl    $0x4,%rdx
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
movupd 0x40(%rsi,%r12,8),%xmm2
movupd 0x50(%rsi,%r12,8),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x40(%rsi,%r12,8)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x50(%rsi,%r12,8)
movupd 0x40(%rsi,%rdx,1),%xmm2
movupd 0x50(%rsi,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x40(%rsi,%rdx,1)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x50(%rsi,%rdx,1)
add    %rdx,%rsi
add    $0xfffffffe,%eax
jne    1bf0 <kernel_dgetrf_pivot_4_lib4+0xad0>
lea    (%rsi,%r12,8),%rax
test   $0x1,%cl
je     1c6d <kernel_dgetrf_pivot_4_lib4+0xb4d>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movupd 0x40(%rax),%xmm2
movupd 0x50(%rax),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x40(%rax)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x50(%rax)
lea    (%rax,%r12,8),%rax
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
cmp    %r10d,%ecx
jge    1d8a <kernel_dgetrf_pivot_4_lib4+0xc6a>
mov    %r14d,%edx
sub    %ecx,%edx
add    $0xfffffffb,%edx
cmp    $0x3,%edx
jb     1d4c <kernel_dgetrf_pivot_4_lib4+0xc2c>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     21ea <kernel_dgetrf_pivot_4_lib4+0x10ca>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x40(%rax,%rdi,8),%xmm2
movupd 0x50(%rax,%rdi,8),%xmm3
movupd 0x60(%rax,%rdi,8),%xmm4
movupd 0x70(%rax,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x40(%rax,%rdi,8)
movupd %xmm3,0x50(%rax,%rdi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x60(%rax,%rdi,8)
movupd %xmm5,0x70(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1cd0 <kernel_dgetrf_pivot_4_lib4+0xbb0>
test   $0x1,%r9b
je     1d40 <kernel_dgetrf_pivot_4_lib4+0xc20>
movupd 0x40(%rax,%rdi,8),%xmm2
movupd 0x50(%rax,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x40(%rax,%rdi,8)
movupd %xmm3,0x50(%rax,%rdi,8)
cmp    %r8,%rdx
je     1d8a <kernel_dgetrf_pivot_4_lib4+0xc6a>
add    %r8d,%ecx
lea    (%rax,%r8,8),%rax
mov    %r14d,%edx
sub    %ecx,%edx
add    $0xfffffffc,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  0x40(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%edx
jne    1d60 <kernel_dgetrf_pivot_4_lib4+0xc40>
jmp    1d8a <kernel_dgetrf_pivot_4_lib4+0xc6a>
mov    0x10(%rsp),%rax
movq   $0x0,0x10(%rax)
mov    %ebx,%r10d
xor    %ecx,%ecx
movsd  0x60(%r15),%xmm8
movsd  0x68(%r15),%xmm9
movsd  0x8(%r15),%xmm2
mulsd  %xmm8,%xmm2
subsd  %xmm2,%xmm9
movsd  %xmm9,0x68(%r15)
movsd  0x70(%r15),%xmm10
movsd  0x10(%r15),%xmm3
mulsd  %xmm8,%xmm3
subsd  %xmm3,%xmm10
movsd  0x30(%r15),%xmm3
mulsd  %xmm9,%xmm3
subsd  %xmm3,%xmm10
movsd  %xmm10,0x70(%r15)
movsd  0x78(%r15),%xmm3
movsd  0x18(%r15),%xmm4
mulsd  %xmm8,%xmm4
subsd  %xmm4,%xmm3
movsd  0x38(%r15),%xmm4
mulsd  %xmm9,%xmm4
subsd  %xmm4,%xmm3
movsd  0x58(%r15),%xmm4
mulsd  %xmm10,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x78(%r15)
mov    %r13,%rax
cmp    $0x8,%r14d
jl     1ed8 <kernel_dgetrf_pivot_4_lib4+0xdb8>
movapd %xmm8,%xmm11
unpcklpd %xmm8,%xmm11
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
lea    0x0(,%r12,8),%rcx
xor    %edx,%edx
mov    %r13,%rax
nopl   0x0(%rax,%rax,1)
movupd 0x60(%rax),%xmm7
movupd 0x70(%rax),%xmm3
movupd (%rax),%xmm0
movupd 0x10(%rax),%xmm1
movupd 0x20(%rax),%xmm2
movupd 0x30(%rax),%xmm4
mulpd  %xmm11,%xmm0
subpd  %xmm0,%xmm7
mulpd  %xmm11,%xmm1
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
subpd  %xmm2,%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    %ebp,%edx
jl     1e50 <kernel_dgetrf_pivot_4_lib4+0xd30>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
movlpd %xmm7,(%rsp)
movhpd %xmm7,0x20(%rsp)
movlpd %xmm3,0x28(%rsp)
unpckhpd %xmm3,%xmm3
lea    0x78(%r15),%rbp
movsd  %xmm3,0x18(%rsp)
cmp    %r10d,%ecx
jge    1f4a <kernel_dgetrf_pivot_4_lib4+0xe2a>
mov    %r14d,%edx
sub    %ecx,%edx
add    $0xfffffffc,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x60(%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rsp)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm1,%xmm0
movsd  0x20(%rax,%rcx,8),%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm1,%xmm0
movsd  0x40(%rax,%rcx,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
movsd  %xmm0,0x60(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%edx
jne    1f00 <kernel_dgetrf_pivot_4_lib4+0xde0>
lea    -0x3(%r14),%edi
lea    0xc(%rsp),%r8
lea    0x18(%rsp),%r9
mov    $0x3,%esi
mov    %rbp,%rdx
mov    0x38(%rsp),%rcx
xor    %eax,%eax
call   1030 <idamax_lib4@plt>
mov    0xc(%rsp),%ecx
lea    0x3(%rcx),%eax
mov    0x40(%rsp),%rdx
mov    %eax,0xc(%rdx)
movsd  0x18(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1f91 <kernel_dgetrf_pivot_4_lib4+0xe71>
jnp    21bd <kernel_dgetrf_pivot_4_lib4+0x109d>
test   %ecx,%ecx
je     1fcb <kernel_dgetrf_pivot_4_lib4+0xeab>
lea    0x18(%r15),%rsi
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
mov    %ecx,%edx
sar    $0x2,%edx
mov    0x34(%rsp),%edi
imul   %edx,%edi
movslq %edi,%rdx
lea    (%r15,%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>
xor    %eax,%eax
movsd  0x102b(%rip),%xmm0
divsd  0x0(%rbp),%xmm0
mov    0x10(%rsp),%rcx
movsd  %xmm0,0x18(%rcx)
cmp    $0x8,%r14d
jl     20aa <kernel_dgetrf_pivot_4_lib4+0xf8a>
lea    -0x8(%r14),%ecx
mov    %ecx,%eax
shr    $0x2,%eax
add    $0x1,%eax
cmp    $0x4,%ecx
jb     2074 <kernel_dgetrf_pivot_4_lib4+0xf54>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r12,%rdx
shl    $0x4,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x60(%r15,%r12,8),%xmm2
movupd 0x70(%r15,%r12,8),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x60(%r15,%r12,8)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x70(%r15,%r12,8)
movupd 0x60(%r15,%rdx,1),%xmm2
movupd 0x70(%r15,%rdx,1),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x60(%r15,%rdx,1)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x70(%r15,%rdx,1)
add    %rdx,%r15
add    $0xfffffffe,%ecx
jne    2020 <kernel_dgetrf_pivot_4_lib4+0xf00>
lea    (%r15,%r12,8),%r13
test   $0x1,%al
je     20a5 <kernel_dgetrf_pivot_4_lib4+0xf85>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movupd 0x60(%r13),%xmm2
movupd 0x70(%r13),%xmm3
mulpd  %xmm1,%xmm2
movupd %xmm2,0x60(%r13)
mulpd  %xmm1,%xmm3
movupd %xmm3,0x70(%r13)
lea    0x0(%r13,%r12,8),%r13
mov    %ebx,%eax
and    $0xfffffffc,%eax
cmp    %ebx,%eax
jge    21ca <kernel_dgetrf_pivot_4_lib4+0x10aa>
mov    %r14d,%ecx
sub    %eax,%ecx
add    $0xfffffffb,%ecx
cmp    $0x3,%ecx
jb     2194 <kernel_dgetrf_pivot_4_lib4+0x1074>
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     21fb <kernel_dgetrf_pivot_4_lib4+0x10db>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd 0x60(%r13,%rsi,8),%xmm2
movupd 0x70(%r13,%rsi,8),%xmm3
movupd 0x80(%r13,%rsi,8),%xmm4
movupd 0x90(%r13,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x60(%r13,%rsi,8)
movupd %xmm3,0x70(%r13,%rsi,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x80(%r13,%rsi,8)
movupd %xmm5,0x90(%r13,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2100 <kernel_dgetrf_pivot_4_lib4+0xfe0>
test   $0x1,%bpl
je     2188 <kernel_dgetrf_pivot_4_lib4+0x1068>
movupd 0x60(%r13,%rsi,8),%xmm2
movupd 0x70(%r13,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x60(%r13,%rsi,8)
movupd %xmm3,0x70(%r13,%rsi,8)
cmp    %rdx,%rcx
je     21ca <kernel_dgetrf_pivot_4_lib4+0x10aa>
add    %edx,%eax
lea    0x0(%r13,%rdx,8),%r13
sub    %eax,%r14d
add    $0xfffffffc,%r14d
xor    %eax,%eax
nopl   (%rax)
movsd  0x60(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%r13,%rax,8)
add    $0x1,%rax
cmp    %eax,%r14d
jne    21a0 <kernel_dgetrf_pivot_4_lib4+0x1080>
jmp    21ca <kernel_dgetrf_pivot_4_lib4+0x10aa>
mov    0x10(%rsp),%rax
movq   $0x0,0x18(%rax)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%sil
jne    18d0 <kernel_dgetrf_pivot_4_lib4+0x7b0>
jmp    18f0 <kernel_dgetrf_pivot_4_lib4+0x7d0>
xor    %edi,%edi
test   $0x1,%r9b
jne    1d20 <kernel_dgetrf_pivot_4_lib4+0xc00>
jmp    1d40 <kernel_dgetrf_pivot_4_lib4+0xc20>
xor    %esi,%esi
test   $0x1,%bpl
jne    2164 <kernel_dgetrf_pivot_4_lib4+0x1044>
jmp    2188 <kernel_dgetrf_pivot_4_lib4+0x1068>

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

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