LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logReadSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logReadSuccess(Address * address, bool isCoordinator, int transID, string key, string value){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: read success at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), value.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %r8, %r12
movl %ecx, %ebp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rax)
leaq 0x93ba(%rip), %rax      # 0x13952
leaq 0x93bf(%rip), %rsi      # 0x1395e
testl %edx, %edx
cmovneq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x34d0
movq 0x8(%rsp), %r13
movq 0x8(%r14), %rdi
callq 0xabe4
movq (%r12), %r9
movq (%r15), %rcx
movq %rcx, (%rsp)
leaq 0x1c731(%rip), %r15     # 0x26d00
leaq 0x93cb(%rip), %rsi      # 0x139a1
movq %r15, %rdi
movq %r13, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa106
leaq 0x8(%rsp), %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logDeleteSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logDeleteSuccess(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: delete success at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movl %ecx, %ebp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rax)
leaq 0x923b(%rip), %rax      # 0x13952
leaq 0x9240(%rip), %rsi      # 0x1395e
testl %edx, %edx
cmovneq %rax, %rsi
movq %rsp, %rdi
callq 0x34d0
movq (%rsp), %r12
movq 0x8(%r14), %rdi
callq 0xabe4
movq (%r15), %r9
leaq 0x1cd9d(%rip), %r15     # 0x274e0
leaq 0x92cd(%rip), %rsi      # 0x13a17
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa106
movq %rsp, %rdi
callq 0x3120
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logReadFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logReadFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: read fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movl %ecx, %ebp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rax)
leaq 0x90cd(%rip), %rax      # 0x13952
leaq 0x90d2(%rip), %rsi      # 0x1395e
testl %edx, %edx
cmovneq %rax, %rsi
movq %rsp, %rdi
callq 0x34d0
movq (%rsp), %r12
movq 0x8(%r14), %rdi
callq 0xabe4
movq (%r15), %r9
leaq 0x1d40f(%rip), %r15     # 0x27cc0
leaq 0x91ca(%rip), %rsi      # 0x13a82
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa106
movq %rsp, %rdi
callq 0x3120
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logDeleteFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logDeleteFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: delete fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r15
movl %ecx, %ebp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rax)
leaq 0x8f5f(%rip), %rax      # 0x13952
leaq 0x8f64(%rip), %rsi      # 0x1395e
testl %edx, %edx
cmovneq %rax, %rsi
movq %rsp, %rdi
callq 0x34d0
movq (%rsp), %r12
movq 0x8(%r14), %rdi
callq 0xabe4
movq (%r15), %r9
leaq 0x1da81(%rip), %r15     # 0x284a0
leaq 0x90c2(%rip), %rsi      # 0x13ae8
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3070
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa106
movq %rsp, %rdi
callq 0x3120
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Params.cpp
// Function: Params::setparams(char*)
void Params::setparams(char *config_file) {
	//trace.funcEntry("Params::setparams");
	char CRUD[10];
	FILE *fp = fopen(config_file,"r");

	fscanf(fp,"MAX_NNB: %d", &MAX_NNB);
	fscanf(fp,"\nSINGLE_FAILURE: %d", &SINGLE_FAILURE);
	fscanf(fp,"\nDROP_MSG: %d", &DROP_MSG);
	fscanf(fp,"\nMSG_DROP_PROB: %lf", &MSG_DROP_PROB);
	fscanf(fp,"\nCRUD_TEST: %s", CRUD);

	auto type = testTypeMap.find(CRUD);
	if(type == testTypeMap.end()){
		throw std::runtime_error("Unavailable Test Type!");
	}
	else{
		this->CRUDTEST = type->second;
	}

	//printf("Parameters of the test case: %d %d %d %lf\n", MAX_NNB, SINGLE_FAILURE, DROP_MSG, MSG_DROP_PROB);

	EN_GPSZ = MAX_NNB;
	STEP_RATE=.25;
	MAX_MSG_SIZE = 4000;
	globaltime = 0;
	dropmsg = 0;
	allNodesJoined = 0;
	for ( int i = 0; i < EN_GPSZ; i++ ) {
		allNodesJoined += i;
	}
	fclose(fp);
	//trace.funcExit("Params::setparams", SUCCESS);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8ed5(%rip), %rsi      # 0x13963
movq %rax, %rdi
callq 0x3330
movq %rax, %r14
leaq 0x907c(%rip), %rsi      # 0x13b1c
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x34b0
leaq 0x4(%rbx), %rdx
leaq 0x9070(%rip), %rsi      # 0x13b28
movq %r14, %rdi
xorl %eax, %eax
callq 0x34b0
leaq 0x20(%rbx), %rdx
leaq 0x906f(%rip), %rsi      # 0x13b3c
movq %r14, %rdi
xorl %eax, %eax
callq 0x34b0
leaq 0x8(%rbx), %rdx
leaq 0x9068(%rip), %rsi      # 0x13b4a
movq %r14, %rdi
xorl %eax, %eax
callq 0x34b0
leaq 0x906b(%rip), %rsi      # 0x13b5e
leaq 0x36(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x34b0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x4bc2
leaq 0x1dd72(%rip), %rdi     # 0x28890
leaq 0x10(%rsp), %rsi
callq 0xabe8
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x3120
testq %r15, %r15
je 0xab8c
movl 0x28(%r15), %eax
movl %eax, 0x34(%rbx)
movl (%rbx), %eax
movl %eax, 0x18(%rbx)
movabsq $0x3fd0000000000000, %rcx # imm = 0x3FD0000000000000
movq %rcx, 0x10(%rbx)
movl $0xfa0, 0x1c(%rbx)      # imm = 0xFA0
andq $0x0, 0x24(%rbx)
andl $0x0, 0x2c(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpl %edx, %eax
je 0xab7a
addl %edx, %ecx
movl %ecx, 0x2c(%rbx)
incl %edx
jmp 0xab6d
movq %r14, %rdi
callq 0x32a0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %r14
leaq 0x8fcf(%rip), %rsi      # 0x13b6d
movq %rax, %rdi
callq 0x30e0
movq 0x12443(%rip), %rsi     # 0x1cff0
movq 0x12404(%rip), %rdx     # 0x1cfb8
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
movq %r14, %rdi
callq 0x3200
jmp 0xabdb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3120
jmp 0xabdb
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Member.cpp
// Function: Member::operator=(Member const&)
Member& Member::operator =(const Member& anotherMember) {
	this->addr = anotherMember.addr;
	this->inited = anotherMember.inited;
	this->inGroup = anotherMember.inGroup;
	this->bFailed = anotherMember.bFailed;
	this->nnb = anotherMember.nnb;
	this->heartbeat = anotherMember.heartbeat;
	this->pingCounter = anotherMember.pingCounter;
	this->timeOutCounter = anotherMember.timeOutCounter;
	this->memberList = anotherMember.memberList;
	this->myPos = anotherMember.myPos;
	this->mp1q = anotherMember.mp1q;
	this->mp2q = anotherMember.mp2q;
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0xc(%rsi), %eax
movw %ax, 0xc(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movb 0xe(%rsi), %al
movb %al, 0xe(%rdi)
movb 0xf(%rsi), %al
movb %al, 0xf(%rdi)
movb 0x10(%rsi), %al
movb %al, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, 0x14(%rdi)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
addq $0x28, %rsi
addq $0x28, %rdi
callq 0xae50
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
leaq 0x48(%r14), %rsi
leaq 0x48(%rbx), %rdi
callq 0xaf16
movl $0x98, %edi
addq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0xaf16
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Trace.cpp
// Function: Trace::traceFileCreate()
int Trace::traceFileCreate() {

    int rc = SUCCESS;        // Return code

    logF = fopen(LOG_FILE_LOCATION, "w");
    if ( NULL == logF )
    {
        printf("\nUnable to open log file in write mode\n");
        rc = FAILURE;
    }

    return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x7024(%rip), %rdi      # 0x13bc3
leaq 0x6d3d(%rip), %rsi      # 0x138e3
callq 0x3330
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0xcbc7
leaq 0x703d(%rip), %rdi      # 0x13bfc
callq 0x3420
pushq $-0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Trace.cpp
// Function: Trace::printToTrace(char*, char*)
int Trace::printToTrace(char *keyMsg, char *valueMsg) {

    int rc = SUCCESS;        // Return code

    fprintf(logF, "%s : %s\n", keyMsg, valueMsg);
    fflush(logF);

    return rc;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x6ff1(%rip), %rsi      # 0x13bcf
xorl %eax, %eax
callq 0x33c0
movq (%rbx), %rdi
callq 0x3320
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Trace.cpp
// Function: Trace::funcEntry(char*)
int Trace::funcEntry(char *funcName) {

    int rc = SUCCESS;        // Return code

    fprintf(logF, "ENTRY - %s\n", funcName);
    fflush(logF);

    return rc;
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x6fc7(%rip), %rsi      # 0x13bd8
xorl %eax, %eax
callq 0x33c0
movq (%rbx), %rdi
callq 0x3320
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/Trace.cpp
// Function: Trace::funcExit(char*, int)
int Trace::funcExit(char *funcName, int f_rc) {

    int rc = SUCCESS;        // Return code

    fprintf(logF, "EXIT - %s with rc = %d\n", funcName, f_rc);
    fflush(logF);

    return rc;
}

// Assembly:
pushq %rbx
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x6fad(%rip), %rsi      # 0x13be4
xorl %eax, %eax
callq 0x33c0
movq (%rbx), %rdi
callq 0x3320
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::MP2Node(Member*, Params*, EmulNet*, Log*, Address*)
MP2Node::MP2Node(Member *memberNode, Params *par, EmulNet * emulNet, Log * log, Address * address) {
	this->memberNode = memberNode;
	this->par = par;
	this->emulNet = emulNet;
	this->log = log;
	ht = new HashTable();
	this->memberNode->addr = *address;
	this->delimiter = "::";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
leaq 0x80(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x70(%rdi)
andq $0x0, 0x78(%rdi)
movb $0x0, 0x80(%rdi)
leaq 0x98(%rdi), %rax
andl $0x0, 0x98(%rdi)
andq $0x0, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movq %rax, 0xb0(%rdi)
andq $0x0, 0xb8(%rdi)
leaq 0xc8(%rdi), %rax
andl $0x0, 0xc8(%rdi)
andq $0x0, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
andq $0x0, 0xe8(%rdi)
movq %rsi, 0x50(%rdi)
movq %rdx, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %r8, 0x68(%rdi)
pushq $0x38
popq %rdi
callq 0x32b0
movq %rax, %r12
movq %rax, %rdi
callq 0x1069c
movq %r12, 0x48(%rbx)
movq 0x50(%rbx), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0xac2e
leaq 0x6f37(%rip), %rsi      # 0x13c5c
movq %r14, %rdi
callq 0x34d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r12, %rdi
callq 0x32c0
jmp 0xcd4f
movq %rax, %r15
leaq 0x30(%rbx), %r12
leaq 0x18(%rbx), %r13
leaq 0xc0(%rbx), %rdi
leaq 0x90(%rbx), %rbp
callq 0xf48e
movq %rbp, %rdi
callq 0xf4f4
movq %r14, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x97f8
movq %r13, %rdi
callq 0x97f8
movq %rbx, %rdi
callq 0x97f8
movq %r15, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::updateRing()
void MP2Node::updateRing() {
    vector<Node> curMemList;
    bool change = false;

	/*
	 *  Step 1. Get the current membership list from Membership Protocol / MP1
	 */
	curMemList = getMembershipList();

	/*
	 * Step 2: Construct the ring
	 */
	// Sort the list based on the hashCode
	sort(curMemList.begin(), curMemList.end());

	// Check if the ring has changes
	if (curMemList.size() != ring.size()) {
        // if the current membership ring and my ring doesn't have the same size, then it must have changed
	    change = true;
	} else {
	    // go through each node in the two rings and check if they the same hash
        for (int i = 0; i < ring.size(); i++) {
            if (ring.at(i).getHashCode() != curMemList.at(i).getHashCode()) {
                change = true;
            }
        }
	}

	ring = curMemList;
	/*
	 * Step 3: Run the stabilization protocol IF REQUIRED
	 */
	// Run stabilization protocol if the hash table size is greater than zero and if there has been a changed in the ring
	if (change) {
        stabilizationProtocol();
	}

	// Also update the transaction map to see if any has been successful or failed
	updateTransactionMap();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xcf02
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x9eb4
movq %r15, %rdi
callq 0x97f8
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0xf5ef
movq 0x8(%rsp), %rdx
subq (%rsp), %rdx
leaq 0x30(%rbx), %r14
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
movq %rax, %rsi
subq %rcx, %rsi
movb $0x1, %bpl
cmpq %rsi, %rdx
jne 0xceb2
xorl %r15d, %r15d
movq %rsp, %r12
xorl %ebp, %ebp
subq %rcx, %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0xceb2
movq %r14, %rdi
movq %r15, %rsi
callq 0x981a
movq %rax, %rdi
callq 0x10680
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x981a
movq %rax, %rdi
callq 0x10680
cmpq %rax, %r13
setne %al
orb %al, %bpl
incq %r15
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rax
jmp 0xce67
movq %rsp, %rsi
movq %r14, %rdi
callq 0xf2a0
testb $0x1, %bpl
je 0xcecb
movq %rbx, %rdi
callq 0xcffa
movq %rbx, %rdi
callq 0xd230
movq %rsp, %rdi
callq 0x97f8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xceee
jmp 0xceee
movq %rax, %rbx
movq %rsp, %rdi
callq 0x97f8
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::getMembershipList()
vector<Node> MP2Node::getMembershipList() {
	unsigned int i;
	vector<Node> curMemList;
	for ( i = 0 ; i < this->memberNode->memberList.size(); i++ ) {
		Address addressOfThisMember;
		int id = this->memberNode->memberList.at(i).getid();
		short port = this->memberNode->memberList.at(i).getport();
		memcpy(&addressOfThisMember.addr[0], &id, sizeof(int));
		memcpy(&addressOfThisMember.addr[4], &port, sizeof(short));
		curMemList.emplace_back(Node(addressOfThisMember));
	}
	return curMemList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r15d, %r15d
leaq 0x12(%rsp), %r12
leaq 0x18(%rsp), %rbp
movl %r15d, %r15d
movq 0x50(%r14), %rdi
movq 0x30(%rdi), %rax
subq 0x28(%rdi), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0xcfc1
andw $0x0, 0x10(%rsp)
addq $0x28, %rdi
andl $0x0, 0xc(%rsp)
movq %r15, %rsi
callq 0xf36a
movq %rax, %rdi
callq 0xacac
movl %eax, %r13d
movq 0x50(%r14), %rdi
addq $0x28, %rdi
movq %r15, %rsi
callq 0xf36a
movq %rax, %rdi
callq 0xacb0
movl %r13d, 0xc(%rsp)
movw %ax, 0x10(%rsp)
movq %r12, %rdi
leaq 0xc(%rsp), %rsi
callq 0xac20
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10594
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf388
movq %rbp, %rdi
callq 0x10604
incl %r15d
jmp 0xcf2e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x10604
jmp 0xcfe9
jmp 0xcfe6
jmp 0xcfe6
movq %rax, %r14
movq %rbx, %rdi
callq 0x97f8
movq %r14, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::stabilizationProtocol()
void MP2Node::stabilizationProtocol() {
    for (auto pair : ht->hashTable) {
        auto nodes = findNodes(pair.first);
        for (auto node : nodes) {
            Message msg(-1, memberNode->addr, CREATE, pair.first, pair.second);
            sendMessage(*node.getAddress(), msg);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
movq 0x48(%rdi), %rcx
movq 0x20(%rcx), %rax
addq $0x10, %rcx
movq %rcx, 0x18(%rsp)
leaq 0x68(%rsp), %rcx
leaq 0xe8(%rsp), %r15
leaq 0xc8(%rsp), %r14
leaq 0x180(%rsp), %r12
leaq 0x108(%rsp), %r13
cmpq 0x18(%rsp), %rax
je 0xd191
movq %rax, 0x20(%rsp)
leaq 0x20(%rax), %rsi
leaq 0x88(%rsp), %rdi
movq %rcx, %rbp
callq 0xf454
movq %rbp, %rdi
leaq 0x88(%rsp), %rsi
callq 0x33a0
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0xd97e
movq %rbp, %rdi
callq 0x3120
movq 0x30(%rsp), %rbp
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq 0x28(%rsp), %rbp
je 0xd166
leaq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x1060e
movq 0x50(%rbx), %rsi
addq $0x8, %rsi
leaq 0x12(%rsp), %rdi
callq 0xac20
movq %r15, %rdi
leaq 0x88(%rsp), %rsi
callq 0x33a0
movq %r14, %rdi
leaq 0xa8(%rsp), %rsi
callq 0x33a0
movq %r12, %rdi
pushq $-0x1
popq %rsi
leaq 0x12(%rsp), %rdx
xorl %ecx, %ecx
movq %r15, %r8
movq %r14, %r9
callq 0x11ef6
movq %r14, %rdi
callq 0x3120
movq %r15, %rdi
callq 0x3120
leaq 0x48(%rsp), %rdi
callq 0x10686
leaq 0xc(%rsp), %rdi
movq %rax, %rsi
callq 0xac20
movq %r13, %rdi
movq %r12, %rsi
callq 0x11e20
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
movq %r13, %rdx
callq 0xdb48
movq %r13, %rdi
callq 0xf3c4
movq %r12, %rdi
callq 0xf3c4
leaq 0x48(%rsp), %rdi
callq 0x10604
addq $0x20, %rbp
jmp 0xd09f
leaq 0x30(%rsp), %rdi
callq 0x97f8
leaq 0x88(%rsp), %rdi
callq 0x9900
movq 0x20(%rsp), %rdi
callq 0x31d0
leaq 0x68(%rsp), %rcx
jmp 0xd044
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xd21b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3120
jmp 0xd21b
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0xf3c4
jmp 0xd1fa
movq %rax, %rbx
jmp 0xd211
movq %rax, %rbx
jmp 0xd1e3
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x3120
leaq 0xe8(%rsp), %rdi
callq 0x3120
jmp 0xd207
movq %rax, %rbx
jmp 0xd207
movq %rax, %rbx
leaq 0x180(%rsp), %rdi
callq 0xf3c4
leaq 0x48(%rsp), %rdi
callq 0x10604
leaq 0x30(%rsp), %rdi
callq 0x97f8
leaq 0x88(%rsp), %rdi
callq 0x9900
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::findNodes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<Node> MP2Node::findNodes(string key) {
	size_t pos = hashFunction(key);
	vector<Node> addr_vec;
	if (ring.size() >= 3) {
		// if pos <= min || pos > max, the leader is the min
		if (pos <= ring.at(0).getHashCode() || pos > ring.at(ring.size()-1).getHashCode()) {
			addr_vec.emplace_back(ring.at(0));
			addr_vec.emplace_back(ring.at(1));
			addr_vec.emplace_back(ring.at(2));
		}
		else {
			// go through the ring until pos <= node
			for (int i=1; i < (int)ring.size(); i++){
				Node addr = ring.at(i);
				if (pos <= addr.getHashCode()) {
					addr_vec.emplace_back(addr);
					addr_vec.emplace_back(ring.at((i+1)%ring.size()));
					addr_vec.emplace_back(ring.at((i+2)%ring.size()));
					break;
				}
			}
		}
	}
	return addr_vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x33a0
movq %r14, %rsi
callq 0xd6c6
movq %rax, %r12
movq %r14, %rdi
callq 0x3120
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x38(%r15), %rax
subq 0x30(%r15), %rax
cmpq $0x41, %rax
jb 0xda52
leaq 0x30(%r15), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x981a
movq %rax, %rdi
callq 0x10680
cmpq %rax, %r12
jbe 0xda11
movq 0x38(%r15), %rsi
subq 0x30(%r15), %rsi
sarq $0x5, %rsi
decq %rsi
movq %r14, %rdi
callq 0x981a
movq %rax, %rdi
callq 0x10680
cmpq %rax, %r12
jbe 0xda64
movq %r14, %rdi
xorl %esi, %esi
callq 0x981a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf418
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x981a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf418
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x981a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf418
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x3
popq %r13
leaq 0x8(%rsp), %rbp
movq 0x38(%r15), %rax
subq 0x30(%r15), %rax
leaq -0x2(%r13), %rsi
shrq $0x5, %rax
cltq
cmpq %rax, %rsi
jge 0xda52
movq %r14, %rdi
callq 0x981a
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1060e
movq %rbp, %rdi
callq 0x10680
cmpq %rax, %r12
jbe 0xdab1
movq %rbp, %rdi
callq 0x10604
incq %r13
jmp 0xda6d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf418
leaq -0x1(%r13), %rax
movq 0x38(%r15), %rcx
subq 0x30(%r15), %rcx
sarq $0x5, %rcx
xorl %edx, %edx
divq %rcx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x981a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf418
movq 0x38(%r15), %rcx
subq 0x30(%r15), %rcx
sarq $0x5, %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x981a
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf418
leaq 0x8(%rsp), %rdi
callq 0x10604
jmp 0xda52
jmp 0xdb24
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x10604
jmp 0xdb38
jmp 0xdb35
movq %rax, %r14
movq %rbx, %rdi
callq 0x97f8
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::clientRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MP2Node::clientRead(string key){
    // start a transaction
    Transaction transaction(READ, par->getcurrtime());
    transaction.key = key;
    txMap.emplace(transaction.txId, transaction);

    // send messages to all nodes who should hold the key
    auto nodes = findNodes(key);
    int txId = transaction.txId;
    for (int i = 0; i < nodes.size(); i++) {
        auto node = nodes[i];
        Message msg(txId, memberNode->addr, READ, key);
        msg.replica = static_cast<ReplicaType>(i);
        sendMessage(node.nodeAddress, msg);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdi
callq 0xabe4
leaq 0xa8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rcx)
leaq 0xc8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %dl, (%rcx)
andq $0x0, -0x48(%rcx)
leaq 0x98(%rsp), %rdi
movl $0x1, -0x38(%rcx)
movl 0x1ad00(%rip), %edx     # 0x28910
leal 0x1(%rdx), %esi
movl %esi, 0x1acf7(%rip)     # 0x28910
movl %edx, -0x40(%rcx)
movl %eax, -0x3c(%rcx)
movq %rbx, 0x10(%rsp)
movq %rbx, %rsi
callq 0x3170
leaq 0x88(%rsp), %rsi
leaq 0xc0(%r14), %rdi
leaq 0x80(%rsp), %rdx
callq 0x101c6
leaq 0x60(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x33a0
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movq %r14, %rsi
callq 0xd97e
leaq 0x60(%rsp), %rdi
callq 0x3120
movl 0x88(%rsp), %eax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
leaq 0xd8(%rsp), %r15
leaq 0xf8(%rsp), %rbx
leaq 0x170(%rsp), %r12
xorl %ebp, %ebp
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rbp, %rax
jbe 0xdd57
addq %r13, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1060e
movq 0x50(%r14), %rsi
addq $0x8, %rsi
leaq 0x22(%rsp), %rdi
callq 0xac20
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x33a0
movq %rbx, %rdi
movl 0xc(%rsp), %esi
leaq 0x22(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r15, %r8
callq 0x11fd8
movq %r15, %rdi
callq 0x3120
movl %ebp, 0xfc(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xac20
movq %r12, %rdi
movq %rbx, %rsi
callq 0x11e20
movq %r14, %rdi
leaq 0x1c(%rsp), %rsi
movq %r12, %rdx
callq 0xdb48
movq %r12, %rdi
callq 0xf3c4
movq %rbx, %rdi
callq 0xf3c4
leaq 0x40(%rsp), %rdi
callq 0x10604
incq %rbp
addq $0x20, %r13
jmp 0xdc9b
leaq 0x28(%rsp), %rdi
callq 0x97f8
leaq 0x80(%rsp), %rdi
callq 0xf3e8
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3120
jmp 0xdde8
jmp 0xdd91
movq %rax, %rbx
jmp 0xdde8
movq %rax, %rbx
jmp 0xddde
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x3120
jmp 0xddd4
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0xf3c4
jmp 0xddc2
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xf3c4
jmp 0xddd4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x10604
leaq 0x28(%rsp), %rdi
callq 0x97f8
leaq 0x80(%rsp), %rdi
callq 0xf3e8
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::clientDelete(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MP2Node::clientDelete(string key){
    // start a transaction
    Transaction transaction(DELETE, par->getcurrtime());
    transaction.key = key;
    txMap.emplace(transaction.txId, transaction);

    // send messages to all nodes who should hold the key
    auto nodes = findNodes(key);
    int txId = transaction.txId;
    for (int i = 0; i < nodes.size(); i++) {
        auto node = nodes[i];
        Message msg(txId, memberNode->addr, DELETE, key);
        msg.replica = static_cast<ReplicaType>(i);
        sendMessage(node.nodeAddress, msg);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdi
callq 0xabe4
leaq 0xa8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rcx)
leaq 0xc8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %dl, (%rcx)
andq $0x0, -0x48(%rcx)
leaq 0x98(%rsp), %rdi
movl $0x3, -0x38(%rcx)
movl 0x1a806(%rip), %edx     # 0x28910
leal 0x1(%rdx), %esi
movl %esi, 0x1a7fd(%rip)     # 0x28910
movl %edx, -0x40(%rcx)
movl %eax, -0x3c(%rcx)
movq %rbx, 0x10(%rsp)
movq %rbx, %rsi
callq 0x3170
leaq 0x88(%rsp), %rsi
leaq 0xc0(%r14), %rdi
leaq 0x80(%rsp), %rdx
callq 0x101c6
leaq 0x60(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x33a0
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movq %r14, %rsi
callq 0xd97e
leaq 0x60(%rsp), %rdi
callq 0x3120
movl 0x88(%rsp), %eax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
leaq 0xd8(%rsp), %r15
leaq 0xf8(%rsp), %rbx
leaq 0x170(%rsp), %r12
xorl %ebp, %ebp
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rbp, %rax
jbe 0xe251
addq %r13, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1060e
movq 0x50(%r14), %rsi
addq $0x8, %rsi
leaq 0x22(%rsp), %rdi
callq 0xac20
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x33a0
movq %rbx, %rdi
movl 0xc(%rsp), %esi
leaq 0x22(%rsp), %rdx
pushq $0x3
popq %rcx
movq %r15, %r8
callq 0x11fd8
movq %r15, %rdi
callq 0x3120
movl %ebp, 0xfc(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xac20
movq %r12, %rdi
movq %rbx, %rsi
callq 0x11e20
movq %r14, %rdi
leaq 0x1c(%rsp), %rsi
movq %r12, %rdx
callq 0xdb48
movq %r12, %rdi
callq 0xf3c4
movq %rbx, %rdi
callq 0xf3c4
leaq 0x40(%rsp), %rdi
callq 0x10604
incq %rbp
addq $0x20, %r13
jmp 0xe195
leaq 0x28(%rsp), %rdi
callq 0x97f8
leaq 0x80(%rsp), %rdi
callq 0xf3e8
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3120
jmp 0xe2e2
jmp 0xe28b
movq %rax, %rbx
jmp 0xe2e2
movq %rax, %rbx
jmp 0xe2d8
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x3120
jmp 0xe2ce
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0xf3c4
jmp 0xe2bc
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xf3c4
jmp 0xe2ce
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x10604
leaq 0x28(%rsp), %rdi
callq 0x97f8
leaq 0x80(%rsp), %rdi
callq 0xf3e8
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::createKeyValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ReplicaType)
bool MP2Node::createKeyValue(string key, string value, ReplicaType replica) {
	// Insert key, value, replicaType into the hash table
	Entry entry(value, this->par->getcurrtime(), replica);
	auto res = ht->create(key, entry.convertToString());
	return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x33a0
movq 0x58(%r14), %rdi
callq 0xabe4
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl %eax, %edx
movl %ebp, %ecx
callq 0x11268
leaq 0x48(%rsp), %rdi
callq 0x3120
movq 0x48(%r14), %r14
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x33a0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1146c
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x106ec
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
leaq 0x68(%rsp), %rdi
callq 0xf402
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
jmp 0xe3b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0xe3bf
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf402
jmp 0xe3d8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::readKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string MP2Node::readKey(string key) {
	// Read key from local hash table and return value
	auto val = ht->read(key);
	if (val.empty()) {
	    return val;
	}
	Entry entry(val);
	return entry.value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq 0x48(%rsi), %r15
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x33a0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x106fa
leaq 0x48(%rsp), %rdi
callq 0x3120
cmpq $0x0, 0x10(%rsp)
je 0xe469
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x33a0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x112e6
leaq 0x28(%rsp), %rdi
callq 0x3120
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a0
leaq 0x68(%rsp), %rdi
callq 0xf402
jmp 0xe4a7
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xe48c
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xe492
movups (%rax), %xmm0
movups %xmm0, (%rcx)
andq $0x0, 0x8(%rbx)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf402
jmp 0xe4e4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0xe4e4
jmp 0xe4e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::handleReadMessage(Message)
void MP2Node::handleReadMessage(Message msg) {
    string res = readKey(msg.key);
    Message reply(msg.transID, memberNode->addr, READREPLY, msg.key, res, msg.replica);
    if (res.empty()) {
        log->logReadFail(&msg.fromAddr, false, msg.transID, msg.key);
        reply.success = false;
    } else {
        log->logReadSuccess(&msg.fromAddr, false, msg.transID, msg.key, res);
        reply.success = true;
    }
    sendMessage(msg.fromAddr, reply);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsi), %r12
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x33a0
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe3e0
leaq 0xe8(%rsp), %rdi
callq 0x3120
movl 0x50(%r15), %ebp
movq 0x50(%r14), %rsi
addq $0x8, %rsi
leaq 0x22(%rsp), %rdi
movq %r13, 0x10(%rsp)
callq 0xac20
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
callq 0x33a0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x33a0
movl 0x4(%r15), %eax
movl %eax, (%rsp)
leaq 0x108(%rsp), %rdi
leaq 0x22(%rsp), %rdx
pushq $0x5
popq %rcx
leaq 0x88(%rsp), %r8
leaq 0x68(%rsp), %r9
movl %ebp, %esi
callq 0x11d34
leaq 0x68(%rsp), %rdi
callq 0x3120
leaq 0x88(%rsp), %rdi
callq 0x3120
cmpq $0x0, 0x30(%rsp)
movq 0x68(%r14), %rbp
je 0xee82
movl 0x50(%r15), %ebx
leaq 0xa8(%rsp), %rdi
movq %r12, %rsi
callq 0x33a0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x33a0
leaq 0x48(%r15), %rsi
leaq 0xa8(%rsp), %r13
leaq 0x48(%rsp), %r9
movq %rbp, %rdi
xorl %edx, %edx
movl %ebx, %ecx
movq %r13, %r8
callq 0xa564
leaq 0x48(%rsp), %rdi
callq 0x3120
movb $0x1, %r12b
jmp 0xeeaf
movl 0x50(%r15), %ebx
leaq 0xc8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x33a0
leaq 0x48(%r15), %rsi
xorl %r12d, %r12d
movq %rbp, %rdi
xorl %edx, %edx
movl %ebx, %ecx
movq %r13, %r8
callq 0xa856
movq %r13, %rdi
callq 0x3120
movb %r12b, 0x15c(%rsp)
addq $0x48, %r15
leaq 0x1c(%rsp), %rdi
movq %r15, %rsi
callq 0xac20
leaq 0x180(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x11e20
leaq 0x1c(%rsp), %rsi
leaq 0x180(%rsp), %rdx
movq %r14, %rdi
callq 0xdb48
leaq 0x180(%rsp), %rdi
callq 0xf3c4
leaq 0x108(%rsp), %rdi
callq 0xf3c4
leaq 0x28(%rsp), %rdi
callq 0x3120
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
jmp 0xef57
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x3120
jmp 0xef4f
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x3120
jmp 0xefa3
movq %rax, %r14
leaq 0x180(%rsp), %rdi
callq 0xf3c4
jmp 0xefa3
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x3120
jmp 0xef82
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x3120
jmp 0xefb0
movq %rax, %r14
movq %rbx, 0x10(%rsp)
jmp 0xefb0
movq %rax, %r14
jmp 0xefb0
movq %rax, %r14
leaq 0x108(%rsp), %rdi
callq 0xf3c4
movq 0x10(%rsp), %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::handleDeleteMessage(Message)
void MP2Node::handleDeleteMessage(Message msg) {
    Message reply(msg.transID, memberNode->addr, REPLY, msg.key, msg.value, msg.replica);
    if (!deletekey(msg.key)) {
        log->logDeleteFail(&msg.fromAddr, false, msg.transID, msg.key);
        reply.success = false;
    } else {
        log->logDeleteSuccess(&msg.fromAddr, false, msg.transID, msg.key);
        reply.success = true;
    }
    sendMessage(msg.fromAddr, reply);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
movl 0x50(%rsi), %ebp
movq 0x50(%rdi), %rsi
addq $0x8, %rsi
leaq 0x12(%rsp), %rdi
callq 0xac20
leaq 0x8(%r14), %r15
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x33a0
leaq 0x28(%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x33a0
movl 0x4(%r14), %eax
movl %eax, (%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x12(%rsp), %rdx
pushq $0x4
popq %rcx
leaq 0x58(%rsp), %r8
leaq 0x38(%rsp), %r9
movl %ebp, %esi
callq 0x11d34
leaq 0x38(%rsp), %rdi
callq 0x3120
leaq 0x58(%rsp), %rdi
callq 0x3120
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x33a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xe5dc
movl %eax, %r12d
leaq 0x18(%rsp), %rdi
callq 0x3120
movq 0x68(%rbx), %r13
movl 0x50(%r14), %ebp
testb %r12b, %r12b
je 0xf0a5
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x33a0
leaq 0x48(%r14), %rsi
movb $0x1, %r15b
movq %r13, %rdi
xorl %edx, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0xa6e8
jmp 0xf0ce
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x33a0
leaq 0x48(%r14), %rsi
xorl %r15d, %r15d
movq %r13, %rdi
xorl %edx, %edx
movl %ebp, %ecx
movq %r12, %r8
callq 0xa9c4
movq %r12, %rdi
callq 0x3120
movb %r15b, 0x10c(%rsp)
addq $0x48, %r14
leaq 0xc(%rsp), %rdi
movq %r14, %rsi
callq 0xac20
leaq 0x130(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x11e20
leaq 0xc(%rsp), %rsi
leaq 0x130(%rsp), %rdx
movq %rbx, %rdi
callq 0xdb48
leaq 0x130(%rsp), %rdi
callq 0xf3c4
leaq 0xb8(%rsp), %rdi
callq 0xf3c4
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0xf176
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0xf176
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0xf3c4
jmp 0xf19e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3120
jmp 0xf19e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3120
jmp 0xf18f
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3120
jmp 0xf1ab
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xf3c4
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/MP2Node.cpp
// Function: MP2Node::handleReplyMessage(Message)
void MP2Node::handleReplyMessage(Message msg) {
    int txId = msg.transID;
    auto it = txMap.find(txId);

    if (it != txMap.end()) {
        Transaction *transaction = &it->second;

        transaction->totalCount++;
        // READREPLY messages don't use success field, they use value field instead (if fail value is null)
        // see Message(string str) constructor
        if (msg.type == READREPLY && !msg.value.empty()) {
            transaction->successCount++;
            transaction->value = msg.value;
        } else if (msg.success) {
            transaction->successCount++;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x50(%rsi), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
addq $0xc0, %rdi
callq 0x1052e
addq $0xc8, %r14
cmpq %r14, %rax
je 0xf210
incl 0x2c(%rax)
cmpl $0x5, (%rbx)
jne 0xf207
cmpq $0x0, 0x30(%rbx)
je 0xf207
addq $0x28, %rbx
incl 0x28(%rax)
addq $0x60, %rax
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3170
jmp 0xf210
cmpb $0x1, 0x54(%rbx)
jne 0xf210
incl 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string HashTable::read(string key) {
	map<string, string>::iterator search;

	search = hashTable.find(key);
	if ( search != hashTable.end() ) {
		// Value found
		return search->second;
	}
	else {
		// Value not found
		return "";
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x10d7e
addq $0x10, %r14
cmpq %r14, %rax
je 0x1072a
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33a0
jmp 0x1073e
leaq 0x2b25(%rip), %rsi      # 0x13256
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x4bc2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool HashTable::update(string key, string newValue) {
	map<string, string>::iterator update;

	if (read(key).empty()) {
		// Key not found
		return false;
	}
	// Key found
	//update = hashTable.at(key) = newValue;
	hashTable.at(key) = newValue;
	// Update successful
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x33a0
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x106fa
leaq 0x28(%rsp), %rdi
movq 0x8(%rdi), %r12
callq 0x3120
leaq 0x8(%rsp), %rdi
callq 0x3120
testq %r12, %r12
je 0x107b2
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10b3c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3170
testq %r12, %r12
setne %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
nop
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::deleteKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool HashTable::deleteKey(string key) {
	uint eraseCount = 0;

	if (read(key).empty()) {
		// Key not found
		return false;
	}
	eraseCount = hashTable.erase(key);
	if ( eraseCount < 1 ) {
		// Could not erase
		return false;
	}
	// Delete was successful
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x33a0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x106fa
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x3120
movq %rsp, %rdi
callq 0x3120
testq %r15, %r15
je 0x10835
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10dbc
testl %eax, %eax
setne %al
jmp 0x10837
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retPrimaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retPrimaryPairs() {
	vector<pair<string, string>> primaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
		Entry entry(it->second);
		if ( PRIMARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			primaryPairs.emplace_back(temp);
		}
	}
	return primaryPairs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r15
addq $0x10, %r14
movq %rsp, %r12
leaq 0x20(%rsp), %r13
leaq 0x68(%rsp), %rbp
cmpq %r14, %r15
je 0x10911
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x33a0
movq %r13, %rdi
movq %r12, %rsi
callq 0x112e6
movq %r12, %rdi
callq 0x3120
cmpl $0x0, 0x44(%rsp)
jne 0x108fc
leaq 0x20(%r15), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x10c10
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10b9c
movq %rbp, %rdi
callq 0x10bd8
movq %r13, %rdi
callq 0xf402
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
jmp 0x108af
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x10938
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x10bd8
leaq 0x20(%rsp), %rdi
callq 0xf402
jmp 0x10954
movq %rax, %r14
jmp 0x10954
movq %rax, %r14
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x10bee
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retSecondaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retSecondaryPairs() {
	vector<pair<string, string>> secondaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
			Entry entry(it->second);
			if ( SECONDARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			secondaryPairs.emplace_back(temp);
		}
	}
	return secondaryPairs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r15
addq $0x10, %r14
movq %rsp, %r12
leaq 0x20(%rsp), %r13
leaq 0x68(%rsp), %rbp
cmpq %r14, %r15
je 0x109fd
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x33a0
movq %r13, %rdi
movq %r12, %rsi
callq 0x112e6
movq %r12, %rdi
callq 0x3120
cmpl $0x1, 0x44(%rsp)
jne 0x109e8
leaq 0x20(%r15), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x10c10
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10b9c
movq %rbp, %rdi
callq 0x10bd8
movq %r13, %rdi
callq 0xf402
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
jmp 0x1099b
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x10a24
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x10bd8
leaq 0x20(%rsp), %rdi
callq 0xf402
jmp 0x10a40
movq %rax, %r14
jmp 0x10a40
movq %rax, %r14
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x10bee
movq %r14, %rdi
callq 0x3490
// File: /workspace/github_cpp_makefile_star2_O2/tonymuu[P]distributed-kv-store/HashTable.cpp
// Function: HashTable::retTertiaryPairs[abi:cxx11]()
vector<pair<string, string>> HashTable::retTertiaryPairs() {
	vector<pair<string, string>> tertiaryPairs;

	for ( auto it = hashTable.begin(); it != hashTable.end(); ++it ) {
			Entry entry(it->second);
			if ( TERTIARY == entry.replica ) {
			pair<string, string> temp= make_pair(it->first, entry.value);
			tertiaryPairs.emplace_back(temp);
		}
	}
	return tertiaryPairs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %r15
addq $0x10, %r14
movq %rsp, %r12
leaq 0x20(%rsp), %r13
leaq 0x68(%rsp), %rbp
cmpq %r14, %r15
je 0x10ae9
leaq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x33a0
movq %r13, %rdi
movq %r12, %rsi
callq 0x112e6
movq %r12, %rdi
callq 0x3120
cmpl $0x2, 0x44(%rsp)
jne 0x10ad4
leaq 0x20(%r15), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x10c10
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10b9c
movq %rbp, %rdi
callq 0x10bd8
movq %r13, %rdi
callq 0xf402
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
jmp 0x10a87
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x10b10
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x10bd8
leaq 0x20(%rsp), %rdi
callq 0xf402
jmp 0x10b2c
movq %rax, %r14
jmp 0x10b2c
movq %rax, %r14
movq %rsp, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x10bee
movq %r14, %rdi
callq 0x3490