LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::build_vxl_vec(nw::Standard_Ipt::xml_evt* const&)
vector<_Voxel*> Standard_Ipt::build_vxl_vec(xml_evt* const& evt){
	vector<_Voxel*> act_vvc;

	if(evt->xml_vxl[0] == -1){
		return vvc;
	}

	for(size_t i = 0; i < evt->xml_vxl.size(); ++i){
		act_vvc.push_back(vvc[evt->xml_vxl[i]]);
	}
	return act_vvc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq (%rdx), %rcx
movq 0x30(%rcx), %rax
addq $0x468, %r14            # imm = 0x468
cmpq $-0x1, (%rax)
je 0x8e4d
movq %rdx, %r15
xorl %r13d, %r13d
movq %rsp, %r12
movq 0x38(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x8e2e
movq (%rax,%r13,8), %rsi
shlq $0x3, %rsi
addq (%r14), %rsi
movq %r12, %rdi
callq 0x9258
incq %r13
movq (%r15), %rcx
movq 0x30(%rcx), %rax
jmp 0x8dff
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
jmp 0x8e58
movq %rbx, %rdi
movq %r14, %rsi
callq 0x92fa
movq %rsp, %rdi
callq 0xa324
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8e73
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa324
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/../System/../Events/../Voxel/_Voxel.h
// Function: nw::_Voxel::_Voxel(long, double, std::vector<nw::_Species*, std::allocator<nw::_Species*>>)
_Voxel(long id, double box_length, SpeciesVector state_vec):
		id(id),
		box_length(box_length),
		dirty_flag(true),
		state_vec(state_vec){
		// convert m^3 to liter (factor 1e3)
		this->volume = pow(this->box_length,3)*1e3;
		// set the number of molecules of all species
		for (long i = 0; i < (long)state_vec.size();i++) {
			this->state_vec[i]->set_n_molecules(this->volume);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x24ef4(%rip), %rax     # 0x2ea70
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movsd %xmm0, 0x10(%rdi)
movb $0x1, 0x20(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x9b18
leaq 0x40(%r15), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r15)
andq $0x0, 0x50(%r15)
movsd 0x10(%r15), %xmm0
movsd 0x146f6(%rip), %xmm1    # 0x1e2b0
callq 0x44e0
mulsd 0x146f1(%rip), %xmm0    # 0x1e2b8
movsd %xmm0, 0x18(%r15)
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r13
jge 0x9bf9
movq 0x28(%r15), %rax
movq (%rax,%r13,8), %rdi
movsd 0x18(%r15), %xmm0
movq (%rdi), %rax
callq *0x28(%rax)
incq %r13
jmp 0x9bd0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0xa324
movq %r14, %rdi
callq 0x9c1e
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Input/../System/../Events/_Event.h
// Function: nw::_Event::_Event(long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, std::vector<nw::_Voxel*, std::allocator<nw::_Voxel*>>, nw::Uni_Rnd*)
_Event(long id, string name, double k, VoxelVector vvc, Uni_Rnd* rg):
		id(id),
		name(name),
		k(k),
		rg(rg),
		dirty_flag(true){

//		add self-reference to dependency list.
		this->dep_list.push_back(this);
//		check if all voxel in the assigned voxel vector have the same size
		for (size_t i = 0; i < tv_vec.size(); i++){
			if(vvc[i]->get_volume() != vvc[0]->get_volume()){
				cout << "ERROR: Voxel sizes in Event: " << this->name << " differ in size. "
						"You either have to create another Event or resize the voxel to one size"
						<< std::endl;
				break;
			}
		}

//		create the tau voxel structure container that assigns a tau value to each _Voxel
//		in the _Voxel vector
		tv_vec.resize(vvc.size());
		for(size_t i = 0; i < tv_vec.size(); i++){
			tv_vec[i].v = vvc[i];
			tv_vec[i].t = 0.0;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r13
movq %rcx, %rbx
movsd %xmm0, (%rsp)
movq %rdi, %r14
leaq 0x24a66(%rip), %rax     # 0x2e7c8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4380
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%r14)
leaq 0x50(%r14), %r12
xorpd %xmm0, %xmm0
movupd %xmm0, 0x38(%r14)
movupd %xmm0, 0x48(%r14)
movupd %xmm0, 0x58(%r14)
movq %r13, 0x68(%r14)
movb $0x1, 0x80(%r14)
andq $0x0, 0x98(%r14)
leaq 0x88(%r14), %r13
movupd %xmm0, 0x88(%r14)
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %r13, %rdi
callq 0x9fb8
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
sarq $0x4, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x9e34
movq (%rbx), %rdx
movq (%rdx,%rcx,8), %rsi
movsd 0x18(%rsi), %xmm0
movq (%rdx), %rdx
incq %rcx
ucomisd 0x18(%rdx), %xmm0
jne 0x9dff
jnp 0x9ddf
movq 0x251c2(%rip), %rdi     # 0x2efc8
leaq 0x14a2f(%rip), %rsi     # 0x1e83c
callq 0x4240
movq %rax, %rdi
movq %r15, %rsi
callq 0x4210
leaq 0x14a36(%rip), %rsi     # 0x1e85a
movq %rax, %rdi
callq 0x4240
movq %rax, %rdi
callq 0x4100
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x3, %rsi
movq %r12, %rdi
callq 0x9f84
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x8, %rax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x9e79
movq (%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
movq %rsi, -0x8(%rax)
andq $0x0, (%rax)
incq %rdx
addq $0x10, %rax
jmp 0x9e5c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9e8b
jmp 0x9e8b
movq %rax, %rbx
addq $0x38, %r14
movq %r13, %rdi
callq 0x4bc4
movq %r12, %rdi
callq 0x4bf8
movq %r14, %rdi
callq 0x4b54
movq %r15, %rdi
callq 0x4568
movq %rbx, %rdi
callq 0x44f0
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Random/Uni_Rnd.cpp
// Function: nw::Uni_Rnd::uni_Rnd(long*)
double Uni_Rnd::uni_Rnd(long* idum){

	int j;
	long k;
	static long iy=0;
	static long iv[NTAB];
	double temp;
//	Initialize.
	if (*idum <= 0 || !iy){
// 		Make sure to prevent idum = 0.
		if (-(*idum) < 1) *idum=1;
		else *idum = -(*idum);
//		Load the shuffle table (after 8 warm-ups).
		for (j=NTAB+7;j>=0;j--){
			k=(*idum)/IQ;
			*idum=IA*(*idum-k*IQ)-IR*k;
			if (*idum < 0) *idum += IM;
			if (j < NTAB) iv[j] = *idum;
		}
	   iy=iv[0];
	}
// 	Start here when not initializing.
	k=(*idum)/IQ;
// 	Compute idum=(IA*idum) % IM without over
	*idum=IA*(*idum-k*IQ)-IR*k;

// 	flows by Schrage's method.
	if (*idum < 0) *idum += IM;

// 	Will be in the range 0..NTAB-1.
	j=iy/NDIV;
//  Output previously stored value and refill the
	iy=iv[j];
//	shuffle table.
	iv[j] = *idum;

// 	Because users don't expect endpoint values.
	if ((temp=AM*iy) > RNMX) return RNMX;
	else return temp;
}

// Assembly:
movq (%rsi), %rcx
testq %rcx, %rcx
setg %al
movq 0x240ac(%rip), %rdi     # 0x2f328
testq %rdi, %rdi
setne %dl
testb %dl, %al
jne 0xb2f2
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
pushq $0x1
popq %rcx
cmovsq %rax, %rcx
pushq $0x27
popq %rdi
movl $0x1f31d, %r8d          # imm = 0x1F31D
leaq 0x2408a(%rip), %r9      # 0x2f330
testl %edi, %edi
js 0xb2eb
movq %rcx, %rax
cqto
idivq %r8
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rdx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rdx,%rax), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rax, %rdx
cmovnsq %rdx, %rcx
cmpl $0x1f, %edi
ja 0xb2e7
movl %edi, %eax
movq %rcx, (%r9,%rax,8)
decl %edi
jmp 0xb2a6
movq 0x2403e(%rip), %rdi     # 0x2f330
movl $0x1f31d, %r8d          # imm = 0x1F31D
movq %rcx, %rax
cqto
idivq %r8
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rcx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rcx,%rax), %r8
addq $0x7fffffff, %r8        # imm = 0x7FFFFFFF
addq %rax, %rcx
cmovnsq %rcx, %r8
movq %r8, (%rsi)
movl $0x4000000, %ecx        # imm = 0x4000000
movq %rdi, %rax
cqto
idivq %rcx
cltq
leaq 0x23fed(%rip), %rcx     # 0x2f330
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x23fda(%rip)     # 0x2f328
cvtsi2sd %rdx, %xmm1
mulsd 0x135e5(%rip), %xmm1    # 0x1e940
movq %r8, (%rcx,%rax,8)
movsd 0x135e1(%rip), %xmm0    # 0x1e948
minsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/System/Gillespie_Sys.cpp
// Function: nw::Gillespie_Sys::build_dep_graph()
void Gillespie_Sys::build_dep_graph(){

	try{
//		temporary vectors
		vector<long> sc_a, sc_b;

//		find dependency relations based on state change vectors
		for (size_t i = 0; i < evt_vec->size(); ++i){
			sc_a = evt_vec->at(i)->get_sc_vec();
			for (size_t j = 0; j < evt_vec->size(); ++j){
				sc_b = evt_vec->at(j)->get_sc_vec();
				if(evt_vec->at(i) != evt_vec->at(j)){
					for (size_t k = 0; k < sc_a.size(); ++k){
						if(sc_a.at(k) != 0 && sc_b.at(k) < 0 ){
							evt_vec->at(i)->add_dep_list(evt_vec->at(j));
							break;
						}
					}
				}
			}
		}
	}

	catch(exception& e){
		cout << "System::build_dep_graph()" << e.what();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq 0xef0(%rdi), %rdi
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
xorl %esi, %esi
leaq 0x50(%rsp), %r13
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rax, %rsi
jae 0xbb66
movq %rsi, 0x8(%rsp)
callq 0x970e
movq (%rax), %rsi
addq $0x38, %rsi
movq %r13, %rdi
callq 0x525c
movq %r14, %rdi
movq %r13, %rsi
callq 0xc612
movq %r13, %rdi
callq 0x4b54
xorl %ebp, %ebp
movq 0xef0(%rbx), %rdi
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rbp
jae 0xbb59
movq %rbp, %rsi
callq 0x970e
movq (%rax), %rsi
addq $0x38, %rsi
movq %r13, %rdi
callq 0x525c
movq %r15, %rdi
movq %r13, %rsi
callq 0xc612
movq %r13, %rdi
callq 0x4b54
movq 0xef0(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x970e
movq (%rax), %r12
movq 0xef0(%rbx), %rdi
movq %rbp, %rsi
callq 0x970e
cmpq (%rax), %r12
je 0xbb51
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0xbb51
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ae8
cmpq $0x0, (%rax)
je 0xbb1e
movq %r15, %rdi
movq %r12, %rsi
callq 0x4ae8
cmpq $0x0, (%rax)
js 0xbb23
incq %r12
jmp 0xbae9
movq 0xef0(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x970e
movq (%rax), %r12
movq 0xef0(%rbx), %rdi
movq %rbp, %rsi
callq 0x970e
movq (%rax), %rsi
movq %r12, %rdi
callq 0xc51c
incq %rbp
jmp 0xba73
movq 0x8(%rsp), %rsi
incq %rsi
jmp 0xba35
leaq 0x30(%rsp), %rdi
callq 0x4b54
leaq 0x10(%rsp), %rdi
callq 0x4b54
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb91
jmp 0xbb91
jmp 0xbb91
jmp 0xbb91
movq %rdx, %r14
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4b54
leaq 0x10(%rsp), %rdi
callq 0x4b54
cmpl $0x1, %r14d
jne 0xbbf5
movq %rbx, %rdi
callq 0x40e0
movq %rax, %rbx
movq 0x23405(%rip), %rdi     # 0x2efc8
leaq 0x12eed(%rip), %rsi     # 0x1eab7
callq 0x4240
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4240
callq 0x4480
jmp 0xbb7a
movq %rax, %rbx
callq 0x4480
movq %rbx, %rdi
callq 0x44f0
movq %rax, %rdi
callq 0x4b49
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/System/Gillespie_Sys.cpp
// Function: nw::Gillespie_Sys::print_system_state()
void Gillespie_Sys::print_system_state(){

//	print current system state
	cout << "---System State---\n";
	info_output_file << "---System State---\n";
	for (long i = 0; i < (long)vxl_vec->size();i++){
		cout << "Voxel " << i << ": ";
		info_output_file << "Voxel " << i << ": ";
		for (long j = 0; j < (long)vxl_vec->at(i)->get_state_vec()->size(); j++){
			cout << vxl_vec->at(i)->get_state_vec()->at(j)->get_n_molecules() << ",";
			info_output_file << vxl_vec->at(i)->get_state_vec()->at(j)->get_n_molecules() << ",";
		}
		cout << endl;
		info_output_file << endl;
	}
	cout << "------------------\n";
	info_output_file << "------------------\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x22df3(%rip), %r15     # 0x2efc8
leaq 0x128f5(%rip), %r12     # 0x1ead1
movq %r15, %rdi
movq %r12, %rsi
callq 0x4240
leaq 0x890(%r14), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4240
xorl %r12d, %r12d
leaq 0x121f1(%rip), %r13     # 0x1e3f4
movq 0xef8(%r14), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jge 0xc332
movq %r15, %rdi
leaq 0x128bd(%rip), %rbp     # 0x1eae5
movq %rbp, %rsi
callq 0x4240
movq %rax, %rdi
movq %r12, %rsi
callq 0x4230
movq %rax, %rdi
leaq 0x11f0a(%rip), %rsi     # 0x1e14f
callq 0x4240
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4240
movq %rax, %rdi
movq %r12, %rsi
callq 0x4230
movq %rax, %rdi
leaq 0x11ee5(%rip), %rsi     # 0x1e14f
callq 0x4240
xorl %ebp, %ebp
movq 0xef8(%r14), %rdi
movq %r12, %rsi
callq 0x52aa
movq (%rax), %rax
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
jge 0xc31a
movq 0xef8(%r14), %rdi
movq %r12, %rsi
callq 0x52aa
movq (%rax), %rdi
addq $0x28, %rdi
movq %rbp, %rsi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x4230
movq %rax, %rdi
movq %r13, %rsi
callq 0x4240
movq 0xef8(%r14), %rdi
movq %r12, %rsi
callq 0x52aa
movq (%rax), %rdi
addq $0x28, %rdi
movq %rbp, %rsi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4230
movq %rax, %rdi
movq %r13, %rsi
callq 0x4240
incq %rbp
jmp 0xc271
movq %r15, %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4100
incq %r12
jmp 0xc203
movq 0x22c8f(%rip), %rdi     # 0x2efc8
leaq 0x127ac(%rip), %r14     # 0x1eaec
movq %r14, %rsi
callq 0x4240
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4240
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/System/Gillespie_Sys.cpp
// Function: nw::Gillespie_Sys::system_output()
inline void Gillespie_Sys::system_output(){
//	print system state with a fixed time step dt (recording interval)
	if (rec_time >= rec_interval){
//			run through output voxel vector
			for(size_t k = 0; k < ovid.size(); ++k){
//				run through output species id vector
				for(size_t i = 0; i < osid.size(); ++i){
					data_output_file<<	vxl_vec->at(ovid[k])->get_state_vec()
										->at(osid[i])->get_n_molecules() << ",";
				}
			}
		if (this->output_mode == 2){
			data_output_file << curr_time << ",";
		}
		opcntr++;
		rec_time -= rec_interval;
	}

//	check if the channel state changed and if so log the open and close times
	if(	vxl_vec->at(0)->get_state_vec()->at(vxl_vec->at(0)
		->get_state_vec()->size()-1)->get_n_molecules() != channel_state){
//		update current channel state
		channel_state = vxl_vec->at(0)->get_state_vec()->at(vxl_vec->at(0)
						->get_state_vec()->size() - 1)->get_n_molecules();
//		write current system time to oc_log.e
		oc_log_file << curr_time << ",";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movsd 0x40(%rdi), %xmm0
ucomisd 0x30(%rdi), %xmm0
jb 0xc450
leaq 0x690(%rbx), %r14
xorl %r12d, %r12d
leaq 0x12065(%rip), %r15     # 0x1e3f4
movq 0xee0(%rbx), %rax
subq 0xed8(%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0xc41a
xorl %r13d, %r13d
movq 0xec8(%rbx), %rax
subq 0xec0(%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0xc412
movq 0xed8(%rbx), %rax
movq 0xef8(%rbx), %rdi
movq (%rax,%r12,8), %rsi
callq 0x52aa
movq (%rax), %rdi
addq $0x28, %rdi
movq 0xec0(%rbx), %rax
movq (%rax,%r13,8), %rsi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x4230
movq %rax, %rdi
movq %r15, %rsi
callq 0x4240
incq %r13
jmp 0xc3a9
incq %r12
jmp 0xc38f
cmpq $0x2, 0x8(%rbx)
jne 0xc43d
movsd 0x38(%rbx), %xmm0
movq %r14, %rdi
callq 0x4460
leaq 0x11fbf(%rip), %rsi     # 0x1e3f4
movq %rax, %rdi
callq 0x4240
incq 0x18(%rbx)
movsd 0x40(%rbx), %xmm0
subsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x40(%rbx)
movq 0xef8(%rbx), %rdi
xorl %esi, %esi
callq 0x52aa
movq (%rax), %r14
addq $0x28, %r14
movq 0xef8(%rbx), %rdi
xorl %esi, %esi
callq 0x52aa
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
decq %rsi
movq %r14, %rdi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq 0x20(%rbx), %rax
jne 0xc4a6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xef8(%rbx), %rdi
xorl %esi, %esi
callq 0x52aa
movq (%rax), %r14
addq $0x28, %r14
movq 0xef8(%rbx), %rdi
xorl %esi, %esi
callq 0x52aa
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
decq %rsi
movq %r14, %rdi
callq 0x4ac6
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x20(%rbx)
movsd 0x38(%rbx), %xmm0
addq $0xa90, %rbx            # imm = 0xA90
movq %rbx, %rdi
callq 0x4460
leaq 0x11ee9(%rip), %rsi     # 0x1e3f4
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Voxel/Border_Vxl.cpp
// Function: nw::Border_Vxl::update_state(std::vector<long, std::allocator<long>>)
void Border_Vxl::update_state(vector<long> sc_vec)
{
	this->dirty_flag = true;

//	do not update the state vector of Border_vxl!
	for (size_t i = 0; i < sc_vec.size(); ++i) {
		if (sc_vec[i] != 0) {
			state_vec[i]->set_dirty_flag(true);
		}
	}
}

// Assembly:
movb $0x1, 0x20(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x28(%rdi), %rdx
xorl %esi, %esi
cmpq %rcx, %rsi
jae 0xc679
cmpq $0x0, (%rax,%rsi,8)
je 0xc674
movq (%rdx,%rsi,8), %rdi
movb $0x1, 0x30(%rdi)
incq %rsi
jmp 0xc660
retq
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/Voxel/Standard_Vxl.cpp
// Function: nw::Standard_Vxl::update_state(std::vector<long, std::allocator<long>>)
void Standard_Vxl::update_state(vector<long> sc_vec)
{
	if (sc_vec.size() == state_vec.size()) {
	//	update the state vector of voxel using the assigned state change vector
		for (size_t i = 0; i < state_vec.size(); ++i) {
			state_vec[i]->mod_n_molecules(sc_vec[i]);
		}
		this->dirty_flag = true;
	} else {
	//	Debug information: Throw error if sc_vec.size() != state_vec
		cout << "ERROR: state change vector and state vector differ in size";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rsi, %rdx
jne 0xc6ec
movq %rdi, %rbx
xorl %r15d, %r15d
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jae 0xc6e2
movq (%rax,%r15,8), %rdi
movq (%r14), %rax
movq (%rax,%r15,8), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
incq %r15
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
jmp 0xc6b8
movb $0x1, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x228d5(%rip), %rdi     # 0x2efc8
leaq 0x1243b(%rip), %rsi     # 0x1eb35
popq %rbx
popq %r14
popq %r15
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/main/execSim.cpp
// Function: main
int main(int argc, char* argv[]){
/* argv[1]: Input file path (string)
 * argv[2]: output directory (string)
 * argv[3]: number of iterations (int)
 * */
  
	for (int i = 1; i <= atoi(argv[3]); i++){ // 3. Number of iterations
		_Input *ipt = new Standard_Ipt(argv[1],argv[2]); //1. Input File path 2. Output directory
		ipt->get_System()->go(i);
//		Release memory!
		if(ipt){delete ipt;ipt = NULL;}
//		Sleep for two seconds to get new seed for random generator
		sleep(2);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
pushq $0x1
popq %r14
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %rbp
pushq $0x2
popq %r13
movq 0x18(%rbx), %rdi
callq 0x4430
cltq
cmpq %rax, %r14
jg 0xc7ca
movl $0x498, %edi            # imm = 0x498
callq 0x4260
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x8e86
movq 0x10(%rbx), %rsi
movq %rbp, %rdi
leaq 0x6(%rsp), %rdx
callq 0x8e86
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xc812
movq %rbp, %rdi
callq 0x4568
movq %r12, %rdi
callq 0x4568
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x10(%rcx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl %r13d, %edi
callq 0x41b0
incq %r14
jmp 0xc73f
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc7fc
movq %rax, %rbx
jmp 0xc7f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4568
leaq 0x28(%rsp), %rdi
callq 0x4568
movl $0x498, %esi            # imm = 0x498
movq %r15, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/main/../Input/Standard_Ipt.h
// Function: nw::Standard_Ipt::Standard_Ipt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Standard_Ipt(string input_path, string output_dir_path){
		this->p = (char*)input_path.c_str();
		xml_parse_result result = doc.load_file(p); // load xml file
		this->output_dir_path = output_dir_path;
		rg = new Uni_Rnd();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x2210e(%rip), %rax     # 0x2e938
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rdx, %r13
movb %al, 0x40(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movq %rsi, %r14
leaq 0x10(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movb %al, 0x60(%rdi)
addq $0x98, %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x4140
leaq 0x170(%rbx), %r15
movq %r15, %rdi
callq 0x113a0
leaq 0x248(%rbx), %r12
movq %r12, %rdi
callq 0x44b0
leaq 0x450(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x468(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x480(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x480(%rbx)
movups %xmm0, 0x470(%rbx)
andq $0x0, 0x490(%rbx)
movups %xmm0, 0x460(%rbx)
movups %xmm0, 0x450(%rbx)
movq (%r14), %rdx
movq %rdx, 0x240(%rbx)
leaq 0x20(%rsp), %rdi
pushq $0x74
popq %rcx
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x11fc4
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4130
pushq $0x18
popq %rdi
callq 0x4260
movq %rax, %r14
movq %rax, %rdi
callq 0xc994
movq %r14, 0x448(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0xc96d
movq %rax, %r13
jmp 0xc975
movq %rax, %r13
movq %rbp, %rdi
callq 0x9c1e
movq 0x10(%rsp), %rdi
callq 0xa324
movq 0x18(%rsp), %rdi
callq 0x4bc4
movq %r12, %rdi
callq 0x43f0
movq %r15, %rdi
callq 0x1142a
addq $0x30, %rbx
movq %rbx, %rdi
callq 0x8f16
movq 0x8(%rsp), %rdi
callq 0x4568
movq %r13, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/nwieder[P]SSTS/src/pugi/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_tree(pugi::xml_node_struct*, pugi::xml_node_struct*)
PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn)
	{
		xml_allocator& alloc = get_allocator(dn);
		xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;

		node_copy_contents(dn, sn, shared_alloc);

		xml_node_struct* dit = dn;
		xml_node_struct* sit = sn->first_child;

		while (sit && sit != sn)
		{
			// when a tree is copied into one of the descendants, we need to skip that subtree to avoid an infinite loop
			if (sit != dn)
			{
				xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));

				if (copy)
				{
					node_copy_contents(copy, sit, shared_alloc);

					if (sit->first_child)
					{
						dit = copy;
						sit = sit->first_child;
						continue;
					}
				}
			}

			// continue to the next node
			do
			{
				if (sit->next_sibling)
				{
					sit = sit->next_sibling;
					break;
				}

				sit = sit->parent;
				dit = dit->parent;
			}
			while (sit != sn);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd939
movq %rax, %r15
movq %rbx, %rdi
callq 0xd939
xorl %edx, %edx
cmpq %rax, %r15
cmoveq %r15, %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %rdx, (%rsp)
callq 0x1773b
movq 0x20(%rbx), %rax
movq %r14, %r13
testq %rax, %rax
je 0xe32a
movq %rax, %rbp
cmpq %rbx, %rax
je 0xe32a
movq %r13, %r12
cmpq %r14, %rbp
je 0xe307
movl (%rbp), %edx
andl $0xf, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x177fd
testq %rax, %rax
je 0xe307
movq %rax, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq (%rsp), %rdx
callq 0x1773b
movq 0x20(%rbp), %rax
testq %rax, %rax
jne 0xe2c1
movq %rbp, %rax
movq %r12, %r13
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0xe325
movq 0x18(%rax), %rax
movq 0x18(%r13), %r13
cmpq %rbx, %rax
jne 0xe30d
jmp 0xe2c1
movq %rcx, %rax
jmp 0xe2c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sotrteacher[P]1MM1INTRO/20190906_1MM1_INTRO_pista_prac01/segundos_a_formato.c
// Function: main
int main(int argc,char *argv[])
{
  int S,s,m,h;
  printf("Segundos: ");
  scanf("%d",&S);
  (!(S/60))?printf("%s:%s:%.2d\n","00","00",S):
((S/60)<60)?printf("%s:%.2d:%.2d\n","00",S/60,S%60):
printf("%.2d:%.2d:%.2d\n",S/3600,(S%3600)/60,(S%3600)%60);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xeab(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xea8(%rip), %rdi       # 0x200f
leaq -0xc(%rbp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movl (%rbx), %ecx
pushq $0x3c
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %r8d
leal 0x3b(%rcx), %edx
cmpl $0x76, %edx
ja 0x11a4
leaq 0xe81(%rip), %rdi       # 0x2012
leaq 0xe86(%rip), %rdx       # 0x201e
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x11f6
cmpl $0xe0f, %ecx            # imm = 0xE0F
jg 0x11c8
leaq 0xe6e(%rip), %rdi       # 0x2021
leaq 0xe64(%rip), %rsi       # 0x201e
movl %eax, %edx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x1030
jmp 0x11f6
movl $0xe10, %esi            # imm = 0xE10
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %eax, %esi
movl %edx, %eax
movw $0x3c, %cx
xorl %edx, %edx
divw %cx
movzwl %ax, %eax
movzwl %dx, %ecx
leaq 0xe42(%rip), %rdi       # 0x202f
movl %eax, %edx
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/main.cpp
// Function: main
int main(void) {
	Score S;
	S.fileread();
	int ch;
	while(1) {
		ch=show_menu();
		switch(ch) {
			case 1:
				S.addscore(classic_game());
				break;
			case 2:
				fun_snake_game();
				break;
			case 3:
				S.showscores();
				break;
			case 4:
				S.filewrite();
				endwin();
				return 0;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x38c4
movq %rbx, %rdi
callq 0x3956
leaq 0x2b65(%rip), %r14      # 0x5004
callq 0x3bb4
decl %eax
cmpl $0x3, %eax
ja 0x249f
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
callq 0x4093
movq %rbx, %rdi
movl %eax, %esi
callq 0x3a0c
jmp 0x249f
movq %rbx, %rdi
callq 0x3a52
jmp 0x249f
callq 0x420c
jmp 0x249f
leaq 0xc(%rsp), %rdi
callq 0x38da
callq 0x21f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::Snake(int)
Snake::Snake(int len) {
	int i;
	Cell temp;
	fdir=RIGHT;
	temp.p.row=0;
	temp.c='@';
	for(i=0; i<len-1; i++) {
		temp.p.col=i;
		cells.push_front(temp);
	}
	temp.c='O';
	temp.p.col=i;
	cells.push_front(temp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x5838(%rip), %rax      # 0x7d40
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2b1a
leaq 0x58(%r15), %r14
movq %r14, %rdi
callq 0x2d3e
pushq $0x1
popq %r12
movl %r12d, 0xa8(%r15)
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
movb $0x40, 0x8(%r15)
cmpl $0x2, %ebp
cmovgel %ebp, %r12d
decl %r12d
xorl %ebp, %ebp
cmpl %ebp, %r12d
je 0x2560
movl %ebp, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29f8
incl %ebp
jmp 0x2548
leaq 0x4(%rsp), %rsi
movb $0x4f, 0x8(%rsi)
movl %r12d, 0x4(%rsi)
movq %rbx, %rdi
callq 0x29f8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2589
movq %rax, %r15
jmp 0x2594
movq %rax, %r15
movq %r14, %rdi
callq 0x2f86
movq %rbx, %rdi
callq 0x2f58
movq %r15, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::createNode(int)
void Snake::createNode(int d) {
		fdir=d;
		Node n;
		n.p.row=cells.front().p.row;
		n.p.col=cells.front().p.col;
		n.dir=d;
		nodes.push_back(n);
	}

// Assembly:
subq $0x18, %rsp
movl %esi, 0xa8(%rdi)
movq 0x18(%rdi), %rax
movq (%rax), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl %esi, 0x8(%rax)
addq $0x58, %rdi
movq %rax, %rsi
callq 0x2a1a
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::render()
void Snake::render(void) {
		erase();
		for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
			mvaddch(it->p.row, it->p.col, it->c);
		}
		refresh();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x21b0
movq 0x18(%rbx), %r14
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %r15
movq 0x59e2(%rip), %r12      # 0x7fd8
cmpq 0x38(%rbx), %r14
je 0x2639
movq (%r12), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
callq 0x21a0
cmpl $-0x1, %eax
je 0x261f
movq (%r12), %rdi
movsbl 0x8(%r14), %esi
callq 0x2090
addq $0xc, %r14
cmpq %r13, %r14
jne 0x25f6
movq 0x8(%r15), %r14
addq $0x8, %r15
leaq 0x1f8(%r14), %r13
jmp 0x25f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::movesnake()
void Snake::movesnake(void) {
		Point f, b;
		Cell temp;
		f=cells.front().p;
		b=cells.back().p;
		cells.front().c='@';
		switch(fdir) {
			case UP:
				f.row=getrow(f.row-1);
				break;
			case DOWN:
				f.row=getrow(f.row+1);
				break;
			case RIGHT:
				f.col=getcol(f.col+1);
				break;
			case LEFT:
				f.col=getcol(f.col-1);
				break;
		}
		temp.p=f;
		temp.c='O';
		cells.push_front(temp);
		if(!nodes.empty()) {
			if(b.row==nodes.front().p.row && b.col==nodes.front().p.col) {
				nodes.pop_front();
			}
		}
		cells.pop_back();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x38(%rdi), %rcx
cmpq 0x40(%rdi), %rcx
jne 0x2674
movq 0x50(%rbx), %rdx
movl $0x1f8, %ecx            # imm = 0x1F8
addq -0x8(%rdx), %rcx
leaq 0x8(%rbx), %r14
movl (%rax), %ebp
movl 0x4(%rax), %r15d
movl -0xc(%rcx), %r13d
movl -0x8(%rcx), %r12d
movb $0x40, 0x8(%rax)
movl 0xa8(%rbx), %eax
cmpq $0x3, %rax
ja 0x26ca
leaq 0x2977(%rip), %rcx      # 0x5014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
decl %ebp
jmp 0x26ac
incl %ebp
movl %ebp, %edi
callq 0x4415
movl %eax, %ebp
jmp 0x26ca
decl %r15d
jmp 0x26bf
incl %r15d
movl %r15d, %edi
callq 0x4428
movl %eax, %r15d
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movl %r15d, 0x4(%rsi)
movb $0x4f, 0x8(%rsi)
movq %r14, %rdi
callq 0x29f8
movq 0x68(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x2705
cmpl (%rax), %r13d
jne 0x2705
cmpl 0x4(%rax), %r12d
jne 0x2705
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x2a42
movq %r14, %rdi
callq 0x2a60
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::Classic_Snake()
Classic_Snake::Classic_Snake():Snake(2) {
	T.p.row=12;
	T.p.col=39;
	T.points=1;
	T.c='&';
	score=0;
	coll=0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x24f0
leaq 0x5621(%rip), %rax      # 0x7d60
movq %rax, (%rbx)
movabsq $0x270000000c, %rax     # imm = 0x270000000C
movq %rax, 0xb4(%rbx)
movl $0x1, 0xbc(%rbx)
movb $0x26, 0xc0(%rbx)
andq $0x0, 0xac(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::movesnake()
void Classic_Snake::movesnake(void) {
	Point f, b;
	Cell temp;
	f=cells.front().p;
	b=cells.back().p;
	cells.front().c='@';
	switch(fdir) {
		case UP:
			f.row=getrow(f.row-1);
			break;
		case DOWN:
			f.row=getrow(f.row+1);
			break;
		case RIGHT:
			f.col=getcol(f.col+1);
			break;
		case LEFT:
			f.col=getcol(f.col-1);
			break;
	}
	temp.p=f;
	temp.c='O';
	cells.push_front(temp);
	if(collide()) {
		coll=1;
		return;
	}
	if(cells.front().p.row!=T.p.row || cells.front().p.col!=T.p.col) {
		if(!nodes.empty()) {
			if(b.row==nodes.front().p.row && b.col==nodes.front().p.col) {
				nodes.pop_front();
			}
		}
		cells.pop_back();
	}
	else {
		score+=T.points;
		addtreat();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x38(%rdi), %rcx
cmpq 0x40(%rdi), %rcx
jne 0x2802
movq 0x50(%rbx), %rdx
movl $0x1f8, %ecx            # imm = 0x1F8
addq -0x8(%rdx), %rcx
leaq 0x8(%rbx), %r14
movl (%rax), %ebp
movl 0x4(%rax), %r15d
movl -0xc(%rcx), %r13d
movl -0x8(%rcx), %r12d
movb $0x40, 0x8(%rax)
movl 0xa8(%rbx), %eax
cmpq $0x3, %rax
ja 0x2858
leaq 0x27f9(%rip), %rcx      # 0x5024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
decl %ebp
jmp 0x283a
incl %ebp
movl %ebp, %edi
callq 0x4415
movl %eax, %ebp
jmp 0x2858
decl %r15d
jmp 0x284d
incl %r15d
movl %r15d, %edi
callq 0x4428
movl %eax, %r15d
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movl %r15d, 0x4(%rsi)
movb $0x4f, 0x8(%rsi)
movq %r14, %rdi
callq 0x29f8
movq %rbx, %rdi
callq 0x28f2
testl %eax, %eax
je 0x2887
movl $0x1, 0xb0(%rbx)
jmp 0x28e2
movq 0x18(%rbx), %rax
movl (%rax), %ecx
cmpl 0xb4(%rbx), %ecx
jne 0x28b6
movl 0x4(%rax), %eax
cmpl 0xb8(%rbx), %eax
jne 0x28b6
movl 0xbc(%rbx), %eax
addl %eax, 0xac(%rbx)
movq %rbx, %rdi
callq 0x276e
jmp 0x28e2
movq 0x68(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x28da
cmpl (%rax), %r13d
jne 0x28da
cmpl 0x4(%rax), %r12d
jne 0x28da
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x2a42
movq %r14, %rdi
callq 0x2a60
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::render()
void Classic_Snake::render(void) {
	erase();
	for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
		mvaddch(it->p.row, it->p.col, it->c);
	}
	mvaddch(T.p.row, T.p.col, T.c);
	refresh();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x21b0
movq 0x18(%rbx), %r15
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %r12
movq 0x5666(%rip), %r14      # 0x7fd8
movq (%r14), %rdi
cmpq 0x38(%rbx), %r15
je 0x29b4
movl (%r15), %esi
movl 0x4(%r15), %edx
callq 0x21a0
cmpl $-0x1, %eax
je 0x2999
movq (%r14), %rdi
movsbl 0x8(%r15), %esi
callq 0x2090
addq $0xc, %r15
cmpq %r13, %r15
jne 0x2972
movq 0x8(%r12), %r15
addq $0x8, %r12
leaq 0x1f8(%r15), %r13
jmp 0x2972
movl 0xb4(%rbx), %esi
movl 0xb8(%rbx), %edx
callq 0x21a0
cmpl $-0x1, %eax
je 0x29d9
movq (%r14), %rdi
movsbl 0xc0(%rbx), %esi
callq 0x2090
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::filewrite()
void Score::filewrite() {
  std::ofstream file;
  if(head>-1) {
    if(file.is_open()) {
      file.close();
    }
    file.open(FILE_NAME, std::ios::trunc | std::ios::binary);
    file.write((char *)this, sizeof(Score));
    file.close();
  }
}

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x22b0
cmpl $0x0, 0x38(%rbx)
js 0x3931
leaq 0x70(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x3909
movq %rsp, %rdi
callq 0x2240
leaq 0x176b(%rip), %rsi      # 0x507b
movq %rsp, %rdi
pushq $0x24
popq %rdx
callq 0x2030
movq %rsp, %rdi
pushq $0x3c
popq %rdx
movq %rbx, %rsi
callq 0x2230
movq %rsp, %rdi
callq 0x2240
movq %rsp, %rdi
callq 0x2260
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::fileread()
void Score::fileread() {
  std::ifstream file;
  file.open(FILE_NAME, std::ios::in | std::ios::binary);
  if(file.is_open()) {
    file.read((char *)this, sizeof(Score));
  }
  file.close();
  sortscore();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x21c0
leaq 0x1706(%rip), %rsi      # 0x507b
pushq $0xc
popq %rdx
movq %r14, %rdi
callq 0x2110
leaq 0x78(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x399c
movq %rsp, %rdi
pushq $0x3c
popq %rdx
movq %rbx, %rsi
callq 0x2200
movq %rsp, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x39d2
movq %rsp, %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::sortscore()
void Score::sortscore(void) {
  int temp;
  if(head>0) {
    for(int i=0; i<=head; i++) {
      for(int j=0; j<=head-1; j++) {
        if(scores[j]>scores[j+1]) {
          temp=scores[j+1];
          scores[j+1]=scores[j];
          scores[j]=temp;
        }
      }
    }
  }
}

// Assembly:
movl 0x38(%rdi), %eax
testl %eax, %eax
jle 0x3a0a
xorl %ecx, %ecx
cmpl %eax, %ecx
jg 0x3a0a
xorl %edx, %edx
movslq %eax, %rsi
cmpq %rsi, %rdx
jge 0x3a06
movl (%rdi,%rdx,4), %esi
movl 0x4(%rdi,%rdx,4), %r8d
incq %rdx
cmpl %r8d, %esi
jle 0x39e1
movl %esi, (%rdi,%rdx,4)
movl %r8d, -0x4(%rdi,%rdx,4)
movl 0x38(%rdi), %eax
jmp 0x39e1
incl %ecx
jmp 0x39db
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::addscore(int)
void Score::addscore(int s) {
  sortscore();
  if(head<13) {
    scores[++head]=s;
    sortscore();
  }
  else {
    if(s>scores[0]) {
      scores[0]=s;
      sortscore();
    }
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x39d2
movslq 0x38(%rbx), %rax
cmpq $0xc, %rax
jg 0x3a34
leaq 0x1(%rax), %rcx
movl %ecx, 0x38(%rbx)
leaq (%rbx,%rax,4), %rax
addq $0x4, %rax
jmp 0x3a3b
movq %rbx, %rax
cmpl %ebp, (%rbx)
jge 0x3a4b
movl %ebp, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x39d2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::showscores()
void Score::showscores(void) {
  sortscore();
  erase();
  int ch;
  int t=(23-head-1)/2;
  if(head>-1) {
    for(int i=head, j=0; i>=0; i--,  j++) {
      mvprintw(t+j, 36, "%2d. %2u", j+1, scores[i]);
    }
  }
  attron(A_STANDOUT);
  mvprintw(23, 25, "PRESS 'Q' to EXIT BACK TO MENU.");
  attroff(A_STANDOUT);
  refresh();
  while((ch=getch())!='q');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x39d2
callq 0x21b0
movl 0x38(%rbx), %r13d
pushq $0x16
popq %rax
subl %r13d, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
testl %r13d, %r13d
js 0x3aba
movl %eax, %r14d
pushq $0x1
popq %r15
leaq 0x15f7(%rip), %r12      # 0x5084
pushq $0x24
popq %rbp
cmpl $-0x1, %r13d
je 0x3aba
leal (%r14,%r15), %edi
decl %edi
movl %r13d, %eax
movl (%rbx,%rax,4), %r8d
movl %ebp, %esi
movq %r12, %rdx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2220
decl %r13d
incl %r15d
jmp 0x3a90
movq 0x4517(%rip), %rbx      # 0x7fd8
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x20f0
leaq 0x15b6(%rip), %rdx      # 0x508d
pushq $0x17
popq %rdi
pushq $0x19
popq %rsi
xorl %eax, %eax
callq 0x2220
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x2210
callq 0x22c0
movq (%rbx), %rdi
callq 0x20c0
cmpl $0x71, %eax
jne 0x3af8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: print_snake()
void print_snake(void) {
	mvprintw(0, 14, " $$$$$$\\  $$\\   $$\\  $$$$$$\\  $$\\   $$\\ $$$$$$$$\\\n");
	mvprintw(1, 14, "$$  __$$\\ $$$\\  $$ |$$  __$$\\ $$ | $$  |$$  _____|\n");
	mvprintw(2, 14, "$$ /  \\__|$$$$\\ $$ |$$ /  $$ |$$ |$$  / $$ |\n");
	mvprintw(3, 14, "\\$$$$$$\\  $$ $$\\$$ |$$$$$$$$ |$$$$$  /  $$$$$\\\n");
	mvprintw(4, 14, " \\____$$\\ $$ \\$$$$ |$$  __$$ |$$  $$<   $$  __|\n");
	mvprintw(5, 14, "$$\\   $$ |$$ |\\$$$ |$$ |  $$ |$$ |\\$$\\  $$ |\n");
	mvprintw(6, 14, "\\$$$$$$  |$$ | \\$$ |$$ |  $$ |$$ | \\$$\\ $$$$$$$$\\\n");
	mvprintw(7, 14, " \\______/ \\__|  \\__|\\__|  \\__|\\__|  \\__|\\________|\n");
}

// Assembly:
pushq %rbx
leaq 0x15c7(%rip), %rdx      # 0x50e7
pushq $0xe
popq %rbx
xorl %edi, %edi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x15e5(%rip), %rdx      # 0x511a
pushq $0x1
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x1606(%rip), %rdx      # 0x514e
pushq $0x2
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x1621(%rip), %rdx      # 0x517c
pushq $0x3
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x163e(%rip), %rdx      # 0x51ac
pushq $0x4
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x165c(%rip), %rdx      # 0x51dd
pushq $0x5
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x1677(%rip), %rdx      # 0x520b
pushq $0x6
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2220
leaq 0x1697(%rip), %rdx      # 0x523e
pushq $0x7
popq %rdi
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: classic_game()
int classic_game(void) {
	Classic_Snake S;
	int ch, d;
	initscr();
	keypad(stdscr, TRUE);
	noecho();
	timeout(TIMEOUT);
	curs_set(0);
	while(1) {
		ch=getch();
		if(ch=='q') {
			return S.getscore();
		}
		else if(ch==KEY_UP || ch==KEY_DOWN || ch==KEY_RIGHT || ch==KEY_LEFT) {
			switch(ch) {
				case KEY_UP:
					d=UP;
					break;
				case KEY_DOWN:
					d=DOWN;
					break;
				case KEY_RIGHT:
					d=RIGHT;
					break;
				case KEY_LEFT:
					d=LEFT;
					break;
			}
			if(diff(S.getfdir(), d)!=2 && d!=S.getfdir()) {
				S.createNode(d);
			}
		}
		S.movesnake();
		S.render();
		if(S.getcoll()) {
			timeout(TIMEOUT_LONG);
			getch();
			show_gameover(S.getscore());
			return S.getscore();
		}
		attron(A_STANDOUT);
		mvprintw(23, 25, "PRESS 'Q' to EXIT BACK TO MENU.");
		attroff(A_STANDOUT);
		refresh();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsp, %rdi
callq 0x272c
callq 0x2270
movq 0x3f20(%rip), %rbx      # 0x7fd8
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x20d0
callq 0x21d0
movq (%rbx), %rdi
pushq $0x64
popq %rsi
callq 0x21e0
xorl %edi, %edi
callq 0x2130
movq %rsp, %r14
pushq $0x17
popq %rbp
pushq $0x19
popq %r12
leaq 0xfd5(%rip), %r15       # 0x50c0
movq (%rbx), %rdi
callq 0x20c0
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x410b
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
pushq $0x2
jmp 0x411b
cmpl $0x71, %eax
jne 0x414f
jmp 0x41c7
pushq $0x3
jmp 0x411b
pushq $0x1
popq %r13
jmp 0x4122
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x271c
subl %r13d, %eax
addl $0x2, %eax
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
je 0x414f
movq %r14, %rdi
callq 0x271c
cmpl %eax, %r13d
je 0x414f
movq %r14, %rdi
movl %r13d, %esi
callq 0x25a4
movq %r14, %rdi
callq 0x27d6
movq %r14, %rdi
callq 0x294e
movq %r14, %rdi
callq 0x29e8
movq (%rbx), %rdi
testl %eax, %eax
jne 0x41a6
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x20f0
movl %ebp, %edi
movl %r12d, %esi
leaq 0xf07(%rip), %rdx       # 0x508d
xorl %eax, %eax
callq 0x2220
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x2210
callq 0x22c0
jmp 0x40eb
movl $0x2710, %esi           # imm = 0x2710
callq 0x21e0
movq (%rbx), %rdi
callq 0x20c0
movq %rsp, %rdi
callq 0x29f0
movl %eax, %edi
callq 0x3ef4
movq %rsp, %rdi
callq 0x29f0
movl %eax, %ebx
movq %rsp, %rdi
callq 0x443c
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41ef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x443c
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: fun_snake_game()
void fun_snake_game(void) {
	Snake S;
	int ch, d;
	initscr();
	keypad(stdscr, TRUE);
	noecho();
	timeout(TIMEOUT);
	curs_set(0);
	while(1) {
		ch=getch();
		if(ch=='q') {
			return;
		}
		else if(ch==KEY_UP || ch==KEY_DOWN || ch==KEY_RIGHT || ch==KEY_LEFT) {
			switch(ch) {
				case KEY_UP:
					d=UP;
					break;
				case KEY_DOWN:
					d=DOWN;
					break;
				case KEY_RIGHT:
					d=RIGHT;
					break;
				case KEY_LEFT:
					d=LEFT;
					break;
			}
			if(diff(S.getfdir(), d)!=2 && d!=S.getfdir()) {
				S.createNode(d);
			}
		}
		S.movesnake();
		S.render();
		attron(A_STANDOUT);
		mvprintw(23, 25, "PRESS 'Q' to EXIT BACK TO MENU.");
		attroff(A_STANDOUT);
		refresh();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x8(%rsp), %rdi
pushq $0x19
popq %rsi
callq 0x24f0
callq 0x2270
movq 0x3da2(%rip), %rbx      # 0x7fd8
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x20d0
callq 0x21d0
movq (%rbx), %rdi
pushq $0x64
popq %rsi
callq 0x21e0
xorl %edi, %edi
callq 0x2130
leaq 0x8(%rsp), %r14
pushq $0x17
popq %rbp
pushq $0x19
popq %r12
leaq 0xe65(%rip), %r15       # 0x50d0
movq (%rbx), %rdi
callq 0x20c0
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x428b
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
pushq $0x2
jmp 0x429b
cmpl $0x71, %eax
jne 0x42cf
jmp 0x431a
pushq $0x3
jmp 0x429b
pushq $0x1
popq %r13
jmp 0x42a2
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x271c
subl %r13d, %eax
addl $0x2, %eax
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
je 0x42cf
movq %r14, %rdi
callq 0x271c
cmpl %eax, %r13d
je 0x42cf
movq %r14, %rdi
movl %r13d, %esi
callq 0x25a4
movq %r14, %rdi
callq 0x2648
movq %r14, %rdi
callq 0x25d2
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x20f0
movl %ebp, %edi
movl %r12d, %esi
leaq 0xd93(%rip), %rdx       # 0x508d
xorl %eax, %eax
callq 0x2220
movq (%rbx), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %edx, %edx
callq 0x2210
callq 0x22c0
jmp 0x426b
leaq 0x8(%rsp), %rdi
callq 0x443c
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4338
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x443c
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: rand_point(std::deque<Cell, std::allocator<Cell>>)
Point rand_point(std::deque<Cell> cells) {
	Point p;
	int flag;
	srand(time(NULL));
	do {
		flag=0;
		p.row=rand()%(MAX_ROW+1);
		p.col=rand()%(MAX_COL+1);
		for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
			if(p.row==it->p.row && p.col==it->p.col) {
				flag=1;
			}
		}
	}while(flag);
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x2160
pushq $0x13
popq %r14
pushq $0x50
popq %r15
pushq $0x1
popq %r12
callq 0x2070
cltd
idivl %r14d
movl %edx, %ebp
callq 0x2070
cltd
idivl %r15d
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rsi
xorl %r8d, %r8d
cmpq %rsi, %rax
je 0x43c3
cmpl (%rax), %ebp
jne 0x43a9
cmpl 0x4(%rax), %edx
cmovel %r12d, %r8d
addq $0xc, %rax
cmpq %rdi, %rax
jne 0x4399
movq 0x8(%rcx), %rax
addq $0x8, %rcx
leaq 0x1f8(%rax), %rdi
jmp 0x4399
testl %r8d, %r8d
jne 0x4372
shlq $0x20, %rdx
movl %ebp, %eax
orq %rdx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: getcol(int)
int getcol(int col) {
	if(col>=0 && col<=MAX_COL) {
		return col;
	}
	else if(col<0) {
		return MAX_COL+col+1;
	}
	else {
		return col-MAX_COL-1;
	}
}

// Assembly:
movl %edi, %eax
cmpl $0x50, %edi
jb 0x4436
testl %eax, %eax
js 0x4437
addl $-0x50, %eax
retq
addl $0x50, %eax
retq
nop