LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::DisplayStatistics()
void Process::DisplayStatistics(void) {
    std::cout << std::endl;
    std::cout << "Process: \"" << name << "\"" << std::endl;
    std::cout << "-------------------------" << std::endl;
    std::cout << "Memory References: " << references << std::endl;
    std::cout << "Page Faults: " << pageFaults << std::endl;
    std::cout << "Size in Pages: " << size << std::endl;
    std::cout << "Fault Rate: " << ((float)pageFaults / (float)references) * 100.0 << "%" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x5743(%rip), %rbx      # 0xbfc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x1a45(%rip), %rsi      # 0x82f8
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2200
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2200
movq %rax, %r15
leaq 0x1a28(%rip), %rsi      # 0x8301
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x19ef(%rip), %rsi      # 0x8303
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x19ce(%rip), %rsi      # 0x831d
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2200
movzwl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x1997(%rip), %rsi      # 0x8331
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2200
movzwl 0x22(%r14), %esi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x195a(%rip), %rsi      # 0x833f
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2200
movzwl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0x2130
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x191f(%rip), %rsi      # 0x834f
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2200
movzwl 0x22(%r14), %eax
cvtsi2ss %eax, %xmm0
movzwl 0x20(%r14), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x1891(%rip), %xmm0     # 0x82f0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %rbx
leaq 0x18eb(%rip), %rsi      # 0x835c
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::EntryExists(unsigned short)
bool PageTable::EntryExists(const uint16_t page) {
    //Return true if the page entry exists AND is valid
    if(table.count(page)) {
        if(table[page].valid) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movq %rax, %rsi
callq 0x6d92
testq %rax, %rax
je 0x6d0d
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e10
movq %rax, %rcx
movb $0x1, %al
cmpb $0x0, 0x4(%rcx)
jne 0x6d0f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::AddEntry(unsigned short, PageTableEntry&)
void PageTable::AddEntry(const uint16_t page, PageTableEntry & entry) {
    //Set the valid bit
    entry.valid = true;

    //Store the entry in the page table
    table[page] = entry;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movb $0x1, 0x4(%rdx)
movq %rax, %rsi
callq 0x6e10
movl (%rbx), %ecx
movl %ecx, (%rax)
movb 0x4(%rbx), %cl
movb %cl, 0x4(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::GetEntry(unsigned short)
PageTableEntry & PageTable::GetEntry(const uint16_t page) {
    //Returns the entry associated with the page, if it exists
    if(table.count(page)) {
        return table[page];
    } else {
        return invalid;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movq %rax, %rsi
callq 0x6d92
testq %rax, %rax
je 0x6d85
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x6e10
movq %rax, %rbx
jmp 0x6d89
addq $0x38, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Slexis-Works[P]texture-packing/texture-packing.cpp
// Function: showUsage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void showUsage(const std::string name) {
	std::cerr << "Utilisation : " << std::endl
			<< name << " --help" << std::endl
			<< "Affiche plus de détails" << std::endl
			<< name << " [--seed nombre] [--tmin tailleMin] [--tmax tailleMax] [--lt largeurTexture] [--ht hauteurTexture] [--sortie nomDossier] [--tests nombre] [algorithme(s)]" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9a41(%rip), %r14      # 0xeff0
leaq 0x514b(%rip), %rsi      # 0xa701
movl $0xe, %edx
movq %r14, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x510d(%rip), %rsi      # 0xa710
movl $0x7, %edx
movq %rax, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq %rax, %r14
leaq 0x50d7(%rip), %rsi      # 0xa718
movl $0x18, %edx
movq %rax, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rax, %rdi
callq 0x2270
movq %rax, %rbx
leaq 0x50a3(%rip), %rsi      # 0xa731
movl $0x99, %edx
movq %rax, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/population.cpp
// Function: Population::speciate()
void Population::speciate(){

	vector<Individual*>::iterator curInd;
	vector<Species*>::iterator spePtr;

	bool accepted;

	for(curInd=individuals.begin(); curInd!=individuals.end(); ++curInd){
		// cout << "spe1" << endl;

		accepted = false;
		if(species.size()==0){
			Species *new_species = new Species(*curInd);
			// cout << "spe2" << endl;

			species.push_back(new_species);
		}
		else{
			// cout << "spe3" << endl;

			for(spePtr=species.begin(); spePtr!=species.end(); ++spePtr){
				// cout << "spe4" << endl;

				accepted = (*spePtr)->add_member(*curInd);
				// cout << "spe5" << endl;

				if(accepted) break;
			}
			if(!accepted){
				// cout << "spe6" << endl;

				Species *new_species = new Species(*curInd);
				species.push_back(new_species);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
cmpq 0x8(%rdi), %r13
je 0x28ea
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
leaq -0x30(%rbp), %r15
movq 0x50(%rbx), %r12
cmpq %r12, 0x58(%rbx)
je 0x2885
cmpq 0x58(%rbx), %r12
je 0x284f
movq (%r12), %rdi
movq (%r13), %rsi
callq 0x46dc
testb %al, %al
jne 0x28dc
addq $0x8, %r12
cmpq 0x58(%rbx), %r12
jne 0x2828
testb %al, %al
jne 0x28dc
movl $0x48, %edi
callq 0x1100
movq %rax, %r12
movq (%r13), %rsi
movq %rax, %rdi
movsd 0x47ed(%rip), %xmm0     # 0x7058
movaps %xmm0, %xmm1
movsd 0x47ea(%rip), %xmm2     # 0x7060
movsd 0x47ea(%rip), %xmm3     # 0x7068
callq 0x3ebe
jmp 0x28b9
movl $0x48, %edi
callq 0x1100
movq %rax, %r12
movq (%r13), %rsi
movq %rax, %rdi
movsd 0x47b7(%rip), %xmm0     # 0x7058
movaps %xmm0, %xmm1
movsd 0x47b4(%rip), %xmm2     # 0x7060
movsd 0x47b4(%rip), %xmm3     # 0x7068
callq 0x3ebe
movq %r12, -0x30(%rbp)
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x28d1
movq %r12, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0x28dc
movq %r14, %rdi
movq %r15, %rdx
callq 0x3d60
addq $0x8, %r13
cmpq 0x8(%rbx), %r13
jne 0x2818
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28fb
movq %rax, %rbx
movl $0x48, %esi
movq %r12, %rdi
callq 0x1110
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/population.cpp
// Function: Population::~Population()
Population::~Population(){
	// vector<Individual*>::iterator curInd;

	// for(curInd=individuals.begin(); curInd!=individuals.end(); ++curInd){
	// 	delete *curInd;
	// }
	// delete innov_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x2932
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2947
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x295c
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2976
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1110
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/species.cpp
// Function: Species::calc_n_offspring()
int Species::calc_n_offspring(){
	vector<Individual*>::iterator indPtr;

	n_offspring = 0;

	double double_offspring = 0.;

	for(indPtr=members.begin(); indPtr!=members.end(); indPtr++){

		double_offspring += (*indPtr)->est_n_offspring;
	}

	n_offspring = (int) floor(double_offspring);

	return n_offspring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x40(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x4756
movq (%rax), %rdx
addsd 0x10(%rdx), %xmm0
addq $0x8, %rax
jmp 0x4743
callq 0x1180
cvttsd2si %xmm0, %eax
movl %eax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/species.cpp
// Function: Species::~Species()
Species::~Species(){

	vector<Individual*>::iterator indPtr;

	rep = NULL;

	for(indPtr=members.begin(); indPtr!=members.end(); indPtr++){

	 	*indPtr = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x18(%rdi)
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
je 0x4afc
movq $0x0, (%rax)
addq $0x8, %rax
jmp 0x4ae9
movq (%rdi), %rax
testq %rax, %rax
je 0x4b14
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
popq %rbp
jmp 0x1110
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/individual.cpp
// Function: Individual::activate(std::vector<double, std::allocator<double>>)
bool Individual::activate(vector<double> input){

	if(input.size() != inputs.size()){
		cout << "invalid input size" << endl;
		return false;
	}

	for(int i=0; i<inputs.size(); i++){
		inputs[i]->firing = input[i];
		inputs[i]->activated = true;
	}

	// messy, but it looks like it's the way to go 
	// (see FAQ: https://www.cs.ucf.edu/~kstanley/neat.html#FAQ1)
	int max_loops = 20; 
	int loops = 0;
	bool outputs_activated = false;
	while(!outputs_activated || loops<max_loops){
		outputs_activated = true;
		for(int i=*in_size; i<nodes.size(); i++){
			nodes[i]->activate();
			
			if(nodes[i]->node_type==OUTPUT && !nodes[i]->activated){
				outputs_activated = false;
			}
		}
		loops++;

	}

	if(!outputs_activated) {
		cout<<"activation pb" << endl;
		return false;
	}
	else return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
subq %rax, %rsi
movq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rdx
movq %rdx, %r8
subq %rcx, %r8
movq %rsi, -0x38(%rbp)
cmpq %r8, %rsi
movq %r8, -0x30(%rbp)
jne 0x5c5b
movq %rdi, %rbx
cmpq %rcx, %rdx
je 0x5be3
movq %r8, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movq (%rcx,%rsi,8), %rdi
movsd %xmm0, 0x10(%rdi)
movb $0x1, 0xc(%rdi)
incq %rsi
cmpq %rsi, %rdx
jne 0x5bc9
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x80(%rbx), %rax
movslq (%rax), %r15
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movb $0x1, %r14b
cmpq %r15, %rcx
jbe 0x5c46
movb $0x1, %r14b
movq (%rax,%r15,8), %rdi
callq 0x6686
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x1, (%rax)
jne 0x5c2f
movzbl %r14b, %r14d
cmpb $0x0, 0xc(%rax)
cmovel %r12d, %r14d
incq %r15
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x5c0d
cmpl $0x13, %r13d
leal 0x1(%r13), %eax
setae %cl
movl %eax, %r13d
testb %cl, %r14b
je 0x5be9
jmp 0x5c9d
movq 0x4376(%rip), %rbx      # 0x9fd8
leaq 0x15af(%rip), %rsi      # 0x7218
movl $0x12, %edx
movq %rbx, %rdi
callq 0x1120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq -0x30(%rbp), %rax
cmpq %rax, -0x38(%rbp)
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/individual.cpp
// Function: Individual::get_outputs()
vector<double> Individual::get_outputs(){
	
	vector<double> out;

	vector<Node*>::iterator nodePtr;
	for(nodePtr=outputs.begin(); nodePtr != outputs.end(); ++nodePtr){

		out.push_back((*nodePtr)->firing);

	}
	return out;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x48(%rsi), %r15
cmpq 0x50(%rsi), %r15
je 0x5d15
movq %rsi, %r14
movq (%r15), %rdx
addq $0x10, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5d03
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5d0b
movq %rbx, %rdi
callq 0x64ea
addq $0x8, %r15
cmpq 0x50(%r14), %r15
jne 0x5ce0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5d3a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq %r14, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/individual.cpp
// Function: Individual::mutate(std::vector<Node*, std::allocator<Node*>>*, std::vector<Connection*, std::allocator<Connection*>>*)
void Individual::mutate(vector<Node*> *all_nodes, vector<Connection*> *all_connections){

	if(randdouble(0.,1.)<0.8){
		// cout << "mu1" <<endl;
		mutate_weights();
	}
	if(randdouble(0.,1.)<0.03){
		// cout << "mu2" <<endl;

		mutate_add_node(all_nodes, all_connections);
	}
	if(randdouble(0.,1.)<0.05){
		// cout << "mu3" <<endl;

		mutate_add_connection(all_nodes, all_connections);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1040
cvtsi2sd %eax, %xmm0
divsd 0x145e(%rip), %xmm0     # 0x71f0
movsd 0x145e(%rip), %xmm1     # 0x71f8
ucomisd %xmm0, %xmm1
jbe 0x5da8
movq %r14, %rdi
callq 0x5e18
callq 0x1040
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x1434(%rip), %xmm0     # 0x71f0
movsd 0x143c(%rip), %xmm1     # 0x7200
ucomisd %xmm0, %xmm1
jbe 0x5dd5
movq %r14, %rdi
movq %r15, %rsi
callq 0x5e68
callq 0x1040
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x1407(%rip), %xmm0     # 0x71f0
movsd 0x1417(%rip), %xmm1     # 0x7208
ucomisd %xmm0, %xmm1
jbe 0x5e0c
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x614a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/individual.cpp
// Function: Individual::mutate_weights()
void Individual::mutate_weights(){
	vector<Connection*>::iterator conPtr;

	for(conPtr=connections.begin(); conPtr != connections.end(); ++conPtr){

		// uniform perturbation
		if(randdouble(0.,1.)>0.1){
			(*conPtr)->perturb_weight();
		}
		// assign new random value
		else{
			(*conPtr)->reset_weight();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x60(%rdi), %r14
cmpq 0x68(%rdi), %r14
je 0x5e63
movq %rdi, %rbx
callq 0x1040
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x13b0(%rip), %xmm0     # 0x71f0
ucomisd 0x13c8(%rip), %xmm0     # 0x7210
movq (%r14), %rdi
jbe 0x5e54
callq 0x68c4
jmp 0x5e59
callq 0x688e
addq $0x8, %r14
cmpq 0x68(%rbx), %r14
jne 0x5e2c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/individual.cpp
// Function: Individual::~Individual()
Individual::~Individual(){

	vector<Node*>::iterator curNode;
	vector<Connection*>::iterator curCon;

	for(curNode=nodes.begin(); curNode!=nodes.end(); ++curNode){
		delete *curNode;
	}

	for(curCon=connections.begin(); curCon!=connections.end(); ++curCon){
		delete *curCon;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r15
cmpq 0x20(%rdi), %r15
je 0x63c0
movq (%r15), %r14
testq %r14, %r14
je 0x63b6
movq %r14, %rdi
callq 0x676e
movl $0x48, %esi
movq %r14, %rdi
callq 0x1110
addq $0x8, %r15
cmpq 0x20(%rbx), %r15
jne 0x6399
movq 0x60(%rbx), %r15
cmpq 0x68(%rbx), %r15
je 0x63ed
movq (%r15), %r14
testq %r14, %r14
je 0x63e7
movq %r14, %rdi
callq 0x6920
movl $0x28, %esi
movq %r14, %rdi
callq 0x1110
addq $0x8, %r15
jmp 0x63c4
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x6402
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x6417
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x642c
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x1110
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x644b
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/node.cpp
// Function: Node::activate()
bool Node::activate(){

	firing = 0.;

	vector<Connection*>::iterator conPtr;

	bool any_active_input_con = false;
	bool any_active_input_node = false;
	for(conPtr=in_connections.begin(); conPtr != in_connections.end(); ++conPtr){

		if((*conPtr)->is_active){
			any_active_input_con = true;
			if(((*conPtr)->in_node->activated)){
				any_active_input_node = true;
			// 	return false;
			}
		}
	}
	if(!any_active_input_con){
		// cout << "node not activated" <<endl;
		return false; 
	}

	for(conPtr=in_connections.begin(); conPtr != in_connections.end(); ++conPtr){

		firing += (*conPtr)->in_node->firing * (*conPtr)->weight;
	}
	
	if(any_active_input_node){
		firing = sigmoid(firing);
		activated = true;

	}


	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0x66d8
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
movq %rax, %rdi
movq (%rdi), %r8
cmpb $0x1, 0x18(%r8)
jne 0x66cd
movq (%r8), %r8
cmpb $0x0, 0xc(%r8)
movzbl %dl, %edx
cmovnel %esi, %edx
movb $0x1, %r14b
addq $0x8, %rdi
cmpq %rcx, %rdi
jne 0x66b2
jmp 0x66dd
xorl %edx, %edx
xorl %r14d, %r14d
testb $0x1, %r14b
je 0x673f
cmpq %rcx, %rax
je 0x670f
movsd 0x10(%rbx), %xmm0
movq (%rax), %rsi
movq (%rsi), %rdi
movsd 0x10(%rdi), %xmm1
mulsd 0x10(%rsi), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x66ed
testb $0x1, %dl
je 0x673f
movsd 0x10(%rbx), %xmm0
mulsd 0xb27(%rip), %xmm0      # 0x7248
callq 0x11b0
movsd 0x92a(%rip), %xmm1      # 0x7058
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
movb $0x1, 0xc(%rbx)
andb $0x1, %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/samuel500[P]NEAT/connection.cpp
// Function: Connection::Connection(Node*, Node*, int, int)
Connection::Connection(Node *inode, Node *onode, int hist_marking, int creation_gen): hist_marking(hist_marking), creation_gen(creation_gen){

	in_node = new Node;
	in_node = inode;

	out_node = new Node;
	out_node = onode;

	is_active = true;

	in_node->out_connections.push_back(this);
	out_node->in_connections.push_back(this);

	weight = randdouble(-1., 1.);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0x1c(%rdi)
movl %r8d, 0x20(%rdi)
movl $0x48, %edi
callq 0x1100
movq %rax, %r14
movq %rax, %rdi
callq 0x6638
movq %r12, (%rbx)
movl $0x48, %edi
callq 0x1100
movq %rax, %r14
movq %rax, %rdi
callq 0x6638
movq %r15, 0x8(%rbx)
movb $0x1, 0x18(%rbx)
movq (%rbx), %rdi
addq $0x30, %rdi
leaq -0x28(%rbp), %r14
movq %rbx, (%r14)
movq %r14, %rsi
callq 0x692c
movq 0x8(%rbx), %rdi
addq $0x18, %rdi
movq %rbx, (%r14)
leaq -0x28(%rbp), %rsi
callq 0x692c
callq 0x1040
cvtsi2sd %eax, %xmm0
divsd 0x9ab(%rip), %xmm0      # 0x71f0
addsd %xmm0, %xmm0
addsd 0x9ff(%rip), %xmm0      # 0x7250
movsd %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6865
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x1110
movq %rbx, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: Socket::Socket()
Socket::Socket() {
    my_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (my_socket == INVALID_SOCKET) {
        error_code = ErrorCode::CREATE_ERROR;
        return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd08c(%rip), %rax      # 0x10898
movq %rax, (%rdi)
movl $0x0, 0x34(%rdi)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
jne 0x3836
movl $0x1, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ServerSocket::Bind(std::string ip_address, int port) {
    if (IsInvalid()) return -2;
    memset(&my_address, 0, sizeof(my_address));
    my_address.sin_family = AF_INET;
    my_address.sin_port = htons(port);
    my_address.sin_addr.s_addr = htonl(INADDR_ANY);

    if (bind(my_socket, (struct sockaddr*)&my_address, sizeof(my_address)) == -1) {
        error_code = ErrorCode::BIND_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x0, 0x34(%rdi)
je 0x3868
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
rolw $0x8, %dx
movw $0x2, 0xc(%rdi)
movw %dx, 0xe(%rdi)
movl $0x0, 0x10(%rdi)
movl 0x8(%rdi), %edi
movl $0x10, %edx
callq 0x3060
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x38b3
movl $0x2, 0x34(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Listen(int)
int ServerSocket::Listen(int backlog) {
    if (IsInvalid()) return -2;
    if (listen(my_socket, backlog) == SOCKET_ERROR) {
        error_code = ErrorCode::LISTEN_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x0, 0x34(%rdi)
je 0x38c6
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0x32e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x38ec
movl $0x3, 0x34(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Accept()
int ServerSocket::Accept() {
#ifdef _WIN32
    your_socket = accept(my_socket, (struct sockaddr*)&your_address, (int *)&your_address_size);
#else
    your_socket = accept(my_socket, (struct sockaddr*)&your_address, &your_address_size);
#endif
    if (your_socket == INVALID_SOCKET) {
        error_code = ErrorCode::ACCEPT_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %edi
leaq 0x20(%rbx), %rsi
leaq 0x30(%rbx), %rdx
callq 0x30d0
movl %eax, %ecx
movl %eax, 0x1c(%rbx)
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x3925
movl $0x4, 0x34(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ServerSocket::Recv[abi:cxx11]()
std::string ServerSocket::Recv() {
    char buffer[BUFF_SIZE + 5];
    if (recv(your_socket, buffer, BUFF_SIZE, 0) < 0) {
        throw -1;
    }
    return std::string(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rdi, %rbx
movl 0x1c(%rsi), %edi
leaq -0x2020(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
callq 0x30e0
testq %rax, %rax
js 0x39d3
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x2020(%rbp), %r14
movq %r14, %rdi
callq 0x3130
leaq (%rax,%rbp), %rdx
addq $-0x2020, %rdx          # imm = 0xDFE0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bfa
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
movl $0x4, %edi
callq 0x3150
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0xd5ae(%rip), %rsi      # 0x10f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ClientSocket::Connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ClientSocket::Connect(std::string ip_address, int port) {
#ifdef _WIN32
#else
    struct hostent* host_info;
    struct in_addr addr;
    if ((host_info = gethostbyname(ip_address.c_str())) == 0) {
        error_code = ErrorCode::CONNECT_ERROR;
        return -2;
    }
    memcpy(&addr, host_info->h_addr_list[0], host_info->h_length);
    ip_address = std::string(inet_ntoa(addr));
#endif
    memset(&your_address, 0, sizeof(your_address));
    your_address.sin_family = AF_INET;
    your_address.sin_port = htons(port);
    your_address.sin_addr.s_addr = inet_addr(ip_address.c_str());

    if (connect(my_socket, (struct sockaddr*)&your_address, sizeof(your_address)) == SOCKET_ERROR) {
        error_code = ErrorCode::CONNECT_ERROR;
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x3300
testq %rax, %rax
je 0x3afd
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movslq 0x14(%rax), %rdx
leaq -0x28(%rbp), %r12
movq %r12, %rdi
callq 0x3210
movl (%r12), %edi
callq 0x3140
leaq -0x48(%rbp), %r12
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x3110
movq %r14, %rdi
movq %r12, %rsi
callq 0x3330
movq (%r12), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3ab7
callq 0x3260
leaq 0x20(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movw $0x2, 0x20(%rbx)
rolw $0x8, %r15w
movw %r15w, 0x22(%rbx)
movq (%r14), %rdi
callq 0x32b0
movl %eax, 0x24(%rbx)
movl 0x8(%rbx), %edi
movq %r12, %rsi
movl $0x10, %edx
callq 0x3220
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x3b09
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3b02
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl $0x5, 0x34(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_socket.cpp
// Function: ClientSocket::Recv[abi:cxx11]()
std::string ClientSocket::Recv() {
    char buffer[BUFF_SIZE + 5];
    if (recv(my_socket, buffer, BUFF_SIZE, 0) < 0) {
        throw -1;
    }
    return std::string(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rdi, %rbx
movl 0x8(%rsi), %edi
leaq -0x2020(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
xorl %ecx, %ecx
callq 0x30e0
testq %rax, %rax
js 0x3bbd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x2020(%rbp), %r14
movq %r14, %rdi
callq 0x3130
leaq (%rax,%rbp), %rdx
addq $-0x2020, %rdx          # imm = 0xDFE0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bfa
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r14
popq %rbp
retq
movl $0x4, %edi
callq 0x3150
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0xd3c4(%rip), %rsi      # 0x10f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_library.cpp
// Function: kbhit()
bool kbhit() {
    struct termios oldt, newt;
    int ch;
    int oldf;
    
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
    newt.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    
    ch = getchar();
    
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
    fcntl(STDIN_FILENO, F_SETFL, oldf);
    
    if (ch != EOF) {
        ungetc(ch, stdin);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq -0x9c(%rbp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x32d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
leaq -0x60(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm2, 0x20(%rdx)
movups %xmm3, 0x2c(%rdx)
andb $-0xb, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3340
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x31a0
movl %eax, %r15d
movl %eax, %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x31a0
callq 0x3380
movl %eax, %r14d
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3340
xorl %edi, %edi
movl $0x4, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x31a0
cmpl $-0x1, %r14d
je 0x3d4a
movq 0xd279(%rip), %rax      # 0x10fb8
movq (%rax), %rsi
movl %r14d, %edi
callq 0x3070
cmpl $-0x1, %r14d
setne %al
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/cross_library.cpp
// Function: getch()
int getch() {
    struct termios oldattr, newattr;
    int ch;

    tcgetattr( STDIN_FILENO, &oldattr );
    newattr = oldattr;
    newattr.c_lflag &= ~( ICANON | ECHO );
    tcsetattr( STDIN_FILENO, TCSANOW, &newattr );

    ch = getchar();

    tcsetattr( STDIN_FILENO, TCSANOW, &oldattr );

    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq -0x8c(%rbp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x32d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
leaq -0x50(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm1, 0x10(%rdx)
movaps %xmm2, 0x20(%rdx)
movups %xmm3, 0x2c(%rdx)
andb $-0xb, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x3340
callq 0x3380
movl %eax, %r14d
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3340
movl %r14d, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: Game::DrawPlayerInformation(PlayerInformation const&, int, int)
void Game::DrawPlayerInformation(const PlayerInformation &info, int offset_x, int offset_y) {
    std::cout << Console::white;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(5 + offset_y)) << std::right << std::setw(6) << info.chain_number;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(7 + offset_y)) << std::right << std::setw(6) << info.max_chain_number;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(9 + offset_y)) << std::right << std::setw(6) << info.score;
    std::cout << Console::GotoXY(X(9 + offset_x), Y(12 + offset_y)) << std::right << std::setw(6) << info.obstacle_number_taken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movq 0xcd6a(%rip), %r13      # 0x10fd0
leaq 0xd057(%rip), %rsi      # 0x112c4
movq %r13, %rdi
callq 0x3e37
leal 0x12(,%r12,2), %r15d
leal 0x5(%r14), %eax
leaq -0x30(%rbp), %r12
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x3e7e
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl $0xffffff4f, %r13d      # imm = 0xFFFFFF4F
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x3470
leal 0x7(%r14), %eax
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq 0xcceb(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
callq 0x3e7e
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x3470
leal 0x9(%r14), %eax
movl %r15d, (%r12)
movl %eax, 0x4(%r12)
movq 0xcc9d(%rip), %rdi      # 0x10fd0
movq %r12, %rsi
callq 0x3e7e
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %r13d, %esi
movl $0x80, %edi
orl %edi, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl (%rbx), %esi
movq %rax, %rdi
callq 0x3470
addl $0xc, %r14d
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
leaq -0x30(%rbp), %rsi
movq 0xcc4c(%rip), %rdi      # 0x10fd0
callq 0x3e7e
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
andl 0x18(%rax,%rdx), %r13d
movl $0x80, %esi
orl %esi, %r13d
movl %r13d, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl $0x6, %edx
movq %rdx, 0x10(%rax,%rcx)
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x3470
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: Game::Draw(std::shared_ptr<Board> const&, std::shared_ptr<BiPuyo> const&, PlayerInformation const&, int, int)
void Game::Draw(const std::shared_ptr<Board> &board, const std::shared_ptr<BiPuyo> &bipuyo, const PlayerInformation &info, int offset_x, int offset_y) {
    Game::DrawFrame(offset_x, offset_y);
    Game::DrawBoard(board, offset_x, offset_y);
    Game::DrawNextBiPuyo(bipuyo, offset_x, offset_y);
    Game::DrawPlayerInformation(info, offset_x, offset_y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %ecx, %edi
movl %r8d, %esi
callq 0x3eec
movq (%r13), %rdi
leal 0x1(%r14), %esi
leal 0x1(%rbx), %edx
callq 0x6d24
movq (%r12), %rdi
leal 0xa(%r14), %esi
leal 0x3(%rbx), %edx
callq 0x6e46
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4248
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: SingleGame::GameInit()
bool SingleGame::GameInit() {
    Console::ScreenClear();
    std::cout << Console::GotoXY(X(0), Y(0));
    
    // prepare game
    my_bipuyo_generator = std::make_shared<BiPuyoGenerator>(); // single game doesn't need sync seed
    my_board = std::make_shared<Board>();
    my_board->SetNextBiPuyo(my_bipuyo_generator->GenerateBipuyo());
    my_next_bipuyo = my_bipuyo_generator->GenerateBipuyo();
    
    std::cout << "Loading..." << std::endl;
    Console::Sleep(500);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x3de0
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movq %r12, (%r15)
movq 0xcb7c(%rip), %rbx      # 0x10fd0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e7e
movq %r12, (%r15)
leaq -0x38(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r15, %rsi
callq 0x96ec
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x18(%r14), %rdi
movups %xmm0, 0x10(%r14)
testq %rdi, %rdi
je 0x4490
callq 0x7fac
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x449e
callq 0x7fac
leaq -0x38(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x21(%rbp), %rdx
movq %r15, %rsi
callq 0x9bba
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x28(%r14), %rdi
movups %xmm0, 0x20(%r14)
testq %rdi, %rdi
je 0x44d4
callq 0x7fac
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x44e2
callq 0x7fac
movq 0x20(%r14), %r12
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x6ef2
movq (%r15), %rax
movq %rax, 0x50(%r12)
leaq 0x58(%r12), %rdi
leaq -0x38(%rbp), %r15
movq %r15, %rsi
callq 0x8026
movabsq $0x100000002, %rax      # imm = 0x100000002
movq %rax, 0x60(%r12)
movl $0x0, 0x68(%r12)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4530
callq 0x7fac
movq 0x10(%r14), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x6ef2
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x38(%r14), %rdi
movups %xmm0, 0x30(%r14)
testq %rdi, %rdi
je 0x455e
callq 0x7fac
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x456c
callq 0x7fac
leaq 0x7c7d(%rip), %rsi      # 0xc1f0
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movl $0x1f4, %edi            # imm = 0x1F4
callq 0x3dd0
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: SingleGame::GameResult()
void SingleGame::GameResult() {
    while (kbhit()) getch();
    Console::ScreenClear();
    std::cout << Console::white << Console::GotoXY(0, 0)
        << "게임 끝" << std::endl
        << "점수: " << my_info.score << std::endl
        << "최대 연쇄: " << my_info.max_chain_number << std::endl
        << "메인으로 돌아가려면 아무키나 누르세요" << std::endl;
    getch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3c94
testb %al, %al
je 0x4806
callq 0x3d5f
jmp 0x47f6
callq 0x3de0
movq 0xc7be(%rip), %rdi      # 0x10fd0
leaq 0xcaab(%rip), %rsi      # 0x112c4
callq 0x3e37
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e7e
movq %rax, %r14
leaq 0x79c0(%rip), %rsi      # 0xc1fb
movl $0xa, %edx
movq %rax, %rdi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x79f5(%rip), %rsi      # 0xc26e
movl $0x8, %edx
movq %rax, %rdi
callq 0x3310
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x79b5(%rip), %rsi      # 0xc27a
movl $0xf, %edx
movq %rax, %rdi
callq 0x3310
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x78f5(%rip), %rsi      # 0xc206
movl $0x36, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
callq 0x3d5f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSGame::GameResult()
void VSGame::GameResult() {
    while (kbhit()) getch();
    Console::ScreenClear();
    std::cout << Console::white << Console::GotoXY(0, 0);
    if (my_board->IsGameOver()) {
        std::cout << "1p가 이겼습니다." << std::endl;
    }
    else {
        std::cout << "2p가 이겼습니다." << std::endl;
    }
    std::cout
        << "1p 점수: " << my_info.score << std::endl
        << "1p 최대 연쇄: " << my_info.max_chain_number << std::endl
        << "2p 점수: " << other_info.score << std::endl
        << "2p 최대 연쇄: " << other_info.max_chain_number << std::endl
        << "메인으로 돌아가려면 아무키나 누르세요" << std::endl;
    getch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3c94
testb %al, %al
je 0x4f1c
callq 0x3d5f
jmp 0x4f0c
callq 0x3de0
movq 0xc0a8(%rip), %r14      # 0x10fd0
leaq 0xc395(%rip), %rsi      # 0x112c4
movq %r14, %rdi
callq 0x3e37
leaq -0x18(%rbp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x3e7e
movq 0x20(%rbx), %rax
cmpl $0x6, 0x68(%rax)
leaq 0x72e4(%rip), %rax      # 0xc23d
leaq 0x72f4(%rip), %rsi      # 0xc254
cmoveq %rax, %rsi
movl $0x16, %edx
movq %r14, %rdi
callq 0x3310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
leaq 0x72cc(%rip), %rsi      # 0xc26b
movl $0xb, %edx
movq %r14, %rdi
callq 0x3310
movl 0x40(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x728c(%rip), %rsi      # 0xc277
movl $0x12, %edx
movq %rax, %rdi
callq 0x3310
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x7253(%rip), %rsi      # 0xc28a
movl $0xb, %edx
movq %rax, %rdi
callq 0x3310
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %r14
leaq 0x7210(%rip), %rsi      # 0xc296
movl $0x12, %edx
movq %rax, %rdi
callq 0x3310
movl 0x88(%rbx), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq %rax, %rbx
leaq 0x7131(%rip), %rsi      # 0xc206
movl $0x36, %edx
movq %rax, %rdi
callq 0x3310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
callq 0x3d5f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSGame::Draw()
void VSGame::Draw() {
    /*
        0                   1                   2 
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
    00  ┌──  ───┐┌───┐  ┌──  ───┐┌───┐ 
     1  │            ││ NEXT │  │            ││ NEXT │ 
     2  │            ││      │  │            ││      │ 
     3  │            ││      │  │            ││      │ 
     4  │            ││      │  │            ││      │ 
     5  │            ││ Chain│  │            ││ Chain│ 
     6  │            ││      │  │            ││      │ 
     7  │            ││MaxChn│  │            ││MaxChn│ 
     8  │            ││      │  │            ││      │ 
     9  │            ││ Score│  │            ││ Score│ 
    10  │            ││      │  │            ││      │ 
     1  │            ││BGM   │  │            ││BGM   │ 
     2  │            ││ObsNum│  │            ││ObsNum│ 
     3  │            ││      │  │            ││      │ 
     4  └──────┘└───┘  └──────┘└───┘ 
    */
    Game::Draw(my_board, my_next_bipuyo, my_info);
    for (int i = 0; i <= 14; i++) {
        std::cout << Console::GotoXY(X(13), Y(i)) << "  ";
    }
    Game::Draw(other_board, other_next_bipuyo, other_info, 14);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rsi
leaq 0x40(%rbx), %rdx
xorl %r13d, %r13d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43ca
movq 0xbe87(%rip), %r14      # 0x10fd0
leaq -0x30(%rbp), %r15
leaq 0x752d(%rip), %r12      # 0xc681
movl $0x1a, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e7e
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3310
incl %r13d
cmpl $0xf, %r13d
jne 0x5154
leaq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rsi
subq $-0x80, %rbx
movq %rbx, %rdx
movl $0xe, %ecx
xorl %r8d, %r8d
callq 0x43ca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Leeingnyo[P]newPuyoC/game.cpp
// Function: VSRemoteGame::Serialize[abi:cxx11]()
std::string VSRemoteGame::Serialize() {
    std::ostringstream data;
    data
        << "G{"
            << "P{" << my_info.Serialize() << "}"
            << "M{" << my_board->Serialize() << "}"
            << "B{" << my_next_bipuyo->Serialize() << "}"
            << "O{" << obstacle_to_send << "}"
        << "}";
    return data.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x3360
leaq 0x62cf(%rip), %rsi      # 0xc6f3
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
leaq 0x62be(%rip), %rsi      # 0xc6f6
leaq -0x1f0(%rbp), %rdi
movl $0x2, %edx
callq 0x3310
leaq 0x40(%r14), %rsi
leaq -0x78(%rbp), %rdi
callq 0x7310
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x1f0(%rbp), %rdi
callq 0x3310
movq %rax, %r15
leaq 0x6285(%rip), %rsi      # 0xc6f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x6273(%rip), %rsi      # 0xc6fb
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movq 0x20(%r14), %rsi
leaq -0x58(%rbp), %rdi
callq 0x7416
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %r15, %rdi
callq 0x3310
movq %rax, %r15
leaq 0x623d(%rip), %rsi      # 0xc6f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x622e(%rip), %rsi      # 0xc6fe
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movq 0x30(%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x758a
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r15, %rdi
callq 0x3310
movq %rax, %r15
leaq 0x61f5(%rip), %rsi      # 0xc6f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x61e9(%rip), %rsi      # 0xc701
movl $0x2, %edx
movq %r15, %rdi
callq 0x3310
movl 0xa0(%r14), %esi
movq %r15, %rdi
callq 0x3470
movq %rax, %r14
leaq 0x61bb(%rip), %rsi      # 0xc6f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x3310
leaq 0x61a7(%rip), %rsi      # 0xc6f9
movl $0x1, %edx
movq %r14, %rdi
callq 0x3310
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6571
callq 0x3260
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6583
callq 0x3260
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6595
callq 0x3260
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x3410
movq 0xaa15(%rip), %rsi      # 0x10fc0
leaq -0x1f0(%rbp), %rdi
callq 0x3180
leaq -0x180(%rbp), %rdi
callq 0x30f0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65da
jmp 0x65e4
jmp 0x65df
movq %rax, %rbx
jmp 0x65fe
movq %rax, %rbx
jmp 0x6622
movq %rax, %rbx
jmp 0x6610
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65fe
callq 0x3260
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6610
callq 0x3260
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6622
callq 0x3260
movq 0xa997(%rip), %rsi      # 0x10fc0
leaq -0x1f0(%rbp), %rdi
callq 0x3180
leaq -0x180(%rbp), %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x3480
nop