LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, unsigned long)
void add(uint32_t tag, uint64_t data) {

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_INT64, index);

        size_t n = (8 - (store.size() % 8)) % 8;

        while (n > 0) {
            store += '\0';
            --n;
        }

        add_uint32(store.size(), index);
        add_uint32(1, index);
        add_uint64(data, store);

        ++nentries;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movq %rbx, %rsi
callq 0xf0d8
movl $0x5, %edi
movq %rbx, %rsi
callq 0xf0d8
leaq 0x20(%rbx), %r14
xorl %r15d, %r15d
subl 0x28(%rbx), %r15d
andl $0x7, %r15d
je 0x127d1
movq %r14, %rdi
xorl %esi, %esi
callq 0x3690
decq %r15
jne 0x127c2
movl 0x28(%rbx), %edi
movq %rbx, %rsi
callq 0xf0d8
movl $0x1, %edi
movq %rbx, %rsi
callq 0xf0d8
movq %r14, %rsi
callq 0xf139
incq 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ivan-tkatchev[P]makerpm/./mfile.h
// Function: mfile::mfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mfile(const std::string& f) {

        fd = ::open(f.c_str(), O_RDONLY|O_LARGEFILE);
        
        if (fd < 0) {
            throw std::runtime_error("Could not open: " + f);
        }

        struct stat st;

        if (::fstat(fd, &st) < 0) {
            throw std::runtime_error("Could not stat: " + f);
        }

        size = st.st_size;

        addr = ::mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3280
movl %eax, 0x8(%r14)
testl %eax, %eax
js 0x12bfd
leaq 0x20(%rsp), %rsi
movl %eax, %edi
callq 0x34f0
testl %eax, %eax
js 0x12c48
movq 0x50(%rsp), %rsi
movq %rsi, 0x10(%r14)
movl 0x8(%r14), %r8d
xorl %edi, %edi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r9d, %r9d
callq 0x3540
movq %rax, (%r14)
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x6ddb(%rip), %rsi      # 0x199ec
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0x12b16
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xa3b1(%rip), %rsi      # 0x1cfe8
movq 0xa3a2(%rip), %rdx      # 0x1cfe0
movq %r14, %rdi
callq 0x3360
jmp 0x12c8d
movl $0x10, %edi
callq 0x3240
movq %rax, %r14
leaq 0x6dbf(%rip), %rsi      # 0x19a1b
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x12b16
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x31c0
xorl %ebp, %ebp
movq 0xa36a(%rip), %rsi      # 0x1cfe8
movq 0xa35b(%rip), %rdx      # 0x1cfe0
movq %r14, %rdi
callq 0x3360
movq %rax, %rbx
leaq 0x10(%rsp), %rax
jmp 0x12ca1
jmp 0x12cb1
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12cb7
callq 0x32f0
jmp 0x12cb7
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x12cc4
movq %r14, %rdi
callq 0x3500
movq %rbx, %rdi
callq 0x3370
// File: /workspace/github_cpp_makefile_star2_O1/nwieder[P]SSTS/src/Events/ChFlux_Rct_Evt.cpp
// Function: nw::ChFlux_Rct_Evt::update(double)
double ChFlux_Rct_Evt::update(double last_tau){

	double minTau = INFINITY;
	double actTau;

//	run through the tv vector
	for (long i = 0; i < (long) tv_vec.size(); i++) {
//		check for voxel that have been affected by last executed event
		if (tv_vec.at(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;
			}
//		this voxel has not been affected by last event
		} else {
//			adjust tau value to global times scale
			tv_vec.at(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;
			}
		}
	}
	this->dirty_flag = false;

	return minTau;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movsd 0x1e2dc(%rip), %xmm1    # 0x24008
testq %rdx, %rdx
jle 0x5d9d
movl $0x8, %r15d
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x5db2
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x5d63
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm1, 0x8(%rsp)
callq 0x5dc4
movsd 0x8(%rsp), %xmm1
jmp 0x5d74
movsd (%rax,%r15), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm1
jbe 0x5d82
movq %r14, 0x70(%rbx)
movapd %xmm0, %xmm1
incq %r14
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
addq $0x10, %r15
cmpq %rdx, %r14
jl 0x5d3a
movb $0x0, 0x80(%rbx)
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1e28a(%rip), %rdi     # 0x24043
movq %r14, %rsi
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::init()
void Diffusion_Evt::init(){

//	calculate the correct diffusion probability constant according to the voxel volume
	this->c = (k*1e-3)/pow(tv_vec[0].v->get_box_length()*1e6,2);

//	build state change vector
	build_sc_vec();

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movsd 0x30(%rdi), %xmm0
mulsd 0x1e01b(%rip), %xmm0    # 0x240a8
movq 0x50(%rdi), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm1
mulsd 0x1e00f(%rip), %xmm1    # 0x240b0
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rdi)
callq 0x60c4
movq (%rbx), %rax
movq 0x10(%rax), %rax
xorpd %xmm0, %xmm0
movq %rbx, %rdi
popq %rbx
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::build_sc_vec()
void Diffusion_Evt::build_sc_vec(){
//	build sc_vec
	sc_vec.assign(tv_vec[0].v->get_state_vec()->size(),0);
	inv_sc_vec.assign(tv_vec[0].v->get_state_vec()->size(),0);
	sc_vec[diff_spec_id] = -1;
	inv_sc_vec[diff_spec_id] = 1;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %r14, %rdx
callq 0x66c4
leaq 0xa0(%rbx), %rdi
movq 0x50(%rbx), %rax
movq (%rax), %rax
movq 0x30(%rax), %rsi
subq 0x28(%rax), %rsi
sarq $0x3, %rsi
movq %r15, (%r14)
leaq 0x8(%rsp), %rdx
callq 0x66c4
movq 0x38(%rbx), %rax
movq 0xb8(%rbx), %rcx
movq $-0x1, (%rax,%rcx,8)
movq 0xa0(%rbx), %rax
movq 0xb8(%rbx), %rcx
movq $0x1, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65fa
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x61a6
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 0x1dee0(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x1dee8(%rip), %xmm2    # 0x240d0
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
negq %rcx
movl $0x1, %edx
movq 0x1debc(%rip), %xmm2    # 0x240c0
movapd 0x1dec4(%rip), %xmm3    # 0x240d0
leaq (%rcx,%rdx), %rsi
cmpq $0x1, %rsi
je 0x6278
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 0x620c
movq -0x10(%rax,%rdx,8), %r14
leaq 0xa0(%rbx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x65fa
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6278
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
je 0x62ac
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 0x6299
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x62d9
jmp 0x62e5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x62e5
leaq 0x30(%rsp), %r12
movq (%r12), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6396
cmpq %rax, %rcx
je 0x63dd
movsd 0x1dce4(%rip), %xmm2    # 0x24008
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x635b
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x63fa
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
jmp 0x636b
movsd (%rax,%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm2
jbe 0x6379
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 0x6332
jmp 0x63e5
subq %rax, %rcx
je 0x63dd
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0x1dc55(%rip), %xmm2    # 0x24008
xorl %edx, %edx
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
ucomisd %xmm0, %xmm2
jbe 0x63cf
movq %rdx, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x63b5
jmp 0x63e5
movsd 0x1dc23(%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_O1/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 0x64ef
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 0x64fb
xorps 0x1db96(%rip), %xmm0    # 0x24010
movaps %xmm0, 0x10(%rsp)
subq %r12, %r15
sarq $0x3, %r15
movq %r15, %xmm0
punpckldq 0x1dc2d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1dc35(%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 0x1db4d(%rip), %rdi     # 0x24043
movq %rbx, %rsi
jmp 0x6502
leaq 0x1db41(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68a2
movq 0xa8(%rbx), %rax
subq 0xa0(%rbx), %rax
sarq $0x3, %rax
cmpq $0x2, %rax
je 0x6866
cmpq $0x1, %rax
jne 0x6890
movsd 0x30(%rbx), %xmm0
jmp 0x688b
movq 0x50(%rbx), %rax
movq (%rax), %rax
movsd 0x18(%rax), %xmm1
mulsd 0x1d8ae(%rip), %xmm1    # 0x24128
movsd 0x30(%rbx), %xmm0
mulsd 0x1d8a9(%rip), %xmm1    # 0x24130
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_O1/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 0x65fa
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6966
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 0x69a1
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 0x698e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x69cd
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x69cd
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6a1d
movq %rbx, %rdi
callq 0x4100
movq %rax, %rbx
movq 0x2c5e3(%rip), %rdi     # 0x32fc8
leaq 0x1d74c(%rip), %rsi     # 0x24138
movl $0x19, %edx
callq 0x42f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x2c5c2(%rip), %rdi     # 0x32fc8
movq %rax, %rsi
callq 0x4290
callq 0x44a0
jmp 0x69a1
movq %rax, %rbx
callq 0x44a0
movq %rbx, %rdi
callq 0x4510
movq %rax, %rdi
callq 0x6d6b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movapd %xmm0, %xmm1
movq %rdi, %rbx
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpb $0x0, 0x80(%rdi)
je 0x6ae6
cmpq %rax, %rcx
je 0x6b2d
movsd 0x1d5a4(%rip), %xmm2    # 0x24008
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm1, (%rsp)
movq -0x8(%rax,%r15), %rcx
cmpb $0x1, 0x20(%rcx)
jne 0x6aab
movq %rbx, %rdi
movq %r14, %rsi
movsd %xmm2, 0x8(%rsp)
callq 0x6b4a
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm2
jbe 0x6ac9
movq 0x50(%rbx), %rax
movsd (%rax,%r15), %xmm0
jmp 0x6ac1
movsd (%rax,%r15), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r15)
ucomisd %xmm0, %xmm2
jbe 0x6ac9
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 0x6a72
jmp 0x6b35
subq %rax, %rcx
je 0x6b2d
sarq $0x4, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movsd 0x1d505(%rip), %xmm2    # 0x24008
xorl %edx, %edx
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
ucomisd %xmm0, %xmm2
jbe 0x6b1f
movq %rdx, 0x70(%rbx)
movapd %xmm0, %xmm2
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x6b05
jmp 0x6b35
movsd 0x1d4d3(%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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
subq 0xa0(%rdi), %rax
je 0x6c3b
cmpq $0x10, %rax
ja 0x6c3b
movq %rsi, %r14
movsd 0x78(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0xa0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
je 0x6bf7
xorl %r15d, %r15d
movq %r14, %r12
shlq $0x4, %r12
movq 0x50(%rbx), %rcx
movq (%rcx,%r12), %rcx
movq (%rax,%r15,8), %rsi
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x6c2d
movq (%rax,%rsi,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r15
movq 0xa0(%rbx), %rax
movq 0xa8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x6b9a
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x4210
xorpd 0x1d403(%rip), %xmm0    # 0x24010
divsd (%rsp), %xmm0
movq 0x50(%rbx), %rax
shlq $0x4, %r14
movsd %xmm0, 0x8(%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d40f(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
movq 0x2c386(%rip), %rdi     # 0x32fc8
leaq 0x1d509(%rip), %rsi     # 0x24152
callq 0x4290
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4120
xorl %edi, %edi
callq 0x4330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65fa
movq (%r14), %rax
movq %rsp, %rsi
movq %r14, %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6eb4
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 0x6ee3
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movb $0x1, 0x80(%rsi)
incq %rdx
cmpq %rdx, %rcx
jne 0x6ed0
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 0x6f47
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
je 0x6f2e
leaq 0x2b98a(%rip), %rsi     # 0x328a8
leaq 0x2b993(%rip), %rdx     # 0x328b8
xorl %ecx, %ecx
callq 0x42e0
jmp 0x6f30
xorl %eax, %eax
movq %rax, 0xb8(%rbx)
movq %rbx, %rdi
callq 0x6fdc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d0f5(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6f79
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x6f79
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x6fcc
movq %rbx, %rdi
callq 0x4100
movq %rax, %rbx
movq 0x2c037(%rip), %rdi     # 0x32fc8
leaq 0x1d23b(%rip), %rsi     # 0x241d3
movl $0x22, %edx
callq 0x42f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x2c016(%rip), %rdi     # 0x32fc8
movq %rax, %rsi
callq 0x4290
callq 0x44a0
jmp 0x6f3f
movq %rax, %rbx
callq 0x44a0
movq %rbx, %rdi
callq 0x4510
movq %rax, %rdi
callq 0x6d6b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70a3
movq %rdi, %rbx
cmpq $0x0, (%rax,%rsi,8)
jle 0x7032
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 0xe078
js 0x7077
movq 0x2bf8d(%rip), %rbx     # 0x32fc8
leaq 0x1d1b4(%rip), %rsi     # 0x241f6
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 0xe108
leaq 0x1cf99(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7868
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 0xd022
leaq 0x98(%r14), %rsi
leaq 0x50(%rsp), %r13
movq %r13, %rdi
callq 0x65fa
leaq 0xb0(%r14), %rsi
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x65fa
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 0xe18c
addq $0x10, %rsp
movq %rbx, 0x8(%r14)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x77b0
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x77c7
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x77e3
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 0x7815
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x7815
movq %rax, %r14
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x7831
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
jmp 0x7831
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7852
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x7852
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_O1/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 0x1c54d(%rip), %rsi     # 0x24700
leaq 0x1c681(%rip), %rdx     # 0x2483b
movq %rbx, %rdi
callq 0xd2ca
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 0x81f8
movq (%r15), %rsi
incq %rsi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc502
movq 0x480(%r14), %rax
movq 0x488(%r14), %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0xb8ad
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 0xb87f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb8b8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb8cf
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc4d0
movq (%r15), %rax
movq 0x48(%rax), %rcx
movq 0x50(%rax), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
testq %rdi, %rdi
jle 0xb96f
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 0xb9c7
movq $-0x1, (%r8,%rsi,8)
incq %r9
cmpq %r9, %rdi
jne 0xb956
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
testq %rax, %rax
jle 0xb9ad
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 0xb9c7
movq $0x1, (%rdi,%rsi,8)
incq %r8
cmpq %r8, %rax
jne 0xb994
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18675(%rip), %rdi     # 0x24043
xorl %eax, %eax
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x30(%rax), %rax
cmpq $-0x1, (%rax)
je 0xba96
movq %rdx, %r15
movq (%rdx), %rcx
movq 0x30(%rcx), %rax
cmpq %rax, 0x38(%rcx)
je 0xba6b
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 0xba49
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0xba51
movq %r12, %rdi
callq 0xd0b2
incq %r13
movq (%r15), %rcx
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0xba20
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
jmp 0xbaa8
addq $0x468, %r14            # imm = 0x468
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbf38
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xbabe
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xbad1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xbaea
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x42c0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x261ee(%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 0xc7dc
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq $0x0, 0x50(%rbx)
movsd 0x10(%rbx), %xmm0
movsd 0x17a03(%rip), %xmm1    # 0x242b0
callq 0x4500
mulsd 0x179fe(%rip), %xmm0    # 0x242b8
movsd %xmm0, 0x18(%rbx)
movq 0x8(%r15), %rax
subq (%r15), %rax
testq %rax, %rax
jle 0xc8f8
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 0xc8d2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0xc91a
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_O1/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), %rax
movabsq $0x41a705af1fe3fb79, %rdi # imm = 0x41A705AF1FE3FB79
testq %rax, %rax
jle 0xdf50
cmpq $0x0, 0x253ee(%rip)     # 0x33338
jne 0xdfd1
movq %rax, %rdx
negq %rdx
testq %rax, %rax
movl $0x1, %ecx
cmovsq %rdx, %rcx
movq %rcx, (%rsi)
movl $0x27, %r8d
leaq 0x253ce(%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 0xdfba
movq %rcx, (%r9,%r8,8)
addq $-0x1, %r8
jb 0xdf72
movq %rcx, (%rsi)
movq 0x25376(%rip), %rax     # 0x33340
movq %rax, 0x25367(%rip)     # 0x33338
movq (%rsi), %rcx
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)
movq 0x2531c(%rip), %rax     # 0x33338
leaq 0x3ffffff(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
shrq $0x1a, %rcx
movslq %ecx, %rax
leaq 0x25308(%rip), %rcx     # 0x33340
movq (%rcx,%rax,8), %rsi
movq %rsi, 0x252f5(%rip)     # 0x33338
cvtsi2sd %rsi, %xmm1
mulsd 0x168f0(%rip), %xmm1    # 0x24940
movq %rdx, (%rcx,%rax,8)
movsd 0x168ec(%rip), %xmm0    # 0x24948
minsd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfce9
sarq $0x3, %rcx
movq 0x28(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
cmpq $0x0, (%rax,%rsi,8)
je 0xfce1
movq (%rdx,%rsi,8), %rdi
movb $0x1, 0x30(%rdi)
incq %rsi
cmpq %rsi, %rcx
jne 0xfcd2
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfe7a
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 0xbaf2
movq 0x10(%r14), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0xbaf2
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xfee6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xfe1f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfe3b
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 0xfdc8
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xfed0
movq %rax, %r14
jmp 0xfeb4
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xfeb4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfed0
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_O1/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 0x22a24(%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 0x15cd2
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 0x16a8e
movq %r14, %rdi
movq %r12, %rsi
callq 0x4150
movl $0x18, %edi
callq 0x42b0
movq %rax, %r12
leaq 0x22a93(%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 0x1005f
movq %rax, %r12
jmp 0x10067
movq %rax, %r12
movq 0x480(%rbx), %rdi
testq %rdi, %rdi
je 0x1004a
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 0x15d60
addq $0x30, %rbx
movq %rbx, %rdi
callq 0xbb30
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0x1008d
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42c0
movq %r12, %rdi
callq 0x4510
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x120a
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 0x120a
movl %ecx, %eax
movl $0x91a2b3c5, %esi       # imm = 0x91A2B3C5
imulq %rax, %rsi
shrq $0x2b, %rsi
imull $0xe10, %esi, %eax      # imm = 0xE10
subl %eax, %ecx
imulq $0x4444445, %rcx, %rdx  # imm = 0x4444445
shrq $0x20, %rdx
imull $0x3c, %edx, %eax
subl %eax, %ecx
leaq 0xe2c(%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_O1/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 0x38b4
movq %rbx, %rdi
callq 0x3974
leaq 0x2b25(%rip), %r14      # 0x5004
callq 0x3bfb
decl %eax
cmpl $0x3, %eax
ja 0x24df
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
callq 0x40dc
movq %rbx, %rdi
movl %eax, %esi
callq 0x3a2e
jmp 0x24df
movq %rbx, %rdi
callq 0x3a74
jmp 0x24df
callq 0x4297
jmp 0x24df
leaq 0xc(%rsp), %rdi
callq 0x38cc
callq 0x2210
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2cd8
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 0x2e7e
movl $0x1, 0xa8(%r15)
movl $0x0, 0xc(%rsp)
movb $0x40, 0x14(%rsp)
cmpl $0x2, %ebp
jl 0x2605
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 0x30ba
incl %r13d
cmpl %r13d, %ebp
jne 0x25cc
movb $0x4f, 0x14(%rsp)
movl %r13d, 0x10(%rsp)
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x2630
movl 0x14(%rsp), %ecx
movl %ecx, -0x4(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, -0xc(%rax)
addq $-0xc, 0x18(%r15)
jmp 0x263d
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x30ba
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2653
movq %rax, %r15
jmp 0x265e
movq %rax, %r15
movq %r14, %rdi
callq 0x306a
movq %rbx, %rdi
callq 0x301a
movq %r15, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl (%rax), %ecx
movl %ecx, 0xc(%rsp)
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl %esi, 0x14(%rsp)
movq 0x88(%rdi), %rax
movq 0x98(%rdi), %rcx
addq $-0xc, %rcx
cmpq %rcx, %rax
je 0x26bd
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, (%rax)
addq $0xc, 0x88(%rdi)
jmp 0x26cb
addq $0x58, %rdi
leaq 0xc(%rsp), %rsi
callq 0x32e8
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21d0
movq 0x18(%rbx), %r14
cmpq 0x38(%rbx), %r14
je 0x273b
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %r15
movq 0x58de(%rip), %r12      # 0x7fd8
movq (%r12), %rdi
movl (%r14), %esi
movl 0x4(%r14), %edx
callq 0x21c0
cmpl $-0x1, %eax
je 0x271d
movq (%r12), %rdi
movsbl 0x8(%r14), %esi
callq 0x2090
addq $0xc, %r14
cmpq %r13, %r14
jne 0x2735
movq 0x8(%r15), %r14
addq $0x8, %r15
leaq 0x1f8(%r14), %r13
cmpq 0x38(%rbx), %r14
jne 0x26fa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22e0
nop