LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::FindSSRs(Arguments*)
FindSSRs::FindSSRs(Arguments* _args)
{
	this->args = _args;
	this->out_file = new OutputFile(this->args->getOutFileName());
	this->out_file->write("#Sequence_Name\tSSR\tRepeats\tPosition\n");
	this->progress_bar = new ProgressMeter(this->args->displayProgressBar());
	this->atomicity_checker = new AtomicityChecker();
	this->tasks = new TaskQueue(this->args->getMaxTaskQueueSize());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x132e0
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl $0x220, %edi            # imm = 0x220
callq 0x43a0
movq %rax, -0x50(%rbp)
jmp 0x10d73
movq -0x58(%rbp), %rax
movb $0x1, -0x41(%rbp)
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x19f10
jmp 0x10d89
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4df0
jmp 0x10d98
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x0, -0x41(%rbp)
movq %rcx, 0x20(%rax)
leaq -0x40(%rbp), %rdi
callq 0x4788
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x103c3(%rip), %rsi     # 0x21183
callq 0x53e0
jmp 0x10dc7
movl $0x38, %edi
callq 0x43a0
movq %rax, -0x68(%rbp)
jmp 0x10dd7
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x19c30
movb %al, -0x69(%rbp)
jmp 0x10de8
movq -0x68(%rbp), %rdi
movb -0x69(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
callq 0x206e0
jmp 0x10dfc
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x28, %edi
callq 0x43a0
movq %rax, -0x78(%rbp)
jmp 0x10e18
movq -0x78(%rbp), %rdi
callq 0x9be0
jmp 0x10e23
movq -0x58(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl $0x68, %edi
callq 0x43a0
movq %rax, -0x80(%rbp)
jmp 0x10e3f
movq -0x58(%rbp), %rax
movq (%rax), %rdi
callq 0x19c50
movl %eax, -0x84(%rbp)
jmp 0x10e53
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdi
callq 0x16920
jmp 0x10e64
movq -0x58(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x38(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10f17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x10ead
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4788
testb $0x1, -0x41(%rbp)
jne 0x10eb5
jmp 0x10ec3
movq -0x50(%rbp), %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x43b0
jmp 0x10f17
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x38, %esi
callq 0x43b0
jmp 0x10f17
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x43b0
jmp 0x10f17
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x68, %esi
callq 0x43b0
movq -0x60(%rbp), %rdi
callq 0x13300
movq -0x18(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::~FindSSRs()
FindSSRs::~FindSSRs()
{
	delete this->out_file;
	delete this->progress_bar;
	delete this->atomicity_checker;
	delete this->tasks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x10f69
movq -0x10(%rbp), %rdi
callq 0x5190
movq -0x10(%rbp), %rdi
movl $0x220, %esi            # imm = 0x220
callq 0x43b0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x10f92
movq -0x20(%rbp), %rdi
callq 0x20760
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x10fbb
movq -0x28(%rbp), %rdi
callq 0xaa80
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x43b0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x10fe4
movq -0x30(%rbp), %rdi
callq 0x16950
movq -0x30(%rbp), %rdi
movl $0x68, %esi
callq 0x43b0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x13300
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::run()
uint32_t FindSSRs::run()
{
	// set up consumers
	uint32_t error = this->makeThreads(); // set up consumers

	if (error)
	{
		return error;
	}

	// find the ssrs in the sequences
	try
	{
		this->processInput(); // produce (and consume if only main thread)
	}
	catch (string e)
	{
		cerr << e << endl;
		return 1;
	}
	catch (const char* e)
	{
		cerr << e << endl;
		return 1;
	}

	// join threads
	//cerr << "About to start joining threads..." << endl;
	//usleep(3000000);
	this->joinAndForgetAllThreads(); // clean up consumers

	// we're done!
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11180
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x11030
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11155
movq -0x58(%rbp), %rdi
callq 0x112d0
jmp 0x1103b
jmp 0x11145
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x110c1
movq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x44d0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x4170
jmp 0x11076
movq -0x68(%rbp), %rdi
callq 0x4150
movq 0x20f6a(%rip), %rdi     # 0x31ff0
leaq -0x50(%rbp), %rsi
callq 0x4340
movq %rax, -0x70(%rbp)
jmp 0x11095
movq -0x70(%rbp), %rdi
movq 0x20ef0(%rip), %rsi     # 0x31f90
callq 0x43e0
jmp 0x110a7
movl $0x1, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4788
callq 0x4640
jmp 0x11155
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x11161
movq -0x20(%rbp), %rdi
callq 0x4150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq 0x20f07(%rip), %rdi     # 0x31ff0
callq 0x4390
movq %rax, -0x78(%rbp)
jmp 0x110f4
movq -0x78(%rbp), %rdi
movq 0x20e91(%rip), %rsi     # 0x31f90
callq 0x43e0
jmp 0x11106
movl $0x1, -0x4(%rbp)
callq 0x4640
jmp 0x11155
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4640
jmp 0x11161
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4788
callq 0x4640
jmp 0x11143
jmp 0x11161
movq -0x58(%rbp), %rdi
callq 0x11b50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46e0
movq %rax, %rdi
callq 0x4d60
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::makeThreads()
uint32_t FindSSRs::makeThreads()
{
	pthread_attr_t tattr;
	pthread_attr_init(&tattr);
	pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
	//pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
	
	for (uint32_t i = 1; i < this->args->getNumThreads(); ++i)
	{
		pthread_t thread;
		this->threads.push_back(thread);

		if ( pthread_create(&(this->threads[this->threads.size() - 1]), &tattr, &consume, (void*) new ConsumerArguments(this->tasks, this->progress_bar, this->out_file, this->atomicity_checker, this->args)) != 0 )
		{
			perror("creating threads");
			return errno;
		}
	}

	pthread_attr_destroy(&tattr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x44a0
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x4510
movl $0x1, -0x4c(%rbp)
movq -0x70(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, -0x74(%rbp)
movq (%rax), %rdi
callq 0x19d30
movl %eax, %ecx
movl -0x74(%rbp), %eax
cmpl %ecx, %eax
jae 0x112a4
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x90(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x13360
movq -0x90(%rbp), %rdi
callq 0x133f0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0x133d0
movq %rax, -0x88(%rbp)
movl $0x28, %edi
callq 0x43a0
movq %rax, %rdi
movq -0x70(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq 0x38(%rax), %rsi
movq 0x28(%rax), %rdx
movq (%rax), %r9
movq 0x20(%rax), %rcx
movq 0x30(%rax), %r8
callq 0x13410
jmp 0x11240
movq -0x80(%rbp), %rcx
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq 0x9aa(%rip), %rdx       # 0x11c00
callq 0x4720
cmpl $0x0, %eax
je 0x11294
leaq 0xff41(%rip), %rdi      # 0x211a8
callq 0x4300
callq 0x4050
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x112b4
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movl $0x28, %esi
callq 0x43b0
jmp 0x112c0
jmp 0x11296
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x111b2
leaq -0x48(%rbp), %rdi
callq 0x4650
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x46e0
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::joinAndForgetAllThreads()
void FindSSRs::joinAndForgetAllThreads()
{
	for (uint32_t i = 0; i < this->threads.size(); ++i)
	{
		//cerr << "Attempting to join thread #" << i << " with ID=" << this->threads[i] << endl;
		long status = 0L;
		long* status_ptr = &status;

		int joinerr = 0;
		joinerr = pthread_join(this->threads[i],(void**) &status_ptr); //if ( pthread_join(this->threads[i],(void**) &status_ptr) != 0)
		if ( joinerr != 0 && joinerr != EINVAL)
		{
			perror("joining thread");
			//cerr << "joinerr,errno" << joinerr << "," << errno << endl;
		}
	}

	this->threads.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x133f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x11be8
movq -0x30(%rbp), %rdi
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
addq $0x8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x133d0
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4360
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x11bdb
cmpl $0x16, -0x24(%rbp)
je 0x11bdb
leaq 0xf5e3(%rip), %rdi      # 0x211b9
callq 0x4300
jmp 0x11bdd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11b6b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x13460
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: calculateDataSizeFromFasta(std::basic_ifstream<char, std::char_traits<char>>&)
static
uint32_t calculateDataSizeFromFasta(ifstream &fasta)
{
	fasta.seekg(0, fasta.end); // move to the end
	uint32_t size = fasta.tellg(); // get position of the end
	fasta.seekg(0, fasta.beg); // move to the beginning
	fasta.clear(); // reset the error state flags, if necessary
	return size; // return the size
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x4540
movq -0x8(%rbp), %rdi
callq 0x46d0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x13780
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4540
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x4680
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: findSSRsExhaustively(Task*, std::set<unsigned int, bool (*)(unsigned int, unsigned int), std::allocator<unsigned int>>*)
static
vector<SSR*>* findSSRsExhaustively(Task* task, set<uint32_t, bool(*)(uint32_t,uint32_t)>* periods)
{
	vector<SSR*>* ssrs = new vector<SSR*>();

	string seq = task->getSequence();
	//vector<uint32_t> periods = task->getPeriods();

	//for (uint32_t i = 0; i < periods.size(); ++i)
	for (set<uint32_t, bool(*)(uint32_t,uint32_t)>::iterator itr = periods->begin(); itr != periods->end(); ++itr)
	{
		for (uint32_t index = 0; index < task->size(); ++index)
		{
			//ssrs.push_back(seekSinglePeriodSizeSSRatIndex(task->getSequenceRef(), index, task->getGlobalPosition(), periods[i]));
			//ssrs->push_back(seekSinglePeriodSizeSSRatIndex(seq, index, task->getGlobalPosition(), periods[i]));
			ssrs->push_back(seekSinglePeriodSizeSSRatIndex(seq, index, task->getGlobalPosition(), *itr));
		}
	}

	return ssrs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x43a0
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x41c0
movq -0x70(%rbp), %rdi
callq 0x137b0
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x163a0
movq -0x10(%rbp), %rdi
callq 0x137d0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13830
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13800
testb $0x1, %al
jne 0x1283e
jmp 0x128fd
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
callq 0x163d0
movl %eax, -0x74(%rbp)
jmp 0x12859
movl -0x78(%rbp), %eax
movl -0x74(%rbp), %ecx
cmpl %ecx, %eax
jae 0x128ed
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x163f0
movl %eax, -0x7c(%rbp)
jmp 0x12886
leaq -0x40(%rbp), %rdi
callq 0x13890
movl -0x80(%rbp), %esi
movl -0x7c(%rbp), %edx
movl (%rax), %ecx
leaq -0x38(%rbp), %rdi
callq 0x12de0
movq %rax, -0x90(%rbp)
jmp 0x128a9
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x13860
jmp 0x128c6
jmp 0x128c8
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x12845
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4788
jmp 0x12921
jmp 0x128ef
leaq -0x40(%rbp), %rdi
callq 0x138c0
jmp 0x1281b
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4788
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x46e0
nopw (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: keepSSR(SSR*, Arguments*)
static
bool keepSSR(SSR* ssr, Arguments* args)
{
	// check the number of repeats
	if ( (ssr->getRepeats() < args->getMinRepeats()) || (ssr->getRepeats() > args->getMaxRepeats()) )
	{
		return false;
	}

	// check the entire ssr length
	if ( (ssr->getLength() < args->getMinNucleotideLength()) || (ssr->getLength() > args->getMaxNucleotideLength()) )
	{
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x57e0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19cf0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jb 0x1327c
movq -0x10(%rbp), %rdi
callq 0x57e0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19d10
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jbe 0x13282
movb $0x0, -0x1(%rbp)
jmp 0x132c8
movq -0x10(%rbp), %rdi
callq 0x5820
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19cb0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jb 0x132be
movq -0x10(%rbp), %rdi
callq 0x5820
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19cd0
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jbe 0x132c4
movb $0x0, -0x1(%rbp)
jmp 0x132c8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: ConsumerArguments::ConsumerArguments(TaskQueue*, ProgressMeter*, OutputFile*, AtomicityChecker*, Arguments*)
ConsumerArguments(TaskQueue* _tasks_ptr, ProgressMeter* _progress_bar_ptr, OutputFile* _ofd_ptr, AtomicityChecker* _atomicity_checker_ptr, Arguments* _arguments_ptr)
	{
		tasks_ptr = _tasks_ptr;
		progress_bar_ptr = _progress_bar_ptr;
		ofd_ptr = _ofd_ptr;
		atomicity_checker_ptr = _atomicity_checker_ptr;
		arguments_ptr = _arguments_ptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::~Arguments()
Arguments::~Arguments()
{
	this->alphabet->clear();
	delete this->alphabet;

	this->periods->clear();
	delete this->periods;
	
	this->enumerated_ssrs->clear();
	delete this->enumerated_ssrs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x1b5f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x19ad4
movq -0x10(%rbp), %rdi
callq 0x1b610
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x1b630
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x19b10
movq -0x20(%rbp), %rdi
callq 0x1b650
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x43b0
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x1b670
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x19b4c
movq -0x28(%rbp), %rdi
callq 0x1b690
movq -0x28(%rbp), %rdi
movl $0x38, %esi
callq 0x43b0
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
callq 0x4788
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x4788
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x4788
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x4788
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x4788
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::parsePositiveIntegerArgument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint32_t Arguments::parsePositiveIntegerArgument(string argument)
{
	long int num = strtol(argument.c_str(), NULL, 10);

	if (num != 0L and num != LONG_MAX and num != LONG_MIN and num > 0)
	{
		return (uint32_t) num;
	}
	else
	{
		throw "ERROR: One of your arguments should have been a positive integer, but it wasn't.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4160
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x4570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a0dd
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0x1a0dd
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
je 0x1a0dd
cmpq $0x0, -0x18(%rbp)
jle 0x1a0dd
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x80e7(%rip), %rax      # 0x221d8
movq %rax, (%rdi)
movq 0x17ea5(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::addToAlphabet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Arguments::addToAlphabet(string alphabet_str)
{
	for (uint32_t i = 0; i < alphabet_str.size(); ++i)
	{
		if (!isalpha(alphabet_str[i]) && alphabet_str[i] != ',')
		{
			throw string("ERROR: '") + alphabet_str[i] + "' is not a valid alphabet character.";
		}

		this->alphabet->insert(toupper(alphabet_str[i]));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x90(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x98(%rbp)
callq 0x4260
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x1a2fc
movq -0x90(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4770
movsbl (%rax), %edi
callq 0x4620
cmpl $0x0, %eax
jne 0x1a2aa
movq -0x90(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4770
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x1a2aa
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x41a0
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4700
movq -0xa0(%rbp), %rdx
leaq 0x82cd(%rip), %rsi      # 0x224a4
leaq -0x58(%rbp), %rdi
callq 0x6da0
jmp 0x1a1e2
movq -0x90(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4770
movq %rax, -0xb0(%rbp)
jmp 0x1a1fc
movq -0xb0(%rbp), %rax
movsbl (%rax), %edx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b980
jmp 0x1a215
movq -0xa8(%rbp), %rdi
leaq 0x828a(%rip), %rdx      # 0x224ad
leaq -0x38(%rbp), %rsi
callq 0x16810
jmp 0x1a22e
movq -0xa8(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x17b28(%rip), %rsi     # 0x31d68
movq 0x17d61(%rip), %rdx     # 0x31fa8
callq 0x46a0
jmp 0x1a30e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1a28b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1a282
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4788
leaq -0x58(%rbp), %rdi
callq 0x4788
leaq -0x59(%rbp), %rdi
callq 0x4410
testb $0x1, -0x6d(%rbp)
jne 0x1a29c
jmp 0x1a2a8
movq -0xa8(%rbp), %rdi
callq 0x42a0
jmp 0x1a305
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4770
movsbl (%rax), %edi
callq 0x4730
movq -0xb8(%rbp), %rdi
movb %al, -0x6e(%rbp)
leaq -0x6e(%rbp), %rsi
callq 0x1b9d0
movq %rax, -0x80(%rbp)
movb %dl, -0x78(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a13c
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x46e0
nop
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::sanityCheckArguments() const
void Arguments::sanityCheckArguments() const
{
	if (this->min_nucleotides > this->max_nucleotides)
	{
		throw "ERROR: -n must not be > than -N";
	}
	
	if (this->min_repeats > this->max_repeats)
	{
		throw "ERROR: -r must not be > than -R";
	}

	if (this->min_sequence_length > this->max_sequence_length)
	{
		throw "ERROR: -l must not be > than -L";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x80(%rcx), %eax
cmpl 0x84(%rcx), %eax
jbe 0x1acc9
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x778e(%rip), %rax      # 0x22444
movq %rax, (%rdi)
movq 0x172e0(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
movq -0x10(%rbp), %rcx
movl 0xb4(%rcx), %eax
cmpl 0xb8(%rcx), %eax
jbe 0x1ad02
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x7775(%rip), %rax      # 0x22464
movq %rax, (%rdi)
movq 0x172a7(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
movq -0x10(%rbp), %rcx
movl 0x78(%rcx), %eax
cmpl 0x7c(%rcx), %eax
jbe 0x1ad35
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x7762(%rip), %rax      # 0x22484
movq %rax, (%rdi)
movq 0x17274(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::autoDetectCompressedInput()
void Arguments::autoDetectCompressedInput()
{
	if (this->input_file_name.size() >= 3 && this->input_file_name.substr(this->input_file_name.size() - 3, 3) == ".gz")
	{
		this->gzipped_input = true;
	}
	if (this->input_file_name.size() >= 4 && this->input_file_name.substr(this->input_file_name.size() - 4, 4) == ".bz2")
	{
		this->bzipped2_input = true;
	}
	if (this->bzipped2_input && this->gzipped_input)
	{
		throw "ERROR: Your input cannot be compressed with both gzip and bzip2.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x58, %rdi
callq 0x4260
movq %rax, %rcx
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq $0x3, %rcx
movb %al, -0x62(%rbp)
jb 0x1adc7
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4260
movq -0x88(%rbp), %rsi
movq %rax, %rdx
addq $-0x3, %rdx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %ecx
callq 0x43c0
movq -0x80(%rbp), %rdi
movb $0x1, -0x29(%rbp)
leaq 0x7603(%rip), %rsi      # 0x223b8
callq 0x13520
movb %al, -0x71(%rbp)
jmp 0x1adbf
movb -0x71(%rbp), %al
movb %al, -0x62(%rbp)
jmp 0x1adc7
movb -0x62(%rbp), %al
movb %al, -0x89(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1add8
jmp 0x1ade1
leaq -0x28(%rbp), %rdi
callq 0x4788
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x1aded
jmp 0x1ae19
movq -0x70(%rbp), %rax
movb $0x1, 0xd(%rax)
jmp 0x1ae19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1ae0b
jmp 0x1ae14
leaq -0x28(%rbp), %rdi
callq 0x4788
jmp 0x1af35
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
callq 0x4260
movq %rax, %rcx
movb $0x0, -0x61(%rbp)
xorl %eax, %eax
cmpq $0x4, %rcx
movb %al, -0x8a(%rbp)
jb 0x1ae9f
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4260
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
addq $-0x4, %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x4, %ecx
callq 0x43c0
movq -0x98(%rbp), %rdi
movb $0x1, -0x61(%rbp)
leaq 0x7538(%rip), %rsi      # 0x223bc
callq 0x13520
movb %al, -0x8b(%rbp)
jmp 0x1ae91
movb -0x8b(%rbp), %al
movb %al, -0x8a(%rbp)
jmp 0x1ae9f
movb -0x8a(%rbp), %al
movb %al, -0xa1(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x1aeb3
jmp 0x1aebc
leaq -0x60(%rbp), %rdi
callq 0x4788
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1aec8
jmp 0x1aef1
movq -0x70(%rbp), %rax
movb $0x1, 0x9(%rax)
jmp 0x1aef1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x1aee6
jmp 0x1aeef
leaq -0x60(%rbp), %rdi
callq 0x4788
jmp 0x1af35
movq -0x70(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x1af2c
movq -0x70(%rbp), %rax
testb $0x1, 0xd(%rax)
je 0x1af2c
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x74a8(%rip), %rax      # 0x223c1
movq %rax, (%rdi)
movq 0x1707d(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46e0
nop
// File: ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::autoDetectCompressedOutput()
void Arguments::autoDetectCompressedOutput()
{
	if (this->output_file_name.size() >= 3 && this->output_file_name.substr(this->output_file_name.size() - 3, 3) == ".gz")
	{
		this->gzipped_output = true;
	}
	if (this->output_file_name.size() >= 4 && this->output_file_name.substr(this->output_file_name.size() - 4, 4) == ".bz2")
	{
		this->bzipped2_output = true;
	}
	if (this->bzipped2_output && this->gzipped_output)
	{
		throw "ERROR: Your output cannot be compressed with both gzip and bzip2.";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x88, %rdi
callq 0x4260
movq %rax, %rcx
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq $0x3, %rcx
movb %al, -0x62(%rbp)
jb 0x1afcd
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x88(%rbp)
callq 0x4260
movq -0x88(%rbp), %rsi
movq %rax, %rdx
addq $-0x3, %rdx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %ecx
callq 0x43c0
movq -0x80(%rbp), %rdi
movb $0x1, -0x29(%rbp)
leaq 0x73fd(%rip), %rsi      # 0x223b8
callq 0x13520
movb %al, -0x71(%rbp)
jmp 0x1afc5
movb -0x71(%rbp), %al
movb %al, -0x62(%rbp)
jmp 0x1afcd
movb -0x62(%rbp), %al
movb %al, -0x89(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1afde
jmp 0x1afe7
leaq -0x28(%rbp), %rdi
callq 0x4788
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x1aff3
jmp 0x1b01f
movq -0x70(%rbp), %rax
movb $0x1, 0xe(%rax)
jmp 0x1b01f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x1b011
jmp 0x1b01a
leaq -0x28(%rbp), %rdi
callq 0x4788
jmp 0x1b141
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
callq 0x4260
movq %rax, %rcx
movb $0x0, -0x61(%rbp)
xorl %eax, %eax
cmpq $0x4, %rcx
movb %al, -0x8a(%rbp)
jb 0x1b0ab
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4260
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
addq $-0x4, %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x4, %ecx
callq 0x43c0
movq -0x98(%rbp), %rdi
movb $0x1, -0x61(%rbp)
leaq 0x732c(%rip), %rsi      # 0x223bc
callq 0x13520
movb %al, -0x8b(%rbp)
jmp 0x1b09d
movb -0x8b(%rbp), %al
movb %al, -0x8a(%rbp)
jmp 0x1b0ab
movb -0x8a(%rbp), %al
movb %al, -0xa1(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x1b0bf
jmp 0x1b0c8
leaq -0x60(%rbp), %rdi
callq 0x4788
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1b0d4
jmp 0x1b0fd
movq -0x70(%rbp), %rax
movb $0x1, 0xa(%rax)
jmp 0x1b0fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x1b0f2
jmp 0x1b0fb
leaq -0x60(%rbp), %rdi
callq 0x4788
jmp 0x1b141
movq -0x70(%rbp), %rax
testb $0x1, 0xa(%rax)
je 0x1b138
movq -0x70(%rbp), %rax
testb $0x1, 0xe(%rax)
je 0x1b138
movl $0x8, %edi
callq 0x41a0
movq %rax, %rdi
leaq 0x72dd(%rip), %rax      # 0x22402
movq %rax, (%rdi)
movq 0x16e71(%rip), %rsi     # 0x31fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x46a0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x46e0
nopw (%rax,%rax)
// File: nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/LSH/../../algorithms/Search/LSH/headers/hashing.h
// Function: unsigned int lsh::AmplifiedHashFunction::hash<double>(std::vector<double, std::allocator<double>>)
uint32_t hash(std::vector<T> x) {
				int concatenated = 0;
				for (std::list<HashFunction>::iterator it = hlist.begin(); it != hlist.end(); it++) {
					// each time, concatenate with a bit-wise manner the next h
					concatenated = our_math::bitwise_concat(concatenated, it->hash(x), k);
				}

				// return the final random number
				return concatenated;
			}

// Assembly:
subq $0x88, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x0, 0x74(%rsp)
callq 0x9c90
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc230
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xec90
testb $0x1, %al
jne 0xeb8f
jmp 0xec30
movw 0x74(%rsp), %ax
movw %ax, 0x6(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xece0
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4500
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xed00
movl %eax, 0x1c(%rsp)
jmp 0xebd1
movl 0x1c(%rsp), %esi
movw 0x6(%rsp), %ax
movq 0x28(%rsp), %rcx
movl 0x30(%rcx), %edx
movzwl %ax, %edi
callq 0xecb0
movl %eax, (%rsp)
jmp 0xebef
movl (%rsp), %eax
movl %eax, 0x74(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x34b0
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0xef70
movq %rax, 0x30(%rsp)
jmp 0xeb68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x34b0
jmp 0xec3c
movl 0x74(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: SneachChea[P]Wolf-Monte-Carlo-Cpp/./model.hpp
// Function: model::model(int, int)
model(int _L, int _Ntrials){
        this->L = _L;
        this-> N = _L*_L;
        this-> N_trials = _Ntrials;
        x_y_dic.reserve(N);
        nbr.reserve(N);
        init();
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x4420
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
movq %rdi, 0x20(%rsp)
callq 0x4430
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
movq %rdi, 0x10(%rsp)
callq 0x4440
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x3c(%rsp), %ecx
imull %ecx, %ecx
movl %ecx, 0x4(%rax)
movl 0x38(%rsp), %ecx
movl %ecx, 0x8(%rax)
movslq 0x4(%rax), %rsi
callq 0x4450
jmp 0x356b
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x58, %rdi
movslq 0x4(%rax), %rsi
callq 0x4560
jmp 0x3582
movq 0x18(%rsp), %rdi
callq 0x9020
jmp 0x358e
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x4670
movq 0x20(%rsp), %rdi
callq 0x46d0
movq 0x8(%rsp), %rdi
callq 0x4730
movq 0x30(%rsp), %rdi
callq 0x2350
nopl (%rax)
// File: SneachChea[P]Wolf-Monte-Carlo-Cpp/./tools.hpp
// Function: int randomChoice<int>(std::vector<int, std::allocator<int>>)
T randomChoice(std::vector<T> const vec){
    assert(vec.size() != 0);
    std::random_device rd;  
    std::mt19937 gen(rd()); 
    std::uniform_int_distribution<> dis(0, vec.size()-1);
    return vec[dis(gen)];
}

// Assembly:
subq $0x2758, %rsp           # imm = 0x2758
movq %rdi, 0x20(%rsp)
movq %rdi, 0x2750(%rsp)
callq 0x3c40
cmpq $0x0, %rax
je 0x3c81
jmp 0x3ca0
leaq 0x945b(%rip), %rdi      # 0xd0e3
leaq 0x9464(%rip), %rsi      # 0xd0f3
movl $0x1c, %edx
leaq 0x9464(%rip), %rcx      # 0xd0ff
callq 0x2140
leaq 0x13c8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x35d0
movq 0x10(%rsp), %rdi
callq 0x3670
movl %eax, 0x1c(%rsp)
jmp 0x3cc2
movl 0x1c(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x3680
jmp 0x3cd6
movq 0x20(%rsp), %rdi
callq 0x3c40
movl %eax, %edx
decl %edx
leaq 0x2c(%rsp), %rdi
xorl %esi, %esi
callq 0x36c0
jmp 0x3cf2
leaq 0x2c(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3ba0
movl %eax, 0xc(%rsp)
jmp 0x3d07
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rsi
callq 0x75f0
movl (%rax), %eax
movl %eax, 0x8(%rsp)
leaq 0x13c8(%rsp), %rdi
callq 0x43c0
movl 0x8(%rsp), %eax
addq $0x2758, %rsp           # imm = 0x2758
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x13c8(%rsp), %rdi
callq 0x43c0
movq 0x38(%rsp), %rdi
callq 0x2350
nopl (%rax)
// File: SneachChea[P]Wolf-Monte-Carlo-Cpp/model.cpp
// Function: model::get_nbr(int, int)
int model::get_nbr(const int i, const int number)
{
    switch(number)
    {
        case 0:
            return std::get<0>(nbr[i]);
        case 1:
            return std::get<1>(nbr[i]);
        case 2:
            return std::get<2>(nbr[i]);
        case 3:
            return std::get<3>(nbr[i]);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x942a
movq 0x8(%rsp), %rax
leaq 0x3e83(%rip), %rcx      # 0xd21c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
addq $0x58, %rdi
movslq 0x14(%rsp), %rsi
callq 0x96c0
movq %rax, %rdi
callq 0x9720
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x942c
movq (%rsp), %rdi
addq $0x58, %rdi
movslq 0x14(%rsp), %rsi
callq 0x96c0
movq %rax, %rdi
callq 0x9730
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x942c
movq (%rsp), %rdi
addq $0x58, %rdi
movslq 0x14(%rsp), %rsi
callq 0x96c0
movq %rax, %rdi
callq 0x9740
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x942c
movq (%rsp), %rdi
addq $0x58, %rdi
movslq 0x14(%rsp), %rsi
callq 0x96c0
movq %rax, %rdi
callq 0x9750
movl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x942c
ud2
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: SneachChea[P]Wolf-Monte-Carlo-Cpp/tools.cpp
// Function: linspace(double, double, int, bool)
d_vector linspace(double min, double max, int nbr, bool endpoint)
{
    d_vector d;
    if(nbr==1){
        d.push_back(min);
        return d;
    }
    if(min==max){
        d.push_back(max);
        return d;
    }
    d.reserve(nbr);
    if(endpoint==false){
    for(int i=0; i<nbr; i++){
        d.push_back(min +i*(max-min)/double(nbr));
    }
    }else{
    for(int i=0; i<nbr; i++){
        d.push_back(min +i*(max-min)/double(nbr-1));
    }   
    }
    return d;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
vmovsd %xmm0, 0x58(%rsp)
vmovsd %xmm1, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
andb $0x1, %al
movb %al, 0x4b(%rsp)
movb $0x0, 0x4a(%rsp)
callq 0xb450
cmpl $0x1, 0x4c(%rsp)
jne 0xb1df
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xb460
jmp 0xb1b0
movb $0x1, 0x4a(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0xb306
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x4360
jmp 0xb321
vmovsd 0x58(%rsp), %xmm0
vucomisd 0x50(%rsp), %xmm0
jne 0xb212
jp 0xb212
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb460
jmp 0xb200
movb $0x1, 0x4a(%rsp)
movl $0x1, 0x38(%rsp)
jmp 0xb306
movq 0x8(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xb4d0
jmp 0xb223
movb 0x4b(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb293
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xb291
movq 0x8(%rsp), %rdi
vmovsd 0x58(%rsp), %xmm0
vcvtsi2sdl 0x34(%rsp), %xmm1, %xmm1
vmovsd 0x50(%rsp), %xmm2
vsubsd %xmm0, %xmm2, %xmm2
vmulsd %xmm2, %xmm1, %xmm1
vcvtsi2sdl 0x4c(%rsp), %xmm2, %xmm2
vdivsd %xmm2, %xmm1, %xmm1
vaddsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0xb5e0
jmp 0xb282
jmp 0xb284
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xb239
jmp 0xb2f9
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0xb2f7
movq 0x8(%rsp), %rdi
vmovsd 0x58(%rsp), %xmm0
vcvtsi2sdl 0x24(%rsp), %xmm1, %xmm1
vmovsd 0x50(%rsp), %xmm2
vsubsd %xmm0, %xmm2, %xmm2
vmulsd %xmm2, %xmm1, %xmm1
movl 0x4c(%rsp), %eax
decl %eax
vcvtsi2sd %eax, %xmm2, %xmm2
vdivsd %xmm2, %xmm1, %xmm1
vaddsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0xb5e0
jmp 0xb2e8
jmp 0xb2ea
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xb29b
jmp 0xb2f9
movb $0x1, 0x4a(%rsp)
movl $0x1, 0x38(%rsp)
testb $0x1, 0x4a(%rsp)
jne 0xb317
movq 0x8(%rsp), %rdi
callq 0x4360
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2350
nopl (%rax,%rax)
// File: SneachChea[P]Wolf-Monte-Carlo-Cpp/tools.cpp
// Function: initLattice(std::vector<int, std::allocator<int>>&)
void initLattice(std::vector<int> &S)
{   
    std::random_device rd;  
    std::mt19937 gen(rd()); 
    std::uniform_int_distribution<> dis(0, 1);
    for(auto & i : S)
    {
        i = dis(gen)*2-1;
    }
}

// Assembly:
subq $0x2768, %rsp           # imm = 0x2768
movq %rdi, 0x2760(%rsp)
leaq 0x13d8(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35d0
movq 0x8(%rsp), %rdi
callq 0x3670
movl %eax, 0x14(%rsp)
jmp 0xb361
movl 0x14(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x3680
jmp 0xb375
leaq 0x3c(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x36c0
jmp 0xb388
movq 0x2760(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x40c0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x40f0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x85f0
testb $0x1, %al
jne 0xb3c8
jmp 0xb425
leaq 0x28(%rsp), %rdi
callq 0x8670
movq %rax, 0x18(%rsp)
leaq 0x3c(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ba0
movl %eax, 0x4(%rsp)
jmp 0xb3ec
movl 0x4(%rsp), %ecx
shll %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x85d0
jmp 0xb3b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x13d8(%rsp), %rdi
callq 0x43c0
jmp 0xb43a
leaq 0x13d8(%rsp), %rdi
callq 0x43c0
addq $0x2768, %rsp           # imm = 0x2768
retq
movq 0x48(%rsp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nop
// File: hkbu-victor[P]SFastLDA/super_fast_final1_w.cpp
// Function: show_help()
void show_help(){
	printf("\nHKBU SuperFast Gibb's sampling for LDA\n");
	printf("\n word-by-word LDA modeling\n");
	printf("=====================================\n");
	printf("Command line usage:\n");
	printf("super_fast_final1_w -alpha <double> -beta <double> -ntopics <int> -niters <int> -dfile <string> -seed <int> -ofile <string>\n");
	printf("=====================================\n");
	printf("Parameters \t Type \t\t Descriptions\n");
	printf("-alpha\t\t<double> Hyper-parameter for documents-topic distributions\n");
    printf("-beta\t\t<double> Hyper-parameter for word-topic distributions \n");
    printf("-ntopics\t\t<int> Number of topics \n");
    printf("-niters\t\t<int> Number of Gibbs sampling iterations \n");
    printf("-seed\t\t<int> Random seed \n");
    printf("-dfile\t\t<file> Input training data file \n");
	printf("-ofile\t\t<file> The output WP file and Z file (in text format)\n");
}

// Assembly:
pushq %rax
leaq 0x5db0(%rip), %rdi      # 0x7028
movb $0x0, %al
callq 0x1040
leaq 0x5dcb(%rip), %rdi      # 0x7051
movb $0x0, %al
callq 0x1040
leaq 0x5dda(%rip), %rdi      # 0x706e
movb $0x0, %al
callq 0x1040
leaq 0x5df3(%rip), %rdi      # 0x7095
movb $0x0, %al
callq 0x1040
leaq 0x5dfa(%rip), %rdi      # 0x70aa
movb $0x0, %al
callq 0x1040
leaq 0x5db0(%rip), %rdi      # 0x706e
movb $0x0, %al
callq 0x1040
leaq 0x5e5b(%rip), %rdi      # 0x7127
movb $0x0, %al
callq 0x1040
leaq 0x5e70(%rip), %rdi      # 0x714a
movb $0x0, %al
callq 0x1040
leaq 0x5ea6(%rip), %rdi      # 0x718e
movb $0x0, %al
callq 0x1040
leaq 0x5ed7(%rip), %rdi      # 0x71cd
movb $0x0, %al
callq 0x1040
leaq 0x5eec(%rip), %rdi      # 0x71f0
movb $0x0, %al
callq 0x1040
leaq 0x5f13(%rip), %rdi      # 0x7225
movb $0x0, %al
callq 0x1040
leaq 0x5f20(%rip), %rdi      # 0x7240
movb $0x0, %al
callq 0x1040
leaq 0x5f3c(%rip), %rdi      # 0x726a
movb $0x0, %al
callq 0x1040
popq %rax
retq
nopw (%rax,%rax)
// File: hkbu-victor[P]SFastLDA/super_fast_final1_w.cpp
// Function: eval_BETA_D_2_norm()
void eval_BETA_D_2_norm(){
	double dtemp;
	for (int di=0; di<D; di++){
		BETA_D_2_norm[ di ] = 0.0;
		di_pair = dpPair[di];
		for (int j=0; j<D_pair_count[di]; j++){
			dtemp = (double) di_pair[j].value * BETA;
			BETA_D_2_norm[di] += dtemp * dtemp;
		}
	}
}

// Assembly:
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl 0x8a82(%rip), %eax      # 0xa104
jge 0x1739
movq 0x8b31(%rip), %rax      # 0xa1c0
movslq -0xc(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x8b7d(%rip), %rax      # 0xa220
movslq -0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8b65(%rip)      # 0xa218
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq 0x8aa2(%rip), %rcx      # 0xa168
movslq -0xc(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x1727
movq 0x8b41(%rip), %rax      # 0xa218
movslq -0x10(%rsp), %rcx
cvtsi2sdl 0x4(%rax,%rcx,8), %xmm0
mulsd 0x8a96(%rip), %xmm0     # 0xa180
movsd %xmm0, -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
movsd -0x8(%rsp), %xmm2
movq 0x8abd(%rip), %rax      # 0xa1c0
movslq -0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x16bb
jmp 0x1729
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1678
retq
nopw (%rax,%rax)
// File: hkbu-victor[P]SFastLDA/super_fast_final1_w.cpp
// Function: sort_dpPairIdx()
void sort_dpPairIdx(){
	int di, pair_count;

	for (di=0; di<D; di++){
		di_pair = dpPair[di];
		pair_count = D_pair_count[di];
		std::sort(di_pair, di_pair + pair_count, compare_D_DoublePair());
	}
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x873e(%rip), %eax      # 0xa104
jge 0x1a1e
movq 0x8851(%rip), %rax      # 0xa220
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8839(%rip)      # 0xa218
movq 0x8782(%rip), %rax      # 0xa168
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
movq 0x881f(%rip), %rdi      # 0xa218
movq 0x8818(%rip), %rsi      # 0xa218
movslq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x49e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x19bc
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: dmonaldo[P]simple-network-file-system/client.cpp
// Function: main
int main(int argc, char **argv)
{
  Shell shell;

  if (argc == 2) {
    shell.mountNFS(string(argv[1]));
    shell.run();
  }
  else if (argc == 4 && strcmp(argv[1], "-s") == 0) {
    shell.mountNFS(string(argv[3]));
    shell.run_script(argv[2]);
  }
  else {
    cerr << "Invalid command line" << endl;
    cerr << "Usage (one of the following): " << endl;
    cerr << "./nfsclient server:port" << endl;
    cerr << "./nfsclient -s <script-name> server:port" << endl;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8140
cmpl $0x2, -0x8(%rbp)
jne 0x7fce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3470
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x6380
jmp 0x7f6e
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3700
jmp 0x7f7d
leaq -0x38(%rbp), %rdi
callq 0x3508
leaq -0x39(%rbp), %rdi
callq 0x3320
leaq -0x18(%rbp), %rdi
callq 0x5050
jmp 0x811f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3508
leaq -0x39(%rbp), %rdi
callq 0x3320
jmp 0x812a
cmpl $0x4, -0x8(%rbp)
jne 0x8095
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1282(%rip), %rsi      # 0x9269
callq 0x33c0
cmpl $0x0, %eax
jne 0x8095
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3470
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x6380
jmp 0x802d
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3700
jmp 0x803c
leaq -0x70(%rbp), %rdi
callq 0x3508
leaq -0x71(%rbp), %rdi
callq 0x3320
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x5850
jmp 0x811d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8087
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3508
leaq -0x71(%rbp), %rdi
callq 0x3320
jmp 0x812a
movq 0x3f54(%rip), %rdi      # 0xbff0
leaq 0x11c9(%rip), %rsi      # 0x926c
callq 0x32b0
movq %rax, %rdi
movq 0x3ef6(%rip), %rsi      # 0xbfa8
callq 0x3300
movq 0x3f32(%rip), %rdi      # 0xbff0
leaq 0x11bc(%rip), %rsi      # 0x9281
callq 0x32b0
movq %rax, %rdi
movq 0x3ed4(%rip), %rsi      # 0xbfa8
callq 0x3300
movq 0x3f10(%rip), %rdi      # 0xbff0
leaq 0x11b9(%rip), %rsi      # 0x92a0
callq 0x32b0
movq %rax, %rdi
movq 0x3eb2(%rip), %rsi      # 0xbfa8
callq 0x3300
movq 0x3eee(%rip), %rdi      # 0xbff0
leaq 0x11af(%rip), %rsi      # 0x92b8
callq 0x32b0
movq %rax, %rdi
movq 0x3e90(%rip), %rsi      # 0xbfa8
callq 0x3300
jmp 0x811f
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/int-div.cc
// Function: main
int main() 
{
	// ival1 is 3; result is truncated; remainder is discarded
	int ival1 = 21/6;

	// ival2 is 3; no remainder; result is an integral value
	int ival2 = 21/7;

	cout << ival1 << " " << ival2 << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x3, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
movl -0x8(%rbp), %esi
movq 0x2df1(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xe0e(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2db8(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: signExtend(long, int)
uint64_t signExtend(int64_t x,int n)
{
	int mask = 0x1;
	uint64_t tmpval = 0;
	int sign = x & (mask<<n);
	REP(i,0,n-1)
		tmpval += x & (mask << i);
	if(sign)
	{
		tmpval -= sign;
	}

	return tmpval;
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x13bc
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %edx
movl -0x20(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1388
cmpl $0x0, -0x1c(%rbp)
je 0x13d1
movslq -0x1c(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)