LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::dir_iterator::move_to(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::filesystem::dir_iterator::move_to(std::string path){
	std::stringstream ss(path);
	std::string token;

	virt::filesystem::dir_iterator iterator = 
		(path[0] == '/')? (this->working_fs->root()) : (*this);
	

	while (std::getline(ss, token, '/')){
		if (token == "")
			continue;
		if (iterator.working_dir->has_child(token))
			iterator.working_dir = iterator.working_dir->child_dir(token);
		else 
			return false;
	}

	this->working_dir = iterator.working_dir;
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x3290
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r15), %rax
xorl %ecx, %ecx
cmpb $0x2f, (%rax)
setne %cl
movq %rbx, 0x68(%rsp)
movq (%rbx,%rcx,8), %r15
movq %rsp, %r12
leaq 0x6266(%rip), %r13      # 0xbdcd
leaq 0x40(%rsp), %rbp
movq %r14, %rdi
movq %r12, %rsi
movl $0x2f, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebx
testb $0x5, %bl
jne 0x5c4d
movq %r12, %rdi
movq %r13, %rsi
callq 0x3090
testl %eax, %eax
je 0x5b6c
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4ac8
movq %r15, 0x60(%rsp)
movq %r15, %rdi
movq %rbp, %r15
movq %rbp, %rsi
callq 0x3b4c
movl %eax, %ebp
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5bee
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
je 0x5c56
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4ac8
movq 0x60(%rsp), %rdi
movq %r15, %rbp
leaq 0x20(%rsp), %rsi
callq 0x3b66
movq %rax, %r15
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5b6c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5b6c
movq 0x68(%rsp), %rax
movq %r15, 0x8(%rax)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5c71
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
testb $0x5, %bl
setne %bl
movq 0xb33a(%rip), %rsi      # 0x10fb8
leaq 0x70(%rsp), %rdi
callq 0x3160
leaq 0xf0(%rsp), %rdi
callq 0x30b0
movl %ebx, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5ce8
movq 0x30(%rsp), %rsi
jmp 0x5cd9
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5ce8
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5ce8
jmp 0x5ce5
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5d03
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0xb2ae(%rip), %rsi      # 0x10fb8
leaq 0x70(%rsp), %rdi
callq 0x3160
leaq 0xf0(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::dir_iterator::operator=(virt::filesystem::dir_iterator const&)
virt::filesystem::dir_iterator& virt::filesystem::dir_iterator::operator= 
		(const virt::filesystem::dir_iterator& c){
	if (this != &c){
		this->working_fs = c.working_fs;
		this->working_dir = c.working_dir;
	}
	return *this;
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
je 0x5d4e
movq (%rsi), %rcx
movq %rcx, (%rax)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::install_utility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, virt::os::utility*)
bool virt::operatingsystem::install_utility(std::string name, virt::os::utility* new_utility){
	if (utilities.find(name) != utilities.end())
		return false;

	utilities[name] = new_utility;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x602a
movq %rax, %r15
leaq 0x8(%r12), %r13
cmpq %r13, %rax
jne 0x5de0
movq %r12, %rdi
movq %r14, %rsi
callq 0x5f36
movq %rbx, (%rax)
cmpq %r13, %r15
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::remove_utility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::operatingsystem::remove_utility(std::string name){
	if (utilities.find(name) == utilities.end())
		return false;

	utilities.erase(name);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x602a
movq %rax, %r14
leaq 0x8(%rbx), %r12
cmpq %r12, %rax
je 0x5e25
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63c6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x646e
cmpq %r12, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/vos/operatingsystem.cpp
// Function: virt::operatingsystem::app(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
virt::os::utility* virt::operatingsystem::app(std::string name){
	std::map<std::string, virt::os::utility*>::iterator it = utilities.find(name);
	if (it == utilities.end()){
		return NULL;
	}

	return utilities[name];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x602a
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x5e60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f36
movq (%rax), %rax
jmp 0x5e62
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/./utility/shell.h
// Function: virt::util::shell::process_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void process_command(std::string appname, std::string command){
			if (working_os->app(appname) == NULL)
				return ;
			std::string output = working_os->app(appname)->launch(command);
			std::cout << output;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r12
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x4ac8
movq %r12, %rdi
movq %r13, %rsi
callq 0x5e38
movq %rax, %r12
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8f09
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r12, %r12
je 0x8fd3
movq 0x8(%r15), %r15
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x4ac8
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e38
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4ac8
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8f8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x8fa2
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x801d(%rip), %rdi      # 0x10fd0
callq 0x3200
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8fd3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq -0x10(%r12), %rdi
jmp 0x902c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9027
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x9027
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x903d
movq 0x58(%rsp), %rsi
jmp 0x9035
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x903d
movq (%r12), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/./utility/cd.h
// Function: virt::util::cd::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!\n";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			bool s = sh->shell_iterator.move_to(param);
			if (!s)
				return "No such directory. See 'help cd' for more information";
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1f93(%rip), %rsi      # 0xb1ef
leaq 0x1f91(%rip), %rdx      # 0xb1f4
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4718
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e38
testq %rax, %rax
je 0x929d
leaq 0x7901(%rip), %rsi      # 0x10b88
leaq 0x790a(%rip), %rdx      # 0x10b98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x92a0
xorl %r15d, %r15d
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x92b7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r15, %r15
jne 0x92e5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x230a(%rip), %rsi      # 0xb5d4
leaq 0x2329(%rip), %rdx      # 0xb5fa
jmp 0x938d
movl $0x1, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movq (%r14), %rax
cmpb $0x20, (%rax)
je 0x92d6
movq (%r14), %rsi
movq 0x8(%r14), %rdx
cmpb $0x20, -0x1(%rsi,%rdx)
jne 0x9323
decq %rdx
movq %rdx, %rax
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3070
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq -0x1(%rdx), %rax
cmpb $0x20, -0x1(%rsi,%rdx)
je 0x9301
addq $0x50, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4ac8
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b0c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9364
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
testb %bpl, %bpl
je 0x937f
leaq 0x2a56(%rip), %rdx      # 0xbdcd
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x9390
leaq 0x2591(%rip), %rsi      # 0xb917
leaq 0x25bf(%rip), %rdx      # 0xb94c
movq %rbx, %rdi
callq 0x4718
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x93b9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x93ca
movq (%r13), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/./utility/pwd.h
// Function: virt::util::pwd::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			return sh->shell_iterator.get_working_dir()->path() + "\n";
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x192e(%rip), %rsi      # 0xb1ef
leaq 0x192c(%rip), %rdx      # 0xb1f4
movq %rsp, %r12
movq %r12, %rdi
callq 0x4718
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e38
testq %rax, %rax
je 0x9900
leaq 0x729e(%rip), %rsi      # 0x10b88
leaq 0x72a7(%rip), %rdx      # 0x10b98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x9903
xorl %r15d, %r15d
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9919
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r15, %r15
jne 0x994f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2242(%rip), %rsi      # 0xbb6e
leaq 0x2260(%rip), %rdx      # 0xbb93
movq %rbx, %rdi
callq 0x4718
jmp 0x9a0c
movl $0x1, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movq (%r14), %rax
cmpb $0x20, (%rax)
je 0x9940
movq (%r14), %rax
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x9987
decq %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3070
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq -0x1(%rcx), %rsi
cmpb $0x20, -0x1(%rax,%rcx)
je 0x9968
addq $0x50, %r15
movq %r15, %rdi
callq 0x5d32
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x38de
leaq 0x2422(%rip), %rsi      # 0xbdcc
movq %r14, %rdi
callq 0x3300
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x99d4
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x99da
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a0c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a4e
movq 0x30(%rsp), %rsi
jmp 0x9a46
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x9a4e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/FalconUA[P]vfs/./utility/rm.h
// Function: virt::util::rm::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!\n";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			sh->shell_iterator.get_working_dir()->remove_file(param);
			sh->shell_iterator.get_working_dir()->remove_subdir(param);
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x10af(%rip), %rsi      # 0xb1ef
leaq 0x10ad(%rip), %rdx      # 0xb1f4
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x4718
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e38
testq %rax, %rax
je 0xa181
leaq 0x6a1d(%rip), %rsi      # 0x10b88
leaq 0x6a26(%rip), %rdx      # 0x10b98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0xa184
xorl %r15d, %r15d
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa19b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x31c0
testq %r15, %r15
jne 0xa1cc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1426(%rip), %rsi      # 0xb5d4
leaq 0x1445(%rip), %rdx      # 0xb5fa
movq %rbx, %rdi
jmp 0xa2b6
movl $0x1, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3070
movq (%r14), %rax
cmpb $0x20, (%rax)
je 0xa1bd
movq (%r14), %rax
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0xa204
decq %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x3070
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq -0x1(%rcx), %rsi
cmpb $0x20, -0x1(%rax,%rcx)
je 0xa1e5
addq $0x50, %r15
movq %r15, %rdi
callq 0x5d32
movq %rax, %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x4ac8
movq %r12, %rdi
movq %r13, %rsi
callq 0x4194
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa255
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %r15, %rdi
callq 0x5d32
movq %rax, %r15
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4ac8
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cba
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa2a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b1d(%rip), %rdx      # 0xbdcd
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4718
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0xa2e9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0xa2e9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xa2fa
movq (%rbp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: ReadMatrix(gaps::R4Matrix&, char const*)
static int
ReadMatrix(R4Matrix& m, const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open matrix file: %s\n", filename);
    return 0;
  }

  // Read matrix from file
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      double value;
      fscanf(fp, "%lf", &value);
      m[i][j] = value;
    }
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xdd59e(%rip), %rsi     # 0x104a53
movq %r15, %rdi
callq 0x22a60
testq %rax, %rax
je 0x27513
movq %rax, %r14
leaq 0xd9ca6(%rip), %r15     # 0x101172
movq %rsp, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x23120
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx,%rbp,8)
incq %rbp
cmpq $0x4, %rbp
jne 0x274d4
incq %r13
addq $0x20, %rbx
cmpq $0x4, %r13
jne 0x274d2
movq %r14, %rdi
callq 0x22860
movl $0x1, %ebx
jmp 0x27526
leaq 0xd0c3e(%rip), %rdi     # 0xf8158
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa69a6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: get_nodes(newick_node*, std::vector<newick_node*, std::allocator<newick_node*>>&)
static void get_nodes(newick_node* node, vn& N)
{
    N[node->taxoni] = node;
    for (newick_child* child = node->child; child; child = child->next)
        if (!N[child->node->taxoni])
            get_nodes(child->node, N);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x28(%rdi), %rax
movq (%rsi), %rcx
movq %rdi, (%rcx,%rax,8)
movq (%rdi), %r14
testq %r14, %r14
je 0x3e55
movq %rsi, %rbx
movq (%r14), %rdi
movslq 0x28(%rdi), %rax
movq (%rbx), %rcx
cmpq $0x0, (%rcx,%rax,8)
jne 0x3e4c
movq %rbx, %rsi
callq 0x3e19
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x3e33
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: load_tree(char const*)
newick_node* load_tree(const char* filename)
{
    ifstream File(filename);
    if (!File)
    {
        cout << "Cannot read " << filename << endl;
        return nullptr;
    }

    int Size;
    File.seekg(0, ios::end);
    Size = File.tellg();
    File.seekg(0, ios::beg);

    string str(Size, 0);
    File.read(&str[0], Size);

    size_t itr = 0;
    return parse_tree(str, itr);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %r14
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2390
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x50(%rsp,%rax)
je 0x3f4d
movq 0x50bf(%rip), %rbx      # 0x8fd0
leaq 0x2261(%rip), %rsi      # 0x6179
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2250
testq %r14, %r14
je 0x3fd8
movq %r14, %rdi
callq 0x2100
movq 0x5093(%rip), %rdi      # 0x8fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2250
jmp 0x3fef
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22c0
leaq 0x30(%rsp), %rdi
callq 0x2360
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22c0
movslq %ebx, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2260
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rbx, %rdx
callq 0x2280
leaq 0x28(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x406d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x401c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x401c
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2350
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq 0x4fc3(%rip), %rdi      # 0x8fd0
callq 0x2030
movq %rax, %rdi
callq 0x2150
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
jmp 0x4036
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x405b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x405b
jmp 0x4058
jmp 0x4058
jmp 0x4058
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: parse_tree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&)
static newick_node* parse_tree(string& str, size_t& itr)
{
    newick_child* child = nullptr;
    newick_child** childptr = &child;
    for (itr += 1; itr < str.size() && str[itr - 1] != ')'; ++itr)
    {
        newick_node* new_child = nullptr;
        if (str[itr] == '(')
            new_child = parse_tree(str, itr);
        else
            new_child = parse_node(str, itr, nullptr);

        *childptr = new newick_child(new_child);
        childptr = &(*childptr)->next;
    }
    return parse_node(str, itr, child);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsp)
movq (%rsi), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rsi)
cmpq 0x8(%rdi), %rax
jae 0x40ef
movq %rsp, %r12
movq (%r14), %rdx
cmpb $0x29, (%rdx,%rcx)
je 0x40ef
cmpb $0x28, (%rdx,%rax)
jne 0x40b2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x406d
jmp 0x40bf
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x47a3
movq %rax, %r15
movl $0x10, %edi
callq 0x2200
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%r12)
leaq 0x8(%rax), %r12
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
cmpq 0x8(%r14), %rax
jb 0x4096
movq (%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x47a3
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: load_dag_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, newick_node*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, newick_node*>>>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::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>>>>>>>&)
static newick_node* load_dag_internal(const string& r, msn& M, msvs& C)
{
    if (newick_node* node = M[r])
        return node;

    newick_child* child = nullptr;
    newick_child** childptr = &child;
    for (const string& i : C[r])
    {
        *childptr = new newick_child(load_dag_internal(i, M, C));
        childptr = &(*childptr)->next;
    }
    return M[r] = new newick_node(r, 0, child);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x4b9c
movq (%rax), %r12
testq %r12, %r12
jne 0x46a0
movq $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, 0x10(%rsp)
movq %rbx, %rsi
callq 0x4a40
movq (%rax), %r12
movq 0x8(%rax), %rbp
cmpq %rbp, %r12
je 0x466d
leaq 0x8(%rsp), %rbx
movl $0x10, %edi
callq 0x2200
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x45db
movq %rax, (%r13)
movq $0x0, 0x8(%r13)
movq %r13, (%rbx)
movq %r13, %rbx
addq $0x8, %rbx
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x4633
movl $0x38, %edi
callq 0x2200
movq %rax, %r12
movq 0x8(%rsp), %rdx
xorps %xmm0, %xmm0
movq %rax, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x3c52
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b9c
movq %r12, (%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r12, %rdi
jmp 0x46ca
movq %rax, %rbx
movl $0x10, %esi
movq %r13, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: print_tree(newick_node*, std::ostream&)
void print_tree(newick_node* root, ostream& file)
{
    file << fixed << setprecision(6);
    if (root->child)
    {
        file << "(";
        for (newick_child* child = root->child; child; child = child->next)
        {
            print_tree(child->node, file);
            if (child->next)
                file << ",";
        }
        file << ")" << root->taxon << ":" /*<< root->dist*/;
    }
    else
        file << root->taxon << ":" /*<< root->dist*/;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rsi,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rsi,%rcx)
movq -0x18(%rax), %rax
movq $0x6, 0x8(%rsi,%rax)
cmpq $0x0, (%rdi)
je 0x4774
leaq 0x1a9a(%rip), %rsi      # 0x61b0
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2250
movq (%r14), %r12
testq %r12, %r12
je 0x4760
leaq 0x1a80(%rip), %r15      # 0x61b2
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x46d7
cmpq $0x0, 0x8(%r12)
je 0x4756
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2250
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x4732
leaq 0x1a83(%rip), %rsi      # 0x61ea
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2250
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x2250
leaq 0x1a29(%rip), %rsi      # 0x61b4
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/newick.cpp
// Function: parse_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&, newick_child*)
static newick_node* parse_node(string& str, size_t& itr, newick_child* child)
{
    size_t index = str.find_first_of(",);\r\n\0", itr);
    string data = str.substr(itr, index - itr);
    itr = index;

    size_t index2 = data.find_first_of(':');
    string taxon = data.substr(0, index2);
    float dist = 0;
    if (index2 != string::npos && data.back() != ':')
        dist = stof(data.substr(index2 + 1));

    return new newick_node(taxon, dist, child);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdx
leaq 0x1a28(%rip), %rsi      # 0x61ec
movl $0x5, %ecx
callq 0x2310
movq %rax, %r12
movq (%r14), %rdx
movq %rax, %rcx
subq %rdx, %rcx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2220
movq %r12, (%r14)
movq %r13, %rdi
movl $0x3a, %esi
xorl %edx, %edx
callq 0x22a0
movq %rax, %r14
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2220
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cmpq $-0x1, %r14
je 0x48c0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpb $0x3a, -0x1(%rax,%rcx)
je 0x48c0
incq %r14
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x2220
movq 0x30(%rsp), %r15
callq 0x2050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x70(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x22b0
movss %xmm0, 0xc(%rsp)
cmpq %r15, (%r12)
je 0x492b
movl (%r14), %eax
testl %eax, %eax
je 0x48a2
cmpl $0x22, %eax
jne 0x48a5
leaq 0x1919(%rip), %rdi      # 0x61b6
callq 0x22e0
movl %ebp, (%r14)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48c0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2210
movl $0x38, %edi
callq 0x2200
movq %rax, %r14
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
movss 0xc(%rsp), %xmm0
movq %rbx, %rdx
callq 0x3c52
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48fe
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x2210
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4919
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2210
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1884(%rip), %rdi      # 0x61b6
callq 0x2130
jmp 0x496f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x4945
movl %ebp, (%r14)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4972
movq 0x40(%rsp), %rsi
incq %rsi
jmp 0x4968
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x2210
jmp 0x4972
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4992
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x4992
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49ad
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/usefcnptr.cc
// Function: main
int main() 
{
    vector<int> ivec;
    // give ivec some values
    cout << "Direct call: "   
         << min_element(ivec.begin(), ivec.end()) << endl;

    cout << "Indirect call: " 
         << pf(ivec.begin(), ivec.end()) << endl;

	cout << "equivalent indirect call: "
	     << (*pf)(ivec.begin(), ivec.end()) << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dee(%rip), %rbx      # 0x3fd8
leaq 0xe13(%rip), %rsi       # 0x2004
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq 0xdd9(%rip), %rsi       # 0x2012
movl $0xf, %edx
movq %rbx, %rdi
callq 0x1070
xorl %edi, %edi
xorl %esi, %esi
callq *0x2e10(%rip)           # 0x4060
movq %rbx, %rdi
movl %eax, %esi
callq 0x1090
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
leaq 0xd97(%rip), %rsi       # 0x2022
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x1070
xorl %edi, %edi
xorl %esi, %esi
callq *0x2dbe(%rip)           # 0x4060
movq %rbx, %rdi
movl %eax, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/flip.cc
// Function: main
int main()
{
	int i = 0, j = 0, k = 0, l = 0;
	cout << i << " " << j << " " << k << " " << l << endl;

	f(42, i);        // f changes its argument i
	flip1(f, j, 42); // f called through flip1 leaves j unchanged
	flip2(f, k, 42); // ok: k is changed
	g(1, i);
	flip(g, i, 42);  // ok: rvalue-ness of the third argument is preserved
	cout << i << " " << j << " " << k << " " << l << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r12d, %r12d
leaq -0x34(%rbp), %r15
movl %r12d, (%r15)
leaq -0x30(%rbp), %r14
movl %r12d, (%r14)
movq 0x2d01(%rip), %rdi      # 0x3fd8
xorl %esi, %esi
callq 0x1090
movq %rax, %r13
leaq 0xd1c(%rip), %rbx       # 0x2004
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r13, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movl $0x2a, %edi
movq %r15, %rsi
callq 0x11dc
leaq -0x2c(%rbp), %r13
movl %r12d, (%r13)
movl $0x2a, %edi
movq %r13, %rsi
callq 0x11dc
movl $0x2a, %edi
movq %r14, %rsi
callq 0x11dc
movl $0x1, (%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0x1247
movl $0x2a, (%r13)
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x1247
movl (%r15), %esi
movq 0x2c12(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r15, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movl (%r14), %esi
movq %r15, %rdi
callq 0x1090
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movq %r14, %rdi
xorl %esi, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::simple_sas(int, std::vector<double, std::allocator<double>>&, int)
void simple_sas(int samplecount, Table &samples, int from = 0){
                
                double steps = double(bincount) / samplecount;
                //double r = _random(0.0, steps);
                double r = steps * (1.0 - __random(gen));
                double x =  bincount - r;
                int i = from;

                int to = from + samplecount;
                while(i < to){
                  //  int ri = int(x);
                   // int rf  = x  -ri;
                    samples[i] = aliassample(int(x), x- int(x));
                    x -= steps;
                    i++;
                }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movsd 0x78(%rdi), %xmm0
movapd %xmm0, (%rsp)
leaq 0x651e(%rip), %rdi      # 0xa4e0
callq 0x4ea6
testl %r14d, %r14d
jle 0x40a7
movapd (%rsp), %xmm2
unpcklps 0x20a4(%rip), %xmm2     # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x20ac(%rip), %xmm2     # 0x6090
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
divsd %xmm2, %xmm1
addl %ebp, %r14d
movsd 0x78(%rbx), %xmm3
unpcklps 0x2075(%rip), %xmm3     # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
subpd 0x207d(%rip), %xmm3     # 0x6090
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
movsd 0x7849(%rip), %xmm3     # 0xb870
movsd 0x7839(%rip), %xmm4     # 0xb868
subsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
addsd %xmm4, %xmm0
movsd 0x1fcd(%rip), %xmm3     # 0x6010
subsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
subsd %xmm3, %xmm2
movq 0x60(%rbx), %rax
movq (%r15), %rcx
movslq %ebp, %rdx
movslq %r14d, %rsi
leaq 0x30(%rbx), %rdi
addq $0x18, %rbx
cvttsd2si %xmm2, %r8d
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm2, %xmm3
subsd %xmm0, %xmm3
movslq %r8d, %r8
movsd (%rax,%r8,8), %xmm0
ucomisd %xmm3, %xmm0
movq %rdi, %r9
cmovbq %rbx, %r9
movq (%r9), %r9
movsd (%r9,%r8,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
subsd %xmm1, %xmm2
incq %rdx
cmpq %rsi, %rdx
jl 0x4064
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Simulation.cpp
// Function: main
int main(int argc, char **argv) {
    Simulation simulation;

    std::cout << "Virtual Memory Simulation" << std::endl;

    //Get the input file from the user
    std::string filepath;
    std::cout << "Input file: ";
    std::cin >> filepath;

    //Remove whitespace/newlines
    StringUtilities::Trim(filepath);

    simulation.SetInputFilepath(filepath);
    simulation.Run();

    std::cout << std::endl << "Simulation Complete:" << std::endl;

    simulation.DisplayStatistics();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
leaq 0x60(%rsp), %rdi
callq 0x3394
movq 0x95bf(%rip), %rbx      # 0xbfc8
leaq 0x564e(%rip), %rsi      # 0x805e
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2200
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x958d(%rip), %rdi      # 0xbfc8
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x9564(%rip), %rbx      # 0xbfc8
leaq 0x560d(%rip), %rsi      # 0x8078
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2200
movq 0x9559(%rip), %rdi      # 0xbfd8
movq %rsp, %rsi
callq 0x2240
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x4d20
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x33fe
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ad0
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ae7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x2c4a
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x94ac(%rip), %rdi      # 0xbfc8
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %rbx
leaq 0x5552(%rip), %rsi      # 0x8085
movl $0x14, %edx
movq %rax, %rdi
callq 0x2200
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
callq 0x2140
leaq 0x60(%rsp), %rdi
callq 0x3358
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2b87
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0xb0(%rsp), %rbx
leaq 0x140(%rsp), %rdi
callq 0x3d18
leaq 0x110(%rsp), %rdi
callq 0x3d68
leaq 0xe0(%rsp), %rdi
callq 0x3d68
movq %rbx, %rdi
callq 0x3d68
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0x3d7c
movq -0x20(%rbx), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x2be9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x21d0
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c1c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2c1c
movq %rax, %rbx
jmp 0x2c32
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2c32
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x60(%rsp), %rdi
callq 0x34c4
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/./StringUtilities.h
// Function: StringUtilities::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> SplitString(std::string s, const std::string &delimiter) {
        size_t pos = 0;
        std::vector<std::string> tokens;

        bool debug = false;

        if(debug) std::cout << "s = " << s << ", delimiter = " << delimiter;

        while((pos = s.find(delimiter)) != std::string::npos) {
            if(debug) std::cout << "Found delimiter at pos = " << pos << std::endl;
            tokens.push_back(s.substr(0, pos));
            if(debug) std::cout << "Added token to vector: " << s.substr(0, pos) << std::endl;
            s.erase(0, pos + delimiter.length());
            if(debug) std::cout << "Erased token and delimiter" << std::endl;
        }

        if(debug) std::cout << "Adding last token to vector: " << s << std::endl;
        tokens.push_back(s);

        return tokens;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x22e0
cmpq $-0x1, %rax
je 0x35b8
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x35a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
addq 0x8(%r15), %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2060
jmp 0x3559
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4102
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35f5
jmp 0x35f5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x35f8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x35f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x3608
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/./Memory.h
// Function: Memory::Memory()
Memory(void) {
        ram.clear();
        available.clear();
        free.clear();
        lru.clear();

        //Generate 16 available frames
        for(int i = 0; i < (MEM_SIZE / FRAME_SIZE); i++) {
            available.insert(i);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorl %ebp, %ebp
movl %ebp, 0x8(%rdi)
movq %rbp, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x38(%rdi), %rax
movl %ebp, 0x38(%rdi)
movq %rbp, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rbp, 0x58(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x68(%rdi), %rax
movl %ebp, 0x68(%rdi)
movq %rbp, 0x70(%rdi)
movq %rax, 0x78(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x90(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xa8(%rdi)
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xc8(%rdi)
movq %rbp, 0xd8(%rdi)
movq %r12, %rdi
xorl %esi, %esi
callq 0x3a1e
movq %rbx, %rdi
callq 0x3b96
movq %r14, %rdi
callq 0x3b96
movq %r15, %rdi
callq 0x3b96
movq %r12, %rdi
callq 0x39b6
leaq 0x6(%rsp), %r13
movw %bp, 0x6(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x3c00
incl %ebp
cmpl $0x10, %ebp
jne 0x395f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x3995
movq %rax, %r13
movq %r12, %rdi
callq 0x3d18
movq %r15, %rdi
callq 0x3d68
movq %r14, %rdi
callq 0x3d68
movq %rbx, %rdi
callq 0x3d68
movq %r13, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Memory.cpp
// Function: Memory::AvailableToRAM(unsigned short)
void Memory::AvailableToRAM(const uint16_t frame) {
    //Make sure it does not exist in the available list
    if(available.count(frame)) {
        available.erase(available.find(frame));
    }

    ram.insert(frame);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
movq %rdi, %rbx
movw %ax, 0xe(%rsp)
movq 0x40(%rdi), %rcx
leaq 0x38(%rdi), %rsi
movq %rsi, %rdx
testq %rcx, %rcx
je 0x60e4
movq %rcx, %rdi
movq %rsi, %rdx
xorl %r8d, %r8d
cmpw %ax, 0x20(%rdi)
setb %r8b
cmovaeq %rdi, %rdx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x60cb
movq %rsi, %rdi
cmpq %rsi, %rdx
je 0x60f7
cmpw %ax, 0x20(%rdx)
cmovaq %rsi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdi
je 0x6135
movq %rsi, %rdx
testq %rcx, %rcx
je 0x611f
movq %rsi, %rdx
xorl %edi, %edi
cmpw %ax, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %rcx
jne 0x6107
leaq 0x30(%rbx), %rdi
cmpq %rsi, %rdx
je 0x6130
cmpw %ax, 0x20(%rdx)
cmovbeq %rdx, %rsi
callq 0x65ca
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x6606
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process()
Process::Process(void) {
    name.clear();
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x28, %rdi
callq 0x6c04
leaq 0x70(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x70(%rbx)
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq %rcx, 0x90(%rbx)
movq %rcx, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movl %ecx, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6729
movq (%r15), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Process::Process(const std::string & name) {
    this->name = name;
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x6c04
leaq 0x70(%rbx), %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq %rcx, 0x90(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f0
movl $0x0, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x68(%rbx), %rdi
callq 0x3d68
movq %r14, %rdi
callq 0x4cfa
jmp 0x67c2
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x67d6
movq (%r12), %rsi
incq %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::PageAccess(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint16_t Process::PageAccess(const std::string & string) {
    //Decode the string into the page number
    uint16_t page = DecodePageNumber(string);

    //Add the referenced page number to the set
    pages.insert(page);

    //Determine the range of the page set (this is the size...)
    size = ComputeSize();

    //Increment number of references
    references++;

    return page;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x6ade
movzwl (%r14), %eax
leaq 0xe(%rsp), %r14
movw %ax, (%r14)
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x6606
movq 0x80(%rbx), %rdi
leaq 0x70(%rbx), %rsi
callq 0x6b59
movzwl 0x20(%rax), %eax
movw %ax, 0x24(%rbx)
incw 0x20(%rbx)
movzwl (%r14), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::DecodePageNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint16_t Process::DecodePageNumber(const std::string & string) {
    //Create a bitset from the string
    std::bitset<6> bitset(string);

    //Return and cast the integer representation of the bitset
    return (uint16_t)bitset.to_ulong();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6ade
movzwl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
nop