LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::vector<unsigned short, std::allocator<unsigned short>> const&)
void add(uint32_t tag, const std::vector<uint16_t>& data) {

        if (data.empty())
            return;

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

        if (store.size() & 1) {
            store += '\0';
        }

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

        for (uint16_t v : data) {
            add_uint16(v, store);
        }

        ++nentries;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24870
testb $0x1, %al
jne 0x227aa
jmp 0x227af
jmp 0x2288f
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x40(%rbp), %rsi
movl $0x3, %edi
callq 0x1d910
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
andq $0x1, %rax
cmpq $0x0, %rax
je 0x227ef
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rdi
callq 0x248b0
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x248d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24900
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x24930
testb $0x1, %al
jne 0x22850
jmp 0x2287f
leaq -0x28(%rbp), %rdi
callq 0x24970
movq -0x40(%rbp), %rsi
movw (%rax), %ax
movw %ax, -0x32(%rbp)
movw -0x32(%rbp), %ax
addq $0x20, %rsi
movzwl %ax, %edi
callq 0x1d860
leaq -0x28(%rbp), %rdi
callq 0x24990
jmp 0x2283d
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x28(%rbp), %rsi
movl $0x5, %edi
callq 0x1d910
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq %rax, %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
andq $0x7, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x22919
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
callq 0x4490
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x228f5
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x28(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x28(%rbp), %rsi
movl $0x1, %edi
callq 0x1d910
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edi
addq $0x20, %rsi
callq 0x1d9b0
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x4340
movl %eax, %ecx
movq -0x100(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, 0x8(%rax)
jge 0x22fb5
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0x108(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xe837(%rip), %rsi      # 0x31770
leaq -0x30(%rbp), %rdi
callq 0x22dc0
jmp 0x22f44
movq -0x108(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4230
jmp 0x22f56
movq -0x108(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
movq 0x17078(%rip), %rsi     # 0x39fe0
movq 0x17069(%rip), %rdx     # 0x39fd8
callq 0x4430
jmp 0x230cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22f9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4540
testb $0x1, -0x3d(%rbp)
jne 0x22fa4
jmp 0x22fb0
movq -0x108(%rbp), %rdi
callq 0x4630
jmp 0x230c6
movq -0x100(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0xd0(%rbp), %rsi
callq 0x4620
cmpl $0x0, %eax
jge 0x2307f
movb $0x1, -0xf1(%rbp)
movl $0x10, %edi
callq 0x42f0
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xe7a8(%rip), %rsi      # 0x3179f
leaq -0xf0(%rbp), %rdi
callq 0x22dc0
jmp 0x23005
movq -0x110(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x4230
jmp 0x2301a
movq -0x110(%rbp), %rdi
movb $0x0, -0xf1(%rbp)
movq 0x16fb1(%rip), %rsi     # 0x39fe0
movq 0x16fa2(%rip), %rdx     # 0x39fd8
callq 0x4430
jmp 0x230cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x23066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x4540
testb $0x1, -0xf1(%rbp)
jne 0x23071
jmp 0x2307d
movq -0x110(%rbp), %rdi
callq 0x4630
jmp 0x230c6
movq -0x100(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rsi
movl 0x8(%rax), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x4690
movq %rax, %rcx
movq -0x100(%rbp), %rax
movq %rcx, (%rax)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4440
nop
// File: ivan-tkatchev[P]makerpm/makerpm.cc
// Function: Store::add(unsigned int, std::vector<unsigned char, std::allocator<unsigned char>> const&)
void add(uint32_t tag, const std::vector<unsigned char>& data) {

        if (data.empty())
            return;

        add_uint32(tag, index);
        add_uint32(rpm::index_t::entry_t::TYPE_BIN, index);
        add_uint32(store.size(), index);
        add_uint32(data.size(), index);

        for (unsigned char c : data) {
            store += c;
        }

        ++nentries;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24e40
testb $0x1, %al
jne 0x231ca
jmp 0x231cf
jmp 0x23286
movq -0x40(%rbp), %rsi
movl -0xc(%rbp), %edi
callq 0x1d910
movq -0x40(%rbp), %rsi
movl $0x7, %edi
callq 0x1d910
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0x4270
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rdi
callq 0x24e80
movq -0x40(%rbp), %rsi
movl %eax, %edi
callq 0x1d910
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24ea0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24ed0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x24f00
testb $0x1, %al
jne 0x2324a
jmp 0x23276
leaq -0x28(%rbp), %rdi
callq 0x24f40
movq -0x40(%rbp), %rdi
movb (%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
addq $0x20, %rdi
movsbl %al, %esi
callq 0x4490
leaq -0x28(%rbp), %rdi
callq 0x24f60
jmp 0x23237
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd 0x3f2b7(%rip), %xmm0    # 0x45008
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x50, %rdi
callq 0x5fd0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x5e6a
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0x5ff0
movq (%rax), %rdi
callq 0x6030
testb $0x1, %al
jne 0x5da2
jmp 0x5ddc
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5e80
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5dda
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x70(%rax)
jmp 0x5e57
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0x5ff0
movsd -0x40(%rbp), %xmm1
movq -0x30(%rbp), %rdi
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0x6050
movsd 0x8(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5e55
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x28(%rbp), %rsi
callq 0x6050
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd 0x8(%rcx), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x70(%rax)
jmp 0x5e57
jmp 0x5e59
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5d5e
movq -0x30(%rbp), %rax
movb $0x0, 0x80(%rax)
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movsd 0x3df74(%rip), %xmm0    # 0x450a0
mulsd 0x30(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6050
movq (%rax), %rdi
callq 0x79c0
movsd 0x3df45(%rip), %xmm1    # 0x45098
mulsd %xmm1, %xmm0
movl $0x2, %edi
callq 0x7990
movq -0x10(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rdi)
callq 0x7190
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
xorps %xmm0, %xmm0
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq %rax, %rdi
callq 0x68d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x7bc0
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq %rax, %rdi
callq 0x68d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x7bc0
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0xb8(%rax), %rsi
callq 0x70f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq $-0x1, (%rcx)
movq %rax, %rdi
addq $0xa0, %rdi
movq 0xb8(%rax), %rsi
callq 0x70f0
movq $0x1, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x5ff0
movq (%rax), %rdi
callq 0x7ad0
movq %rax, %rdi
callq 0x7af0
movsd -0x38(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, %xmm1
movaps 0x3d919(%rip), %xmm2    # 0x450b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x3d91d(%rip), %xmm2    # 0x450c0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x5280
movq -0x20(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0x6090
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
cvtsi2sd %rax, %xmm1
mulsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x8(%rax)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movsd 0x8(%rax), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nwieder[P]SSTS/src/Events/Diffusion_Evt.cpp
// Function: nw::Diffusion_Evt::get_a()
double Diffusion_Evt::get_a(){
	double a_ges = 0;
	for(long i = 0; i < (long) tv_vec.size(); i++){
		a_ges += c*tv_vec[i].v->get_state_vec()->at(diff_spec_id)->get_n_molecules() *
				tv_vec[i].v->get_diff_vec()->size();
	}
	return a_ges;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
callq 0x5fd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x797e
movq -0x20(%rbp), %rdi
movsd 0x78(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x50, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0xb8(%rax), %rsi
callq 0x6090
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rdi
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x7ad0
movq %rax, %rdi
callq 0x7af0
movsd -0x30(%rbp), %xmm0
movq %rax, %xmm2
movaps 0x3d770(%rip), %xmm1    # 0x450b0
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movapd 0x3d774(%rip), %xmm1    # 0x450c0
subpd %xmm1, %xmm2
movaps %xmm2, %xmm1
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm1, %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7894
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x8920
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6d10
cmpq $0x1, %rax
jne 0x889f
movq -0x10(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0x78(%rax)
jmp 0x8907
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6d10
cmpq $0x2, %rax
jne 0x8905
movq -0x10(%rbp), %rdi
movsd 0x30(%rdi), %xmm0
movsd %xmm0, -0x18(%rbp)
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6050
movq (%rax), %rdi
callq 0x9000
movq -0x10(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
movsd 0x3c834(%rip), %xmm2    # 0x45120
mulsd %xmm2, %xmm1
movsd 0x3c820(%rip), %xmm2    # 0x45118
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rax)
jmp 0x8907
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
xorps %xmm0, %xmm0
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movq 0x70(%rax), %rsi
callq 0x6050
movq -0x50(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rsi
leaq -0x20(%rbp), %rdi
callq 0x79e0
jmp 0x89ee
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x20(%rbp), %rsi
callq *%rax
jmp 0x8a01
leaq -0x20(%rbp), %rdi
callq 0x61a0
movq -0x50(%rbp), %rax
movb $0x1, 0x80(%rax)
movq $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x88, %rdi
callq 0x7b50
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x8af3
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
movq -0x38(%rbp), %rsi
callq 0x7b70
movq (%rax), %rdi
movl $0x1, %esi
callq 0x7b90
jmp 0x8a68
jmp 0x8a6a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8a1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x8a9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x61a0
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8b0a
movq -0x28(%rbp), %rdi
callq 0x5110
movq %rax, -0x40(%rbp)
movq 0x55515(%rip), %rdi     # 0x5dfd0
leaq 0x3c666(%rip), %rsi     # 0x45128
callq 0x5300
movq %rax, -0x60(%rbp)
jmp 0x8acd
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5300
jmp 0x8ae8
callq 0x55d0
addq $0x60, %rsp
popq %rbp
retq
jmp 0x8aed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x55d0
jmp 0x8b08
jmp 0x8b0a
movq -0x28(%rbp), %rdi
callq 0x5650
movq %rax, %rdi
callq 0x6240
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0xa0, %rdi
callq 0x6d10
cmpq $0x0, %rax
jbe 0x8ea2
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6d10
cmpq $0x2, %rax
ja 0x8ea2
movq -0x28(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0xa0, %rdi
callq 0x6d10
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x8e38
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0xa0, %rdi
movq -0x20(%rbp), %rsi
callq 0x70f0
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x6090
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cvtsi2sd %rax, %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8dae
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
callq 0x5280
movq -0x28(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movsd %xmm0, 0x8(%rax)
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
callq 0x6050
movsd 0x8(%rax), %xmm0
addq $0x40, %rsp
popq %rbp
retq
movq 0x55127(%rip), %rdi     # 0x5dfd0
leaq 0x3c292(%rip), %rsi     # 0x45142
callq 0x5300
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
callq 0x52c0
movq %rax, %rdi
movq 0x550d1(%rip), %rsi     # 0x5dfa0
callq 0x5340
xorl %edi, %edi
callq 0x5420
nopl (%rax,%rax)
// File: nwieder[P]SSTS/src/Events/Reaction_Evt.cpp
// Function: nw::Reaction_Evt::get_a()
double Reaction_Evt::get_a(){
	double a_ges = 0;
	for(size_t i = 0; i < tv_vec.size(); ++i){
		double a = c;
		for (size_t j = 0; j < educt_vec.size(); ++j){
			a *= tv_vec[i].v->get_state_vec()->at(educt_vec[j])->get_n_molecules();
		}
		a_ges += a;
	}
	return a_ges;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x50, %rdi
callq 0x5fd0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x8fe9
movq -0x30(%rbp), %rax
movsd 0x78(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0xa0, %rdi
callq 0x6d10
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x8fc9
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0xa0, %rdi
movq -0x28(%rbp), %rsi
callq 0x70f0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
callq 0x6090
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cvtsi2sd %rax, %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8f3f
movsd -0x20(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x8f04
movsd -0x10(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, %rdi
addq $0x50, %rdi
movq 0x70(%rax), %rsi
callq 0x6050
movq -0x50(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x38, %rsi
leaq -0x20(%rbp), %rdi
callq 0x79e0
jmp 0x93b1
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x20(%rbp), %rsi
callq *%rax
jmp 0x93c4
leaq -0x20(%rbp), %rdi
callq 0x61a0
movq $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x88, %rdi
callq 0x7b50
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jge 0x94b2
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
movq -0x38(%rbp), %rsi
callq 0x7b70
movq (%rax), %rdi
movl $0x1, %esi
callq 0x7b90
jmp 0x9420
jmp 0x9422
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x93d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9453
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x61a0
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9558
movq -0x28(%rbp), %rdi
callq 0x5110
movq %rax, -0x40(%rbp)
movq 0x54b59(%rip), %rdi     # 0x5dfd0
leaq 0x3bd45(%rip), %rsi     # 0x451c3
callq 0x5300
movq %rax, -0x60(%rbp)
jmp 0x9489
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5300
jmp 0x94a4
callq 0x55d0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rax
movq %rax, %rdi
addq $0x50, %rdi
movq 0x70(%rax), %rsi
callq 0x6050
movq (%rax), %rdi
callq 0x6070
movq %rax, -0x68(%rbp)
jmp 0x94d4
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0xc8(%rax), %rsi
callq 0x6090
movq %rax, -0x70(%rbp)
jmp 0x94ee
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x9520
movq -0x78(%rbp), %rdi
leaq 0x543c6(%rip), %rsi     # 0x5d8d0
leaq 0x543cf(%rip), %rdx     # 0x5d8e0
xorl %eax, %eax
movl %eax, %ecx
callq 0x53b0
movq %rax, -0x80(%rbp)
jmp 0x9528
xorl %eax, %eax
movq %rax, -0x80(%rbp)
jmp 0x9528
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, 0xb8(%rdi)
callq 0x9570
jmp 0x953e
jmp 0x94a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x55d0
jmp 0x9556
jmp 0x9558
movq -0x28(%rbp), %rdi
callq 0x5650
movq %rax, %rdi
callq 0x6240
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
addq $0x38, %rdi
movq 0xc0(%rax), %rsi
callq 0x60d0
cmpq $0x0, (%rax)
jle 0x95f2
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq 0xb8(%rax), %rdi
callq 0x9690
movsd -0x28(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cvtsi2sd %rcx, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, -0x10(%rbp)
movq 0xb8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x19260
jmp 0x9685
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0xc0(%rax), %rsi
callq 0x60d0
cmpq $0x0, (%rax)
jge 0x9661
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x20(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movq 0xb8(%rax), %rdi
callq 0x96b0
movsd -0x30(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cvtsi2sd %rcx, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, -0x18(%rbp)
movq 0xb8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x193c0
jmp 0x9683
movq 0x54968(%rip), %rdi     # 0x5dfd0
leaq 0x3bb77(%rip), %rsi     # 0x451e6
callq 0x5300
movq %rax, %rdi
movq 0x54922(%rip), %rsi     # 0x5dfa0
callq 0x5340
jmp 0x9685
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa1e0
movl $0xf00, %edi            # imm = 0xF00
callq 0x5320
movq -0xb0(%rbp), %rsi
movq %rax, -0xa8(%rbp)
movb $0x1, -0x69(%rbp)
movq 0x70(%rsi), %rax
movq %rax, -0xa0(%rbp)
cvttsd2si 0x78(%rsi), %rax
movq %rax, -0x98(%rbp)
movsd 0x80(%rsi), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd 0x88(%rsi), %xmm0
movsd %xmm0, -0x88(%rbp)
movq %rsi, %rax
addq $0x450, %rax            # imm = 0x450
movq %rax, -0x80(%rbp)
movq %rsi, %rax
addq $0x468, %rax            # imm = 0x468
movq %rax, -0x78(%rbp)
addq $0x10, %rsi
leaq -0x28(%rbp), %rdi
callq 0x5130
jmp 0xa09c
movq -0xb0(%rbp), %rsi
addq $0x98, %rsi
leaq -0x50(%rbp), %rdi
callq 0x79e0
jmp 0xa0b5
movq -0xb0(%rbp), %rsi
addq $0xb0, %rsi
leaq -0x68(%rbp), %rdi
callq 0x79e0
jmp 0xa0ce
movq -0x78(%rbp), %r8
movq -0x80(%rbp), %rcx
movsd -0x88(%rbp), %xmm1
movsd -0x90(%rbp), %xmm0
movq -0x98(%rbp), %rdx
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
movq %rsp, %rax
leaq -0x68(%rbp), %r9
movq %r9, 0x8(%rax)
leaq -0x50(%rbp), %r9
movq %r9, (%rax)
leaq -0x28(%rbp), %r9
callq 0x19550
jmp 0xa118
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb $0x0, -0x69(%rbp)
movq %rcx, 0x8(%rax)
leaq -0x68(%rbp), %rdi
callq 0x61a0
leaq -0x50(%rbp), %rdi
callq 0x61a0
leaq -0x28(%rbp), %rdi
callq 0x5768
movq -0xb0(%rbp), %rax
movq 0x8(%rax), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xa1ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xa1a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xa19c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x61a0
leaq -0x50(%rbp), %rdi
callq 0x61a0
leaq -0x28(%rbp), %rdi
callq 0x5768
testb $0x1, -0x69(%rbp)
jne 0xa1b6
jmp 0xa1c7
movq -0xa8(%rbp), %rdi
movl $0xf00, %esi            # imm = 0xF00
callq 0x5330
jmp 0xa1c9
movq -0x30(%rbp), %rdi
callq 0x5650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x52d0
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5660
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x3a8c4(%rip), %rsi     # 0x456d8
callq 0xed50
jmp 0xae1b
leaq -0x1a(%rbp), %rdi
callq 0x5360
leaq -0x18(%rbp), %rdi
callq 0x5100
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x52e0
jmp 0xae3b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xae7e
jmp 0xae75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x5360
jmp 0xae88
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5768
jmp 0xae88
movq -0x40(%rbp), %rdi
callq 0x5768
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5650
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x10490
movq -0x40(%rbp), %rdi
addq $0x480, %rdi            # imm = 0x480
callq 0x68d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x104b0
jmp 0xe9da
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x480, %rdi            # imm = 0x480
callq 0x68d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jge 0xea65
movq -0x40(%rbp), %rdi
addq $0x480, %rdi            # imm = 0x480
movq -0x30(%rbp), %rsi
callq 0x68b0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x58(%rbp)
jmp 0xea2c
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x68b0
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe9e2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xf0d0
jmp 0xea82
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xea78
movq -0x38(%rbp), %rdi
callq 0xf0d0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5650
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x18, %edi
callq 0x5320
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x10390
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x30(%rbp)
addq $0x468, %rax            # imm = 0x468
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x70f0
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x8180
movq (%rax), %rdi
callq 0x6070
movq %rax, %rdi
callq 0x68d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x103b0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x48, %rdi
callq 0x6d10
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jge 0xeb93
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x48, %rdi
movq -0x28(%rbp), %rsi
callq 0x60d0
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
callq 0x60d0
movq $-0x1, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xeb32
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x60, %rdi
callq 0x6d10
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jge 0xebfc
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x60, %rdi
movq -0x28(%rbp), %rsi
callq 0x60d0
movq -0x78(%rbp), %rdi
movq (%rax), %rsi
callq 0x60d0
movq $0x1, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xeb9b
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x79e0
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10440
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x70f0
cmpq $-0x1, (%rax)
jne 0xeca6
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x468, %rsi            # imm = 0x468
callq 0xfb80
jmp 0xec80
movl $0x1, -0x40(%rbp)
jmp 0xed32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf130
jmp 0xed45
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
callq 0x6d10
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xed1e
movq -0x50(%rbp), %rax
addq $0x468, %rax            # imm = 0x468
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq -0x48(%rbp), %rsi
callq 0x70f0
movq -0x70(%rbp), %rdi
movq (%rax), %rsi
callq 0x8180
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xfa30
jmp 0xed0e
jmp 0xed10
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xecae
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10460
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf130
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5650
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq 0x4c0f1(%rip), %rax     # 0x5da88
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movb $0x1, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x11870
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x50(%rbp)
callq 0x10440
movq -0x48(%rbp), %rax
movsd 0x10(%rax), %xmm0
movl $0x3, %edi
callq 0x7990
movsd %xmm0, -0x40(%rbp)
jmp 0x119e8
movq -0x48(%rbp), %rax
movsd -0x40(%rbp), %xmm0
movsd 0x33897(%rip), %xmm1    # 0x45290
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
movq $0x0, -0x38(%rbp)
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x68d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jge 0x11a82
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq -0x38(%rbp), %rsi
callq 0x68b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rdi
movsd 0x18(%rax), %xmm0
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x11a52
jmp 0x11a54
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x11a0a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xf130
movq -0x58(%rbp), %rdi
callq 0xf0d0
jmp 0x11a88
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5650
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nwieder[P]SSTS/src/Species/Channel_Spc.cpp
// Function: nw::Channel_Spc::activate_Subunit(long)
void Channel_Spc::activate_Subunit(long rnd_id){
	ch_it = ch_Vec.begin();

//	iterate to an activatable channel
	for (size_t i = 0; i <= size_t(rnd_id);++i){
		if(i!=0){ch_it++;}
		while(*ch_it == n_Subunits){
			ch_it++;
		}
	}

//	decrease number of completely inactivated Channel if it was a Channel with 0 active su
	if(*ch_it == 0){n_fully_inactivated_Ch--; dirty_flag = true;}
//	increase number of active subunits and check if the channel is open!
	if(++*ch_it == n_Subunits_To_Open){n_active_Ch++; dirty_flag = true;}
//	if the channel is completely activated, increase number of fully activated channels
	if (*ch_it == n_Subunits) {n_fully_activated_Ch++; dirty_flag = true;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x70, %rdi
callq 0x6c10
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x19310
cmpq $0x0, -0x20(%rbp)
je 0x192c6
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
callq 0x19510
movq %rax, -0x28(%rbp)
jmp 0x192c8
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movslq 0x50(%rcx), %rcx
cmpq %rcx, %rax
jne 0x19300
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
callq 0x19510
movq %rax, -0x30(%rbp)
jmp 0x192c8
jmp 0x19302
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1929f
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
cmpq $0x0, (%rax)
jne 0x1933a
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movb $0x1, 0x30(%rax)
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq (%rdx), %rax
addq $0x1, %rax
movq %rax, (%rdx)
movslq 0x54(%rcx), %rcx
cmpq %rcx, %rax
jne 0x19378
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movb $0x1, 0x30(%rax)
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movslq 0x50(%rcx), %rcx
cmpq %rcx, %rax
jne 0x193ac
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movb $0x1, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nwieder[P]SSTS/src/Species/Channel_Spc.cpp
// Function: nw::Channel_Spc::inactivate_Subunit(long)
void Channel_Spc::inactivate_Subunit(long rnd_id){
	ch_it = ch_Vec.begin();
//	iterate to an inactivatable channel
	for (size_t i = 0; i <= (size_t)rnd_id;++i){
		if(i!=0){ch_it++;}
		while(*ch_it == 0){
			ch_it++;
		}
	}

//	decrease number of fully activated Channel if it was a Channel with maximum active su
	if(*ch_it == n_Subunits){n_fully_activated_Ch--; dirty_flag = true;}
//	decrease number of active subunits and check if the channel is open!
	if(*ch_it == n_Subunits_To_Open){n_active_Ch--; dirty_flag = true;}
//	if the channel is completely inactivated, increase number of fully inactivated channels
	if (--*ch_it == 0) {n_fully_inactivated_Ch++; dirty_flag = true;}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x70, %rdi
callq 0x6c10
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x19466
cmpq $0x0, -0x20(%rbp)
je 0x19426
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
callq 0x19510
movq %rax, -0x28(%rbp)
jmp 0x19428
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
cmpq $0x0, (%rax)
jne 0x19456
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
xorl %esi, %esi
callq 0x19510
movq %rax, -0x30(%rbp)
jmp 0x19428
jmp 0x19458
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x193ff
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movslq 0x50(%rcx), %rcx
cmpq %rcx, %rax
jne 0x1949a
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x60(%rax)
movb $0x1, 0x30(%rax)
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movslq 0x54(%rcx), %rcx
cmpq %rcx, %rax
jne 0x194ce
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
movb $0x1, 0x30(%rax)
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
callq 0x9350
movq %rax, %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x19505
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
movb $0x1, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, 0x20(%rax)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6d10
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b776
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x70f0
cmpq $0x0, (%rax)
je 0x1b766
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x68b0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x1b780
jmp 0x1b768
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1b718
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6d10
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x68d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x1b8ac
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
callq 0x68d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b8a2
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x68b0
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
callq 0x70f0
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1b841
movq -0x28(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x1b8bf
movq 0x4271d(%rip), %rdi     # 0x5dfd0
leaq 0x2a253(%rip), %rsi     # 0x45b0d
callq 0x5300
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop