LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/mvector.cpp
// Function: MVectStat::print(Msa&)
void
MVectStat :: print(Msa & msa)
{
	/* Print the output */
	ofstream file(Options::Get().output_fname.c_str());
	if (!file.is_open()){
	  cerr << "Cannot open file " << Options::Get().output_fname << "\n";
		exit(0);
	}
	int K = (int) sm_alphabet.size();
	file.precision(3);
	file << setw(10) << " ";
	for (int a(0); a < K; ++a) {
		file.precision(3);
		file << setw(10) << sm_alphabet[a];
	}
	file << "\n";
	for (int col(0); col < (int) means.size(); col++) {
		file.precision(3);
		file << setw(10) << col + 1;
  	for (int a(0); a < K; ++a) {
			file.precision(3);	
			file << setw(10) << means[col][a];
		}
		file << "\n";
	}
	file.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x4a00
movq 0xa8(%rax), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x42a0
leaq 0x78(%rsp), %rdi
callq 0x4080
testb %al, %al
je 0xaa42
movq 0x10(%rbx), %r13
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0xa, 0x18(%rsp,%rax)
leaq 0x2c81(%rip), %rsi      # 0xd591
callq 0x4250
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
leaq 0x8(%rsp), %r14
cmpq %r15, %r13
je 0xa95e
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0xa, 0x18(%rsp,%rax)
movq 0x8(%rbx), %rax
movsbl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x42b0
incq %r15
jmp 0xa924
leaq 0x2b91(%rip), %rsi      # 0xd4f6
leaq 0x8(%rsp), %rdi
callq 0x4250
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r12
jge 0xaa1c
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0xa, 0x18(%rsp,%rax)
leaq 0x1(%r12), %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x4420
imulq $0x18, %r12, %r12
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0xaa05
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x3, 0x10(%rsp,%rcx)
movq -0x18(%rax), %rax
movq $0xa, 0x18(%rsp,%rax)
movq 0x28(%rbx), %rax
movq (%rax,%r12), %rax
movss (%rax,%rbp,4), %xmm0
movq %r14, %rdi
callq 0x41e0
incq %rbp
jmp 0xa9c7
movq %r14, %rdi
leaq 0x2ae7(%rip), %rsi      # 0xd4f6
callq 0x4250
movq %r15, %r12
jmp 0xa977
leaq 0x8(%rsp), %rdi
callq 0x4360
leaq 0x8(%rsp), %rdi
callq 0x4380
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x859f(%rip), %rdi      # 0x12fe8
leaq 0x25d0(%rip), %rsi      # 0xd020
callq 0x4250
movq %rax, %rbx
callq 0x4a00
addq $0xa8, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4240
leaq 0x2a81(%rip), %rsi      # 0xd4f6
movq %rax, %rdi
callq 0x4250
xorl %edi, %edi
callq 0x42d0
jmp 0xaa8c
jmp 0xaa8c
jmp 0xaa8c
jmp 0xaa8c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4380
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::~ScoringMatrix()
ScoringMatrix :: ~ScoringMatrix()
{
	if (is_set){
		for (int i(0); i < (int) alphabet.size(); ++i){
			free(matrix[i]);
		}
		free(matrix);
		for (int i(0); i < (int) alphabet.size(); ++i){
			free(norm_matrix[i]);
		}
		free(norm_matrix);
	}
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x793a(%rip), %rax      # 0x12ce8
movq %rax, (%rdi)
cmpb $0x1, 0x30(%rdi)
jne 0xb3fd
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
movq 0x28(%rbx), %rdi
cmpq %rax, %r14
jge 0xb3d5
movq (%rdi,%r14,8), %rdi
callq 0x42c0
incq %r14
jmp 0xb3ba
callq 0x42c0
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
movq 0x38(%rbx), %rdi
cmpq %rax, %r14
jge 0xb3f8
movq (%rdi,%r14,8), %rdi
callq 0x42c0
incq %r14
jmp 0xb3dd
callq 0x42c0
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4110
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/scoring_matrix.cpp
// Function: ScoringMatrix::index(char)
int 
ScoringMatrix :: index(char aa)
{
	int pos = (int) alphabet.find(aa);
	if (pos >= (int) alphabet.size()){
		cerr << "Symbol " << aa << " is not in alphabet\n";
		exit(0);
	} 
	return pos;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x8, %rdi
xorl %edx, %edx
callq 0x4340
cmpl 0x10(%r14), %eax
jge 0xb448
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x7b99(%rip), %rdi      # 0x12fe8
leaq 0x23fa(%rip), %rsi      # 0xd850
callq 0x4250
movsbl %bl, %esi
movq %rax, %rdi
callq 0x42b0
leaq 0x23eb(%rip), %rsi      # 0xd858
movq %rax, %rdi
callq 0x4250
xorl %edi, %edi
callq 0x42d0
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/statistic.cpp
// Function: AddAllStatistics()
void AddAllStatistics()
{
	StatisticFactory::Add<WEntStat>  ("wentropy");
	StatisticFactory::Add<TridStat>  ("trident");
	StatisticFactory::Add<MVectStat> ("mvector");
	StatisticFactory::Add<JensenStat>("jensen");
	StatisticFactory::Add<KabatStat> ("kabat");
	StatisticFactory::Add<GapStat>   ("gap");
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x1da9(%rip), %rsi      # 0xd26d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb5ee
leaq 0x10(%rsp), %rdi
callq 0x4110
leaq 0x238f(%rip), %rsi      # 0xd87d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb60e
leaq 0x10(%rsp), %rdi
callq 0x4110
leaq 0x236d(%rip), %rsi      # 0xd885
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb62e
leaq 0x10(%rsp), %rdi
callq 0x4110
leaq 0x234b(%rip), %rsi      # 0xd88d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb64e
leaq 0x10(%rsp), %rdi
callq 0x4110
leaq 0x2328(%rip), %rsi      # 0xd894
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb66e
leaq 0x10(%rsp), %rdi
callq 0x4110
leaq 0x2304(%rip), %rsi      # 0xd89a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x79bc
leaq 0x10(%rsp), %rdi
callq 0xb68e
leaq 0x10(%rsp), %rdi
callq 0x4110
addq $0x30, %rsp
popq %rbx
retq
jmp 0xb5d3
jmp 0xb5e2
jmp 0xb5d3
jmp 0xb5e2
jmp 0xb5d3
jmp 0xb5e2
jmp 0xb5d3
jmp 0xb5e2
jmp 0xb5d3
jmp 0xb5e2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4110
jmp 0xb5e5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/gcollet[P]MstatX/src/trident.cpp
// Function: TridStat::normVect(std::vector<float, std::allocator<float>>)
float
TridStat :: normVect(vector<float> vect){
	float score= 0.0;
	for(int i(0); i < (int) vect.size(); ++i){
		score += vect[i] * vect[i];
	}
	return sqrt(score);
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorps %xmm0, %xmm0
cmpq %rdx, %rcx
je 0xbc4d
movss (%rax,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
incq %rdx
jmp 0xbc36
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4460
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/test_mpi_sage.cpp
// Function: ParseFileNum(std::vector<int, std::allocator<int>>)
vector<pair<int, int> > ParseFileNum(vector<int> spots){
    int cycle_start = 1;
    int cycle_end = 197;
    int interval = 4;
    int spots_size = spots.size();
    vector<pair<int, int> > result;
    for(int i_spot = 0; i_spot < spots_size; ++i_spot){
        for(int i_cycle = cycle_start; i_cycle<=cycle_end; i_cycle += interval){
            // 此处将所有spot和cycle拼接在一起，然后均分给多个MPI计算
            result.push_back(make_pair(spots[i_spot], i_cycle));
        }
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x2, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %eax
movq %rax, 0x8(%rsp)
movabsq $0x400000000, %rbp      # imm = 0x400000000
cmpq 0x8(%rsp), %r13
je 0x36b6
movabsq $0x100000000, %r12      # imm = 0x100000000
pushq $0x1
popq %r15
cmpq $0xc6, %r15
jae 0x36b1
movq (%r14), %rax
movl (%rax,%r13,4), %eax
addq %r12, %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4052
addq $0x4, %r15
addq %rbp, %r12
jmp 0x3683
incq %r13
jmp 0x366e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x401e
movq %r14, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movl %r8d, %r15d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x35f97(%rip), %rax     # 0x39cb8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x3e46
leaq 0x138(%rbx), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x138(%rbx)
andq $0x0, 0x148(%rbx)
movl %r15d, 0x158(%rbx)
movl %r12d, 0x15c(%rbx)
leaq 0x160(%rbx), %r12
leaq 0x68(%rbx), %r15
movl $0xd8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x3150
movq %r15, %rdi
movq %r14, %rsi
callq 0x3140
leaq 0x20(%rbx), %rdi
movq %rbp, %rsi
callq 0x3140
leaq 0x48(%rbx), %rdi
movq %r13, %rsi
callq 0x3140
movl $0x2, 0x238(%rbx)
movaps 0x18270(%rip), %xmm0    # 0x1c020
movups %xmm0, 0x240(%rbx)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x260(%rbx)
movaps 0x18261(%rip), %xmm0    # 0x1c030
movups %xmm0, 0x250(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
leaq 0x1c0(%rbx), %rdi
leaq 0x1a8(%rbx), %r14
leaq 0x190(%rbx), %r15
addq $0x178, %rbx            # imm = 0x178
callq 0x3e7a
movq %r14, %rdi
callq 0x3ebe
movq %r15, %rdi
callq 0x3ebe
movq %rbx, %rdi
callq 0x3ebe
movq %r12, %rdi
callq 0x3ebe
movq 0x8(%rsp), %rdi
callq 0x3f0e
movq 0x10(%rsp), %rdi
callq 0x3ee0
movq %r13, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x1c(%rdi), %rsi
movslq 0xa0(%rdi), %rax
movslq 0x10(%rdi), %rdx
imulq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5440
leaq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x5732
movq 0x35cac(%rip), %rdi     # 0x39fc8
leaq 0x17e8d(%rip), %rsi     # 0x1c1b0
callq 0x3250
movq 0x140(%rbx), %rsi
movq %rax, %rdi
callq 0x3240
leaq 0x17e81(%rip), %rsi     # 0x1c1bf
movq %rax, %rdi
callq 0x3250
movq 0x148(%rbx), %rsi
movq %rax, %rdi
callq 0x3240
movq %rax, %rdi
callq 0x3110
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
callq 0x3380
movq %rsp, %r15
movq %r15, %rdi
callq 0x5684
movq (%r15), %rdx
movq (%rbx), %rcx
leaq 0x16e19(%rip), %rdi     # 0x1c2d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3030
movq %r15, %rdi
callq 0x3100
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3230
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x31c0
leaq 0x16c39(%rip), %rdx     # 0x1c2e2
leaq 0x10(%rsp), %r14
pushq $0x40
popq %rsi
movq %r14, %rdi
movq %rax, %rcx
callq 0x31f0
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b5e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x58f2
movq %rsi, %r12
movq (%r15), %rdi
callq 0x32c0
testq %r12, %r12
je 0x58ed
movq %r12, %rdi
callq 0x5933
jmp 0x58ef
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3320
movq %rax, %rbx
cmpq $0x10, %r14
setae %al
testb $0xf, %bl
setne %cl
testb %cl, %al
jne 0x599a
testq %rbx, %rbx
sete %al
testq %r14, %r14
setne %cl
testb %al, %cl
je 0x598f
callq 0x5906
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x16f42(%rip), %rdi     # 0x1c8e3
leaq 0x16ff5(%rip), %rsi     # 0x1c99d
leaq 0x1700d(%rip), %rcx     # 0x1c9bc
movl $0xa1, %edx
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rax, %rax
cmpq %rsi, %rax
je 0x5ccc
movq %rsi, %r15
movq (%r14), %rdi
callq 0x32c0
testq %r15, %r15
je 0x5cc7
movq %r15, %rdi
callq 0x5933
jmp 0x5cc9
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/isi_sage.cpp
// Function: IsiSage::InitTau(Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, int)
RowVectorXcd IsiSage::InitTau(const complex_mat data, const int iL){
    Util::log("init tau...");
    // go through all CIR find tau index with max power 
    int min_tau = 1;
    int max_tau = config.sample_codes;
    int step = config.delay_step;
    int tau_size = (max_tau-min_tau)/step + 1;
    VectorXd tau_power_sum(tau_size);
    tau_power_sum.setZero(tau_size);
    for(int i_tau = 0; i_tau < tau_size; ++i_tau){
        tau_power_sum(i_tau) = data.row(i_tau*step).norm();
    }
    // get index of max tau_power_sum
    int max_index = 0;
    tau_power_sum.maxCoeff(&max_index);
    result.tau(iL) = min_tau + max_index * step;
    //return tau_power
    return data.row(max_index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x16dca(%rip), %rsi     # 0x1d767
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x3b5e
movq %rbx, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x547e
leaq 0x40(%rsp), %rdi
callq 0x3100
movl 0x1c(%r15), %eax
movq %r15, 0x28(%rsp)
movslq 0x130(%r15), %r15
decl %eax
cltd
idivl %r15d
incl %eax
leaq 0x14(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xaade
movslq (%rbx), %rsi
movq %r12, %rdi
callq 0xab0e
xorl %r12d, %r12d
leaq 0x60(%rsp), %r13
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
movslq 0x14(%rsp), %rax
cmpq %rax, %rbx
jge 0x6a51
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xbc6c
movq %r13, %rdi
callq 0xab32
movsd %xmm0, 0x38(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x564e
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %rbx
addq %r15, %r12
jmp 0x6a0e
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0xab3e
movl 0xc(%rsp), %ebx
movq 0x28(%rsp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movslq 0x10(%rsp), %rsi
callq 0x5618
imull %r15d, %ebx
incl %ebx
movl %ebx, (%rax)
movslq 0xc(%rsp), %rdx
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0xbc6c
movq 0x30(%rsp), %rbx
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0xbf14
movq 0x18(%rsp), %rdi
callq 0x32c0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ae2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3100
jmp 0x6aef
movq %rax, %rbx
jmp 0x6aef
jmp 0x6ae2
jmp 0x6ae2
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x6404
movq %rbx, %rdi
callq 0x899e
leaq 0x48(%rbx), %rsi
leaq 0x13030(%rip), %rdx     # 0x1d8df
leaq 0x60(%rsp), %rdi
callq 0x3b99
movl 0x150(%rbx), %esi
leaq 0x40(%rsp), %rdi
callq 0xaa69
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xb225
leaq 0x12ffd(%rip), %rdx     # 0x1d8e4
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x545f
movl 0x154(%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0xaa69
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xb225
leaq 0x20(%rsp), %rdi
callq 0x3100
leaq 0xa0(%rsp), %rdi
callq 0x3100
leaq 0x80(%rsp), %rdi
callq 0x3100
leaq 0x40(%rsp), %rdi
callq 0x3100
leaq 0x60(%rsp), %rdi
callq 0x3100
movq %rsp, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x3330
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa55a
movq %rsp, %rdi
callq 0x3100
leaq 0xc0(%rsp), %rdi
callq 0x3100
addq $0xe0, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3100
jmp 0xa9a7
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0xa9fb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3100
jmp 0xa9c3
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x3100
jmp 0xa9d5
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x3100
jmp 0xa9e7
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3100
jmp 0xa9f6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O2/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::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>, 1, -1, 1, 1, -1> const> const, Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1> const> 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:
subq $0x58, %rsp
movq 0x40(%rdi), %rcx
cmpq $0x0, 0x8(%rcx)
jle 0xd2b7
movups 0x20(%rdi), %xmm0
movq %rsp, %rax
movups %xmm0, 0x18(%rax)
movq 0x30(%rdi), %rdx
movq (%rdx), %rdx
movq %rdx, 0x30(%rax)
movq (%rcx), %rcx
movq %rcx, 0x40(%rax)
movq %rdi, 0x50(%rax)
movq %rax, %rdi
callq 0xd2d6
addq $0x58, %rsp
retq
leaq 0x114b7(%rip), %rdi     # 0x1e775
leaq 0x114f4(%rip), %rsi     # 0x1e7b9
leaq 0x1411f(%rip), %rcx     # 0x213eb
movl $0x19d, %edx            # imm = 0x19D
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/CoreEvaluators.h
// Function: Eigen::internal::visitor_impl<Eigen::internal::max_coeff_visitor<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::visitor_evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, -1>::run(Eigen::internal::visitor_evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::internal::max_coeff_visitor<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
  CoeffReturnType coeff(Index row, Index col) const
  {
    if (IsRowMajor)
      return m_data[row * m_outerStride.value() + col];
    else
      return m_data[row + col * m_outerStride.value()];
  }

// Assembly:
movq (%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsi)
xorpd %xmm1, %xmm1
movupd %xmm1, (%rsi)
movq 0x10(%rdi), %rdx
movq 0x8(%rdx), %rcx
pushq $0x1
popq %r8
cmpq %rcx, %r8
jge 0xd517
movsd (%rax,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd512
movsd %xmm1, 0x10(%rsi)
movq %r8, (%rsi)
andq $0x0, 0x8(%rsi)
movapd %xmm1, %xmm0
incq %r8
jmp 0xd4f0
movq 0x10(%rdx), %rdx
xorl %r8d, %r8d
testq %rcx, %rcx
cmovleq %r8, %rcx
pushq $0x1
popq %r8
pushq $0x8
popq %r9
cmpq %rdx, %r8
jge 0xd56f
movq 0x8(%rdi), %r10
imulq %r9, %r10
addq %rax, %r10
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0xd566
movsd (%r10,%r11,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd561
movsd %xmm1, 0x10(%rsi)
movq %r11, (%rsi)
movq %r8, 0x8(%rsi)
movapd %xmm1, %xmm0
incq %r11
jmp 0xd540
incq %r8
addq $0x8, %r9
jmp 0xd52d
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0xc020
movq %rsi, %r15
movq (%r14), %rdi
callq 0x32c0
testq %r15, %r15
je 0xc01b
movq %r15, %rdi
callq 0x5933
jmp 0xc01d
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/Visitor.h
// Function: void Eigen::DenseBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::visit<Eigen::internal::max_coeff_visitor<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>(Eigen::internal::max_coeff_visitor<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&) const
EIGEN_DEVICE_FUNC
void DenseBase<Derived>::visit(Visitor& visitor) const
{
  typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
  ThisEvaluator thisEval(derived());
  
  enum {
    unroll =  SizeAtCompileTime != Dynamic
           && SizeAtCompileTime * ThisEvaluator::CoeffReadCost + (SizeAtCompileTime-1) * internal::functor_traits<Visitor>::Cost <= EIGEN_UNROLLING_LIMIT
  };
  return internal::visitor_impl<Visitor, ThisEvaluator, unroll ? int(SizeAtCompileTime) : Dynamic>::run(thisEval, visitor);
}

// Assembly:
subq $0x18, %rsp
movq (%rdi), %rcx
movq %rsp, %rax
movq %rcx, (%rax)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rdi, 0x10(%rax)
movq %rax, %rdi
callq 0xd4d0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/ProductEvaluators.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>, Eigen::Product<Eigen::PermutationMatrix<-1, -1, int>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, 2>, 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::Product<Eigen::PermutationMatrix<-1, -1, int>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<std::complex<double>>, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, 2> 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x10(%rbx), %rdx
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jne 0x17c69
cmpq %rdx, 0x10(%r14)
je 0x17c77
movq %r14, %rdi
movq %rax, %rsi
callq 0x583c
movq (%rbx), %rsi
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17c8e
nop
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::gemv_dense_selector<1, 0, true>::run<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>, Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>>(Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const> const> const&, Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1> const&, Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>&, Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>::Scalar const&)
static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
  {
    Transpose<Dest> destT(dest);
    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
    gemv_dense_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
      ::run(rhs.transpose(), lhs.transpose(), destT, alpha);
  }

// Assembly:
subq $0x28, %rsp
leaq 0x10(%rsp), %rax
movq %rdx, (%rax)
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq (%rdi), %rdi
leaq 0x18(%rsp), %rsi
movq %rdi, (%rsi)
movq %rdx, %rdi
movq %rax, %rdx
callq 0xdb9c
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rax
decq %rax
cmpq $0xe, %rax
ja 0xee92
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xeec0
movq %r15, %rdi
callq 0xeef0
movsd 0xe536(%rip), %xmm0     # 0x1d3d8
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xef08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>, 0, false, std::complex<double>, 0, false, 0>, 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::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::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::internal::gemm_blocking_space<0, std::complex<double>, std::complex<double>, -1, -1, -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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r10
movq %r8, %r14
movq %rcx, %rax
movq %rdx, %rbx
movq %rdi, %r11
movq 0x8(%rdi), %rdi
cmpq $-0x1, %r8
jne 0x1743e
movq 0x10(%rdi), %r14
shlq $0x4, %rsi
movq (%r11), %r8
movq 0x10(%r11), %r12
movq (%r8), %rcx
addq %rsi, %rcx
movq 0x10(%r8), %rdx
movq 0x78(%rdi), %r15
movq %r15, %r9
imulq %rax, %r9
shlq $0x4, %r9
addq (%rdi), %r9
movq 0x78(%r12), %r13
imulq %r13, %rax
shlq $0x4, %rax
addq (%r12), %rax
movq 0x78(%r8), %r8
addq %rsi, %rax
movsd 0x18(%r11), %xmm0
movsd 0x20(%r11), %xmm1
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
pushq %r10
pushq 0x28(%r11)
pushq %r13
pushq %rax
pushq %r15
callq 0x174b2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
xorl %eax, %eax
cmpq $0x2, %rax
je 0x1179f
movq %rax, (%rsp)
leaq (%rax,%rax), %rbp
movq %r15, 0x8(%rsp)
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x1178d
movq (%r14), %rsi
addq %r15, %rsi
movq 0x8(%r14), %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x117ae
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movq %rbx, %rcx
pushq $0x2
popq %r8
movq %r8, %r9
callq 0x117f4
movq %r13, %rdi
movq %r12, %rsi
callq 0x119ba
addq $0x2, %rbx
addq $0x20, %r15
jmp 0x1173c
movq (%rsp), %rax
incq %rax
movq 0x8(%rsp), %r15
addq $0x10, %r15
jmp 0x11727
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/CoreEvaluators.h
// Function: Eigen::internal::etor_product_packet_impl<0, 1, Eigen::internal::evaluator<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::Matrix<std::complex<double>, 4, 1, 0, 4, 1>>, Eigen::internal::Packet1cd, 0>::run(long, long, Eigen::internal::evaluator<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1>> const&, Eigen::internal::evaluator<Eigen::Matrix<std::complex<double>, 4, 1, 0, 4, 1>> const&, long, Eigen::internal::Packet1cd&)
EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    if (IsRowMajor)
      return ploadt<PacketType, LoadMode>(m_data + row * m_outerStride.value() + col);
    else
      return ploadt<PacketType, LoadMode>(m_data + row + col * m_outerStride.value());
  }

// Assembly:
movq (%rdx), %rax
shlq $0x4, %rdi
movq (%rcx), %rcx
movupd (%rcx), %xmm0
movupd (%rax,%rdi), %xmm1
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
mulpd %xmm0, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
shufpd $0x1, %xmm0, %xmm0      # xmm0 = xmm0[1,0]
mulpd %xmm1, %xmm0
xorpd 0x3cc8(%rip), %xmm0     # 0x1d460
addpd %xmm2, %xmm0
movapd %xmm0, (%r9)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, 0x8(%rbx)
jne 0x12137
cmpq %rdx, 0x10(%rbx)
je 0x12142
movq %rbx, %rdi
callq 0x583c
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12152
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x7fffffff, 0x8(%rdi)  # imm = 0x7FFFFFFF
jge 0x12402
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, 0x8(%rdi)
callq 0x12440
movsd %xmm0, 0x38(%rbx)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x12421
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x1235e
movq %rsp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1244d
movb (%r15), %al
andb $0x1, %al
negb %al
orb $0x1, %al
movb %al, 0x40(%rbx)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1790a
movb $0x1, 0x41(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12b5c(%rip), %rdi     # 0x24f65
leaq 0x12b7b(%rip), %rsi     # 0x24f8b
leaq 0x12b92(%rip), %rcx     # 0x24fa9
movl $0x208, %edx            # imm = 0x208
callq 0x31a0
leaq 0x12c0d(%rip), %rdi     # 0x25035
leaq 0x12b5c(%rip), %rsi     # 0x24f8b
leaq 0x12b73(%rip), %rcx     # 0x24fa9
movl $0x20c, %edx            # imm = 0x20C
callq 0x31a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq %rsi, %rax
movq 0x10(%rdi), %rsi
cmpq 0x8(%rax), %rsi
jne 0x1247a
movq %rdx, %r9
movq (%rax), %r8
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq $0x100, (%rsp)          # imm = 0x100
movq %rcx, %rdi
callq 0x12726
popq %rax
retq
leaq 0x1366d(%rip), %rdi     # 0x25aee
leaq 0x12b03(%rip), %rsi     # 0x24f8b
leaq 0x13686(%rip), %rcx     # 0x25b15
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x31a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/Visitor.h
// Function: Eigen::internal::visitor_impl<Eigen::internal::max_coeff_visitor<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<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, true>, -1, 1, false> const>>, Eigen::internal::visitor_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<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, true>, -1, 1, false> const>>, -1>::run(Eigen::internal::visitor_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<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, true>, -1, 1, false> const>> const&, Eigen::internal::max_coeff_visitor<Eigen::CwiseUnaryOp<Eigen::internal::scalar_score_coeff_op<std::complex<double>>, Eigen::Block<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, true>, -1, 1, false> const>>&)
EIGEN_DEVICE_FUNC
  static inline void run(const Derived& mat, Visitor& visitor)
  {
    visitor.init(mat.coeff(0,0), 0, 0);
    for(Index i = 1; i < mat.rows(); ++i)
      visitor(mat.coeff(i, 0), i, 0);
    for(Index j = 1; j < mat.cols(); ++j)
      for(Index i = 0; i < mat.rows(); ++i)
        visitor(mat.coeff(i, j), i, j);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x126d6
movsd %xmm0, 0x10(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
pushq $0x1
popq %r15
movq 0x20(%r14), %rax
cmpq 0x8(%rax), %r15
jge 0x134c7
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x134ce
ucomisd 0x10(%rbx), %xmm0
jbe 0x134c2
movsd %xmm0, 0x10(%rbx)
movq %r15, (%rbx)
andq $0x0, 0x8(%rbx)
incq %r15
jmp 0x13497
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/arch/SSE/Complex.h
// Function: Eigen::internal::Packet1cd Eigen::internal::pdiv<Eigen::internal::Packet1cd>(Eigen::internal::Packet1cd const&, Eigen::internal::Packet1cd 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:
movapd (%rdi), %xmm1
movapd %xmm1, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
movapd (%rsi), %xmm3
mulpd %xmm3, %xmm2
xorpd 0x9b50(%rip), %xmm2     # 0x1d450
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movapd %xmm3, %xmm0
shufpd $0x1, %xmm3, %xmm0      # xmm0 = xmm0[1],xmm3[0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
mulpd %xmm3, %xmm3
movapd %xmm3, %xmm1
shufpd $0x1, %xmm3, %xmm1      # xmm1 = xmm1[1],xmm3[0]
addpd %xmm3, %xmm1
divpd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Pyboon[P]sage/./Eigen/src/Core/PermutationMatrix.h
// Function: Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&)
Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
    {
      setIdentity(tr.size());
      for(Index k=size()-1; k>=0; --k)
        applyTranspositionOnTheRight(k,tr.coeff(k));
      return derived();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x17948
movq 0x8(%rbx), %r15
testq %r15, %r15
jle 0x1793f
movq (%r14), %rax
movslq -0x4(%rax,%r15,4), %rdx
decq %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1795a
jmp 0x17922
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/eliebe-5[P]Catmull-clark-subdivision/main.cc
// Function: main
int main(int argc, char * argv[])
{
    if(argc < 3)
        printf("ERROR: Not enough arguments.\n");
    else
    {
        Mesh m;

        m.generateHalfEdge(argv[1]);

        int count = atoi(argv[2]);

        auto s1 = std::chrono::high_resolution_clock::now();
        for(int i = 0; i < count; i++)
        {
            auto t1 = std::chrono::high_resolution_clock::now();
            m.subdivide();
            auto t2 = std::chrono::high_resolution_clock::now();
            double duration = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count() * 0.000000001;
            printf("Subdiv number %d took: %f seconds\n", i + 1, duration);
        }
        auto s2 = std::chrono::high_resolution_clock::now();
        double duration = (double)std::chrono::duration_cast<std::chrono::nanoseconds>(s2 - s1).count() * 0.000000001;
        printf("All subdivs took: %f seconds\n", duration);
        
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpl $0x2, %edi
jg 0x23f0
leaq 0x2c6b(%rip), %rdi      # 0x5051
callq 0x2200
jmp 0x24a2
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x24cc
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x250a
movq 0x10(%rbx), %rdi
callq 0x2210
movl %eax, %ebp
callq 0x2060
movq %rax, (%rsp)
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
negl %ebx
pushq $0x1
popq %r14
leaq 0x8(%rsp), %r15
leaq 0x2bd7(%rip), %r12      # 0x5010
leal (%rbx,%r14), %ebp
callq 0x2060
movq %rax, %r13
cmpl $0x1, %ebp
je 0x2479
movq %r15, %rdi
callq 0x33c0
callq 0x2060
subq %r13, %rax
cvtsi2sd %rax, %xmm0
mulsd 0x2ba1(%rip), %xmm0     # 0x5008
movq %r12, %rdi
movl %r14d, %esi
movb $0x1, %al
callq 0x2050
incl %r14d
jmp 0x2439
subq (%rsp), %r13
cvtsi2sd %r13, %xmm0
mulsd 0x2b7e(%rip), %xmm0     # 0x5008
leaq 0x2ba2(%rip), %rdi      # 0x5033
movb $0x1, %al
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x24e8
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24b5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x24e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/eliebe-5[P]Catmull-clark-subdivision/halfedge.cc
// Function: Mesh::facePoint(HEFace*)
HEVert* Mesh::facePoint(HEFace *face)
{

    if(face->avg != nullptr)
        return face->avg;

    HEVert *fp = vertPool.new_element();
    
    HEEdge* temp = face->edge->next;

    fp->pos = v3(0, 0, 0);
    
    while(true)
    {

        fp->pos = fp->pos + temp->vert->pos;

        if(temp == face->edge)
            break;
        temp = temp->next;
    }

    fp->pos = fp->pos * 0.25f;
    
    face->avg = fp;
    return face->avg;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3000
retq
pushq %rbx
movq %rsi, %rbx
addq $0x20, %rdi
callq 0x39fe
movq (%rbx), %rcx
movq 0x18(%rcx), %rdx
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
movaps %xmm1, %xmm2
movq (%rdx), %rsi
movsd (%rsi), %xmm1
addss 0x8(%rsi), %xmm0
addps %xmm2, %xmm1
movlps %xmm1, (%rax)
movss %xmm0, 0x8(%rax)
cmpq %rcx, %rdx
je 0x3047
movq 0x18(%rdx), %rdx
jmp 0x3022
mulps 0x2032(%rip), %xmm1     # 0x5080
mulss 0x204a(%rip), %xmm0     # 0x50a0
movlps %xmm1, (%rax)
movss %xmm0, 0x8(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
retq