LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_positional_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Options::get_positional_option(string optionflag){
	string positional = "";
	for (auto iter = optionvec.begin(); iter < optionvec.end(); ++iter){
		if (*iter == optionflag){
			try{
				positional = *(iter + 1);
				return positional;
			}
			catch (...){
				print_error("Unable to read the positional argument for the " + optionflag + " option.  Did you include one?");
				return "";
			}
		}
	}
	return positional;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x295c(%rip), %rdx      # 0xfe77
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xd2b2
movq 0x8(%r15), %rax
movq (%rax), %r15
movq 0x8(%rax), %rbp
cmpq %rbp, %r15
jae 0xd575
movq 0x8(%r14), %r12
cmpq %r12, 0x8(%r15)
jne 0xd559
testq %r12, %r12
je 0xd564
movq (%r14), %rsi
movq (%r15), %rdi
movq %r12, %rdx
callq 0x3280
testl %eax, %eax
je 0xd564
addq $0x20, %r15
cmpq %rbp, %r15
jb 0xd53c
jmp 0xd575
addq $0x20, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3160
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r13, %rcx
je 0xd594
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0xd59c
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x30f0
leaq 0x30f3(%rip), %rsi      # 0x106b9
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0xbab1
leaq 0x310f(%rip), %rsi      # 0x106e9
leaq 0x48(%rsp), %rdi
callq 0x3420
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xd60b
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0xd612
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0xba72
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xd64a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd665
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3270
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2804(%rip), %rdx      # 0xfe77
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xd2b2
callq 0x33c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xd5a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xd5a5
movq %rax, %rbx
jmp 0xd6ee
jmp 0xd6e6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xd6c9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xd6c9
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd6e9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xd6e9
movq %rax, %rbx
callq 0x33c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xd705
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0xdab7
nop
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_input[abi:cxx11]()
string Options::get_input(){
	string inputflag = "-i";
	string inputfile = "";
	for (auto iter = optionvec.begin(); iter < optionvec.end(); ++iter){
		if (*iter == inputflag){
			inputfile = *(iter + 1);
			return inputfile;
		}
	}
	return inputfile;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2216(%rip), %rsi      # 0xf951
leaq 0x2211(%rip), %rdx      # 0xf953
leaq 0x8(%rsp), %rdi
callq 0xd2b2
leaq 0x10(%rbx), %rbp
movq %rbp, (%rbx)
leaq 0x271d(%rip), %rdx      # 0xfe77
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xd2b2
movq 0x8(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq 0x8(%rsp), %r14
cmpq %r13, %r15
jae 0xd7c5
movq 0x10(%rsp), %r12
cmpq %r12, 0x8(%r15)
jne 0xd79c
testq %r12, %r12
je 0xd7ac
movq (%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3280
testl %eax, %eax
je 0xd7ac
addq $0x20, %r15
cmpq %r13, %r15
jb 0xd77f
leaq 0x18(%rsp), %r12
jmp 0xd7c5
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %r12
callq 0x3160
movq 0x8(%rsp), %r14
cmpq %r12, %r14
je 0xd7da
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x3270
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0xd808
movq (%rbp), %rsi
incq %rsi
callq 0x3270
jmp 0xd808
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd824
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_output[abi:cxx11]()
string Options::get_output(){
	string outputflag = "-o";
	string outputfile = "";
	for (auto iter = optionvec.begin(); iter < optionvec.end(); ++iter){
		if (*iter == outputflag){
			outputfile = *(iter + 1);
			return outputfile;
		}
	}
	return outputfile;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2eb7(%rip), %rsi      # 0x10708
leaq 0x2eb2(%rip), %rdx      # 0x1070a
leaq 0x8(%rsp), %rdi
callq 0xd2b2
leaq 0x10(%rbx), %rbp
movq %rbp, (%rbx)
leaq 0x2607(%rip), %rdx      # 0xfe77
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xd2b2
movq 0x8(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
movq 0x8(%rsp), %r14
cmpq %r13, %r15
jae 0xd8db
movq 0x10(%rsp), %r12
cmpq %r12, 0x8(%r15)
jne 0xd8b2
testq %r12, %r12
je 0xd8c2
movq (%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3280
testl %eax, %eax
je 0xd8c2
addq $0x20, %r15
cmpq %r13, %r15
jb 0xd895
leaq 0x18(%rsp), %r12
jmp 0xd8db
addq $0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %r12
callq 0x3160
movq 0x8(%rsp), %r14
cmpq %r12, %r14
je 0xd8f0
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x3270
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0xd91e
movq (%rbp), %rsi
incq %rsi
callq 0x3270
jmp 0xd91e
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd93a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::get_last_positional[abi:cxx11]()
string Options::get_last_positional(){
	auto iter_end = optionvec.end();
	//return the last argument on the command line
	string laststring = *(iter_end - 1);
	return laststring;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
callq 0xd21c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::fill_arg_vector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int Options::fill_arg_vector(vector<string>& fill_vector){
	for (auto iter = optionvec.begin() + 2; iter < optionvec.end(); ++iter){
		char c = (*iter)[0];
		switch(c) {
			// if it is a short option (starts with '-') or long option (starts with '-')
			case '-':
				return 1;  //then break out of the vector fill loop and return because done filling the vector
			default:
				fill_vector.push_back(*iter);  //fill the vector with the string arguments up until the first option
				break;
		}
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movq (%rax), %r15
addq $0x40, %r15
cmpq 0x8(%rax), %r15
jae 0xd9a7
movq %rsi, %rbx
movq %rdi, %r14
movq (%r15), %rax
cmpb $0x2d, (%rax)
je 0xd9a7
movq %rbx, %rdi
movq %r15, %rsi
callq 0xda7a
addq $0x20, %r15
movq 0x8(%r14), %rax
cmpq 0x8(%rax), %r15
jb 0xd986
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/opts.cpp
// Function: Options::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Options::contains(string optionflag){
	vector<string> optv = get_options();
	int i = 0;
	//check the options vector and determine whether it contains the requested optionflag
	for (auto s : optv){
		if (s == optionflag){
			i = 1;
		}
	}
	if (i){
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xd348
movq (%rbx), %r12
movq 0x8(%rbx), %r13
xorl %ebx, %ebx
cmpq %r13, %r12
je 0xda4a
leaq 0x10(%rsp), %rbp
movq %rsp, %r15
movq %rbp, (%rsp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xd21c
movq 0x8(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0xda26
testq %rdx, %rdx
je 0xda21
movq (%r14), %rsi
movq (%rsp), %rdi
callq 0x3280
testl %eax, %eax
jne 0xda26
movl $0x1, %ebx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0xda3c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x20, %r12
cmpq %r13, %r12
jne 0xd9e9
testl %ebx, %ebx
setne %bl
leaq 0x20(%rsp), %rdi
callq 0xcf4e
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xcf4e
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_string(std::basic_ifstream<char, std::char_traits<char>>&)
void IO::get_string(ifstream& inputstream){
	while (inputstream.good()) {
		//load the input stream from the file into a string stream
		int next = inputstream.get();
		if (next == EOF){
			break;
		}
		//implicit conversion of the int char to a string
		inputstring += next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsi,%rax)
jne 0xe352
movq %rsi, %rbx
movq %rdi, %r14
addq $0x60, %r14
movq %rbx, %rdi
callq 0x32d0
cmpl $-0x1, %eax
je 0xe352
movsbl %al, %esi
movq %r14, %rdi
callq 0x3200
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0xe32c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_first_line[abi:cxx11]()
string& IO::get_first_line(){
	ifstream in;
	ifstream& inr = in;
	ifstream& rinr = (get_input_stream(inr));
	get_lines(THE_BEGINNING , 1 , rinr);
	string& isr = inputstring;
	return isr;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x32b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe3bc
movq %rsp, %rcx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xe56a
addq $0x60, %rbx
movq %rsp, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_input_stream(std::basic_ifstream<char, std::char_traits<char>>&)
ifstream& IO::get_input_stream(ifstream& infilestream){
	if (!path.empty()){
		try{
			infilestream.open(path);
			if (infilestream.good()) {
				ifstream& inr = infilestream;
				return inr;
			}
			else{
				throw runtime_error("Input File Error");
			}
		}
		catch (...) {
			print("Unable to open the input file " + path);
			exit(EXIT_FAILURE);
		}
	}
	else if (!ipath.empty()){
		try{
			infilestream.open(ipath);
			if (infilestream.good()){
				ifstream& inr = infilestream;
				return inr;
			}
			else{
				throw runtime_error("Input File Error");
			}
		}
		catch (...){
			print("Unable to open the input file " + ipath);
			exit(EXIT_FAILURE);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xe425
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0xe448
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x243e(%rip), %rsi      # 0x10843
movq %rax, %rdi
callq 0x30e0
movq 0x5bdc(%rip), %rsi      # 0x13ff0
movq 0x5ba5(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
jmp 0xe487
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x3210
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0xe455
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x23da(%rip), %rsi      # 0x10843
movq %rax, %rdi
callq 0x30e0
movq 0x5b78(%rip), %rsi      # 0x13ff0
movq 0x5b41(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
movq %rax, %r15
movq %r14, %rdi
callq 0x3190
jmp 0xe4a4
movq %rax, %r15
movq %r14, %rdi
callq 0x3190
jmp 0xe4f8
movq %rax, %r15
movq %r15, %rdi
callq 0x30f0
leaq 0x22cf(%rip), %rsi      # 0x10782
movq %rsp, %rdi
movq %rbx, %rdx
callq 0xbab1
movq %rsp, %rdi
callq 0xa49f
movq %rsp, %rdi
jmp 0xe523
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe4ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xe4ee
movq %rax, %rbx
callq 0x33c0
jmp 0xe55a
movq %rax, %r15
movq %r15, %rdi
callq 0x30f0
leaq 0x227b(%rip), %rsi      # 0x10782
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0xbab1
leaq 0x20(%rsp), %rdi
callq 0xa49f
leaq 0x20(%rsp), %rdi
callq 0x3110
movl $0x1, %edi
callq 0x32e0
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe555
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xe555
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0xdab7
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_lines[abi:cxx11](int, int, std::basic_ifstream<char, std::char_traits<char>>&)
string& IO::get_lines(int startposition, int number_of_lines, ifstream& infile){
	if (startposition == THE_BEGINNING) {
		if (number_of_lines == 1){
			//return a single line from the file
			try{
				// if first line requested, get it and define inputstring class string with the line of text
				std::getline(infile, inputstring);
			}
			catch (...){
				print("Unable to read the first line from the input file");
				exit(EXIT_FAILURE);
			}
		}
		else {
			// return n requested lines from the file
			int linenumber = 0;
			//confirm that there are at least as many lines as the user requested
			while(! infile.eof()) {
				std::getline(infile, tempstring);
				++linenumber;
				inputstring += tempstring + "\n";
				if (linenumber == number_of_lines){
					string& isr = inputstring;
					return isr;
				}
			}
			//if did not return with above code, there were not as many lines in the file as the user requested
			//so return the entire file string
			inputstring = tempstring;
			string& isr = inputstring;
			return isr;
		}
	}
	else if (startposition == THE_END) {

	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
je 0xe64d
movl %edx, %ebp
leaq 0x80(%r14), %r12
leaq 0x60(%r14), %r15
leaq 0x8(%rsp), %r13
movq (%rbx), %rax
movq -0x18(%rax), %rdi
testb $0x2, 0x20(%rbx,%rdi)
jne 0xe630
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3400
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xd21c
movq %r13, %rdi
leaq 0x1883(%rip), %rsi      # 0xfe76
callq 0x3420
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x30b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe626
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
decl %ebp
jne 0xe599
jmp 0xe63b
movq %r15, %rdi
movq %r12, %rsi
callq 0x3160
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3050
movq %rax, %rdi
callq 0x30f0
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2155(%rip), %rsi      # 0x107c9
leaq 0x217f(%rip), %rdx      # 0x107fa
leaq 0x28(%rsp), %rdi
callq 0xd2b2
leaq 0x28(%rsp), %rdi
callq 0xa49f
leaq 0x28(%rsp), %rdi
callq 0x3110
movl $0x1, %edi
callq 0x32e0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xe6c2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xe6c2
movq %rax, %rbx
callq 0x33c0
jmp 0xe6f2
movq %rax, %rdi
callq 0xdab7
jmp 0xe6d3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe6f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::write_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void IO::write_file(string& outstring) {
	if (!path.empty()) {
		ofstream outfile(path);
		if (outfile.good()) {
			ofstream& outr = outfile;
			write_filestring(outr, outstring);
			outfile.close();
		}
		else{
			throw runtime_error("Unable to open the output file " + path);
		}
	}
	else if (!opath.empty()) {
		ofstream outfile(opath);
		if (outfile.good()) {
			ofstream& outr = outfile;
			write_filestring(outr, outstring);
			outfile.close();
		}
		else{
			throw runtime_error("Unable to open the output file " + opath);
		}
	}
	else{
		throw runtime_error("Missing a filepath for the output file.");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xe7c4
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x3430
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0xe851
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0xe972
leaq 0x28(%rsp), %rdi
callq 0x3320
jmp 0xe811
cmpq $0x0, 0x48(%rbx)
je 0xe89c
addq $0x40, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x3430
movq (%r15), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0xe8ce
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0xe972
leaq 0x28(%rsp), %rdi
callq 0x3320
movq 0x57a0(%rip), %rax      # 0x13fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x31e0
leaq 0x120(%rsp), %rdi
callq 0x30c0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x1f96(%rip), %rsi      # 0x107fb
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xbab1
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x33b0
xorl %ebp, %ebp
movq 0x5765(%rip), %rsi      # 0x13ff0
movq 0x572e(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
jmp 0xe917
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x1f6b(%rip), %rsi      # 0x1081b
movq %rax, %rdi
callq 0x30e0
movq 0x5731(%rip), %rsi      # 0x13ff0
movq 0x56fa(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x1f19(%rip), %rsi      # 0x107fb
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xbab1
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x33b0
xorl %ebp, %ebp
movq 0x56e8(%rip), %rsi      # 0x13ff0
movq 0x56b1(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
jmp 0xe928
jmp 0xe94d
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
jmp 0xe969
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe946
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
testb %bpl, %bpl
jne 0xe950
jmp 0xe95f
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
jmp 0xe95f
jmp 0xe95c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/chrissimpkins[P]octopus/src/io.cpp
// Function: IO::get_output_stream(std::basic_ofstream<char, std::char_traits<char>>&)
ofstream& IO::get_output_stream(ofstream& outfilestream){
	if (!path.empty()){
		try{
			outfilestream.open(path);
			if (outfilestream.good()) {
				ofstream& outr = outfilestream;
				return outr;
			}
			else{
				throw runtime_error("File Write Error");
			}
		}
		catch (...) {
			print("Unable to write to the output file " + path);
			exit(EXIT_FAILURE);
		}
	}
	else if (!opath.empty()){
		try{
			outfilestream.open(opath);
			if (outfilestream.good()) {
				ofstream& outr = outfilestream;
				return outr;
			}
			else{
				throw runtime_error("File Write Error");
			}
		}
		catch (...) {
			print("Unable to write to the output file " + opath);
			exit(EXIT_FAILURE);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xea29
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x3120
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0xea4c
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x1e4b(%rip), %rsi      # 0x10854
movq %rax, %rdi
callq 0x30e0
movq 0x55d8(%rip), %rsi      # 0x13ff0
movq 0x55a1(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
jmp 0xea8b
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x3120
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0xea59
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3140
movq %rax, %r14
leaq 0x1de7(%rip), %rsi      # 0x10854
movq %rax, %rdi
callq 0x30e0
movq 0x5574(%rip), %rsi      # 0x13ff0
movq 0x553d(%rip), %rdx      # 0x13fc0
movq %r14, %rdi
callq 0x33d0
movq %rax, %r15
movq %r14, %rdi
callq 0x3190
jmp 0xeaa8
movq %rax, %r15
movq %r14, %rdi
callq 0x3190
jmp 0xeafc
movq %rax, %r15
movq %r15, %rdi
callq 0x30f0
leaq 0x1dae(%rip), %rsi      # 0x10865
movq %rsp, %rdi
movq %rbx, %rdx
callq 0xbab1
movq %rsp, %rdi
callq 0xa49f
movq %rsp, %rdi
jmp 0xeb27
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeaf2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xeaf2
movq %rax, %rbx
callq 0x33c0
jmp 0xeb5e
movq %rax, %r15
movq %r15, %rdi
callq 0x30f0
leaq 0x1d5a(%rip), %rsi      # 0x10865
leaq 0x20(%rsp), %rdi
movq %rbx, %rdx
callq 0xbab1
leaq 0x20(%rsp), %rdi
callq 0xa49f
leaq 0x20(%rsp), %rdi
callq 0x3110
movl $0x1, %edi
callq 0x32e0
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xeb59
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3270
jmp 0xeb59
movq %rax, %rbx
callq 0x33c0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0xdab7
// File: /workspace/github_cpp_makefile_star2_O3/vygr[P]C-Chess/chess.cpp
// Function: display_board(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto display_board(const board &brd)
{
	cls();
	std::cout << "\n  a   b   c   d   e   f   g   h\n";
	std::cout << "┏━━━┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━┳━━━┓\n";
	for (auto row = 0; row < 8; ++row)
 	{
		for (auto col = 0; col < 8; ++col)
		{
			std::cout << "┃" << " " << unicode_pieces[brd[row*8+col]] << " ";
		}
		std::cout << "┃" << 8-row << "\n";
		if (row != 7)
		{
			std::cout << "┣━━━╋━━━╋━━━╋━━━╋━━━╋━━━╋━━━╋━━━┫\n";
		}
	}
	std::cout << "┗━━━┻━━━┻━━━┻━━━┻━━━┻━━━┻━━━┻━━━┛\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0xaf5a(%rip), %r14      # 0xdfd8
leaq 0x6a3c(%rip), %rsi      # 0x9ac1
movl $0x7, %edx
movq %r14, %rdi
callq 0x21d0
leaq 0x6a30(%rip), %rsi      # 0x9ac9
movl $0x21, %edx
movq %r14, %rdi
callq 0x21d0
leaq 0x6a3e(%rip), %rsi      # 0x9aeb
movl $0x64, %edx
movq %r14, %rdi
callq 0x21d0
xorl %ebp, %ebp
leaq 0x6a8d(%rip), %rsi      # 0x9b50
leaq 0x6bbb(%rip), %r12      # 0x9c85
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
movq 0x10(%rsp), %r15
movl $0x3, %edx
movq %r14, %rdi
movq %rsi, %rbx
callq 0x21d0
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq (%r15), %rsi
addq %rbp, %rsi
addq %r13, %rsi
leaq 0xb0cd(%rip), %rdi      # 0xe1d8
callq 0x5f02
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x21d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rbx, %rsi
incq %r13
cmpq $0x8, %r13
jne 0x30db
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movl $0x8, %esi
movq 0x8(%rsp), %r15
subl %r15d, %esi
movq %r14, %rdi
callq 0x22b0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x6b5d(%rip), %rsi      # 0x9cc9
callq 0x21d0
cmpq $0x7, %r15
je 0x319f
movl $0x64, %edx
movq %r14, %rdi
leaq 0x69ce(%rip), %rsi      # 0x9b54
callq 0x21d0
incq %r15
movq %r15, 0x8(%rsp)
addq $0x8, %rbp
movq %rbx, %rsi
jmp 0x30d3
movq 0xae32(%rip), %rdi      # 0xdfd8
leaq 0x6a0c(%rip), %rsi      # 0x9bb9
movl $0x64, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/vygr[P]C-Chess/chess.cpp
// Function: piece_scans(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, std::vector<vector, std::allocator<vector>> const&)
auto piece_scans(const board &brd, unsigned int index, const vectors &vectors)
{
	auto yield = std::string{}; yield.reserve(8);
	auto cx = int(index % 8);
	auto cy = int(index / 8);
	for (auto &vector : vectors)
 	{
		auto dx = vector.dx;
		auto dy = vector.dy;
		auto length = vector.length;
		auto x = cx;
		auto y = cy;
		for (;length > 0; --length)
		{
			x += dx;
			y += dy;
			if ((0 <= x) && (x < 8) && (0 <= y) && (y < 8))
			{
				//still on the board
				auto piece = brd[y*8+x];
				if (piece != ' ')
				{
					//not empty square so yield piece
					yield.push_back(piece);
					break;
				}
			}
		}
	}
	return yield;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movl %edx, %r13d
movq %rsi, %r15
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x8, %esi
movq %rdi, 0x8(%rsp)
callq 0x2260
movq (%r12), %rbp
movq 0x8(%r12), %r12
cmpq %r12, %rbp
je 0x3289
movl %r13d, %r14d
andl $0x7, %r14d
shrl $0x3, %r13d
movl 0x8(%rbp), %eax
testl %eax, %eax
jle 0x3280
movl (%rbp), %ecx
movl 0x4(%rbp), %edx
movq (%r15), %rsi
leal (%r14,%rcx), %edi
leal (%rdx,%r13), %r8d
leal (%rdi,%r8,8), %r9d
leal (%rcx,%rdx,8), %r10d
incl %eax
cmpl $0x8, %edi
setb %r11b
cmpl $0x8, %r8d
setb %bl
andb %r11b, %bl
cmpb $0x1, %bl
jne 0x3261
movl %r9d, %r11d
movb (%rsi,%r11), %r11b
cmpb $0x20, %r11b
jne 0x3272
addl %r10d, %r9d
addl %edx, %r8d
addl %ecx, %edi
decl %eax
cmpl $0x1, %eax
jg 0x323e
jmp 0x3280
movsbl %r11b, %esi
movq 0x8(%rsp), %rdi
callq 0x2170
addq $0xc, %rbp
cmpq %r12, %rbp
jne 0x321c
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x329f
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x32c1
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/vygr[P]C-Chess/chess.cpp
// Function: in_check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, unsigned long&)
auto in_check(const board &brd, int colour, std::size_t &king_index)
{
	auto king_piece = 'K';
	auto tests = white_tests;
	if (colour == black)
 	{
		//testing black king in check rather than white
		king_piece = 'k';
		tests = black_tests;
	}
	//find king index on board
	if (brd[king_index] != king_piece)
 	{
		king_index = brd.find(king_piece);
	}
	for (auto &test : tests)
 	{
		if (test.pieces.find_first_of(piece_scans(brd, static_cast<unsigned int>(king_index), *test.vectors))
			!= std::string::npos) return true;
	}
	//not in check
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0xb0a2(%rip), %rsi      # 0xe388
movq %rsp, %rdi
callq 0x5f68
movb $0x4b, %r15b
cmpl $-0x1, %ebp
jne 0x3308
movb $0x6b, %r15b
leaq 0xb0a0(%rip), %rsi      # 0xe3a0
movq %rsp, %rdi
callq 0x6002
movq (%rbx), %rax
movq (%r14), %rcx
cmpb %r15b, (%rcx,%rax)
je 0x3325
movzbl %r15b, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2200
movq %rax, (%rbx)
movq (%rsp), %r15
movq 0x8(%rsp), %r13
cmpq %r13, %r15
je 0x339a
addq $0x28, %r15
movl (%rbx), %edx
movq -0x8(%r15), %rcx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x31c5
leaq -0x28(%r15), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
xorl %edx, %edx
callq 0x2230
movq %rax, %r12
cmpq $-0x1, %rax
setne %bpl
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3386
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
cmpq $-0x1, %r12
jne 0x339c
leaq 0x28(%r15), %rax
cmpq %r13, %r15
movq %rax, %r15
jne 0x3337
jmp 0x339c
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0x5d92
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33b7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5d92
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/vygr[P]C-Chess/chess.cpp
// Function: all_moves(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto all_moves(const board &brd, int colour)
{
	//enumarate the board square by square
	auto yield = score_boards{}; yield.reserve(max_chess_moves);
	std::size_t king_index = 0;
	auto is_black = (colour == black);
	auto len = int(brd.length());
	for (auto index = 0; index < len; ++index)
	{
		auto piece = brd[index];
		if (piece == ' ') continue;
		if (piece > 'Z' != is_black) continue;
		//one of our pieces ! so gather all boards from possible moves of this piece
		piece_moves(yield, brd, index, colour, (*moves_map[piece]), king_index);
	}
	return yield;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x6d, %esi
callq 0x6302
movq $0x0, 0x30(%rsp)
movq 0x8(%r14), %r13
testl %r13d, %r13d
jle 0x393e
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
cmpl $-0x1, %ebp
setne %al
movq (%r14), %rsi
movb (%rsi,%r15), %dl
movb %dl, 0xf(%rsp)
cmpb $0x5b, %dl
setge %cl
cmpb $0x20, %dl
je 0x3932
xorb %cl, %al
je 0x3932
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x6974
leaq 0xa9bc(%rip), %rdi      # 0xe2b0
leaq 0xf(%rsp), %rsi
callq 0x6406
movq (%rax), %r8
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %ebp, %ecx
leaq 0x30(%rsp), %r9
callq 0x3481
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x3932
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
incq %r15
cmpq %r15, %r13
jne 0x38b4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3952
movq %rax, %r14
jmp 0x3976
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x3976
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x646c
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: parse_CSV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> parse_CSV(string str1) {
	stringstream ss(str1);
	vector<string> result;

    string i;
	while( ss.good() )
	{
		string substr;
		getline( ss, substr, ',' );
		result.push_back( substr );
	}
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq -0x1f0(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x2270
xorl %eax, %eax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x1d0(%rbp,%rax)
jne 0x4bc9
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %r15
movq %r13, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x2330
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52f8
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4b9f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x1f0(%rbp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, -0x1d0(%rbp,%rax)
je 0x4b5f
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x4bc9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x43e0(%rip), %rsi      # 0x8fb0
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x170(%rbp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4c15
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x4c2a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x3a62
movq 0x4377(%rip), %rsi      # 0x8fb0
leaq -0x1f0(%rbp), %rdi
callq 0x2140
leaq -0x170(%rbp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: decimal_to_ternary(int)
vector<int> decimal_to_ternary(int decimal){
	vector<int> ternary;
	while (decimal>2){
		div_t val;
		val = div(decimal,3);
		ternary.push_back(val.rem);
		decimal = val.quot;
	}
	ternary.push_back(decimal);
	return ternary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x3, %esi
jl 0x4d71
movl %esi, %eax
leaq -0x1c(%rbp), %r14
movl %eax, %edi
movl $0x3, %esi
callq 0x21a0
movq %rax, -0x20(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4d45
shrq $0x20, %rax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4d50
movq %rbx, %rdi
movq %r14, %rdx
callq 0x55c2
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x2, %eax
jg 0x4d1b
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4d73
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x4d7f
xorl %esi, %esi
leaq -0x14(%rbp), %rdx
movq %rbx, %rdi
callq 0x55c2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4d8d
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4da4
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: check_result(char, char)
int check_result(char user_move, char comp_move){
	//Basic computer game 
	if ((user_move == 'R' && comp_move == 'S') || (user_move == 'S' && comp_move == 'P') || (user_move == 'P' && comp_move == 'R')){
		return -1;
	}
	if ((user_move == 'S' && comp_move == 'R') || (user_move == 'P' && comp_move == 'S') || (user_move == 'R' && comp_move == 'P')){
		return 1;
	}
	return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %ecx
xorb $0x52, %cl
movl %esi, %edx
xorb $0x53, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %ecx, %r8d
orb %dl, %r8b
je 0x4e06
movl %edi, %r9d
xorb $0x53, %r9b
movl %esi, %r8d
xorb $0x50, %r8b
movl %r9d, %r10d
orb %r8b, %r10b
je 0x4e06
xorb $0x50, %dil
xorb $0x52, %sil
movl %edi, %r10d
orb %sil, %r10b
je 0x4e06
orb %sil, %r9b
sete %al
orb %dl, %dil
sete %dl
orb %al, %dl
orb %r8b, %cl
sete %al
orb %dl, %al
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: convert_queue_to_state(std::deque<int, std::allocator<int>>, int)
int convert_queue_to_state(deque<int> my_state, int R){
	//Go through all the queues elements - should be exactly R
	int out = 0;
	int temp;
	for (int i =0;i< R; i++){
		//Check the top element and pop it
		temp = my_state.front() ; //Check this syntax
		my_state.pop_front();
		out = out + temp * pow(3,i);
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x4e88
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %r14, %rdi
callq 0x5344
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1489(%rip), %xmm0     # 0x62e0
movsd -0x20(%rbp), %xmm1
callq 0x2300
mulsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %r15d
movsd -0x20(%rbp), %xmm0
addsd 0x146b(%rip), %xmm0     # 0x62e8
movsd %xmm0, -0x20(%rbp)
decl %ebx
jne 0x4e2a
jmp 0x4e8b
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: print_queue(std::deque<int, std::allocator<int>>)
void print_queue(deque<int> q)
{
  while (!q.empty())
  {
    cout << q.front() << " ";
    q.pop_front();
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x4fb1
movq %rdi, %rbx
movq 0x4052(%rip), %r14      # 0x8fd0
leaq 0x1377(%rip), %r15      # 0x62fc
movl (%rax), %esi
movq %r14, %rdi
callq 0x22e0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x5344
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x4f85
movq 0x4018(%rip), %rbx      # 0x8fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: convert_user_input_to_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int convert_user_input_to_num(string valid_input,char user_input){
	int break_flag = 0;
	for(int i=0;i<valid_input.length();i++){
		if (valid_input[i] == user_input){
			break_flag = 1;
			return i-1;// -1 because I need the output as 0,1,2 for P,R,S
		}
	}
	cout << "User input bad!!! Terminating\n\n\n\n";
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x5121
movq (%rdi), %rdx
xorl %eax, %eax
cmpb %sil, (%rdx,%rax)
je 0x5140
incq %rax
cmpq %rax, %rcx
jne 0x5113
movq 0x3ea8(%rip), %rdi      # 0x8fd0
leaq 0x11d2(%rip), %rsi      # 0x6301
movl $0x21, %edx
callq 0x21f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5142
decl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: draw_sample(int*, float)
int draw_sample(int trans_counts[],float prior_count){
	/*
	TO DO::
	Takes in a distribution and draws a random variable from that distribution
	
	@params: dist contains the number of transitions. Need not be integer.
	Returns: A character number : 1[P],2[R],3[S]
	*/
	int trans_counts_len = 1+(sizeof(trans_counts)/sizeof(*trans_counts));
	float summed_trans[trans_counts_len+1];
	summed_trans[0] = 0;
 	for (int i=0;i<trans_counts_len;i++){
		summed_trans[i+1] = summed_trans[i] + trans_counts[i] + prior_count;
	}

	//Test the computed
	// print_array(summed_trans,trans_counts_len + 1);
	// print_array(trans_counts,trans_counts_len);
	//Generate a random number
    random_device rd;  //Will be used to obtain a seed for the random number engine
    mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    uniform_real_distribution<> dis(0,1);

	float rand_number = dis(gen);
	rand_number = rand_number * summed_trans[trans_counts_len];
	//Get the lower bound of the nearest element
	int pos = lower_bound(summed_trans,summed_trans+ trans_counts_len + 1,rand_number) - summed_trans;

	return pos;


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2728, %rsp           # imm = 0x2728
movl $0x0, -0x20(%rbp)
xorps %xmm1, %xmm1
movl $0x1, %eax
xorps %xmm2, %xmm2
cvtsi2ssl -0x4(%rdi,%rax,4), %xmm2
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, -0x20(%rbp,%rax,4)
incq %rax
movaps %xmm2, %xmm1
cmpq $0x4, %rax
jne 0x515f
leaq -0x2730(%rbp), %rbx
movq %rbx, %rdi
callq 0x3c2c
movq %rbx, %rdi
callq 0x2230
movl %eax, %eax
movq %rax, -0x13a8(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x13a8(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x51a7
leaq -0x13a8(%rbp), %rdi
movq $0x270, 0x1380(%rdi) # imm = 0x270
callq 0x5702
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
leaq -0x20(%rbp), %rbx
mulss 0xc(%rbx), %xmm0
movl $0x4, %ecx
movq %rcx, %rax
shrq %rax
ucomiss (%rbx,%rax,4), %xmm0
jbe 0x5216
leaq (%rbx,%rax,4), %rbx
addq $0x4, %rbx
notq %rax
addq %rcx, %rax
movq %rax, %rcx
testq %rax, %rax
jg 0x51ff
leaq -0x2730(%rbp), %rdi
callq 0x2190
leaq -0x20(%rbp), %rax
subq %rax, %rbx
shrq $0x2, %rbx
movl %ebx, %eax
addq $0x2728, %rsp           # imm = 0x2728
popq %rbx
popq %rbp
retq
jmp 0x525c
jmp 0x5245
movq %rax, %rbx
leaq -0x2730(%rbp), %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x3ca9
// File: /workspace/github_cpp_makefile_star2_O3/sagarvare[P]reinforcement-learning-rock-paper-scissor/helper.cpp
// Function: user_won(char, char)
int user_won(char user_move, char comp_move ){
	if (user_move == 'R' && comp_move =='S'){
		return 1;
	}

	else if (user_move == 'P' && comp_move =='R'){
		return 1;
	}

	else if (user_move == 'S' && comp_move =='P'){
		return 1;
	}

	else{
		return 0;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %ecx
xorb $0x52, %cl
movl %esi, %edx
xorb $0x53, %dl
movl $0x1, %eax
orb %cl, %dl
je 0x5299
movl %edi, %ecx
xorb $0x50, %cl
movl %esi, %edx
xorb $0x52, %dl
orb %cl, %dl
je 0x5299
xorb $0x53, %dil
xorb $0x50, %sil
xorl %eax, %eax
orb %dil, %sil
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/test/main.cpp
// Function: perimeterTest_correctInput_Test::TestBody()
TEST(perimeterTest, correctInput)
{
    Circle one;

    one.r = 5;
    EXPECT_FLOAT_EQ(31.415, Perimeter(one));

    one.r = 1337.322;
    EXPECT_FLOAT_EQ(8402.3945, Perimeter(one));

    one.r = 0.005;
    EXPECT_FLOAT_EQ(0.031415, Perimeter(one));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss 0x6d1b(%rip), %xmm1     # 0x544f0
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6da5(%rip), %rsi      # 0x54589
leaq 0x6da5(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6cfc(%rip), %xmm0     # 0x544f4
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4d863
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d81e
movq (%rax), %r8
jmp 0x4d825
leaq 0x72eb(%rip), %r8       # 0x54b10
leaq 0x6d4f(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0xd, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d863
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d877
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movss 0x6c79(%rip), %xmm1     # 0x544f8
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6d11(%rip), %rsi      # 0x5459f
leaq 0x6cfb(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6c5a(%rip), %xmm0     # 0x544fc
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4d90d
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d8c8
movq (%rax), %r8
jmp 0x4d8cf
leaq 0x7241(%rip), %r8       # 0x54b10
leaq 0x6ca5(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0x10, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d90d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d921
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movss 0x6bd7(%rip), %xmm1     # 0x54500
callq 0x4ee3c
movaps %xmm0, %xmm1
leaq 0x6c71(%rip), %rsi      # 0x545a9
leaq 0x6c51(%rip), %rdx      # 0x54590
leaq 0x10(%rsp), %rbx
movss 0x6bb8(%rip), %xmm0     # 0x54504
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4d9b7
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4d972
movq (%rax), %r8
jmp 0x4d979
leaq 0x7197(%rip), %r8       # 0x54b10
leaq 0x6bfb(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0x13, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4d9b7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4d9cb
leaq 0x18(%rsp), %rdi
callq 0x39b6c
addq $0x20, %rsp
popq %rbx
retq
jmp 0x4d9db
jmp 0x4d9ea
jmp 0x4d9db
jmp 0x4d9ff
jmp 0x4d9ea
movq %rax, %rbx
movq %rsp, %rdi
callq 0xabc6
jmp 0x4d9ed
jmp 0x4d9ff
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4da02
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4da02
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4da16
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movq %rbx, %rdi
callq 0x9c50
// File: /workspace/github_cpp_makefile_star2_O3/El-Duder1no[P]geometry/test/main.cpp
// Function: areaTest_correctInput_Test::TestBody()
TEST(areaTest, correctInput)
{
    Circle one;

    one.r = 8.65124;
    EXPECT_FLOAT_EQ(235.12228, Area(one));

    one.r = 93.59;
    EXPECT_FLOAT_EQ(27516.6752, Area(one));

    one.r = 14.55;
    EXPECT_FLOAT_EQ(665.0634, Area(one));
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss 0x6add(%rip), %xmm1     # 0x54508
callq 0x4ee20
movaps %xmm0, %xmm1
leaq 0x6b81(%rip), %rsi      # 0x545bb
leaq 0x6b84(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x6abe(%rip), %xmm0     # 0x5450c
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4dab9
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4da74
movq (%rax), %r8
jmp 0x4da7b
leaq 0x7095(%rip), %r8       # 0x54b10
leaq 0x6af9(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1b, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dab9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4dacd
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movss 0x6a3b(%rip), %xmm1     # 0x54510
callq 0x4ee20
movaps %xmm0, %xmm1
leaq 0x6aeb(%rip), %rsi      # 0x545cf
leaq 0x6ada(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x6a1c(%rip), %xmm0     # 0x54514
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4db63
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4db1e
movq (%rax), %r8
jmp 0x4db25
leaq 0x6feb(%rip), %r8       # 0x54b10
leaq 0x6a4f(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0x1e, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4db63
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4db77
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movss 0x6999(%rip), %xmm1     # 0x54518
callq 0x4ee20
movaps %xmm0, %xmm1
leaq 0x6a4c(%rip), %rsi      # 0x545da
leaq 0x6a30(%rip), %rdx      # 0x545c5
leaq 0x10(%rsp), %rbx
movss 0x697a(%rip), %xmm0     # 0x5451c
movq %rbx, %rdi
callq 0x4e910
cmpb $0x0, (%rbx)
jne 0x4dc0d
leaq 0x8(%rsp), %rdi
callq 0xcaba
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4dbc8
movq (%rax), %r8
jmp 0x4dbcf
leaq 0x6f41(%rip), %r8       # 0x54b10
leaq 0x69a5(%rip), %rdx      # 0x5457b
movq %rsp, %rdi
movl $0x1, %esi
movl $0x21, %ecx
callq 0xab58
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0xac00
movq %rsp, %rdi
callq 0xabc6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dc0d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4dc21
leaq 0x18(%rsp), %rdi
callq 0x39b6c
addq $0x20, %rsp
popq %rbx
retq
jmp 0x4dc31
jmp 0x4dc40
jmp 0x4dc31
jmp 0x4dc55
jmp 0x4dc40
movq %rax, %rbx
movq %rsp, %rdi
callq 0xabc6
jmp 0x4dc43
jmp 0x4dc55
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dc58
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4dc58
movq %rax, %rbx
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x4dc6c
leaq 0x18(%rsp), %rdi
callq 0x39b6c
movq %rbx, %rdi
callq 0x9c50