void d_update_gradient_new_rhs_mpc_hard_tv(int N, int *nx, int *nu, int *nb,
                                           int *ng, double **db, double **lamt,
                                           double **qx) {
  const int bs = 4;
  const int ncl = 4;
  int nb0, pnb, ng0, png;
  double temp0, temp1;
  double *ptr_db, *ptr_Qx, *ptr_qx, *ptr_lamt;
  int ii, jj, bs0;
  for (jj = 0; jj <= N; jj++) {
    ptr_lamt = lamt[jj];
    ptr_db = db[jj];
    ptr_qx = qx[jj];
    nb0 = nb[jj];
    if (nb0 > 0) {
      pnb = (nb0 + bs - 1) / bs * bs;
      for (ii = 0; ii < nb0 - 3; ii += 4) {
        ptr_qx[ii + 0] = -ptr_lamt[ii + pnb + 0] * ptr_db[ii + pnb + 0] -
                         ptr_lamt[ii + 0] * ptr_db[ii + 0];
        ptr_qx[ii + 1] = -ptr_lamt[ii + pnb + 1] * ptr_db[ii + pnb + 1] -
                         ptr_lamt[ii + 1] * ptr_db[ii + 1];
        ptr_qx[ii + 2] = -ptr_lamt[ii + pnb + 2] * ptr_db[ii + pnb + 2] -
                         ptr_lamt[ii + 2] * ptr_db[ii + 2];
        ptr_qx[ii + 3] = -ptr_lamt[ii + pnb + 3] * ptr_db[ii + pnb + 3] -
                         ptr_lamt[ii + 3] * ptr_db[ii + 3];
      }
      for (; ii < nb0; ii++) {
        ptr_qx[ii + 0] = -ptr_lamt[ii + pnb + 0] * ptr_db[ii + pnb + 0] -
                         ptr_lamt[ii + 0] * ptr_db[ii + 0];
      }
      ptr_lamt += 2 * pnb;
      ptr_db += 2 * pnb;
      ptr_qx += pnb;
    }
    ng0 = ng[jj];
    if (ng0 > 0) {
      png = (ng0 + bs - 1) / bs * bs;
      for (ii = 0; ii < ng0 - 3; ii += 4) {
        ptr_qx[ii + 0] = -ptr_lamt[ii + png + 0] * ptr_db[ii + png + 0] -
                         ptr_lamt[ii + 0] * ptr_db[ii + 0];
        ptr_qx[ii + 1] = -ptr_lamt[ii + png + 1] * ptr_db[ii + png + 1] -
                         ptr_lamt[ii + 1] * ptr_db[ii + 1];
        ptr_qx[ii + 2] = -ptr_lamt[ii + png + 2] * ptr_db[ii + png + 2] -
                         ptr_lamt[ii + 2] * ptr_db[ii + 2];
        ptr_qx[ii + 3] = -ptr_lamt[ii + png + 3] * ptr_db[ii + png + 3] -
                         ptr_lamt[ii + 3] * ptr_db[ii + 3];
      }
      for (; ii < ng0; ii++) {
        ptr_qx[ii + 0] = -ptr_lamt[ii + png + 0] * ptr_db[ii + png + 0] -
                         ptr_lamt[ii + 0] * ptr_db[ii + 0];
      }
    }
  }
}


x86 assembly (clang, -O0):
<d_update_gradient_new_rhs_mpc_hard_tv>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
movl   $0x4,-0x38(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1896 <d_update_gradient_new_rhs_mpc_hard_tv+0x796>
mov    0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    151c <d_update_gradient_new_rhs_mpc_hard_tv+0x41c>
mov    -0x3c(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
shl    $0x2,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1422 <d_update_gradient_new_rhs_mpc_hard_tv+0x322>
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
jmp    11ab <d_update_gradient_new_rhs_mpc_hard_tv+0xab>
jmp    1427 <d_update_gradient_new_rhs_mpc_hard_tv+0x327>
mov    -0x7c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    14d7 <d_update_gradient_new_rhs_mpc_hard_tv+0x3d7>
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1427 <d_update_gradient_new_rhs_mpc_hard_tv+0x327>
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x70(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    1883 <d_update_gradient_new_rhs_mpc_hard_tv+0x783>
mov    -0x44(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
shl    $0x2,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    17c9 <d_update_gradient_new_rhs_mpc_hard_tv+0x6c9>
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
jmp    1552 <d_update_gradient_new_rhs_mpc_hard_tv+0x452>
jmp    17ce <d_update_gradient_new_rhs_mpc_hard_tv+0x6ce>
mov    -0x7c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    187e <d_update_gradient_new_rhs_mpc_hard_tv+0x77e>
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    17ce <d_update_gradient_new_rhs_mpc_hard_tv+0x6ce>
jmp    1883 <d_update_gradient_new_rhs_mpc_hard_tv+0x783>
jmp    1888 <d_update_gradient_new_rhs_mpc_hard_tv+0x788>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1139 <d_update_gradient_new_rhs_mpc_hard_tv+0x39>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<d_update_gradient_new_rhs_mpc_hard_tv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x8(%rsp)
mov    %r8,-0x10(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %rdi,-0x20(%rsp)
test   %edi,%edi
js     1ce4 <d_update_gradient_new_rhs_mpc_hard_tv+0xbe4>
mov    -0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,-0x20(%rsp)
xor    %r12d,%r12d
movapd 0xec1(%rip),%xmm9
movapd 0xeb8(%rip),%xmm8
jmp    115f <d_update_gradient_new_rhs_mpc_hard_tv+0x5f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    -0x20(%rsp),%r12
je     1ce4 <d_update_gradient_new_rhs_mpc_hard_tv+0xbe4>
mov    0x38(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    -0x8(%rsp),%rcx
mov    (%rcx,%r12,8),%rbx
mov    0x40(%rsp),%rcx
mov    (%rcx,%r12,8),%rdx
mov    -0x18(%rsp),%rcx
mov    (%rcx,%r12,4),%r9d
test   %r9d,%r9d
jle    1758 <d_update_gradient_new_rhs_mpc_hard_tv+0x658>
lea    0x3(%r9),%r8
mov    %r8d,%r13d
and    $0xfffffffc,%r13d
xor    %r10d,%r10d
cmp    $0x4,%r9d
jb     1298 <d_update_gradient_new_rhs_mpc_hard_tv+0x198>
lea    -0x3(%r9),%ebp
cmp    $0x5,%rbp
mov    $0x4,%r11d
cmovae %rbp,%r11
add    $0xffffffffffffffff,%r11
cmp    $0x4,%r11
jae    12c8 <d_update_gradient_new_rhs_mpc_hard_tv+0x1c8>
xor    %r10d,%r10d
lea    (%rax,%r13,8),%rcx
add    $0x18,%rcx
lea    (%rbx,%r13,8),%rdi
add    $0x18,%rdi
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rcx,%r10,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  (%rbx,%r10,8),%xmm1
mulsd  (%rax,%r10,8),%xmm1
mulsd  -0x18(%rdi,%r10,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%r10,8)
movsd  -0x10(%rcx,%r10,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x8(%rbx,%r10,8),%xmm1
mulsd  0x8(%rax,%r10,8),%xmm1
mulsd  -0x10(%rdi,%r10,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%r10,8)
movsd  -0x8(%rcx,%r10,8),%xmm0
movsd  0x10(%rbx,%r10,8),%xmm1
mulsd  0x10(%rax,%r10,8),%xmm1
xorpd  %xmm9,%xmm0
mulsd  -0x8(%rdi,%r10,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rdx,%r10,8)
movsd  (%rcx,%r10,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x18(%rbx,%r10,8),%xmm1
mulsd  0x18(%rax,%r10,8),%xmm1
mulsd  (%rdi,%r10,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rdx,%r10,8)
add    $0x4,%r10
cmp    %rbp,%r10
jb     11e0 <d_update_gradient_new_rhs_mpc_hard_tv+0xe0>
cmp    %r9d,%r10d
jge    12c0 <d_update_gradient_new_rhs_mpc_hard_tv+0x1c0>
mov    %r10d,%r14d
movslq %r13d,%r11
mov    %r9,%r10
sub    %r14,%r10
cmp    $0x4,%r10
jae    1537 <d_update_gradient_new_rhs_mpc_hard_tv+0x437>
mov    %r14,%r15
jmp    1698 <d_update_gradient_new_rhs_mpc_hard_tv+0x598>
nopl   0x0(%rax,%rax,1)
movslq %r13d,%r11
jmp    1742 <d_update_gradient_new_rhs_mpc_hard_tv+0x642>
mov    %r8,-0x48(%rsp)
cmp    $0x5,%rbp
mov    $0x4,%ecx
cmovae %rbp,%rcx
add    $0xffffffffffffffff,%rcx
and    $0xfffffffffffffffc,%rcx
lea    (%rdx,%rcx,8),%r8
add    $0x20,%r8
lea    0x20(%rax,%rcx,8),%rsi
lea    (%rax,%r13,8),%r14
lea    (%rcx,%r13,1),%rdi
lea    0x20(%rax,%rdi,8),%r10
lea    0x20(%rbx,%rcx,8),%rcx
mov    %rcx,-0x28(%rsp)
lea    (%rbx,%r13,8),%r15
lea    (%rbx,%rdi,8),%rcx
add    $0x20,%rcx
mov    %rcx,-0x30(%rsp)
cmp    %rsi,%rdx
setb   -0x38(%rsp)
cmp    %r8,%rax
setb   -0x40(%rsp)
cmp    %r10,%rdx
setb   %cl
cmp    %r8,%r14
setb   -0x49(%rsp)
cmp    -0x28(%rsp),%rdx
setb   %dil
cmp    %r8,%rbx
setb   -0x28(%rsp)
cmp    -0x30(%rsp),%rdx
setb   %sil
cmp    %r8,%r15
setb   %r8b
mov    -0x40(%rsp),%r10b
test   %r10b,-0x38(%rsp)
jne    1cd7 <d_update_gradient_new_rhs_mpc_hard_tv+0xbd7>
and    -0x49(%rsp),%cl
jne    1cd7 <d_update_gradient_new_rhs_mpc_hard_tv+0xbd7>
mov    %r8d,%ecx
and    -0x28(%rsp),%dil
mov    -0x48(%rsp),%r8
jne    11c4 <d_update_gradient_new_rhs_mpc_hard_tv+0xc4>
mov    $0x0,%r10d
and    %cl,%sil
jne    11c7 <d_update_gradient_new_rhs_mpc_hard_tv+0xc7>
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%rdi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdi
lea    0x0(,%rdi,4),%r10
mov    %rdi,%r8
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rcx,1),%xmm2
movupd 0x10(%r14,%rcx,1),%xmm3
movupd 0x20(%r14,%rcx,1),%xmm0
movupd 0x30(%r14,%rcx,1),%xmm1
movapd %xmm2,%xmm6
unpcklpd %xmm0,%xmm6
unpckhpd %xmm0,%xmm2
movapd %xmm3,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm3
xorpd  %xmm8,%xmm6
movupd (%r15,%rcx,1),%xmm15
movupd 0x10(%r15,%rcx,1),%xmm11
movupd 0x20(%r15,%rcx,1),%xmm1
movupd 0x30(%r15,%rcx,1),%xmm7
movapd %xmm15,%xmm5
unpcklpd %xmm1,%xmm5
mulpd  %xmm6,%xmm5
unpckhpd %xmm1,%xmm15
movapd %xmm11,%xmm13
unpcklpd %xmm7,%xmm13
unpckhpd %xmm7,%xmm11
movsd  (%rax,%rcx,1),%xmm7
movsd  0x8(%rax,%rcx,1),%xmm14
movsd  0x10(%rax,%rcx,1),%xmm12
movsd  0x18(%rax,%rcx,1),%xmm10
movhpd 0x20(%rax,%rcx,1),%xmm7
movsd  (%rbx,%rcx,1),%xmm6
movsd  0x8(%rbx,%rcx,1),%xmm0
movsd  0x10(%rbx,%rcx,1),%xmm8
movsd  0x18(%rbx,%rcx,1),%xmm1
movhpd 0x20(%rbx,%rcx,1),%xmm6
mulpd  %xmm7,%xmm6
subpd  %xmm6,%xmm5
xorpd  0xb7e(%rip),%xmm2
mulpd  %xmm15,%xmm2
movhpd 0x28(%rax,%rcx,1),%xmm14
movhpd 0x28(%rbx,%rcx,1),%xmm0
mulpd  %xmm14,%xmm0
subpd  %xmm0,%xmm2
xorpd  0xb5b(%rip),%xmm4
mulpd  %xmm13,%xmm4
movhpd 0x30(%rax,%rcx,1),%xmm12
movhpd 0x30(%rbx,%rcx,1),%xmm8
mulpd  %xmm12,%xmm8
subpd  %xmm8,%xmm4
movapd 0xb35(%rip),%xmm8
xorpd  %xmm8,%xmm3
mulpd  %xmm11,%xmm3
movhpd 0x38(%rax,%rcx,1),%xmm10
movhpd 0x38(%rbx,%rcx,1),%xmm1
mulpd  %xmm10,%xmm1
subpd  %xmm1,%xmm3
movapd %xmm5,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movhlps %xmm5,%xmm2
movhlps %xmm4,%xmm3
movups %xmm3,0x30(%rdx,%rcx,1)
movups %xmm2,0x20(%rdx,%rcx,1)
movupd %xmm1,0x10(%rdx,%rcx,1)
movupd %xmm0,(%rdx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%r8
jne    13c0 <d_update_gradient_new_rhs_mpc_hard_tv+0x2c0>
cmp    %rdi,%r11
mov    -0x48(%rsp),%r8
jne    11c7 <d_update_gradient_new_rhs_mpc_hard_tv+0xc7>
jmp    1298 <d_update_gradient_new_rhs_mpc_hard_tv+0x198>
mov    %r8,-0x48(%rsp)
lea    (%rdx,%r14,8),%rdi
lea    (%rdx,%r9,8),%rbp
lea    (%rax,%r14,8),%r15
lea    (%rax,%r9,8),%rcx
mov    %r11,%rsi
add    %r14,%r11
lea    (%rax,%r11,8),%r8
mov    %rsi,-0x40(%rsp)
add    %r9,%rsi
cmp    %rcx,%rdi
lea    (%rax,%rsi,8),%rcx
setb   -0x38(%rsp)
cmp    %rbp,%r15
setb   %r13b
cmp    %rcx,%rdi
lea    (%rbx,%r9,8),%r15
setb   %cl
cmp    %rbp,%r8
setb   -0x30(%rsp)
cmp    %r15,%rdi
lea    (%rbx,%r14,8),%r8
setb   %r15b
cmp    %rbp,%r8
lea    (%rbx,%rsi,8),%rsi
setb   %r8b
cmp    %rsi,%rdi
lea    (%rbx,%r11,8),%rsi
setb   %dil
cmp    %rbp,%rsi
setb   %bpl
test   %r13b,-0x38(%rsp)
jne    168b <d_update_gradient_new_rhs_mpc_hard_tv+0x58b>
and    -0x30(%rsp),%cl
jne    168b <d_update_gradient_new_rhs_mpc_hard_tv+0x58b>
and    %r8b,%r15b
jne    168b <d_update_gradient_new_rhs_mpc_hard_tv+0x58b>
and    %bpl,%dil
jne    168b <d_update_gradient_new_rhs_mpc_hard_tv+0x58b>
mov    %r10,%r13
and    $0xfffffffffffffffc,%r13
lea    (%r14,%r13,1),%r15
lea    (%rbx,%r11,8),%r8
add    $0x10,%r8
lea    0x10(%rax,%r11,8),%r11
lea    (%rax,%r14,8),%rdi
add    $0x10,%rdi
lea    (%rbx,%r14,8),%rcx
add    $0x10,%rcx
lea    (%rdx,%r14,8),%rbp
add    $0x10,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%r11,%rsi,8),%xmm0
movupd (%r11,%rsi,8),%xmm1
xorpd  %xmm8,%xmm0
xorpd  %xmm8,%xmm1
movupd -0x10(%r8,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r8,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movupd -0x10(%rdi,%rsi,8),%xmm1
movupd (%rdi,%rsi,8),%xmm3
movupd -0x10(%rcx,%rsi,8),%xmm4
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
movupd (%rcx,%rsi,8),%xmm1
mulpd  %xmm3,%xmm1
subpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rbp,%rsi,8)
movupd %xmm0,0x0(%rbp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1610 <d_update_gradient_new_rhs_mpc_hard_tv+0x510>
cmp    %r13,%r10
mov    -0x48(%rsp),%r8
mov    -0x40(%rsp),%r11
jne    1698 <d_update_gradient_new_rhs_mpc_hard_tv+0x598>
jmp    1742 <d_update_gradient_new_rhs_mpc_hard_tv+0x642>
mov    %r14,%r15
mov    -0x48(%rsp),%r8
mov    -0x40(%rsp),%r11
mov    %r9d,%esi
sub    %r15d,%esi
mov    %r15,%rcx
test   $0x1,%sil
je     16d4 <d_update_gradient_new_rhs_mpc_hard_tv+0x5d4>
lea    (%r15,%r11,1),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorpd  %xmm8,%xmm0
movsd  (%rbx,%r15,8),%xmm1
mulsd  (%rax,%r15,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%r15,8)
lea    0x1(%r15),%rcx
not    %r15
add    %r9,%r15
je     1742 <d_update_gradient_new_rhs_mpc_hard_tv+0x642>
lea    (%rax,%r11,8),%rsi
add    $0x8,%rsi
lea    (%rbx,%r11,8),%rdi
add    $0x8,%rdi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
xorpd  %xmm9,%xmm0
mulsd  -0x8(%rdi,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  (%rdi,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    16f0 <d_update_gradient_new_rhs_mpc_hard_tv+0x5f0>
add    %r8d,%r8d
and    $0xfffffff8,%r8d
movslq %r8d,%rcx
lea    (%rax,%rcx,8),%rax
lea    (%rbx,%rcx,8),%rbx
lea    (%rdx,%r11,8),%rdx
mov    -0x10(%rsp),%rcx
mov    (%rcx,%r12,4),%r10d
test   %r10d,%r10d
jle    1150 <d_update_gradient_new_rhs_mpc_hard_tv+0x50>
lea    0x3(%r10),%r15d
and    $0xfffffffc,%r15d
xor    %esi,%esi
cmp    $0x4,%r10d
jb     1854 <d_update_gradient_new_rhs_mpc_hard_tv+0x754>
lea    -0x3(%r10),%r14d
cmp    $0x5,%r14
mov    $0x4,%r11d
cmovae %r14,%r11
add    $0xffffffffffffffff,%r11
cmp    $0x4,%r11
jae    187b <d_update_gradient_new_rhs_mpc_hard_tv+0x77b>
xor    %esi,%esi
lea    (%rax,%r15,8),%rcx
add    $0x18,%rcx
lea    (%rbx,%r15,8),%rdi
add    $0x18,%rdi
movsd  -0x18(%rcx,%rsi,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  (%rbx,%rsi,8),%xmm1
mulsd  (%rax,%rsi,8),%xmm1
mulsd  -0x18(%rdi,%rsi,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movsd  -0x10(%rcx,%rsi,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x8(%rbx,%rsi,8),%xmm1
mulsd  0x8(%rax,%rsi,8),%xmm1
mulsd  -0x10(%rdi,%rsi,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
movsd  -0x8(%rcx,%rsi,8),%xmm0
movsd  0x10(%rbx,%rsi,8),%xmm1
mulsd  0x10(%rax,%rsi,8),%xmm1
xorpd  %xmm9,%xmm0
mulsd  -0x8(%rdi,%rsi,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rdx,%rsi,8)
movsd  (%rcx,%rsi,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x18(%rbx,%rsi,8),%xmm1
mulsd  0x18(%rax,%rsi,8),%xmm1
mulsd  (%rdi,%rsi,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %r14,%rsi
jb     17b0 <d_update_gradient_new_rhs_mpc_hard_tv+0x6b0>
cmp    %r10d,%esi
jge    1150 <d_update_gradient_new_rhs_mpc_hard_tv+0x50>
mov    %esi,%r14d
movslq %r15d,%r8
mov    %r10,%r11
sub    %r14,%r11
cmp    $0x4,%r11
jae    1ad1 <d_update_gradient_new_rhs_mpc_hard_tv+0x9d1>
mov    %r14,%r15
jmp    1c1e <d_update_gradient_new_rhs_mpc_hard_tv+0xb1e>
cmp    $0x5,%r14
mov    $0x4,%ecx
cmovae %r14,%rcx
add    $0xffffffffffffffff,%rcx
and    $0xfffffffffffffffc,%rcx
lea    (%rdx,%rcx,8),%r8
add    $0x20,%r8
lea    0x20(%rax,%rcx,8),%rsi
lea    (%rax,%r15,8),%r9
lea    (%rcx,%r15,1),%rdi
lea    0x20(%rax,%rdi,8),%r13
lea    0x20(%rbx,%rcx,8),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rbx,%r15,8),%rbp
lea    (%rbx,%rdi,8),%rdi
add    $0x20,%rdi
cmp    %rsi,%rdx
setb   -0x48(%rsp)
cmp    %r8,%rax
setb   -0x38(%rsp)
cmp    %r13,%rdx
setb   %cl
cmp    %r8,%r9
setb   %r13b
cmp    -0x40(%rsp),%rdx
setb   %sil
cmp    %r8,%rbx
setb   -0x40(%rsp)
cmp    %rdi,%rdx
setb   %dil
cmp    %r8,%rbp
setb   -0x30(%rsp)
mov    -0x38(%rsp),%r8b
test   %r8b,-0x48(%rsp)
jne    179e <d_update_gradient_new_rhs_mpc_hard_tv+0x69e>
and    %r13b,%cl
jne    179e <d_update_gradient_new_rhs_mpc_hard_tv+0x69e>
and    -0x40(%rsp),%sil
jne    179e <d_update_gradient_new_rhs_mpc_hard_tv+0x69e>
mov    $0x0,%esi
and    -0x30(%rsp),%dil
jne    17a0 <d_update_gradient_new_rhs_mpc_hard_tv+0x6a0>
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%r8
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%r8
lea    0x0(,%r8,4),%rsi
mov    %r8,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movupd (%r9,%rdi,1),%xmm2
movupd 0x10(%r9,%rdi,1),%xmm3
movupd 0x20(%r9,%rdi,1),%xmm0
movupd 0x30(%r9,%rdi,1),%xmm1
movapd %xmm2,%xmm7
unpcklpd %xmm0,%xmm7
unpckhpd %xmm0,%xmm2
movapd %xmm3,%xmm4
unpcklpd %xmm1,%xmm4
unpckhpd %xmm1,%xmm3
xorpd  %xmm8,%xmm7
movupd 0x0(%rbp,%rdi,1),%xmm14
movupd 0x10(%rbp,%rdi,1),%xmm11
movupd 0x20(%rbp,%rdi,1),%xmm0
movupd 0x30(%rbp,%rdi,1),%xmm1
movapd %xmm14,%xmm5
unpcklpd %xmm0,%xmm5
mulpd  %xmm7,%xmm5
unpckhpd %xmm0,%xmm14
movapd %xmm11,%xmm12
unpcklpd %xmm1,%xmm12
unpckhpd %xmm1,%xmm11
movsd  (%rax,%rdi,1),%xmm7
movsd  0x8(%rax,%rdi,1),%xmm13
movsd  0x10(%rax,%rdi,1),%xmm8
movsd  0x18(%rax,%rdi,1),%xmm10
movhpd 0x20(%rax,%rdi,1),%xmm7
movsd  (%rbx,%rdi,1),%xmm0
movsd  0x8(%rbx,%rdi,1),%xmm6
movsd  0x10(%rbx,%rdi,1),%xmm1
movsd  0x18(%rbx,%rdi,1),%xmm15
movhpd 0x20(%rbx,%rdi,1),%xmm0
mulpd  %xmm7,%xmm0
subpd  %xmm0,%xmm5
xorpd  0x5df(%rip),%xmm2
mulpd  %xmm14,%xmm2
movhpd 0x28(%rax,%rdi,1),%xmm13
movhpd 0x28(%rbx,%rdi,1),%xmm6
mulpd  %xmm13,%xmm6
subpd  %xmm6,%xmm2
xorpd  0x5bc(%rip),%xmm4
mulpd  %xmm12,%xmm4
movhpd 0x30(%rax,%rdi,1),%xmm8
movhpd 0x30(%rbx,%rdi,1),%xmm1
mulpd  %xmm8,%xmm1
movapd 0x59c(%rip),%xmm8
subpd  %xmm1,%xmm4
xorpd  %xmm8,%xmm3
mulpd  %xmm11,%xmm3
movhpd 0x38(%rax,%rdi,1),%xmm10
movhpd 0x38(%rbx,%rdi,1),%xmm15
mulpd  %xmm10,%xmm15
subpd  %xmm15,%xmm3
movapd %xmm5,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movhlps %xmm5,%xmm2
movhlps %xmm4,%xmm3
movups %xmm3,0x30(%rdx,%rdi,1)
movups %xmm2,0x20(%rdx,%rdi,1)
movupd %xmm1,0x10(%rdx,%rdi,1)
movupd %xmm0,(%rdx,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1960 <d_update_gradient_new_rhs_mpc_hard_tv+0x860>
cmp    %r8,%r11
jne    17a0 <d_update_gradient_new_rhs_mpc_hard_tv+0x6a0>
jmp    1854 <d_update_gradient_new_rhs_mpc_hard_tv+0x754>
lea    (%rdx,%r14,8),%rdi
lea    (%rdx,%r10,8),%rbp
lea    (%rax,%r14,8),%r15
lea    (%rax,%r10,8),%rcx
lea    (%r8,%r14,1),%r9
mov    %r8,%rsi
lea    (%rax,%r9,8),%r8
mov    %rsi,-0x38(%rsp)
add    %r10,%rsi
cmp    %rcx,%rdi
lea    (%rax,%rsi,8),%rcx
setb   -0x48(%rsp)
cmp    %rbp,%r15
setb   %r13b
cmp    %rcx,%rdi
lea    (%rbx,%r10,8),%r15
setb   %cl
cmp    %rbp,%r8
setb   -0x40(%rsp)
cmp    %r15,%rdi
lea    (%rbx,%r14,8),%r8
setb   %r15b
cmp    %rbp,%r8
lea    (%rbx,%rsi,8),%rsi
setb   %r8b
cmp    %rsi,%rdi
lea    (%rbx,%r9,8),%rsi
setb   %dil
cmp    %rbp,%rsi
setb   %bpl
test   %r13b,-0x48(%rsp)
jne    1c16 <d_update_gradient_new_rhs_mpc_hard_tv+0xb16>
and    -0x40(%rsp),%cl
jne    1c16 <d_update_gradient_new_rhs_mpc_hard_tv+0xb16>
and    %r8b,%r15b
jne    1c16 <d_update_gradient_new_rhs_mpc_hard_tv+0xb16>
and    %bpl,%dil
jne    1c16 <d_update_gradient_new_rhs_mpc_hard_tv+0xb16>
mov    %r11,%r13
and    $0xfffffffffffffffc,%r13
lea    (%r14,%r13,1),%r15
lea    (%rbx,%r9,8),%r8
add    $0x10,%r8
lea    0x10(%rax,%r9,8),%r9
lea    (%rax,%r14,8),%rdi
add    $0x10,%rdi
lea    (%rbx,%r14,8),%rcx
add    $0x10,%rcx
lea    (%rdx,%r14,8),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movupd -0x10(%r9,%rbp,8),%xmm0
movupd (%r9,%rbp,8),%xmm1
xorpd  %xmm8,%xmm0
xorpd  %xmm8,%xmm1
movupd -0x10(%r8,%rbp,8),%xmm2
mulpd  %xmm0,%xmm2
movupd (%r8,%rbp,8),%xmm0
mulpd  %xmm1,%xmm0
movupd -0x10(%rdi,%rbp,8),%xmm1
movupd (%rdi,%rbp,8),%xmm3
movupd -0x10(%rcx,%rbp,8),%xmm4
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
movupd (%rcx,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
subpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%rsi,%rbp,8)
movupd %xmm0,(%rsi,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r13
jne    1ba0 <d_update_gradient_new_rhs_mpc_hard_tv+0xaa0>
cmp    %r13,%r11
mov    -0x38(%rsp),%r8
je     1150 <d_update_gradient_new_rhs_mpc_hard_tv+0x50>
jmp    1c1e <d_update_gradient_new_rhs_mpc_hard_tv+0xb1e>
mov    %r14,%r15
mov    -0x38(%rsp),%r8
mov    %r10d,%esi
sub    %r15d,%esi
mov    %r15,%rcx
test   $0x1,%sil
je     1c5a <d_update_gradient_new_rhs_mpc_hard_tv+0xb5a>
lea    (%r15,%r8,1),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorpd  %xmm8,%xmm0
movsd  (%rbx,%r15,8),%xmm1
mulsd  (%rax,%r15,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%r15,8)
lea    0x1(%r15),%rcx
not    %r15
add    %r10,%r15
je     1150 <d_update_gradient_new_rhs_mpc_hard_tv+0x50>
lea    (%rax,%r8,8),%rsi
add    $0x8,%rsi
lea    (%rbx,%r8,8),%rdi
add    $0x8,%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
xorpd  %xmm9,%xmm0
mulsd  -0x8(%rdi,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
xorpd  %xmm9,%xmm0
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  (%rdi,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1c80 <d_update_gradient_new_rhs_mpc_hard_tv+0xb80>
jmp    1150 <d_update_gradient_new_rhs_mpc_hard_tv+0x50>
xor    %r10d,%r10d
mov    -0x48(%rsp),%r8
jmp    11c7 <d_update_gradient_new_rhs_mpc_hard_tv+0xc7>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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