LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/cssartori[P]ga-qap/src/datafile.cpp
// Function: DataFile::write_solution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Solution const&)
int DataFile::write_solution(const std::string& filename, const Solution& s){
	FILE *file = fopen(filename.c_str(), "wt");
	
	if(file == NULL)
		return -1;

	fprintf(file, "%li %i\n", n, s.fitness());
	for(size_t i=0;i<n;i++){
		fprintf(file, "%i ", s[i]);
	}
	fprintf(file, "\n");

	fclose(file);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x4908(%rip), %rsi      # 0x700d
callq 0x21c0
testq %rax, %rax
je 0x2781
movq %rax, %r15
movq 0x30(%r14), %r12
movq %rbx, %rdi
callq 0x3612
leaq 0x48eb(%rip), %rsi      # 0x7010
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x2200
cmpq $0x0, 0x30(%r14)
je 0x276a
leaq 0x48d4(%rip), %r12      # 0x7018
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3608
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x2200
incq %r13
cmpq 0x30(%r14), %r13
jb 0x2747
movl $0xa, %edi
movq %r15, %rsi
callq 0x21f0
movq %r15, %rdi
callq 0x2180
jmp 0x2786
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x782b(%rip), %r14      # 0x9fd8
leaq 0x4868(%rip), %rsi      # 0x701c
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 0x4852(%rip), %rsi      # 0x7041
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 0x480d(%rip), %rsi      # 0x7046
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 0x28e6
xorl %r12d, %r12d
leaq 0x47c6(%rip), %r15      # 0x7044
cmpq $0x0, 0x30(%rbx)
je 0x28b6
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 0x288b
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 0x287e
leaq 0x475d(%rip), %rsi      # 0x704a
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 0x299b
xorl %r12d, %r12d
leaq 0x4712(%rip), %r15      # 0x7044
cmpq $0x0, 0x30(%rbx)
je 0x296b
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 0x293f
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 0x2932
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpq $0x0, 0x30(%rax)
je 0x37e3
movq %rsi, 0x10(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %r13
movq (%rdi), %r14
cmpq $0x0, 0x30(%r14)
je 0x37d5
leaq (%rbx,%rbx,2), %rax
movq %rax, 0x18(%rsp)
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax,%r12,4), %r15d
movq %r13, %rdi
movl %ebx, %esi
callq 0x3608
cltq
movq 0x18(%r14), %rcx
movq %rcx, 0x20(%rsp)
leaq (%rax,%rax,2), %r14
movq %r13, %rdi
movl %r12d, %esi
callq 0x3608
movq 0x8(%rsp), %rdi
cltq
movq 0x20(%rsp), %rcx
movq (%rcx,%r14,8), %rcx
imull (%rcx,%rax,4), %r15d
addl %r15d, %ebp
incq %r12
movq (%rdi), %r14
cmpq 0x30(%r14), %r12
jb 0x377d
incq %rbx
movq (%rdi), %rax
cmpq 0x30(%rax), %rbx
jb 0x3767
jmp 0x37e5
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_O1/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
cmpq $0x0, 0x30(%rax)
je 0x47b1
movq %rsi, %r14
xorl %r12d, %r12d
movq %rsi, 0x10(%rsp)
leaq 0x1(%r12), %rcx
movq (%r14), %rax
movq %rcx, (%rsp)
cmpq 0x30(%rax), %rcx
jae 0x47a0
movq (%rsp), %r13
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x37f6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3612
cmpl %eax, %ebp
jge 0x4794
movq %rbx, %rdi
movl %r12d, %esi
callq 0x35fc
movl (%rax), %r14d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x35fc
movl (%rax), %r15d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x35fc
movl %r15d, (%rax)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x35fc
movl %r14d, (%rax)
movq 0x10(%rsp), %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3616
incq %r13
movq (%r14), %rax
cmpq 0x30(%rax), %r13
jb 0x472d
movq (%r14), %rax
movq (%rsp), %r12
cmpq 0x30(%rax), %r12
jb 0x4717
movq (%rbx), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b49
movq %rcx, %rbx
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq 0x20(%rsp), %r15
movq %r12, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4242
movl %eax, %r13d
movq %r12, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4242
cmpl %r13d, %eax
je 0x4ac2
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 0x37f6
movq %r15, %rdi
movl %eax, %esi
callq 0x3616
movq %r15, %rdi
movl %r13d, %esi
callq 0x35fc
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x35fc
movl (%rax), %r14d
movq %r15, %rdi
movl %r13d, %esi
callq 0x35fc
movl %r14d, (%rax)
movq %r15, %rdi
movl %ebp, %esi
movl 0xc(%rsp), %ebp
callq 0x35fc
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
cmpl 0x4(%rsp), %ebp
jne 0x4ab1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cssartori[P]ga-qap/src/geneticalgorithm.cpp
// Function: GeneticAlgorithm::GeneticAlgorithm(DataFile const&, unsigned long, unsigned long, unsigned long, double, unsigned long, bool)
GeneticAlgorithm::GeneticAlgorithm(const DataFile& _data, size_t pop_size, size_t max_generations, size_t k, double pc, size_t seed, bool prints) : data(_data){
	this->pop_size = pop_size;
	this->max_generations = max_generations;
	this->k = k;
	this->pc = pc;
	this->seed = seed;
	this->prints = prints;

	this->generator = std::default_random_engine(seed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movsd %xmm0, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x38(%rdi), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3564
leaq 0x58(%rbx), %rdi
xorl %esi, %esi
callq 0x3564
movb 0x40(%rsp), %al
movq %r13, 0x10(%rbx)
movq %r12, 0x20(%rbx)
movq %r15, 0x18(%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x28(%rbx)
movb %al, 0x30(%rbx)
movabsq $0x200000005, %rcx      # imm = 0x200000005
movq %r14, %rax
mulq %rcx
movq %r14, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rcx
shlq $0x1f, %rcx
subq %rcx, %rax
leaq (%r14,%rax), %rcx
cmpq $0x1, %rcx
adcq %r14, %rax
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c57
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4242
cmpl (%r14), %eax
jne 0x5856
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x4242
cmpl (%r14), %eax
je 0x5843
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 0x2e46
movl 0x18(%r15,%r12), %eax
movl %eax, 0x18(%rbp)
movl %ebx, (%r14)
cmpq $0x2, 0x18(%rsp)
jb 0x5915
movl $0x1, %ebx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4242
movl %eax, %r15d
movq 0x8(%rsp), %r12
cmpl (%r14), %r15d
jne 0x58c8
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4242
movl %eax, %r15d
jmp 0x58b0
movq %r12, %rsi
movslq %r15d, %r12
shlq $0x5, %r12
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq %r12, %rdi
callq 0x361a
testb %al, %al
je 0x590b
movq 0x10(%rsp), %rax
addq (%rax), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2cfe
movl 0x18(%r12), %eax
movq 0x8(%rsp), %rcx
movl %eax, 0x18(%rcx)
movl %r15d, (%r14)
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x589a
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 0x5936
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x594c
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x63c8
movq (%r15), %rax
movq 0x30(%rax), %rsi
subq %rbx, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x63c8
movq (%r15), %rax
cmpq $0x0, 0x30(%rax)
je 0x6160
leaq (,%rbx,4), %r13
negq %r13
xorl %r12d, %r12d
cmpq %rbx, %r12
jae 0x613b
movq %r14, %rdi
movl %r12d, %esi
callq 0x35fc
movl (%rax), %eax
movq 0x20(%rsp), %rcx
jmp 0x6150
movq %r14, %rdi
movl %r12d, %esi
callq 0x35fc
movl (%rax), %eax
movq 0x8(%rsp), %rcx
addq %r13, %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
movq (%r15), %rax
cmpq 0x30(%rax), %r12
jb 0x6122
movq (%r15), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x61c7
leaq (,%rbx,4), %r13
xorl %r12d, %r12d
movq %rax, %rcx
subq %rbx, %rcx
cmpq %rcx, %r12
jae 0x6198
movq 0x8(%rsp), %rax
movl (%rax,%r12,4), %ebp
movq %r14, %rdi
movl %r12d, %esi
callq 0x35fc
jmp 0x61b6
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 0x35fc
movl %ebp, (%rax)
incq %r12
movq (%r15), %rax
movq 0x30(%rax), %rax
cmpq %rax, %r12
jb 0x6177
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x61de
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x61f5
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 0x6225
jmp 0x620b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6225
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x623c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3182
movq 0x10(%r14), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2c44
leaq -0xa8(%rbp), %rdi
callq 0x2be2
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 0x2be2
movq %rbx, %rdi
callq 0x2350
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/Vanuan[P]pocketbook_free_swupdate/PocketBookUpdate.cpp
// Function: convertInt[abi:cxx11](int)
string convertInt(int number)
{
   if( number == 0) return "";
   stringstream ss;//create a stringstream
   ss << number;//add number to the stream
   return ss.str();//return a string with the contents of the stream
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
testl %esi, %esi
je 0x263d
movl %esi, %ebp
movq %rsp, %rdi
callq 0x2140
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x2340
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2310
movq 0x3992(%rip), %rsi      # 0x5fb8
movq %rsp, %rdi
callq 0x2160
leaq 0x80(%rsp), %rdi
callq 0x20d0
jmp 0x2656
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1a3d(%rip), %rdx      # 0x4088
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x33d8
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq 0x394b(%rip), %rsi      # 0x5fb8
movq %rsp, %rdi
callq 0x2160
leaq 0x80(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f11(%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 0xfdc(%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 0xf58(%rip), %rsi       # 0x4086
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0xf3d(%rip), %rsi       # 0x4085
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69fe
movq %rax, %r15
leaq 0x8(%r12), %r13
cmpq %r13, %rax
je 0x69ee
movq %r12, %rdi
movq %r14, %rsi
callq 0x69fe
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_O1/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 0x69fe
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0xb6eb
movq 0x40(%r15), %rdx
leaq 0x38(%r15), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0xb6d1
movl (%r14), %esi
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0xb6ba
movq %rax, %rdx
cmpq %rax, %rcx
je 0xb6e6
movl (%r14), %edx
cmpl 0x20(%rcx), %edx
cmovlq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0xb6f8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb932
movl %ebp, (%rax)
addq $0x30, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb9ae
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3150
movb $0x1, %al
jmp 0xb6ed
// File: /workspace/github_cpp_makefile_star2_O1/neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::queryY2X(int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
bool Bijection<TypeX,TypeY>::
	queryY2X(const TypeY& input, TypeX& result)const
{
	if(Y2XMap.find(input)!=Y2XMap.end())
	{
		result=Y2XMap.find(input)->second;
		return true;
	}
	else
	{
		return false;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
addq $0x38, %rbx
movq %rbx, %rcx
testq %rax, %rax
je 0xb832
movl (%rsi), %edi
movq %rax, %r8
movq %rbx, %rcx
xorl %r9d, %r9d
cmpl %edi, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rcx
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0xb819
movq %rbx, %r14
cmpq %rbx, %rcx
je 0xb846
movl (%rsi), %edi
cmpl 0x20(%rcx), %edi
cmovlq %rbx, %rcx
movq %rcx, %r14
cmpq %rbx, %r14
je 0xb893
movq %rbx, %rcx
testq %rax, %rax
je 0xb870
movl (%rsi), %edi
movq %rbx, %rcx
xorl %r8d, %r8d
cmpl %edi, 0x20(%rax)
setl %r8b
cmovgeq %rax, %rcx
movq 0x10(%rax,%r8,8), %rax
testq %rax, %rax
jne 0xb858
movq %rbx, %rax
cmpq %rbx, %rcx
je 0xb884
movl (%rsi), %eax
cmpl 0x20(%rcx), %eax
cmovlq %rbx, %rcx
movq %rcx, %rax
addq $0x28, %rax
movq %rdx, %rdi
movq %rax, %rsi
callq 0x3150
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x144cc
movq %rsi, %rbx
leaq 0x20(%r15), %rsi
leaq 0x40(%r15), %rdx
movq %rbx, %rdi
callq 0xb686
movq %r15, %rdi
callq 0x3360
movq %rax, %r15
cmpq %r14, %rax
jne 0x144ac
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x189a2
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 0x18932
jmp 0x189a6
movl %eax, %edx
movl %eax, %ecx
leaq 0x28803(%rip), %r8      # 0x411b0
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_O1/neubig[P]egret/Egret/src/bob-hash.cpp
// Function: hashword2(unsigned int const*, unsigned long, unsigned int*, unsigned int*)
void hashword2 (
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       *pc,                      /* IN: seed OUT: primary hash value */
uint32_t       *pb)               /* IN: more seed OUT: secondary hash value */
{
  uint32_t a,b,c;

  /* Set up the internal state */
  a = b = c = 0xdeadbeef + ((uint32_t)(length<<2)) + *pc;
  c += *pb;

  /*------------------------------------------------- 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 */
  *pc=c; *pb=b;
}

// Assembly:
pushq %rbx
movl (%rdx), %eax
leal (%rax,%rsi,4), %eax
addl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movl (%rcx), %r8d
addl %eax, %r8d
movl %eax, %r9d
cmpq $0x4, %rsi
jb 0x18a89
addl (%rdi), %r9d
addl 0x4(%rdi), %eax
addl 0x8(%rdi), %r8d
movl %r8d, %r10d
roll $0x4, %r10d
subl %r8d, %r9d
xorl %r9d, %r10d
addl %eax, %r8d
subl %r10d, %eax
movl %r10d, %r11d
roll $0x6, %r11d
xorl %eax, %r11d
addl %r8d, %r10d
movl %r11d, %ebx
roll $0x8, %ebx
subl %r11d, %r8d
xorl %r8d, %ebx
addl %r10d, %r11d
subl %ebx, %r10d
movl %ebx, %r9d
roll $0x10, %r9d
xorl %r10d, %r9d
addl %r11d, %ebx
movl %r9d, %eax
roll $0x13, %eax
subl %r9d, %r11d
xorl %r11d, %eax
addl %ebx, %r9d
subl %eax, %ebx
movl %eax, %r8d
roll $0x4, %r8d
xorl %ebx, %r8d
addl %r9d, %eax
addq $-0x3, %rsi
addq $0xc, %rdi
cmpq $0x3, %rsi
ja 0x18a14
leaq 0x28730(%rip), %r10     # 0x411c0
movslq (%r10,%rsi,4), %rsi
addq %r10, %rsi
jmpq *%rsi
addl 0x8(%rdi), %r8d
addl 0x4(%rdi), %eax
addl (%rdi), %r9d
xorl %eax, %r8d
movl %eax, %esi
roll $0xe, %esi
subl %esi, %r8d
xorl %r8d, %r9d
movl %r8d, %esi
roll $0xb, %esi
subl %esi, %r9d
xorl %r9d, %eax
movl %r9d, %esi
roll $0x19, %esi
subl %esi, %eax
movl %eax, %esi
roll $0x10, %esi
xorl %eax, %r8d
subl %esi, %r8d
xorl %r8d, %r9d
movl %r8d, %esi
roll $0x4, %esi
subl %esi, %r9d
xorl %r9d, %eax
roll $0xe, %r9d
subl %r9d, %eax
xorl %eax, %r8d
movl %eax, %esi
roll $0x18, %esi
subl %esi, %r8d
movl %r8d, (%rdx)
movl %eax, (%rcx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f4c9
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r14
movq 0x10(%rsp), %rax
movq 0x18(%rax), %r15
cmpq %r14, %r15
je 0x1f4b3
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 0x1f40a
movq %r15, %rdi
callq 0x31f0
movq %rax, %r15
cmpq %r14, %rax
jne 0x1f48e
movq 0x8(%rsp), %rdi
callq 0x31f0
movq %rax, 0x8(%rsp)
cmpq 0x20(%rsp), %rax
jne 0x1f477
movb 0x90(%rbx), %bpl
testb %bpl, %bpl
jne 0x1f54b
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 0x1f4ee
xorl %eax, %eax
movabsq $0x3fb2a9930be0ded3, %rcx # imm = 0x3FB2A9930BE0DED3
xorl %edx, %edx
movq (%r15,%rdx,8), %rsi
xorl %edi, %edi
movq %rcx, (%rsi,%rdi,8)
incq %rdi
cmpq $0x64, %rdi
jne 0x1f515
incq %rdx
cmpq $0x64, %rdx
jne 0x1f50f
incl %eax
cmpl $0x64, %eax
jne 0x1f50d
testb %bpl, %bpl
jne 0x1f54b
callq 0x31c0
subq 0x18(%rsp), %rax
leaq 0x36e20(%rip), %rcx     # 0x56368
addq %rax, (%rcx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %r15
movl $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %r15, 0x30(%rdi)
movq %r15, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movups %xmm0, 0x58(%rdi)
movq %rax, 0x68(%rdi)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x48(%rdi)
movq $-0x1, 0x50(%rdi)
cmpq %rax, 0x60(%rdi)
je 0x20a22
movq $0x0, 0x60(%rbx)
movq %r14, %rdi
callq 0x20d64
leaq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rbx, %rsi
callq 0x20b88
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x21802
movq 0x10(%rsp), %rsi
cmpq %rsi, 0x18(%rsp)
je 0x20abc
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
xorl %ebp, %ebp
addq %r12, %rsi
movq %r14, %rdi
callq 0x2104a
cmpq %r15, %rax
jne 0x20a9b
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x20d2a
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x21338
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 0x20a6b
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xf(%rsp), %rdx
callq 0x214c2
leaq 0x10(%rsp), %rdi
callq 0x1d534
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20ae8
movq %rax, %r15
leaq 0x58(%rbx), %r12
leaq 0x10(%rsp), %rdi
callq 0x1d534
movq (%r12), %rdi
testq %rdi, %rdi
je 0x20b0e
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %r14, %rdi
callq 0x1d582
movq %rbx, %rdi
callq 0x1d534
movq %r15, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21802
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0xf(%rsp), %rdx
callq 0x214c2
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x20d64
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x210ca
ucomisd %xmm1, %xmm0
jbe 0x210cb
xorl %eax, %eax
retq
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x210ca
ja 0x210c8
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 0x2111d
movl (%rdx), %edi
movl (%rax), %r8d
cmpl %edi, %r8d
jne 0x21124
addq $0x4, %rdx
addq $0x4, %rax
cmpq %rsi, %rdx
jne 0x21106
cmpq %rcx, %rax
setne %al
retq
setg %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %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)
cmpq $0x0, 0x18(%rsp)
je 0x302ed
movq $0x0, 0x18(%rsp)
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x3047b
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x30be8
movups 0x30(%rsp), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
testq %rdi, %rdi
je 0x3034c
subq %rdi, %rsi
callq 0x32e0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x30363
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
leaq 0x18(%r14), %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x30c28
movq %r15, %rdi
movq %rax, %rsi
callq 0x30ce4
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %r15, %rcx
cmpq $0x29, %rcx
jl 0x30422
leaq -0x28(%rax), %r12
movups -0x28(%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
leaq -0x18(%rax), %rdi
movups -0x18(%rax), %xmm0
movaps %xmm0, 0x60(%rsp)
movq -0x8(%rax), %r13
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rax)
movq $0x0, -0x8(%rax)
movups (%r15), %xmm0
movups %xmm0, -0x28(%rax)
leaq 0x10(%r15), %rsi
callq 0x217c2
subq %r15, %r12
sarq $0x3, %r12
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %r12, %rdx
movaps 0x70(%rsp), %xmm0
leaq 0x30(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps 0x60(%rsp), %xmm0
movaps %xmm0, 0x10(%rcx)
movq %r13, 0x20(%rcx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x215a6
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x30422
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
leaq 0x10(%rsp), %r15
movq 0x8(%r14), %rax
leaq -0x28(%rax), %rcx
movq %rcx, 0x8(%r14)
movq -0x18(%rax), %rdi
testq %rdi, %rdi
je 0x30448
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x32e0
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
jmp 0x30493
movups 0x48(%r14), %xmm0
movups %xmm0, (%rbx)
leaq 0x10(%rbx), %rdi
addq $0x58, %r14
movq %r14, %rsi
callq 0x933e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x304aa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x304df
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
jmp 0x304df
jmp 0x304dc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x304f6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2104a
leaq 0x20(%r15), %rcx
cmpq %rcx, %rax
jne 0x305a9
movq %r15, %rdi
movq %rbx, %rsi
callq 0x20d2a
movq (%r15), %rdi
movq 0x8(%r15), %rax
movups -0x28(%rax), %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movups -0x18(%rax), %xmm0
movq -0x8(%rax), %rdx
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 0x21712
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3059e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21338
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x305cd
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x32e0
movq %rbx, %rdi
callq 0x3530
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3087a
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x3071d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3084e
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 0x306f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30c0b
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
addq $0x10, %rax
movq %rax, %rsi
jmp 0x30c1d
movups 0x48(%rsi), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x10, %rdi
addq $0x58, %rsi
callq 0x933e
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10536(%rip), %rsi     # 0x41c23
callq 0x30c0
testl %eax, %eax
je 0x3174a
leaq 0x10532(%rip), %rsi     # 0x41c2f
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x3174e
leaq 0x10035(%rip), %rsi     # 0x41745
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x31755
leaq 0x10519(%rip), %rsi     # 0x41c3c
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0x3175c
leaq 0x1050f(%rip), %rsi     # 0x41c45
movq %rbx, %rdi
callq 0x30c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
adcl $0x2, %eax
jmp 0x31761
xorl %eax, %eax
jmp 0x31761
movl $0x1, %eax
jmp 0x31761
movl $0x2, %eax
jmp 0x31761
movl $0x4, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37e1b
movq %rax, 0x108(%r14)
movq 0xd0(%r14), %rax
cmpq %rax, 0xd8(%r14)
je 0x37e32
movq %rax, 0xd8(%r14)
leaq 0xd0(%r14), %r15
leaq 0xe8(%r14), %r12
movq 0xe8(%r14), %rax
cmpq %rax, 0xf0(%r14)
je 0x37e57
movq %rax, 0xf0(%r14)
movslq %ebx, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0xf41a
movq %r12, %rdi
movq %r13, %rsi
callq 0xf41a
testl %r13d, %r13d
jle 0x37ee4
movabsq $-0x3dfd5fa0e0000000, %rbp # imm = 0xC202A05F20000000
movq %rsp, %r13
movq %rbp, (%rsp)
movq 0xd8(%r14), %rsi
cmpq 0xe0(%r14), %rsi
je 0x37ea6
movq %rbp, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xd8(%r14)
jmp 0x37eb1
movq %r15, %rdi
movq %r13, %rdx
callq 0xfaa4
movq %rbp, (%rsp)
movq 0xf0(%r14), %rsi
cmpq 0xf8(%r14), %rsi
je 0x37ed5
movq %rbp, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xf0(%r14)
jmp 0x37ee0
movq %r12, %rdi
movq %r13, %rdx
callq 0xfaa4
decl %ebx
jne 0x37e82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1535(%rip), %rsi      # 0x411ab
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3fcc7
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 0x3fcc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
leaq 0x21e5(%rip), %rsi      # 0x41eb3
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3fd1f
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 0x3fd1f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
leaq 0x1662(%rip), %rsi      # 0x41388
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3510
cmpq $-0x1, %rax
je 0x3fd80
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 0x3fd80
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3fd95
jmp 0x3fd95
jmp 0x3fd95
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3fdac
movq (%r12), %rsi
incq %rsi
callq 0x32e0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15631(%rip), %rsi     # 0x55fa8
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 0x409b8
movq (%r15), %rsi
incq %rsi
callq 0x32e0
jmp 0x409b8
movq %rax, %r14
movq 0x155e9(%rip), %rsi     # 0x55fa8
movq %rsp, %rdi
callq 0x3230
leaq 0x80(%rsp), %rdi
callq 0x30e0
movq %r14, %rdi
callq 0x3530