LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x90(%rbp)
addq $0x78, %rdi
callq 0x45170
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jb 0xb15ef
movl -0x14(%rbp), %esi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x17e460
movq -0xa0(%rbp), %rdx
leaq 0x129b91(%rip), %rsi    # 0x1db0e9
leaq -0x58(%rbp), %rdi
callq 0x8e0f0
jmp 0xb1563
leaq 0x129ba2(%rip), %rdx    # 0x1db10c
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x441f0
jmp 0xb1579
leaq -0x38(%rbp), %rdi
callq 0x17e420
jmp 0xb1584
leaq -0x38(%rbp), %rdi
callq 0x311e8
leaq -0x58(%rbp), %rdi
callq 0x311e8
leaq -0x78(%rbp), %rdi
callq 0x311e8
jmp 0xb15ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb15e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb15db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x311e8
leaq -0x58(%rbp), %rdi
callq 0x311e8
leaq -0x78(%rbp), %rdi
callq 0x311e8
jmp 0xb1622
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
addq $0x78, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x45190
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x30170
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, (%rsi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rsi)
movl -0x18(%rbp), %eax
movl %eax, 0x18(%rsi)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0xb1680
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0xb46f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xb1b8a
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0xb4710
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xb1b7d
movb $0x1, -0x1(%rbp)
jmp 0xb1b8e
jmp 0xb1b7f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb1b3e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
subl -0x10(%rbp), %ecx
movl %ecx, -0xec(%rbp)
movq 0xa8(%rax), %rdi
callq 0x8dec0
movq -0xf8(%rbp), %rcx
movl %eax, %esi
movl -0xec(%rbp), %eax
xorl %edx, %edx
divl %esi
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x40(%rcx), %eax
je 0xb1d98
movl -0x14(%rbp), %esi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x17e460
movq -0x100(%rbp), %rdx
leaq 0x12a676(%rip), %rsi    # 0x1dc29a
leaq -0x98(%rbp), %rdi
callq 0x8e0f0
jmp 0xb1c32
leaq 0x12a686(%rip), %rdx    # 0x1dc2bf
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x441f0
jmp 0xb1c4b
movq -0xf8(%rbp), %rax
movl 0x40(%rax), %esi
leaq -0xe8(%rbp), %rdi
callq 0x17e460
jmp 0xb1c63
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x9c7d0
jmp 0xb1c79
leaq 0x12a643(%rip), %rdx    # 0x1dc2c3
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x441f0
jmp 0xb1c8f
leaq -0x38(%rbp), %rdi
callq 0x17e420
jmp 0xb1c9a
leaq -0x38(%rbp), %rdi
callq 0x311e8
leaq -0x58(%rbp), %rdi
callq 0x311e8
leaq -0xe8(%rbp), %rdi
callq 0x311e8
leaq -0x78(%rbp), %rdi
callq 0x311e8
leaq -0x98(%rbp), %rdi
callq 0x311e8
leaq -0xb8(%rbp), %rdi
callq 0x311e8
jmp 0xb1d98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xb1d8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xb1d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xb1d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xb1d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0xb1d60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x311e8
leaq -0x58(%rbp), %rdi
callq 0x311e8
leaq -0xe8(%rbp), %rdi
callq 0x311e8
leaq -0x78(%rbp), %rdi
callq 0x311e8
leaq -0x98(%rbp), %rdi
callq 0x311e8
leaq -0xb8(%rbp), %rdi
callq 0x311e8
jmp 0xb1da4
movl -0x14(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x30170
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x50(%rax), %rax
testb $0x1, 0x1631(%rax)
je 0xccde4
movq 0x208264(%rip), %rdi    # 0x2d4f90
leaq -0xc(%rbp), %rsi
callq 0x311b0
jmp 0xccd37
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x3, 0x1614(%rax)
jb 0xccd9d
movq 0x208201(%rip), %rdi    # 0x2d4f50
leaq 0x111472(%rip), %rsi    # 0x1de1c8
callq 0x2ff50
movq %rax, -0x30(%rbp)
jmp 0xccd61
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2f800
movq %rax, -0x38(%rbp)
jmp 0xccd73
movq -0x38(%rbp), %rdi
leaq 0x111456(%rip), %rsi    # 0x1de1d4
callq 0x2ff50
movq %rax, -0x40(%rbp)
jmp 0xccd89
movq -0x40(%rbp), %rdi
movq 0x208234(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
jmp 0xccd9b
jmp 0xccd9d
callq 0x30e30
jmp 0xccda4
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x3, 0x1614(%rax)
jb 0xccde2
movq 0x208194(%rip), %rdi    # 0x2d4f50
leaq 0x11142a(%rip), %rsi    # 0x1de1ed
callq 0x2ff50
movq %rax, -0x48(%rbp)
jmp 0xccdce
movq -0x48(%rbp), %rdi
movq 0x2081ef(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
jmp 0xccde0
jmp 0xccde2
jmp 0xcce37
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0xd04a0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0xd0510
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd04d0
testb $0x1, %al
jne 0xcce19
jmp 0xcce35
leaq -0x18(%rbp), %rdi
callq 0xd0540
movq (%rax), %rdi
callq 0xd0560
leaq -0x18(%rbp), %rdi
callq 0xd0580
jmp 0xccdf5
jmp 0xcce37
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
callq 0xd03f0
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0xd0420
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0xd0480
movq -0x28(%rbp), %rdi
callq 0x448d0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x43490
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdx, -0x250(%rbp)
movq %rdi, -0x248(%rbp)
movq %rdi, %rax
movq %rax, -0x240(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2f790
leaq -0x190(%rbp), %rsi
leaq -0x228(%rbp), %rdi
xorl %edx, %edx
callq 0xd0ff0
jmp 0xceca2
movq -0x250(%rbp), %rsi
leaq -0x228(%rbp), %rdi
callq 0xd1070
jmp 0xcecb7
leaq -0x228(%rbp), %rdi
callq 0xd10b0
movq -0x248(%rbp), %rdi
movb $0x0, -0x235(%rbp)
leaq -0x1a0(%rbp), %rsi
callq 0x302b0
jmp 0xcecdf
movb $0x1, -0x235(%rbp)
testb $0x1, -0x235(%rbp)
jne 0xced31
jmp 0xced25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0xced4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0xd10b0
jmp 0xced4d
movq -0x248(%rbp), %rdi
callq 0x311e8
leaq -0x1a0(%rbp), %rdi
callq 0x2f940
movq -0x240(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x2f940
movq -0x230(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fe00
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x451d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Pheromones.hh
// Function: void Pheromones::swarmMessage::serialize<boost::archive::text_oarchive>(boost::archive::text_oarchive&, unsigned int)
void serialize(Archive & ar, const unsigned int version)
		{
			ar & tag;

			ar & id;
			ar & sender;

			ar & message;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe06a0
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0xe06d0
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x24, %rsi
callq 0xe06d0
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0xe0700
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x2f790
movq -0x1e0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x30140
jmp 0xe3f4e
leaq -0x1d0(%rbp), %rdi
callq 0x2f880
movq -0x1f0(%rbp), %rdi
movb $0x0, -0x1d1(%rbp)
callq 0x448b0
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2f050
movq %rax, -0x1f8(%rbp)
jmp 0xe3f8d
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2f8e0
movb %al, -0x1f9(%rbp)
jmp 0xe3fab
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0xe3fb7
jmp 0xe400e
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x45280
jmp 0xe3fcc
jmp 0xe3f6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0xe4052
movq -0x1f0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
callq 0x448d0
leaq -0x1d0(%rbp), %rdi
callq 0x311e8
jmp 0xe4052
movb $0x1, -0x1d1(%rbp)
testb $0x1, -0x1d1(%rbp)
jne 0xe402a
movq -0x1f0(%rbp), %rdi
callq 0x448d0
leaq -0x1d0(%rbp), %rdi
callq 0x311e8
leaq -0x1a0(%rbp), %rdi
callq 0x2f940
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x2f940
movq -0x1a8(%rbp), %rdi
callq 0x30170
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x13c0, %rsp           # imm = 0x13C0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x13b0(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xe984a
movl -0xc(%rbp), %edi
callq 0x31020
movq -0x13b0(%rbp), %rax
cmpl $0x3, 0x1614(%rax)
jb 0xe9848
movq 0x1eb72e(%rip), %rdi    # 0x2d4f50
leaq 0xf76c4(%rip), %rsi     # 0x1e0eed
callq 0x2ff50
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2f800
movq %rax, %rdi
movq 0x1eb785(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
jmp 0xe98aa
leaq -0x1398(%rbp), %rdi
movq %rdi, -0x13c0(%rbp)
callq 0xb2730
movq -0x13c0(%rbp), %rdi
callq 0xb27d0
movl %eax, -0x13b4(%rbp)
jmp 0xe9871
movl -0x13b4(%rbp), %edi
callq 0x31020
leaq -0x1398(%rbp), %rdi
callq 0xb2960
jmp 0xe98aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13a0(%rbp)
movl %eax, -0x13a4(%rbp)
leaq -0x1398(%rbp), %rdi
callq 0xb2960
jmp 0xe98b3
addq $0x13c0, %rsp           # imm = 0x13C0
popq %rbp
retq
movq -0x13a0(%rbp), %rdi
callq 0x30170
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xc0, %edi
callq 0x2f3b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0xccc30
jmp 0xe98ef
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcce80
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc0, %esi
callq 0x2f2a0
movq -0x18(%rbp), %rdi
callq 0x30170
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0xe99c8
movsd -0x18(%rbp), %xmm0
callq 0x2fd10
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2fd10
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x2fd10
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2fd10
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xe99e5
movsd -0x18(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0xe9a7a
movsd -0x20(%rbp), %xmm0
callq 0x2fd10
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x2fd10
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x2fd10
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm3
movsd -0x38(%rbp), %xmm0
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movl $0xa, %edi
callq 0xb29d0
movsd %xmm0, -0x8(%rbp)
jmp 0xe9a9b
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
subsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1ea191(%rip), %rdi    # 0x2d4f50
callq 0x2f780
movq %rax, %rdi
movq 0x1ea1fa(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movq -0x18(%rbp), %rax
testb $0x1, 0x13f8(%rax)
je 0xeadfa
movq -0x18(%rbp), %rdi
movl $0x16, %esi
callq 0x108620
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xccd00
movl $0x1, %edi
callq 0x30200
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xec508
movq -0xc8(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0xd0(%rbp)
addq $0x14c0, %rdi           # imm = 0x14C0
addq $0x100, %rdi            # imm = 0x100
callq 0x45170
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0xec508
movq -0xc8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x15d8(%rax)
cmpl $0x3, 0x1614(%rax)
jb 0xec503
movq 0x1e8ab2(%rip), %rdi    # 0x2d4f50
leaq 0xf4d7d(%rip), %rsi     # 0x1e1222
callq 0x2ff50
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2f800
movq %rax, %rdi
leaq 0xf4d8b(%rip), %rsi     # 0x1e124a
callq 0x2ff50
movq -0xc8(%rbp), %rdi
movq %rax, -0xd8(%rbp)
addq $0x14c0, %rdi           # imm = 0x14C0
addq $0x100, %rdi            # imm = 0x100
callq 0x45170
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x30cf0
movq %rax, %rdi
movq 0x1e8aca(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
jmp 0xec667
movl -0xc(%rbp), %esi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x17ce40
movq -0xe0(%rbp), %rdx
leaq 0xf4d2c(%rip), %rsi     # 0x1e1258
leaq -0x70(%rbp), %rdi
callq 0x8e0f0
jmp 0xec537
leaq 0xf4d0c(%rip), %rdx     # 0x1e124a
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x441f0
jmp 0xec54d
movq -0xc8(%rbp), %rdi
addq $0x15c0, %rdi           # imm = 0x15C0
callq 0x45170
movl %eax, %esi
leaq -0xc0(%rbp), %rdi
callq 0x17ce40
jmp 0xec570
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x9c7d0
jmp 0xec586
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xeada0
jmp 0xec598
leaq -0x30(%rbp), %rdi
callq 0x311e8
leaq -0xc0(%rbp), %rdi
callq 0x311e8
leaq -0x50(%rbp), %rdi
callq 0x311e8
leaq -0x70(%rbp), %rdi
callq 0x311e8
leaq -0x90(%rbp), %rdi
callq 0x311e8
jmp 0xec667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xec659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xec650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xec647
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xec63b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x311e8
leaq -0xc0(%rbp), %rdi
callq 0x311e8
leaq -0x50(%rbp), %rdi
callq 0x311e8
leaq -0x70(%rbp), %rdi
callq 0x311e8
leaq -0x90(%rbp), %rdi
callq 0x311e8
jmp 0xec670
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x30170
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
addq $0x14c0, %rdi           # imm = 0x14C0
addq $0x100, %rdi            # imm = 0x100
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x45190
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8e140
testb $0x1, -0x15(%rbp)
je 0xec7fc
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x30940
movl $0x1, -0x3c(%rbp)
jmp 0xec851
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2f300
jmp 0xec80b
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x17d590
jmp 0xec81a
leaq -0x60(%rbp), %rdi
callq 0x311e8
movl $0x1, -0x3c(%rbp)
jmp 0xec851
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xec867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x311e8
jmp 0xec867
leaq -0x38(%rbp), %rdi
callq 0x311e8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x311e8
movq -0x68(%rbp), %rdi
callq 0x30170
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x3, 0x1614(%rax)
jb 0xf9fbf
movq 0x1dafac(%rip), %rdi    # 0x2d4f50
leaq 0xe78ec(%rip), %rsi     # 0x1e1897
callq 0x2ff50
movq %rax, %rdi
movq 0x1db00e(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movq -0x10(%rbp), %rdi
callq 0xfa070
movq -0x10(%rbp), %rdi
callq 0xfa140
movq -0x10(%rbp), %rax
movsd %xmm0, 0x1d88(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0xfa03f
movsd -0x10(%rbp), %xmm0
movl $0x2, %edi
callq 0x8e5b0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xfa013
movl -0x14(%rbp), %ecx
xorl %edx, %edx
movl $0x1, %eax
divl %ecx
cvtsi2sd %eax, %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x2fc60
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x3, 0x1614(%rax)
jb 0xfa0af
movq 0x1daebc(%rip), %rdi    # 0x2d4f50
leaq 0xe7813(%rip), %rsi     # 0x1e18ae
callq 0x2ff50
movq %rax, %rdi
movq 0x1daf1e(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0xfa104
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xfa250
movq -0x18(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
addq $0x1cf0, %rdi           # imm = 0x1CF0
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x121fc0
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfa0b6
movq -0x18(%rbp), %rax
cmpl $0x3, 0x1614(%rax)
jb 0xfa133
movq 0x1dae38(%rip), %rdi    # 0x2d4f50
leaq 0xe77a9(%rip), %rsi     # 0x1e18c8
callq 0x2ff50
movq %rax, %rdi
movq 0x1dae9a(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::calcWeightedAveragePosition()
double Swarm::calcWeightedAveragePosition() {

	if (options.verbosity >= 3) {
		cout << "Calculating weighted average position" << endl;
	}

	double sum = 0;
	for (int p = 1; p <= options.swarmSize; ++p) {

		if ((unsigned) p == particleBestFitsByFit_.begin()->second) {
			continue;
		}

		sum += particleWeights_.at(p) * particleBestFits_[p];
	}

	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x3, 0x1614(%rax)
jb 0xfa17f
movq 0x1dadec(%rip), %rdi    # 0x2d4f50
leaq 0xe7767(%rip), %rsi     # 0x1e18d2
callq 0x2ff50
movq %rax, %rdi
movq 0x1dae4e(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0xfa237
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x1ab0, %rdi           # imm = 0x1AB0
callq 0x122630
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x122660
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0xfa1d1
jmp 0xfa229
movq -0x30(%rbp), %rdi
addq $0x1cf0, %rdi           # imm = 0x1CF0
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x1226a0
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x1a20, %rdi           # imm = 0x1A20
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x121fc0
movsd -0x40(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfa18e
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::calcParticleWeight(unsigned int)
double Swarm::calcParticleWeight(unsigned int particle) {
	// Get reciprocal of euclidian norm of the difference between swarm best fit and particle best fit
	double numerator = 1 / getEuclidianNorm( (particleBestFits_[particle] - particleBestFitsByFit_.begin()->first), this->getNumFreeParams());

	// Eq 8 in Moraes et al
	double sum = 0;
	for (int i = 1; i <= options.swarmSize; ++i) {
		// Make sure we're not using the particle with the best fit -- it will
		// result in a div_by_0
		if ((unsigned)i == particleBestFitsByFit_.begin()->second) {
			continue;
		}

		// Add 1/euclidian
		sum += 1 / numerator;
	}

	double weight = numerator / sum;

	return weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x1a20, %rdi           # imm = 0x1A20
leaq -0xc(%rbp), %rsi
callq 0x122740
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x1ab0, %rdi           # imm = 0x1AB0
callq 0x122630
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x122660
movsd -0x58(%rbp), %xmm0
movq -0x50(%rbp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x121af0
movq -0x50(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movl %eax, %esi
callq 0xf9ff0
movaps %xmm0, %xmm1
movsd 0xe0859(%rip), %xmm0    # 0x1dab28
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x50(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0xfa348
movq -0x50(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x1ab0, %rdi           # imm = 0x1AB0
callq 0x122630
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x122660
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0xfa326
jmp 0xfa33d
movsd 0xe07fa(%rip), %xmm0    # 0x1dab28
divsd -0x18(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfa2e7
movsd -0x18(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::updateInertia()
void Swarm::updateInertia() {
	// Eq 3 from Moraes et al
	options.inertia = options.inertiaInit + (options.inertiaFinal - options.inertiaInit) * (inertiaUpdateCounter_ / (float)(options.nmax + inertiaUpdateCounter_));
	if (options.verbosity >= 3) {
		cout << "Setting inertia to " << options.inertia << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movss 0x169c(%rax), %xmm1
movss 0x16a0(%rax), %xmm0
subss %xmm1, %xmm0
movl 0x1d98(%rax), %ecx
movl %ecx, %edx
cvtsi2ss %rcx, %xmm2
movl 0x1694(%rax), %ecx
addl %edx, %ecx
cvtsi2ss %rcx, %xmm3
divss %xmm3, %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x1688(%rax)
cmpl $0x3, 0x1614(%rax)
jb 0xfcce5
movq 0x1d829a(%rip), %rdi    # 0x2d4f50
leaq 0xe5032(%rip), %rsi     # 0x1e1cef
callq 0x2ff50
movq %rax, %rdi
movq -0x10(%rbp), %rax
movss 0x1688(%rax), %xmm0
callq 0x30ce0
movq %rax, %rdi
movq 0x1d82e8(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::outputBootstrapSummary()
void Swarm::outputBootstrapSummary() {
	outputError("Swarm::outputBootstrapSummary()");
/*
	string outputPath = options.outputDir + "/" + options.jobName + "_bootstrap/bootstrap_results.txt";
	ofstream outputFile;
	outputFile.open(outputPath, ofstream::out | std::ofstream::app);

	if (outputFile.is_open()) {
		outputFile.precision(8);
		outputFile.setf(ios::scientific);

		if (bootstrapCounter == 0) {
			// Output first two fields of header
			outputFile << left << setw(16) << "Fit";

			// Output parameter names
			for (auto i = options.model->freeParams_.begin(); i != options.model->freeParams_.end(); ++i) {
				outputFile << left << setw(16) << i->first;
			}
			outputFile << endl;
		}

		vector<string> paramVals;
		split(allGenFits.begin()->second, paramVals);
		outputFile << left << setw(16) << allGenFits.begin()->first;
		for (unsigned int i = 1; i < paramVals.size(); i++) {
			outputFile << left << setw(16) << stod(paramVals[i]);
		}
		outputFile << endl;
		outputFile.close();
	}
	else {
		cout << "Warning: couldn't open: " << outputPath << " to write fit summary." << endl;
	}
	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x30a70
movq -0x48(%rbp), %rdx
leaq 0xdef31(%rip), %rsi     # 0x1e43ed
leaq -0x28(%rbp), %rdi
callq 0x44470
jmp 0x1054c7
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xeada0
jmp 0x1054d6
leaq -0x28(%rbp), %rdi
callq 0x311e8
leaq -0x29(%rbp), %rdi
callq 0x311c0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x105511
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x311e8
leaq -0x29(%rbp), %rdi
callq 0x311c0
movq -0x38(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::killAllParticles(int)
void Swarm::killAllParticles(int tag) {
	int p, sp;
	unsigned int mid;
	for (p = 1; p <= options.swarmSize; ++p) {
		//cout << "killing " << p << " with tag: " << tag << endl;
		for(mid=0; mid < options.models.size(); mid++){//Raquel modified this
			//sp = (p-1)*getNumModels()+ mid + 1; //Raquel replaced by code bellow
			sp = fcalcsubParID(p, mid, options.models.size());

			if(options.verbosity>=3){
				cout << "RAQUEL sending message to subPar " << sp << "message=" << tag << endl;
			}
			swarmComm->sendToSwarm(0, sp, tag, false, swarmComm->univMessageSender);
		}
	}
	swarmComm->univMessageSender.clear();
	//cout << "killed all particles" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0x10874f
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
addq $0x14c0, %rdi           # imm = 0x14C0
addq $0x100, %rdi            # imm = 0x100
callq 0x45170
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x10873f
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x14c0, %rdi           # imm = 0x14C0
addq $0x100, %rdi            # imm = 0x100
callq 0x45170
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
movl %eax, %edx
callq 0x17d3a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
cmpl $0x3, 0x1614(%rax)
jb 0x10870f
movq 0x1cc881(%rip), %rdi    # 0x2d4f50
leaq 0xdbd37(%rip), %rsi     # 0x1e440d
callq 0x2ff50
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2f800
movq %rax, %rdi
leaq 0xdbd3f(%rip), %rsi     # 0x1e442f
callq 0x2ff50
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2f800
movq %rax, %rdi
movq 0x1cc8be(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %edx
movl -0xc(%rbp), %ecx
movq (%rax), %r9
xorl %r8d, %r8d
movl %r8d, %esi
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
callq 0xcd520
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x108658
jmp 0x108741
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10863e
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x451d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::insertKeyByValue(std::multimap<double, unsigned int, std::less<double>, std::allocator<std::pair<double const, unsigned int>>>&, double, unsigned int)
void Swarm::insertKeyByValue(multimap<double, unsigned int> &theMap, double key, unsigned int value) {
	//cout << "looking for " << value << endl;
	for (auto thePair = theMap.begin(); thePair != theMap.end(); ++thePair) {
		if (thePair->second == value) {
			//cout << "found " << value << " inserting " << key << endl;
			theMap.erase(thePair);
			theMap.insert(pair<double, unsigned int>(key, value));
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x122630
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1231a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1231d0
testb $0x1, %al
jne 0x10f075
jmp 0x10f0db
leaq -0x28(%rbp), %rdi
callq 0x122660
movl 0x8(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x10f0cb
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x123200
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x123240
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x122340
movq %rax, -0x58(%rbp)
jmp 0x10f0db
jmp 0x10f0cd
leaq -0x28(%rbp), %rdi
callq 0xcbd20
jmp 0x10f055
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::saveSwarmState()
void Swarm::saveSwarmState() {
	string serializedSwarmPath = options.jobOutputDir + "swarmState.sconf";

	std::ofstream ofs(serializedSwarmPath);
	if (ofs.is_open()) {

		boost::archive::binary_oarchive ar(ofs);
		ar & *this;
		ofs.close();
	}
	else {
		cout << "Warning: Couldn't save swarm state to " << serializedSwarmPath << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x2a8(%rbp)
addq $0x1520, %rsi           # imm = 0x1520
leaq 0xf68a3(%rip), %rdx     # 0x205b8b
leaq -0x28(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x447b0
movq -0x2a0(%rbp), %rsi
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x2f360
jmp 0x10f312
leaq -0x228(%rbp), %rdi
callq 0x30530
movb %al, -0x2a9(%rbp)
jmp 0x10f326
movb -0x2a9(%rbp), %al
testb $0x1, %al
jne 0x10f335
jmp 0x10f3ce
leaq -0x298(%rbp), %rdi
leaq -0x228(%rbp), %rsi
xorl %edx, %edx
callq 0x123b20
jmp 0x10f34c
movq -0x2a8(%rbp), %rsi
leaq -0x298(%rbp), %rdi
callq 0x123b90
jmp 0x10f361
leaq -0x228(%rbp), %rdi
callq 0x30910
jmp 0x10f36f
leaq -0x298(%rbp), %rdi
callq 0x123bc0
jmp 0x10f41a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x10f444
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x10f438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x123bc0
jmp 0x10f438
movq 0x1c5b7b(%rip), %rdi    # 0x2d4f50
leaq 0xd3e32(%rip), %rsi     # 0x1e320e
callq 0x2ff50
movq %rax, -0x2b8(%rbp)
jmp 0x10f3ea
movq -0x2b8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2f780
movq %rax, -0x2c0(%rbp)
jmp 0x10f403
movq -0x2c0(%rbp), %rdi
movq 0x1c5bb7(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
jmp 0x10f418
jmp 0x10f41a
leaq -0x228(%rbp), %rdi
callq 0x304f0
leaq -0x28(%rbp), %rdi
callq 0x311e8
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x228(%rbp), %rdi
callq 0x304f0
leaq -0x28(%rbp), %rdi
callq 0x311e8
movq -0x230(%rbp), %rdi
callq 0x30170
nopl (%rax)
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::generateParticleFs()
vector<float> Swarm::generateParticleFs() {
	float min = 0.5;
	float max = 1.5;

	vector<float> Fs = vector<float>(options.swarmSize + 1, 0);

	for (int p = 1; p <= options.swarmSize; ++p) {
		float r = (float)rand() / (float)RAND_MAX;
		float diff = max - min;

		Fs[p] = (r * diff) + min;
	}

	return Fs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x3f000000, -0x14(%rbp) # imm = 0x3F000000
movl $0x3fc00000, -0x18(%rbp) # imm = 0x3FC00000
movb $0x0, -0x19(%rbp)
movl 0x1620(%rax), %eax
incl %eax
cltq
movq %rax, -0x50(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x124730
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq 0x124750
jmp 0x11622e
leaq -0x21(%rbp), %rdi
callq 0x1247d0
movl $0x1, -0x38(%rbp)
movq -0x60(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0x1162ca
callq 0x30b00
movq -0x58(%rbp), %rdi
cvtsi2ss %eax, %xmm0
movss 0xca8f6(%rip), %xmm1    # 0x1e0b58
divss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x18(%rbp), %xmm0
subss -0x14(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x3c(%rbp), %xmm0
movss -0x40(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x6c(%rbp)
movslq -0x38(%rbp), %rsi
callq 0x124910
movss -0x6c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x11623e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x1247d0
jmp 0x1162e7
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1162dd
movq -0x58(%rbp), %rdi
callq 0x1248b0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x30170
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::generateParticleCRs()
vector<float> Swarm::generateParticleCRs() {
	float min = 0.1;
	float max = 0.9;

	vector<float> CRs = vector<float>(options.swarmSize + 1, 0);

	for (int p = 1; p <= options.swarmSize; ++p) {
		float r = (float)rand() / (float)RAND_MAX;
		float diff = max - min;

		CRs[p] = (r * diff) + min;
	}

	return CRs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x3dcccccd, -0x14(%rbp) # imm = 0x3DCCCCCD
movl $0x3f666666, -0x18(%rbp) # imm = 0x3F666666
movb $0x0, -0x19(%rbp)
movl 0x1620(%rax), %eax
incl %eax
cltq
movq %rax, -0x50(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x124730
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x20(%rbp), %rdx
callq 0x124750
jmp 0x11635e
leaq -0x21(%rbp), %rdi
callq 0x1247d0
movl $0x1, -0x38(%rbp)
movq -0x60(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0x1163fa
callq 0x30b00
movq -0x58(%rbp), %rdi
cvtsi2ss %eax, %xmm0
movss 0xca7c6(%rip), %xmm1    # 0x1e0b58
divss %xmm1, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x18(%rbp), %xmm0
subss -0x14(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x3c(%rbp), %xmm0
movss -0x40(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x6c(%rbp)
movslq -0x38(%rbp), %rsi
callq 0x124910
movss -0x6c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x11636e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x1247d0
jmp 0x116417
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x11640d
movq -0x58(%rbp), %rdi
callq 0x1248b0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x30170
// File: richardposner[P]BioNetFit2/src/code/Swarm.cpp
// Function: Swarm::generateParticleTemps()
vector<double> Swarm::generateParticleTemps() {
	// Eq 4 in Olensek et al

	// maxTemp is the difference between highest and lowest fits
	double maxTemp = particleBestFitsByFit_.rbegin()->first - particleBestFitsByFit_.begin()->first;
	//cout << "maxtemp is " << maxTemp << endl;
	//cout << "minTemp is " << options.minTemp << endl;
	//cout << "ss is " << options.swarmSize - 1 << endl;
	double ct = (1 / ((double)options.swarmSize - 1)) * log(maxTemp / options.minTemp);


	//cout << fixed << setprecision(10) << "ct is " << ct << endl;

	vector<double> temps = vector<double>(options.swarmSize + 1, 0);
	for (int p = 1; p <= options.swarmSize; ++p) {
		temps[p] = exp(0 - (ct * (p - 1)));
		//cout << fixed << setprecision(10) << "temp of " << p << " is " << temps[p] << endl;
	}

	return temps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x80(%rbp)
addq $0x1ab0, %rsi           # imm = 0x1AB0
movq %rsi, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1239e0
movq -0x98(%rbp), %rdi
callq 0x123a70
movq -0x90(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
callq 0x122630
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x122660
movsd -0x88(%rbp), %xmm0
movq %rax, %rcx
movq -0x80(%rbp), %rax
movsd (%rcx), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl 0x1620(%rax), %xmm1
movsd 0xc4664(%rip), %xmm0    # 0x1dab28
subsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x1710(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x2f410
movq -0x80(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movl 0x1620(%rax), %eax
incl %eax
cltq
movq %rax, -0x68(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb5b80
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
leaq -0x40(%rbp), %rdx
callq 0x1246b0
jmp 0x11653a
leaq -0x41(%rbp), %rdi
callq 0xbefe0
movl $0x1, -0x58(%rbp)
movq -0x80(%rbp), %rcx
movl -0x58(%rbp), %eax
cmpl 0x1620(%rcx), %eax
jg 0x1165d2
movsd -0x30(%rbp), %xmm0
movl -0x58(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
callq 0x2f350
movq -0x70(%rbp), %rdi
movsd %xmm0, -0xa8(%rbp)
movslq -0x58(%rbp), %rsi
callq 0xb2610
movsd -0xa8(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x11654a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xbefe0
jmp 0x1165f5
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x1165e5
movq -0x70(%rbp), %rdi
callq 0xb2660
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x30170
nop