LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::logTransformData()
void Data::logTransformData() {
	for(map<string,map<double,double> >::iterator c = dataCurrent->begin(); c != dataCurrent->end(); ++c) {
		for(map<double,double>::iterator v = c->second.begin(); v != c->second.end(); ++v) {
			if (v->second == 0) {
				swarm_->outputError("You chose to log transform simulation output, but the first value in the column '" + c->first + "' is 0. We cannot take the log of 0.");
			}
			else if (std::isnan(v->second)) {
				dataLogTransformed_[c->first][v->first] = nan("1");
				continue;
			}
			dataLogTransformed_[c->first][v->first] = log10(v->second)/log10(swarm_->options.logTransformSimData);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x18(%r14), %rdi
leaq 0x8(%r14), %rax
cmpq %rax, %rdi
je 0x49b2a
leaq 0xf0(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %r15
movq 0x58(%rdi), %rbp
leaq 0x48(%rdi), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x49b15
movq %rdi, 0x30(%rsp)
leaq 0x20(%rdi), %r12
movsd 0x28(%rbp), %xmm0
ucomisd 0xad120(%rip), %xmm0    # 0xf6ae8
jne 0x49a1c
jp 0x49a1c
movq 0x150(%rbx), %r14
leaq 0x48(%rsp), %r13
movq %r13, %rdi
leaq 0xad409(%rip), %rsi     # 0xf6deb
movq %r12, %rdx
callq 0x31944
movq %r13, %rdi
leaq 0xad449(%rip), %rsi     # 0xf6e3d
callq 0x233b0
movq %r15, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49a39
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x49a42
ucomisd %xmm0, %xmm0
jnp 0x49a9f
leaq 0xaf1b3(%rip), %rdi     # 0xf8bdc
callq 0x22130
movsd %xmm0, 0x8(%rsp)
jmp 0x49ad1
movupd (%rcx), %xmm0
movupd %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x784c2
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x49a7e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x49a9a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x229c0
movsd 0x28(%rbp), %xmm0
callq 0x22480
movsd %xmm0, 0x8(%rsp)
movq 0x150(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0x1640(%rax), %xmm0
callq 0x22480
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
leaq 0x20(%rbp), %r14
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x4a1ce
movq %rax, %rdi
movq %r14, %rsi
callq 0x4a332
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbp, %rdi
callq 0x22670
movq %rax, %rbp
cmpq 0x40(%rsp), %rax
jne 0x499bb
movq (%rbx), %r14
movq 0x30(%rsp), %rdi
callq 0x22670
movq %rax, %rdi
leaq 0x8(%r14), %rax
cmpq %rax, %rdi
jne 0x4999c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x49b58
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x49b58
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x49b74
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::Data(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<double, double, std::less<double>, std::allocator<std::pair<double const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<double, double, std::less<double>, std::allocator<std::pair<double const, double>>>>>>&)
Data::Data(map<string, map<double, double> > &dataSet) {
	dataOrig_ = dataSet;
	dataCurrent = &dataOrig_;
	isExp_ = false;
	swarm_ = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
leaq 0x80(%rdi), %rbp
movq %rbp, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movb $0x0, 0x80(%rdi)
leaq 0x90(%rdi), %r14
leaq 0x98(%rdi), %rcx
movl %eax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq %rcx, 0xa8(%rdi)
movq %rcx, 0xb0(%rdi)
movq %rax, 0xb8(%rdi)
leaq 0xc8(%rdi), %rcx
movl %eax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rcx, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
leaq 0xf8(%rdi), %rcx
movl %eax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movq %rcx, 0x110(%rdi)
movq %rax, 0x118(%rdi)
leaq 0x128(%rdi), %rcx
movl %eax, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movq %rcx, 0x138(%rdi)
movq %rcx, 0x140(%rdi)
movq %rax, 0x148(%rdi)
movq %r14, %rdi
callq 0x4a4ea
movq %r14, (%rbx)
movb $0x0, 0x158(%rbx)
movq $0x0, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x120(%rbx), %rdi
leaq 0xf0(%rbx), %r12
leaq 0xc0(%rbx), %r13
callq 0x4a39e
movq %r12, %rdi
callq 0x4a39e
movq %r13, %rdi
callq 0x4a39e
movq %r14, %rdi
callq 0x4a39e
movq 0x70(%rbx), %rdi
cmpq %rbp, %rdi
je 0x49e7b
movq (%rbp), %rsi
incq %rsi
callq 0x229c0
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
callq 0x4a472
movq %rbx, %rdi
callq 0x4a39e
movq %r15, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::Data()
Data::Data() {
	map<string, map<double, double> > dummySet;
	dataOrig_ = dummySet;
	dataCurrent = 0;
	isExp_ = false;
	swarm_ = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
leaq 0x80(%rdi), %r15
movq %r15, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movb $0x0, 0x80(%rdi)
leaq 0x90(%rdi), %r14
leaq 0x98(%rdi), %rcx
movl %eax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq %rcx, 0xa8(%rdi)
movq %rcx, 0xb0(%rdi)
movq %rax, 0xb8(%rdi)
leaq 0xc8(%rdi), %rcx
movl %eax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rcx, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
leaq 0xf8(%rdi), %rcx
movl %eax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movq %rcx, 0x110(%rdi)
movq %rax, 0x118(%rdi)
leaq 0x128(%rdi), %rcx
movl %eax, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movq %rcx, 0x138(%rdi)
movq %rcx, 0x140(%rdi)
movq %rax, 0x148(%rdi)
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4a4ea
xorl %eax, %eax
movq %rax, (%rbx)
movb $0x0, 0x158(%rbx)
movq %rax, 0x150(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x4a39e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, (%rsp)
leaq 0x120(%rbx), %r12
leaq 0xf0(%rbx), %r13
leaq 0xc0(%rbx), %rbp
leaq 0x8(%rsp), %rdi
callq 0x4a39e
movq %r12, %rdi
callq 0x4a39e
movq %r13, %rdi
callq 0x4a39e
movq %rbp, %rdi
callq 0x4a39e
movq %r14, %rdi
callq 0x4a39e
movq 0x70(%rbx), %rdi
cmpq %r15, %rdi
je 0x4a041
movq (%r15), %rsi
incq %rsi
callq 0x229c0
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
callq 0x4a472
movq %rbx, %rdi
callq 0x4a39e
movq (%rsp), %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::getPath[abi:cxx11]()
std::string Data::getPath() {
	if (!dataPath.empty())
		return dataPath;
	else
		return "empty";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rsi), %rdx
leaq 0x10(%rdi), %rax
testq %rdx, %rdx
je 0x4a085
movq %rax, (%rbx)
movq 0x70(%rsi), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3213c
jmp 0x4a09e
movq %rax, (%rbx)
leaq 0xb1bb3(%rip), %rsi     # 0xfbc42
leaq 0xb1bb1(%rip), %rdx     # 0xfbc47
movq %rbx, %rdi
callq 0x321d2
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/FreeParam.cpp
// Function: FreeParam::FreeParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FreeParam::FreeParam(string parameterName) {
	parameterName_ = parameterName;
	generationMethod_ = "";
	hasMutation_ = false;
	mutationRate_ = 0;
	mutationFactor_ = 0;
	genMin_ = 0;
	genMax_ = 0;
	isLog_ = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
callq 0x22500
movq 0x28(%rbx), %rdx
leaq 0xa9aee(%rip), %rcx     # 0xf6c71
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22fb0
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movw $0x0, 0x50(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4d1be
movq (%r13), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2387d
movq %r12, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/FreeParam.cpp
// Function: FreeParam::FreeParam()
FreeParam::FreeParam() {
	parameterName_ = "";
	generationMethod_ = "";
	hasMutation_ = false;
	mutationRate_ = 0;
	mutationFactor_ = 0;
	genMin_ = 0;
	genMax_ = 0;
	isLog_ = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0xa9a69(%rip), %rcx     # 0xf6c71
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x22fb0
movq 0x28(%rbx), %rdx
leaq 0xa9a52(%rip), %rcx     # 0xf6c71
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22fb0
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movw $0x0, 0x50(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4d25a
movq (%r13), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23891
movq %r12, %rdi
callq 0x23240
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Model.cpp
// Function: Model::Model(Swarm*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Model::Model(Swarm * swarm, string path) {

	swarm_ = swarm;
	hasGenerateNetwork_ = false;
	modelPath_ = convertToAbsPath(path);
	parseModel();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x38(%rdi), %rax
movl %ecx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x68(%rdi), %r14
leaq 0x78(%rdi), %r13
movq %r13, 0x68(%rdi)
movq %rcx, 0x70(%rdi)
movb %cl, 0x78(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa8(%rdi)
movq %rsi, 0x60(%rdi)
movb %cl, 0xb8(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x3213c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xbdb20
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22bb0
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4d338
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4d34e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x4d3cc
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4d381
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4d384
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x4d384
movq %rax, %r15
leaq 0x88(%rbx), %r12
leaq 0xa0(%rbx), %rdi
callq 0x31a0a
movq %r12, %rdi
callq 0x31a0a
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4d3b3
movq (%r13), %rsi
incq %rsi
callq 0x229c0
leaq 0x30(%rbx), %rdi
callq 0x5169e
movq %rbx, %rdi
callq 0x51716
movq %r15, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
void Parser::split(string in, string& left, string& right, char c) {
	size_t pos = in.find_first_of(c);
	if(pos == string::npos) {
		left = in;
		trim(left);
		right = "";
	} else if (pos <= 1) {
		left = "";
		right = in.substr(pos+1, string::npos);
		trim(right);
	} else {
		left = in.substr(0, pos-1);
		trim(left);
		right = in.substr(pos+1, string::npos);
		trim(right);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rsi, %rdi
movl %r8d, %esi
xorl %edx, %edx
callq 0x22c80
cmpq $-0x1, %rax
je 0x52a8c
movq %rax, %r15
cmpq $0x1, %rax
ja 0x52ac4
movq 0x8(%r12), %rdx
leaq 0xa422f(%rip), %rcx     # 0xf6c71
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22fb0
incq %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x22a00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22bb0
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
jne 0x52b35
jmp 0x52b42
movq %r12, %rdi
movq %r14, %rsi
callq 0x22500
movq %r12, %rsi
callq 0x52c38
movq 0x8(%rbx), %rdx
leaq 0xa41c7(%rip), %rcx     # 0xf6c71
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22fb0
leaq -0x1(%r15), %rcx
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x22a00
movq %r12, %rdi
movq %r13, %rsi
callq 0x22bb0
movq (%r13), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x52afe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %r12, %rsi
callq 0x52c38
incq %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x22a00
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22bb0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x52b42
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rsi
callq 0x52c38
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::pString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::pString(string name) {
	map<string, string>::iterator i = symbols.find(name);
	if (i == symbols.end()) {
		//logError(cout << "access of missing property '" << name << "' (" << debugInfo << ")" << endl);
		exit(4);
	}
	return i->second;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x53a92
addq $0x8, %r14
cmpq %r14, %rax
je 0x52fcf
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3213c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4, %edi
callq 0x22b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::pBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::pBool(string name) {
	string val = pString(name);

	if ( (val == "yes") ||
	     (val == "Yes") ||
	     (val == "YES") ||
		 (val == "true") ||
	     (val == "True") ||
	     (val == "TRUE"))
	{
		return true;
	}

	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3213c
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x52f8c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x5302e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
leaq 0xa5232(%rip), %rsi     # 0xf8267
movq %rsp, %rdi
callq 0x22250
movb $0x1, %bl
testl %eax, %eax
je 0x530a3
leaq 0xa5221(%rip), %rsi     # 0xf826b
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x530a3
leaq 0xa5212(%rip), %rsi     # 0xf826f
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x530a3
leaq 0xa5203(%rip), %rsi     # 0xf8273
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x530a3
leaq 0xa51f5(%rip), %rsi     # 0xf8278
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x530a3
leaq 0xa51e7(%rip), %rsi     # 0xf827d
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
sete %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x530be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x530e4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::objFunc_divByMeasured(double, double, double)
double Particle::objFunc_divByMeasured(double sim, double exp, double dummyvar) {
	if(swarm_->options.verbosity >=4){
		cout << "sim: " << sim << endl;
		cout << "exp: " << exp << endl;
	}
	if(sim!=0){
		return pow(((abs(sim) - exp) / sim), 2);
	}else{
		return pow(((abs(sim) - exp)), 2); //Raquel solving division by zero problem

	}

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm3
movq 0xa8(%rdi), %rax
cmpl $0x4, 0x1614(%rax)
jb 0x53f01
movq 0x122156(%rip), %rbx    # 0x175fa8
leaq 0xa4538(%rip), %rsi     # 0xf8391
movl $0x5, %edx
movq %rbx, %rdi
movapd %xmm3, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x22ab0
movq %rbx, %rdi
movaps 0x10(%rsp), %xmm0
callq 0x23060
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %r14, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
leaq 0xa44e7(%rip), %rsi     # 0xf8397
movl $0x5, %edx
movq %rbx, %rdi
callq 0x22ab0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x23060
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %rbx, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
movsd 0x8(%rsp), %xmm1
movapd 0x10(%rsp), %xmm3
movapd 0xa3d47(%rip), %xmm4    # 0xf7c50
andpd %xmm3, %xmm4
subsd %xmm1, %xmm4
movapd %xmm4, %xmm2
divsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm4, %xmm4
xorpd %xmm0, %xmm0
cmpneqsd %xmm3, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm4, %xmm3
andpd %xmm2, %xmm0
orpd %xmm3, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::getCentroid(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
vector<double> Particle::getCentroid(vector<vector<double> > centroidVectors) {
	vector<double> centroid;

	for (unsigned int d = 0; d < centroidVectors[0].size(); ++d) {
		double sum = 0;
		for (unsigned int set = 0; set < centroidVectors.size(); ++set) {
			sum += centroidVectors[set][d];
		}
		centroid.push_back(sum / centroidVectors[0].size());
	}

	return centroid;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
cmpq %rdx, %rcx
je 0x5404f
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x8(%rsp), %r15
movq 0x8(%r14), %rsi
subq %rax, %rsi
je 0x53fd6
sarq $0x3, %rsi
imulq %r13, %rsi
xorpd %xmm0, %xmm0
movl $0x1, %edi
movq %rax, %r8
movq (%r8), %r9
addsd (%r9,%r12,8), %xmm0
movl %edi, %r9d
addq $0x18, %r8
incl %edi
cmpq %r9, %rsi
ja 0x53fbd
jmp 0x53fda
xorpd %xmm0, %xmm0
subq %rdx, %rcx
sarq $0x3, %rcx
movq %rcx, %xmm1
punpckldq 0xa42a2(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xa42aa(%rip), %xmm1    # 0xf82a0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x54024
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x54032
movq %rbx, %rdi
movq %r15, %rdx
callq 0x67e5a
movq (%r14), %rax
incl %r12d
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rcx, %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq %r12, %rsi
ja 0x53fa0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x54077
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::setModel(Model*, unsigned int)
void Particle::setModel(Model * model, unsigned int mid) {
	//cout<<"press a key to set model. Model size:"<<models.size()<<" mid:"<<mid;	//mypause();

	/* razi: moved to constructor
	int gap = mid+1-models.size();
	if(gap>0)
		for (int i=0; i<gap; i++)
			models.push_back(0);
	*/
	if (mid>=models.size())  outputError("setModel failed. Invalid model id:"+toString(mid)+". I am quitting....");
	models.at(mid)=model;   //the list is not long enough
	//cout<<"Model is set. press a key  Model size:"<<models.size()<<endl; //mypause();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %eax
movq %rsi, %r14
movl %edx, %ebx
movq 0x78(%rdi), %rcx
movq 0x80(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
ja 0x65243
movq %rdi, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movl %eax, %esi
callq 0xbfa49
leaq 0x93778(%rip), %rcx     # 0xf88aa
movl $0x22, %r8d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22a80
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6516b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x65173
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rsp, %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x93739(%rip), %rsi     # 0xf88cd
callq 0x233b0
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x651c0
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x651c8
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0xbfa27
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x65200
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x65216
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65231
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x78(%r15), %rcx
movq 0x80(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0x6525a
movq %r14, (%rcx,%rbx,8)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8e418(%rip), %rdi     # 0xf3679
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22f40
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x6528a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x6528a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x652a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x652a5
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x652c0
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: subParticle::subParticle(Particle*, unsigned int, unsigned int)
subParticle::subParticle(Particle * p, unsigned int modelId, unsigned int subParID) {
	parParticle = p;
	mid_ = modelId;   //razi: model id startuing from 0
	subParID_=subParID;   //razi: global subPar Id

	p->addSubParticle(this, modelId, true);
}

// Assembly:
movq %rdi, %rax
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0x18(%rdi)
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %ecx
jmp 0x652e4
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: subParticle::setModel(unsigned int)
void subParticle::setModel(unsigned int mid){
	if (!parParticle) {
		cout<<"Particle::setModel Error: Parent Particle is not set yet. I'm quitting ....\n";
		exit(0);
	}

	if (!parParticle->swarm_) {
		cout<<"Particle::setModel Error: Swarm object is not set yet. I'm quitting ....\n";
		exit(0);
	}

	if (mid_!=mid) {
		parParticle->swarm_->outputError("Particle::setModel Error: Trying to set invalid model id. I'm quitting ....");
		exit(0);
	}

	if ((mid<0) || (mid >= parParticle->swarm_->options.models.size())) {
		parParticle->swarm_->outputError("Particle::setModel Error: Particle model out of range. I'm quitting ....");
		exit(0);
	}

	model = parParticle->swarm_->options.models.at(mid);
	//parParticle->swarm_->setParticleModelId(id_, mid);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x655d4
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x655e4
cmpl %esi, 0x8(%rdi)
jne 0x655f9
movl %esi, %eax
movq 0x15c0(%rbx), %rcx
movq 0x15c8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x6562f
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1109cd(%rip), %rdi    # 0x175fa8
leaq 0x942b2(%rip), %rsi     # 0xf9894
jmp 0x655f2
movq 0x1109bd(%rip), %rdi    # 0x175fa8
leaq 0x942ef(%rip), %rsi     # 0xf98e1
callq 0x22960
jmp 0x65664
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x94322(%rip), %rsi     # 0xf992b
leaq 0x94366(%rip), %rdx     # 0xf9976
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x321d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x784c2
leaq 0x20(%rsp), %rdi
jmp 0x6565f
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x94338(%rip), %rsi     # 0xf9977
leaq 0x94379(%rip), %rdx     # 0xf99bf
movq %rsp, %r14
movq %r14, %rdi
callq 0x321d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x784c2
movq %rsp, %rdi
callq 0x23470
xorl %edi, %edi
callq 0x22b90
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x6567c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x6568c
movq (%r15), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::subParExist(unsigned int)
bool Particle::subParExist(unsigned int subParID){
	for(unsigned int i=0; i< subParIDs.size(); i++)
		if(subParIDs.at(i)==subParID)
			return true;
	return false;
}

// Assembly:
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rdx
subq %rcx, %rdx
je 0x656cf
sarq $0x2, %rdx
movl $0x1, %edi
xorl %r8d, %r8d
cmpl %esi, (%rcx,%r8,4)
sete %al
je 0x656ce
movl %edi, %r8d
incl %edi
cmpq %r8, %rdx
ja 0x656bb
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Pheromones.cpp
// Function: Pheromones::~Pheromones()
Pheromones::~Pheromones() {
	if (swarm_->options.useCluster) {
	    int world_rank;
	    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	    if (swarm_->options.verbosity>=3) {
	    	cout << "my rank is " << world_rank << " starting ~environment()" << endl;
	    }
		//env_->~environment();
		MPI_Finalize();
	    if (swarm_->options.verbosity>=3) {

	    	cout << "~environment() done" << endl;
	    }

	}
	else {
		for (auto mq = smq_.begin(); mq != smq_.end(); ++mq) {
			(*mq)->~message_queue();
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rax
cmpb $0x1, 0x1631(%rax)
jne 0x6b3fa
movq 0x10ac89(%rip), %rdi    # 0x175f68
leaq 0x4(%rsp), %rsi
callq 0x22dc0
movq 0x50(%rbx), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x6b35c
movq 0x10acab(%rip), %rdi    # 0x175fa8
leaq 0x9043c(%rip), %rsi     # 0xfb740
movl $0xb, %edx
callq 0x22ab0
movl 0x4(%rsp), %esi
movq 0x10ac8f(%rip), %rdi    # 0x175fa8
callq 0x231e0
movq %rax, %r14
leaq 0x90424(%rip), %rsi     # 0xfb74c
movl $0x18, %edx
movq %rax, %rdi
callq 0x22ab0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %r14, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
callq 0x22770
movq 0x50(%rbx), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x6b3b4
movq 0x10ac33(%rip), %r14    # 0x175fa8
leaq 0x903e9(%rip), %rsi     # 0xfb765
movl $0x13, %edx
movq %r14, %rdi
callq 0x22ab0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq 0x10ac01(%rip), %rdi    # 0x175fa8
callq 0x22050
movq %rax, %rdi
callq 0x22660
leaq 0x98(%rbx), %rdi
callq 0x32268
leaq 0x88(%rbx), %rdi
callq 0x32268
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x6b3e1
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x229c0
leaq 0x18(%rbx), %rdi
callq 0x6f0e0
movq %rbx, %rdi
callq 0x31a0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x68(%rbx), %r14
cmpq 0x70(%rbx), %r14
je 0x6b3b4
movq (%r14), %rdi
callq 0x6f678
addq $0x8, %r14
jmp 0x6b3fe
movq %rax, %rdi
callq 0x3185b
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Pheromones.cpp
// Function: Pheromones::serializeSwarmMessage[abi:cxx11](Pheromones::swarmMessage)
std::string Pheromones::serializeSwarmMessage(swarmMessage sm) {
	std::stringstream oss;
	{
	boost::archive::text_oarchive oa(oss);
	oa << sm;
	}
	std::string serializedMessage(oss.str());

	return serializedMessage;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %rdi
callq 0x22680
leaq 0xa0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x6ecf0
callq 0x6ede8
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe7360
leaq 0x8(%rsp), %rdi
callq 0xe6f00
leaq 0x38(%rsp), %rdi
callq 0xe8ab0
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23010
movq 0x108cc7(%rip), %rsi    # 0x175f50
leaq 0x90(%rsp), %rdi
callq 0x226f0
leaq 0x110(%rsp), %rdi
callq 0x222d0
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
jmp 0x6d2b3
movq %rax, %rbx
jmp 0x6d2cf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe6f00
leaq 0x38(%rsp), %rdi
callq 0xe8ab0
movq 0x108c7a(%rip), %rsi    # 0x175f50
leaq 0x90(%rsp), %rdi
callq 0x226f0
leaq 0x110(%rsp), %rdi
callq 0x222d0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Pheromones.cpp
// Function: Pheromones::getRank()
int Pheromones::getRank() {
	//return world_->rank();
    int world_rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	return world_rank;

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x107474(%rip), %rdi    # 0x175f68
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x22dc0
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Evaluate.cpp
// Function: splitResults(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> splitResults(const string &s, char delim) {
    stringstream ss;
    ss.str(s);
    string item;
    vector<string> elems;
    while (getline(ss, item, delim)) {
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x22680
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x22f00
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x23300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x73768
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31cec
jmp 0x73740
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7377f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x1027ca(%rip), %rsi    # 0x175f50
leaq 0x28(%rsp), %rdi
callq 0x226f0
leaq 0xa8(%rsp), %rdi
callq 0x222d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x737d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x737d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x102772(%rip), %rsi    # 0x175f50
leaq 0x28(%rsp), %rdi
callq 0x226f0
leaq 0xa8(%rsp), %rdi
callq 0x222d0
movq %r14, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Evaluate.cpp
// Function: constraintFunction(double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
int constraintFunction(double value1, string constraintOperator, double value2){

    bool result;

    if(constraintOperator == "=" || constraintOperator == "=="){
      result = (value1 == value2); return result;
    }

    if(constraintOperator == ">"){
      result = (value1 > value2); return result;
    }

    if(constraintOperator == "<"){
       result = (value1 < value2); return result;
    }

    if(constraintOperator == ">="){
      result = (value1 >= value2); return result;
    }

    if(constraintOperator == "<="){
       result = (value1 <= value2); return result;
    }

    if(constraintOperator == "!="){
       result = (value1 != value2); return result;
    }
   //0 means false
   //1 means true
   //-1 means that the logial operator was not found in this function
   return -1;

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, (%rsp)
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
leaq 0x8d57f(%rip), %rsi     # 0x100d96
callq 0x22250
testl %eax, %eax
je 0x738ab
leaq 0x7dd23(%rip), %rsi     # 0xf154e
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x738ab
leaq 0x86204(%rip), %rsi     # 0xf9a42
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x738c1
leaq 0x8a4b7(%rip), %rsi     # 0xfdd08
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x738d0
leaq 0x8a4a6(%rip), %rsi     # 0xfdd0a
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x738e2
leaq 0x8a496(%rip), %rsi     # 0xfdd0d
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x738f1
leaq 0x8a486(%rip), %rsi     # 0xfdd10
movq %rbx, %rdi
callq 0x22250
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x73901
movsd 0x8(%rsp), %xmm0
cmpneqsd (%rsp), %xmm0
jmp 0x738b7
movsd 0x8(%rsp), %xmm0
cmpeqsd (%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x73901
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x738dd
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
seta %al
jmp 0x73901
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x738fe
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
setae %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::initRNGS(int)
void Swarm::initRNGS(int seed) {
	if (seed) {
		srand(seed);
		if(options.verbosity >= 3){
			cout << "seeding rng with: " << seed << endl;
		}
	}
	else {
		// TODO: Make sure everything is being seeded properly and in the proper place. Also let's do away with rand()
		// Seed our random number engine
//razi changed was 		srand (std::tr1::random_device{}());
		srand (std::random_device{}());
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1388, %rsp           # imm = 0x1388
testl %esi, %esi
je 0x77397
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x22930
cmpl $0x3, 0x1614(%r14)
jb 0x773b9
movq 0xfec63(%rip), %r14     # 0x175fa8
leaq 0x870d1(%rip), %rsi     # 0xfe41d
movl $0x12, %edx
movq %r14, %rdi
callq 0x22ab0
movq %r14, %rdi
movl %ebx, %esi
callq 0x231e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %rbx, %rdi
callq 0x22050
movq %rax, %rdi
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
jmp 0x22660
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x65ce2
movq %rbx, %rdi
callq 0x22d60
movl %eax, %edi
callq 0x22930
movq %rsp, %rdi
callq 0x22910
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
retq
jmp 0x773d9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22910
movq %rbx, %rdi
callq 0x23240
movq %rax, %rdi
callq 0x3185b
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::initComm()
void Swarm::initComm() {
	// Create the communication class
	Pheromones *ph = new Pheromones();

	// Initialize the communication class
	ph->init(this);

	// Store our communication class
	swarmComm = ph;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xc0, %edi
callq 0x22980
movq %rax, %rbx
movq %rax, %rdi
callq 0x6b218
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b41a
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xc0, %esi
movq %rbx, %rdi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::deNormalizeParam(double, double, double, bool)
double Swarm::deNormalizeParam(double oldParam, double min, double max, bool log) {
	if (log) {
		return pow(10, log10(min) + oldParam * (log10(max) - log10(min)));
		//return min + oldParam * (max - min);
	}
	else {
		return min + oldParam * (max - min);
	}
}

// Assembly:
testl %esi, %esi
je 0x77513
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x22480
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x22480
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x22480
movsd 0x8(%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd 0x18(%rsp), %xmm1
movsd 0x80dde(%rip), %xmm0    # 0xf82e8
addq $0x28, %rsp
jmp 0x23210
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::outputError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Swarm::outputError(string errorMessage) {
	cout << errorMessage << endl;

	if (commInit) {
		// Tell all particles to die
		killAllParticles(FIT_FINISHED);

		// Deconstruct our communicator
		swarmComm->~Pheromones();
	}

	exit (EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0xfdad1(%rip), %rdi     # 0x175fa8
movq %rax, %rsi
callq 0x22ab0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %r14, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
cmpb $0x1, 0x13f8(%rbx)
jne 0x78527
movq %rbx, %rdi
movl $0x16, %esi
callq 0x9439a
movq (%rbx), %rdi
callq 0x6b2c0
movl $0x1, %edi
callq 0x22b90
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::getModelName[abi:cxx11](unsigned int, bool)
std::string Swarm::getModelName(unsigned int modelId, bool FullPath){
	std::string path = options.models.at(modelId)->getName();
	if (FullPath)
		return path;
	else
		return getFilename(path);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rsi, %rax
movl %edx, %esi
movq 0x15c0(%rax), %rcx
movq 0x15c8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x7a06e
movq %rdi, %rbx
movq (%rcx,%rsi,8), %rax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x68(%rax), %rsi
movq 0x70(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3213c
testb %bpl, %bpl
je 0x79fe0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x7a026
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x7a02d
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3213c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xbeb1d
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x7a049
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x7a049
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a060
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x79604(%rip), %rdi     # 0xf3679
xorl %eax, %eax
callq 0x22f40
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x7a09b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x7a09b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a0b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::calcQPSOmBests()
vector<double> Swarm::calcQPSOmBests() {
	// Eq 2b Liu et al
	//cout<<"Modification needed\n...."; mypause();

	vector<double> mBests;

	//for (unsigned int param = 0; param < options.model->getFreeParams_().size(); ++param) {
	//for (auto param = this->getFreeParams_().begin(); param != this->getFreeParams_().end(); ++param) { //for (auto param = options.model->getFreeParams_().begin(); param != options.model->getFreeParams_().end(); ++param) {
	unsigned int i = 0;



		double sum = 0;
		for (int particle = 1; particle <= options.swarmSize; ++particle) {
			i = 0;
			for (auto param = particleCurrParamSets_.at(particle).begin(); param != particleCurrParamSets_.at(particle).end(); ++param) {

//				for(int mid=0; mid < options.models.size(); mid++){

					sum += abs(particleBestParamSets_.at(particle)[i]);

	//			}
				++i;
			}



			double mean = sum / (double)options.swarmSize;

			// TODO: Adaptive mutation ala Liu 2005
			if (options.mutateQPSO) {
				boost::random::cauchy_distribution<double> dist(0, cauchyMutator_);
				double mutator = dist(generalRand);
				mean += mutator;
				//cout << mean << " mutated by: " << mutator << endl;
			}
			mBests.push_back(sum / (double)options.swarmSize);

		}


	//}

	return mBests;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x0, 0x1620(%rsi)
jle 0x7cd6b
leaq 0x1400(%rsi), %r15
leaq 0x1cc0(%rsi), %r12
leaq 0x58(%rsi), %rax
movq %rax, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x1, %r13d
movq %rsp, %rbp
movq %rbx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movl %r13d, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7a46
movq (%rax), %r14
xorl %ebx, %ebx
movl %r13d, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa7a46
cmpq 0x8(%rax), %r14
je 0x7ccde
movl %r13d, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xa7a46
movl %ebx, %ecx
movq (%rax), %rax
movsd (%rax,%rcx,8), %xmm0
andpd 0x7af8a(%rip), %xmm0    # 0xf7c50
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %ebx
addq $0x8, %r14
jmp 0x7cc90
movq 0x20(%rsp), %r14
cmpb $0x0, 0x16ac(%r14)
movq 0x10(%rsp), %rbx
je 0x7cd14
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
callq 0xaf06c
addsd 0x81309(%rip), %xmm0    # 0xfe010
mulsd 0x81309(%rip), %xmm0    # 0xfe018
callq 0x22550
movl 0x1620(%r14), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7cd49
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7cd5b
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x67e5a
movl 0x1620(%r14), %eax
leal 0x1(%r13), %ecx
cmpl %eax, %r13d
movl %ecx, %r13d
jl 0x7cc7c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7cd85
jmp 0x7cd85
jmp 0x7cd85
jmp 0x7cd85
movq %rax, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7cda1
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::updateEnhancedStop()
void Swarm::updateEnhancedStop() {
	// First calculate particle weights

	if (options.verbosity >= 3) {
		cout << "Updating enhanced stop" << endl;
	}

	updateParticleWeights();
	weightedAvgPos_ = calcWeightedAveragePosition();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, 0x1614(%rdi)
jb 0x873de
movq 0xeec05(%rip), %r14     # 0x175fa8
leaq 0x77a1d(%rip), %rsi     # 0xfedc7
movl $0x16, %edx
movq %r14, %rdi
callq 0x22ab0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %r14, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
movq %rbx, %rdi
callq 0x87450
movq %rbx, %rdi
callq 0x87548
movsd %xmm0, 0x1d88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::getEuclidianNorm(double, unsigned int)
double Swarm::getEuclidianNorm(double y, unsigned int n) {

	// Eq 10 in Moraes at al
	double sum = 0;
	for (unsigned int i = 1; i <= n; ++i) {
		sum += pow(y, 2);
	}

	double norm = sqrt( (1/n) * sum);

	return norm;
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
testl %esi, %esi
je 0x8742a
mulsd %xmm1, %xmm1
leal 0x1(%rsi), %ecx
cmpl $0x3, %ecx
movl $0x2, %eax
cmovael %ecx, %eax
decl %eax
addsd %xmm1, %xmm0
decl %eax
jne 0x87422
cmpl $0x1, %esi
je 0x87435
xorpd %xmm1, %xmm1
jmp 0x8743d
movsd 0x70eb3(%rip), %xmm1    # 0xf82f0
mulsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x22790
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::updateParticleWeights()
void Swarm::updateParticleWeights() {

	if (options.verbosity >= 3) {
		cout << "Updating particle weights" << endl;
	}

	for (int p = 1; p <= options.swarmSize; ++p) {
		particleWeights_[p] = calcParticleWeight(p);
	}
	if (options.verbosity >= 3) {
		cout << "done here" << endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x3, 0x1614(%rdi)
jb 0x874a8
movq 0xeeb3b(%rip), %r14     # 0x175fa8
leaq 0x7796a(%rip), %rsi     # 0xfedde
movl $0x19, %edx
movq %r14, %rdi
callq 0x22ab0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %r14, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
cmpl $0x0, 0x1620(%rbx)
jle 0x874f2
leaq 0x1cf0(%rbx), %r14
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x87638
movsd %xmm0, 0x10(%rsp)
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7734
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
cmpl 0x1620(%rbx), %ebp
jl 0x874bf
cmpl $0x2, 0x1614(%rbx)
jbe 0x8753d
movq 0xeeaa6(%rip), %rbx     # 0x175fa8
leaq 0x778ef(%rip), %rsi     # 0xfedf8
movl $0x9, %edx
movq %rbx, %rdi
callq 0x22ab0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x22940
movsbl %al, %esi
movq %rbx, %rdi
callq 0x22050
movq %rax, %rdi
callq 0x22660
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq