LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ed0
movq %r15, %rdi
movq %r12, %rsi
callq 0x32cc
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4403
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r15b, %r15b
je 0x445f
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a5c
movq (%rax), %rax
cmpb $0x0, 0x31(%rax)
je 0x44b5
movq 0x3ba5(%rip), %r14      # 0x7fd0
leaq 0xe9b(%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 0xe7d(%rip), %rsi       # 0x52d5
movl $0x1b, %edx
jmp 0x4481
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3b63(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, %rbx
leaq 0xe75(%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 0x456c
movq 0x3b14(%rip), %r15      # 0x7fd0
leaq 0xdfb(%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 0x4a5c
movq (%rax), %r15
testq %r15, %r15
je 0x454f
leaq 0x3809(%rip), %rax      # 0x7d30
movq %rax, (%r15)
movq 0x8(%r15), %rdi
leaq 0x18(%r15), %rax
cmpq %rax, %rdi
je 0x4542
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 0x4bfe
movq %r14, %rdi
movq %rax, %rsi
callq 0x4cb0
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 0x4593
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ed0
movq %r15, %rdi
movq %r12, %rsi
callq 0x32cc
movl %eax, %r15d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x45f7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
testb %r15b, %r15b
je 0x46c3
movq 0x39c9(%rip), %r15      # 0x7fd0
leaq 0xc9d(%rip), %rsi       # 0x52ab
movl $0x5, %edx
movq %r15, %rdi
callq 0x21e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a5c
movq (%rax), %rsi
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x3070
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0xcaf(%rip), %rsi       # 0x5306
movl $0x9, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r14), %rdi
addq $0x40, %rdi
movq %rbx, %rsi
callq 0x4a5c
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x309e
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 0x46a8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4714
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x4714
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x38ff(%rip), %rdi      # 0x7fd0
callq 0x21e0
movq %rax, %rbx
leaq 0xc11(%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 0x4746
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0x4746
jmp 0x4743
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4771
movq -0x78(%rbp), %rsi
jmp 0x4769
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x4771
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3070
movq (%rbx), %r14
cmpb $0x1, 0x70(%r14)
jne 0x48e6
leaq -0x60(%rbp), %r13
leaq -0x80(%rbp), %rbx
leaq -0xb0(%rbp), %r15
leaq -0x90(%rbp), %r12
movq %r14, %rdi
callq 0x32f0
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x3070
movq %r15, %rdi
leaq 0x81f(%rip), %rsi       # 0x5004
callq 0x22d0
movq %r13, -0x70(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x480a
movq %rdx, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4812
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 0x4860
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x4866
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 0x48a4
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x48b9
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x48db
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpb $0x0, 0x70(%r14)
jne 0x47c5
leaq 0x717(%rip), %rsi       # 0x5004
leaq -0x50(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x4915
leaq -0x50(%rbp), %rsi
movq 0x8(%rsi), %rcx
movl $0x1, %edx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x21c0
jmp 0x4933
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 0x2ed0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x494c
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 0x4965
jmp 0x4965
movq %rax, %rbx
jmp 0x49a9
movq %rax, %rbx
jmp 0x4987
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x4987
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0xb0(%rbp), %rdi
leaq -0xa0(%rbp), %rax
cmpq %rax, %rdi
je 0x49a9
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49c2
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23e30(%rip), %r12     # 0x2b358
movq %r12, (%rax)
leaq 0x18b5e(%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 0x18b3c(%rip), %rax     # 0x20097
movq %rax, 0x10(%r14)
movq %r13, 0x18(%r14)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
leaq 0x18b27(%rip), %rsi     # 0x2009e
movq %rax, %rdi
xorl %edx, %edx
callq 0xac74
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
leaq 0x18b13(%rip), %rsi     # 0x200a8
movq %rax, %rdi
xorl %edx, %edx
callq 0xac74
xorl %eax, %eax
movq %rax, -0x68(%rbp)
leaq 0x23f9c(%rip), %rcx     # 0x2b548
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 0xad26
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xae36
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xae36
leaq 0x23f45(%rip), %rax     # 0x2b548
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 0x7663
movq %rax, %rbx
movq %r13, %rdi
callq 0x71d0
jmp 0x7648
movq %rax, %rbx
movq %r12, %rdi
jmp 0x763e
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
jmp 0x765b
movq %rax, %rbx
leaq 0x23ef9(%rip), %rax     # 0x2b548
movq %rax, -0x70(%rbp)
movl -0x48(%rbp), %edi
callq 0x7370
movq %rbx, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x115b8
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23aa2(%rip), %rcx     # 0x2b958
movq %rcx, (%r15)
movq %rax, 0x18(%r15)
movq $0x3c, 0x20(%r15)
movl $0xf0, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rcx
leaq (%rax,%rcx,4), %rdx
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, (%rdx,%rax,4)
incq %rax
cmpl $0x32, %eax
jne 0x7edd
addq %rax, %rcx
movq %rcx, 0x18(%r15)
movq %r15, %rdi
callq 0x12f08
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cd0c
leaq 0x23373(%rip), %rsi     # 0x2b288
leaq 0x233cc(%rip), %rdx     # 0x2b2e8
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 0x7f6e
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18205(%rip), %rsi     # 0x20153
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x18769(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb16c
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
cmpl $0x32, %r12d
jne 0x7fde
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1cd0c
leaq 0x23274(%rip), %rsi     # 0x2b288
leaq 0x232e5(%rip), %rdx     # 0x2b300
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 0x806d
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18106(%rip), %rsi     # 0x20153
movq %r14, %rdi
callq 0x127ec
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1866a(%rip), %rsi     # 0x206de
movq %r14, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x239b8(%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)
movq 0x18(%r15), %rcx
leaq (%rax,%rcx,4), %rdx
xorl %eax, %eax
movl %eax, (%rdx,%rax,4)
incq %rax
cmpl $0x64, %eax
jne 0x80ff
addq %rax, %rcx
movq %rcx, 0x18(%r15)
movq %r15, %rdi
callq 0x136f8
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cd0c
leaq 0x2315a(%rip), %rsi     # 0x2b288
leaq 0x231e3(%rip), %rdx     # 0x2b318
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 0x8187
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x18013(%rip), %rsi     # 0x2017a
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x18550(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb32a
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
cmpl $0x64, %r12d
jne 0x81f7
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1cd0c
leaq 0x2305b(%rip), %rsi     # 0x2b288
leaq 0x230fc(%rip), %rdx     # 0x2b330
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 0x8286
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x17f39(%rip), %rsi     # 0x2019f
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
callq 0x71d0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x18451(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x238e2(%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 0x13d2c
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xb4e4
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8380
leaq 0x17e79(%rip), %rsi     # 0x201c5
movq %r15, %rdi
callq 0x7290
testl %eax, %eax
jne 0x8380
leaq 0x17eb9(%rip), %rsi     # 0x20218
movq %rbx, %rdi
callq 0x127ec
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 0x18357(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2383f(%rip), %rax     # 0x2bc18
movq %rax, (%rdi)
movl $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xb846
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb92a
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x845e
leaq 0x17e01(%rip), %rsi     # 0x2023b
movq %rbx, %rdi
callq 0x127ec
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 0x18279(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x237c9(%rip), %rax     # 0x2bc80
movq %rax, (%rdi)
movl $0x1, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
callq 0xbc8c
movq %rax, %r15
movl $0x30, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xbd70
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x853c
leaq 0x17d42(%rip), %rsi     # 0x2025a
movq %rbx, %rdi
callq 0x127ec
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 0x1819b(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17cee(%rip), %rsi     # 0x2027a
xorl %r15d, %r15d
leaq -0x58(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac74
leaq -0x38(%rbp), %rax
movq %r15, 0x8(%rax)
leaq 0x22dac(%rip), %rcx     # 0x2b358
movq %rcx, (%rax)
leaq 0x17cc9(%rip), %rcx     # 0x2027f
movq %rcx, 0x10(%rax)
movl $0x3, %ecx
movq %rcx, 0x18(%rax)
leaq -0x98(%rbp), %rdi
movq %r15, 0x8(%rdi)
leaq 0x23713(%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 0xc0d2
movq %rax, %r15
movl $0x40, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc1f2
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8661
leaq 0x17c49(%rip), %rsi     # 0x20283
movq %rbx, %rdi
callq 0x127ec
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 0x18076(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17bcc(%rip), %rsi     # 0x2027a
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac74
leaq -0x70(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x23681(%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 0xc5cc
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc6ce
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8758
leaq 0x17b6e(%rip), %rsi     # 0x202a2
movq %rbx, %rdi
callq 0x127ec
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 0x17f7f(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17ad5(%rip), %rsi     # 0x2027a
leaq -0x38(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac74
leaq -0x70(%rbp), %rdi
movq $0x0, 0x8(%rdi)
leaq 0x235f2(%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 0xca5a
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xcb5c
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x884f
leaq 0x17a77(%rip), %rsi     # 0x202a2
movq %rbx, %rdi
callq 0x127ec
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 0x17e88(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23560(%rip), %rax     # 0x2be08
movq %rax, (%rdi)
movl $0x6, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x179f0(%rip), %rax     # 0x202c1
movq %rax, 0x30(%rdi)
callq 0xcee8
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xcfde
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8938
leaq 0x179b4(%rip), %rsi     # 0x202c8
movq %rbx, %rdi
callq 0x127ec
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 0x17d9f(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x234df(%rip), %rax     # 0x2be70
movq %rax, (%rdi)
movl $0x3, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x17907(%rip), %rax     # 0x202c1
movq %rax, 0x30(%rdi)
callq 0xd342
movq %rax, %r15
movl $0x38, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xd44e
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8a21
leaq 0x178ed(%rip), %rsi     # 0x202ea
movq %rbx, %rdi
callq 0x127ec
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 0x17cb6(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2345e(%rip), %rax     # 0x2bed8
movq %rax, (%rdi)
movl $0x8, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x3, 0x28(%rdi)
leaq 0x17868(%rip), %rax     # 0x2030b
movq %rax, 0x30(%rdi)
movq $0xbb9, 0x38(%rdi)      # imm = 0xBB9
callq 0xd82e
movq %rax, %r15
movl $0x40, %edi
callq 0x7200
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xd938
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7290
testl %eax, %eax
jne 0x8b12
leaq 0x17827(%rip), %rsi     # 0x20315
movq %rbx, %rdi
callq 0x127ec
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 0x17bc5(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x225a0(%rip), %r13     # 0x2b358
movq %r13, (%rax)
leaq 0x172ce(%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 0x172ad(%rip), %rax     # 0x20097
movq %rax, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r14, %rdi
callq 0x10ee0
movq %rax, %r13
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xe408
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x8e5e
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8e5e
leaq 0x17535(%rip), %rsi     # 0x20371
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x17879(%rip), %rsi     # 0x206de
movq -0x30(%rbp), %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
leaq 0x171d6(%rip), %rsi     # 0x20090
movq %rax, %rdi
xorl %edx, %edx
callq 0xac74
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
leaq 0x171bf(%rip), %rsi     # 0x20097
movq %rax, %rdi
xorl %edx, %edx
callq 0xac74
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r13
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xe586
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x8f4b
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8f4b
leaq 0x1745f(%rip), %rsi     # 0x2038c
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1778c(%rip), %rsi     # 0x206de
movq %rbx, %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %r14
jmp 0x8f77
movq %rax, %rbx
movq %r15, %r14
jmp 0x8f77
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testKVStoreSerialization()
void testKVStoreSerialization() {
    Sys* system = new Sys();
    KVStore* kvs1 = tempStore();
    char* serialized = kvs1->serialize();
    KVStore* kvs2 = new KVStore(serialized);
    char* serialized2 = kvs2->serialize();
    String* s = new String(serialized);
    String* s2 = new String(serialized2);
    system->t_true(s2->equals(s));
    //system->t_true(kvs2->get(k1)->equals(v1));
    system->OK("Passed KVStore serialization");
    delete kvs1;
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, -0x30(%rbp)
callq 0x74fc
movq %rax, %rdi
movq (%rax), %rax
movq %rdi, -0x40(%rbp)
callq *0x38(%rax)
movq %rax, %r13
movl $0x118, %edi            # imm = 0x118
callq 0x7200
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xe71e
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq %r13, %rdi
callq 0x70f0
movq %rax, %rbx
movq $0x0, 0x8(%r15)
leaq 0x22471(%rip), %rax     # 0x2b478
movq %rax, (%r15)
movq %rbx, 0x10(%r15)
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7180
movb $0x0, (%r14,%rbx)
movl $0x20, %edi
callq 0x7200
movq %rax, %r13
movq -0x38(%rbp), %rdi
callq 0x70f0
movq %rax, %rbx
movq $0x0, 0x8(%r13)
leaq 0x2241c(%rip), %rax     # 0x2b478
movq %rax, (%r13)
movq %rbx, 0x10(%r13)
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r13)
movq %rax, %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x7180
movb $0x0, (%r14,%rbx)
movq %r13, %rdi
movq %r15, %rsi
callq 0x1149c
testb %al, %al
je 0x90cd
leaq 0x17304(%rip), %rsi     # 0x203a5
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x127ec
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1760a(%rip), %rsi     # 0x206de
movq -0x30(%rbp), %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r13, %r15
jmp 0x90f4
jmp 0x90f1
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testSchema()
void testSchema() {
    Sys* system = new Sys();
    Schema* sch = new Schema("IFD");
    char* serialized = sch->serialize();
    //std::cout << serialized << "\n";
    Schema* sch2 = new Schema(serialized);
    //std::cout << sch2->serialize() << "\n";
    String* s = new String(serialized);
    String* s2 = new String(sch2->serialize());
    system->t_true(s2->equals(s));

    system->OK("Passed Schema");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x50, %edi
callq 0x7200
movq %rax, %r15
leaq 0x16020(%rip), %rsi     # 0x204ad
movq %rax, %rdi
callq 0x10492
movq %rbx, -0x30(%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movl $0x50, %edi
callq 0x7200
movq %rax, -0x38(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1061e
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq %r12, %rdi
callq 0x70f0
movq %rax, %r13
movq $0x0, 0x8(%r15)
leaq 0x20f93(%rip), %rax     # 0x2b478
movq %rax, (%r15)
movq %r13, 0x10(%r15)
leaq 0x1(%r13), %rbx
movq %rbx, %rdi
callq 0x7030
movq %rax, %r14
movq %r15, -0x40(%rbp)
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7180
movb $0x0, (%r14,%r13)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
movq %rax, %rdi
callq 0x70f0
movq %rax, %r13
movq $0x0, 0x8(%r15)
leaq 0x20f2e(%rip), %rax     # 0x2b478
movq %rax, (%r15)
movq %r13, 0x10(%r15)
leaq 0x1(%r13), %rbx
movq %rbx, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7180
movb $0x0, (%r14,%r13)
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x1149c
testb %al, %al
je 0xa5b0
leaq 0x15f23(%rip), %rsi     # 0x204b1
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x16127(%rip), %rsi     # 0x206de
movq -0x30(%rbp), %rdi
callq 0x127ec
movl $0x1, %edi
callq 0x7260
jmp 0xa5d7
movq %rax, %rbx
movq -0x38(%rbp), %r15
jmp 0xa5da
jmp 0xa5d7
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testApplication()
void testApplication() {
    Sys* system = new Sys();
    NetworkIP network;
    Trivial* triv = new Trivial(0, &network);
    triv->run_();

    system->OK("Passed Application code M2");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
xorl %eax, %eax
movq %rax, -0x58(%rbp)
leaq 0x20c52(%rip), %r15     # 0x2b548
movq %r15, -0x60(%rbp)
movq $0x1, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
leaq -0x60(%rbp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1c5f6
leaq 0x2234c(%rip), %rax     # 0x2cc78
movq %rax, (%r14)
movq %r14, %rdi
callq 0x1c670
leaq 0x15b9d(%rip), %rsi     # 0x204db
movq %rbx, %rdi
callq 0x127ec
movq %rbx, %rdi
callq 0x7270
movq %r15, -0x60(%rbp)
movl -0x38(%rbp), %edi
callq 0x7370
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa98b
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
jmp 0xa977
movq %rax, %rbx
movq %r15, -0x60(%rbp)
movl -0x38(%rbp), %edi
callq 0x7370
movq %rbx, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x115b8
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/testSerialize.cpp
// Function: main
int main() {
    testValueSerialization();
    testKeySerialization();
    testIntArraySerialization();
    testIntColumnSerialization();
    testStringArraySerialization();
    testStringColumnSerialization();
    testFloatArraySerialization();
    testFloatColumnSerialization();
    testMessageSerialization();
    testAckSerialization();
    testNackSerialization();
    testPutSerialization();
    testGetSerialization();
    testWaitAndGetSerialization();
    testStatusSerialization();
    testReplySerialization();
    testRegisterSerialization();
    testDirectorySerialization();
    testIntDistributedArrays();
    testStringDistributedArrays();
    testFloatDistributedArrays();
    testDistributedIntColumn();
    testDistributedDoubleColumn();
    testDistributedFloatColumn();
    testDistributedBoolColumn();
    testDistributedStringColumn();
    testSchema();
    testDistributedDataframe();
    testApplication();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x8d81
callq 0x8e8b
callq 0x8099
callq 0x81b3
callq 0x79f0
callq 0x7c42
callq 0x7e77
callq 0x7f9a
callq 0x82b2
callq 0x83ac
callq 0x848a
callq 0x8568
callq 0x868d
callq 0x8784
callq 0x887b
callq 0x8964
callq 0x8a4d
callq 0x8b3e
callq 0x9104
callq 0x936e
callq 0x9646
callq 0x98df
callq 0x9b2b
callq 0x9d77
callq 0x9fc3
callq 0xa20f
callq 0xa45b
callq 0xa5ea
callq 0xa8cf
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/./../src/dataframe/column.h
// Function: FloatColumn::FloatColumn(int, ...)
FloatColumn(int n, ...) {
    val_ = new Array();
    for(int i = 0; i < metaArrayStartSize_; i++) {
      val_->pushBack(new FloatArray(arraySize_));
    }
    va_list ap;
    va_start (ap, n);
    for (int i = 0; i < n; i++) {
      push_back(va_arg (ap, float)); 
    }
    va_end (ap);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0xb1d1
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
xorl %r12d, %r12d
movq %r12, 0x8(%rdi)
leaq 0x207c9(%rip), %rax     # 0x2b9a8
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x20571(%rip), %rax     # 0x2b780
movq %rax, (%r15)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq $0x5, 0x20(%r15)
movq $0x0, 0x18(%r15)
movq %r15, 0x10(%r14)
cmpl $0x0, 0x20(%r14)
jle 0xb2a3
xorl %r13d, %r13d
movq 0x10(%r14), %r12
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movslq 0x1c(%r14), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movl $0x0, %ecx
movq %rcx, 0x8(%r15)
leaq 0x206ea(%rip), %rdx     # 0x2b958
movq %rdx, (%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r13d
cmpl 0x20(%r14), %r13d
jl 0xb23e
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
testl %ebx, %ebx
jle 0xb303
movl -0x3c(%rbp), %ecx
cmpq $0xa0, %rcx
ja 0xb2e3
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x10, %ecx
movl %ecx, -0x3c(%rbp)
jmp 0xb2ef
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movss (%rax), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
decl %ebx
jne 0xb2c8
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb317
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/tests/./../src/dataframe/column.h
// Function: IntColumn::IntColumn(int, ...)
IntColumn(int n, ...) {
    val_ = new Array();
    for(int i = 0; i < metaArrayStartSize_; i++) {
      val_->pushBack(new IntArray(arraySize_));
    }
    va_list ap;
    va_start (ap, n);
    for (int i = 0; i < n; i++) {
      push_back(va_arg (ap, int)); 
    }
    va_end (ap);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0xb38f
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
xorl %r12d, %r12d
movq %r12, 0x8(%rdi)
leaq 0x20743(%rip), %rax     # 0x2bae0
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x203b3(%rip), %rax     # 0x2b780
movq %rax, (%r15)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq $0x5, 0x20(%r15)
movq $0x0, 0x18(%r15)
movq %r15, 0x10(%r14)
cmpl $0x0, 0x20(%r14)
jle 0xb461
xorl %r13d, %r13d
movq 0x10(%r14), %r12
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movslq 0x1c(%r14), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movl $0x0, %ecx
movq %rcx, 0x8(%r15)
leaq 0x20664(%rip), %rdx     # 0x2ba90
movq %rdx, (%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r13d
cmpl 0x20(%r14), %r13d
jl 0xb3fc
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
testl %ebx, %ebx
jle 0xb4bc
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xb49e
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0xb4aa
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
decl %ebx
jne 0xb486
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb4d0
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
nop