LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/datafile.cpp
// Function: DataFile::print()
void DataFile::print(){
	std::cout << "====================================" << std::endl;
	std::cout << "n = " << this->n << std::endl;
	
	std::cout << "A :" << std::endl;
	for(size_t i=0;i<this->n;i++){
		for(size_t j=0;j<this->n;j++){
			std::cout << this->flow[i][j] << " ";
		}
		std::cout << std::endl;
	}
	std::cout << "B :" << std::endl;
	for(size_t i=0;i<this->n;i++){
		for(size_t j=0;j<this->n;j++){
			std::cout << this->distance[i][j] << " ";
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8801(%rip), %r14      # 0xafd8
leaq 0x587a(%rip), %rsi      # 0x8058
movl $0x24, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x5864(%rip), %rsi      # 0x807d
movl $0x4, %edx
movq %r14, %rdi
callq 0x21b0
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x581f(%rip), %rsi      # 0x8082
movl $0x3, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
cmpq $0x0, 0x30(%rbx)
je 0x2909
xorl %r12d, %r12d
leaq 0x57d8(%rip), %r15      # 0x8080
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
callq 0x2270
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
incq %rbp
cmpq 0x30(%rbx), %rbp
jb 0x28ae
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incq %r12
cmpq 0x30(%rbx), %r12
jb 0x28a8
leaq 0x5776(%rip), %rsi      # 0x8086
movl $0x3, %edx
movq %r14, %rdi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
cmpq $0x0, 0x30(%rbx)
je 0x29b7
xorl %r12d, %r12d
leaq 0x572b(%rip), %r15      # 0x8080
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %esi
movq %r14, %rdi
callq 0x2270
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
incq %rbp
cmpq 0x30(%rbx), %rbp
jb 0x295b
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incq %r12
cmpq 0x30(%rbx), %r12
jb 0x2955
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/objectivefunction.cpp
// Function: ObjectiveFunction::eval(Solution const&) const
int ObjectiveFunction::eval(const Solution& s) const{
	int fitness = 0;
	/*Function to minimize*/
	for(size_t i=0;i<data.n;i++){
		for(size_t j=0;j<data.n;j++){
			/*There is a flow between two locations i and j, but also there is a distance between facilities p(i) and p(j)*/
			fitness += data.flow[i][j]*data.distance[s[i]][s[j]];
		}
	}

	return fitness;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r13
cmpq $0x0, 0x30(%r13)
je 0x3be5
movq %rsi, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
xorl %ebp, %ebp
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movq (%r13), %rax
movq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax,%r12,4), %r15d
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x373c
cltq
movq 0x18(%r13), %r13
leaq (%rax,%rax,2), %r14
movq %rbx, %rdi
movl %r12d, %esi
callq 0x373c
movq 0x10(%rsp), %rdi
cltq
movq (%r13,%r14,8), %rcx
imull (%rcx,%rax,4), %r15d
addl %r15d, %ebp
incq %r12
movq (%rdi), %r13
movq 0x30(%r13), %rax
cmpq %rax, %r12
jb 0x3b7b
movq 0x8(%rsp), %rdx
incq %rdx
movq %rdx, 0x8(%rsp)
cmpq %rax, %rdx
jb 0x3b6a
jmp 0x3be7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/localsearch.cpp
// Function: LocalSearch::all_pair_changes(Solution)
Solution LocalSearch::all_pair_changes(Solution s){

	for(size_t t=0;t<data.n;t++){
		for(size_t u=t+1;u<data.n;u++){
			int f = of.eval_pair_change(s, t, u);

			if(f < s.fitness()){
				int temp = s[t];
				s[t] = s[u];
				s[u] = temp;
				s.set_fitness(f);
			}
		}
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x4b86
movq %rsi, %r14
xorl %r12d, %r12d
movq %rsi, 0x10(%rsp)
leaq 0x1(%r12), %rcx
movq %rcx, (%rsp)
cmpq %rax, %rcx
jae 0x4b79
movq (%rsp), %r13
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x3bf8
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3746
cmpl %eax, %ebp
jge 0x4b6a
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3730
movl (%rax), %r14d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3730
movl (%rax), %r15d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3730
movl %r15d, (%rax)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3730
movl %r14d, (%rax)
movq 0x10(%rsp), %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x374a
incq %r13
movq (%r14), %rax
movq 0x30(%rax), %rax
cmpq %rax, %r13
jb 0x4b03
movq (%rsp), %r12
cmpq %rax, %r12
jb 0x4af1
movups (%rbx), %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/localsearch.cpp
// Function: LocalSearch::perturbation(Solution&, int, std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&)
void LocalSearch::perturbation(Solution& s, int u, std::default_random_engine& generator){
	std::uniform_int_distribution<int> rand_place(0,data.n-1);
	int p = 0;
	
	while(p < u){
		p++;
		/*Pick two locations randomly*/
		int t = rand_place(generator);
		int v = rand_place(generator);	
		while(v == t)
			v = rand_place(generator);	

		/*Evaluate the exchange*/
		int f = of.eval_pair_change(s, t, v);
		/*Exhcange points (wheter it is better or not)*/
		s.set_fitness(f);
		int temp = s[t];
		s[t] = s[v];
		s[v] = temp;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rdi), %rax
movl 0x30(%rax), %eax
decl %eax
movl $0x0, 0x10(%rsp)
movl %eax, 0x14(%rsp)
movl %edx, 0x4(%rsp)
testl %edx, %edx
jle 0x4eff
movq %rcx, %rbx
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq 0x20(%rsp), %r15
movq %r12, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4638
movl %eax, %r13d
movq %r12, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4638
cmpl %r13d, %eax
je 0x4e78
incl %ebp
movl %ebp, 0xc(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rdi
movslq %r13d, %rdx
movslq %eax, %rbp
movq %r15, %rsi
movq %rbp, %rcx
callq 0x3bf8
movq %r15, %rdi
movl %eax, %esi
callq 0x374a
movq %r15, %rdi
movl %r13d, %esi
callq 0x3730
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x3730
movl (%rax), %r14d
movq %r15, %rdi
movl %r13d, %esi
callq 0x3730
movl %r14d, (%rax)
movq %r15, %rdi
movl %ebp, %esi
movl 0xc(%rsp), %ebp
callq 0x3730
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
cmpl 0x4(%rsp), %ebp
jne 0x4e67
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/geneticalgorithm.cpp
// Function: GeneticAlgorithm::tournament(std::vector<Solution, std::allocator<Solution>> const&, unsigned long, int&)
Solution GeneticAlgorithm::tournament(const std::vector<Solution>& population, size_t k, int& except){
	/*Selects a random individual from the population that is not the except one*/
	std::uniform_int_distribution<int> rand_pop(0, pop_size-1);
	int r = rand_pop(generator);

	while(r == except) r = rand_pop(generator);
	
	Solution selected = population[r];
	except = r;
	
	/*Runs the tournament k-1 times and selects the best from this tournament*/
	for(size_t i=1;i<k;i++){
		r = rand_pop(generator);
		while(r == except) r = rand_pop(generator);
		if(population[r] < selected){
			selected = population[r];
			except = r;
		}
	}

	/*Returns the best permutation*/
	return selected;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
movl 0x10(%rsi), %eax
decl %eax
leaq 0x20(%rsp), %rdi
movl $0x0, (%rdi)
movl %eax, 0x4(%rdi)
subq $-0x80, %r13
movq %r13, %rsi
movq %rdi, %rdx
callq 0x4638
cmpl (%r14), %eax
jne 0x5c28
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4638
cmpl (%r14), %eax
je 0x5c15
movslq %eax, %rbx
movq 0x10(%rsp), %rax
movq (%rax), %r15
movq %rbx, %r12
shlq $0x5, %r12
leaq (%r15,%r12), %rsi
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x2f74
movl 0x18(%r15,%r12), %eax
movl %eax, 0x18(%rbp)
movl %ebx, (%r14)
cmpq $0x2, 0x18(%rsp)
jb 0x5ce7
movl $0x1, %ebx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4638
movl %eax, %r15d
movq 0x8(%rsp), %r12
cmpl (%r14), %r15d
jne 0x5c9a
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4638
movl %eax, %r15d
jmp 0x5c82
movq %r12, %rsi
movslq %r15d, %r12
shlq $0x5, %r12
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq %r12, %rdi
callq 0x374e
testb %al, %al
je 0x5cdd
movq 0x10(%rsp), %rax
addq (%rax), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2e1e
movl 0x18(%r12), %eax
movq 0x8(%rsp), %rcx
movl %eax, 0x18(%rcx)
movl %r15d, (%r14)
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x5c6c
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %r12
jmp 0x5d08
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x5d1e
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/cssartori[P]ga-qap/src/geneticalgorithm.cpp
// Function: GeneticAlgorithm::shift_mutation(Solution&, unsigned long)
void GeneticAlgorithm::shift_mutation(Solution& s, size_t u){
	std::vector<int> p1(u);
	std::vector<int> p2(data.n-u);

	for(size_t i=0;i<data.n;i++){
		if(i<u) p1[i] = s[i];
		else p2[i-u] = s[i];
	}

	for(size_t i=0;i<data.n;i++){
		if(i < (data.n-u)) s[i] = p2[i];
		else s[i] = p1[i-(data.n-u)];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x676e
movq (%r15), %rax
movq 0x30(%rax), %rsi
subq %rbx, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x676e
movq (%r15), %rax
cmpq $0x0, 0x30(%rax)
je 0x6552
leaq (,%rbx,4), %r13
movq %r13, %rbp
negq %rbp
xorl %r12d, %r12d
cmpq %rbx, %r12
jae 0x64d2
movq %r14, %rdi
movl %r12d, %esi
callq 0x3730
movl (%rax), %eax
movq 0x20(%rsp), %rcx
jmp 0x64e7
movq %r14, %rdi
movl %r12d, %esi
callq 0x3730
movl (%rax), %eax
movq 0x8(%rsp), %rcx
addq %rbp, %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
movq (%r15), %rax
movq 0x30(%rax), %rax
cmpq %rax, %r12
jb 0x64b9
testq %rax, %rax
je 0x6552
xorl %r12d, %r12d
movq %rax, %rcx
subq %rbx, %rcx
cmpq %rcx, %r12
jae 0x6523
movq 0x8(%rsp), %rax
movl (%rax,%r12,4), %ebp
movq %r14, %rdi
movl %r12d, %esi
callq 0x3730
jmp 0x6541
movq 0x20(%rsp), %rcx
shlq $0x2, %rax
subq %rax, %rcx
addq %r13, %rcx
movl (%rcx,%r12,4), %ebp
movq %r14, %rdi
movl %r12d, %esi
callq 0x3730
movl %ebp, (%rax)
incq %r12
movq (%r15), %rax
movq 0x30(%rax), %rax
cmpq %rax, %r12
jb 0x6502
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6569
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6580
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x65b0
jmp 0x6596
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x65b0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x65c7
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/Vanuan[P]pocketbook_free_swupdate/main.cpp
// Function: main
int main(int argc, char ** argv)
{
  if(argc != 3) {
    cout << "Usage:" << argv[0] << " SWUPDATE.BIN_filename output_dir" << endl;
    return -1;
  }
  PocketBookUpdate update(argv[1]);
  update.print();
  update.extract(argv[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x2530
movq 0x8(%r14), %rsi
leaq -0xa8(%rbp), %rbx
movq %rbx, %rdi
callq 0x268a
movq %rbx, %rdi
callq 0x317a
movq 0x10(%r14), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2c3e
leaq -0xa8(%rbp), %rdi
callq 0x2bdc
xorl %eax, %eax
jmp 0x25c6
movq 0x3aa1(%rip), %rbx      # 0x5fd8
leaq 0x1ac6(%rip), %rsi      # 0x4004
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2230
movq (%r14), %r14
testq %r14, %r14
je 0x256f
movq %r14, %rdi
callq 0x20f0
movq 0x3a76(%rip), %rdi      # 0x5fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2230
jmp 0x2586
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2330
leaq 0x1a7e(%rip), %rsi      # 0x400b
movl $0x21, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2bdc
movq %rbx, %rdi
callq 0x2350
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Vanuan[P]pocketbook_free_swupdate/PocketBookUpdate.cpp
// Function: PocketBookUpdate::printField(unsigned int, unsigned int, char const*)
int PocketBookUpdate::printField(unsigned offset, unsigned size, const char* name)
{
  cout.width(10);
  cout << showbase << hex;
  cout << offset << " ";
  cout.width(10);
  cout << offset+size << "\t\t" << name << ":\t\t";
  cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq 0x2f19(%rip), %rbx      # 0x5fd8
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xa, %r12d
movq %r12, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rcx
orl $0x200, 0x18(%rbx,%rcx) # imm = 0x200
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
callq 0x22b0
leaq 0xfe4(%rip), %rsi       # 0x40e2
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%rbx,%rax)
addl %r15d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22b0
leaq 0xf60(%rip), %rsi       # 0x4086
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0xf45(%rip), %rsi       # 0x4085
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::queryX2Y(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) const
bool Bijection<TypeX,TypeY>::
	queryX2Y(const TypeX& input, TypeY& result)const
{
	if(X2YMap.find(input)!=X2YMap.end())
	{
		result=X2YMap.find(input)->second;
		return true;
	}
	else
	{
		return false;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x6a72
movq %rax, %r15
leaq 0x8(%r12), %r13
cmpq %r13, %rax
je 0x6a62
movq %r12, %rdi
movq %r14, %rsi
callq 0x6a72
movl 0x40(%rax), %eax
movl %eax, (%rbx)
cmpq %r13, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&)
bool Bijection<TypeX,TypeY>::
	add(const TypeX& X, const TypeY& Y)
{
	if(!containX(X)&&!containY(Y))
	{
		X2YMap[X]=Y;
		Y2XMap[Y]=X;
		return true;
		
	}
	else return false;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x6a72
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0xb614
xorl %eax, %eax
jmp 0xb671
movq 0x40(%r15), %rax
movl (%r14), %ebp
testq %rax, %rax
je 0xb648
leaq 0x38(%r15), %rdx
movq %rdx, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rax)
setl %sil
cmovgeq %rax, %rcx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0xb627
cmpq %rdx, %rcx
je 0xb648
cmpl 0x20(%rcx), %ebp
jge 0xb610
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb866
movl %ebp, (%rax)
addq $0x30, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb8e2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3150
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::clone(Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>&) const
void Bijection<TypeX,TypeY>::
clone(Bijection<TypeX,TypeY>& sun)const
{
	typename map<TypeX,TypeY>::const_iterator iter;
	iter=X2YMap.begin();
	for(;iter!=X2YMap.end();iter++)
	{
		sun.add(iter->first,iter->second);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x142d8
movq %rsi, %rbx
leaq 0x20(%r15), %rsi
leaq 0x40(%r15), %rdx
movq %rbx, %rdi
callq 0xb5f2
movq %r15, %rdi
callq 0x3360
movq %rax, %r15
cmpq %r14, %rax
jne 0x142b8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/bob-hash.cpp
// Function: hashword(unsigned int const*, unsigned long, unsigned int)
uint32_t hashword(
const uint32_t *k,                   /* the key, an array of uint32_t values */
size_t          length,               /* the length of the key, in uint32_ts */
uint32_t        initval)         /* the previous hash, or an arbitrary value */
{
  uint32_t a,b,c;

  /* Set up the internal state */
  a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;

  /*------------------------------------------------- handle most of the key */
  while (length > 3)
  {
    a += k[0];
    b += k[1];
    c += k[2];
    mix(a,b,c);
    length -= 3;
    k += 3;
  }

  /*------------------------------------------- handle the last 3 uint32_t's */
  switch(length)                     /* all the case statements fall through */
  { 
  case 3 : c+=k[2];
  case 2 : b+=k[1];
  case 1 : a+=k[0];
    final(a,b,c);
  case 0:     /* case 0: nothing left to add */
    break;
  }
  /*------------------------------------------------------ report the result */
  return c;
}

// Assembly:
leal (%rdx,%rsi,4), %eax
addl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
cmpq $0x4, %rsi
jb 0x18422
movl %eax, %ecx
movl %eax, %edx
addl (%rdi), %edx
addl 0x4(%rdi), %ecx
addl 0x8(%rdi), %eax
movl %eax, %r8d
roll $0x4, %r8d
subl %eax, %edx
xorl %edx, %r8d
addl %ecx, %eax
subl %r8d, %ecx
movl %r8d, %r9d
roll $0x6, %r9d
xorl %ecx, %r9d
addl %eax, %r8d
movl %r9d, %r10d
roll $0x8, %r10d
subl %r9d, %eax
xorl %eax, %r10d
addl %r8d, %r9d
subl %r10d, %r8d
movl %r10d, %edx
roll $0x10, %edx
xorl %r8d, %edx
addl %r9d, %r10d
movl %edx, %ecx
roll $0x13, %ecx
subl %edx, %r9d
xorl %r9d, %ecx
addl %r10d, %edx
subl %ecx, %r10d
movl %ecx, %eax
roll $0x4, %eax
xorl %r10d, %eax
addl %edx, %ecx
addq $-0x3, %rsi
addq $0xc, %rdi
cmpq $0x3, %rsi
ja 0x183b2
jmp 0x18426
movl %eax, %edx
movl %eax, %ecx
leaq 0x27d83(%rip), %r8      # 0x401b0
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
addl 0x8(%rdi), %eax
addl 0x4(%rdi), %ecx
addl (%rdi), %edx
xorl %ecx, %eax
movl %ecx, %esi
roll $0xe, %esi
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0xb, %esi
subl %esi, %edx
movl %edx, %esi
roll $0x19, %esi
xorl %edx, %ecx
subl %esi, %ecx
xorl %ecx, %eax
movl %ecx, %esi
roll $0x10, %esi
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0x4, %esi
subl %esi, %edx
xorl %edx, %ecx
roll $0xe, %edx
subl %edx, %ecx
xorl %ecx, %eax
roll $0x18, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Forest-Berkeley.cpp
// Function: genNewNode_byLabel_berkeley(BerkeleyRuleSet const&, Node&, Node&, Node&, DecodeType)
Node& genNewNode_byLabel_berkeley(const BerkeleyRuleSet& ruleSet,Node& n1, Node& n2, Node& n3 , DecodeType decodetype)
{
	double score=1.0;
	clock_t sec=clock();

	for(Node::iterator n1iter=n1.begin();n1iter!=n1.end();n1iter++)
	{
		for(Node::iterator n2iter=n2.begin();n2iter!=n2.end();n2iter++)
		{
			Label& label1=n1iter->second;
			Label& label2=n2iter->second;
			genNewNode_byLabel_berkeley(ruleSet,label1,label2,n3,decodetype);
		}
	}
	if(!n3.useAllowState())
	{
		/*
		vector<vector<double> > prob;
		prob.clear();
		prob.reserve(100);
		for(int i=0;i<100;i++)
		{
			vector<double> temp;
			temp.clear();
			temp.reserve(100);
			prob.push_back(temp);
			for(int j=0;j<100;j++)
				prob[i].push_back(0);
		}
		*/
		double ** prob = (double**)malloc(sizeof(double*)*100);
		double *pool=(double*)malloc(sizeof(double)*100*100);
		for(int i=0;i<100;i++)
			//prob[i]=(double*)malloc(sizeof(double)*100);
			prob[i]=pool+i*100;
		for(int i=0;i<100;i++)
		{	
			for(int j=0;j<100;j++)
			{
				for(int k=0;k<100;k++)
				{
					prob[j][k]=0.9*0.9*.09;
					score=1.0*900*100;
				}
			}
		}
	}
	if(!n3.useAllowState())
		inbitime+=clock()-sec;
	return n3;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r13
callq 0x31c0
movq %rax, 0x18(%rsp)
movq 0x18(%r14), %rax
addq $0x8, %r14
movq %r14, 0x20(%rsp)
movq %rax, 0x8(%rsp)
cmpq %r14, %rax
je 0x1ee7a
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r14
movq 0x10(%rsp), %rax
movq 0x18(%rax), %r15
cmpq %r14, %r15
je 0x1ee64
movq 0x8(%rsp), %rax
leaq 0x40(%rax), %r12
leaq 0x40(%r15), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x1edbb
movq %r15, %rdi
callq 0x31f0
movq %rax, %r15
cmpq %r14, %rax
jne 0x1ee3f
movq 0x8(%rsp), %rdi
callq 0x31f0
movq %rax, 0x8(%rsp)
cmpq 0x20(%rsp), %rax
jne 0x1ee28
cmpb $0x0, 0x90(%rbx)
jne 0x1eef2
movl $0x320, %edi            # imm = 0x320
callq 0x33c0
movq %rax, %r15
movl $0x13880, %edi          # imm = 0x13880
callq 0x33c0
xorl %ecx, %ecx
movq %rax, (%r15,%rcx,8)
incq %rcx
addq $0x320, %rax            # imm = 0x320
cmpq $0x64, %rcx
jne 0x1ee9c
xorl %eax, %eax
movaps 0x214c8(%rip), %xmm0    # 0x40380
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
xorl %esi, %esi
movups %xmm0, (%rdx,%rsi,8)
addq $0x2, %rsi
cmpq $0x64, %rsi
jne 0x1eec0
incq %rcx
cmpq $0x64, %rcx
jne 0x1eeba
incl %eax
cmpl $0x64, %eax
jne 0x1eeb8
callq 0x31c0
subq 0x18(%rsp), %rax
leaq 0x36479(%rip), %rcx     # 0x55368
addq %rax, (%rcx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::UniqueHeap()
UniqueHeap(){
		dataSet.clear();
		vector<_type> tempVec;
		tempVec=data;
		data.clear();
		for(size_t i=0;i<tempVec.size();i++)
		{
			if(dataSet.count(tempVec[i])==0)
			{
				data.push_back(tempVec[i]);
				dataSet.insert(tempVec[i]);
			}
		}
        make_heap(data.begin(), data.end());
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %r15
movl $0x0, 0x20(%rdi)
movq %r12, 0x28(%rdi)
movq %r15, 0x30(%rdi)
movq %r15, 0x38(%rdi)
movq %r12, 0x40(%rdi)
movups %xmm0, 0x58(%rdi)
movq %r12, 0x68(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x48(%rdi)
movq $-0x1, 0x50(%rdi)
movq %r14, %rdi
callq 0x20720
leaq 0x10(%rsp), %rdi
movq %r12, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq %rbx, %rsi
callq 0x20524
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x21172
movq 0x10(%rsp), %rsi
cmpq %rsi, 0x18(%rsp)
je 0x20457
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
xorl %ebp, %ebp
addq %r12, %rsi
movq %r14, %rdi
callq 0x20a14
cmpq %r15, %rax
jne 0x20436
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x206e6
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x20cc8
incq %rbp
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x28, %r12
cmpq %rax, %rbp
jb 0x20406
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xf(%rsp), %rdx
callq 0x20e54
leaq 0x10(%rsp), %rdi
callq 0x1cf34
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20483
movq %rax, %r15
leaq 0x58(%rbx), %r12
leaq 0x10(%rsp), %rdi
callq 0x1cf34
movq (%r12), %rdi
testq %rdi, %rdi
je 0x204a9
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %r14, %rdi
callq 0x1cf88
movq %rbx, %rdi
callq 0x1cf34
movq %r15, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::clear()
bool clear(){
        data.clear();
        make_heap(data.begin(), data.end());
		dataSet.clear();
		return true;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
callq 0x21172
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xf(%rsp), %rdx
callq 0x20e54
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x20720
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/ScoreInfo.h
// Function: ScoreInfo::operator<(ScoreInfo const&) const
bool operator < (const ScoreInfo& si)const
	{
/*		if(_score==si.score()&&!((*this)==si))
		{
			cout<<"compare:"<<endl;
			print(cout);
			si.print(cout);
		}
*/		if(_score<si.score())
		{
			//cout<<"<"<<endl;
			return true;
		}
		else if(_score>si.score())
			return false;
		else if(_childPairID<si.childPairID())
		{
			return true;
		}
		else if(_childPairID>si.childPairID())
			return false;
		else if(_posInChs<si.posInChs())
		{
			return true;
		}
		else return false;
	}

// Assembly:
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
ja 0x20a90
ucomisd %xmm1, %xmm0
jbe 0x20a91
xorl %eax, %eax
retq
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x20a90
ja 0x20a8e
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rdi
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq %rdi, %r8
subq %rdx, %r8
movq %rcx, %r9
subq %rax, %r9
leaq (%rdx,%r9), %rsi
cmpq %r8, %r9
cmovgeq %rdi, %rsi
cmpq %rdx, %rsi
je 0x20ae3
movl (%rdx), %edi
movl (%rax), %r8d
cmpl %edi, %r8d
jne 0x20aea
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rsi, %rdx
jne 0x20acc
cmpq %rcx, %rax
setne %al
retq
setg %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::pop()
_type pop(){
        _type ret;
		if(empty())
		{
			return nullData;
		}
		else
		{
			ret = top();
			dataSet.erase(ret);
			pop_heap(data.begin(), data.end());
			data.pop_back();
			return ret;
		}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rsp)
movq $-0x1, 0x8(%rsp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x2fa88
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x30198
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm1, 0x10(%rsi)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsi)
leaq 0x18(%r14), %r15
movq %r15, %rdi
callq 0x301d8
movq %r15, %rdi
movq %rax, %rsi
callq 0x3029a
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %r15, %rcx
cmpq $0x29, %rcx
jl 0x2fa50
leaq -0x28(%rax), %rcx
movups -0x28(%rax), %xmm0
leaq 0x30(%rsp), %r12
movaps %xmm0, (%r12)
leaq -0x18(%rax), %rdi
movq -0x8(%rax), %rbp
leaq 0x10(%r15), %rsi
subq %r15, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %r13
movups -0x18(%rax), %xmm0
movaps %xmm0, 0x60(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rax)
movq $0x0, -0x8(%rax)
movups (%r15), %xmm0
movups %xmm0, -0x28(%rax)
callq 0x2113a
movaps 0x60(%rsp), %xmm0
movaps %xmm0, 0x10(%r12)
movq %rbp, 0x20(%r12)
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x20f27
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2fa4c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq 0x8(%r14), %rax
leaq -0x28(%rax), %rcx
movq %rcx, 0x8(%r14)
movq -0x18(%rax), %rdi
testq %rdi, %rdi
je 0x2fa6d
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x32e0
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%rbx)
jmp 0x2faa0
movups 0x48(%r14), %xmm0
movups %xmm0, (%rbx)
leaq 0x10(%rbx), %rdi
addq $0x58, %r14
movq %r14, %rsi
callq 0x9310
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2fad3
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
jmp 0x2fad3
jmp 0x2fad0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2faea
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::push(ScoreInfo)
void push(_type entry){
		if(dataSet.count(entry)==0)
		{
			data.push_back(entry);
			push_heap(data.begin(), data.end());
			dataSet.insert(entry);
		}
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x20a14
leaq 0x20(%r15), %rcx
cmpq %rcx, %rax
jne 0x2fb9d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x206e6
movq (%r15), %rdi
movq 0x8(%r15), %rax
movups -0x28(%rax), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq -0x8(%rax), %rdx
movups -0x18(%rax), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, -0x18(%rax)
movq $0x0, -0x8(%rax)
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
decq %rsi
movaps %xmm0, 0x10(%rcx)
movq %rdx, 0x20(%rcx)
leaq 0xf(%rsp), %r8
xorl %edx, %edx
callq 0x2108b
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2fb92
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20cc8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2fbc1
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/ScoreInfo.h
// Function: IntArray::shoulders(std::vector<IntArray, std::allocator<IntArray>>&) const
vector<IntArray>& shoulders(vector<IntArray>& m_ia)const
	{
		m_ia.clear();
		for(size_t i=0;i<size();i++)
		{
			m_ia.push_back((*this));
			m_ia[i][i]++;
		}
		return m_ia;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq %rbx, %rdi
callq 0x2fe48
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x2fce5
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fe1c
movq (%rbx), %rax
movq (%rax,%r15), %rax
incl (%rax,%r12,4)
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r12
sarq $0x2, %rax
addq $0x18, %r15
cmpq %rax, %r12
jb 0x2fcb8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::top()
_type top(){
		if(empty())
			return nullData;
		else
			return *(data.begin());
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x301bb
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
addq $0x10, %rax
movq %rax, %rsi
jmp 0x301cd
movups 0x48(%rsi), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
addq $0x58, %rsi
callq 0x9310
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Main.cpp
// Function: string2oft(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ObjectFunctionType string2oft(string str)
{
	if(str=="variational")
		return VARIATIONAL;
	else if(str=="max_rule_sum")
		return MAX_RULE_SUM;
	else if(str=="max_rule_product")
		return MAX_RULE_PRODUCT;
	else if(str=="max_prob")
		return MAX_PROB;
	else if(str=="viterbi")
		return NONE;
	return MAX_RULE_PRODUCT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10022(%rip), %rsi     # 0x40c33
callq 0x30c0
testl %eax, %eax
je 0x30c6e
leaq 0x1001e(%rip), %rsi     # 0x40c3f
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x30c72
leaq 0xfb21(%rip), %rsi      # 0x40755
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x30c79
leaq 0x10005(%rip), %rsi     # 0x40c4c
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x30c80
leaq 0xfffb(%rip), %rsi      # 0x40c55
movq %rbx, %rdi
callq 0x30c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
adcl $0x2, %eax
jmp 0x30c85
xorl %eax, %eax
jmp 0x30c85
movl $0x1, %eax
jmp 0x30c85
movl $0x2, %eax
jmp 0x30c85
movl $0x4, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Node.cpp
// Function: Node::reset_scorePool_initLevel(int)
void 
Node::reset_scorePool_initLevel(int numOfState)
{
	_allowState.clear();
	_iScore.clear();
	_oScore.clear();
	_iScore.reserve(numOfState);
	_oScore.reserve(numOfState);
	for(int i=0;i<numOfState;i++)
	{
		_iScore.push_back(-1E10);
		_oScore.push_back(-1E10);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x100(%rdi), %rax
cmpq %rax, 0x108(%rdi)
je 0x37295
movq %rax, 0x108(%r14)
movq 0xd0(%r14), %rax
cmpq %rax, 0xd8(%r14)
je 0x372ac
movq %rax, 0xd8(%r14)
leaq 0xd0(%r14), %r15
leaq 0xe8(%r14), %r12
movq 0xe8(%r14), %rax
cmpq %rax, 0xf0(%r14)
je 0x372d1
movq %rax, 0xf0(%r14)
movslq %ebx, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0xf2d4
movq %r12, %rdi
movq %r13, %rsi
callq 0xf2d4
testl %r13d, %r13d
jle 0x3735e
movabsq $-0x3dfd5fa0e0000000, %rbp # imm = 0xC202A05F20000000
movq %rsp, %r13
movq %rbp, (%rsp)
movq 0xd8(%r14), %rsi
cmpq 0xe0(%r14), %rsi
je 0x37320
movq %rbp, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xd8(%r14)
jmp 0x3732b
movq %r15, %rdi
movq %r13, %rdx
callq 0xf936
movq %rbp, (%rsp)
movq 0xf0(%r14), %rsi
cmpq 0xf8(%r14), %rsi
je 0x3734f
movq %rbp, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xf0(%r14)
jmp 0x3735a
movq %r12, %rdi
movq %r13, %rdx
callq 0xf936
decl %ebx
jne 0x372fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/Tree.cpp
// Function: getUPennTerm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string getUPennTerm(string& str)
{
	string result;
	size_t pos=0;
	
	result=str;
	pos=str.find("_");
	if(pos!=string::npos)
		result=str.substr(0,pos);
	
	pos=str.find("^g");
	if(pos!=string::npos)
	{
		result=str.substr(0,pos);
	}
	pos=result.find("u*");
	if(pos!=string::npos)
	{
		result=result.substr(pos+2);
	}
	return result;
	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x3150
leaq 0x1207(%rip), %rsi      # 0x401ab
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3eff5
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3300
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3380
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3eff5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
leaq 0x1ed7(%rip), %rsi      # 0x40ed3
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3f04d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3300
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3380
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f04d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
leaq 0x1346(%rip), %rsi      # 0x4039a
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3f0ae
addq $0x2, %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x3300
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3380
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3f0ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3f0c3
jmp 0x3f0c3
jmp 0x3f0c3
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3f0da
movq (%r12), %rsi
incq %rsi
callq 0x32e0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/utils.cpp
// Function: intToString[abi:cxx11](int)
string
intToString(int i)
{
  stringstream ss;
  ss<<i;
  string ans;
  ss>>ans;
  return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3200
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x3500
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x33a0
movq 0x15321(%rip), %rsi     # 0x54fa8
movq %rsp, %rdi
callq 0x3230
leaq 0x80(%rsp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3fcc8
movq (%r15), %rsi
incq %rsi
callq 0x32e0
jmp 0x3fcc8
movq %rax, %r14
movq 0x152d9(%rip), %rsi     # 0x54fa8
movq %rsp, %rdi
callq 0x3230
leaq 0x80(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/neubig[P]egret/Egret/src/utils.cpp
// Function: doubleToString[abi:cxx11](double)
string doubleToString(double i)
{
  stringstream ss;
  ss.precision(20);
  if(i==0)
	  return "0.0";
  ss<<i;
  string ans;
  ss>>ans;
  return ans;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3200
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x14, 0x10(%rsp,%rax)
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3fd4d
jp 0x3fd4d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x119a(%rip), %rsi      # 0x40ed6
leaq 0x1196(%rip), %rdx      # 0x40ed9
movq %rbx, %rdi
callq 0xb7d0
jmp 0x3fd7b
movapd %xmm1, %xmm0
leaq 0x18(%rsp), %rdi
callq 0x34a0
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x33a0
movq 0x15226(%rip), %rsi     # 0x54fa8
leaq 0x8(%rsp), %rdi
callq 0x3230
leaq 0x88(%rsp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3fdc6
movq (%r15), %rsi
incq %rsi
callq 0x32e0
jmp 0x3fdc6
jmp 0x3fdc3
movq %rax, %r14
movq 0x151db(%rip), %rsi     # 0x54fa8
leaq 0x8(%rsp), %rdi
callq 0x3230
leaq 0x88(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTreeNode::insert(SecondaryBTreeDataMap&)
int SecondaryBTreeNode::insert(SecondaryBTreeDataMap& key)
{ // [TROCAR]

    int i;

    for (i = count; i >= 1; i--) {
        if (key > keys[i - 1]) {
            keys[i] = key;
            break;
        } else {
            keys[i] = keys[i - 1];
        }
    }
    if (i == 0) {
        keys[0] = key;
    }

    count++;

    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rdi), %r13d
testq %r13, %r13
je 0x1c26
leaq 0x4(%rbx), %rbp
imulq $0x130, %r13, %rax      # imm = 0x130
leaq (%rax,%rbx), %r12
addq $-0x12c, %r12           # imm = 0xFED4
movq %r13, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x1100
testl %eax, %eax
jg 0x1c49
decq %r15
leaq 0x130(%r12), %rdi
movl $0x12c, %edx            # imm = 0x12C
movq %r12, %rsi
callq 0x1090
movl 0x12c(%r12), %eax
movl %eax, 0x25c(%r12)
leaq 0x1(%r15), %rax
addq $-0x130, %r12           # imm = 0xFED0
cmpq $0x1, %rax
ja 0x1bd9
testq %r15, %r15
jne 0x1c73
leaq 0x4(%rbx), %rdi
movl $0x12c, %edx            # imm = 0x12C
movq %r14, %rsi
callq 0x1090
movl 0x12c(%r14), %eax
movl %eax, 0x130(%rbx)
xorl %r15d, %r15d
jmp 0x1c73
movl %r15d, %eax
imulq $0x130, %rax, %r12      # imm = 0x130
leaq (%r12,%rbp), %rdi
movl $0x12c, %edx            # imm = 0x12C
movq %r14, %rsi
callq 0x1090
movl 0x12c(%r14), %eax
movl %eax, 0x12c(%rbp,%r12)
incl %r13d
movw %r13w, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTree::insert(SecondaryBTreeDataMap&, _IO_FILE*)
void SecondaryBTree::insert(SecondaryBTreeDataMap& key, FILE* indexFile)
{ // [TROCAR]
    auto result = insertRecursive(key, root, rootOffset, indexFile);

    if (result.hasBeenSplit) { // se tiver um promovido vindo de um split abaixo
        SecondaryBTreeNodeReinterpret* newRoot = new SecondaryBTreeNodeReinterpret();
        newRoot->node.insert(result.promotedKey); // insere a key promovida do nível abaixo
        newRoot->node.blockPointers[0] = rootOffset; //apontador esquerdo -> antiga raíz

        // considerando que o block splittado já foi salvo no arquivo na função insertRecursive
        newRoot->node.blockPointers[1] = result.newBlockOffset;
        newRoot->node.countPointers = 2;

        // salvar o newRoot no arquivo da SecondaryBTree
        rootOffset = writeNewNode(&newRoot->node, indexFile);

        // atualizar o header
        fseek(indexFile, 0, SEEK_SET);

        fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

        delete (root);
        root = newRoot;

        fseek(indexFile, 0, SEEK_END);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x138(%rdi), %rcx
movl 0x140(%rdi), %r8d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %r9
callq 0x1d72
cmpb $0x1, (%r15)
jne 0x26de
leaq 0x140(%r14), %r12
movl $0x1000, %edi           # imm = 0x1000
callq 0x10b0
movq %rax, %r15
movl $0x0, (%rax)
leaq 0xc(%rsp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x1ba6
movl 0x140(%r14), %eax
movl %eax, 0xe44(%r15)
movl 0x130(%r13), %eax
movl %eax, 0xe48(%r15)
movw $0x2, 0x2(%r15)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10d0
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1180
movq %rbx, %rdi
callq 0x1030
shrq $0xc, %rax
decl %eax
movl %eax, 0x140(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x1180
movq 0x138(%r14), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
movq %r15, 0x138(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10d0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTreeNode::insert(int)
unsigned short PrimaryBTreeNode::insert(int key)
{ // [TROCAR]

    unsigned short i;

    for (i = count; i >= 1; i--) {
        if (key > keys[i - 1]) {
            keys[i] = key;
            break;
        } else {
            keys[i] = keys[i - 1];
        }
    }
    if (i == 0) {
        keys[0] = key;
    }

    count++;

    return i;
}

// Assembly:
movzwl (%rdi), %ecx
testw %cx, %cx
je 0x2a6b
leaq 0x4(%rdi), %rdx
movl %ecx, %eax
movzwl %ax, %r8d
leal -0x1(%r8), %r9d
movl (%rdx,%r9,4), %r9d
leaq (%rdx,%r8,4), %r8
cmpl %esi, %r9d
jl 0x2a71
movl %r9d, (%r8)
decw %ax
jne 0x2a4e
leaq 0x4(%rdi), %r8
xorl %eax, %eax
movl %esi, (%r8)
incl %ecx
movw %cx, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTree::insert(int, _IO_FILE*)
void PrimaryBTree::insert(int key, FILE* indexFile)
{ // [TROCAR]
    auto result = insertRecursive(key, root, rootOffset, indexFile);

    if (result.hasBeenSplit) { // se tiver um promovido vindo de um split abaixo
        PrimaryBTreeNodeReinterpret* newRoot = new PrimaryBTreeNodeReinterpret();
        newRoot->node.insert(result.promotedKey); // insere a key promovida do nível abaixo
        newRoot->node.blockPointers[0] = rootOffset; //apontador esquerdo -> antiga raíz

        // considerando que o block splittado já foi salvo no arquivo na função insertRecursive
        newRoot->node.blockPointers[1] = result.newBlockOffset;
        newRoot->node.countPointers = 2;

        // salvar o newRoot no arquivo da PrimaryBTree
        rootOffset = writeNewNode(&newRoot->node, indexFile);

        // atualizar o header
        fseek(indexFile, 0, SEEK_SET);

        fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

        delete (root);
        root = newRoot;

        fseek(indexFile, 0, SEEK_END);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdx
movzwl 0x18(%rdi), %ecx
movq %rbx, %r8
callq 0x2b5a
movq %rax, %r13
testb $0x1, %r13b
je 0x3368
movl %edx, %ebp
leaq 0x18(%r14), %r12
movl $0x1000, %edi           # imm = 0x1000
callq 0x10b0
movq %rax, %r15
shrq $0x20, %r13
movl %r13d, 0x4(%rax)
movw $0x1, (%rax)
movzwl 0x18(%r14), %eax
movw %ax, 0xaa4(%r15)
movw %bp, 0xaa6(%r15)
movw $0x2, 0x2(%r15)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10d0
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1180
movq %rbx, %rdi
callq 0x1030
shrl $0xc, %eax
decl %eax
movw %ax, 0x18(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x1180
movq 0x10(%r14), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
movq %r15, 0x10(%r14)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop