// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/LU/FullPivLU.h
// Function: Eigen::FullPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::computeInPlace()
void FullPivLU<MatrixType>::computeInPlace()
{
  check_template_parameters();

  // the permutations are stored as int indices, so just to be sure:
  eigen_assert(m_lu.rows()<=NumTraits<int>::highest() && m_lu.cols()<=NumTraits<int>::highest());

  m_l1_norm = m_lu.cwiseAbs().colwise().sum().maxCoeff();

  const Index size = m_lu.diagonalSize();
  const Index rows = m_lu.rows();
  const Index cols = m_lu.cols();

  // will store the transpositions, before we accumulate them at the end.
  // can't accumulate on-the-fly because that will be done in reverse order for the rows.
  m_rowsTranspositions.resize(m_lu.rows());
  m_colsTranspositions.resize(m_lu.cols());
  Index number_of_transpositions = 0; // number of NONTRIVIAL transpositions, i.e. m_rowsTranspositions[i]!=i

  m_nonzero_pivots = size; // the generic case is that in which all pivots are nonzero (invertible case)
  m_maxpivot = RealScalar(0);

  for(Index k = 0; k < size; ++k)
  {
    // First, we need to find the pivot.

    // biggest coefficient in the remaining bottom-right corner (starting at row k, col k)
    Index row_of_biggest_in_corner, col_of_biggest_in_corner;
    typedef internal::scalar_score_coeff_op<Scalar> Scoring;
    typedef typename Scoring::result_type Score;
    Score biggest_in_corner;
    biggest_in_corner = m_lu.bottomRightCorner(rows-k, cols-k)
                        .unaryExpr(Scoring())
                        .maxCoeff(&row_of_biggest_in_corner, &col_of_biggest_in_corner);
    row_of_biggest_in_corner += k; // correct the values! since they were computed in the corner,
    col_of_biggest_in_corner += k; // need to add k to them.

    if(biggest_in_corner==Score(0))
    {
      // before exiting, make sure to initialize the still uninitialized transpositions
      // in a sane state without destroying what we already have.
      m_nonzero_pivots = k;
      for(Index i = k; i < size; ++i)
      {
        m_rowsTranspositions.coeffRef(i) = i;
        m_colsTranspositions.coeffRef(i) = i;
      }
      break;
    }

    RealScalar abs_pivot = internal::abs_knowing_score<Scalar>()(m_lu(row_of_biggest_in_corner, col_of_biggest_in_corner), biggest_in_corner);
    if(abs_pivot > m_maxpivot) m_maxpivot = abs_pivot;

    // Now that we've found the pivot, we need to apply the row/col swaps to
    // bring it to the location (k,k).

    m_rowsTranspositions.coeffRef(k) = row_of_biggest_in_corner;
    m_colsTranspositions.coeffRef(k) = col_of_biggest_in_corner;
    if(k != row_of_biggest_in_corner) {
      m_lu.row(k).swap(m_lu.row(row_of_biggest_in_corner));
      ++number_of_transpositions;
    }
    if(k != col_of_biggest_in_corner) {
      m_lu.col(k).swap(m_lu.col(col_of_biggest_in_corner));
      ++number_of_transpositions;
    }

    // Now that the pivot is at the right location, we update the remaining
    // bottom-right corner by Gaussian elimination.

    if(k<rows-1)
      m_lu.col(k).tail(rows-k-1) /= m_lu.coeff(k,k);
    if(k<size-1)
      m_lu.block(k+1,k+1,rows-k-1,cols-k-1).noalias() -= m_lu.col(k).tail(rows-k-1) * m_lu.row(k).tail(cols-k-1);
  }

  // the main loop is over, we still have to accumulate the transpositions to find the
  // permutations P and Q

  m_p.setIdentity(rows);
  for(Index k = size-1; k >= 0; --k)
    m_p.applyTranspositionOnTheRight(k, m_rowsTranspositions.coeff(k));

  m_q.setIdentity(cols);
  for(Index k = 0; k < size; ++k)
    m_q.applyTranspositionOnTheRight(k, m_colsTranspositions.coeff(k));

  m_det_pq = (number_of_transpositions%2) ? -1 : 1;

  m_isInitialized = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
cmpq $0x7fffffff, 0x8(%rdi)  # imm = 0x7FFFFFFF
jg 0x1f4c5
movq 0x10(%rdi), %rax
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, %rax
jge 0x1f4c5
movq %rdi, 0x48(%rsp)
testq %rax, %rax
jle 0x1f4e4
leaq 0xa8(%rsp), %r14
movq %rdi, (%rsp)
movq %rdi, (%r14)
leaq 0x40(%rsp), %rax
movq %rax, 0x18(%r14)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f9c0
movapd %xmm0, %xmm1
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
cmpq $0x2, 0x10(%rax)
jl 0x1eb2a
movl $0x1, %r14d
leaq 0xa8(%rsp), %r15
movsd %xmm1, 0x10(%rsp)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1f9c0
maxsd 0x10(%rsp), %xmm0
incq %r14
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movapd %xmm0, %xmm1
cmpq 0x10(%rax), %r14
jl 0x1eaf6
jmp 0x1eb2e
movapd %xmm1, %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x60(%rax)
movq 0x8(%rax), %r15
movq 0x10(%rax), %rcx
cmpq %r15, %rcx
movq %r15, %r13
movq %rcx, 0x30(%rsp)
cmovlq %rcx, %r13
testq %r15, %r15
js 0x1f503
leaq 0x38(%rax), %r14
movl $0x1, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x1f5e2
movq (%rsp), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
js 0x1f51a
leaq 0x48(%rax), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x1f68a
movq (%rsp), %r10
movq %r13, 0x58(%r10)
movq $0x0, 0x68(%r10)
testq %r13, %r13
jle 0x1f33d
movq %r14, 0x88(%rsp)
movq %rbx, 0x78(%rsp)
leaq -0x1(%r15), %rax
movq %rax, 0xa0(%rsp)
leaq -0x1(%r13), %rax
movq %rax, 0x80(%rsp)
leaq (,%r15,8), %rax
negq %rax
movq %rax, 0x98(%rsp)
movl $0x1, %ebx
subq %r15, %rbx
movl $0x8, %eax
movq %rax, 0x90(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x18(%rsp)
xorl %r14d, %r14d
movq %r15, 0x20(%rsp)
movq %r15, %rbp
subq %r14, %rbp
movq 0x30(%rsp), %r12
subq %r14, %r12
movq (%r10), %rax
testq %rax, %rax
sete %cl
movq %r12, %rdx
orq %rbp, %rdx
setns %dl
orb %cl, %dl
je 0x1f39d
movq %rbx, 0x10(%rsp)
movq 0x8(%r10), %rcx
movq %rcx, %rdx
subq %rbp, %rdx
movq %rdx, %rsi
orq %rbp, %rsi
js 0x1f383
movq 0x10(%r10), %rsi
subq %r12, %rsi
movq %rsi, %rdi
orq %r12, %rdi
js 0x1f383
leaq (%rax,%rdx,8), %rax
movq %rsi, %rdi
imulq %rcx, %rdi
leaq (%rax,%rdi,8), %rax
movq %rax, 0xa8(%rsp)
movq %rbp, 0xb0(%rsp)
movq %r12, 0xb8(%rsp)
movq %r10, 0xc0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rcx, 0xd8(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r10, %rbx
callq 0x1fb62
movsd 0x50(%rsp), %xmm3
ucomisd 0x3d74d(%rip), %xmm3    # 0x5c420
jne 0x1ed03
jp 0x1ed03
movq %r14, 0x58(%rbx)
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
movq %r14, %rdx
movq %rbx, %r10
movq %rdx, (%rax,%rdx,8)
movq %rdx, (%rcx,%rdx,8)
incq %rdx
cmpq %r13, %rdx
jl 0x1ece9
movq 0x10(%rsp), %rbx
jmp 0x1f273
movq 0x40(%rsp), %rcx
movq %rcx, %rax
addq %r14, %rax
js 0x1f3ce
movq %rbx, %r10
movq 0x48(%rsp), %r15
movq %r15, %rbx
addq %r14, %rbx
js 0x1f3ce
cmpq %rax, 0x8(%r10)
jle 0x1f3ce
cmpq %rbx, 0x10(%r10)
jle 0x1f3ce
ucomisd 0x68(%r10), %xmm3
jbe 0x1ed4a
movsd %xmm3, 0x68(%r10)
movq (%r10), %rdx
movq 0x88(%rsp), %rsi
movq (%rsi), %rsi
movq %rax, (%rsi,%r14,8)
movq 0x78(%rsp), %rsi
movq (%rsi), %rsi
movq %rbx, (%rsi,%r14,8)
testq %rcx, %rcx
movsd %xmm3, 0x28(%rsp)
je 0x1ee2f
leaq (%rdx,%r14,8), %rsi
movq 0x10(%r10), %rcx
movq %rsi, 0xa8(%rsp)
movq %rcx, 0xb8(%rsp)
testq %rdx, %rdx
sete %sil
testq %rcx, %rcx
setns %dil
orb %sil, %dil
je 0x1f451
movq %r10, 0xc0(%rsp)
movq %r14, 0xc8(%rsp)
movq $0x0, 0xd0(%rsp)
movq $0x1, 0xd8(%rsp)
movq 0x8(%r10), %rsi
cmpq %r14, %rsi
jle 0x1f3ed
leaq (%rdx,%rax,8), %rdx
movq %rdx, 0x40(%rsp)
movq %rcx, 0x50(%rsp)
movq %r10, 0x58(%rsp)
movq %rax, 0x60(%rsp)
movq $0x0, 0x68(%rsp)
movq $0x1, 0x70(%rsp)
cmpq %rax, %rsi
jle 0x1f3ed
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1f732
incq 0x18(%rsp)
movq (%rsp), %r10
movsd 0x28(%rsp), %xmm3
testq %r15, %r15
je 0x1ef04
movq (%r10), %rcx
movq 0x8(%r10), %rax
movq %rax, %rdx
imulq %r14, %rdx
leaq (%rcx,%rdx,8), %rdx
movq %rdx, 0xa8(%rsp)
movq %rax, 0xb0(%rsp)
testq %rcx, %rcx
sete %dl
testq %rax, %rax
setns %sil
orb %dl, %sil
movq 0x20(%rsp), %r15
je 0x1f40c
movq %r10, 0xc0(%rsp)
movq $0x0, 0xc8(%rsp)
movq %r14, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
movq 0x10(%r10), %rdx
cmpq %r14, %rdx
jle 0x1f3b7
movq %rax, %rsi
imulq %rbx, %rsi
leaq (%rcx,%rsi,8), %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq %r10, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq %rbx, 0x68(%rsp)
movq %rax, 0x70(%rsp)
cmpq %rbx, %rdx
jbe 0x1f3b7
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1f7ca
incq 0x18(%rsp)
movq (%rsp), %r10
movq 0x10(%rsp), %rbx
movsd 0x28(%rsp), %xmm3
jmp 0x1ef0e
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %rbx
cmpq 0xa0(%rsp), %r14
jge 0x1f067
movq (%r10), %rax
movq 0x8(%r10), %rcx
testq %rax, %rax
sete %dl
testq %rcx, %rcx
setns %sil
orb %dl, %sil
je 0x1f40c
cmpq %r14, 0x10(%r10)
jle 0x1f3b7
movq %rcx, %rdx
imulq %r14, %rdx
leaq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
sete %dl
testq %rbp, %rbp
setg %sil
orb %dl, %sil
je 0x1f423
leaq -0x1(%rbp), %rdx
movq %rcx, %rsi
subq %rdx, %rsi
movq %rsi, %r8
orq %rdx, %r8
js 0x1f43a
testq %rbp, %rbp
jle 0x1f468
leaq (%rdi,%rsi,8), %r8
movq %rdx, %rsi
testb $0x7, %r8b
jne 0x1efa2
shrl $0x3, %r8d
andl $0x1, %r8d
cmpq %rdx, %r8
cmovaeq %rdx, %r8
movq %r8, %rsi
movsd (%rdi,%r14,8), %xmm0
testq %rsi, %rsi
je 0x1efe4
movq 0x98(%rsp), %rdi
leaq (%rax,%rdi), %r8
leaq 0x1(%rcx), %rdi
imulq 0x90(%rsp), %rdi
addq %r8, %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rsi
jne 0x1efcc
movq %rdx, %r8
subq %rsi, %r8
movq %r8, %rdi
shrq $0x3f, %rdi
addq %r8, %rdi
andq $-0x2, %rdi
addq %rsi, %rdi
cmpq $0x2, %r8
jl 0x1f036
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %r8
imulq 0x38(%rsp), %r8
leaq (%rcx,%rbx), %r9
leaq (%r8,%r9,8), %r8
addq %rax, %r8
movapd (%r8,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%r8,%rsi,8)
addq $0x2, %rsi
cmpq %rdi, %rsi
jl 0x1f01d
cmpq %rdx, %rdi
jge 0x1f067
movq %rcx, %rdx
imulq 0x38(%rsp), %rdx
addq %rbx, %rcx
leaq (%rdx,%rcx,8), %rcx
addq %rcx, %rax
movsd (%rax,%rdi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdi,8)
incq %rdi
movq %rbx, %rcx
addq %rdi, %rcx
jne 0x1f04e
cmpq 0x80(%rsp), %r14
jge 0x1f273
movq (%r10), %r8
movq 0x8(%r10), %rax
testq %r8, %r8
sete %cl
testq %rax, %rax
setns %dl
orb %cl, %dl
je 0x1f40c
movq 0x10(%r10), %rdi
cmpq %r14, %rdi
jle 0x1f3b7
testq %r8, %r8
sete %cl
testq %rbp, %rbp
setg %dl
orb %cl, %dl
je 0x1f423
leaq -0x1(%rbp), %rsi
movq %rax, %rcx
subq %rsi, %rcx
movq %rcx, %rdx
orq %rsi, %rdx
js 0x1f43a
cmpq %r14, %rax
jle 0x1f3ed
testq %r8, %r8
sete %dl
testq %r12, %r12
setg %r9b
orb %dl, %r9b
je 0x1f487
leaq -0x1(%r12), %r9
movq %rdi, %rdx
subq %r9, %rdx
movq %rdx, %r10
orq %r9, %r10
js 0x1f4a6
movq %rax, %r10
imulq %r14, %r10
leaq (%r8,%r10,8), %r10
leaq (%r10,%rcx,8), %r11
leaq (%r8,%r14,8), %rbx
movq %rdx, %r15
imulq %rax, %r15
leaq (%rbx,%r15,8), %r15
testq %r8, %r8
sete %r8b
movq %r11, 0xa8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %r10, 0xc0(%rsp)
movq %rax, 0xc8(%rsp)
movq (%rsp), %r11
movq %r11, 0xd8(%rsp)
movl $0x0, %r10d
movq %r10, 0xe0(%rsp)
movq %r14, 0xe8(%rsp)
movq %rax, 0xf0(%rsp)
movq %rcx, 0xf8(%rsp)
movq %rax, 0x108(%rsp)
movq %r15, 0x110(%rsp)
movq %r9, 0x120(%rsp)
movq %rbx, 0x128(%rsp)
movq %rdi, 0x138(%rsp)
movq %r11, 0x140(%rsp)
movq %r14, 0x148(%rsp)
movq %r10, 0x150(%rsp)
movl $0x1, %edi
movq %rdi, 0x158(%rsp)
movq %rdx, 0x168(%rsp)
movq %rdi, 0x170(%rsp)
leaq 0x1(%r14), %rdi
movq %rax, %r10
imulq %rdi, %r10
leaq (%rbx,%r10,8), %r10
addq $0x8, %r10
movq %r10, 0x40(%rsp)
movq %rsi, 0x48(%rsp)
movq %r9, 0x50(%rsp)
orq %rsi, %r9
setns %sil
orb %r8b, %sil
je 0x1f39d
movq %r11, 0x58(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdi, 0x68(%rsp)
movq %rax, 0x70(%rsp)
testq %rbp, %rbp
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %rbx
jle 0x1f383
testq %r12, %r12
jle 0x1f383
cmpq %r14, %rcx
jle 0x1f383
cmpq %r14, %rdx
jle 0x1f383
leaq 0x40(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x110(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
callq 0x1fc22
movq (%rsp), %r10
movsd 0x28(%rsp), %xmm3
ucomisd 0x3d1a5(%rip), %xmm3    # 0x5c420
jne 0x1f27f
jnp 0x1f29d
incq %r14
addq $0x8, 0x90(%rsp)
addq $0x8, 0x38(%rsp)
incq %rbx
cmpq %r13, %r14
jne 0x1ec13
movq 0x18(%rsp), %r14
andb $0x1, %r14b
negb %r14b
orb $0x1, %r14b
movq %r15, %rsi
leaq 0x18(%r10), %r15
movq %r15, %rdi
callq 0x1f896
testq %r13, %r13
jle 0x1f351
movq 0x88(%rsp), %rbx
movq 0x80(%rsp), %rsi
movq (%rbx), %rax
movq (%rax,%rsi,8), %rdx
movq %r15, %rdi
movq %rsi, %r12
callq 0x1f974
leaq -0x1(%r12), %rsi
incq %r12
cmpq $0x1, %r12
ja 0x1f2d5
movq (%rsp), %rax
leaq 0x28(%rax), %r15
movq %r15, %rdi
movq 0x30(%rsp), %rsi
callq 0x1f896
testq %r13, %r13
jle 0x1f37d
movq %r14, %r12
xorl %r14d, %r14d
movq 0x78(%rsp), %rbx
movq (%rbx), %rax
movq (%rax,%r14,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f974
incq %r14
cmpq %r14, %r13
jne 0x1f31a
movq (%rsp), %rbx
movq %r12, %r14
jmp 0x1f363
leaq 0x18(%r10), %rdi
movq %r15, %rsi
movq %r10, %rbx
callq 0x1f896
movb $0x1, %r14b
jmp 0x1f355
movq (%rsp), %rbx
leaq 0x28(%rbx), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f896
movb %r14b, 0x78(%rbx)
movb $0x1, 0x79(%rbx)
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rbx
jmp 0x1f363
leaq 0x3d461(%rip), %rdi     # 0x5c7eb
leaq 0x3d385(%rip), %rsi     # 0x5c716
leaq 0x3ee23(%rip), %rcx     # 0x5e1bb
jmp 0x1f4bb
leaq 0x3d4d6(%rip), %rdi     # 0x5c87a
leaq 0x3d579(%rip), %rsi     # 0x5c924
leaq 0x3eec1(%rip), %rcx     # 0x5e273
jmp 0x1f49c
leaq 0x3f0ce(%rip), %rdi     # 0x5e48c
leaq 0x3d351(%rip), %rsi     # 0x5c716
leaq 0x3f167(%rip), %rcx     # 0x5e533
jmp 0x1f402
leaq 0x42491(%rip), %rdi     # 0x61866
leaq 0x3de86(%rip), %rsi     # 0x5d262
leaq 0x424b8(%rip), %rcx     # 0x6189b
movl $0x16d, %edx            # imm = 0x16D
callq 0x9200
leaq 0x3f098(%rip), %rdi     # 0x5e48c
leaq 0x3d31b(%rip), %rsi     # 0x5c716
leaq 0x3f598(%rip), %rcx     # 0x5e99a
movl $0x7a, %edx
callq 0x9200
leaq 0x3d467(%rip), %rdi     # 0x5c87a
leaq 0x3d50a(%rip), %rsi     # 0x5c924
leaq 0x3f1c0(%rip), %rcx     # 0x5e5e1
jmp 0x1f49c
leaq 0x3d450(%rip), %rdi     # 0x5c87a
leaq 0x3d4f3(%rip), %rsi     # 0x5c924
leaq 0x42835(%rip), %rcx     # 0x61c6d
jmp 0x1f49c
leaq 0x3d3aa(%rip), %rdi     # 0x5c7eb
leaq 0x3d2ce(%rip), %rsi     # 0x5c716
leaq 0x4272a(%rip), %rcx     # 0x61b79
jmp 0x1f4bb
leaq 0x3d422(%rip), %rdi     # 0x5c87a
leaq 0x3d4c5(%rip), %rsi     # 0x5c924
leaq 0x3f5d9(%rip), %rcx     # 0x5ea3f
jmp 0x1f49c
leaq 0x3d0ed(%rip), %rdi     # 0x5c55c
leaq 0x3d17b(%rip), %rsi     # 0x5c5f1
leaq 0x3df6f(%rip), %rcx     # 0x5d3ec
movl $0x4a, %edx
callq 0x9200
leaq 0x3d3ec(%rip), %rdi     # 0x5c87a
leaq 0x3d48f(%rip), %rsi     # 0x5c924
leaq 0x42997(%rip), %rcx     # 0x61e33
movl $0xaf, %edx
callq 0x9200
leaq 0x3d33e(%rip), %rdi     # 0x5c7eb
leaq 0x3d262(%rip), %rsi     # 0x5c716
leaq 0x4289c(%rip), %rcx     # 0x61d57
movl $0x93, %edx
callq 0x9200
leaq 0x41df8(%rip), %rdi     # 0x612c4
leaq 0x41e42(%rip), %rsi     # 0x61315
leaq 0x41e56(%rip), %rcx     # 0x61330
movl $0x1ef, %edx            # imm = 0x1EF
callq 0x9200
leaq 0x3d506(%rip), %rdi     # 0x5c9f1
leaq 0x3d543(%rip), %rsi     # 0x5ca35
leaq 0x41eab(%rip), %rcx     # 0x613a4
movl $0x19d, %edx            # imm = 0x19D
callq 0x9200
leaq 0x3d743(%rip), %rdi     # 0x5cc4d
leaq 0x3d7c6(%rip), %rsi     # 0x5ccd7
leaq 0x41cbc(%rip), %rcx     # 0x611d4
jmp 0x1f52f
leaq 0x3d72c(%rip), %rdi     # 0x5cc4d
leaq 0x3d7af(%rip), %rsi     # 0x5ccd7
leaq 0x41d13(%rip), %rcx     # 0x61242
movl $0x138, %edx            # imm = 0x138
callq 0x9200
nop