LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::execute()
void Diffusion_Evt::execute(){
//	update diffusion origin voxel with the inverse state change vector
	tv_vec[nextVoxel].v->update_state(sc_vec);

//	choose diffusion partner
	double r = rg->get_Uni_Rnd();
	double d; // temp
	for (size_t i = 0; i < tv_vec[nextVoxel].v->get_diff_vec()->size(); ++i){
		d = (double)(i+1)/tv_vec[nextVoxel].v->get_diff_vec()->size();
		if(r-d < 0){
			tv_vec[nextVoxel].v->get_diff_vec()->at(i)->update_state(inv_sc_vec);
			break;
		}
	}

//	set dirty flag to indicate that dependent events have to be updated properly
	for(size_t i = 0; i < dep_list.size(); i++){
		dep_list[i]->set_flag(true);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
leaq 0x38(%rdi), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x67f2
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x639e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
leaq 0x18(%rsp), %r12
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x50(%rbx), %rax
movq 0x70(%rbx), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rcx
movq 0x40(%rcx), %rax
movq 0x48(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, %xmm2
punpckldq 0x1dce8(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x1dcf0(%rip), %xmm2    # 0x240d0
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
negq %rcx
movl $0x1, %edx
movq 0x1dcc4(%rip), %xmm2    # 0x240c0
movapd 0x1dccc(%rip), %xmm3    # 0x240d0
leaq (%rcx,%rdx), %rsi
cmpq $0x1, %rsi
je 0x6470
movq %rdx, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
divsd %xmm1, %xmm5
incq %rdx
ucomisd %xmm0, %xmm5
jbe 0x6404
movq -0x10(%rax,%rdx,8), %r14
leaq 0xa0(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x67f2
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6470
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
je 0x64a4
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x6491
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x64d1
jmp 0x64dd
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x64dd
leaq 0x30(%rsp), %r12
movq (%r12), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::update(double)
double Diffusion_Evt::update(double last_tau){

	double minTau = INFINITY, actTau;

//	check if this event depends on the last executed event
	if (this->dirty_flag) {
//		run through the tv vector
		for (size_t i = 0; i < tv_vec.size(); ++i) {
//			check for voxel that have been affected by last executed event
			if (tv_vec[i].v->get_dirty_flag()) {
				actTau = calc_tau(i);
//				find smallest tau value (->next voxel) for this event
				if (actTau < minTau) {
					minTau = actTau;
					nextVoxel = i;
				}
//			voxel has not been affected by last event
			} else {
//				adjust tau value to global times scale
				tv_vec[i].t -= last_tau;
//				find smallest tau value (->next voxel) for this event
				if (tv_vec[i].t < minTau) {
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
			}
		}
//  event has not been affected by last event
	} else {
//		adjust tau values to global times scale
		for (size_t i = 0; i < tv_vec.size(); ++i) {
			tv_vec[i].t -= last_tau;
			if (tv_vec[i].t < minTau) {
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}

	this->dirty_flag = false;
	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpb $0x0, 0x80(%rdi)
je 0x658e
cmpq %rax, %rcx
je 0x65d5
movsd 0x1daec(%rip), %xmm2    # 0x24008
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x6553
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x65f2
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
jmp 0x6563
movsd (%rax,%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm2
jbe 0x6571
movq %r14, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %r14
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r15
cmpq %rcx, %r14
jb 0x652a
jmp 0x65dd
subq %rax, %rcx
je 0x65d5
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0x1da5d(%rip), %xmm2    # 0x24008
xorl %edx, %edx
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
ucomisd %xmm0, %xmm2
jbe 0x65c7
movq %rdx, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x65ad
jmp 0x65dd
movsd 0x1da2b(%rip), %xmm2    # 0x24008
movb $0x0, 0x80(%rbx)
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::calc_tau(long)
double Diffusion_Evt::calc_tau(long vid){
//	adapt the c value to the number of diffusion sites!
	double c_adapted =  c * tv_vec.at(vid).v->get_diff_vec()->size();
//	calculate tau
	tv_vec[vid].t = -log(rg->get_Uni_Rnd()) / (tv_vec[vid].v->get_state_vec()->
			at(diff_spec_id)->get_n_molecules() * c_adapted);

	return tv_vec[vid].t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rsi, %rdx
jbe 0x66e7
movq %rdi, %r14
movsd 0x78(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
shlq $0x4, %rbx
movq (%rax,%rbx), %rax
movq 0x40(%rax), %r12
movq 0x48(%rax), %r15
movq 0x68(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x4210
movq 0x50(%r14), %rax
movq 0xb8(%r14), %rsi
movq (%rax,%rbx), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x66f3
xorps 0x1d99e(%rip), %xmm0    # 0x24010
movaps %xmm0, 0x10(%rsp)
subq %r12, %r15
sarq $0x3, %r15
movq %r15, %xmm0
punpckldq 0x1da35(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1da3d(%rip), %xmm0    # 0x240d0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rax,%rsi,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
mulsd 0x8(%rsp), %xmm1
movapd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movq 0x50(%r14), %rax
movsd %xmm0, 0x8(%rax,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d955(%rip), %rdi     # 0x24043
movq %rbx, %rsi
jmp 0x66fa
leaq 0x1d949(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::init()
void Reaction_Evt::init(){

//	build educt vector
	build_educt_vector();

//	calculate the correct probability rate constant depending on the reaction order.
	if (educt_vec.size() == 1){
		this->c = k;
	}else if(educt_vec.size() == 2){
		this->c = k/(tv_vec[0].v->get_volume()*N_AVO*1e-6);
	}

//	update the Reaction Event the first time
	update(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x6cea
movq 0xa8(%rbx), %rax
subq 0xa0(%rbx), %rax
sarq $0x3, %rax
cmpq $0x2, %rax
je 0x6cae
cmpq $0x1, %rax
jne 0x6cd8
movsd 0x30(%rbx), %xmm0
jmp 0x6cd3
movq 0x50(%rbx), %rax
movq (%rax), %rax
movsd 0x18(%rax), %xmm1
mulsd 0x1d486(%rip), %xmm1    # 0x24148
movsd 0x30(%rbx), %xmm0
mulsd 0x1d481(%rip), %xmm1    # 0x24150
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rbx)
movq (%rbx), %rax
movq 0x10(%rax), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::execute()
void Reaction_Evt::execute(){
	try{
//		execute event by using the state change vector
		tv_vec[nextVoxel].v->update_state(sc_vec);

//		set dirty flag to indicate that dependent events have to be updated
		this->dirty_flag = true;
		for(size_t i = 0; i < dep_list.size(); i++){
			dep_list[i]->set_flag(true);
		}
	}
	catch(exception& e){
		cout << "Reaction_Evt::execute(): " << e.what();
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
leaq 0x38(%rdi), %rsi
movq %rsp, %rdi
callq 0x67f2
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6db4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movb $0x1, 0x80(%rbx)
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
je 0x6def
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x6ddc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e1b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x6e1b
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6e6b
movq %rbx, %rdi
callq 0x4100
movq %rax, %rbx
movq 0x2c195(%rip), %rdi     # 0x32fc8
leaq 0x1d31e(%rip), %rsi     # 0x24158
movl $0x19, %edx
callq 0x42f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x2c174(%rip), %rdi     # 0x32fc8
movq %rax, %rsi
callq 0x4290
callq 0x44a0
jmp 0x6def
movq %rax, %rbx
callq 0x44a0
movq %rbx, %rdi
callq 0x4510
movq %rax, %rdi
callq 0x71af
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::update(double)
double Reaction_Evt::update(double last_tau){

	double minTau = INFINITY;

//	check if this event depends on the last executed event
	if(this->dirty_flag){
//		run through the tv vector
		for (size_t i = 0; i < tv_vec.size(); ++i){
//			check for voxel that have been affected by last executed event
			if (tv_vec[i].v->get_dirty_flag()){
//				find smallest tau value (->next voxel) for this event
				if(calc_tau(i) < minTau){
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
//			voxel has not been affected by last event
			} else {
//				adjust tau value to global times scale
				tv_vec[i].t -= last_tau;
//				find smallest tau value (->next voxel) for this event
				if(tv_vec[i].t < minTau){
					minTau = tv_vec[i].t;
					nextVoxel = i;
				}
			}
		}
//  event has not been affected by last event
	} else  {
//		adjust tau values to global times scale
		for (size_t i = 0; i < tv_vec.size(); ++i) {
			tv_vec[i].t -= last_tau;
			if(tv_vec[i].t < minTau){
				minTau = tv_vec[i].t;
				nextVoxel = i;
			}
		}
	}

	this->dirty_flag = false;
	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpb $0x0, 0x80(%rdi)
je 0x6f33
cmpq %rax, %rcx
je 0x6f7a
movsd 0x1d15a(%rip), %xmm2    # 0x24008
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm0, (%rsp)
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x6ef5
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x6f98
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
movq 0x50(%rbx), %rax
jbe 0x6f15
movsd (%rax,%r15), %xmm1
movsd (%rsp), %xmm0
jmp 0x6f0b
movsd (%rax,%r15), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r15)
ucomisd %xmm1, %xmm2
jbe 0x6f1a
movq %r14, 0x70(%rbx)
movapd %xmm1, %xmm2
jmp 0x6f1a
movsd (%rsp), %xmm0
incq %r14
movq 0x58(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r15
cmpq %rcx, %r14
jb 0x6ebc
jmp 0x6f82
subq %rax, %rcx
je 0x6f7a
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0x1d0b8(%rip), %xmm2    # 0x24008
xorl %edx, %edx
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax)
ucomisd %xmm1, %xmm2
jbe 0x6f6c
movq %rdx, 0x70(%rbx)
movapd %xmm1, %xmm2
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x6f52
jmp 0x6f82
movsd 0x1d086(%rip), %xmm2    # 0x24008
movb $0x0, 0x80(%rbx)
movapd %xmm2, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::calc_tau(long)
double Reaction_Evt::calc_tau(long vid){

// 	make sure the educt vector is valid -> only first -and second order reactions are allowed
	if(educt_vec.size() > 0 && educt_vec.size() <= 2){
		double a = c;
		for (size_t i = 0; i < educt_vec.size(); ++i){
			a *= tv_vec[vid].v->get_state_vec()->at(educt_vec[i])->get_n_molecules();
		}
		tv_vec[vid].t = -log(rg->get_Uni_Rnd()) / a;

		return tv_vec[vid].t;
	} else {
		cout << "ERROR: Only first and second order reactions are allowed! "
				"Check sc_vec of:" << this->name <<endl;
		exit(0);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xa0(%rdi), %rax
movq 0xa8(%rdi), %rcx
subq %rax, %rcx
je 0x7078
cmpq $0x10, %rcx
ja 0x7078
movq %rsi, %r14
movsd 0x78(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
shlq $0x4, %r14
movq 0x50(%rbx), %rcx
movq (%rcx,%r14), %rcx
movq (%rax,%r15,8), %rsi
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x706a
movq (%rax,%rsi,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incq %r15
movq 0xa0(%rbx), %rax
movq 0xa8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x6fda
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x4210
xorpd 0x1cfc1(%rip), %xmm0    # 0x24010
divsd 0x8(%rsp), %xmm0
movq 0x50(%rbx), %rax
movsd %xmm0, 0x8(%rax,%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1cfd2(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
movq 0x2bf49(%rip), %rdi     # 0x32fc8
leaq 0x1d0ec(%rip), %rsi     # 0x24172
callq 0x4290
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %edi, %edi
callq 0x4330
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/SubUnitSwitch_Rct_Evt.cpp
// Function: nw::SubUnitSwitch_Rct_Evt::execute()
void SubUnitSwitch_Rct_Evt::execute(){

	try{
//		execute event by using the state change vector
		tv_vec[nextVoxel].v->update_state(sc_vec);

//		set dirty flag to indicate that dependent events have to be updated properly
		for(long i = 0; i < (long)dep_list.size(); i++){
			dep_list[i]->set_flag(true);
		}

//		update the activation states of the subunits of chs
		chs = dynamic_cast<Channel_Spc*>(tv_vec[nextVoxel].v->get_state_vec()->at(ch_spc_id));
		update_Channel_Spc();
	}
	catch(exception& e){
		cout << "SubuintSwitch_Rct_evt::execute(): " << e.what();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x70(%rdi), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
leaq 0x38(%rdi), %rsi
movq %rsp, %rdi
callq 0x67f2
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x72f8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x7327
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x7314
movq 0x50(%rbx), %rax
movq 0x70(%rbx), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rcx
movq 0xc8(%rbx), %rsi
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x738b
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
je 0x7372
leaq 0x2b546(%rip), %rsi     # 0x328a8
leaq 0x2b54f(%rip), %rdx     # 0x328b8
xorl %ecx, %ecx
callq 0x42e0
jmp 0x7374
xorl %eax, %eax
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
callq 0x7420
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ccb1(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x73bd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x73bd
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x7410
movq %rbx, %rdi
callq 0x4100
movq %rax, %rbx
movq 0x2bbf3(%rip), %rdi     # 0x32fc8
leaq 0x1ce17(%rip), %rsi     # 0x241f3
movl $0x22, %edx
callq 0x42f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x2bbd2(%rip), %rdi     # 0x32fc8
movq %rax, %rsi
callq 0x4290
callq 0x44a0
jmp 0x7383
movq %rax, %rbx
callq 0x44a0
movq %rbx, %rdi
callq 0x4510
movq %rax, %rdi
callq 0x71af
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Events/SubUnitSwitch_Rct_Evt.cpp
// Function: nw::SubUnitSwitch_Rct_Evt::update_Channel_Spc()
void SubUnitSwitch_Rct_Evt::update_Channel_Spc(){

	if (sc_vec.at(act_su_id) > 0){
		long r_chid = (long)(rg->get_Uni_Rnd() * chs->get_n_Activable_Ch());
		chs->activate_Subunit(r_chid);
	}else if(sc_vec.at(act_su_id) < 0){
		long r_chid = (long)(rg->get_Uni_Rnd() * chs->get_n_Inactivable_Ch());
 		chs->inactivate_Subunit(r_chid);
	}else{
		cout << "ERROR: The SubUnitActSwitch_Rct_Evt state change vector doesn't suit the"
				" assigned active_subUnit_Species_ID. Please check your input!" << endl;
	}
}

// Assembly:
pushq %rbx
movq 0xc0(%rdi), %rsi
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x74e7
movq %rdi, %rbx
cmpq $0x0, (%rax,%rsi,8)
jle 0x7476
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0xb8(%rbx), %rdi
movq 0x38(%rdi), %rax
subq 0x60(%rdi), %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
popq %rbx
jmp 0xe4d0
js 0x74bb
movq 0x2bb49(%rip), %rbx     # 0x32fc8
leaq 0x1cd90(%rip), %rsi     # 0x24216
movl $0x85, %edx
movq %rbx, %rdi
callq 0x42f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
jmp 0x4190
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0xb8(%rbx), %rdi
movq 0x38(%rdi), %rax
subq 0x68(%rdi), %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
popq %rbx
jmp 0xe55a
leaq 0x1cb55(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::get_System()
_System* Standard_Ipt::get_System(){
	read_Sim_Data();
//	create Gillespie_Sys
	s = new Gillespie_Sys(	xgd.xml_output_mode, xgd.xml_max_sim_steps, xgd.xml_max_sim_time,
							xgd.xml_sample_rate,&evc, &vvc,output_dir_path,xgd.xml_output_Spc,
							xgd.xml_output_Vxl);
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
callq 0x7cf4
movl $0xf00, %edi            # imm = 0xF00
callq 0x42b0
movq %rax, %rbx
cvttsd2si 0x78(%r14), %r15
movq 0x70(%r14), %r12
movsd 0x80(%r14), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x88(%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xd476
leaq 0x98(%r14), %rsi
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0x67f2
leaq 0xb0(%r14), %rsi
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x67f2
leaq 0x450(%r14), %rcx
leaq 0x468(%r14), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
pushq %rbp
pushq %r13
callq 0xe5e4
addq $0x10, %rsp
movq %rbx, 0x8(%r14)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x7c3c
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x7c53
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7c6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
movq 0x8(%r14), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x7ca1
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x7ca1
movq %rax, %r14
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x7cbd
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x7cbd
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7cde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x7cde
movq %rax, %r14
movl $0xf00, %esi            # imm = 0xF00
movq %rbx, %rdi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::build_header[abi:cxx11]()
string Standard_Ipt::build_header(){
	time_t rawtime;
	time ( &rawtime );

	string tmp = 	"STOCHASTIC SIMULATION SOFTWARE \n ------------------"
					"--------------------------------\n developed by Nicolas Wieder and "
					"Frederic von Wegner \n Medical Biophysics Group, Institute of "
					"Physiology and Pathophysiology,\n University of Heidelberg, "
					"69120 Heidelberg, Germany\n----------------------------------"
					"----------------\n\n";
	tmp += ctime (&rawtime);
	return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4260
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
leaq 0x1c0e1(%rip), %rsi     # 0x24720
leaq 0x1c215(%rip), %rdx     # 0x2485b
movq %rbx, %rdi
callq 0xd724
movq %r14, %rdi
callq 0x40f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4560
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x8684
movq (%r15), %rsi
incq %rsi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::clone_svc()
vector<_Species*> Standard_Ipt::clone_svc(){
	vector<_Species*> svcClone;
	svcClone.resize(svc.size());

	for (long i = 0; i < (long) svc.size(); i++)
		svcClone[i] = svc[i]->copy();
	return svcClone;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x488(%rsi), %rsi
subq 0x480(%r14), %rsi
sarq $0x3, %rsi
callq 0xc92c
movq 0x480(%r14), %rax
movq 0x488(%r14), %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0xbd0f
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movq 0x480(%r14), %rax
movq 0x488(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jl 0xbce1
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0xbd1a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbd31
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/nwieder[P]SSTS/src/Input/Standard_Ipt.cpp
// Function: nw::Standard_Ipt::build_sc_vector(nw::Standard_Ipt::xml_Rct_Evt* const&)
vector<long> Standard_Ipt::build_sc_vector(xml_Rct_Evt* const& cxe){
	vector<long>* scv  = new vector<long>;
	scv->resize(vvc[cxe->xml_vxl[0]]->get_state_vec()->size());
	long i;

	for (i = 0; i < (long)cxe->xml_educts.size(); i++)
		scv->at(cxe->xml_educts.at(i)) = -1;
	for (i = 0; i < (long)cxe->xml_products.size(); i++)
		scv->at(cxe->xml_products.at(i)) = 1;

	return *scv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x18, %edi
callq 0x42b0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%r15), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq 0x468(%r12), %rcx
movq (%rcx,%rax,8), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0xc8fa
movq (%r15), %rax
movq 0x48(%rax), %rcx
movq 0x50(%rax), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
testq %rdi, %rdi
jle 0xbdd1
movq (%r14), %r8
movq 0x8(%r14), %rdx
subq %r8, %rdx
sarq $0x3, %rdx
xorl %r9d, %r9d
movq (%rcx,%r9,8), %rsi
cmpq %rsi, %rdx
jbe 0xbe29
movq $-0x1, (%r8,%rsi,8)
incq %r9
cmpq %r9, %rdi
jne 0xbdb8
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
testq %rax, %rax
jle 0xbe0f
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
xorl %r8d, %r8d
movq (%rcx,%r8,8), %rsi
cmpq %rsi, %rdx
jbe 0xbe29
movq $0x1, (%rdi,%rsi,8)
incq %r8
cmpq %r8, %rax
jne 0xbdf6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67f2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18213(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rsp)
movq (%rdx), %rcx
movq 0x30(%rcx), %rax
cmpq $-0x1, (%rax)
je 0xbecd
cmpq %rax, 0x38(%rcx)
je 0xbee1
movq %rdx, %r15
xorl %r13d, %r13d
movq %rsp, %r12
movq (%rax,%r13,8), %rdx
shlq $0x3, %rdx
addq 0x468(%r14), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xbea0
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0xbea8
movq %r12, %rdi
callq 0xd50c
incq %r13
movq (%r15), %rcx
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0xbe77
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
jmp 0xbee3
addq $0x468, %r14            # imm = 0x468
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc362
jmp 0xbeea
xorl %eax, %eax
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xbf14
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %rbx
leaq 0x25dc4(%rip), %rax     # 0x32a60
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 0xcc06
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq $0x0, 0x50(%rbx)
movsd 0x10(%rbx), %xmm0
movsd 0x175f9(%rip), %xmm1    # 0x242d0
callq 0x4500
mulsd 0x175f4(%rip), %xmm0    # 0x242d8
movsd %xmm0, 0x18(%rbx)
movq 0x8(%r15), %rax
subq (%r15), %rax
testq %rax, %rax
jle 0xcd22
leaq 0x40(%rbx), %r12
xorl %r13d, %r13d
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
movsd 0x18(%rbx), %xmm0
movq (%rdi), %rax
callq *0x28(%rax)
incq %r13
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
cmpq %rax, %r13
jl 0xccfc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0xcd44
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45eb
movq %r15, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24f8c(%rip), %r8      # 0x33338
testq %r8, %r8
setne %dl
movabsq $0x41a705af1fe3fb79, %rdi # imm = 0x41A705AF1FE3FB79
testb %dl, %al
jne 0xe434
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
movl $0x1, %ecx
cmovsq %rax, %rcx
movl $0x27, %r8d
leaq 0x24f61(%rip), %r9      # 0x33340
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rdx     # imm = 0xF4EC
leaq (%rax,%rdx), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rdx, %rax
cmovnsq %rax, %rcx
cmpq $0x1f, %r8
ja 0xe427
movq %rcx, (%r9,%r8,8)
addq $-0x1, %r8
jb 0xe3df
movq 0x24f0c(%rip), %r8      # 0x33340
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
addq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
addq %rcx, %rax
cmovnsq %rax, %rdx
movq %rdx, (%rsi)
leaq 0x3ffffff(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
shrq $0x1a, %rax
cltq
leaq 0x24eb0(%rip), %rcx     # 0x33340
movq (%rcx,%rax,8), %rsi
movq %rsi, 0x24e9d(%rip)     # 0x33338
cvtsi2sd %rsi, %xmm1
mulsd 0x164b8(%rip), %xmm1    # 0x24960
movq %rdx, (%rcx,%rax,8)
movsd 0x164b4(%rip), %xmm0    # 0x24968
minsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0x1013d
sarq $0x3, %rcx
movq 0x28(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
cmpq $0x0, (%rax,%rsi,8)
je 0x10135
movq (%rdx,%rsi,8), %rdi
movb $0x1, 0x30(%rdi)
incq %rsi
cmpq %rsi, %rcx
jne 0x10126
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x101b7
movq %rdi, %rbx
cmpq %rax, %rcx
je 0x101ad
xorl %r15d, %r15d
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
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x10185
movb $0x1, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x22e0a(%rip), %rdi     # 0x32fc8
leaq 0x14990(%rip), %rsi     # 0x24b55
movl $0x3a, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x42f0
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq 0x18(%rsi), %rdi
callq 0x4450
testl %eax, %eax
jle 0x102d2
xorl %r15d, %r15d
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %rbp
leaq 0x6(%rsp), %r13
movl $0x498, %edi            # imm = 0x498
callq 0x42b0
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0xbf1c
movq 0x10(%r14), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0xbf1c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1033e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x10277
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10293
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42c0
incq %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
movq %rax, %rdi
movq %r15, %rsi
callq *0x10(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x2, %edi
callq 0x41e0
movq 0x18(%r14), %rdi
callq 0x4450
cltq
cmpq %rax, %r15
jl 0x10220
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x10328
movq %rax, %r14
jmp 0x1030c
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1030c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10328
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42c0
movl $0x498, %esi            # imm = 0x498
movq %rbx, %rdi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x225cc(%rip), %rax     # 0x32928
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
addq $0x98, %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x4160
leaq 0x170(%rbx), %r15
movq %r15, %rdi
callq 0x15da6
leaq 0x248(%rbx), %r13
movq %r13, %rdi
callq 0x44d0
leaq 0x450(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x468(%rbx), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x480(%rbx)
movups %xmm0, 0x470(%rbx)
movups %xmm0, 0x460(%rbx)
movups %xmm0, 0x450(%rbx)
movq $0x0, 0x490(%rbx)
movq (%rbp), %rdx
movq %rdx, 0x240(%rbx)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movl $0x74, %ecx
xorl %r8d, %r8d
callq 0x16aa8
movq %r14, %rdi
movq %r12, %rsi
callq 0x4150
movl $0x18, %edi
callq 0x42b0
movq %rax, %r12
leaq 0x2263b(%rip), %rax     # 0x32a88
addq $0x10, %rax
movq %rax, (%r12)
xorl %edi, %edi
callq 0x4260
negq %rax
movq %rax, 0x10(%r12)
movq %r12, 0x448(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x104b7
movq %rax, %r12
jmp 0x104bf
movq %rax, %r12
movq 0x480(%rbx), %rdi
testq %rdi, %rdi
je 0x104a2
movq 0x490(%rbx), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x46dd
movq %r15, %rdi
callq 0x15e32
addq $0x30, %rbx
movq %rbx, %rdi
callq 0xbf5a
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x104e5
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42c0
movq %r12, %rdi
callq 0x4510
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq (%rbx), %rcx
leal 0x3b(%rcx), %eax
cmpl $0x76, %eax
ja 0x119a
leaq 0xe8b(%rip), %rdi       # 0x2012
leaq 0xe90(%rip), %rdx       # 0x201e
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x120b
cmpl $0xe0f, %ecx            # imm = 0xE0F
jg 0x11d5
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %eax
shrl $0x1f, %eax
sarl $0x5, %edx
addl %eax, %edx
imull $0x3c, %edx, %eax
subl %eax, %ecx
leaq 0xe5c(%rip), %rdi       # 0x2021
leaq 0xe52(%rip), %rsi       # 0x201e
xorl %eax, %eax
callq 0x1030
jmp 0x120b
movl %ecx, %eax
movl $0x91a2b3c5, %esi       # imm = 0x91A2B3C5
imulq %rax, %rsi
shrq $0x2b, %rsi
imull $0xe10, %esi, %eax      # imm = 0xE10
subl %eax, %ecx
imull $0x889, %ecx, %edx      # imm = 0x889
shrl $0x11, %edx
imull $0x3c, %edx, %eax
subl %eax, %ecx
movzwl %cx, %ecx
leaq 0xe2b(%rip), %rdi       # 0x202f
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x384c
movq %rbx, %rdi
callq 0x390c
leaq 0x2b25(%rip), %r14      # 0x5004
callq 0x3b97
decl %eax
cmpl $0x3, %eax
ja 0x24df
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
callq 0x410e
movq %rbx, %rdi
movl %eax, %esi
callq 0x39cc
jmp 0x24df
movq %rbx, %rdi
callq 0x3a12
jmp 0x24df
callq 0x42c9
jmp 0x24df
leaq 0xc(%rsp), %rdi
callq 0x3864
callq 0x2210
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x57ee(%rip), %rax      # 0x7d38
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2cd0
leaq 0x58(%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%r15)
movups %xmm0, 0x88(%r15)
movups %xmm0, 0x78(%r15)
movups %xmm0, 0x68(%r15)
movups %xmm0, 0x58(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2e76
movl $0x1, 0xa8(%r15)
movl $0x0, 0xc(%rsp)
movb $0x40, 0x14(%rsp)
cmpl $0x2, %ebp
jl 0x2608
decl %ebp
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movl %r13d, 0x10(%rsp)
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x25f2
movl 0x14(%rsp), %ecx
movl %ecx, -0x4(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, -0xc(%rax)
addq $-0xc, 0x18(%r15)
jmp 0x25fd
movq %rbx, %rdi
movq %r12, %rsi
callq 0x30c2
incl %r13d
cmpl %r13d, %ebp
jne 0x25cc
movl %ebp, %r12d
movb $0x4f, 0x14(%rsp)
movl %r12d, 0x10(%rsp)
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x2633
movl 0x14(%rsp), %ecx
movl %ecx, -0x4(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, -0xc(%rax)
addq $-0xc, 0x18(%r15)
jmp 0x2640
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x30c2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2656
movq %rax, %r15
jmp 0x2661
movq %rax, %r15
movq %r14, %rdi
callq 0x306a
movq %rbx, %rdi
callq 0x3012
movq %r15, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rax, 0x8(%rsp)
movl %esi, 0x10(%rsp)
movq 0x88(%rdi), %rax
movq 0x98(%rdi), %rcx
addq $-0xc, %rcx
cmpq %rcx, %rax
je 0x26bc
movl 0x10(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
addq $0xc, 0x88(%rdi)
jmp 0x26ca
addq $0x58, %rdi
leaq 0x8(%rsp), %rsi
callq 0x32f0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2776
movq 0x50(%rbx), %rdx
movl $0x1f8, %ecx            # imm = 0x1F8
addq -0x8(%rdx), %rcx
movl (%rax), %ebp
movl 0x4(%rax), %r14d
movl -0xc(%rcx), %r13d
movl -0x8(%rcx), %r12d
movb $0x40, 0x8(%rax)
movl 0xa8(%rbx), %eax
cmpq $0x3, %rax
ja 0x27c8
leaq 0x2879(%rip), %rcx      # 0x5014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
decl %ebp
jmp 0x27aa
incl %ebp
movl %ebp, %edi
callq 0x4571
movl %eax, %ebp
jmp 0x27c8
decl %r14d
jmp 0x27bd
incl %r14d
movl %r14d, %edi
callq 0x4584
movl %eax, %r14d
leaq 0x8(%rbx), %r15
movl %ebp, 0xc(%rsp)
movl %r14d, 0x10(%rsp)
movb $0x4f, 0x14(%rsp)
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x27fb
movl 0x14(%rsp), %ecx
movl %ecx, -0x4(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, -0xc(%rax)
addq $-0xc, 0x18(%rbx)
jmp 0x2808
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x30c2
movq 0x68(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x282c
cmpl (%rax), %r13d
jne 0x282c
cmpl 0x4(%rax), %r12d
jne 0x282c
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x2b5a
movq %r15, %rdi
callq 0x2ba8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21d0
movq 0x18(%rbx), %r14
cmpq 0x38(%rbx), %r14
je 0x2b0d
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %r15
movq 0x550c(%rip), %r12      # 0x7fd8
movq (%r12), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
callq 0x21c0
cmpl $-0x1, %eax
je 0x2aef
movq (%r12), %rdi
movsbl 0x8(%r14), %esi
callq 0x2090
addq $0xc, %r14
cmpq %r13, %r14
jne 0x2b07
movq 0x8(%r15), %r14
addq $0x8, %r15
leaq 0x1f8(%r14), %r13
cmpq 0x38(%rbx), %r14
jne 0x2acc
movq 0x54c4(%rip), %r14      # 0x7fd8
movq (%r14), %rdi
movl 0xb4(%rbx), %esi
movl 0xb8(%rbx), %edx
callq 0x21c0
cmpl $-0x1, %eax
je 0x2b3c
movq (%r14), %rdi
movsbl 0xc0(%rbx), %esi
callq 0x2090
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22d0
cmpl $0x0, 0x38(%rbx)
js 0x38bf
leaq 0x70(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x3893
movq %rsp, %rdi
callq 0x2260
leaq 0x17e1(%rip), %rsi      # 0x507b
movq %rsp, %rdi
movl $0x24, %edx
callq 0x2030
movq %rsp, %rdi
movl $0x3c, %edx
movq %rbx, %rsi
callq 0x2250
movq %rsp, %rdi
callq 0x2260
movq 0x470a(%rip), %rax      # 0x7fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2150
leaq 0xf8(%rsp), %rdi
callq 0x20b0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x21e0
leaq 0x1750(%rip), %rsi      # 0x507b
movq %r14, %rdi
movl $0xc, %edx
callq 0x2120
leaq 0x78(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x3956
movq %rsp, %rdi
movl $0x3c, %edx
movq %rbx, %rsi
callq 0x2220
movq %rsp, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x398c
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 0x22f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39cb
xorl %ecx, %ecx
testl %eax, %eax
jle 0x39c2
movl (%rdi), %edx
xorl %esi, %esi
movl 0x4(%rdi,%rsi,4), %r8d
cmpl %r8d, %edx
jle 0x39b4
movl %edx, 0x4(%rdi,%rsi,4)
movl %r8d, (%rdi,%rsi,4)
movl 0x38(%rdi), %eax
jmp 0x39b7
movl %r8d, %edx
incq %rsi
movslq %eax, %r8
cmpq %r8, %rsi
jl 0x399d
leal 0x1(%rcx), %edx
cmpl %eax, %ecx
movl %edx, %ecx
jl 0x3995
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x398c
movslq 0x38(%rbx), %rax
cmpq $0xc, %rax
jg 0x39f4
leaq 0x1(%rax), %rcx
movl %ecx, 0x38(%rbx)
leaq (%rbx,%rax,4), %rax
addq $0x4, %rax
jmp 0x39fb
movq %rbx, %rax
cmpl %ebp, (%rbx)
jge 0x3a0b
movl %ebp, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x398c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq