LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x88db3(%rip), %rsi     # 0xd4c01
callq 0x29490
leaq 0x88da7(%rip), %rsi     # 0xd4c01
movq %r14, %rdi
callq 0x29490
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
andw $0x0, 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x295a0
movq %r15, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
leaq 0x68(%rdi), %r14
leaq 0x78(%rdi), %rax
movq %rax, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
xorl %eax, %eax
movb %al, 0x78(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa8(%rdi)
movq %rsi, 0x60(%rdi)
movb %al, 0xb8(%rdi)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x28dd0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x9e3f4
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x28c40
movq %r15, %rdi
callq 0x295a0
movq %rsp, %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x4bfac
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4bf69
movq %rax, %r15
movq %rsp, %rdi
callq 0x295a0
jmp 0x4bf6c
movq %rax, %r15
leaq 0x88(%rbx), %r12
leaq 0xa0(%rbx), %rdi
leaq 0x30(%rbx), %r13
callq 0x3355a
movq %r12, %rdi
callq 0x3355a
movq %r14, %rdi
callq 0x295a0
movq %r13, %rdi
callq 0x4e856
movq %rbx, %rdi
callq 0x4e8ba
movq %r15, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Model.cpp
// Function: Model::parseNet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Model::parseNet(string path) {

	if (swarm_->options.verbosity >= 3) {
		cout << "Parsing .net file" << endl;
	}

	string line;
	ifstream modelFile(path);

	if (modelFile.is_open()) {
		while (getline(modelFile, line)) {
			if (line.at(0) == '#') {
				continue;
			}
			string line_with_newline = line + "\n";
			netContents_.push_back(line_with_newline);
			//cout << line_with_newline;
		}
	}
	else {
		swarm_->outputError("Error: Couldn't open model file " + path + " for parsing.");
	}
	modelFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x4cdbc
movq 0x1191f0(%rip), %rdi    # 0x165f98
leaq 0x88e01(%rip), %rsi     # 0xd5bb0
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x68(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x29100
leaq 0xe0(%rsp), %rdi
callq 0x28200
testb %al, %al
je 0x4ce5a
addq $0xa0, %rbx
leaq 0x68(%rsp), %r14
leaq 0x48(%rsp), %r15
leaq 0x89c4e(%rip), %r12     # 0xd6a54
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x28180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4cea9
movq %r15, %rdi
xorl %esi, %esi
callq 0x294a0
cmpb $0x23, (%rax)
je 0x4ce0b
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x334ed
movq %rbx, %rdi
movq %r13, %rsi
callq 0x33776
movq %r13, %rdi
callq 0x295a0
jmp 0x4ce0b
movq 0x60(%rbx), %rbx
leaq 0x88d5d(%rip), %rsi     # 0xd5bc2
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x3338b
leaq 0x82689(%rip), %rdx     # 0xcf502
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3336c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6aed2
leaq 0x28(%rsp), %rdi
callq 0x295a0
leaq 0x8(%rsp), %rdi
callq 0x295a0
leaq 0x68(%rsp), %rdi
callq 0x281c0
leaq 0x68(%rsp), %rdi
callq 0x28230
leaq 0x48(%rsp), %rdi
callq 0x295a0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x295a0
jmp 0x4cef5
jmp 0x4cef2
jmp 0x4cf03
jmp 0x4cf03
movq %rax, %rbx
jmp 0x4cf10
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x295a0
jmp 0x4cf06
jmp 0x4cf03
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x28230
leaq 0x48(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28d20
cmpq $-0x1, %rax
je 0x4f8c7
movq %rax, %r15
cmpq $0x1, %rax
ja 0x4f8f6
leaq 0x85344(%rip), %rsi     # 0xd4c01
movq %r12, %rdi
callq 0x29490
jmp 0x4f925
movq %r12, %rdi
movq %r14, %rsi
callq 0x28570
movq %r12, %rsi
callq 0x4fa18
leaq 0x85320(%rip), %rsi     # 0xd4c01
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29490
leaq -0x1(%r15), %rcx
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x28a90
movq %r12, %rdi
movq %r13, %rsi
callq 0x28c40
movq %r13, %rdi
callq 0x295a0
movq %r12, %rsi
callq 0x4fa18
incq %r15
movq %rsp, %r12
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28a90
movq %rbx, %rdi
movq %r12, %rsi
callq 0x28c40
movq %r12, %rdi
callq 0x295a0
movq %rbx, %rsi
callq 0x4fa18
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
movq 0x8(%rbx), %rcx
cmpq $0x1, %rcx
jbe 0x4fac1
movq (%rbx), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x4fa51
cmpl $0x9, %eax
jne 0x4fac1
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x28a90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c40
movq %r14, %rdi
callq 0x295a0
jmp 0x4fa33
movq (%rbx), %rax
movzbl -0x1(%rax,%rcx), %edx
cmpq $0x20, %rdx
ja 0x4fad3
movabsq $0x100002600, %rsi      # imm = 0x100002600
btq %rdx, %rsi
jae 0x4fad3
decq %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x28a90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c40
movq %r14, %rdi
callq 0x295a0
movq 0x8(%rbx), %rcx
cmpq $0x2, %rcx
jae 0x4fa77
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x22, (%rax)
jne 0x4fb0b
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28a90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c40
movq %r14, %rdi
callq 0x295a0
movq 0x8(%rbx), %rcx
cmpq $0x2, %rcx
jb 0x4fac7
movq (%rbx), %rax
cmpb $0x22, -0x1(%rax,%rcx)
jne 0x4fac7
decq %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x28a90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c40
movq %r14, %rdi
callq 0x295a0
jmp 0x4fac7
nop
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::symbolExpand(std::map<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::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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Parser::symbolExpand(map<string, string>& symbols, string& s) {
	bool expanded;
	do {
		expanded = false;
		for (map<string, string>::iterator i = symbols.begin(); i != symbols.end(); ++i) {
			string search = "%" + i->first + "%";
			string replace = i->second;
			size_t pos = s.find(search);
			if (pos != string::npos) {
				expanded = true;
				s.replace(pos, search.length(), replace);
			}
		}
	} while (expanded);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %r13
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rbp
xorl %r15d, %r15d
cmpq 0x10(%rsp), %rbp
je 0x4fc01
leaq 0x20(%rbp), %rdx
movq %r12, %rdi
leaq 0x86627(%rip), %r14     # 0xd61b5
movq %r14, %rsi
callq 0x3338b
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3336c
movq %r12, %rdi
callq 0x295a0
leaq 0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x28dd0
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x29540
cmpq $-0x1, %rax
je 0x4fbe1
movb $0x1, %r15b
movq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rcx
callq 0x28370
movq %r12, %rdi
callq 0x295a0
movq %r13, %rdi
callq 0x295a0
movq %rbp, %rdi
callq 0x28700
movq %rax, %rbp
jmp 0x4fb75
testb $0x1, %r15b
jne 0x4fb69
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x295a0
jmp 0x4fc36
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x4fc3b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x50842
addq $0x8, %r14
cmpq %r14, %rax
je 0x4fc80
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x28dd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x4
popq %rdi
callq 0x28c20
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x28dd0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4fc48
leaq 0x28(%rsp), %rdi
callq 0x295a0
leaq 0x864f7(%rip), %rsi     # 0xd61b7
leaq 0x8(%rsp), %rdi
callq 0x3357b
movb $0x1, %bl
testb %al, %al
jne 0x4fd37
leaq 0x864e4(%rip), %rsi     # 0xd61bb
leaq 0x8(%rsp), %rdi
callq 0x3357b
testb %al, %al
jne 0x4fd37
leaq 0x864d3(%rip), %rsi     # 0xd61bf
leaq 0x8(%rsp), %rdi
callq 0x3357b
testb %al, %al
jne 0x4fd37
leaq 0x864c2(%rip), %rsi     # 0xd61c3
leaq 0x8(%rsp), %rdi
callq 0x3357b
testb %al, %al
jne 0x4fd37
leaq 0x864b2(%rip), %rsi     # 0xd61c8
leaq 0x8(%rsp), %rdi
callq 0x3357b
testb %al, %al
jne 0x4fd37
leaq 0x864a2(%rip), %rsi     # 0xd61cd
leaq 0x8(%rsp), %rdi
callq 0x3357b
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x295a0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm3
movq 0xa8(%rdi), %rax
cmpl $0x4, 0x1614(%rax)
jb 0x50ba9
movq 0x115450(%rip), %rbx    # 0x165f98
leaq 0x85762(%rip), %rsi     # 0xd62b1
movq %rbx, %rdi
movapd %xmm3, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x289f0
movq %rax, %rdi
movaps 0x10(%rsp), %xmm0
callq 0x290f0
movq %rax, %rdi
callq 0x284a0
leaq 0x85738(%rip), %rsi     # 0xd62b7
movq %rbx, %rdi
callq 0x289f0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x290f0
movq %rax, %rdi
callq 0x284a0
movsd 0x8(%rsp), %xmm1
movapd 0x10(%rsp), %xmm3
movapd 0x84fef(%rip), %xmm4    # 0xd5ba0
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 $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
xorl %r12d, %r12d
pushq $0x18
popq %r13
leaq 0x8(%rsp), %r15
movl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x50ca6
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %r13
xorl %edx, %edx
xorpd %xmm0, %xmm0
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x50c6b
imulq $0x18, %rdx, %rdi
movq (%rsi,%rdi), %rdi
addsd (%rdi,%r12,8), %xmm0
incl %edx
jmp 0x50c52
movq %rcx, %xmm1
punpckldq 0x85568(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x85570(%rip), %xmm1    # 0xd61f0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5c482
incl %r12d
jmp 0x50c2a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5c44e
movq %r14, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::setParam(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>, unsigned int)
void Particle::setParam(pair<std::string, double> myParams, unsigned int mid){

	/* razi: moved to constructor
	unsigned int gap= mid+1-simParams_.size();
	if (gap>0){   //fill dummy
		std::map<std::string, double> dummyParam;		//dummyParam[""]=0;
		for (int i=0; i < gap; i++)
			simParams_.push_back(dummyParam);//simParams_.push_back(std::map<std::string, double> dummyParam);
	}*/

	if (mid>=simParams_.size())  outputError("setParam failed. Invalid model id:"+toString(mid)+". I am quitting....");
		//Raquel: this code check with the master whether the parameter exists in model
	for (auto p = swarm_->options.models.at(mid)->getFreeParams_().begin(); p != swarm_->options.models.at(mid)->getFreeParams_().end(); ++p) {
		if(p->first == myParams.first) {
				//cout << "Raquel myParams first: " << myParams.first << " second: " << myParams.second << endl;
				simParams_.at(mid).insert(myParams);//Raquel: if it does exist, set the param value
		}//Raquel: otherwise, do nothing
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ecx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x30
popq %rsi
cqto
idivq %rsi
cmpq %r15, %rax
ja 0x510e3
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movl %ecx, %esi
callq 0x9f56b
leaq 0x85763(%rip), %rsi     # 0xd6801
movq %rsp, %rdi
movq %r12, %rdx
callq 0x4933b
leaq 0x8573d(%rip), %rdx     # 0xd67ed
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3336c
leaq 0x20(%rsp), %rdi
callq 0x9f54b
leaq 0x20(%rsp), %rdi
callq 0x295a0
movq %rsp, %rdi
callq 0x295a0
leaq 0x40(%rsp), %rdi
callq 0x295a0
movl $0x15c0, %r13d          # imm = 0x15C0
movq 0xa8(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x3374c
movq (%rax), %rax
movq 0x48(%rax), %r12
movq 0xa8(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
callq 0x3374c
movq (%rax), %rax
addq $0x38, %rax
cmpq %rax, %r12
je 0x51154
leaq 0x20(%r12), %rdi
movq %rbx, %rsi
callq 0x3d600
testb %al, %al
je 0x51147
movq %r14, %rdi
movq %r15, %rsi
callq 0x59f72
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5d22c
movq %r12, %rdi
callq 0x28b60
movq %rax, %r12
jmp 0x51102
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x295a0
jmp 0x51174
movq %rax, %rbx
movq %rsp, %rdi
callq 0x295a0
jmp 0x51181
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, %r14d
movq 0x80(%rdi), %rax
subq 0x78(%rdi), %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x59855
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movl %edx, %esi
callq 0x9f56b
leaq 0x7cfc0(%rip), %rsi     # 0xd67ca
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x4933b
leaq 0x7cfcf(%rip), %rdx     # 0xd67ed
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3336c
leaq 0x28(%rsp), %rdi
callq 0x9f54b
leaq 0x28(%rsp), %rdi
callq 0x295a0
leaq 0x8(%rsp), %rdi
callq 0x295a0
leaq 0x48(%rsp), %rdi
callq 0x295a0
addq $0x78, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3374c
movq %rbx, (%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x295a0
jmp 0x59885
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x295a0
jmp 0x59894
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x1
popq %rcx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x598c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x59a7a
movq 0xa8(%rax), %rbx
testq %rbx, %rbx
je 0x59a8a
movq %rdi, %r14
cmpl %esi, 0x8(%rdi)
jne 0x59aa4
movl %esi, %esi
movq 0x15c8(%rbx), %rax
subq 0x15c0(%rbx), %rax
sarq $0x3, %rax
cmpq %rsi, %rax
jbe 0x59ace
addq $0x15c0, %rbx           # imm = 0x15C0
movq %rbx, %rdi
callq 0x3374c
movq (%rax), %rax
movq %rax, 0x10(%r14)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq 0x10c517(%rip), %rdi    # 0x165f98
leaq 0x7dd2c(%rip), %rsi     # 0xd77b4
jmp 0x59a98
movq 0x10c507(%rip), %rdi    # 0x165f98
leaq 0x7dd69(%rip), %rsi     # 0xd7801
callq 0x289f0
xorl %edi, %edi
callq 0x28c20
leaq 0x7dda0(%rip), %rsi     # 0xd784b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x33402
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x6aed2
leaq 0x28(%rsp), %rdi
jmp 0x59af6
leaq 0x7ddc2(%rip), %rsi     # 0xd7897
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x33402
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6aed2
leaq 0x8(%rsp), %rdi
callq 0x295a0
jmp 0x59a9d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x59b0f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x295a0
jmp 0x59b1b
jmp 0x59b18
movq %rax, %rbx
movq %rbx, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x60(%rdi), %r15
xorl %ecx, %ecx
movl %ecx, %r12d
movq 0x68(%r14), %r13
subq 0x60(%r14), %r13
sarq $0x2, %r13
cmpq %r12, %r13
jbe 0x59b6e
movq %r15, %rdi
movq %r12, %rsi
callq 0x5a5de
leal 0x1(%r12), %ecx
cmpl %ebx, (%rax)
jne 0x59b46
cmpq %r12, %r13
seta %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::calcParID(unsigned int, unsigned int)
unsigned int Particle::calcParID(unsigned int subParID, unsigned int mid){
	unsigned int pID = (int)((subParID-1-mid) / swarm_->getNumModels())+1;
	if (pID != id_)
		outputError("Error when calculating particle id: "+toString(pID)+" <>" + toString(id_) + "!!!\n");
	return pID;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
notl %edx
leal (%rdx,%rsi), %eax
movq 0xa8(%rdi), %rcx
movq 0x15c8(%rcx), %rsi
subq 0x15c0(%rcx), %rsi
shrq $0x3, %rsi
xorl %edx, %edx
divl %esi
movl %eax, %ebx
incl %ebx
cmpl 0x40(%rdi), %ebx
je 0x59c7c
movq %rdi, %r14
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x9f56b
leaq 0x7dd66(%rip), %rsi     # 0xd793b
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x4933b
leaq 0x7dd77(%rip), %rdx     # 0xd7960
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3336c
movl 0x40(%r14), %esi
movq %rsp, %rdi
callq 0x9f56b
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x4e6ed
leaq 0x7dd47(%rip), %rdx     # 0xd7964
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x3336c
leaq 0x80(%rsp), %rdi
callq 0x9f54b
leaq 0x80(%rsp), %rdi
callq 0x295a0
leaq 0x60(%rsp), %rdi
callq 0x295a0
movq %rsp, %rdi
callq 0x295a0
leaq 0x40(%rsp), %rdi
callq 0x295a0
leaq 0x20(%rsp), %rdi
callq 0x295a0
leaq 0xa0(%rsp), %rdi
callq 0x295a0
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x295a0
jmp 0x59ca0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x295a0
jmp 0x59caf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x295a0
jmp 0x59cbc
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x295a0
jmp 0x59ccb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x295a0
leaq 0xa0(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
movq %rax, %rbx
jmp 0x59cd5
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5fc23
movq 0x1063e5(%rip), %rdi    # 0x165f60
leaq 0x4(%rsp), %rsi
callq 0x28e40
movq 0x50(%rbx), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x5fbc8
movq 0x1063ff(%rip), %rdi    # 0x165f98
leaq 0x79b98(%rip), %rsi     # 0xd9738
callq 0x289f0
movl 0x4(%rsp), %esi
movq %rax, %rdi
callq 0x29290
leaq 0x79b8c(%rip), %rsi     # 0xd9744
movq %rax, %rdi
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
callq 0x28800
movq 0x50(%rbx), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x5fbf5
movq 0x1063b7(%rip), %rdi    # 0x165f98
leaq 0x79b75(%rip), %rsi     # 0xd975d
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
leaq 0x80(%rbx), %rdi
callq 0x61b4e
leaq 0x68(%rbx), %rdi
callq 0x629b0
leaq 0x18(%rbx), %rdi
callq 0x622ac
movq %rbx, %rdi
callq 0x3355a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x68(%rbx), %r14
cmpq 0x70(%rbx), %r14
je 0x5fbf5
movq (%r14), %rdi
callq 0x629e4
addq $0x8, %r14
jmp 0x5fc27
movq %rax, %rdi
callq 0x3325c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28710
leaq 0xa0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x61ec8
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x66536
leaq 0x8(%rsp), %rdi
callq 0x61f06
leaq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x29080
leaq 0x90(%rsp), %rdi
callq 0x28790
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
jmp 0x60e56
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61f06
jmp 0x60e59
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x28790
movq %rbx, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Pheromones.cpp
// Function: Pheromones::deserializeSwarmMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Pheromones::swarmMessage Pheromones::deserializeSwarmMessage(std::string sm) {


	swarmMessage smessage;

	//char ch = sm.back();
	//cout << "Last character @" << ch << "@" << endl;
	if(sm.empty()){
	//if(ch=='\0')
		//sm.back() = '\n';
    	sm="\n";

	    if (swarm_->options.verbosity>=3) {

			cout << "String empty" << endl;
	    }
	}else{

		//cout << "last character is not empty, erasing" << endl;
		//sm.erase(sm.size()-1);
		//ch = sm.back();
		//cout << "new last character @" << ch << "@"<< endl;
	}


	if (swarm_->options.verbosity>=3) {

		cout << "serializing message start SM: " << sm << endl;
	}

	{
	std::stringstream iss;
	iss.str(sm);
	boost::archive::text_iarchive ia(iss);
	if (swarm_->options.verbosity>=3) {
		cout << "done serializing message" << endl;
	}
	ia >> smessage;
	}
	return smessage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
xorl %eax, %eax
cmpq %rax, 0x8(%rdx)
jne 0x60ede
leaq 0x75ba6(%rip), %rsi     # 0xd6a54
movq %r15, %rdi
callq 0x29490
movq 0x50(%r14), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x60ede
movq 0x1050ce(%rip), %rdi    # 0x165f98
leaq 0x78d62(%rip), %rsi     # 0xd9c33
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
movq 0x50(%r14), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x60f11
movq 0x1050a6(%rip), %rdi    # 0x165f98
leaq 0x78d47(%rip), %rsi     # 0xd9c40
callq 0x289f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x28910
movq %rax, %rdi
callq 0x284a0
leaq 0x88(%rsp), %rdi
callq 0x28710
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
callq 0x28f70
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
xorl %edx, %edx
callq 0x5a262
movq 0x50(%r14), %rax
cmpl $0x3, 0x1614(%rax)
jb 0x60f6a
movq 0x105042(%rip), %rdi    # 0x165f98
leaq 0x78d02(%rip), %rsi     # 0xd9c5f
callq 0x289f0
movq %rax, %rdi
callq 0x284a0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x66efe
leaq 0x8(%rsp), %rdi
callq 0x5a2a0
leaq 0x88(%rsp), %rdi
callq 0x28790
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
jmp 0x60fa0
movq %rax, %r14
jmp 0x60fb4
jmp 0x60fc3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5a2a0
leaq 0x88(%rsp), %rdi
callq 0x28790
jmp 0x60fc6
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d216
movq %r14, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x104428(%rip), %rdi    # 0x165f60
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x28e40
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x28710
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x28f70
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x293c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x674e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33776
jmp 0x674bc
movq %rsp, %rdi
callq 0x295a0
leaq 0x20(%rsp), %rdi
callq 0x28790
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6751f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3355a
movq %rsp, %rdi
callq 0x295a0
leaq 0x20(%rsp), %rdi
callq 0x28790
movq %r14, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x77a34(%rip), %rsi     # 0xdef7f
callq 0x3357b
testb %al, %al
jne 0x67567
leaq 0x68013(%rip), %rsi     # 0xcf56e
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x67581
movsd 0x8(%rsp), %xmm0
cmpeqsd (%rsp), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x703da(%rip), %rsi     # 0xd7962
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x675a3
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x675c3
leaq 0x748fe(%rip), %rsi     # 0xdbea8
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x675c8
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
seta %al
jmp 0x6757b
leaq 0x748db(%rip), %rsi     # 0xdbeaa
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x675ea
xorl %eax, %eax
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jmp 0x6760a
leaq 0x748bc(%rip), %rsi     # 0xdbead
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x67612
xorl %eax, %eax
movsd (%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
setae %al
jmp 0x6757b
leaq 0x74897(%rip), %rsi     # 0xdbeb0
movq %rbx, %rdi
callq 0x3357b
testb %al, %al
je 0x67636
movsd 0x8(%rsp), %xmm0
cmpneqsd (%rsp), %xmm0
jmp 0x67573
pushq $-0x1
popq %rax
jmp 0x6757b
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a319
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x289d0
cmpl $0x3, 0x1614(%r14)
jb 0x6a33b
movq 0xfbca7(%rip), %rdi     # 0x165f98
leaq 0x72285(%rip), %rsi     # 0xdc57d
callq 0x289f0
movq %rax, %rdi
movl %ebx, %esi
callq 0x29290
movq %rax, %rdi
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
jmp 0x284a0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x59ec0
movq %rbx, %rdi
callq 0x28df0
movl %eax, %edi
callq 0x289d0
movq %rsp, %rdi
callq 0x59f62
addq $0x1388, %rsp           # imm = 0x1388
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x59f62
movq %rbx, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28a10
movq %rax, %rbx
movq %rax, %rdi
callq 0x5fac8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fc44
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xc0, %esi
movq %rbx, %rdi
callq 0x28a50
movq %r14, %rdi
callq 0x292f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6a40f
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, (%rsp)
callq 0x284f0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x284f0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x284f0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x284f0
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_O2/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 0x6a48b
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x284f0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x284f0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x284f0
movsd 0x8(%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
addsd 0x18(%rsp), %xmm1
movsd 0x6bd86(%rip), %xmm0    # 0xd6208
addq $0x28, %rsp
jmp 0x292b0
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::addExp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Swarm::addExp(string path, int mid) {
//	Timer tmr;

//cout << "Swarm::addExp   1-path:"<< path<<endl; mypause();
	path = convertToAbsPath(path);
//cout << "Swarm::addExp   2-fullpath:"<< path<<endl; mypause();
	string basename = getFilename(path);
//cout << "Swarm::addExp   3-basename:"<< basename<<endl; mypause();

//cout << "Swarm::addExp inserting EXP?" << endl; mypause();
	this->options.expFiles.insert(make_pair(basename, new Data(path, this, true, mid)));
//cout << "Swarm::addExp exp inserted" << endl; mypause();

	//double t = tmr.elapsed();
	//cout << "Adding .exp took " << t << " seconds" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x28dd0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9e3f4
leaq 0x8(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x28c40
movq %rbx, %rdi
callq 0x295a0
leaq 0x70(%rsp), %rdi
callq 0x295a0
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x28dd0
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9ed1e
leaq 0x90(%rsp), %rdi
callq 0x295a0
movl $0x160, %edi            # imm = 0x160
callq 0x28a10
movq %rax, %r15
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x28dd0
movb $0x1, %r12b
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %r8d
callq 0x47a50
xorl %r12d, %r12d
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x28dd0
addq $0x1560, %r14           # imm = 0x1560
leaq 0x8(%rsp), %rsi
movq %r15, 0x20(%rsi)
movq %r14, %rdi
callq 0x8d678
leaq 0x8(%rsp), %rdi
callq 0x295a0
leaq 0x30(%rsp), %rdi
callq 0x295a0
leaq 0x50(%rsp), %rdi
callq 0x295a0
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x295a0
xorl %r12d, %r12d
jmp 0x6a5d7
movq %rax, %r14
jmp 0x6a5e6
movq %rax, %r14
jmp 0x6a5f3
movq %rax, %r14
movq %r15, %rbx
jmp 0x6a5f3
movq %rax, %r14
leaq 0x70(%rsp), %rdi
jmp 0x6a5f6
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x295a0
testb %r12b, %r12b
je 0x6a5f3
movl $0x160, %esi            # imm = 0x160
movq %r15, %rdi
callq 0x28a50
movq %rbx, %rdi
callq 0x295a0
movq %r14, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::setsConf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Swarm::setsConf(std::string sConf, int mid){  //razi added
	if (options.verbosity>=3) cout<<"Setting sConf id:" << mid << " File:" << sConf <<endl;
	int sz = sConf_.size();
	if (mid < 0){
		outputError("Error in setting sConf. Invalid id. Quitting ....");
	}else if ((mid >= 0) && (mid == sz)){
		sConf_.push_back(sConf);
	}else if ((mid >= 0) && (mid < sz)){
		sConf_.at(mid) = sConf;
	}else if ((mid >= 0) && (mid > sz)){

		for(int i = 0; i < mid - sz; i++){
			sConf_.push_back("");
		}
		sConf_.at(mid) = sConf;
	}

//	cout<<"set conf done, new size is:"<< sConf_.size() <<". Eneter a number to continue..."; cin>>i;
//	if( sConf_.size()>0)
//		for(i=0; i<sConf_.size(); i++)
//			cout<<" SConf[" << i <<"] is:" << sConf_.at(i)<<", ";
//
//	}
//	catch(string err){
//		cout<<"Error occurred in set conf Err:"<< err;
//	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0x3, 0x1614(%rdi)
jb 0x6adb0
movq 0xfb220(%rip), %rdi     # 0x165f98
leaq 0x71942(%rip), %rsi     # 0xdc6c1
callq 0x289f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x29290
leaq 0x719df(%rip), %rsi     # 0xdc774
movq %rax, %rdi
callq 0x289f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28910
movq %rax, %rdi
callq 0x284a0
movq %rbx, 0x10(%rsp)
testl %ebp, %ebp
js 0x6ae88
leaq 0x1938(%r15), %r14
movq 0x1940(%r15), %rax
subq 0x1938(%r15), %rax
shrq $0x5, %rax
cmpl %eax, %ebp
jne 0x6adf5
movq %r14, %rdi
movq 0x10(%rsp), %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33776
jge 0x6ae1c
movl %ebp, %esi
movq %r14, %rdi
callq 0x85e18
movq %rax, %rdi
movq 0x10(%rsp), %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28570
movl %ebp, %ecx
subl %eax, %ecx
jle 0x6ae79
xorl %ebx, %ebx
testl %ecx, %ecx
cmovgl %ecx, %ebx
leaq 0x69dd1(%rip), %r15     # 0xd4c01
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %r13
subl $0x1, %ebx
jb 0x6ae62
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x33402
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ec8c
movq %r12, %rdi
callq 0x295a0
jmp 0x6ae3a
movl %ebp, %esi
movq %r14, %rdi
callq 0x85e18
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x28570
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71844(%rip), %rsi     # 0xdc6d3
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x33402
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x6aed2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x6aec4
jmp 0x6aeb7
movq %rax, %rbx
jmp 0x6aec9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0xfb0bb(%rip), %rdi     # 0x165f98
callq 0x28910
movq %rax, %rdi
callq 0x284a0
cmpb $0x1, 0x13f8(%rbx)
jne 0x6af06
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x7aeb6
movq (%rbx), %rdi
callq 0x5fb5c
pushq $0x1
popq %rdi
callq 0x28c20
// File: /workspace/github_cpp_makefile_star2_O2/richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::setDefaultModelIndex(int)
void Swarm::setDefaultModelIndex(int mid){
	if((mid>=0) &&((unsigned) mid < this->options.models.size())){
		//this->options.model = this->options.models.at(mid);
		options.defaultModel = mid;
		if (options.verbosity >= 3) cout<<"Default model not set, Index is set to " << mid << " # of models:"<< this->options.models.size()<<endl;
	}else outputError("Default model not set, Index is out of range:"+toString(mid)+" # of models:"+ toString((int)this->options.models.size()));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
js 0x6bc2b
movl %ebp, %eax
movq 0x15c8(%rbx), %rcx
subq 0x15c0(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jbe 0x6bc2b
movl %ebp, 0x15d8(%rbx)
cmpl $0x3, 0x1614(%rbx)
jb 0x6bc1f
movq 0xfa3cb(%rip), %rdi     # 0x165f98
leaq 0x70cde(%rip), %rsi     # 0xdc8b2
callq 0x289f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x29290
leaq 0x70cf0(%rip), %rsi     # 0xdc8da
movq %rax, %rdi
callq 0x289f0
movq 0x15c8(%rbx), %rsi
subq 0x15c0(%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x286e0
movq %rax, %rdi
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x284a0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x80(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x9e9c3
leaq 0x70ca4(%rip), %rsi     # 0xdc8e8
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x4933b
leaq 0x70c82(%rip), %rdx     # 0xdc8da
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3336c
movq 0x15c8(%rbx), %rsi
subq 0x15c0(%rbx), %rsi
shrq $0x3, %rsi
movq %rsp, %rdi
callq 0x9e9c3
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
callq 0x4e6ed
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x6aed2
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x295a0
jmp 0x6bcb2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x295a0
jmp 0x6bcbf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x295a0
jmp 0x6bcce
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x295a0
jmp 0x6bcdd
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x295a0
movq %rbx, %rdi
callq 0x292f0