LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::changeDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::changeDirectory(string dir) {
	if(!dir.compare("..")) {
		if(currentDirectory->hasParent) {
			currentDirectory = currentDirectory->getParent();
		} else {
			cout << dir << ": Invalid directory" << endl;
		}
	} else if(currentDirectory->contains(dir)){
		Entity* newDir = currentDirectory->children[dir];

		if(newDir->isDirectory) {
			currentDirectory = (Directory*) newDir;
			cout << "Current directory is now " << currentDirectory->getName() << endl;
		} else {
			cout << dir << ": Is not a directory" << endl;
		}
	} else {
		cout << "The requested destination does not exist " << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a0c(%rip), %rsi      # 0x50e2
movq %r14, %rdi
callq 0x2080
movq (%rbx), %r15
testl %eax, %eax
je 0x3776
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2230
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r15d
leaq -0x60(%rbp), %rdi
callq 0x20d0
testb %r15b, %r15b
je 0x378a
movq (%rbx), %rdi
addq $0x40, %rdi
movq %r14, %rsi
callq 0x4044
movq (%rax), %rax
cmpb $0x1, 0x31(%rax)
jne 0x37cc
movq %rax, (%rbx)
movq 0x4896(%rip), %rdi      # 0x7fd0
leaq 0x1a74(%rip), %rsi      # 0x51b5
callq 0x21a0
movq %rax, %r14
movq (%rbx), %rsi
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x2d7a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x37f2
cmpb $0x1, 0x70(%r15)
jne 0x379a
movq %r15, %rdi
callq 0x2f2c
movq %rax, (%rbx)
jmp 0x37f2
movq 0x483f(%rip), %rdi      # 0x7fd0
leaq 0x1a4c(%rip), %rsi      # 0x51e4
jmp 0x37e5
movq 0x482f(%rip), %rdi      # 0x7fd0
movq %r14, %rsi
callq 0x2180
leaq 0x19f1(%rip), %rsi      # 0x51a1
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
movq 0x47fd(%rip), %rdi      # 0x7fd0
movq %r14, %rsi
callq 0x2180
leaq 0x19ed(%rip), %rsi      # 0x51cf
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x380f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x2230
movq %r14, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r14d
leaq -0x80(%rbp), %rdi
callq 0x20d0
testb %r14b, %r14b
je 0x3896
movq 0x476d(%rip), %rdi      # 0x7fd0
leaq 0x19bc(%rip), %rsi      # 0x5226
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x19b7(%rip), %rsi      # 0x5238
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
jmp 0x3920
pushq $0x78
popq %rdi
callq 0x21b0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x2230
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x2e1c
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2e92
movq 0x46fc(%rip), %rdi      # 0x7fd0
leaq 0x1933(%rip), %rsi      # 0x520e
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x1927(%rip), %rsi      # 0x5219
movq %rax, %rdi
callq 0x21a0
movq %rax, %rbx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
leaq -0x60(%rbp), %rdi
callq 0x20d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x395b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x3947
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x21c0
jmp 0x3960
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/dwburer[P]CSCI-3232-File-System/FileSystem.cpp
// Function: FileSystem::removeDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::removeDirectory(string dir) {
	
	if(currentDirectory->contains(dir)) {
		if(currentDirectory->children[dir]->isDirectory) {

			Directory* toDelete = (Directory*)(currentDirectory->children[dir]);

			if(toDelete->children.size() == 0) {
				cout << "Deleting directory " << dir << endl;
				delete currentDirectory->children[dir];
				currentDirectory->children.erase(dir);
			} else {
				cout << "Error: \"" << dir << "\" is not empty" << endl;
			}
		} else {
			cout << "Error: \"" << dir << "\" is a file, not a directory" << endl;
		}
	} else {
		cout << dir << ": No such directory found" << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2230
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r15d
leaq -0x40(%rbp), %rdi
callq 0x20d0
testb %r15b, %r15b
je 0x3a04
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %rax
cmpb $0x1, 0x31(%rax)
jne 0x3a1c
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
je 0x3a5e
movq 0x45ec(%rip), %rdi      # 0x7fd0
leaq 0x1871(%rip), %rsi      # 0x525c
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x1863(%rip), %rsi      # 0x5265
jmp 0x3a41
movq 0x45c5(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
callq 0x2180
leaq 0x1877(%rip), %rsi      # 0x5291
jmp 0x3a41
movq 0x45ad(%rip), %rdi      # 0x7fd0
leaq 0x1832(%rip), %rsi      # 0x525c
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x1833(%rip), %rsi      # 0x5274
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x456b(%rip), %rdi      # 0x7fd0
leaq 0x17dc(%rip), %rsi      # 0x5248
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %r15
testq %r15, %r15
je 0x3aa3
movq %r15, %rdi
callq 0x2b80
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x21c0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x423c
jmp 0x3a51
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x2230
movq %r14, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r14d
leaq -0x80(%rbp), %rdi
callq 0x20d0
testb %r14b, %r14b
je 0x3b4e
movq 0x44b5(%rip), %rdi      # 0x7fd0
leaq 0x178f(%rip), %rsi      # 0x52b1
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x16ff(%rip), %rsi      # 0x5238
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
jmp 0x3bd8
pushq $0x40
popq %rdi
callq 0x21b0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x2230
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x3490
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2e92
movq 0x4444(%rip), %rdi      # 0x7fd0
leaq 0x1718(%rip), %rsi      # 0x52ab
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x166f(%rip), %rsi      # 0x5219
movq %rax, %rdi
callq 0x21a0
movq %rax, %rbx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
leaq -0x60(%rbp), %rdi
callq 0x20d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x3c13
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x3bff
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x21c0
jmp 0x3c18
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2230
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r15d
leaq -0x40(%rbp), %rdi
callq 0x20d0
testb %r15b, %r15b
je 0x3c9f
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %rax
cmpb $0x0, 0x31(%rax)
je 0x3cc7
movq 0x4351(%rip), %rdi      # 0x7fd0
leaq 0x1647(%rip), %rsi      # 0x52cd
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
leaq 0x1638(%rip), %rsi      # 0x52d5
jmp 0x3cb5
movq 0x432a(%rip), %rdi      # 0x7fd0
movq %rbx, %rsi
callq 0x2180
leaq 0x163c(%rip), %rsi      # 0x52f1
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
jmp 0x3d26
movq 0x4302(%rip), %rdi      # 0x7fd0
leaq 0x15e9(%rip), %rsi      # 0x52be
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %r15
testq %r15, %r15
je 0x3d0c
movq %r15, %rdi
callq 0x2b80
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x21c0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x423c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x2230
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f16
movl %eax, %r15d
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq 0x4246(%rip), %rdi      # 0x7fd0
testb %r15b, %r15b
je 0x3e18
leaq 0x1511(%rip), %rsi      # 0x52ab
callq 0x21a0
movq %rax, %r15
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %rsi
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x2d7a
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
leaq 0x1534(%rip), %rsi      # 0x5306
movq %rax, %rdi
callq 0x21a0
movq %rax, %r15
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4044
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2d96
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x2180
leaq -0x40(%rbp), %rdi
callq 0x20d0
leaq -0x60(%rbp), %rdi
callq 0x20d0
jmp 0x3e37
movq %rbx, %rsi
callq 0x2180
leaq 0x14ca(%rip), %rsi      # 0x52f1
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x3e57
jmp 0x3e54
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0x3e64
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r14
movq %r14, %rdi
callq 0x2d7a
movq (%rbx), %rbx
leaq -0x70(%rbp), %r15
leaq -0x90(%rbp), %r13
leaq -0xb0(%rbp), %r12
cmpb $0x1, 0x70(%rbx)
jne 0x3f12
movq %rbx, %rdi
callq 0x2f2c
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d7a
movq %r13, %rdi
movq %r15, %rsi
leaq 0x112a(%rip), %rdx      # 0x5004
callq 0x3fa4
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x40ad
movq %r14, %rdi
movq %r12, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x20d0
jmp 0x3eb1
leaq 0x10eb(%rip), %rsi      # 0x5004
leaq -0x50(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x3f3f
leaq -0x50(%rbp), %rsi
movq 0x8(%rsi), %rcx
pushq $0x1
popq %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x21d0
jmp 0x3f4f
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2230
leaq -0x50(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f90
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x20d0
jmp 0x3f83
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20d0
jmp 0x3f93
jmp 0x3f90
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %r15
movq %r15, %rdi
callq 0x7220
movq %rax, %rbx
andq $0x0, 0x8(%rax)
leaq 0x1eec0(%rip), %r12     # 0x263b8
movq %r12, (%rax)
leaq 0x12b9e(%rip), %rax     # 0x1a0a0
movq %rax, 0x10(%rbx)
pushq $0x6
popq %r13
movq %r13, 0x18(%rbx)
movq %r15, %rdi
callq 0x7220
movq %rax, %r14
andq $0x0, 0x8(%rax)
movq %r12, (%rax)
leaq 0x12b7f(%rip), %rax     # 0x1a0a7
movq %rax, 0x10(%r14)
movq %r13, 0x18(%r14)
movq %r15, %rdi
callq 0x7220
movq %rax, %r15
leaq 0x12b6c(%rip), %rsi     # 0x1a0ae
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d76
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x12b5a(%rip), %rsi     # 0x1a0b8
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d76
andq $0x0, -0x68(%rbp)
leaq 0x1efe4(%rip), %rax     # 0x26558
movq %rax, -0x70(%rbp)
movq $0x1, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
andq $0x0, -0x30(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r13
pushq $0x1
popq %rsi
leaq -0x70(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9e80
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x9e80
leaq -0x70(%rbp), %rdi
callq 0xa00a
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x71f0
jmp 0x7604
movq %rax, %rbx
movq %r12, %rdi
jmp 0x75fa
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
jmp 0x760d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testStringArraySerialization()
void testStringArraySerialization() {
    Sys* tester = new Sys();
    Deserializable* ds = new Deserializable();
    StringArray* is = new StringArray();
    is->pushBack(new String("taco"));
    is->pushBack(new String("dorito"));
    is->pushBack(new String("nacho"));
    is->pushBack(new String("enchilada"));
    char* string_is_serialized = is->serialize();
    StringArray* is_two = dynamic_cast<StringArray*>(ds->deserialize(string_is_serialized));
    tester->t_true(strcmp(string_is_serialized, is_two->serialize()) == 0);
    delete is;
    tester->OK("Passed String Array Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x7220
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %rbx
movq %rax, %rdi
callq 0xa02a
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x1284a(%rip), %rsi     # 0x1a0c2
movq %rax, %rdi
callq 0xa064
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r12, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%rbx)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x1286e(%rip), %rsi     # 0x1a113
movq %rax, %rdi
callq 0xa064
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r12, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%rbx)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x12848(%rip), %rsi     # 0x1a11a
movq %rax, %rdi
callq 0xa064
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r12, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%rbx)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x12821(%rip), %rsi     # 0x1a120
movq %rax, %rdi
callq 0xa064
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %r12, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e9b0(%rip), %rsi     # 0x262e8
leaq 0x1e9c1(%rip), %rdx     # 0x26300
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7969
movq %r14, %rdi
callq 0xf396
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq 0x127b1(%rip), %rsi     # 0x1a12a
movq %r14, %rdi
callq 0xf3ae
movq %r14, %rdi
callq 0x71f0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
jmp 0x799f
jmp 0x799f
jmp 0x799f
movq %rax, %r14
movq %r12, %rbx
jmp 0x79aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x71f0
movq %r14, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testStringColumnSerialization()
void testStringColumnSerialization() {
    Sys* tester = new Sys();
    Deserializable* ds = new Deserializable();
    StringColumn* sc = new StringColumn();
    sc->push_back(new String("taco"));
    sc->push_back(new String("dorito"));
    sc->push_back(new String("nacho"));
    sc->push_back(new String("enchilada"));
    char* string_is_serialized = sc->serialize();
    StringColumn* is_two = dynamic_cast<StringColumn*>(ds->deserialize(string_is_serialized));
    tester->t_true(strcmp(string_is_serialized, is_two->serialize()) == 0);
    delete sc;
    tester->OK("Passed String Column Serialization Tests");
    delete tester;
    delete [] ds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $0x1
popq %rbx
movq %rbx, %rdi
callq 0x7220
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %rbx
movq %rax, %rdi
callq 0xa08c
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x126bf(%rip), %rsi     # 0x1a0c2
movq %rax, %rdi
callq 0xa064
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0xb8(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x126e7(%rip), %rsi     # 0x1a113
movq %rax, %rdi
callq 0xa064
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0xb8(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x126c5(%rip), %rsi     # 0x1a11a
movq %rax, %rdi
callq 0xa064
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0xb8(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x126a2(%rip), %rsi     # 0x1a120
movq %rax, %rdi
callq 0xa064
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0xb8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e835(%rip), %rsi     # 0x262e8
leaq 0x1e876(%rip), %rdx     # 0x26330
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7ae4
movq %r14, %rdi
callq 0xf396
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
leaq 0x1265e(%rip), %rsi     # 0x1a152
movq %r14, %rdi
callq 0xf3ae
movq %r14, %rdi
callq 0x71f0
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
jmp 0x7b1a
jmp 0x7b1a
jmp 0x7b1a
movq %rax, %r14
movq %r12, %rbx
jmp 0x7b25
movq %rax, %r14
movq %rbx, %rdi
callq 0x71f0
movq %r14, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x7220
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
pushq $0x3c
popq %rsi
movq %rax, %rdi
callq 0xa136
movq 0x18(%r15), %rax
leaq (,%rax,4), %rcx
addq 0x10(%r15), %rcx
xorl %edx, %edx
cmpl $0x32, %edx
je 0x7b95
cvtsi2ss %edx, %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
jmp 0x7b82
addq %rdx, %rax
movq %rax, 0x18(%r15)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e72e(%rip), %rsi     # 0x262e8
leaq 0x1e787(%rip), %rdx     # 0x26348
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7beb
movq %rbx, %rdi
callq 0xf396
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x12580(%rip), %rsi     # 0x1a17b
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x7220
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
xorl %r12d, %r12d
pushq $0x3c
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xa17c
jmp 0x7c7c
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
movq (%r15), %rax
movq %r15, %rdi
cmpl $0x32, %r12d
jne 0x7c70
callq *0x38(%rax)
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e648(%rip), %rsi     # 0x262e8
leaq 0x1e6b9(%rip), %rdx     # 0x26360
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7cd1
movq %r14, %rdi
callq 0xf396
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x1249a(%rip), %rsi     # 0x1a17b
movq %r14, %rdi
callq 0xf3ae
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x7220
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
pushq $0x64
popq %rsi
movq %rax, %rdi
callq 0xa2ec
movq 0x18(%r15), %rax
leaq (,%rax,4), %rcx
addq 0x10(%r15), %rcx
xorl %edx, %edx
cmpl $0x64, %edx
je 0x7d6e
movl %edx, (%rcx,%rdx,4)
incq %rdx
jmp 0x7d61
addq %rdx, %rax
movq %rax, 0x18(%r15)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e555(%rip), %rsi     # 0x262e8
leaq 0x1e5de(%rip), %rdx     # 0x26378
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7dc4
movq %rbx, %rdi
callq 0xf396
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x123ce(%rip), %rsi     # 0x1a1a2
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r14
movq %r14, %rdi
callq 0x7220
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rax, %r14
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
xorl %r12d, %r12d
pushq $0x78
popq %rsi
movq %rax, %rdi
xorl %eax, %eax
callq 0xa332
jmp 0x7e55
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
movq (%r15), %rax
movq %r15, %rdi
cmpl $0x64, %r12d
jne 0x7e49
callq *0x38(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x17b50
leaq 0x1e46f(%rip), %rsi     # 0x262e8
leaq 0x1e510(%rip), %rdx     # 0x26390
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %r12, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7eaa
movq %rbx, %rdi
callq 0xf396
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x1230d(%rip), %rsi     # 0x1a1c7
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
pushq $0x30
popq %r12
movq %r12, %rdi
callq 0x7220
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x1ec92(%rip), %rax     # 0x26bb0
movq %rax, (%r14)
movl $0x1, 0x10(%r14)
movq $0x2, 0x18(%r14)
movq $0x3, 0x20(%r14)
movq $0x5, 0x28(%r14)
movq %r14, %rdi
callq 0x1064a
movq %rax, %r15
movq %r12, %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa49e
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x7f83
movq %rbx, %rdi
callq 0xf396
leaq 0x12263(%rip), %rsi     # 0x1a1ed
movq %r15, %rdi
callq 0x7290
testl %eax, %eax
je 0x7f9e
movq %rbx, %rdi
callq 0xf396
leaq 0x1229b(%rip), %rsi     # 0x1a240
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
leaq -0x48(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1ec02(%rip), %rcx     # 0x26c00
movq %rcx, (%rdi)
andl $0x0, 0x10(%rdi)
movq %rax, %rbx
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xa616
movq %rax, %r15
pushq $0x30
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa6d2
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x805e
movq %rbx, %rdi
callq 0xf396
leaq 0x121fe(%rip), %rsi     # 0x1a263
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
leaq -0x48(%rbp), %rdi
andq $0x0, 0x8(%rdi)
movq %rax, %rbx
leaq 0x1eba4(%rip), %rax     # 0x26c68
movq %rax, (%rdi)
movl $0x1, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xa84a
movq %rax, %r15
pushq $0x30
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xa906
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x8124
movq %rbx, %rdi
callq 0xf396
leaq 0x12157(%rip), %rsi     # 0x1a282
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq 0x1211e(%rip), %rsi     # 0x1a2a2
leaq -0x58(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x9d76
leaq -0x38(%rbp), %rax
andq $0x0, 0x8(%rax)
leaq 0x1e216(%rip), %rcx     # 0x263b8
movq %rcx, (%rax)
leaq 0x120fb(%rip), %rcx     # 0x1a2a7
movq %rcx, 0x10(%rax)
pushq $0x3
popq %rcx
movq %rcx, 0x18(%rax)
leaq -0x98(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1eb06(%rip), %rdx     # 0x26cd0
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 0xaa7e
movq %rax, %r15
pushq $0x40
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xab76
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x822e
movq %rbx, %rdi
callq 0xf396
leaq 0x12076(%rip), %rsi     # 0x1a2ab
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq 0x12014(%rip), %rsi     # 0x1a2a2
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x9d76
leaq -0x70(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1ea8c(%rip), %rax     # 0x26d38
movq %rax, (%rdi)
movl $0x4, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
movq %r14, 0x30(%rdi)
callq 0xad66
movq %rax, %r15
pushq $0x38
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xae40
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x8310
movq %rbx, %rdi
callq 0xf396
leaq 0x11fb3(%rip), %rsi     # 0x1a2ca
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq 0x11f35(%rip), %rsi     # 0x1a2a2
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x9d76
leaq -0x70(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1ea15(%rip), %rax     # 0x26da0
movq %rax, (%rdi)
movl $0x5, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
movq %r14, 0x30(%rdi)
callq 0xaffc
movq %rax, %r15
pushq $0x38
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb0d6
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x83ef
movq %rbx, %rdi
callq 0xf396
leaq 0x11ed4(%rip), %rsi     # 0x1a2ca
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1e99b(%rip), %rax     # 0x26df0
movq %rax, (%rdi)
movl $0x6, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x11e6b(%rip), %rax     # 0x1a2e9
movq %rax, 0x30(%rdi)
callq 0xb292
movq %rax, %r15
pushq $0x38
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb362
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x84c0
movq %rbx, %rdi
callq 0xf396
leaq 0x11e29(%rip), %rsi     # 0x1a2f0
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1e932(%rip), %rax     # 0x26e58
movq %rax, (%rdi)
movl $0x3, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x11d9a(%rip), %rax     # 0x1a2e9
movq %rax, 0x30(%rdi)
callq 0xb4f6
movq %rax, %r15
pushq $0x38
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb5dc
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x8591
movq %rbx, %rdi
callq 0xf396
leaq 0x11d7a(%rip), %rsi     # 0x1a312
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x1e8c9(%rip), %rax     # 0x26ec0
movq %rax, (%rdi)
movl $0x8, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x11d13(%rip), %rax     # 0x1a333
movq %rax, 0x30(%rdi)
movq $0xbb9, 0x38(%rdi)      # imm = 0xBB9
callq 0xb7c8
movq %rax, %r15
pushq $0x40
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb8aa
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x866a
movq %rbx, %rdi
callq 0xf396
leaq 0x11ccc(%rip), %rsi     # 0x1a33d
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDirectorySerialization()
void testDirectorySerialization() {
    Sys* tester = new Sys();
    size_t ports[5] = {1,2,4,5};
    String* sa = new String("mama mia");
    String* sb = new String("here we");
    String* sc = new String("go");
    String* sd = new String("again");
    String* strings[4] = {sa,sb,sc,sd};
    Directory* d = new Directory(0, 1, 1, 4, ports, strings);
    char* d_serialized = d->serialize();
    Directory* d_two = new Directory(d_serialized);
    char* d_serialized_two = d_two->serialize();
    tester->t_true(strcmp(d_serialized, d_two->serialize()) == 0);
    tester->OK("Passed Directory Serialization Tests!");
    delete tester;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
andq $0x0, -0x40(%rbp)
movq $0x1, -0x60(%rbp)
movq $0x2, -0x58(%rbp)
movq $0x4, -0x50(%rbp)
movq $0x5, -0x48(%rbp)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
leaq 0x11c66(%rip), %rsi     # 0x1a361
movq %rax, %rdi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
leaq 0x11c55(%rip), %rsi     # 0x1a36a
movq %rax, %rdi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
leaq 0x11c43(%rip), %rsi     # 0x1a372
movq %rax, %rdi
callq 0xa064
movq %rbx, -0x30(%rbp)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r13
leaq 0x11c28(%rip), %rsi     # 0x1a375
movq %rax, %rdi
callq 0xa064
leaq -0x80(%rbp), %rbx
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r13, 0x18(%rbx)
pushq $0x48
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rbx, (%rsp)
pushq $0x1
popq %rcx
pushq $0x4
popq %r8
leaq -0x60(%rbp), %r9
movq %rax, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0xba90
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r15
pushq $0x48
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xbb54
movq -0x30(%rbp), %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
je 0x87de
movq %rbx, %rdi
callq 0xf396
leaq 0x11b96(%rip), %rsi     # 0x1a37b
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x71f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8820
jmp 0x8820
movq %rax, %rbx
movq %r13, %rdi
jmp 0x8826
movq %rax, %rbx
movq %r12, %rdi
jmp 0x8826
movq %rax, %rbx
movq %r15, %rdi
jmp 0x8826
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, -0x30(%rbp)
pushq $0x20
popq %r12
movq %r12, %rdi
callq 0x7220
movq %rax, %r15
andq $0x0, 0x8(%rax)
leaq 0x1db50(%rip), %r13     # 0x263b8
movq %r13, (%rax)
leaq 0x1182e(%rip), %rax     # 0x1a0a0
movq %rax, 0x10(%r15)
pushq $0x6
popq %rbx
movq %rbx, 0x18(%r15)
movq %r12, %rdi
callq 0x7220
movq %rax, %r14
andq $0x0, 0x8(%rax)
movq %r13, (%rax)
leaq 0x11810(%rip), %rax     # 0x1a0a7
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq %r15, %rdi
callq 0xdb9e
movq %rax, %r13
movq %r12, %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xbe30
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
movq -0x30(%rbp), %rbx
jne 0x88dc
movq %rbx, %rdi
callq 0xf396
movq %r14, %rdi
movq %r12, %rsi
callq 0xdb1c
testb %al, %al
je 0x88f3
movq %rbx, %rdi
callq 0xf396
leaq 0x11aa7(%rip), %rsi     # 0x1a3a1
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testKeySerialization()
void testKeySerialization() {
    Sys* system = new Sys();
    Key* v1 = new Key("muffin", 0);
    Key* v3 = new Key("carrot", 0);
    char* serialized = v1->serialize();
    Key* v2 = new Key(serialized);
    system->t_true(v1->equals(v2));
    system->t_false(v3->equals(v2));
    system->OK("Passed Key serialization");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
leaq 0x1174a(%rip), %rsi     # 0x1a0a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d76
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
leaq 0x11735(%rip), %rsi     # 0x1a0a7
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d76
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xbf3a
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x89b6
movq %rbx, %rdi
callq 0xf396
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x89ce
movq %rbx, %rdi
callq 0xf396
leaq 0x119e7(%rip), %rsi     # 0x1a3bc
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r12, %r14
jmp 0x8a06
movq %rax, %rbx
movq %r15, %r14
jmp 0x8a06
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330