LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/FindSSRs.cpp
// Function: FindSSRs::splitStringOnIgnoredChars(std::vector<unsigned int, std::allocator<unsigned int>>&, std::vector<unsigned int, std::allocator<unsigned int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&)
void FindSSRs::splitStringOnIgnoredChars(vector<uint32_t> &starts, vector<uint32_t> &sizes, const string &sequence, uint32_t &actually_ignored_chars)
{
	for (uint32_t i = 0; i < sequence.size(); ++i)
	{
		//if (!this->args->alphabet->count(sequence[i])) // if it's a "bad" character
		if (!this->args->inAlphabet(sequence[i])) // if it's a "bad" character
		{
			sizes.push_back(i - starts[starts.size() - 1]);
			++actually_ignored_chars;
		
			if (sizes[sizes.size() - 1] == 0)
			{
				starts.pop_back();
				sizes.pop_back();
			}

			starts.push_back(i + 1);
		}
	}

	sizes.push_back(sequence.size() - starts[starts.size() - 1]);

	if (sizes[sizes.size() - 1] == 0)
	{
		starts.pop_back();
		sizes.pop_back();
	}

	// Sanity check
	if (starts.size() != sizes.size())
	{
		cerr << "\n\tERROR! starts and sizes are not the same size!\n" << endl;
		exit(1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x0, 0x8(%rcx)
je 0x7ea5
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %r13
xorl %ecx, %ecx
xorl %ebp, %ebp
movq (%r13), %rdi
movq (%r12), %rax
movsbl (%rax,%rcx), %esi
callq 0xb7da
testb %al, %al
je 0x7e23
incl %ebp
jmp 0x7e93
movq 0x8(%rbx), %rcx
movl %ebp, %eax
subl -0x4(%rcx), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x7e46
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x7e57
movq %r14, %rdi
leaq 0x14(%rsp), %rdx
callq 0x8e8e
movq 0x8(%r14), %rsi
incl (%r15)
cmpl $0x0, -0x4(%rsi)
jne 0x7e6a
addq $-0x4, 0x8(%rbx)
addq $-0x4, 0x8(%r14)
incl %ebp
movl %ebp, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7e86
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7e93
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x8e8e
movl %ebp, %ecx
movq 0x8(%r12), %rax
cmpq %rcx, %rax
ja 0x7e0a
jmp 0x7ea7
xorl %eax, %eax
movq 0x8(%rbx), %rcx
subl -0x4(%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x7ec8
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x7ed9
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
callq 0x8e8e
movq 0x8(%r14), %rsi
movq (%r14), %rax
cmpl $0x0, -0x4(%rsi)
jne 0x7ef3
addq $-0x4, 0x8(%rbx)
movq 0x8(%r14), %rsi
addq $-0x4, %rsi
movq %rsi, 0x8(%r14)
subq %rax, %rsi
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq %rsi, %rax
jne 0x7f11
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd0d8(%rip), %rdi      # 0x14ff0
leaq 0x62db(%rip), %rsi      # 0xe1fa
callq 0x32e0
movq %rax, %rdi
callq 0x3150
movl $0x1, %edi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xc7be
movq (%rbx), %r14
testq %r14, %r14
je 0xb59f
movq %r14, %rdi
callq 0xc798
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
movq 0xa8(%rbx), %rdi
callq 0xc8f6
movq 0xa8(%rbx), %r14
testq %r14, %r14
je 0xb5cc
movq %r14, %rdi
callq 0xc808
movl $0x30, %esi
movq %r14, %rdi
callq 0x3300
movq 0xc0(%rbx), %rdi
callq 0xc87e
movq 0xc0(%rbx), %r14
testq %r14, %r14
je 0xb5f9
movq %r14, %rdi
callq 0xc858
movl $0x38, %esi
movq %r14, %rdi
callq 0x3300
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0xb624
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq 0x88(%rbx), %rdi
leaq 0x98(%rbx), %rax
cmpq %rax, %rdi
je 0xb642
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0xb65a
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xb672
movq (%rax), %rsi
incq %rsi
callq 0x3300
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0xb691
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq (%rsi), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x33f0
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
leaq 0x1(%rcx), %rdx
testq %rdx, %rax
je 0xb938
leaq -0x1(%rax), %rdx
cmpq %rcx, %rdx
jae 0xb938
popq %rcx
retq
movl $0x8, %edi
callq 0x3160
leaq 0x38d3(%rip), %rcx      # 0xf21c
movq %rcx, (%rax)
movq 0x964d(%rip), %rsi      # 0x14fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%rsi)
je 0xb9ce
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %r15d
xorl %r13d, %r13d
leaq 0x28(%rsp), %r12
movq (%r14), %rax
movsbl (%rax,%r13), %ebp
movl %ebp, %edi
callq 0x34a0
cmpl $0x2c, %ebp
je 0xb99f
testl %eax, %eax
je 0xb9dd
movq (%rbx), %r13
movl %ebp, %edi
callq 0x3590
movb %al, 0x8(%rsp)
movq %r13, 0x28(%rsp)
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0xcade
movl %r15d, %r13d
incl %r15d
cmpq %r13, 0x8(%r14)
ja 0xb987
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3160
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3aee(%rip), %rsi      # 0xf4e8
leaq 0x3aef(%rip), %rdx      # 0xf4f0
leaq 0x8(%rsp), %rdi
callq 0x54f4
movq (%r14), %rax
movsbl (%rax,%r13), %edx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc6d9
movb $0x1, %bpl
leaq 0x3ac5(%rip), %rdx      # 0xf4f1
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xc5c1
xorl %ebp, %ebp
leaq 0x931e(%rip), %rsi      # 0x14d60
movq 0x9547(%rip), %rdx      # 0x14f90
movq %rbx, %rdi
callq 0x3510
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xba6f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3300
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xba86
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
testb %bpl, %bpl
jne 0xbaac
jmp 0xbab4
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xbaac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3300
jmp 0xbaac
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/src/Arguments.cpp
// Function: Arguments::adjustMinSequenceLength()
void Arguments::adjustMinSequenceLength()
{
	// if the minimum period size we're searching for cannot repeat in
	// the minimum sequence size, why even look in those sequences?
	if (this->min_sequence_length < *this->periods->rbegin() * 2)
	{
		this->min_sequence_length = *this->periods->rbegin() * 2;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x78(%rdi), %ebp
movq 0xa8(%rdi), %rdi
addq $0x8, %rdi
callq 0x31c0
movl 0x20(%rax), %eax
addl %eax, %eax
cmpl %eax, %ebp
jae 0xc093
movl %eax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movl 0x80(%rdi), %eax
cmpl 0x84(%rdi), %eax
ja 0xc0c1
movl 0xb4(%rdi), %eax
cmpl 0xb8(%rdi), %eax
ja 0xc0d4
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
ja 0xc0e7
popq %rax
retq
movl $0x8, %edi
callq 0x3160
leaq 0x33b6(%rip), %rcx      # 0xf488
jmp 0xc0f8
movl $0x8, %edi
callq 0x3160
leaq 0x33c3(%rip), %rcx      # 0xf4a8
jmp 0xc0f8
movl $0x8, %edi
callq 0x3160
leaq 0x33d0(%rip), %rcx      # 0xf4c8
movq %rcx, (%rax)
movq 0x8e9e(%rip), %rsi      # 0x14fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdx
cmpq $0x3, %rdx
jb 0xc1c6
leaq 0x58(%rbx), %r14
addq $-0x3, %rdx
movq %rsp, %r15
movl $0x3, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3320
leaq 0x32b1(%rip), %rsi      # 0xf3fc
movq %r15, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0xc16f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
testl %ebp, %ebp
jne 0xc177
movb $0x1, 0xd(%rbx)
movq 0x60(%rbx), %rdx
cmpq $0x4, %rdx
jb 0xc1c6
addq $-0x4, %rdx
movq %rsp, %r15
movl $0x4, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3320
leaq 0x3261(%rip), %rsi      # 0xf400
movq %r15, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xc1be
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
testl %ebp, %ebp
jne 0xc1c6
movb $0x1, 0x9(%rbx)
cmpb $0x1, 0x9(%rbx)
jne 0xc1d2
cmpb $0x1, 0xd(%rbx)
je 0xc1df
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3160
leaq 0x3215(%rip), %rcx      # 0xf405
movq %rcx, (%rax)
movq 0x8da6(%rip), %rsi      # 0x14fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3510
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdx
cmpq $0x3, %rdx
jb 0xc2c7
leaq 0x88(%rbx), %r14
addq $-0x3, %rdx
movq %rsp, %r15
movl $0x3, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3320
leaq 0x31b3(%rip), %rsi      # 0xf3fc
movq %r15, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0xc26d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
testl %ebp, %ebp
jne 0xc275
movb $0x1, 0xe(%rbx)
movq 0x90(%rbx), %rdx
cmpq $0x4, %rdx
jb 0xc2c7
addq $-0x4, %rdx
movq %rsp, %r15
movl $0x4, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3320
leaq 0x3160(%rip), %rsi      # 0xf400
movq %r15, %rdi
callq 0x30f0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xc2bf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3300
testl %ebp, %ebp
jne 0xc2c7
movb $0x1, 0xa(%rbx)
cmpb $0x1, 0xa(%rbx)
jne 0xc2d3
cmpb $0x1, 0xe(%rbx)
je 0xc2e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3160
leaq 0x3155(%rip), %rcx      # 0xf446
movq %rcx, (%rax)
movq 0x8ca5(%rip), %rsi      # 0x14fa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x3510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r13
cmpq %rdi, %r13
je 0x6896
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rsp, %r15
leaq 0x10(%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x382a
movq %r12, %rdi
movq %r15, %rsi
callq 0x68c2
movl %eax, %r12d
movl $0x20, %eax
xorl %edx, %edx
idivl 0x30(%r14)
movzwl %bp, %ebp
movl %eax, %ecx
shll %cl, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6888
callq 0x2200
orl %r12d, %ebp
movq (%r13), %r13
cmpq %r14, %r13
jne 0x684b
jmp 0x6898
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x68ba
callq 0x2200
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x18(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movl $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x58(%rdi), %r15
movq %rdi, %rbx
movq %rax, 0x28(%rdi)
movq %rax, 0x30(%rdi)
vmovups %ymm0, 0x38(%rdi)
vmovups %ymm0, 0x50(%rdi)
movl %esi, (%rdi)
imull %esi, %esi
movl %esi, 0x4(%rdi)
movl %edx, 0x8(%rdi)
movq %r14, %rdi
vzeroupper
callq 0x3672
movslq 0x4(%rbx), %rsi
movq %r15, %rdi
callq 0x370c
movq %rbx, %rdi
callq 0x41a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rdi
movq %rax, %r12
testq %rdi, %rdi
je 0x331c
callq 0x2200
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3329
callq 0x2200
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x37f2
movq %r12, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/SneachChea[P]Wolf-Monte-Carlo-Cpp/model.cpp
// Function: model::init()
void model::init(){
    int row;
    int column;
    int up, right, left, dn;
    for(unsigned int i =0;i<N;i++){
        row = int(i/L);
        column = i-row*L;
        site_dic[std::make_tuple(row, column)]= i;
        x_y_dic[i] = std::make_tuple(row, column);
    }
    for(unsigned int i = 0; i<N;i++){
        row = std::get<0>(x_y_dic[i]);
        column = std::get<1>(x_y_dic[i]);
        up = site_dic[std::make_tuple((row-1+L)%L, column)];
        right = site_dic[std::make_tuple(row, (column+1)%L)];
        dn = site_dic[std::make_tuple((row+1)%L, column)];
        left = site_dic[std::make_tuple(row, (column-1+L)%L)];
        nbr[i] = std::make_tuple(right, up, left,dn);
    }
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0x42ed
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rdi), %r14
leaq 0x4(%rsp), %r12
movq %rdi, %rbx
xorl %r15d, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl %edx, 0x4(%rsp)
movl %edx, %r13d
movl %eax, %ebp
movl %eax, 0x8(%rsp)
callq 0x4332
movl %r15d, (%rax)
movq 0x40(%rbx), %rax
movl %ebp, 0x4(%rax,%r15,8)
movl %r13d, (%rax,%r15,8)
incq %r15
movl 0x4(%rbx), %eax
cmpq %rax, %r15
jb 0x41c7
testl %eax, %eax
je 0x42df
movl $0x4, %r12d
xorl %r13d, %r13d
movq 0x40(%rbx), %rax
movl (%rbx), %ecx
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl (%rax,%r12), %ebp
movl -0x4(%rax,%r12), %r15d
leal -0x1(%rbp,%rcx), %eax
cltd
idivl %ecx
movl %r15d, 0x4(%rsp)
movl %edx, 0x8(%rsp)
callq 0x4332
movl (%rax), %eax
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl %eax, 0x14(%rsp)
leal 0x1(%r15), %eax
cltd
idivl (%rbx)
movl %edx, 0x4(%rsp)
movl %ebp, 0x8(%rsp)
callq 0x4332
movl (%rax), %eax
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl %eax, 0x10(%rsp)
leal 0x1(%rbp), %eax
cltd
idivl (%rbx)
movl %r15d, 0x4(%rsp)
movl %edx, 0x8(%rsp)
callq 0x4332
movl (%rax), %eax
movl (%rbx), %ecx
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
movl %eax, 0xc(%rsp)
leal -0x1(%r15,%rcx), %eax
cltd
idivl %ecx
movl %edx, 0x4(%rsp)
movl %ebp, 0x8(%rsp)
callq 0x4332
movq 0x58(%rbx), %rcx
movl 0x10(%rsp), %edx
movl (%rax), %eax
incq %r13
movl %edx, 0x4(%rcx,%r12,2)
movl 0x14(%rsp), %edx
movl %edx, (%rcx,%r12,2)
movl 0xc(%rsp), %edx
movl %eax, -0x4(%rcx,%r12,2)
movl %edx, -0x8(%rcx,%r12,2)
addq $0x8, %r12
movl 0x4(%rbx), %eax
cmpq %rax, %r13
jb 0x4212
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
vxorps %xmm2, %xmm2, %xmm2
movq %rdi, %rbx
vmovsd %xmm0, 0x30(%rsp)
vmovsd %xmm1, 0x28(%rsp)
movq $0x0, 0x10(%rdi)
vmovups %xmm2, (%rdi)
cmpl $0x1, %esi
jne 0x4665
leaq 0x30(%rsp), %rdx
jmp 0x4672
vucomisd %xmm1, %xmm0
jne 0x468a
jp 0x468a
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4926
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r14d
movl %edx, %ebp
vmovsd %xmm0, 0x10(%rsp)
movslq %esi, %rsi
movq %rbx, %rdi
vmovsd %xmm1, 0x8(%rsp)
callq 0x4894
vmovsd 0x8(%rsp), %xmm0
testb %bpl, %bpl
je 0x4722
testl %r14d, %r14d
jle 0x467c
leal -0x1(%r14), %eax
leaq 0x20(%rsp), %r15
xorl %ebp, %ebp
vcvtsi2sd %eax, %xmm3, %xmm1
vsubsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm1, 0x18(%rsp)
vmovsd %xmm0, 0x8(%rsp)
vcvtsi2sd %ebp, %xmm3, %xmm0
vmulsd 0x8(%rsp), %xmm0, %xmm0
movq 0x8(%rbx), %rsi
vdivsd 0x18(%rsp), %xmm0, %xmm0
vaddsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x470b
vmovsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4716
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4a3a
incl %ebp
cmpl %ebp, %r14d
jne 0x46d7
jmp 0x467c
testl %r14d, %r14d
jle 0x467c
vcvtsi2sd %r14d, %xmm3, %xmm1
vsubsd 0x10(%rsp), %xmm0, %xmm0
leaq 0x20(%rsp), %r15
xorl %ebp, %ebp
vmovsd %xmm1, 0x18(%rsp)
vmovsd %xmm0, 0x8(%rsp)
vcvtsi2sd %ebp, %xmm3, %xmm0
vmulsd 0x8(%rsp), %xmm0, %xmm0
movq 0x8(%rbx), %rsi
vdivsd 0x18(%rsp), %xmm0, %xmm0
vaddsd 0x10(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x20(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x477d
vmovsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4788
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4a3a
incl %ebp
cmpl %ebp, %r14d
jne 0x4749
jmp 0x467c
jmp 0x4798
jmp 0x4798
movq (%rbx), %rdi
movq %rax, %r14
testq %rdi, %rdi
je 0x47a8
callq 0x2200
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
leaq 0x1390(%rsp), %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x333e
movq %r14, %rdi
callq 0x22a0
movl $0x1, %ecx
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x8(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x47e5
movabsq $0x100000000, %rax      # imm = 0x100000000
movq $0x270, 0x1388(%rsp) # imm = 0x270
movq %rax, (%rsp)
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x4853
leaq 0x8(%rsp), %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3976
leal -0x1(%rax,%rax), %eax
movl %eax, (%r15)
addq $0x4, %r15
cmpq %r12, %r15
jne 0x4835
leaq 0x1390(%rsp), %rdi
callq 0x21f0
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x488b
jmp 0x4873
movq %rax, %rbx
leaq 0x1390(%rsp), %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
callq 0x37ae
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x5b82(%rip), %rax      # 0x7114
testq %rax, %rax
jle 0x1600
movq 0x5c32(%rip), %rcx      # 0x71d0
movq 0x5c8b(%rip), %rdx      # 0x7230
movq 0x5bcc(%rip), %rsi      # 0x7178
xorl %edi, %edi
movq $0x0, (%rcx,%rdi,8)
movq (%rdx,%rdi,8), %r8
movq %r8, 0x5c67(%rip)       # 0x7228
movslq (%rsi,%rdi,4), %r9
testq %r9, %r9
jle 0x15f8
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
xorps %xmm1, %xmm1
cvtsi2sdl 0x4(%r8,%r10,8), %xmm1
mulsd 0x5bad(%rip), %xmm1     # 0x7190
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %r10
cmpq %r10, %r9
jne 0x15d1
incq %rdi
cmpq %rax, %rdi
jne 0x15ae
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x57c5(%rip), %eax      # 0x7114
testl %eax, %eax
jle 0x19c8
pushq %r15
pushq %r14
pushq %rbx
movq 0x58d1(%rip), %rcx      # 0x7230
movq 0x5812(%rip), %rdx      # 0x7178
xorl %r15d, %r15d
movq (%rcx,%r15,8), %rbx
movq %rbx, 0x58b4(%rip)      # 0x7228
movslq (%rdx,%r15,4), %rsi
testq %rsi, %rsi
je 0x19b8
leaq (%rbx,%rsi,8), %r14
bsrq %rsi, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39a4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3aa0
movq 0x5885(%rip), %rcx      # 0x7230
movq 0x57c6(%rip), %rdx      # 0x7178
movl 0x575c(%rip), %eax      # 0x7114
incq %r15
movslq %eax, %rsi
cmpq %rsi, %r15
jl 0x1969
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rsp)
cmpl $0x4, %edi
je 0x5877
cmpl $0x2, %edi
jne 0x5890
movq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5a1e
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x257c
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5868
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x8(%rsp), %rdi
callq 0x3e4a
jmp 0x5983
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x5890
cmpb $0x73, 0x1(%rax)
jne 0x5890
cmpb $0x0, 0x2(%rax)
je 0x598b
movq 0x3759(%rip), %rbx      # 0x8ff0
leaq 0x9cb(%rip), %rsi       # 0x6269
movl $0x14, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
leaq 0x9a5(%rip), %rsi       # 0x627e
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
leaq 0x989(%rip), %rsi       # 0x629d
movl $0x17, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
leaq 0x966(%rip), %rsi       # 0x62b5
movl $0x28, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2170
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
movq 0x18(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x5a1e
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x257c
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59c8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x45e0
jmp 0x5983
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a15
movq 0x20(%rsp), %rsi
jmp 0x5a08
jmp 0x5a12
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a15
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x5a15
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BBRL(int, int)
void BBRL(int sw,int RN)
{
	//unconditional register branch
	assert(RN>= 0 && RN <= 31);
	uint64_t target = R[RN].getData();
	NIO = R[RN].getData() - PC.getData();
	if(sw == 0)
	{
		printf(" [log]-unconditional branch(register)\n");

		PC.setData(target);
	}
	else
	{
 		printf("[log]-unconditional call(register)\n");
		//first save the address of next instruction
		R[30].setData(PC.getData());
		subroutine++;
		PC.setData(target);
	}

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x20, %esi
jae 0x13e2
movl %edi, %ebp
movl %esi, %eax
leaq 0x8d90(%rip), %rcx      # 0xa0f0
leaq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x5cae
movq %rax, %rbx
movq %r14, %rdi
callq 0x5cae
movq %rax, %r14
leaq 0x18e77(%rip), %rdi     # 0x1a1f8
callq 0x5cae
subl %eax, %r14d
movl %r14d, 0x18e78(%rip)    # 0x1a208
testl %ebp, %ebp
je 0x13c3
leaq 0x4f69(%rip), %rdi      # 0x6304
callq 0x1140
leaq 0x18e51(%rip), %rdi     # 0x1a1f8
callq 0x5cae
leaq 0x8e2d(%rip), %rdi      # 0xa1e0
movq %rax, %rsi
callq 0x5cb6
incl 0x1de4f(%rip)           # 0x1f210
jmp 0x13cf
leaq 0x4f5d(%rip), %rdi      # 0x6327
callq 0x1140
leaq 0x18e22(%rip), %rdi     # 0x1a1f8
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5cb6
leaq 0x4c93(%rip), %rdi      # 0x607c
leaq 0x4c9f(%rip), %rsi      # 0x608f
leaq 0x4cab(%rip), %rcx      # 0x60a2
movl $0x1a, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BBL(int, unsigned long)
void BBL(int sw,uint64_t offset)
{

	NIO = offset - PC.getData();		
	//unconditional immediate branch
	if(sw == 0)
	{
		printf(" [log]-unconditional branch(immediate)\n");
		PC.setData(offset);
	}
	else
	{
		printf("[log]-unconditional call(immediate)\n");
		subroutine++;
		R[30].setData(PC.getData());
		PC.setData(offset); 
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18de8(%rip), %rdi     # 0x1a1f8
callq 0x5cae
movl %ebx, %ecx
subl %eax, %ecx
movl %ecx, 0x18de9(%rip)     # 0x1a208
testl %ebp, %ebp
je 0x1452
leaq 0x4f23(%rip), %rdi      # 0x634d
callq 0x1140
incl 0x1dddb(%rip)           # 0x1f210
leaq 0x18dbc(%rip), %rdi     # 0x1a1f8
callq 0x5cae
leaq 0x8d98(%rip), %rdi      # 0xa1e0
movq %rax, %rsi
callq 0x5cb6
jmp 0x145e
leaq 0x4f18(%rip), %rdi      # 0x6371
callq 0x1140
leaq 0x18d93(%rip), %rdi     # 0x1a1f8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5cb6
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: BCOND(unsigned long, int)
void BCOND(uint64_t offset,int condition)
{

	int cond = (condition&0x0000000e)>>1;
	bool result;
	switch(cond)
	{
		case 0:
			result = ZFLAG;
			break;
		case 1:
			result = CFLAG;
			break;
		case 2:
			result = NFLAG;
			break;
		case 3:
			result = OFLAG;
			break;
		case 4:
			result = CFLAG && !ZFLAG;
			break;
		case 5:
			result = NFLAG == OFLAG;
			break;
		case 6:
			result = (NFLAG== OFLAG)&& !ZFLAG ;
			break;
		case 7:
			result = true;
			break;


	}

	if((condition &0x01) && condition != 15)
		result = !result;

	if(result)
		BBL(0,offset);

}

// Assembly:
movq %rdi, %rax
movl %esi, %ecx
shrl %ecx
andl $0x7, %ecx
leaq 0x4b80(%rip), %rdx      # 0x6004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb 0x8c4e(%rip), %cl       # 0xa0e1
jmp 0x14f9
movb 0x8c46(%rip), %cl       # 0xa0e1
xorb $0x1, %cl
movzbl %cl, %edx
xorl %ecx, %ecx
cmpb $0x0, 0x8c3a(%rip)      # 0xa0e4
cmovnel %edx, %ecx
jmp 0x14f9
movb 0x8c2e(%rip), %cl       # 0xa0e3
jmp 0x14f9
movb 0x8c25(%rip), %cl       # 0xa0e2
jmp 0x14f9
movb $0x1, %cl
jmp 0x14f9
movb 0x8c1b(%rip), %cl       # 0xa0e4
jmp 0x14f9
movb 0x8c12(%rip), %cl       # 0xa0e3
cmpb 0x8c0b(%rip), %cl       # 0xa0e2
sete %cl
jmp 0x14f9
movb 0x8c01(%rip), %cl       # 0xa0e3
movb 0x8bf9(%rip), %dl       # 0xa0e1
xorb $0x1, %dl
xorl %edi, %edi
cmpb 0x8bef(%rip), %cl       # 0xa0e2
movzbl %dl, %ecx
cmovnel %edi, %ecx
cmpl $0xf, %esi
setne %dl
andb %sil, %dl
cmpb %dl, %cl
jne 0x1507
retq
xorl %edi, %edi
movq %rax, %rsi
jmp 0x1401
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: CBZNZ(int, int, int, unsigned long)
void CBZNZ(int sf,int sw,int RT,uint64_t offset)
{
	uint64_t dat;
	if(sf==1)
		dat = R[RT].getData();
	else if (sf == 0)
		dat = R[RT].getLowerData();

	if(sw == 0)
	{
		printf("[log]- CBZ instruction ");
		if(dat == 0)
			BBL(0,offset);
	}
	else if(sw ==1)
	{
		printf("[log]- CBNZ instruction ");
		if(dat != 0)
			BBL(0,offset);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %esi, %ebp
testl %edi, %edi
je 0x153b
cmpl $0x1, %edi
jne 0x1551
movslq %edx, %rax
leaq 0x8bc3(%rip), %rcx      # 0xa0f0
leaq (%rcx,%rax,8), %rdi
callq 0x5cae
movq %rax, %r14
jmp 0x1551
movslq %edx, %rax
leaq 0x8bab(%rip), %rcx      # 0xa0f0
leaq (%rcx,%rax,8), %rdi
callq 0x5cb2
movl %eax, %r14d
cmpl $0x1, %ebp
je 0x1572
testl %ebp, %ebp
jne 0x156d
leaq 0x4b55(%rip), %rdi      # 0x60b6
xorl %eax, %eax
callq 0x1040
testq %r14, %r14
je 0x1585
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4b55(%rip), %rdi      # 0x60ce
xorl %eax, %eax
callq 0x1040
testq %r14, %r14
je 0x156d
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1401
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: RET(int)
void RET(int n = 30)
{
	if(skip )
	{
		skip = false;
		return;
	}
	printf("[log] - RET instruction\n");
	assert(n>= 0 && n <= 31);
	NIO = R[n].getData() - PC.getData();
	subroutine--;
	PC.setData(R[n].getData());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x18c6e(%rip)     # 0x1a20d
jne 0x15ae
movb $0x0, 0x18c65(%rip)     # 0x1a20d
popq %rbx
popq %r14
popq %r15
retq
movl %edi, %ebx
leaq 0x4de1(%rip), %rdi      # 0x6398
callq 0x1140
cmpl $0x20, %ebx
jae 0x1610
movl %ebx, %eax
leaq 0x8b26(%rip), %rcx      # 0xa0f0
leaq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x5cae
movq %rax, %r14
leaq 0x18c18(%rip), %r15     # 0x1a1f8
movq %r15, %rdi
callq 0x5cae
subl %eax, %r14d
movl %r14d, 0x18c16(%rip)    # 0x1a208
decl 0x1dc18(%rip)           # 0x1f210
movq %rbx, %rdi
callq 0x5cae
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5cb6
leaq 0x4ad0(%rip), %rdi      # 0x60e7
leaq 0x4a71(%rip), %rsi      # 0x608f
leaq 0x4ad3(%rip), %rcx      # 0x60f8
movl $0x8c, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: ASR(int, int, int, int, int)
void ASR(int sf, int sw, int op1, int op2, int  op3 )
{
    if(sf)
    {
        if(sw == 0) //immediate
        {
	   printf("[log] - ASR 64 bit immediate\n");
            uint64_t op2_data = R[op2].getData();
            uint64_t dat;
            dat = op2_data >> op3;
            R[op1].setData(dat);
            
        }
        
        else //register
        {
            uint64_t op2_data = R[op2].getData();
            uint64_t op3_data = R[op3].getData();
            uint64_t dat;
            dat = op2_data >> op3_data;
            R[op1].setData(dat);
            
        }
    }
    
    else    //32 bit registers
    {
        if(sw == 0) //immediate
        {
	    printf("[log] - ASR instruction - 32 bit \n");
            int op2_data = R[op2].getLowerData();
            int dat;
            dat = op2_data >> op3;
            R[op1].setLowerData(dat);
        }
        
        else    //register
        {
            int op2_data = R[op2].getLowerData();
            int op3_data = R[op3].getLowerData();
            int dat;
            dat = op2_data >> op3_data;
            R[op1].setLowerData(dat);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %ebx
testl %edi, %edi
je 0x1906
testl %esi, %esi
je 0x193d
movslq %r14d, %rax
leaq 0x8813(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cae
movq %rax, %r14
movslq %ebp, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cae
movl %eax, %ecx
shrq %cl, %r14
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movq %r14, %rsi
jmp 0x196b
testl %esi, %esi
je 0x197a
movslq %r14d, %rax
leaq 0x87dc(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
movl %eax, %r14d
movslq %ebp, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
movl %eax, %ecx
sarl %cl, %r14d
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movl %r14d, %esi
jmp 0x19a6
leaq 0x4b39(%rip), %rdi      # 0x647d
callq 0x1140
movslq %r14d, %rax
leaq 0x879d(%rip), %r14      # 0xa0f0
leaq (%r14,%rax,8), %rdi
callq 0x5cae
movl %ebp, %ecx
shrq %cl, %rax
movslq %ebx, %rcx
leaq (%r14,%rcx,8), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
leaq 0x4ada(%rip), %rdi      # 0x645b
callq 0x1140
movslq %r14d, %rax
leaq 0x8760(%rip), %r14      # 0xa0f0
leaq (%r14,%rax,8), %rdi
callq 0x5cb2
movl %ebp, %ecx
sarl %cl, %eax
movslq %ebx, %rcx
leaq (%r14,%rcx,8), %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: LSL(int, int, int, int, int)
void LSL(int sf, int sw,int op1, int op2, int  op3 )
{
	//op1 = RD
	//op2 = RN
	//op3 = immRM
    if(sf)  //64 bit registers
    {
        if(sw == 0) //immediate
        {
   	    printf("[log] - LSL 64 bit immediate\n");
            uint64_t op2_data = R[op2].getData();
            uint64_t dat;
            dat = op2_data << (op3 % 64);
            R[op1].setData(dat);
        }
        
        else    //register
        {
	    printf("[log] - LSL 64 bit register\n");
            uint64_t op2_data = R[op2].getData();
            uint64_t op3_data = R[op3].getData();
            uint64_t dat;
            dat = op2_data << (op3_data % 64);
            R[op1].setData(dat);
        }
    }
    
    else    //32 bit registers
    {
        if(sw == 0) //immediate
        {
	    printf("[log] - LSL 32 bit immediate\n");
            int op2_data = R[op2].getLowerData();
            int dat = op2_data << (op3 % 32);
            R[op1].setLowerData(dat);
        }
        
        else    //register
        {
        	printf("[log] - LSL 32 bit register\n");
            int op2_data = R[op2].getLowerData();
            int op3_data = R[op3].getLowerData();
            int dat = op2_data << (op3_data % 32);
            R[op1].setLowerData(dat);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movl %edx, %ebx
movslq %ecx, %rax
leaq 0x8724(%rip), %r12      # 0xa0f0
leaq (%r12,%rax,8), %r15
testl %edi, %edi
je 0x1a0c
testl %esi, %esi
je 0x1a41
leaq 0x4af4(%rip), %rdi      # 0x64d3
callq 0x1140
movq %r15, %rdi
callq 0x5cae
movq %rax, %r15
movslq %r14d, %rax
leaq (%r12,%rax,8), %rdi
callq 0x5cae
movl %eax, %ecx
shlq %cl, %r15
movslq %ebx, %rax
leaq (%r12,%rax,8), %rdi
movq %r15, %rsi
jmp 0x1a79
testl %esi, %esi
je 0x1a86
leaq 0x4a83(%rip), %rdi      # 0x649a
callq 0x1140
movq %r15, %rdi
callq 0x5cb2
movl %eax, %ebp
movslq %r14d, %rax
leaq (%r12,%rax,8), %rdi
callq 0x5cb2
movl %eax, %ecx
shll %cl, %ebp
movslq %ebx, %rax
leaq (%r12,%rax,8), %rdi
movl %ebp, %esi
jmp 0x1aa8
leaq 0x4aa7(%rip), %rdi      # 0x64ef
callq 0x1140
movq %r15, %rdi
callq 0x5cae
leal 0x3f(%r14), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
andl $0xc0, %ecx
subl %ecx, %r14d
movl %r14d, %ecx
shlq %cl, %rax
movslq %ebx, %rcx
leaq (%r12,%rcx,8), %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
leaq 0x4a29(%rip), %rdi      # 0x64b6
callq 0x1140
movq %r15, %rdi
callq 0x5cb2
movl %r14d, %ecx
shll %cl, %eax
movslq %ebx, %rcx
leaq (%r12,%rcx,8), %rdi
movl %eax, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: LSR(int, int, int, int, int)
void LSR(int sf, int sw,int op1, int op2, int  op3 )
{
	//op1 - RD , op2 - RN, op3 - immr
    if(sf)  //64 bit registers
    {
        if(sw == 0) //immediate
        {
            uint64_t op2_data = R[op2].getData();
            uint64_t dat;
            dat = op2_data >> (op3 % 64);
            R[op1].setData(dat);
        }
        
        else    //register
        {
            uint64_t op2_data = R[op2].getData();
            uint64_t op3_data = R[op3].getData();
            uint64_t dat;
            dat = op2_data >> (op3_data % 64);
            R[op1].setData(dat);
        }
    }
    
    else    //32 bit registers
    {
        if(sw == 0) //immediate
        {
            int op2_data = R[op2].getLowerData();
            int dat = op2_data >> (op3 % 32);
            R[op1].setLowerData(dat);
        }
        
        else    //register
        {
            int op2_data = R[op2].getLowerData();
            int op3_data = R[op3].getLowerData();
            int dat = op2_data >> (op3_data % 32);
            R[op1].setLowerData(dat);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %edx, %ebx
movl %esi, %r12d
movl %edi, %eax
movslq %ecx, %rcx
leaq 0x861c(%rip), %r13      # 0xa0f0
leaq (,%rcx,8), %rdi
addq %r13, %rdi
testl %eax, %eax
je 0x1b07
callq 0x5cae
movq %rax, %r15
testl %r12d, %r12d
je 0x1b2a
movslq %r14d, %rax
leaq (,%rax,8), %rdi
addq %r13, %rdi
callq 0x5cae
movl %eax, %ecx
jmp 0x1b40
callq 0x5cb2
movl %eax, %ebp
testl %r12d, %r12d
je 0x1b67
movslq %r14d, %rax
leaq (,%rax,8), %rdi
addq %r13, %rdi
callq 0x5cb2
movl %eax, %ecx
jmp 0x1b6a
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
andl $0xc0, %eax
subl %eax, %r14d
movl %r14d, %ecx
shrq %cl, %r15
movslq %ebx, %rax
leaq (,%rax,8), %rdi
addq %r13, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
movl %r14d, %ecx
sarl %cl, %ebp
movslq %ebx, %rax
leaq (,%rax,8), %rdi
addq %r13, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: SUB(int, int, int, int, int)
void SUB(int sf, int sw,int op1, int op2, int op3 )
{
	//op1 - RD , op2 - RN , op3 - immRM
    if(sf) //use 64 bit register
    {
        if(sw == 0) //immediate
        {
            printf("[log] - subracting immediate 64 bit\n");
            uint64_t dat;
            dat = R[op2].getData() - op3; 
            R[op1].setData(dat);
        }
        
        if (sw == 1)    //register
        {
            printf("[log] - subracting register 64 bit\n");
            uint64_t dat;
            dat = R[op2].getData() - R[op3].getData();
            R[op1].setData(dat);
        }
    }
    
    else    //use 32 bit register
    {
         if(sw == 0) //immediate
        {
            printf("[log] - subracting immediate 32 bit\n");
            uint64_t dat;
            dat = R[op2].getLowerData() - op3; 
            R[op1].setLowerData(dat);
        }
        
        if (sw == 1)    //register
        {
            printf("[log] - subracting register 32 bit\n");
            int dat;
            dat = R[op2].getLowerData() - R[op3].getLowerData();
            R[op1].setLowerData(dat);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %ebx
testl %edi, %edi
je 0x1bdf
cmpl $0x1, %esi
je 0x1c26
testl %esi, %esi
jne 0x1c1b
leaq 0x49a1(%rip), %rdi      # 0x6553
callq 0x1140
movslq %r14d, %rax
leaq 0x852f(%rip), %r14      # 0xa0f0
leaq (%r14,%rax,8), %rdi
callq 0x5cae
movslq %ebp, %rcx
subq %rcx, %rax
movslq %ebx, %rcx
leaq (%r14,%rcx,8), %rdi
movq %rax, %rsi
jmp 0x1c61
cmpl $0x1, %esi
je 0x1c70
testl %esi, %esi
jne 0x1c1b
leaq 0x4919(%rip), %rdi      # 0x650c
callq 0x1140
movslq %r14d, %rax
leaq 0x84ee(%rip), %r14      # 0xa0f0
leaq (%r14,%rax,8), %rdi
callq 0x5cb2
subl %ebp, %eax
movslq %ebx, %rcx
leaq (%r14,%rcx,8), %rdi
movl %eax, %esi
jmp 0x1cab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x494a(%rip), %rdi      # 0x6577
callq 0x1140
movslq %r14d, %rax
leaq 0x84b4(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cae
movq %rax, %r14
movslq %ebp, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cae
subq %rax, %r14
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
leaq 0x48b9(%rip), %rdi      # 0x6530
callq 0x1140
movslq %r14d, %rax
leaq 0x846a(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
movl %eax, %r14d
movslq %ebp, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
subl %eax, %r14d
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: MOV(int, int, int, int)
void MOV(int sf, int _switch,int op1, int op2 )
{
    if(sf)  //64 bit registers
    {
	
        if(_switch == 0) //immediate
        {
            printf("[log] - mov immediate 64 bit\n");
            R[op1].setData(op2);
        }
        
        else    //register
        {
            printf("[log] - mov register 64 bit\n");
            R[op1].setData(R[op2].getData());
        }
    }
    
    else
    {
        if(_switch == 0) //immediate
        {
			printf("[log] - mov immediate 32 bit\n");
            R[op1].setLowerData(op2);
        }
        
        else    //register
        {
			printf("[log] - mov immediate 32 bit\n");
            R[op1].setLowerData(R[op2].getLowerData());
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movslq %edx, %rax
leaq 0x8423(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rbx
testl %edi, %edi
je 0x1cf9
movslq %ebp, %r14
testl %esi, %esi
je 0x1d1c
leaq 0x48d4(%rip), %rdi      # 0x65b7
callq 0x1140
leaq (%r15,%r14,8), %rdi
callq 0x5cae
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x1d2e
leaq 0x489a(%rip), %rdi      # 0x659a
testl %esi, %esi
je 0x1d3d
callq 0x1140
movslq %ebp, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
movq %rbx, %rdi
movl %eax, %esi
jmp 0x1d47
leaq 0x48b0(%rip), %rdi      # 0x65d3
callq 0x1140
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
callq 0x1140
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc
// File: /workspace/github_cpp_makefile_star2_O3/akshayrajput[P]ARMV8_Simulator/./instructions.cpp
// Function: AND(int, int, int, int, int, int, int, int)
void AND(int sf, int sw, int op1, int op2, int op3, int N, int imms, int immr)
{
	//op1 - RD,op2 - RN, op3 - RM
    if(sf)
    {
		if(sw == 0)
		{
		    uint64_t imm = DecodeBitMask( N,  imms, immr, 64);
		    uint64_t dat = R[op2].getData() & imm;
		    R[op1].setData(dat);
		}
		
		else
		{
			uint64_t dat = R[op2].getData() & R[op3].getData();
			R[op1].setData(dat);
		}
    }
    else
    {
        if(sw == 0)
        {
      		uint32_t imm = DecodeBitMask(N, imms, immr, 32);
       	 	uint32_t dat = R[op2].getLowerData() & imm;
       	 	R[op1].setLowerData(dat);
       	 }
       	 else
       	 {
       	 	uint32_t dat = R[op2].getLowerData() & R[op3].getLowerData();
       	 	R[op1].setLowerData(dat);
       	 }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %eax
movl 0x38(%rsp), %edx
movl 0x30(%rsp), %esi
testl %edi, %edi
je 0x1da8
testl %eax, %eax
je 0x1dda
movslq %ebp, %rax
leaq 0x836f(%rip), %r12      # 0xa0f0
leaq (%r12,%rax,8), %rdi
callq 0x5cae
movq %rax, %r15
movslq %r14d, %rax
leaq (%r12,%rax,8), %rdi
callq 0x5cae
andq %rax, %r15
movslq %ebx, %rax
leaq (%r12,%rax,8), %rdi
movq %r15, %rsi
jmp 0x1e0a
testl %eax, %eax
je 0x1e17
movslq %ebp, %rax
leaq 0x833a(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
movl %eax, %ebp
movslq %r14d, %rax
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
andl %eax, %ebp
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movl %ebp, %esi
jmp 0x1e47
movl %r9d, %edi
movl $0x40, %ecx
callq 0x1e54
movq %rax, %r14
movslq %ebp, %rax
leaq 0x82fc(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cae
andq %rax, %r14
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5cb6
movl %r9d, %edi
movl $0x20, %ecx
callq 0x1e54
movq %rax, %r14
movslq %ebp, %rax
leaq 0x82bf(%rip), %r15      # 0xa0f0
leaq (%r15,%rax,8), %rdi
callq 0x5cb2
andl %eax, %r14d
movslq %ebx, %rax
leaq (%r15,%rax,8), %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5cbc