LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Pyboon[P]sage/./sage.h
// Function: Sage::Sage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Sage(string path_cir, string path_antenna, string path_result, int max_iter_num = 10, int max_path_num = 10):
    max_iter_num(max_iter_num), max_path_num(max_path_num){
        config.path_cir = path_cir;
        config.path_antenna = path_antenna;
        config.path_result = path_result;
        tol.tau = 2;
        tol.doppler = 1;
        tol.phi_rx = 2;
        tol.theta_rx = 2;
        tol.phi_tx = 2;
        tol.theta_tx = 2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq 0xa564a(%rip), %rax     # 0xb4c98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0xf810
movq -0x48(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq %rdi, -0x40(%rbp)
callq 0xf850
jmp 0xf678
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0x158(%rdi)
movl -0x28(%rbp), %eax
movl %eax, 0x15c(%rdi)
addq $0x160, %rdi            # imm = 0x160
movq %rdi, -0x90(%rbp)
callq 0xf8a0
movq -0x48(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0x88(%rbp)
callq 0xf8a0
movq -0x48(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
movq %rdi, -0x80(%rbp)
callq 0xf8a0
movq -0x48(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq %rdi, -0x78(%rbp)
callq 0xf8a0
movq -0x48(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq %rdi, -0x70(%rbp)
callq 0xf8c0
jmp 0xf6f6
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x9050
jmp 0xf709
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x9050
jmp 0xf71c
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x9050
jmp 0xf72f
movq -0x48(%rbp), %rax
movl $0x2, 0x238(%rax)
movsd 0x5e8e3(%rip), %xmm0    # 0x6e028
movsd %xmm0, 0x240(%rax)
movsd 0x5e8cb(%rip), %xmm0    # 0x6e020
movsd %xmm0, 0x250(%rax)
movsd 0x5e8bb(%rip), %xmm0    # 0x6e020
movsd %xmm0, 0x248(%rax)
movsd 0x5e8ab(%rip), %xmm0    # 0x6e020
movsd %xmm0, 0x260(%rax)
movsd 0x5e89b(%rip), %xmm0    # 0x6e020
movsd %xmm0, 0x258(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf7fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xf7c7
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xf9f0
movq -0x78(%rbp), %rdi
callq 0xfa60
movq -0x80(%rbp), %rdi
callq 0xfa60
movq -0x88(%rbp), %rdi
callq 0xfa60
movq -0x90(%rbp), %rdi
callq 0xfa60
movq -0x40(%rbp), %rdi
callq 0xfac0
movq -0x50(%rbp), %rdi
callq 0xfae0
movq -0x30(%rbp), %rdi
callq 0x9dc0
nopl (%rax)
// File: Pyboon[P]sage/sage.cpp
// Function: Sage::InitCIR()
void Sage::InitCIR(){
    int rows = config.sample_codes;
    int cols = config.subchannel_num * config.cycle_num;
    this->CIR = MatrixXcd::Zero(rows, cols);
    cout<<"CIR MAT size: "<<this->CIR.rows()<<" * "<<this->CIR.cols()<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl 0x1c(%rcx), %eax
movl %eax, -0xc(%rbp)
movl 0xa0(%rcx), %eax
imull 0x10(%rcx), %eax
movl %eax, -0x10(%rbp)
movslq -0xc(%rbp), %rsi
movslq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x13a60
movq -0x40(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
leaq -0x30(%rbp), %rsi
callq 0x13ac0
movq 0xa3105(%rip), %rdi     # 0xb4fc8
leaq 0x5c3c6(%rip), %rsi     # 0x6e290
callq 0x9790
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x138, %rdi            # imm = 0x138
callq 0x13af0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x9e40
movq %rax, %rdi
leaq 0x5c3a6(%rip), %rsi     # 0x6e29f
callq 0x9790
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x138, %rdi            # imm = 0x138
callq 0x13b10
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9e40
movq %rax, %rdi
movq 0xa3068(%rip), %rsi     # 0xb4f90
callq 0x97d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Pyboon[P]sage/./util.h
// Function: Util::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void log(const string message){
        char hostname[MAX_LENGTH];
        gethostname(hostname, MAX_LENGTH);
        string cur_time = GetCurTime();
        printf("[%s][%s] INFO:%s\n", hostname, cur_time.c_str(), message.c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x458(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
movq %rdi, -0x450(%rbp)
movl $0x400, %esi            # imm = 0x400
callq 0x9bb0
leaq -0x430(%rbp), %rdi
movq %rdi, -0x460(%rbp)
callq 0x141d0
movq -0x460(%rbp), %rdi
callq 0x92a0
movq -0x458(%rbp), %rdi
movq %rax, -0x448(%rbp)
callq 0x92a0
movq -0x450(%rbp), %rsi
movq -0x448(%rbp), %rdx
movq %rax, %rcx
leaq 0x5a7b8(%rip), %rdi     # 0x6e3b0
xorl %eax, %eax
callq 0x9060
jmp 0x13c01
leaq -0x430(%rbp), %rdi
callq 0x9470
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x438(%rbp)
movl %eax, -0x43c(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x9470
movq -0x438(%rbp), %rdi
callq 0x9dc0
// File: Pyboon[P]sage/./util.h
// Function: Util::GetCurTime[abi:cxx11]()
static string  GetCurTime(){
        time_t nowtime;  
        nowtime = time(NULL); 
        char tmp[64];   
        strftime(tmp,sizeof(tmp),"%Y-%m-%d %H:%M:%S",localtime(&nowtime));   
        return tmp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x9720
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9570
movq %rax, %rcx
leaq 0x5a1b5(%rip), %rdx     # 0x6e3c2
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x40, %esi
callq 0x9650
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9dd0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0xb320
jmp 0x1423f
leaq -0x51(%rbp), %rdi
callq 0x9840
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x9840
movq -0x60(%rbp), %rdi
callq 0x9dc0
nopw %cs:(%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<std::complex<double>, -1, -1, -1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
      m_cols = cols;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
je 0x14c70
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
imulq 0x10(%rax), %rsi
callq 0xfc20
cmpq $0x0, -0x10(%rbp)
je 0x14c63
movq -0x10(%rbp), %rdi
callq 0x14d30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14c6e
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x14c70
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::aligned_malloc(unsigned long)
EIGEN_DEVICE_FUNC inline void* aligned_malloc(std::size_t size)
{
  check_that_malloc_is_allowed();

  void *result;
  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
    result = std::malloc(size);
    #if EIGEN_DEFAULT_ALIGN_BYTES==16
    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade alignd memory allocator.");
    #endif
  #else
    result = handmade_aligned_malloc(size);
  #endif

  if(!result && size)
    throw_std_bad_alloc();

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x14e40
movq -0x8(%rbp), %rdi
callq 0x9a60
movq %rax, -0x10(%rbp)
cmpq $0x10, -0x8(%rbp)
jb 0x14de8
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0x14def
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x14def
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x14df8
jmp 0x14dfa
jmp 0x14e19
leaq 0x59c7d(%rip), %rdi     # 0x6ea7e
leaq 0x59d30(%rip), %rsi     # 0x6eb38
movl $0xa1, %edx
leaq 0x59d43(%rip), %rcx     # 0x6eb57
callq 0x94c0
cmpq $0x0, -0x10(%rbp)
jne 0x14e2c
cmpq $0x0, -0x8(%rbp)
je 0x14e2c
callq 0x14c90
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<std::complex<double>, -1, -1, 2, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
    {
      if(size != m_rows*_Cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
je 0x1635c
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
shlq %rsi
callq 0xfc20
cmpq $0x0, -0x10(%rbp)
je 0x1634f
movq -0x10(%rbp), %rdi
callq 0x14d30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1635a
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1635c
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Pyboon[P]sage/isi_sage.cpp
// Function: IsiSage::run()
void IsiSage::run(){
    // antenna response and CIR init
    ReadCIR();
    ReadAntennaResponse();
    ParamsInit();
    ParamsIterationUpdate();
    string save_path = config.path_result + "/spot_" + to_string(spot) + "_" + to_string(cycle_idx);
    SaveResult(save_path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x100(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x100(%rbp), %rdi
callq 0x18e70
movq -0x100(%rbp), %rdi
callq 0x1c9f0
movq -0x100(%rbp), %rsi
addq $0x48, %rsi
leaq 0x50312(%rip), %rdx     # 0x6fcdf
leaq -0x88(%rbp), %rdi
callq 0xb3d0
movq -0x100(%rbp), %rax
movl 0x150(%rax), %esi
leaq -0xa8(%rbp), %rdi
callq 0x1fef0
jmp 0x1f9f4
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x21bf0
jmp 0x1fa0d
leaq 0x502d0(%rip), %rdx     # 0x6fce4
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x13b30
jmp 0x1fa23
movq -0x100(%rbp), %rax
movl 0x154(%rax), %esi
leaq -0xd8(%rbp), %rdi
callq 0x1fef0
jmp 0x1fa3e
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x21bf0
jmp 0x1fa54
leaq -0xd8(%rbp), %rdi
callq 0x9470
leaq -0x48(%rbp), %rdi
callq 0x9470
leaq -0x68(%rbp), %rdi
callq 0x9470
leaq -0xa8(%rbp), %rdi
callq 0x9470
leaq -0x88(%rbp), %rdi
callq 0x9470
leaq -0xf8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x92c0
jmp 0x1fa9c
movq -0x100(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1f430
jmp 0x1fab1
leaq -0xf8(%rbp), %rdi
callq 0x9470
leaq -0x28(%rbp), %rdi
callq 0x9470
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x1fb5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x1fb4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x1fb46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x1fb3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x9470
leaq -0x48(%rbp), %rdi
callq 0x9470
leaq -0x68(%rbp), %rdi
callq 0x9470
leaq -0xa8(%rbp), %rdi
callq 0x9470
leaq -0x88(%rbp), %rdi
callq 0x9470
jmp 0x1fba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x1fb9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x9470
leaq -0x28(%rbp), %rdi
callq 0x9470
movq -0xb0(%rbp), %rdi
callq 0x9dc0
// File: Pyboon[P]sage/./Eigen/src/Core/Redux.h
// Function: std::complex<double> Eigen::DenseBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<std::complex<double>, std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1> const> const, Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const>>::redux<Eigen::internal::scalar_sum_op<std::complex<double>, std::complex<double>>>(Eigen::internal::scalar_sum_op<std::complex<double>, std::complex<double>> const&) const
EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
DenseBase<Derived>::redux(const Func& func) const
{
  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");

  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
  ThisEvaluator thisEval(derived());
  
  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2ce30
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x65(%rbp)
jle 0x2cd6c
movq -0x70(%rbp), %rdi
callq 0x2ce60
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x65(%rbp)
jle 0x2cd6c
movb $0x1, %al
movb %al, -0x65(%rbp)
jmp 0x2cd6c
movb -0x65(%rbp), %al
testb $0x1, %al
jne 0x2cd75
jmp 0x2cd77
jmp 0x2cd96
leaq 0x43e9e(%rip), %rdi     # 0x70c1c
leaq 0x43edb(%rip), %rsi     # 0x70c60
movl $0x19d, %edx            # imm = 0x19D
leaq 0x46aa9(%rip), %rcx     # 0x7383a
callq 0x94c0
movq -0x70(%rbp), %rdi
callq 0x2cd10
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2ced0
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2cf10
movsd %xmm1, -0x80(%rbp)
movsd %xmm0, -0x78(%rbp)
jmp 0x2cdce
movsd -0x80(%rbp), %xmm0
movsd -0x78(%rbp), %xmm1
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2d3b0
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2d3b0
movq -0x60(%rbp), %rdi
callq 0x9dc0
nopl (%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<std::complex<double>, -1, 1, -1, 1>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
    {
      if(size != _Rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_cols = cols;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x26abe
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0xfc20
cmpq $0x0, -0x10(%rbp)
je 0x26ab1
movq -0x10(%rbp), %rdi
callq 0x14d30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x26abc
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x26abe
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: Pyboon[P]sage/./Eigen/src/Core/arch/SSE/Complex.h
// Function: Eigen::internal::Packet1cd Eigen::internal::pmul<Eigen::internal::Packet1cd>(Eigen::internal::Packet1cd const&, Eigen::internal::Packet1cd const&)
EIGEN_STRONG_INLINE Packet1cd pmul<Packet1cd>(const Packet1cd& a, const Packet1cd& b)
{
  #ifdef EIGEN_VECTORIZE_SSE3
  return Packet1cd(_mm_addsub_pd(_mm_mul_pd(_mm_movedup_pd(a.v), b.v),
                                 _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
                                            vec2d_swizzle1(b.v, 1, 0))));
  #else
  const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0));
  return Packet1cd(_mm_add_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v),
                              _mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
                                                    vec2d_swizzle1(b.v, 1, 0)), mask)));
  #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x128(%rbp)
movq %rsi, -0x130(%rbp)
movl $0x0, -0xf4(%rbp)
movl $0x0, -0xf8(%rbp)
movl $0x80000000, -0xfc(%rbp) # imm = 0x80000000
movl $0x0, -0x100(%rbp)
movd -0xf4(%rbp), %xmm0
movd -0xf8(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd -0xfc(%rbp), %xmm2
movd -0x100(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movaps %xmm0, -0x110(%rbp)
movaps -0x110(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x140(%rbp)
movq -0x128(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x10(%rbp)
movapd -0x10(%rbp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm1
movq -0x130(%rbp), %rax
movapd (%rax), %xmm0
movaps %xmm1, -0x40(%rbp)
movapd %xmm0, -0x50(%rbp)
movapd -0x40(%rbp), %xmm1
movapd -0x50(%rbp), %xmm0
mulpd %xmm0, %xmm1
movq -0x128(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x20(%rbp)
movapd -0x20(%rbp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movapd %xmm0, -0xe0(%rbp)
movapd -0xe0(%rbp), %xmm2
movq -0x130(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x30(%rbp)
movapd -0x30(%rbp), %xmm0
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
movdqa %xmm0, -0xf0(%rbp)
movdqa -0xf0(%rbp), %xmm0
movapd %xmm2, -0x60(%rbp)
movapd %xmm0, -0x70(%rbp)
movapd -0x60(%rbp), %xmm2
mulpd -0x70(%rbp), %xmm2
movapd -0x140(%rbp), %xmm0
movapd %xmm2, -0xa0(%rbp)
movapd %xmm0, -0xb0(%rbp)
movapd -0xa0(%rbp), %xmm0
movapd -0xb0(%rbp), %xmm2
pxor %xmm2, %xmm0
movapd %xmm1, -0x80(%rbp)
movapd %xmm0, -0x90(%rbp)
movapd -0x80(%rbp), %xmm0
addpd -0x90(%rbp), %xmm0
movapd %xmm0, -0x150(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x15370
movapd -0x120(%rbp), %xmm0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/ProductEvaluators.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>, Eigen::Product<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const> const>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0>, Eigen::internal::assign_op<std::complex<double>, std::complex<double>>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>&, Eigen::Product<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const> const>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0> const&, Eigen::internal::assign_op<std::complex<double>, std::complex<double>> const&)
static EIGEN_STRONG_INLINE
  void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);
    // FIXME shall we handle nested_eval here?
    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31270
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31290
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24b50
cmpq -0x20(%rbp), %rax
jne 0x3121c
movq -0x8(%rbp), %rdi
callq 0x24b90
cmpq -0x28(%rbp), %rax
je 0x3122d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x26950
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31320
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31330
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x312b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/arch/SSE/Complex.h
// Function: Eigen::internal::conj_helper<Eigen::internal::Packet1cd, Eigen::internal::Packet1cd, false, true>::pmul(Eigen::internal::Packet1cd const&, Eigen::internal::Packet1cd const&) const
EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& b) const
  {
    #ifdef EIGEN_VECTORIZE_SSE3
    return internal::pmul(a, pconj(b));
    #else
    const __m128d mask = _mm_castsi128_pd(_mm_set_epi32(0x80000000,0x0,0x0,0x0));
    return Packet1cd(_mm_add_pd(_mm_xor_pd(_mm_mul_pd(vec2d_swizzle1(a.v, 0, 0), b.v), mask),
                                _mm_mul_pd(vec2d_swizzle1(a.v, 1, 1),
                                           vec2d_swizzle1(b.v, 1, 0))));
    #endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x128(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdx, -0x138(%rbp)
movl $0x80000000, -0xf4(%rbp) # imm = 0x80000000
movl $0x0, -0xf8(%rbp)
movl $0x0, -0xfc(%rbp)
movl $0x0, -0x100(%rbp)
movd -0xf4(%rbp), %xmm0
movd -0xf8(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd -0xfc(%rbp), %xmm2
movd -0x100(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movaps %xmm0, -0x110(%rbp)
movaps -0x110(%rbp), %xmm0
movaps %xmm0, -0xc0(%rbp)
movaps -0xc0(%rbp), %xmm0
movaps %xmm0, -0x150(%rbp)
movq -0x130(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x10(%rbp)
movapd -0x10(%rbp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, -0xd0(%rbp)
movaps -0xd0(%rbp), %xmm1
movq -0x138(%rbp), %rax
movapd (%rax), %xmm0
movaps %xmm1, -0x40(%rbp)
movapd %xmm0, -0x50(%rbp)
movapd -0x40(%rbp), %xmm1
movapd -0x50(%rbp), %xmm0
mulpd %xmm0, %xmm1
movapd -0x150(%rbp), %xmm0
movapd %xmm1, -0xa0(%rbp)
movapd %xmm0, -0xb0(%rbp)
movaps -0xa0(%rbp), %xmm1
movaps -0xb0(%rbp), %xmm0
pxor %xmm0, %xmm1
movq -0x130(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x20(%rbp)
movapd -0x20(%rbp), %xmm0
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movapd %xmm0, -0xe0(%rbp)
movapd -0xe0(%rbp), %xmm2
movq -0x138(%rbp), %rax
movapd (%rax), %xmm0
movapd %xmm0, -0x30(%rbp)
movapd -0x30(%rbp), %xmm0
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
movdqa %xmm0, -0xf0(%rbp)
movdqa -0xf0(%rbp), %xmm0
movapd %xmm2, -0x60(%rbp)
movapd %xmm0, -0x70(%rbp)
movapd -0x60(%rbp), %xmm0
mulpd -0x70(%rbp), %xmm0
movapd %xmm1, -0x80(%rbp)
movapd %xmm0, -0x90(%rbp)
movapd -0x80(%rbp), %xmm0
addpd -0x90(%rbp), %xmm0
movapd %xmm0, -0x160(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x15370
movapd -0x120(%rbp), %xmm0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: void Eigen::internal::generic_product_impl<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const> const>, Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2>, Eigen::DenseShape, Eigen::DenseShape, 8>::evalTo<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>(Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const> const> const&, Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const&)
static void evalTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    if((rhs.rows()+dst.rows()+dst.cols())<20 && rhs.rows()>0)
      lazyproduct::evalTo(dst, lhs, rhs);
    else
    {
      dst.setZero();
      scaleAndAddTo(dst, lhs, rhs, Scalar(1));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16460
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39560
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39580
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
cmpq $0x14, %rax
jge 0x39613
movq -0x18(%rbp), %rdi
callq 0x16460
cmpq $0x0, %rax
jle 0x39613
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x396c0
jmp 0x3965d
movq -0x8(%rbp), %rdi
callq 0x39710
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movsd 0x349e8(%rip), %xmm0    # 0x6e028
xorps %xmm1, %xmm1
callq 0x14330
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x39750
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: Eigen::internal::gemm_functor<std::complex<double>, long, Eigen::internal::general_matrix_matrix_product<long, std::complex<double>, 1, true, std::complex<double>, 0, false, 0>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2> const>, Eigen::Matrix<std::complex<double>, -1, 2, 0, -1, 2>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>, Eigen::internal::gemm_blocking_space<0, std::complex<double>, std::complex<double>, 2, 2, -1, 1, false>>::operator()(long, long, long, long, Eigen::internal::GemmParallelInfo<long>*) const
void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
  {
    if(cols==-1)
      cols = m_rhs.cols();

    Gemm::run(rows, cols, m_lhs.cols(),
              &m_lhs.coeffRef(row,0), m_lhs.outerStride(),
              &m_rhs.coeffRef(0,col), m_rhs.outerStride(),
              (Scalar*)&(m_dest.coeffRef(row,col)), m_dest.outerStride(),
              m_actualAlpha, m_blocking, info);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $-0x1, -0x38(%rbp)
jne 0x3ea06
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x164a0
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq (%rax), %rdi
callq 0x39140
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x78(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3f5e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq (%rax), %rdi
callq 0x3f620
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3f650
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rdi
callq 0x166d0
movq %rax, %r14
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3f6c0
movq %rax, %rbx
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3a4a0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
movq -0x60(%rbp), %r9
movq %rax, %r11
movq -0x58(%rbp), %rax
movq 0x18(%rax), %r10
movq %r10, -0x50(%rbp)
movq 0x20(%rax), %r10
movq %r10, -0x48(%rbp)
movq 0x28(%rax), %r10
movq -0x40(%rbp), %rax
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x3eb20
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::gebp_traits<std::complex<double>, std::complex<double>, true, false>::broadcastRhs(std::complex<double> const*, Eigen::internal::DoublePacket<double vector[2]>&, Eigen::internal::DoublePacket<double vector[2]>&, Eigen::internal::DoublePacket<double vector[2]>&, Eigen::internal::DoublePacket<double vector[2]>&)
EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsPacket& b2, RhsPacket& b3)
  {
    // FIXME not sure that's the best way to implement it!
    loadRhs(b+0, b0);
    loadRhs(b+1, b1);
    loadRhs(b+2, b2);
    loadRhs(b+3, b3);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x42b90
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %rdx
callq 0x42b90
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x28(%rbp), %rdx
callq 0x42b90
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
movq -0x30(%rbp), %rdx
callq 0x42b90
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::gebp_traits<std::complex<double>, std::complex<double>, true, false>::acc(Eigen::internal::DoublePacket<double vector[2]> const&, Eigen::internal::Packet1cd const&, Eigen::internal::Packet1cd&) const
EIGEN_STRONG_INLINE void acc(const DoublePacketType& c, const ResPacket& alpha, ResPacket& r) const
  {
    // assemble c
    ResPacket tmp;
    if((!ConjLhs)&&(!ConjRhs))
    {
      tmp = pcplxflip(pconj(ResPacket(c.second)));
      tmp = padd(ResPacket(c.first),tmp);
    }
    else if((!ConjLhs)&&(ConjRhs))
    {
      tmp = pconj(pcplxflip(ResPacket(c.second)));
      tmp = padd(ResPacket(c.first),tmp);
    }
    else if((ConjLhs)&&(!ConjRhs))
    {
      tmp = pcplxflip(ResPacket(c.second));
      tmp = padd(pconj(ResPacket(c.first)),tmp);
    }
    else if((ConjLhs)&&(ConjRhs))
    {
      tmp = pcplxflip(ResPacket(c.second));
      tmp = psub(pconj(ResPacket(c.first)),tmp);
    }
    
    r = pmadd(tmp,alpha,r);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35d80
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdi
callq 0x15370
leaq -0x50(%rbp), %rdi
callq 0x42d30
movapd %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x15370
leaq -0x80(%rbp), %rdi
callq 0x2b080
movapd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2dbd0
movapd %xmm0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x42d70
movapd %xmm0, -0x90(%rbp)
movq -0x20(%rbp), %rax
movq -0x90(%rbp), %rcx
movq %rcx, (%rax)
movq -0x88(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::PlainObjectBase<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::KroneckerProduct<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>>(Eigen::ReturnByValue<Eigen::KroneckerProduct<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>> const&)
EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& other)
    {
      _check_template_params();
      // FIXME this does not automatically transpose vectors if necessary
      resize(other.rows(), other.cols());
      other.evalTo(this->derived());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0xfb80
movq -0x30(%rbp), %rdi
callq 0xfba0
callq 0xfb50
movq -0x10(%rbp), %rdi
callq 0x43160
movq %rax, -0x28(%rbp)
jmp 0x430f1
movq -0x10(%rbp), %rdi
callq 0x43180
movq %rax, -0x40(%rbp)
jmp 0x43100
movq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x14af0
jmp 0x43113
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x145a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x431a0
jmp 0x43132
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xfbe0
movq -0x18(%rbp), %rdi
callq 0x9dc0
nopw %cs:(%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/KroneckerProduct/KroneckerTensorProduct.h
// Function: void Eigen::KroneckerProduct<Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2>>::evalTo<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&) const
void KroneckerProduct<Lhs,Rhs>::evalTo(Dest& dst) const
{
  const int BlockRows = Rhs::RowsAtCompileTime,
            BlockCols = Rhs::ColsAtCompileTime;
  const Index Br = m_B.rows(),
              Bc = m_B.cols();
  for (Index i=0; i < m_A.rows(); ++i)
    for (Index j=0; j < m_A.cols(); ++j)
      Block<Dest,BlockRows,BlockCols>(dst,i*Br,j*Bc,Br,Bc) = m_A.coeff(i,j) * m_B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x2, -0x14(%rbp)
movl $0x2, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x39560
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x39580
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0xa0(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq (%rax), %rdi
callq 0x39560
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jge 0x433b2
movq $0x0, -0x38(%rbp)
movq -0xa0(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movq (%rax), %rdi
callq 0x39580
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jge 0x4339f
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x43460
movq %rax, %rsi
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x68(%rbp), %rdi
callq 0x433c0
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
imulq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
imulq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x98(%rbp), %rdi
callq 0x434c0
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x43600
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x432fd
jmp 0x433a1
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x432c8
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 2, 2, false>>, Eigen::internal::evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<std::complex<double>, std::complex<double>>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2> const> const, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2> const>>, Eigen::internal::assign_op<std::complex<double>, std::complex<double>>, 0>, 4, 1>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 2, 2, false>>, Eigen::internal::evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<std::complex<double>, std::complex<double>>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2> const> const, Eigen::Matrix<std::complex<double>, 2, 2, 0, 2, 2> const>>, Eigen::internal::assign_op<std::complex<double>, std::complex<double>>, 0>&)
void run(Kernel &kernel)
  {
    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
    typedef typename Kernel::PacketType PacketType;

    enum { size = DstXprType::InnerSizeAtCompileTime,
           packetSize =unpacket_traits<PacketType>::size,
           vectorizableSize = (size/packetSize)*packetSize };

    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
    {
      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, size>::run(kernel, outer);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44760
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jge 0x44089
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x44780
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x447c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x44044
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Pyboon[P]sage/./Eigen/src/LU/InverseImpl.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, Eigen::Inverse<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<std::complex<double>, std::complex<double>>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&, Eigen::Inverse<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>> const&, Eigen::internal::assign_op<std::complex<double>, std::complex<double>> const&)
static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename XprType::Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);
    
    const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime);
    EIGEN_ONLY_USED_FOR_DEBUG(Size);
    eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst)))
              && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");

    typedef typename internal::nested_eval<XprType,XprType::ColsAtCompileTime>::type  ActualXprType;
    typedef typename internal::remove_all<ActualXprType>::type                        ActualXprTypeCleanded;
    
    ActualXprType actual_xpr(src.nestedExpression());
    
    compute_inverse<ActualXprTypeCleanded, DstXprType>::run(actual_xpr, dst);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44f10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45120
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13af0
cmpq -0x20(%rbp), %rax
jne 0x47a2c
movq -0x8(%rbp), %rdi
callq 0x13b10
cmpq -0x28(%rbp), %rax
je 0x47a3d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x14af0
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x47a70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47a90
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Pyboon[P]sage/./Eigen/src/LU/PartialPivLU.h
// Function: Eigen::PartialPivLU<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>::compute()
void PartialPivLU<MatrixType>::compute()
{
  check_template_parameters();

  // the row permutation is stored as int indices, so just to be sure:
  eigen_assert(m_lu.rows()<NumTraits<int>::highest());

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

  eigen_assert(m_lu.rows() == m_lu.cols() && "PartialPivLU is only for square (and moreover invertible) matrices");
  const Index size = m_lu.rows();

  m_rowsTranspositions.resize(size);

  typename TranspositionType::StorageIndex nb_transpositions;
  internal::partial_lu_inplace(m_lu, m_rowsTranspositions, nb_transpositions);
  m_det_p = (nb_transpositions%2) ? -1 : 1;

  m_p = m_rowsTranspositions;

  m_isInitialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x48210
movq -0x68(%rbp), %rdi
callq 0x13af0
movq %rax, -0x60(%rbp)
callq 0x48220
movl %eax, %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x480ee
jmp 0x4810d
leaq 0x31913(%rip), %rdi     # 0x79a08
leaq 0x31932(%rip), %rsi     # 0x79a2e
movl $0x208, %edx            # imm = 0x208
leaq 0x31944(%rip), %rcx     # 0x79a4c
callq 0x94c0
movq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x48230
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x48280
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x482c0
leaq -0x28(%rbp), %rdi
callq 0x48310
movq -0x68(%rbp), %rdi
movsd %xmm0, 0x38(%rdi)
callq 0x13af0
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x13b10
movq -0x78(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x69(%rbp)
jne 0x48170
movb $0x1, %al
movb %al, -0x69(%rbp)
jmp 0x48170
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x48179
jmp 0x4817b
jmp 0x4819a
leaq 0x31999(%rip), %rdi     # 0x79b1b
leaq 0x318a5(%rip), %rsi     # 0x79a2e
movl $0x20c, %edx            # imm = 0x20C
leaq 0x318b7(%rip), %rcx     # 0x79a4c
callq 0x94c0
movq -0x68(%rbp), %rdi
callq 0x13af0
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x28, %rdi
movq -0x50(%rbp), %rsi
callq 0x48350
movq -0x68(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
leaq -0x54(%rbp), %rdx
callq 0x48380
movq -0x68(%rbp), %rdi
movl -0x54(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, 0x40(%rdi)
movq %rdi, %rsi
addq $0x28, %rsi
addq $0x18, %rdi
callq 0x484a0
movq -0x68(%rbp), %rax
movb $0x1, 0x41(%rax)
addq $0x80, %rsp
popq %rbp
retq
nop
// File: Pyboon[P]sage/./Eigen/src/LU/PartialPivLU.h
// Function: void Eigen::internal::partial_lu_inplace<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, Eigen::Transpositions<-1, -1, int>>(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>&, Eigen::Transpositions<-1, -1, int>&, Eigen::Transpositions<-1, -1, int>::StorageIndex&)
void partial_lu_inplace(MatrixType& lu, TranspositionType& row_transpositions, typename TranspositionType::StorageIndex& nb_transpositions)
{
  eigen_assert(lu.cols() == row_transpositions.size());
  eigen_assert((&row_transpositions.coeffRef(1)-&row_transpositions.coeffRef(0)) == 1);

  partial_lu_impl
    <typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::StorageIndex>
    ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13b10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49bc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x483b8
jmp 0x483d7
leaq 0x32215(%rip), %rdi     # 0x7a5d4
leaq 0x31668(%rip), %rsi     # 0x79a2e
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x32229(%rip), %rcx     # 0x7a5fb
callq 0x94c0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x49bf0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49bf0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq $0x1, %rax
jne 0x4840c
jmp 0x4842b
leaq 0x322ce(%rip), %rdi     # 0x7a6e1
leaq 0x31614(%rip), %rsi     # 0x79a2e
movl $0x1f9, %edx            # imm = 0x1F9
leaq 0x321d5(%rip), %rcx     # 0x7a5fb
callq 0x94c0
movq -0x8(%rbp), %rdi
callq 0x13af0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13b10
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4a1c0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14fa0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49bf0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rax, %r8
movq -0x18(%rbp), %r9
movq $0x100, (%rsp)          # imm = 0x100
callq 0x49c20
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: Pyboon[P]sage/./Eigen/src/Core/SolveTriangular.h
// Function: void Eigen::TriangularViewImpl<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>, 5u, Eigen::Dense>::solveInPlace<1, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>>(Eigen::MatrixBase<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>, -1, -1, false>, -1, -1, false>> const&) const
void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
{
  OtherDerived& other = _other.const_cast_derived();
  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));

  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
  typedef typename internal::conditional<copy,
    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
  OtherCopy otherCopy(other);

  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
    Side, Mode>::run(derived().nestedExpression(), otherCopy);

  if (copy)
    other = otherCopy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x519e0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x519f0
movq %rax, %rdi
callq 0x51a00
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x519f0
movq %rax, %rdi
callq 0x51a20
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jne 0x51988
movq -0x38(%rbp), %rdi
callq 0x519f0
movq %rax, %rdi
callq 0x51a00
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4ed30
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
je 0x51982
xorl %eax, %eax
movb %al, -0x39(%rbp)
jmp 0x51982
movb -0x39(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x51991
jmp 0x51993
jmp 0x519b2
leaq 0x2bb9b(%rip), %rdi     # 0x7d535
leaq 0x2bc2e(%rip), %rsi     # 0x7d5cf
movl $0xaa, %edx
leaq 0x2bc45(%rip), %rcx     # 0x7d5f2
callq 0x94c0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x519f0
movq %rax, %rdi
callq 0x51b80
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x51a40
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)