LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sellibitze[P]secretshare-cxx/main.cpp
// Function: (anonymous namespace)::compute_crc24(unsigned int, unsigned int, slice<unsigned char const>)
uint32_t compute_crc24(unsigned k, unsigned n, slice<const octet> const data)
{
	crc24hasher h;
	h.process_byte(k);
	h.process_byte(n);
	h.process_block(data);
	return h.finish();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x3790
movl -0x14(%rbp), %eax
leaq -0x1c(%rbp), %rdi
movzbl %al, %esi
callq 0x37b0
movl -0x18(%rbp), %eax
leaq -0x1c(%rbp), %rdi
movzbl %al, %esi
callq 0x37b0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x1c(%rbp), %rdi
callq 0x38b0
leaq -0x1c(%rbp), %rdi
callq 0x3940
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::~directory()
virt::fs::directory::~directory(){
	for (std::map<std::string, virt::fs::directory*>::iterator it = subdir.begin();
			it != subdir.end(); it++)
		if ((*it).first != "." && (*it).first != ".." && (*it).first != "")
			delete (*it).second;
	for (std::map<std::string, virt::fs::file*>::iterator it = files.begin();
			it != files.end(); it++)
		delete (*it).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x28, %rdi
callq 0x4b90
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x4bf0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4bc0
testb $0x1, %al
jne 0x3be8
jmp 0x3ca0
leaq -0x10(%rbp), %rdi
callq 0x4c50
movq %rax, %rdi
leaq 0xf40a(%rip), %rsi      # 0x13005
callq 0x4c20
movb %al, -0x41(%rbp)
jmp 0x3c05
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x3c0e
jmp 0x3c8a
leaq -0x10(%rbp), %rdi
callq 0x4c50
movq %rax, %rdi
leaq 0xf3e3(%rip), %rsi      # 0x13004
callq 0x4c20
movb %al, -0x42(%rbp)
jmp 0x3c2b
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x3c34
jmp 0x3c8a
leaq -0x10(%rbp), %rdi
callq 0x4c50
movq %rax, %rdi
leaq 0x10186(%rip), %rsi     # 0x13dcd
callq 0x4c20
movb %al, -0x43(%rbp)
jmp 0x3c51
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x3c5a
jmp 0x3c8a
leaq -0x10(%rbp), %rdi
callq 0x4c50
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x3c88
movq -0x50(%rbp), %rdi
callq 0x3ba0
movq -0x50(%rbp), %rdi
movl $0x88, %esi
callq 0x3260
jmp 0x3c8a
jmp 0x3c8c
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x4c80
movq %rax, -0x20(%rbp)
jmp 0x3bc1
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x4cc0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x4d20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4cf0
testb $0x1, %al
jne 0x3cd5
jmp 0x3d16
leaq -0x28(%rbp), %rdi
callq 0x4d50
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x3d03
movq -0x58(%rbp), %rdi
callq 0x4d70
movq -0x58(%rbp), %rdi
movl $0x48, %esi
callq 0x3260
jmp 0x3d05
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x4da0
movq %rax, -0x38(%rbp)
jmp 0x3cb1
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
callq 0x4b50
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
callq 0x4b70
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x3160
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4c70
nopl (%rax,%rax)
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::path[abi:cxx11]()
std::string virt::fs::directory::path(){
	std::stack<std::string> mark;
	virt::fs::directory* it = this;
	while (it->parent != NULL && it->parent != it){
		mark.push(it->name);
		it = it->parent;
	}
	std::string full_path("");
	while (!mark.empty()){
		full_path = full_path + mark.top() + "/";
		mark.pop();
	}
	return "/" + full_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4de0
movq -0xe8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0xf9(%rbp)
je 0x3db9
movq -0x68(%rbp), %rax
movq (%rax), %rax
cmpq -0x68(%rbp), %rax
setne %al
movb %al, -0xf9(%rbp)
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x3dc5
jmp 0x3df6
movq -0x68(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x4e10
jmp 0x3dd8
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x3d93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x3f6e
leaq -0x99(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x3400
movq -0x108(%rbp), %rdx
leaq 0xffb6(%rip), %rsi      # 0x13dcd
leaq -0x98(%rbp), %rdi
callq 0x4980
jmp 0x3e25
leaq -0x99(%rbp), %rdi
callq 0x32b0
leaq -0x60(%rbp), %rdi
callq 0x4e40
movb %al, -0x109(%rbp)
jmp 0x3e42
movb -0x109(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3e53
jmp 0x3f21
leaq -0x60(%rbp), %rdi
callq 0x4f30
movq %rax, -0x118(%rbp)
jmp 0x3e65
movq -0x118(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4eb0
jmp 0x3e81
leaq 0xf17f(%rip), %rdx      # 0x13007
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x4e60
jmp 0x3e9d
leaq -0x98(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movq %rsi, -0x120(%rbp)
callq 0x3300
movq -0x120(%rbp), %rdi
callq 0x3160
leaq -0xe0(%rbp), %rdi
callq 0x3160
leaq -0x60(%rbp), %rdi
callq 0x4f50
jmp 0x3eda
jmp 0x3e31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x99(%rbp), %rdi
callq 0x32b0
jmp 0x3f6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x3f62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3160
jmp 0x3f62
movq -0xf8(%rbp), %rdi
leaq 0xf0d8(%rip), %rsi      # 0x13007
leaq -0x98(%rbp), %rdx
callq 0x4f70
jmp 0x3f3d
leaq -0x98(%rbp), %rdi
callq 0x3160
leaq -0x60(%rbp), %rdi
callq 0x5080
movq -0xf0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x3160
leaq -0x60(%rbp), %rdi
callq 0x5080
movq -0x70(%rbp), %rdi
callq 0x33f0
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::add_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool virt::fs::directory::add_subdir(std::string dirname, bool forced){
	if (!forced)
		if (subdir.find(dirname) != subdir.end())
			return false; 

	if (files.find(dirname) != files.end())
		return false;

	virt::fs::directory* new_subdir = new virt::fs::directory(this, dirname);
	this->remove_subdir(dirname);
	this->subdir[dirname] = new_subdir;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x40af
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x28, %rdi
callq 0x50a0
movq -0xa0(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x4bf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4bc0
testb $0x1, %al
jne 0x40a4
jmp 0x40ad
movb $0x0, -0x1(%rbp)
jmp 0x4217
jmp 0x40af
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x58, %rdi
callq 0x51b0
movq -0xa0(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x58, %rdi
callq 0x4d20
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4cf0
testb $0x1, %al
jne 0x40f1
jmp 0x40fa
movb $0x0, -0x1(%rbp)
jmp 0x4217
movl $0x88, %edi
callq 0x3250
movq -0xa8(%rbp), %rsi
movq %rax, -0xb0(%rbp)
movb $0x1, -0x75(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x30f0
jmp 0x4121
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x38e0
jmp 0x413a
movb $0x0, -0x75(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rsi
movq %rax, -0x48(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x30f0
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x4230
jmp 0x4181
leaq -0x98(%rbp), %rdi
callq 0x3160
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x48(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x28, %rdi
callq 0x50d0
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4217
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x41e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
testb $0x1, -0x75(%rbp)
jne 0x41ea
jmp 0x41fb
movq -0xb0(%rbp), %rdi
movl $0x88, %esi
callq 0x3260
jmp 0x4225
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3160
jmp 0x4225
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x33f0
nop
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::remove_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::fs::directory::remove_subdir(std::string dirname){
	std::map<std::string, virt::fs::directory*>::iterator it = subdir.find(dirname);
	if (it == subdir.end())
		return false;
	
	delete (*it).second;
	subdir.erase(dirname);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
callq 0x50a0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x4bf0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5250
testb $0x1, %al
jne 0x427d
jmp 0x4283
movb $0x0, -0x1(%rbp)
jmp 0x42c6
leaq -0x20(%rbp), %rdi
callq 0x4c50
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x42b1
movq -0x40(%rbp), %rdi
callq 0x3ba0
movq -0x40(%rbp), %rdi
movl $0x88, %esi
callq 0x3260
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x5280
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::add_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool virt::fs::directory::add_file(std::string filename, std::string content, bool forced){
	if (!forced)
		if (this->files.find(filename) != this->files.end())
			return false;

	if (this->subdir.find(filename) != this->subdir.end())
		return false;

	virt::fs::file* temp = new virt::fs::file(this, filename);
	temp->content = content;
	this->remove_file(filename);
	this->files[filename] = temp;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rsi, -0xb0(%rbp)
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x45ea
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq $0x58, %rdi
callq 0x51b0
movq -0xa8(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x58, %rdi
callq 0x4d20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4cf0
testb $0x1, %al
jne 0x45df
jmp 0x45e8
movb $0x0, -0x1(%rbp)
jmp 0x4766
jmp 0x45ea
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
addq $0x28, %rdi
callq 0x50a0
movq -0xa8(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
callq 0x4bf0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4bc0
testb $0x1, %al
jne 0x462c
jmp 0x4635
movb $0x0, -0x1(%rbp)
jmp 0x4766
movl $0x48, %edi
callq 0x3250
movq -0xb0(%rbp), %rsi
movq %rax, -0xc0(%rbp)
movb $0x1, -0x7d(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x30f0
jmp 0x465c
movq -0xa8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0xa430
jmp 0x4675
movb $0x0, -0x7d(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
movq -0xc0(%rbp), %rax
movq -0xb8(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0x3040
movq -0xb0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x30f0
movq -0xa8(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x48d0
jmp 0x46d0
leaq -0xa0(%rbp), %rdi
callq 0x3160
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0x50(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x58, %rdi
callq 0x52b0
movq -0xd0(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4766
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x4731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3160
testb $0x1, -0x7d(%rbp)
jne 0x4739
jmp 0x474a
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x3260
jmp 0x4774
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3160
jmp 0x4774
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::move_subdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, virt::fs::directory*, virt::fs::directory*)
bool virt::fs::move_subdir(std::string dirname, virt::fs::directory* source, virt::fs::directory* destination){
	if (dirname == "" || dirname == "." || dirname == "..")
		return false;

	std::map<std::string, virt::fs::directory*>::iterator it = source->subdir.find(dirname);
	if (it == source->subdir.end())
		return false;

	virt::fs::directory* temp = (*it).second;

	destination->remove_subdir(dirname); 
	destination->subdir[dirname] = temp;

	source->subdir.erase(dirname);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xf62b(%rip), %rsi      # 0x13dcd
callq 0x5200
testb $0x1, %al
jne 0x47d5
movq -0x70(%rbp), %rdi
leaq 0xe84f(%rip), %rsi      # 0x13005
callq 0x5200
testb $0x1, %al
jne 0x47d5
movq -0x70(%rbp), %rdi
leaq 0xe83a(%rip), %rsi      # 0x13004
callq 0x5200
testb $0x1, %al
jne 0x47d5
jmp 0x47de
movb $0x0, -0x1(%rbp)
jmp 0x48b6
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x50a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x4bf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5250
testb $0x1, %al
jne 0x4817
jmp 0x4820
movb $0x0, -0x1(%rbp)
jmp 0x48b6
leaq -0x28(%rbp), %rdi
callq 0x4c50
movq -0x70(%rbp), %rsi
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30f0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4230
jmp 0x4859
leaq -0x58(%rbp), %rdi
callq 0x3160
movq -0x70(%rbp), %rsi
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x50d0
movq -0x88(%rbp), %rcx
movq -0x70(%rbp), %rsi
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x5280
movb $0x1, -0x1(%rbp)
jmp 0x48b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3160
jmp 0x48c4
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: FalconUA[P]vfs/vfs/directory.cpp
// Function: virt::fs::directory::remove_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool virt::fs::directory::remove_file(std::string filename){
	std::map<std::string, virt::fs::file*>::iterator it = files.find(filename);
	if (it == files.end())
		return false;
	
	delete (*it).second;
	files.erase(filename);
	return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x58, %rdi
callq 0x51b0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x58, %rdi
callq 0x4d20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5390
testb $0x1, %al
jne 0x491d
jmp 0x4923
movb $0x0, -0x1(%rbp)
jmp 0x4966
leaq -0x20(%rbp), %rdi
callq 0x4d50
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4951
movq -0x40(%rbp), %rdi
callq 0x4d70
movq -0x40(%rbp), %rdi
movl $0x48, %esi
callq 0x3260
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
callq 0x53c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: FalconUA[P]vfs/vfs/filesystem.cpp
// Function: virt::filesystem::directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
virt::filesystem::dir_iterator virt::filesystem::directory(std::string absolute_path){
	std::stringstream ss(absolute_path);
	std::string token;

	virt::filesystem::dir_iterator iterator = this->root();	
	iterator.move_to(absolute_path);
	return iterator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, -0x218(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x210(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xaaf0
movq -0x218(%rbp), %rsi
movl %eax, %edx
leaq -0x1a8(%rbp), %rdi
callq 0x33b0
leaq -0x1c8(%rbp), %rdi
callq 0x3360
movq -0x210(%rbp), %rdi
callq 0xa610
movq %rdx, -0x208(%rbp)
movq %rax, -0x200(%rbp)
jmp 0xa6b1
movq -0x218(%rbp), %rsi
movq -0x208(%rbp), %rax
movq -0x200(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x30f0
jmp 0xa6dc
leaq -0x10(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xa780
jmp 0xa6ee
leaq -0x1f8(%rbp), %rdi
callq 0x3160
leaq -0x1c8(%rbp), %rdi
callq 0x3160
leaq -0x1a8(%rbp), %rdi
callq 0x31c0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xa755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x3160
leaq -0x1c8(%rbp), %rdi
callq 0x3160
leaq -0x1a8(%rbp), %rdi
callq 0x31c0
movq -0x1d0(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xaae4
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xaeb0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xaee0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xae80
testb $0x1, %al
jne 0xabd9
jmp 0xabdf
movb $0x0, -0x1(%rbp)
jmp 0xabff
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0xaf10
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xaeb0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xaee0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaff0
testb $0x1, %al
jne 0xac55
jmp 0xac5b
movb $0x0, -0x1(%rbp)
jmp 0xac6c
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xb020
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xaeb0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xaee0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xaff0
testb $0x1, %al
jne 0xacc5
jmp 0xaccf
movq $0x0, -0x8(%rbp)
jmp 0xace3
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xaf10
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x30f0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0xac80
movq %rax, -0xb0(%rbp)
jmp 0xf517
leaq -0x38(%rbp), %rdi
callq 0x3160
movq -0xb0(%rbp), %rax
cmpq $0x0, %rax
jne 0xf54c
jmp 0xf5f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0xf64a
movq -0xd8(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x30f0
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0xac80
movq %rax, -0xe0(%rbp)
jmp 0xf594
movq -0xd0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x30f0
jmp 0xf5a9
movq -0xe0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq *%rax
jmp 0xf5c5
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0x88(%rbp), %rdi
callq 0x3160
movq 0xc9ec(%rip), %rdi      # 0x1bfd0
leaq -0x68(%rbp), %rsi
callq 0x3210
jmp 0xf5ef
leaq -0x68(%rbp), %rdi
callq 0x3160
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xf627
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3160
leaq -0x88(%rbp), %rdi
callq 0x3160
jmp 0xf64a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
movq -0x40(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: ReadScene(char const*)
static R3Scene *
ReadScene(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate scene
  R3Scene *scene = new R3Scene();
  if (!scene) {
    RNFail("Unable to allocate scene for %s\n", filename);
    return NULL;
  }

  // Read scene from file
  if (!scene->ReadFile(filename)) {
    delete scene;
    return NULL;
  }

  // Print statistics
  if (print_verbose) {
    printf("Read scene from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Nodes = %d\n", scene->NNodes());
    printf("  # Lights = %d\n", scene->NLights());
    printf("  # Materials = %d\n", scene->NMaterials());
    printf("  # Brdfs = %d\n", scene->NBrdfs());
    printf("  # Textures = %d\n", scene->NTextures());
    printf("  # Referenced models = %d\n", scene->NReferencedScenes());
    fflush(stdout);
  }

  // Return scene
  return scene;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x120570
movq 0x10(%rsp), %rdi
callq 0x2a970
movl $0x160, %edi            # imm = 0x160
callq 0x23990
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x2b070
jmp 0x2914e
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x291a3
movq 0x48(%rsp), %rsi
leaq 0x197004(%rip), %rdi    # 0x1c0170
movb $0x0, %al
callq 0x1254f0
movq $0x0, 0x50(%rsp)
jmp 0x292df
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x160, %esi            # imm = 0x160
callq 0x239b0
jmp 0x292e9
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d6d0
cmpl $0x0, %eax
jne 0x291f2
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x291e4
movq 0x8(%rsp), %rdi
callq 0x2b2f0
movq 0x8(%rsp), %rdi
movl $0x160, %esi            # imm = 0x160
callq 0x239b0
movq $0x0, 0x50(%rsp)
jmp 0x292df
cmpl $0x0, 0x2132af(%rip)    # 0x23c4a8
je 0x292d5
movq 0x48(%rsp), %rsi
leaq 0x196f86(%rip), %rdi    # 0x1c0191
movb $0x0, %al
callq 0x23090
leaq 0x38(%rsp), %rdi
callq 0x120630
leaq 0x196f86(%rip), %rdi    # 0x1c01a9
movb $0x1, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2a990
movl %eax, %esi
leaq 0x196f83(%rip), %rdi    # 0x1c01c0
movb $0x0, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2a9b0
movl %eax, %esi
leaq 0x196f79(%rip), %rdi    # 0x1c01d0
movb $0x0, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2a9d0
movl %eax, %esi
leaq 0x196f70(%rip), %rdi    # 0x1c01e1
movb $0x0, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2a9f0
movl %eax, %esi
leaq 0x196f6a(%rip), %rdi    # 0x1c01f5
movb $0x0, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2aa10
movl %eax, %esi
leaq 0x196f60(%rip), %rdi    # 0x1c0205
movb $0x0, %al
callq 0x23090
movq 0x30(%rsp), %rdi
callq 0x2aa30
movl %eax, %esi
leaq 0x196f59(%rip), %rdi    # 0x1c0218
movb $0x0, %al
callq 0x23090
movq 0x203cc3(%rip), %rax    # 0x22cf90
movq (%rax), %rdi
callq 0x23ba0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x24210
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: ReadCategories(gaps::R3Scene*, char const*)
static int
ReadCategories(R3Scene *scene, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Read file
  if (!scene->ReadSUNCGModelFile(filename)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Read categories from %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0x120570
movq %rsp, %rdi
callq 0x2a970
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x40e40
cmpl $0x0, %eax
jne 0x2933c
movl $0x0, 0x24(%rsp)
jmp 0x29385
cmpl $0x0, 0x213165(%rip)    # 0x23c4a8
je 0x2937d
movq 0x10(%rsp), %rsi
leaq 0x196ee3(%rip), %rdi    # 0x1c0234
movb $0x0, %al
callq 0x23090
movq %rsp, %rdi
callq 0x120630
leaq 0x196e42(%rip), %rdi    # 0x1c01a9
movb $0x1, %al
callq 0x23090
movq 0x203c1b(%rip), %rax    # 0x22cf90
movq (%rax), %rdi
callq 0x23ba0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: RemoveNodes(gaps::R3Scene*)
static int
RemoveNodes(R3Scene *scene)
{
  // Find select subtree node
  R3SceneNode *select_subtree_node = NULL;
  if (select_nodes_in_subtree_name) {
    select_subtree_node = scene->Node(select_nodes_in_subtree_name);
    if (!select_subtree_node) {
      RNFail("Unable to find select subtree node %s\n", select_nodes_in_subtree_name);
      return 0;
    }
  }

  // Read select grid
  R3Grid *select_grid = NULL;
  if (select_nodes_in_grid_filename) {
    select_grid = ReadGrid(select_nodes_in_grid_filename);
    if (!select_grid) return 0;
  }

  // Remove nodes recursively in post order
  RemoveNodes(scene, scene->Root(), select_subtree_node, select_grid, select_nodes_in_bbox);

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x21301e(%rip)    # 0x23c478
je 0x2949b
movq 0x18(%rsp), %rdi
movq 0x213010(%rip), %rsi    # 0x23c478
callq 0x2b3c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x29499
movq 0x212ff7(%rip), %rsi    # 0x23c478
leaq 0x196de2(%rip), %rdi    # 0x1c026a
movb $0x0, %al
callq 0x1254f0
movl $0x0, 0x24(%rsp)
jmp 0x2950b
jmp 0x2949b
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x212fd4(%rip)    # 0x23c480
je 0x294d3
movq 0x212fcb(%rip), %rdi    # 0x23c480
callq 0x29750
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x294d1
movl $0x0, 0x24(%rsp)
jmp 0x2950b
jmp 0x294d3
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x2a470
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x212e1a(%rip), %r8     # 0x23c318
callq 0x29980
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: WriteScene(gaps::R3Scene*, char const*)
static int
WriteScene(R3Scene *scene, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write scene from file
  if (!scene->WriteFile(filename)) return 1;

  // Print statistics
  if (print_verbose) {
    printf("Wrote scene to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Nodes = %d\n", scene->NNodes());
    printf("  # Lights = %d\n", scene->NLights());
    printf("  # Materials = %d\n", scene->NMaterials());
    printf("  # Brdfs = %d\n", scene->NBrdfs());
    printf("  # Textures = %d\n", scene->NTextures());
    printf("  # Referenced models = %d\n", scene->NReferencedScenes());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0x120570
movq %rsp, %rdi
callq 0x2a970
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x38df0
cmpl $0x0, %eax
jne 0x2955f
movl $0x1, 0x24(%rsp)
jmp 0x29648
cmpl $0x0, 0x212f42(%rip)    # 0x23c4a8
je 0x29640
movq 0x10(%rsp), %rsi
leaq 0x196de6(%rip), %rdi    # 0x1c035e
movb $0x0, %al
callq 0x23090
movq %rsp, %rdi
callq 0x120630
leaq 0x196c1b(%rip), %rdi    # 0x1c01a9
movb $0x1, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2a990
movl %eax, %esi
leaq 0x196c18(%rip), %rdi    # 0x1c01c0
movb $0x0, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2a9b0
movl %eax, %esi
leaq 0x196c0e(%rip), %rdi    # 0x1c01d0
movb $0x0, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2a9d0
movl %eax, %esi
leaq 0x196c05(%rip), %rdi    # 0x1c01e1
movb $0x0, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2a9f0
movl %eax, %esi
leaq 0x196bff(%rip), %rdi    # 0x1c01f5
movb $0x0, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2aa10
movl %eax, %esi
leaq 0x196bf5(%rip), %rdi    # 0x1c0205
movb $0x0, %al
callq 0x23090
movq 0x18(%rsp), %rdi
callq 0x2aa30
movl %eax, %esi
leaq 0x196bee(%rip), %rdi    # 0x1c0218
movb $0x0, %al
callq 0x23090
movq 0x203958(%rip), %rax    # 0x22cf90
movq (%rax), %rdi
callq 0x23ba0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x19f1b9(%rip), %rsi    # 0x1c8833
callq 0x23bb0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x296ac
movq 0x20(%rsp), %rsi
leaq 0x196ab8(%rip), %rdi    # 0x1c0150
movb $0x0, %al
callq 0x1254f0
movl $0x0, 0x34(%rsp)
jmp 0x29738
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x29726
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x29717
movq 0x18(%rsp), %rdi
leaq 0x19b442(%rip), %rsi    # 0x1c4b18
leaq 0x8(%rsp), %rdx
movb $0x0, %al
callq 0x242e0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2a950
movsd (%rsp), %xmm0
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x296c3
jmp 0x29719
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x296b4
movq 0x18(%rsp), %rdi
callq 0x23980
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scn2scn/scn2scn.cpp
// Function: Overlap(gaps::R3SceneNode*, gaps::R3Grid*)
static RNScalar
Overlap(R3SceneNode *node, R3Grid *grid)
{
  RNScalar overlap_area = 0;
  RNScalar total_area = 0;
  R3Affine parent_transformation = node->CumulativeParentTransformation();
  CountOverlapAreas(node, grid, parent_transformation, overlap_area, total_area);
  if (total_area < RN_EPSILON) return 0;
  return overlap_area / total_area;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq $0x0, 0x138(%rsp)
movq $0x0, 0x130(%rsp)
movq 0x148(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x562f0
movq 0x8(%rsp), %rdx
movq 0x148(%rsp), %rdi
movq 0x140(%rsp), %rsi
leaq 0x138(%rsp), %rcx
leaq 0x130(%rsp), %r8
callq 0x29ee0
jmp 0x29e42
movsd 0x130(%rsp), %xmm1
leaq 0x20cbd6(%rip), %rax    # 0x236a28
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29e8c
xorps %xmm0, %xmm0
movsd %xmm0, 0x150(%rsp)
movl $0x1, 0x10(%rsp)
jmp 0x29eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xc0b70
jmp 0x29eca
movsd 0x138(%rsp), %xmm0
divsd 0x130(%rsp), %xmm0
movsd %xmm0, 0x150(%rsp)
movl $0x1, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xc0b70
movsd 0x150(%rsp), %xmm0
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x18(%rsp), %rdi
callq 0x24210
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x49d0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x49d0
cmpq $0x0, (%rax)
jne 0x6dfc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6d90
jmp 0x6dfe
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6dcb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3480
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3130
movb %al, -0x271(%rbp)
jmp 0x6f14
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x6f20
jmp 0x6f98
movq 0x10099(%rip), %rdi     # 0x16fc0
leaq 0x824b(%rip), %rsi      # 0xf179
callq 0x3290
movq %rax, -0x280(%rbp)
jmp 0x6f3c
movq -0x280(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3290
movq %rax, -0x288(%rbp)
jmp 0x6f55
movq -0x288(%rbp), %rdi
movq 0x1004d(%rip), %rsi     # 0x16fb0
callq 0x32e0
jmp 0x6f6a
movq $0x0, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x7125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x713e
xorl %eax, %eax
movl %eax, %esi
leaq -0x218(%rbp), %rdi
movl $0x2, %edx
callq 0x33a0
jmp 0x6faf
leaq -0x218(%rbp), %rdi
callq 0x3440
movq %rdx, -0x298(%rbp)
movq %rax, -0x290(%rbp)
jmp 0x6fcb
movq -0x298(%rbp), %rax
movq -0x290(%rbp), %rcx
movq %rcx, -0x240(%rbp)
movq %rax, -0x238(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x8070
movq %rax, -0x2a0(%rbp)
jmp 0x6ffc
movq -0x2a0(%rbp), %rax
movl %eax, -0x22c(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x33a0
jmp 0x701b
movslq -0x22c(%rbp), %rax
movq %rax, -0x2b0(%rbp)
leaq -0x261(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
callq 0x3460
movq -0x2b0(%rbp), %rsi
movq -0x2a8(%rbp), %rcx
leaq -0x260(%rbp), %rdi
xorl %edx, %edx
callq 0x50d0
jmp 0x705a
leaq -0x261(%rbp), %rdi
callq 0x3300
xorl %eax, %eax
movl %eax, %esi
leaq -0x260(%rbp), %rdi
callq 0x34c0
movq %rax, -0x2b8(%rbp)
jmp 0x707f
movq -0x2b8(%rbp), %rsi
movslq -0x22c(%rbp), %rdx
leaq -0x218(%rbp), %rdi
callq 0x3380
jmp 0x709b
movq $0x0, -0x270(%rbp)
leaq -0x260(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x7160
movq %rax, -0x2c0(%rbp)
jmp 0x70c2
movq -0x2c0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x3190
jmp 0x7125
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x261(%rbp), %rdi
callq 0x3300
jmp 0x713e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x3190
jmp 0x713e
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x8(%rbp), %rax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3090
movq -0x220(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x35(%rbp)
jae 0x71d3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
subq $0x1, %rsi
callq 0x34c0
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x71df
jmp 0x728f
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x34c0
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x7212
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7160
movq %rax, -0x28(%rbp)
jmp 0x7227
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x7bd0
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x32a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rsi
callq 0x6b20
jmp 0x7246
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x718e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x10, %esi
callq 0x32b0
jmp 0x72a6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7bd0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3450
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbf5(%rip), %rsi       # 0x86e0
callq 0x30d0
movq %rax, -0x28(%rbp)
movl $0x6, %edi
callq 0x8710
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x3400
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7ba9
movq -0x10(%rbp), %rdi
leaq 0x768a(%rip), %rsi      # 0xf1b0
callq 0x3290
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7b78
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x7ad0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7b68
movq -0x10(%rbp), %rdi
leaq 0x764f(%rip), %rsi      # 0xf1b2
callq 0x3290
jmp 0x7b6a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b36
movq -0x10(%rbp), %rdi
leaq 0x7667(%rip), %rsi      # 0xf1ea
callq 0x3290
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0x7612(%rip), %rsi      # 0xf1b4
callq 0x3290
jmp 0x7bc9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0x75f0(%rip), %rsi      # 0xf1b4
callq 0x3290
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x75f3(%rip), %rsi      # 0xf1ec
callq 0x3140
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
subq %rdx, %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x32c0
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xa0(%rbp)
movl $0x3a, %esi
callq 0x31a0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x32c0
jmp 0x7c6c
xorps %xmm0, %xmm0
movss %xmm0, -0x78(%rbp)
cmpq $-0x1, -0x48(%rbp)
je 0x7d25
leaq -0x40(%rbp), %rdi
callq 0x3200
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x7d25
movq -0x48(%rbp), %rdx
incq %rdx
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq $-0x1, %rcx
callq 0x32c0
jmp 0x7cb4
xorl %eax, %eax
movl %eax, %esi
leaq -0x98(%rbp), %rdi
callq 0x8810
movss %xmm0, -0xac(%rbp)
jmp 0x7cce
movss -0xac(%rbp), %xmm0
movss %xmm0, -0x78(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3190
jmp 0x7d25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7d9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3190
jmp 0x7d92
movl $0x38, %edi
callq 0x32a0
movq %rax, -0xb8(%rbp)
jmp 0x7d38
movq -0xb8(%rbp), %rdi
movss -0x78(%rbp), %xmm0
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rsi
callq 0x6b90
jmp 0x7d53
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl $0x38, %esi
callq 0x32b0
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0x70(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1470
movq 0x2db6(%rip), %rdi      # 0x3fd8
leaq 0xddb(%rip), %rsi       # 0x2004
callq 0x1060
movq %rax, -0x68(%rbp)
jmp 0x1234
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1490
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x14c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1400
movl %eax, -0x6c(%rbp)
jmp 0x1264
movl -0x6c(%rbp), %esi
movq -0x68(%rbp), %rdi
callq 0x10a0
movq %rax, -0x80(%rbp)
jmp 0x1276
movq -0x80(%rbp), %rdi
movq 0x2d47(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x1288
movq 0x2d49(%rip), %rdi      # 0x3fd8
leaq 0xd7c(%rip), %rsi       # 0x2012
callq 0x1060
movq %rax, -0x88(%rbp)
jmp 0x12a4
movq 0x2dc5(%rip), %rax      # 0x4070
movq %rax, -0x98(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1490
movq -0xa0(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x14c0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x8c(%rbp)
jmp 0x12f2
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdi
callq 0x10a0
movq %rax, -0xa8(%rbp)
jmp 0x130d
movq -0xa8(%rbp), %rdi
movq 0x2cad(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x1322
movq 0x2caf(%rip), %rdi      # 0x3fd8
leaq 0xcf2(%rip), %rsi       # 0x2022
callq 0x1060
movq %rax, -0xb0(%rbp)
jmp 0x133e
movq 0x2d2b(%rip), %rax      # 0x4070
movq %rax, -0xc0(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1490
movq -0xc8(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x14c0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movl %eax, -0xb4(%rbp)
jmp 0x138c
movl -0xb4(%rbp), %esi
movq -0xb0(%rbp), %rdi
callq 0x10a0
movq %rax, -0xd0(%rbp)
jmp 0x13a7
movq -0xd0(%rbp), %rdi
movq 0x2c13(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x13bc
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x14f0
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x14f0
movq -0x28(%rbp), %rdi
callq 0x10b0
nopw %cs:(%rax,%rax)