LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a70c
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 0x4a5c0
movq %r12, %rdi
callq 0x4a5c0
movq %r13, %rdi
callq 0x4a5c0
movq %r14, %rdi
callq 0x4a5c0
movq 0x70(%rbx), %rdi
cmpq %rbp, %rdi
je 0x4a0a1
movq (%rbp), %rsi
incq %rsi
callq 0x229c0
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
callq 0x4a694
movq %rbx, %rdi
callq 0x4a5c0
movq %r15, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a70c
xorl %eax, %eax
movq %rax, (%rbx)
movb $0x0, 0x158(%rbx)
movq %rax, 0x150(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x4a5c0
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 0x4a5c0
movq %r12, %rdi
callq 0x4a5c0
movq %r13, %rdi
callq 0x4a5c0
movq %rbp, %rdi
callq 0x4a5c0
movq %r14, %rdi
callq 0x4a5c0
movq 0x70(%rbx), %rdi
cmpq %r15, %rdi
je 0x4a267
movq (%r15), %rsi
incq %rsi
callq 0x229c0
leaq 0x38(%rbx), %rdi
addq $0x8, %rbx
callq 0x4a694
movq %rbx, %rdi
callq 0x4a5c0
movq (%rsp), %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a2ab
movq %rax, (%rbx)
movq 0x70(%rsi), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32180
jmp 0x4a2c4
movq %rax, (%rbx)
leaq 0xb19ad(%rip), %rsi     # 0xfbc62
leaq 0xb19ab(%rip), %rdx     # 0xfbc67
movq %rbx, %rdi
callq 0x32210
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa986a(%rip), %rcx     # 0xf6cc1
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 0x4d492
movq (%r13), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2387f
movq %r12, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa97e5(%rip), %rcx     # 0xf6cc1
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x22fb0
movq 0x28(%rbx), %rdx
leaq 0xa97ce(%rip), %rcx     # 0xf6cc1
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 0x4d52e
movq (%r13), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23893
movq %r12, %rdi
callq 0x23240
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32180
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xbe434
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x22bb0
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4d60c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4d622
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x4d6a0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4d655
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4d658
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x4d658
movq %rax, %r15
leaq 0x88(%rbx), %r12
leaq 0xa0(%rbx), %rdi
callq 0x31a9e
movq %r12, %rdi
callq 0x31a9e
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x4d687
movq (%r13), %rsi
incq %rsi
callq 0x229c0
leaq 0x30(%rbx), %rdi
callq 0x51992
movq %rbx, %rdi
callq 0x51a0a
movq %r15, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52d68
movq %rax, %r15
cmpq $0x1, %rax
ja 0x52da0
movq 0x8(%r12), %rdx
leaq 0xa3fa3(%rip), %rcx     # 0xf6cc1
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 0x52e11
jmp 0x52e1e
movq %r12, %rdi
movq %r14, %rsi
callq 0x22500
movq %r12, %rsi
callq 0x52f14
movq 0x8(%rbx), %rdx
leaq 0xa3f3b(%rip), %rcx     # 0xf6cc1
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 0x52dda
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %r12, %rsi
callq 0x52f14
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 0x52e1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rsi
callq 0x52f14
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Parser::trim(string& s) {
	while ( (s.length() > 1) && ( (s[0] == ' ') || (s[0] =='\t') ) ) {
		s = s.substr(1, string::npos);
	}
	while ( (s.length() > 1) &&
			( (s[s.length()-1] == ' ') ||
			  (s[s.length()-1] == '\t') || 
			  (s[s.length()-1] == '\n') || 
			  (s[s.length()-1] == '\r') ) ) {
		s = s.substr(0, s.length()-1);
	}
	if ( (s.length() > 1) && (s[0] == '"') ) {
		s = s.substr(1, string::npos);
	}
	if ( (s.length() > 1) && (s[s.length()-1] == '"') ) {
		s = s.substr(0, s.length()-1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpq $0x2, 0x8(%rsi)
jb 0x52f83
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r14
movq (%rbx), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x52f43
cmpl $0x9, %eax
jne 0x52f83
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x22a00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22bb0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52f7c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
cmpq $0x1, 0x8(%rbx)
ja 0x52f33
movq 0x8(%rbx), %rcx
cmpq $0x2, %rcx
setae %al
jb 0x52fff
leaq 0x18(%rsp), %r15
movabsq $0x100002600, %r12      # imm = 0x100002600
leaq 0x8(%rsp), %r14
movq (%rbx), %rdx
movzbl -0x1(%rdx,%rcx), %edx
cmpq $0x20, %rdx
ja 0x53059
btq %rdx, %r12
jae 0x53059
decq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22a00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22bb0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52ff2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x8(%rbx), %rcx
cmpq $0x2, %rcx
setae %al
jae 0x52fa4
movq 0x8(%rbx), %rcx
cmpq $0x2, %rcx
jb 0x5304d
movq (%rbx), %rax
cmpb $0x22, -0x1(%rax,%rcx)
jne 0x5304d
decq %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x22a00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22bb0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5304d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %al
je 0x52fff
movq (%rbx), %rax
cmpb $0x22, (%rax)
jne 0x52fff
leaq 0x8(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x22a00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22bb0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x52fff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x52fff
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53d82
addq $0x8, %r14
cmpq %r14, %rax
je 0x532bf
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x4, %edi
callq 0x22b90
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32180
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5327c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x5331e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
leaq 0xa4f92(%rip), %rsi     # 0xf82b7
movq %rsp, %rdi
callq 0x22250
movb $0x1, %bl
testl %eax, %eax
je 0x53393
leaq 0xa4f81(%rip), %rsi     # 0xf82bb
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x53393
leaq 0xa4f72(%rip), %rsi     # 0xf82bf
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x53393
leaq 0xa4f63(%rip), %rsi     # 0xf82c3
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x53393
leaq 0xa4f55(%rip), %rsi     # 0xf82c8
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
je 0x53393
leaq 0xa4f47(%rip), %rsi     # 0xf82cd
movq %rsp, %rdi
callq 0x22250
testl %eax, %eax
sete %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x533ae
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 0x533d4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x541f1
movq 0x121e4e(%rip), %rbx    # 0x175f90
leaq 0xa4268(%rip), %rsi     # 0xf83b1
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 0xa4217(%rip), %rsi     # 0xf83b7
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 0xa3aa7(%rip), %xmm4    # 0xf7ca0
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_O1/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 %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rcx
movq 0x8(%rcx), %rax
cmpq (%rcx), %rax
je 0x54339
movq %rdx, %r14
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x8(%rsp), %r15
movq 0x8(%r14), %rdx
subq %rcx, %rdx
je 0x542c3
sarq $0x3, %rdx
imulq %r13, %rdx
xorpd %xmm0, %xmm0
movl $0x1, %esi
movq %rcx, %rdi
movq (%rdi), %r8
addsd (%r8,%r12,8), %xmm0
movl %esi, %r8d
addq $0x18, %rdi
incl %esi
cmpq %r8, %rdx
ja 0x542aa
jmp 0x542c7
xorpd %xmm0, %xmm0
subq (%rcx), %rax
sarq $0x3, %rax
movq %rax, %xmm1
punpckldq 0xa4005(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xa400d(%rip), %xmm1    # 0xf82f0
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 0x54311
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5431c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x68326
incl %r12d
movq (%r14), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
cmpq %r12, %rdx
ja 0x5428d
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 0x54361
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %ebx
movq 0x80(%rdi), %rax
subq 0x78(%rdi), %rax
sarq $0x3, %rax
cmpq %rbx, %rax
ja 0x6570a
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movl %edx, %esi
callq 0xc03b8
leaq 0x932bf(%rip), %rcx     # 0xf88ca
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 0x65644
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6564c
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 0x93280(%rip), %rsi     # 0xf88ed
callq 0x233b0
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x65699
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x656a1
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 0xc0396
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x656d9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x656ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6570a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x78(%r15), %rax
movq 0x80(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0x65733
movq %r14, (%rax,%rbx,8)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8df8b(%rip), %rdi     # 0xf36c5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22f40
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x65763
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x65763
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6577e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x6577e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65799
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x657be
// File: /workspace/github_cpp_makefile_star2_O1/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 0x65aac
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x65abc
cmpl %esi, 0x8(%rdi)
jne 0x65ad1
movl %esi, %eax
movq 0x15c0(%rbx), %rcx
movq 0x15c8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x65b07
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1104dd(%rip), %rdi    # 0x175f90
leaq 0x93dfa(%rip), %rsi     # 0xf98b4
jmp 0x65aca
movq 0x1104cd(%rip), %rdi    # 0x175f90
leaq 0x93e37(%rip), %rsi     # 0xf9901
callq 0x22960
jmp 0x65b3c
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x93e6a(%rip), %rsi     # 0xf994b
leaq 0x93eae(%rip), %rdx     # 0xf9996
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x32210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78b66
leaq 0x20(%rsp), %rdi
jmp 0x65b37
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x93e80(%rip), %rsi     # 0xf9997
leaq 0x93ec1(%rip), %rdx     # 0xf99df
movq %rsp, %r14
movq %r14, %rdi
callq 0x32210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78b66
movq %rsp, %rdi
callq 0x23470
xorl %edi, %edi
callq 0x22b90
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x65b54
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x65b64
movq (%r15), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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
setne %al
je 0x65bac
cmpl %esi, (%rcx)
je 0x65bac
sarq $0x2, %rdx
movl $0x1, %edi
movl %edi, %r8d
cmpq %r8, %rdx
seta %al
jbe 0x65bac
leal 0x1(%r8), %edi
cmpl %esi, (%rcx,%r8,4)
jne 0x65b97
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6b8ee
movq 0x10a77d(%rip), %rdi    # 0x175f50
leaq 0x4(%rsp), %rsi
callq 0x22dc0
movq 0x50(%rbx), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x6b850
movq 0x10a79f(%rip), %rdi    # 0x175f90
leaq 0x8ff68(%rip), %rsi     # 0xfb760
movl $0xb, %edx
callq 0x22ab0
movl 0x4(%rsp), %esi
movq 0x10a783(%rip), %rdi    # 0x175f90
callq 0x231e0
movq %rax, %r14
leaq 0x8ff50(%rip), %rsi     # 0xfb76c
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 0x6b8a8
movq 0x10a727(%rip), %r14    # 0x175f90
leaq 0x8ff15(%rip), %rsi     # 0xfb785
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 0x10a6f5(%rip), %rdi    # 0x175f90
callq 0x22050
movq %rax, %rdi
callq 0x22660
leaq 0x98(%rbx), %rdi
callq 0x322a0
leaq 0x88(%rbx), %rdi
callq 0x322a0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x6b8d5
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x229c0
leaq 0x18(%rbx), %rdi
callq 0x6f5f6
movq %rbx, %rdi
callq 0x31a9e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x68(%rbx), %r14
cmpq 0x70(%rbx), %r14
je 0x6b8a8
movq (%r14), %rdi
callq 0x6fb8e
addq $0x8, %r14
jmp 0x6b8f2
movq %rax, %rdi
callq 0x318ef
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6f206
callq 0x6f2fe
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xe7cb0
leaq 0x8(%rsp), %rdi
callq 0xe7850
leaq 0x38(%rsp), %rdi
callq 0xe9400
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23010
movq 0x108761(%rip), %rsi    # 0x175f38
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 0x6d801
movq %rax, %rbx
jmp 0x6d81d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe7850
leaq 0x38(%rsp), %rdi
callq 0xe9400
movq 0x108714(%rip), %rsi    # 0x175f38
leaq 0x90(%rsp), %rdi
callq 0x226f0
leaq 0x110(%rsp), %rdi
callq 0x222d0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/richardposner[P]BioNetFit2/src/code/Pheromones.cpp
// Function: Pheromones::clearSwarmMessage(Pheromones::swarmMessage&)
void Pheromones::clearSwarmMessage(swarmMessage& sm) {
	sm.tag.clear();
	sm.id = 0;
	sm.sender = 0;
	sm.message.clear();
}

// Assembly:
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq (%rsi), %rcx
movb $0x0, (%rcx)
movq %rax, 0x20(%rsi)
movq 0x28(%rsi), %rax
leaq 0x28(%rsi), %rdi
movq %rax, %rsi
jmp 0x6b3a4
// File: /workspace/github_cpp_makefile_star2_O1/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 0x106f42(%rip), %rdi    # 0x175f50
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_O1/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 0x73d78
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31d52
jmp 0x73d50
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x73d8f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x1021a2(%rip), %rsi    # 0x175f38
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 0x73de7
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a9e
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x73de7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x10214a(%rip), %rsi    # 0x175f38
leaq 0x28(%rsp), %rdi
callq 0x226f0
leaq 0xa8(%rsp), %rdi
callq 0x222d0
movq %r14, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8cf88(%rip), %rsi     # 0x100daf
callq 0x22250
testl %eax, %eax
je 0x73ebb
leaq 0x7d733(%rip), %rsi     # 0xf156e
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x73ebb
leaq 0x85c14(%rip), %rsi     # 0xf9a62
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x73ed1
leaq 0x89ee7(%rip), %rsi     # 0xfdd48
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x73ee0
leaq 0x89ed6(%rip), %rsi     # 0xfdd4a
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x73ef2
leaq 0x89ec6(%rip), %rsi     # 0xfdd4d
movq %rbx, %rdi
callq 0x22250
testl %eax, %eax
je 0x73f01
leaq 0x89eb6(%rip), %rsi     # 0xfdd50
movq %rbx, %rdi
callq 0x22250
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x73f11
movsd 0x8(%rsp), %xmm0
cmpneqsd (%rsp), %xmm0
jmp 0x73ec7
movsd 0x8(%rsp), %xmm0
cmpeqsd (%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x73f11
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x73eed
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
seta %al
jmp 0x73f11
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x73f0e
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
setae %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x779eb
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x22930
cmpl $0x3, 0x1614(%r14)
jb 0x77a0d
movq 0xfe5f7(%rip), %r14     # 0x175f90
leaq 0x86a0d(%rip), %rsi     # 0xfe3ad
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 0x661ae
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 0x77a2d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22910
movq %rbx, %rdi
callq 0x23240
movq %rax, %rdi
callq 0x318ef
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6b70c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b90e
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_O1/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::normalizeParam(double, double, double, bool)
double Swarm::normalizeParam(double oldParam, double min, double max, bool log) {
	if (log) {
		return (log10(oldParam) - log10(min)) / (log10(max) - log10(min));
		//return (oldParam - min) / (max - min);
	}
	else {
		return (oldParam - min) / (max - min);
	}
}

// Assembly:
testl %esi, %esi
je 0x77aeb
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, (%rsp)
callq 0x22480
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x22480
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x22480
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x22480
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x18, %rsp
retq
subsd %xmm1, %xmm0
subsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x77b67
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 0x807aa(%rip), %xmm0    # 0xf8308
addq $0x28, %rsp
jmp 0x23210
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfd415(%rip), %rdi     # 0x175f90
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 0x78bcb
movq %rbx, %rdi
movl $0x16, %esi
callq 0x94cbc
movq (%rbx), %rdi
callq 0x6b7b4
movl $0x1, %edi
callq 0x22b90
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7a732
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 0x32180
testb %bpl, %bpl
je 0x7a6a4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r14, %rcx
je 0x7a6ea
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x7a6f1
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x32180
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xbf437
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x7a70d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x7a70d
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 0x7a724
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x78f8c(%rip), %rdi     # 0xf36c5
xorl %eax, %eax
callq 0x22f40
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x7a75f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x7a75f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7a776
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d3f7
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 0xa837c
movq (%rax), %rbx
xorl %r14d, %r14d
movl %r13d, (%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xa837c
cmpq 0x8(%rax), %rbx
je 0x7d36f
movl %r13d, (%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xa837c
movl %r14d, %ecx
movq (%rax), %rax
movsd (%rax,%rcx,8), %xmm0
andpd 0x7a94a(%rip), %xmm0    # 0xf7ca0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incl %r14d
addq $0x8, %rbx
jmp 0x7d31f
movq 0x20(%rsp), %r14
cmpb $0x0, 0x16ac(%r14)
movq 0x10(%rsp), %rbx
je 0x7d3a5
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
callq 0xaf80a
addsd 0x80c08(%rip), %xmm0    # 0xfdfa0
mulsd 0x80c08(%rip), %xmm0    # 0xfdfa8
callq 0x22550
xorps %xmm1, %xmm1
cvtsi2sdl 0x1620(%r14), %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7d3d8
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7d3e3
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x68326
leal 0x1(%r13), %eax
cmpl 0x1620(%r14), %r13d
movl %eax, %r13d
jl 0x7d30a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7d411
jmp 0x7d411
jmp 0x7d411
jmp 0x7d411
movq %rax, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7d42d
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x87e2a
movq 0xee1a1(%rip), %r14     # 0x175f90
leaq 0x76f61(%rip), %rsi     # 0xfed57
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 0x87e9c
movq %rbx, %rdi
callq 0x87f94
movsd %xmm0, 0x1d88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x87e76
mulsd %xmm1, %xmm1
leal 0x1(%rsi), %ecx
cmpl $0x3, %ecx
movl $0x2, %eax
cmovael %ecx, %eax
decl %eax
addsd %xmm1, %xmm0
decl %eax
jne 0x87e6e
cmpl $0x1, %esi
je 0x87e81
xorpd %xmm1, %xmm1
jmp 0x87e89
movsd 0x70487(%rip), %xmm1    # 0xf8310
mulsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0x22790
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x87ef4
movq 0xee0d7(%rip), %r14     # 0x175f90
leaq 0x76eae(%rip), %rsi     # 0xfed6e
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 0x87f3e
leaq 0x1cf0(%rbx), %r14
xorl %ebp, %ebp
leaq 0xc(%rsp), %r15
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x88082
movsd %xmm0, 0x10(%rsp)
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa816e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
cmpl 0x1620(%rbx), %ebp
jl 0x87f0b
cmpl $0x2, 0x1614(%rbx)
jbe 0x87f89
movq 0xee042(%rip), %rbx     # 0x175f90
leaq 0x76e33(%rip), %rsi     # 0xfed88
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