// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fe35
movq 0x10(%rdi), %rax
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, %rax
jge 0x1fe35
movq %rdi, 0x48(%rsp)
testq %rax, %rax
jle 0x1fe54
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 0x202a6
movapd %xmm0, %xmm1
movq 0x18(%r14), %rax
movq 0x8(%rax), %rax
cmpq $0x2, 0x10(%rax)
jl 0x1f4b6
movl $0x1, %r14d
leaq 0xa8(%rsp), %r15
movsd %xmm1, 0x18(%rsp)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x202a6
maxsd 0x18(%rsp), %xmm0
incq %r14
movq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movapd %xmm0, %xmm1
cmpq 0x10(%rax), %r14
jl 0x1f482
jmp 0x1f4ba
movapd %xmm1, %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x60(%rax)
movq 0x8(%rax), %rbp
movq 0x10(%rax), %rcx
cmpq %rbp, %rcx
movq %rbp, %r14
movq %rcx, 0x80(%rsp)
cmovlq %rcx, %r14
testq %rbp, %rbp
js 0x1fe73
leaq 0x38(%rax), %rbx
movl $0x1, %ecx
movq %rbx, %rdi
movq %rbp, %rsi
movq %rbp, %rdx
callq 0x1ff52
movq (%rsp), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
js 0x1fe8a
leaq 0x48(%rax), %rdi
movl $0x1, %edx
movq %rdi, 0x78(%rsp)
movq %rcx, %rsi
callq 0x1fffa
movq (%rsp), %r10
movq %r14, 0x58(%r10)
movq $0x0, 0x68(%r10)
testq %r14, %r14
movq %rbp, 0x20(%rsp)
jle 0x1fc4f
leaq -0x1(%rbp), %rax
movq %rax, 0xa0(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x98(%rsp)
leaq (,%rbp,8), %rax
negq %rax
movq %rax, 0x90(%rsp)
movl $0x1, %eax
subq %rbp, %rax
movq %rax, 0x38(%rsp)
movl $0x8, %eax
movq %rax, 0x88(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movq %rbx, 0x18(%rsp)
movq %rbp, %r12
subq %r13, %r12
movq 0x80(%rsp), %r15
subq %r13, %r15
movq (%r10), %rax
testq %rax, %rax
sete %cl
movq %r15, %rdx
orq %r12, %rdx
setns %dl
orb %cl, %dl
je 0x1fd0d
movq 0x8(%r10), %rcx
movq %rcx, %rdx
subq %r12, %rdx
movq %rdx, %rsi
orq %r12, %rsi
js 0x1fcf3
movq 0x10(%r10), %rsi
subq %r15, %rsi
movq %rsi, %rdi
orq %r15, %rdi
js 0x1fcf3
leaq (%rax,%rdx,8), %rax
movq %rsi, %rdi
imulq %rcx, %rdi
leaq (%rax,%rdi,8), %rax
movq %rax, 0xa8(%rsp)
movq %r12, 0xb0(%rsp)
movq %r15, 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 0x2047e
movsd 0x50(%rsp), %xmm3
ucomisd 0x3cd71(%rip), %xmm3    # 0x5c3d0
jne 0x1f68a
jp 0x1f68a
movq %r13, 0x58(%rbx)
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rcx
movq %r13, %rdx
movq %rbx, %r10
movq %rdx, (%rax,%rdx,8)
movq %rdx, (%rcx,%rdx,8)
incq %rdx
cmpq %r14, %rdx
jl 0x1f675
jmp 0x1fc11
movq 0x40(%rsp), %rcx
movq %rcx, %rax
addq %r13, %rax
js 0x1fd3e
movq %rbx, %r10
movq 0x48(%rsp), %rbp
movq %rbp, %rbx
addq %r13, %rbx
js 0x1fd3e
cmpq %rax, 0x8(%r10)
jle 0x1fd3e
cmpq %rbx, 0x10(%r10)
jle 0x1fd3e
ucomisd 0x68(%r10), %xmm3
jbe 0x1f6d1
movsd %xmm3, 0x68(%r10)
movq (%r10), %rdx
movq 0x18(%rsp), %rsi
movq (%rsi), %rsi
movq %rax, (%rsi,%r13,8)
movq 0x78(%rsp), %rsi
movq (%rsi), %rsi
movq %rbx, (%rsi,%r13,8)
testq %rcx, %rcx
movsd %xmm3, 0x28(%rsp)
je 0x1f7b3
leaq (%rdx,%r13,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 0x1fd93
movq %r10, 0xc0(%rsp)
movq %r13, 0xc8(%rsp)
movq $0x0, 0xd0(%rsp)
movq $0x1, 0xd8(%rsp)
movq 0x8(%r10), %rsi
cmpq %r13, %rsi
jle 0x1fd5d
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 0x1fd5d
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x200a2
incq 0x10(%rsp)
movq (%rsp), %r10
movsd 0x28(%rsp), %xmm3
testq %rbp, %rbp
je 0x1f888
movq (%r10), %rcx
movq 0x8(%r10), %rax
movq %rax, %rdx
imulq %r13, %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), %rbp
je 0x1fd7c
movq %r10, 0xc0(%rsp)
movq $0x0, 0xc8(%rsp)
movq %r13, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
movq 0x10(%r10), %rdx
cmpq %r13, %rdx
jle 0x1fd27
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
jle 0x1fd27
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2013a
incq 0x10(%rsp)
movq (%rsp), %r10
movq 0x38(%rsp), %r11
movsd 0x28(%rsp), %xmm3
jmp 0x1f892
movq 0x20(%rsp), %rbp
movq 0x38(%rsp), %r11
cmpq 0xa0(%rsp), %r13
jge 0x1f9ec
movq (%r10), %rax
movq 0x8(%r10), %rcx
testq %rax, %rax
sete %dl
testq %rcx, %rcx
setns %sil
orb %dl, %sil
je 0x1fd7c
cmpq %r13, 0x10(%r10)
jle 0x1fd27
movq %rcx, %rdx
imulq %r13, %rdx
leaq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
sete %dl
testq %r12, %r12
setg %sil
orb %dl, %sil
je 0x1fdaa
leaq -0x1(%r12), %rdx
movq %rcx, %rsi
subq %rdx, %rsi
movq %rsi, %r8
orq %rdx, %r8
js 0x1fdc1
testq %r12, %r12
jle 0x1fdd8
leaq (%rdi,%rsi,8), %r8
movq %rdx, %rsi
testb $0x7, %r8b
jne 0x1f927
shrl $0x3, %r8d
andl $0x1, %r8d
cmpq %rdx, %r8
cmovgeq %rdx, %r8
movq %r8, %rsi
movsd (%rdi,%r13,8), %xmm0
testq %rsi, %rsi
jle 0x1f969
movq 0x90(%rsp), %rdi
leaq (%rax,%rdi), %r8
leaq 0x1(%rcx), %rdi
imulq 0x88(%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 0x1f951
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 0x1f9bb
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %r8
imulq 0x30(%rsp), %r8
leaq (%rcx,%r11), %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 0x1f9a2
cmpq %rdx, %rdi
jge 0x1f9ec
movq %rcx, %rdx
imulq 0x30(%rsp), %rdx
addq %r11, %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 %r11, %rcx
addq %rdi, %rcx
jne 0x1f9d3
cmpq 0x98(%rsp), %r13
jge 0x1fc11
movq (%r10), %rdi
movq 0x8(%r10), %rax
testq %rdi, %rdi
sete %cl
testq %rax, %rax
setns %dl
orb %cl, %dl
je 0x1fd7c
movq 0x10(%r10), %rsi
cmpq %r13, %rsi
jle 0x1fd27
testq %rdi, %rdi
sete %cl
testq %r12, %r12
setg %dl
orb %cl, %dl
je 0x1fdaa
leaq -0x1(%r12), %rdx
movq %rax, %rcx
subq %rdx, %rcx
movq %rcx, %r8
orq %rdx, %r8
js 0x1fdc1
testq %rdi, %rdi
sete %r8b
testq %rsi, %rsi
setns %r9b
orb %r8b, %r9b
je 0x1fd93
cmpq %r13, %rax
jle 0x1fd5d
testq %rdi, %rdi
sete %r8b
testq %r15, %r15
setg %r9b
orb %r8b, %r9b
je 0x1fdf7
leaq -0x1(%r15), %r9
movq %rsi, %r8
subq %r9, %r8
movq %r8, %r10
orq %r9, %r10
js 0x1fe16
movq %rax, %r10
imulq %r13, %r10
leaq (%rdi,%r10,8), %r10
leaq (%r10,%rcx,8), %r11
leaq (%rdi,%r13,8), %rbx
movq %r8, %rbp
imulq %rax, %rbp
leaq (%rbx,%rbp,8), %rbp
testq %rdi, %rdi
sete %dil
movq %r11, 0xa8(%rsp)
movq %rdx, 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 %r13, 0xe8(%rsp)
movq %rax, 0xf0(%rsp)
movq %rcx, 0xf8(%rsp)
movq %rax, 0x108(%rsp)
movq %rbp, 0x110(%rsp)
movq %r9, 0x120(%rsp)
movq %rbx, 0x128(%rsp)
movq %rsi, 0x138(%rsp)
movq %r11, 0x140(%rsp)
movq %r13, 0x148(%rsp)
movq %r10, 0x150(%rsp)
movl $0x1, %esi
movq %rsi, 0x158(%rsp)
movq %r8, 0x168(%rsp)
movq %rsi, 0x170(%rsp)
leaq 0x1(%r13), %rsi
movq %rax, %r10
imulq %rsi, %r10
leaq (%rbx,%r10,8), %r10
addq $0x8, %r10
movq %r10, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %r9, 0x50(%rsp)
orq %rdx, %r9
setns %dl
orb %dil, %dl
je 0x1fd0d
movq %r11, 0x58(%rsp)
movq %rsi, 0x60(%rsp)
movq %rsi, 0x68(%rsp)
movq %rax, 0x70(%rsp)
testq %r12, %r12
movq 0x20(%rsp), %rbp
jle 0x1fcf3
testq %r15, %r15
jle 0x1fcf3
cmpq %r13, %rcx
jle 0x1fcf3
cmpq %r13, %r8
jle 0x1fcf3
leaq 0x40(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x110(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
callq 0x20543
movq (%rsp), %r10
movq 0x18(%rsp), %rbx
movsd 0x28(%rsp), %xmm3
jmp 0x1fc16
movq 0x18(%rsp), %rbx
ucomisd 0x3c7b2(%rip), %xmm3    # 0x5c3d0
jne 0x1fc22
jnp 0x1fc42
incq %r13
addq $0x8, 0x88(%rsp)
addq $0x8, 0x30(%rsp)
incq 0x38(%rsp)
cmpq %r14, %r13
jne 0x1f5a1
movq 0x10(%rsp), %rax
andb $0x1, %al
negb %al
orb $0x1, %al
jmp 0x1fc51
movb $0x1, %al
movq %rax, 0x10(%rsp)
leaq 0x18(%r10), %rbp
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x20206
testq %r14, %r14
jle 0x1fc92
leaq -0x1(%r14), %r13
movq (%rbx), %rax
movq (%rax,%r13,8), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2025a
leaq -0x1(%r13), %rax
incq %r13
cmpq $0x1, %r13
movq %rax, %r13
jg 0x1fc70
movq (%rsp), %rax
leaq 0x28(%rax), %r12
movq %r12, %rdi
movq 0x80(%rsp), %rsi
callq 0x20206
testq %r14, %r14
movq 0x78(%rsp), %rbx
jle 0x1fcd1
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2025a
incq %r15
cmpq %r15, %r14
jne 0x1fcb7
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movb %cl, 0x78(%rax)
movb $0x1, 0x79(%rax)
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cad1(%rip), %rdi     # 0x5c7cb
leaq 0x3c9f5(%rip), %rsi     # 0x5c6f6
leaq 0x3e68f(%rip), %rcx     # 0x5e397
jmp 0x1fe2b
leaq 0x3cb46(%rip), %rdi     # 0x5c85a
leaq 0x3cbe9(%rip), %rsi     # 0x5c904
leaq 0x3e72d(%rip), %rcx     # 0x5e44f
jmp 0x1fe0c
leaq 0x3e93a(%rip), %rdi     # 0x5e668
leaq 0x3c9c1(%rip), %rsi     # 0x5c6f6
leaq 0x3e9d3(%rip), %rcx     # 0x5e70f
jmp 0x1fd72
leaq 0x41df9(%rip), %rdi     # 0x61b3e
leaq 0x3d4f6(%rip), %rsi     # 0x5d242
leaq 0x41e20(%rip), %rcx     # 0x61b73
movl $0x16d, %edx            # imm = 0x16D
callq 0x9200
leaq 0x3e904(%rip), %rdi     # 0x5e668
leaq 0x3c98b(%rip), %rsi     # 0x5c6f6
leaq 0x3ee04(%rip), %rcx     # 0x5eb76
movl $0x7a, %edx
callq 0x9200
leaq 0x3cad7(%rip), %rdi     # 0x5c85a
leaq 0x3cb7a(%rip), %rsi     # 0x5c904
leaq 0x3ea2c(%rip), %rcx     # 0x5e7bd
jmp 0x1fe0c
leaq 0x3cac0(%rip), %rdi     # 0x5c85a
leaq 0x3cb63(%rip), %rsi     # 0x5c904
leaq 0x3ee73(%rip), %rcx     # 0x5ec1b
jmp 0x1fe0c
leaq 0x3caa9(%rip), %rdi     # 0x5c85a
leaq 0x3cb4c(%rip), %rsi     # 0x5c904
leaq 0x42186(%rip), %rcx     # 0x61f45
jmp 0x1fe0c
leaq 0x3ca03(%rip), %rdi     # 0x5c7cb
leaq 0x3c927(%rip), %rsi     # 0x5c6f6
leaq 0x4207b(%rip), %rcx     # 0x61e51
jmp 0x1fe2b
leaq 0x3c75d(%rip), %rdi     # 0x5c53c
leaq 0x3c7eb(%rip), %rsi     # 0x5c5d1
leaq 0x3d5df(%rip), %rcx     # 0x5d3cc
movl $0x4a, %edx
callq 0x9200
leaq 0x3ca5c(%rip), %rdi     # 0x5c85a
leaq 0x3caff(%rip), %rsi     # 0x5c904
leaq 0x422ff(%rip), %rcx     # 0x6210b
movl $0xaf, %edx
callq 0x9200
leaq 0x3c9ae(%rip), %rdi     # 0x5c7cb
leaq 0x3c8d2(%rip), %rsi     # 0x5c6f6
leaq 0x42204(%rip), %rcx     # 0x6202f
movl $0x93, %edx
callq 0x9200
leaq 0x41760(%rip), %rdi     # 0x6159c
leaq 0x417aa(%rip), %rsi     # 0x615ed
leaq 0x417be(%rip), %rcx     # 0x61608
movl $0x1ef, %edx            # imm = 0x1EF
callq 0x9200
leaq 0x3cb76(%rip), %rdi     # 0x5c9d1
leaq 0x3cbb3(%rip), %rsi     # 0x5ca15
leaq 0x41813(%rip), %rcx     # 0x6167c
movl $0x19d, %edx            # imm = 0x19D
callq 0x9200
leaq 0x3cdb3(%rip), %rdi     # 0x5cc2d
leaq 0x3ce36(%rip), %rsi     # 0x5ccb7
leaq 0x41624(%rip), %rcx     # 0x614ac
jmp 0x1fe9f
leaq 0x3cd9c(%rip), %rdi     # 0x5cc2d
leaq 0x3ce1f(%rip), %rsi     # 0x5ccb7
leaq 0x4167b(%rip), %rcx     # 0x6151a
movl $0x138, %edx            # imm = 0x138
callq 0x9200
nop