LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/main.cpp
// Function: main
int main() {

	bool running = true;
	string command;
	
	Directory root("/");
	FileSystem system(&root);

	cout << "Welcome to CSCI Shell Prompt!" << endl;

    while(running) {
    	cout << "prompt@CSCI-3232:" << system.getWorkingDirectory() << "$ ";
    	getline(cin, command);
    	parseCommand(command, system);
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x98(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x247d(%rip), %rsi      # 0x5004
leaq 0x2477(%rip), %rdx      # 0x5005
leaq -0xa8(%rbp), %rdi
callq 0x2f72
leaq -0x138(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3188
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x2bc8
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0xc0(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x3850
movq 0x53ee(%rip), %rbx      # 0x7fd0
leaq 0x2511(%rip), %rsi      # 0x50fa
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq 0x53bc(%rip), %rdi      # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x78(%rbp), %r15
movq 0x53a4(%rip), %rbx      # 0x7fd0
leaq -0xc0(%rbp), %r12
movq 0x53a6(%rip), %r14      # 0x7fe0
leaq -0x88(%rbp), %r13
movl $0x11, %edx
movq %rbx, %rdi
leaq 0x24c8(%rip), %rsi      # 0x5118
callq 0x21e0
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
callq 0x477e
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x21e0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x24aa(%rip), %rsi      # 0x512a
callq 0x21e0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2c9e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r14, %rdi
leaq -0x48(%rbp), %rsi
callq 0x22c0
movq %r15, -0x88(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x2ed4
movq %r13, %rdi
movq %r12, %rsi
callq 0x24dc
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x2c41
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x2c41
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x2d41
movq -0x78(%rbp), %rsi
jmp 0x2d32
jmp 0x2d3e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2d41
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x2d41
jmp 0x2d3e
movq %rax, %rbx
leaq 0x5000(%rip), %rax      # 0x7d48
addq $0x10, %rax
leaq -0xf8(%rbp), %r14
movq %rax, -0x40(%r14)
movq %r14, %rdi
callq 0x2e36
leaq 0x4fca(%rip), %rax      # 0x7d30
movq %rax, -0x40(%r14)
movq -0x38(%r14), %rdi
leaq -0x120(%rbp), %rax
cmpq %rax, %rdi
je 0x2da6
movq -0x120(%rbp), %rsi
jmp 0x2d99
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x2da6
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x2da6
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x48(%rbp), %rdi
cmpq %rax, %rdi
je 0x2dbf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::list()
void FileSystem::list() {
	cout << "Contents of " << currentDirectory->getName() <<":\n";

	map<string, Entity*>::iterator it;

	for(it = currentDirectory->children.begin(); it != currentDirectory->children.end(); it++ ) {
		if(it->second->isDirectory)
			cout << "[" + it->first + "]" << "   ";
		else
			cout << it->first << "   ";
	}

	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movq 0x4753(%rip), %r15      # 0x7fd0
leaq 0x18ed(%rip), %rsi      # 0x5171
movl $0xc, %edx
movq %r15, %rdi
callq 0x21e0
movq (%r14), %rsi
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x307c
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x21e0
leaq 0x18c8(%rip), %rsi      # 0x517e
movl $0x2, %edx
movq %rax, %rdi
callq 0x21e0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38dc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq (%r14), %rax
movq 0x58(%rax), %r15
addq $0x48, %rax
cmpq %rax, %r15
je 0x3a04
movq 0x46d9(%rip), %r12      # 0x7fd0
leaq 0x1887(%rip), %r13      # 0x5185
movq 0x40(%r15), %rax
cmpb $0x1, 0x31(%rax)
jne 0x3955
movq %r12, %rbx
leaq 0x20(%r15), %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
leaq 0x1864(%rip), %rsi      # 0x5181
callq 0x49ce
movq %r12, %rdi
leaq 0x1857(%rip), %rsi      # 0x5183
callq 0x22d0
leaq -0x38(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3977
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x397d
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %r12, %rdi
callq 0x21e0
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
jmp 0x39e9
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq %rbx, %r12
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x21e0
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39d0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x39e9
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
movq (%r14), %rax
addq $0x48, %rax
cmpq %rax, %r15
jne 0x38fe
movq 0x45c5(%rip), %rbx      # 0x7fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a91
movq -0x38(%rbp), %rsi
jmp 0x3a89
movq %rax, %rbx
jmp 0x3a78
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3a78
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3a91
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::makeFileSystem()
void FileSystem::makeFileSystem() {
	root->flushDirectory();
	currentDirectory = root;
	isFormatted = true;
	cout << "New file system created" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x32ca
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
movb $0x1, 0x10(%rbx)
movq 0x4508(%rip), %rbx      # 0x7fd0
leaq 0x16ba(%rip), %rsi      # 0x5189
movl $0x17, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::makeDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::makeDirectory(string dir) {
	if(!currentDirectory->contains(dir)) {
		Directory* tmp = new Directory(dir);
		currentDirectory->addChild(tmp);
		cout << "Directory " << dir << " created at " << tmp->getTime();
	} else {
		cout << "Error: directory " << dir << " already exists" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x2ed4
movq %r14, %rdi
movq %r12, %rsi
callq 0x32d8
movl %eax, %r14d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3dab
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r14b, %r14b
je 0x3e1d
movq 0x4219(%rip), %r14      # 0x7fd0
leaq 0x1468(%rip), %rsi      # 0x5226
movl $0x11, %edx
movq %r14, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0x1454(%rip), %rsi      # 0x5238
movl $0xf, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x3eed
movl $0x78, %edi
callq 0x21a0
movq %rax, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2ed4
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x3188
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e67
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3234
movq 0x4157(%rip), %r15      # 0x7fd0
leaq 0x138e(%rip), %rsi      # 0x520e
movl $0xa, %edx
movq %r15, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0x1373(%rip), %rsi      # 0x5219
movl $0xc, %edx
movq %rax, %rdi
callq 0x21e0
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x30aa
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x21e0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eed
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f51
movq -0x78(%rbp), %rsi
jmp 0x3f49
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3f2f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x3f2f
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
jmp 0x3f4c
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3f51
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::makeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::makeFile(string filename) {
	if(!currentDirectory->contains(filename)) {
		File* tmp = new File(filename);
		currentDirectory->addChild(tmp);
		cout << "File " << filename << " created at " << tmp->getTime();
	} else {
		cout << "Error: file " << filename << " already exists" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x2ed4
movq %r14, %rdi
movq %r12, %rsi
callq 0x32d8
movl %eax, %r14d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x41fd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r14b, %r14b
je 0x426f
movq 0x3dc7(%rip), %r14      # 0x7fd0
leaq 0x10a1(%rip), %rsi      # 0x52b1
movl $0xc, %edx
movq %r14, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0x1002(%rip), %rsi      # 0x5238
movl $0xf, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x433f
movl $0x40, %edi
callq 0x21a0
movq %rax, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2ed4
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x379c
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x42b9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3234
movq 0x3d05(%rip), %r15      # 0x7fd0
leaq 0xfd9(%rip), %rsi       # 0x52ab
movl $0x5, %edx
movq %r15, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0xf21(%rip), %rsi       # 0x5219
movl $0xc, %edx
movq %rax, %rdi
callq 0x21e0
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x30aa
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x21e0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x433f
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43a3
movq -0x78(%rbp), %rsi
jmp 0x439b
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4381
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x4381
movq %rax, %rbx
movl $0x40, %esi
movq %r14, %rdi
jmp 0x439e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x43a3
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::removeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::removeFile(string filename) {

	if(currentDirectory->contains(filename)) {
		if(!currentDirectory->children[filename]->isDirectory) {
			cout << "Deleting file " << filename << endl;
			delete currentDirectory->children[filename];
			currentDirectory->children.erase(filename);
		} else {
			cout << "Error: " << filename << " is a directory, not a file" << endl;
		}
	} else {
		cout << filename << ": No such file found" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x2ed4
movq %r15, %rdi
movq %r12, %rsi
callq 0x32d8
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4407
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r15b, %r15b
je 0x4463
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a60
movq (%rax), %rax
cmpb $0x0, 0x31(%rax)
je 0x44b9
movq 0x3ba1(%rip), %r14      # 0x7fd0
leaq 0xe97(%rip), %rsi       # 0x52cd
movl $0x7, %edx
movq %r14, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0xe79(%rip), %rsi       # 0x52d5
movl $0x1b, %edx
jmp 0x4485
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3b5f(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, %rbx
leaq 0xe71(%rip), %rsi       # 0x52f1
movl $0x14, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x4570
movq 0x3b10(%rip), %r15      # 0x7fd0
leaq 0xdf7(%rip), %rsi       # 0x52be
movl $0xe, %edx
movq %r15, %rdi
callq 0x21e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a60
movq (%rax), %r15
testq %r15, %r15
je 0x4546
leaq 0x3805(%rip), %rax      # 0x7d30
movq %rax, (%r15)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x4546
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movl $0x38, %esi
movq %r15, %rdi
callq 0x21b0
movq (%r14), %r14
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c02
movq %r14, %rdi
movq %rax, %rsi
callq 0x4cbe
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4597
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::stat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::stat(string filename) {
	if(currentDirectory->contains(filename)) {
		cout << "File " << currentDirectory->children[filename]->getName() << " created " << currentDirectory->children[filename]->getTime();
	} else {
		cout << filename << ": No such file found" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x2ed4
movq %r15, %rdi
movq %r12, %rsi
callq 0x32d8
movl %eax, %r15d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x45fb
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r15b, %r15b
je 0x46c7
movq 0x39c5(%rip), %r15      # 0x7fd0
leaq 0xc99(%rip), %rsi       # 0x52ab
movl $0x5, %edx
movq %r15, %rdi
callq 0x21e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a60
movq (%rax), %rsi
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x307c
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0xcab(%rip), %rsi       # 0x5306
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a60
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x30aa
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x21e0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46ac
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4718
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x4718
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x38fb(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, %rbx
leaq 0xc0d(%rip), %rsi       # 0x52f1
movl $0x14, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x474a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x474a
jmp 0x4747
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4775
movq -0x78(%rbp), %rsi
jmp 0x476d
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x4775
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::getWorkingDirectory[abi:cxx11]()
string FileSystem::getWorkingDirectory() {
	string dir = currentDirectory->getName();
	Directory* backtrack = currentDirectory;

	while(backtrack->hasParent) {
		backtrack = backtrack->getParent();
		dir = backtrack->getName() + "/" + dir;
	}

	return !dir.compare("/") ? dir : dir.substr(1, dir.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq (%rsi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x307c
movq (%rbx), %r14
cmpb $0x1, 0x70(%r14)
jne 0x48ea
leaq -0x60(%rbp), %r13
leaq -0x80(%rbp), %rbx
leaq -0xb0(%rbp), %r15
leaq -0x90(%rbp), %r12
movq %r14, %rdi
callq 0x32fc
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x307c
movq %r15, %rdi
leaq 0x81b(%rip), %rsi       # 0x5004
callq 0x22d0
movq %r13, -0x70(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x480e
movq %rdx, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4816
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x2090
movq %rbx, -0x90(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4864
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x486a
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x88(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x2210
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0x48a8
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x48bd
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x48df
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpb $0x0, 0x70(%r14)
jne 0x47c9
leaq 0x713(%rip), %rsi       # 0x5004
leaq -0x50(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x4919
leaq -0x50(%rbp), %rsi
movq 0x8(%rsi), %rcx
movl $0x1, %edx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x21c0
jmp 0x4937
movq -0x30(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2ed4
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4950
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4969
jmp 0x4969
movq %rax, %rbx
jmp 0x49ad
movq %rax, %rbx
jmp 0x498b
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x498b
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x49ad
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49c6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: tempStore()
KVStore* tempStore() {
    Value* v1 = new Value("muffin", (size_t)6);
    Value* v3 = new Value("carrot", (size_t)6);
    Key* k1 = new Key("payload_1", 0);
    Key* k3 = new Key("payload_3", 0);

    NetworkIP network;

    KVStore* kvs1 = new KVStore(1, 0, &network);
    kvs1->put(k1, v1);
    kvs1->put(k3, v3);
    return kvs1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x20, %edi
callq 0x7200
movq %rax, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rax)
leaq 0x23ec8(%rip), %r12     # 0x2b3e0
movq %r12, (%rax)
leaq 0x18b6e(%rip), %rax     # 0x20090
movq %rax, 0x10(%rbx)
movl $0x6, %r13d
movq %r13, 0x18(%rbx)
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
movq %r15, 0x8(%rax)
movq %r12, (%rax)
leaq 0x18b4c(%rip), %rax     # 0x20097
movq %rax, 0x10(%r14)
movq %r13, 0x18(%r14)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
leaq 0x18b37(%rip), %rsi     # 0x2009e
movq %rax, %rdi
xorl %edx, %edx
callq 0xac04
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
leaq 0x18b23(%rip), %rsi     # 0x200a8
movq %rax, %rdi
xorl %edx, %edx
callq 0xac04
xorl %eax, %eax
movq %rax, -0x68(%rbp)
leaq 0x23fe4(%rip), %rcx     # 0x2b580
movq %rcx, -0x70(%rbp)
movq $0x1, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq %rax, -0x30(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7200
movq %rax, %r13
leaq -0x70(%rbp), %rcx
movl $0x1, %esi
movq %rax, %rdi
xorl %edx, %edx
callq 0xacb6
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xadc6
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xadc6
leaq 0x23f8d(%rip), %rax     # 0x2b580
movq %rax, -0x70(%rbp)
movl -0x48(%rbp), %edi
callq 0x7370
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7653
movq %rax, %rbx
movq %r13, %rdi
callq 0x71d0
jmp 0x7638
movq %rax, %rbx
movq %r12, %rdi
jmp 0x762e
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
jmp 0x764b
movq %rax, %rbx
leaq 0x23f41(%rip), %rax     # 0x2b580
movq %rax, -0x70(%rbp)
movl -0x48(%rbp), %edi
callq 0x7370
movq %rbx, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x11518
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testFloatArraySerialization()
void testFloatArraySerialization() {
    Sys* tester = new Sys();
    Deserializable* ds = new Deserializable();
    FloatArray* fa = new FloatArray(60);
    for(int i = 0; i < 50; i++) {
        fa->pushBack(i);
    }
    char* float_is_serialized = fa->serialize();
    FloatArray* fa_two = dynamic_cast<FloatArray*>(ds->deserialize(float_is_serialized));
    tester->t_true(strcmp(float_is_serialized, fa_two->serialize()) == 0);
    delete fa;
    tester->OK("Passed Float Array Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %r14
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x8(%r15)
leaq 0x23ae5(%rip), %rcx     # 0x2b958
movq %rcx, (%r15)
movq %rax, 0x18(%r15)
movq $0x3c, 0x20(%r15)
movl $0xf0, %edi
callq 0x7030
movq %rax, 0x10(%r15)
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
cmpl $0x32, %ecx
jne 0x7e92
movq %rcx, 0x18(%r15)
movq %r15, %rdi
callq 0x12e04
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c7b4
leaq 0x23449(%rip), %rsi     # 0x2b310
leaq 0x234a2(%rip), %rdx     # 0x2b370
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7230
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x7f20
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18245(%rip), %rsi     # 0x20145
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1879d(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testFloatColumnSerialization()
void testFloatColumnSerialization() {
    Deserializable* ds = new Deserializable();
    Sys* tester = new Sys();
    FloatColumn* fa = new FloatColumn(60);
    for(int i = 0; i < 50; i++) {
        fa->push_back(i);
    }
    char* float_is_serialized = fa->serialize();
    FloatColumn* fa_two = dynamic_cast<FloatColumn*>(ds->deserialize(float_is_serialized));
    tester->t_true(strcmp(float_is_serialized, fa_two->serialize()) == 0);
    delete fa;
    tester->OK("Passed Float Array Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %r14
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
xorl %r12d, %r12d
movq %rax, %rdi
movl $0x3c, %esi
xorl %eax, %eax
callq 0xb0f2
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
cmpl $0x32, %r12d
jne 0x7f90
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c7b4
leaq 0x2334a(%rip), %rsi     # 0x2b310
leaq 0x233bb(%rip), %rdx     # 0x2b388
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7230
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x801f
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18146(%rip), %rsi     # 0x20145
movq %r14, %rdi
callq 0x12738
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1869e(%rip), %rsi     # 0x206c4
movq %r14, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testIntArraySerialization()
void testIntArraySerialization() {
    Sys* tester = new Sys();
    Deserializable* ds = new Deserializable();
    IntArray* ia = new IntArray(100);
    for(int i = 0; i < 100; i++) {
        ia->pushBack(i);
    }
    char* int_is_serialized = ia->serialize();
    IntArray* ia_two = dynamic_cast<IntArray*>(ds->deserialize(int_is_serialized));
    tester->t_true(strcmp(int_is_serialized, ia_two->serialize()) == 0);
    delete ia;
    tester->OK("Passed Int Array Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %r14
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x8(%r15)
leaq 0x23a06(%rip), %rcx     # 0x2ba90
movq %rcx, (%r15)
movq %rax, 0x18(%r15)
movq $0x64, 0x20(%r15)
movl $0x190, %edi            # imm = 0x190
callq 0x7030
movq %rax, 0x10(%r15)
xorl %ecx, %ecx
movl %ecx, (%rax,%rcx,4)
incq %rcx
cmpl $0x64, %ecx
jne 0x80a9
movq %rcx, 0x18(%r15)
movq %r15, %rdi
callq 0x135a6
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c7b4
leaq 0x2323b(%rip), %rsi     # 0x2b310
leaq 0x232c4(%rip), %rdx     # 0x2b3a0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7230
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x812e
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x1805e(%rip), %rsi     # 0x2016c
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1858f(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testIntColumnSerialization()
void testIntColumnSerialization() {
    Sys* tester = new Sys();
    Deserializable* ds = new Deserializable();
    IntColumn* ia = new IntColumn(120);
    for(int i = 0; i < 100; i++) {
        ia->push_back(i);
    }
    char* int_is_serialized = ia->serialize();
    IntColumn* ia_two = dynamic_cast<IntColumn*>(ds->deserialize(int_is_serialized));
    tester->t_true(strcmp(int_is_serialized, ia_two->serialize()) == 0);
    delete ia;
    tester->OK("Passed Int Column Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %r14
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
xorl %r12d, %r12d
movq %rax, %rdi
movl $0x78, %esi
xorl %eax, %eax
callq 0xb2aa
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
cmpl $0x64, %r12d
jne 0x819e
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c7b4
leaq 0x2313c(%rip), %rsi     # 0x2b310
leaq 0x231dd(%rip), %rdx     # 0x2b3b8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7230
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x822d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x17f84(%rip), %rsi     # 0x20191
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x18490(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testMessageSerialization()
void testMessageSerialization() {
    Sys* tester = new Sys();
    Message* msg = new Message(1, 2, 3, 5);
    char* msg_serialized = msg->serialize();
    Message* msg_two = new Message(msg_serialized);
    char* expected = "{ 'Message' : { 'kind_' : '1', 'sender_' : '2', 'target_' : '3', 'id_' : '5',  } }";
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->t_true(strcmp(msg_serialized, expected) == 0);
    tester->OK("Passed Message Serialization Tests");
    delete tester;
    delete msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x30, %edi
callq 0x7200
movq %rax, %r14
movq $0x0, 0x8(%rax)
leaq 0x2393b(%rip), %rax     # 0x2bbc8
movq %rax, (%r14)
movl $0x1, 0x10(%r14)
movq $0x2, 0x18(%r14)
movq $0x3, 0x20(%r14)
movq $0x5, 0x28(%r14)
movq %r14, %rdi
callq 0x13bda
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xb45c
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8327
leaq 0x17ec4(%rip), %rsi     # 0x201b7
movq %r15, %rdi
callq 0x7290
testl %eax, %eax
jne 0x8327
leaq 0x17f04(%rip), %rsi     # 0x2020a
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
leaq 0x18396(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testAckSerialization()
void testAckSerialization() {
    Sys* tester = new Sys();
    Ack ack(1,2,3);
    char* msg_serialized = ack.serialize();
    Ack* msg_two = new Ack(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Ack Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x23898(%rip), %rax     # 0x2bc18
movq %rax, (%rdi)
movl $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xb7b8
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb89c
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8405
leaq 0x17e4c(%rip), %rsi     # 0x2022d
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x182b8(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testNackSerialization()
void testNackSerialization() {
    Sys* tester = new Sys();
    Nack ack(1,2,3);
    char* msg_serialized = ack.serialize();
    Nack* msg_two = new Nack(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Nack Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x23822(%rip), %rax     # 0x2bc80
movq %rax, (%rdi)
movl $0x1, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xbbf8
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xbcdc
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x84e3
leaq 0x17d8d(%rip), %rsi     # 0x2024c
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x181da(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testPutSerialization()
void testPutSerialization() {
    Sys* tester = new Sys();
    Key k("key1", 0);
    Value v("val", 3);
    Put ack(&k, &v, 1,2,3);
    char* msg_serialized = ack.serialize();
    Put* msg_two = new Put(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Put Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq 0x17d39(%rip), %rsi     # 0x2026c
xorl %r15d, %r15d
leaq -0x58(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac04
leaq -0x38(%rbp), %rax
movq %r15, 0x8(%rax)
leaq 0x22e8d(%rip), %rcx     # 0x2b3e0
movq %rcx, (%rax)
leaq 0x17d14(%rip), %rcx     # 0x20271
movq %rcx, 0x10(%rax)
movl $0x3, %ecx
movq %rcx, 0x18(%rax)
leaq -0x98(%rbp), %rdi
movq %r15, 0x8(%rdi)
leaq 0x2376c(%rip), %rdx     # 0x2bce8
movq %rdx, (%rdi)
movl $0x2, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movq %rax, 0x38(%rdi)
callq 0xc038
movq %rax, %r15
movl $0x40, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc158
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8608
leaq 0x17c94(%rip), %rsi     # 0x20275
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x180b5(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testGetSerialization()
void testGetSerialization() {
    Sys* tester = new Sys();
    Key k("key1", 0);
    Get ack(&k, 1,2,3);
    char* msg_serialized = ack.serialize();
    Get* msg_two = new Get(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Get Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq 0x17c17(%rip), %rsi     # 0x2026c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac04
leaq -0x70(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x236da(%rip), %rax     # 0x2bd50
movq %rax, (%rdi)
movl $0x4, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
movq %r14, 0x30(%rdi)
callq 0xc52c
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc62e
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x86ff
leaq 0x17bb9(%rip), %rsi     # 0x20294
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17fbe(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testWaitAndGetSerialization()
void testWaitAndGetSerialization() {
    Sys* tester = new Sys();
    Key k("key1", 0);
    WaitAndGet ack(&k, 1,2,3);
    char* msg_serialized = ack.serialize();
    WaitAndGet* msg_two = new WaitAndGet(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Get Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq 0x17b20(%rip), %rsi     # 0x2026c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac04
leaq -0x70(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x2364b(%rip), %rax     # 0x2bdb8
movq %rax, (%rdi)
movl $0x5, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
movq %r14, 0x30(%rdi)
callq 0xc9b4
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xcab6
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x87f6
leaq 0x17ac2(%rip), %rsi     # 0x20294
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17ec7(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testStatusSerialization()
void testStatusSerialization() {
    Sys* tester = new Sys();
    Status ack("status", 1,2,3);
    char* msg_serialized = ack.serialize();
    Status* msg_two = new Status(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Status Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x235b9(%rip), %rax     # 0x2be08
movq %rax, (%rdi)
movl $0x6, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x17a3b(%rip), %rax     # 0x202b3
movq %rax, 0x30(%rdi)
callq 0xce3c
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xcf32
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x88df
leaq 0x179ff(%rip), %rsi     # 0x202ba
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17dde(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testReplySerialization()
void testReplySerialization() {
    Sys* tester = new Sys();
    Reply ack("status", 1,2,3);
    char* msg_serialized = ack.serialize();
    //std::cout << msg_serialized << "\n";
    Reply* msg_two = new Reply(msg_serialized);
    //std::cout << msg_two->serialize() << "\n";
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Reply Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x23538(%rip), %rax     # 0x2be70
movq %rax, (%rdi)
movl $0x3, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x17952(%rip), %rax     # 0x202b3
movq %rax, 0x30(%rdi)
callq 0xd29e
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xd3aa
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x89c8
leaq 0x17938(%rip), %rsi     # 0x202dc
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17cf5(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testRegisterSerialization()
void testRegisterSerialization() {
    Sys* tester = new Sys();
    Register ack(1,2,3, "127.0.0.1", 3001);
    char* msg_serialized = ack.serialize();
    Register* msg_two = new Register(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Register Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x234b7(%rip), %rax     # 0x2bed8
movq %rax, (%rdi)
movl $0x8, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x178b3(%rip), %rax     # 0x202fd
movq %rax, 0x30(%rdi)
movq $0xbb9, 0x38(%rdi)      # imm = 0xBB9
callq 0xd780
movq %rax, %r15
movl $0x40, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xd88a
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8ab9
leaq 0x17872(%rip), %rsi     # 0x20307
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x71d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17c04(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testValueSerialization()
void testValueSerialization() {
    Sys* system = new Sys();
    Value* v1 = new Value("muffin", (size_t)6);
    Value* v3 = new Value("carrot", (size_t)6);
    char* serialized = v1->serialize();
    Value* v2 = new Value(serialized);
    system->t_true(v1->equals(v2));
    system->t_false(v3->equals(v2));
    system->OK("Passed value serialization");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %edi
callq 0x7200
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
xorl %r12d, %r12d
movq %r12, 0x8(%rax)
leaq 0x22694(%rip), %r13     # 0x2b3e0
movq %r13, (%rax)
leaq 0x1733a(%rip), %rax     # 0x20090
movq %rax, 0x10(%r14)
movl $0x6, %ebx
movq %rbx, 0x18(%r14)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq %r12, 0x8(%rax)
movq %r13, (%rax)
leaq 0x17319(%rip), %rax     # 0x20097
movq %rax, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r14, %rdi
callq 0x10e52
movq %rax, %r13
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xe35e
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x8df1
movq %r15, %rdi
movq %r12, %rsi
callq 0x10dd4
testb %al, %al
jne 0x8df1
leaq 0x17588(%rip), %rsi     # 0x20357
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x178cc(%rip), %rsi     # 0x206c4
movq -0x30(%rbp), %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350