LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::MP1Node(Params*, EmulNet*, Log*, Address*)
MP1Node::MP1Node( Params *params, EmulNet *emul, Log *log, Address *address) {
	for( int i = 0; i < 6; i++ ) {
		NULLADDR[i] = 0;
	}
	this->memberNode = new Member;
    this->shouldDeleteMember = true;
	memberNode->inited = false;
	this->emulNet = emul;
	this->log = log;
	this->par = params;
	this->memberNode->addr = *address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x38265(%rip), %rcx     # 0x3dbe0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x2c(%rbp)
cmpl $0x6, -0x2c(%rbp)
jge 0x59a7
movq -0x48(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, 0x29(%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5989
movl $0xe8, %edi
callq 0x4350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x70b0
jmp 0x59c2
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, 0x28(%rax)
movq 0x20(%rax), %rcx
movb $0x0, 0xe(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rsi
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x18e70
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0xe8, %esi
callq 0x4360
movq -0x38(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::MP1Node(Member*, Params*, EmulNet*, Log*, Address*)
MP1Node::MP1Node(Member* member, Params *params, EmulNet *emul, Log *log, Address *address) {
    for( int i = 0; i < 6; i++ ) {
        NULLADDR[i] = 0;
    }
    this->memberNode = member;
    this->shouldDeleteMember = false;
    this->emulNet = emul;
    this->log = log;
    this->par = params;
    this->memberNode->addr = *address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x38181(%rip), %rcx     # 0x3dbe0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x6, -0x34(%rbp)
jge 0x5a8b
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, 0x29(%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5a6d
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rsi
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x18e70
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::initThisNode(Address*)
int MP1Node::initThisNode(Address *joinaddr) {
    /*
    * This function is partially implemented and may require changes
    */
	int id = *(int*)(&memberNode->addr.addr);
	int port = *(short*)(&memberNode->addr.addr[4]);

	memberNode->bFailed = false;
	memberNode->inited = true;
	memberNode->inGroup = false;
	// node is up!
	memberNode->nnb = 0;
	memberNode->heartbeat = 0;
	memberNode->pingCounter = TFAIL;
	memberNode->timeOutCounter = -1;
	initMemberListTable(memberNode);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x20(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x20(%rdi), %rax
movswl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movq 0x20(%rdi), %rax
movb $0x0, 0x10(%rax)
movq 0x20(%rdi), %rax
movb $0x1, 0xe(%rax)
movq 0x20(%rdi), %rax
movb $0x0, 0xf(%rax)
movq 0x20(%rdi), %rax
movl $0x0, 0x14(%rax)
movq 0x20(%rdi), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rdi), %rax
movl $0x5, 0x20(%rax)
movq 0x20(%rdi), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq 0x20(%rdi), %rsi
callq 0x5fc0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::finishUpThisNode()
int MP1Node::finishUpThisNode(){
    memberNode->inited = false;
    memberNode->inGroup = false;
    memberNode->nnb = 0;
    memberNode->heartbeat = 0;
    memberNode->memberList.clear();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movb $0x0, 0xe(%rcx)
movq 0x20(%rax), %rcx
movb $0x0, 0xf(%rcx)
movq 0x20(%rax), %rcx
movl $0x0, 0x14(%rcx)
movq 0x20(%rax), %rcx
movq $0x0, 0x18(%rcx)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x7280
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::sendJoinRepMsg(Address*)
void MP1Node::sendJoinRepMsg(Address *toAddr) {
    // Create the msg that includes header and my member list entires
    int mleSize = sizeof(int) + sizeof(short) + sizeof(long) + sizeof(long), numEntries = memberNode->memberList.size();
    size_t msgsize = sizeof(MessageHdr) + mleSize * numEntries;

    MessageHdr *msg;
    msg = (MessageHdr *) malloc(msgsize * sizeof(char));
    msg->msgType = JOINREP;

    serializeMemberList(msg);
    // Reply with JOINREP message
    emulNet->ENsend(&memberNode->addr, toAddr, (char *)msg, msgsize);

    free(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x16, -0x14(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x7330
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
cltq
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
callq 0x4490
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rsi
callq 0x6940
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl %eax, %r8d
callq 0xef60
movq -0x28(%rbp), %rdi
callq 0x4420
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::createAddressFromIdAndPort(int, short)
Address MP1Node::createAddressFromIdAndPort(int id, short port) {
    Address addr;
    addr.init();
    *(int *)(&(addr.addr))=id;
    *(short *)(&(addr.addr[4]))=port;
    return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movw %cx, %ax
movq %rdi, %rcx
movq %rcx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
callq 0x71f0
movq -0x28(%rbp), %rdi
callq 0x7300
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rdi)
movw -0x16(%rbp), %cx
movw %cx, 0x4(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::createMemberlistMap()
map<int, MemberListEntry*> MP1Node::createMemberlistMap() {
    map<int, MemberListEntry*> map;
    for (auto neighbour = memberNode->memberList.begin(); neighbour != memberNode->memberList.end(); neighbour++) {
        map[neighbour->id] = &*neighbour;
    }
    return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7740
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x7380
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x73f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x73b0
testb $0x1, %al
jne 0x6cd9
jmp 0x6d38
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7760
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x7420
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x7640
movq %rax, -0x60(%rbp)
jmp 0x6d05
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x7440
movq %rax, -0x40(%rbp)
jmp 0x6cb1
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7720
jmp 0x6d55
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6d4b
movq -0x58(%rbp), %rdi
callq 0x7720
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45b0
nop
// File: tonymuu[P]distributed-kv-store/MP1Node.cpp
// Function: MP1Node::getNodeFromMemberListTable(int)
MemberListEntry* MP1Node::getNodeFromMemberListTable(int id) {
    for(auto mle = memberNode->memberList.begin(); mle != memberNode->memberList.end(); ++mle) {
        if(mle->id == id) {
            return mle.base();
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x7380
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x73f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x73b0
testb $0x1, %al
jne 0x6e40
jmp 0x6e6f
leaq -0x20(%rbp), %rdi
callq 0x7420
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6e62
leaq -0x20(%rbp), %rdi
callq 0x7780
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e77
jmp 0x6e64
leaq -0x20(%rbp), %rdi
callq 0x75c0
jmp 0x6e18
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/./Queue.h
// Function: Queue::enqueue(std::queue<q_elt, std::deque<q_elt, std::allocator<q_elt>>>*, void*, int)
static bool enqueue(queue<q_elt> *queue, void *buffer, int size) {
		q_elt element(buffer, size);
		queue->emplace(element);
		//cout<<endl<<"QUEUE size at this point is: "<<queue->size();
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x18e10
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x95c0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/Application.cpp
// Function: Application::run()
int Application::run()
{
	int i;
	int timeWhenAllNodesHaveJoined = 0;
	// boolean indicating if all nodes have joined
	bool allNodesJoined = false;
	srand(time(NULL));

	// As time runs along
	for( par->globaltime = 0; par->globaltime < TOTAL_RUNNING_TIME; ++par->globaltime ) {
		// Run the membership protocol
		mp1Run();

		// Wait for all nodes to join
		if ( par->allNodesJoined == nodeCount && !allNodesJoined ) {
			timeWhenAllNodesHaveJoined = par->getcurrtime();
			allNodesJoined = true;
		}
		if ( par->getcurrtime() > timeWhenAllNodesHaveJoined + 50 ) {
			// Call the KV store functionalities
			mp2Run();
		}
		// Fail some nodes
		//fail();
	}

	// Clean up
	en->ENcleanup();
	en1->ENcleanup();

	for(i=0;i<=par->EN_GPSZ-1;i++) {
		 mp1[i]->finishUpThisNode();
	}

	return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x42f0
movl %eax, %edi
callq 0x4320
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2bc, 0x28(%rax)      # imm = 0x2BC
jge 0xf99a
movq -0x20(%rbp), %rdi
callq 0x100b0
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x2c(%rax), %eax
cmpl 0x2f717(%rip), %eax     # 0x3f060
jne 0xf965
testb $0x1, -0x11(%rbp)
jne 0xf965
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x18c60
movl %eax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x18c60
movl -0x10(%rbp), %ecx
addl $0x32, %ecx
cmpl %ecx, %eax
jle 0xf985
movq -0x20(%rbp), %rdi
callq 0x10350
jmp 0xf987
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xf91e
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xf3e0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xf3e0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x58(%rcx), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xf9f0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5f70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf9bb
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tonymuu[P]distributed-kv-store/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	delete en1;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
        delete members[i];
		delete mp1[i];
		delete mp2[i];
	}
	free(mp1);
	free(mp2);
    free(members);
	delete par;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x2dda5(%rip), %rcx     # 0x3dcd0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xff4a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xff66
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xff82
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x58(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x10026
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xffc1
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xffe5
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x10016
movq -0x48(%rbp), %rdi
callq 0x1dd70
movq -0x48(%rbp), %rdi
movl $0xf0, %esi
callq 0x4360
jmp 0x10018
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xff89
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x4420
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x4420
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x4420
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1006d
movq -0x50(%rbp), %rdi
movl $0x38, %esi
callq 0x4360
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
callq 0x14b30
addq $0x50, %rsp
popq %rbp
retq
// File: tonymuu[P]distributed-kv-store/Application.cpp
// Function: Application::insertTestKVPairs()
void Application::insertTestKVPairs() {
	int number = 0;

	/*
	 * Init a few test key value pairs
	 */
	initTestKVPairs();

	for ( map<string, string>::iterator it = testKVPairs.begin(); it != testKVPairs.end(); ++it ) {
		// Step 1. Find a node that is alive
		number = findARandomNodeThatIsAlive();

		// Step 2. Issue a create operation
		log->LOG(&mp2[number]->getMemberNode()->addr, "CREATE OPERATION KEY: %s VALUE: %s at time: %d", it->first.c_str(), it->second.c_str(), par->getcurrtime());
		mp2[number]->clientCreate(it->first, it->second);
	}

	cout<<endl<<"Sent " <<testKVPairs.size() <<" create messages to the ring"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x14920
movq -0x78(%rbp), %rdi
addq $0x60, %rdi
callq 0x14ef0
movq %rax, -0x18(%rbp)
movq -0x78(%rbp), %rdi
addq $0x60, %rdi
callq 0x14f50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14f20
testb $0x1, %al
jne 0x1066b
jmp 0x107c4
movq -0x78(%rbp), %rdi
callq 0x148d0
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x38(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14b10
addq $0x8, %rax
movq %rax, -0xa0(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x14f80
movq %rax, %rdi
callq 0x4150
movq -0x80(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x14f80
movq %rax, %rdi
addq $0x20, %rdi
callq 0x4150
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq 0x58(%rax), %rdi
callq 0x18c60
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %r8
movl %eax, %r9d
leaq 0x1bc80(%rip), %rdx     # 0x2c392
xorl %eax, %eax
callq 0x17ae0
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rdi
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
callq 0x14f80
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4160
movq -0x80(%rbp), %rdi
callq 0x14f80
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x60(%rbp), %rdi
callq 0x4160
jmp 0x10760
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x1ecc0
jmp 0x10776
leaq -0x60(%rbp), %rdi
callq 0x4200
leaq -0x40(%rbp), %rdi
callq 0x4200
leaq -0x18(%rbp), %rdi
callq 0x14fa0
jmp 0x10644
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x107b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4200
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x10830
movq 0x2d7f5(%rip), %rdi     # 0x3dfc0
movq 0x2d7d6(%rip), %rsi     # 0x3dfa8
callq 0x4390
movq %rax, %rdi
leaq 0x1bbe0(%rip), %rsi     # 0x2c3c1
callq 0x4330
movq -0x78(%rbp), %rdi
movq %rax, -0xb0(%rbp)
addq $0x60, %rdi
callq 0x14c80
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x40c0
movq %rax, %rdi
leaq 0x1bbb4(%rip), %rsi     # 0x2c3c7
callq 0x4330
movq %rax, %rdi
movq 0x2d786(%rip), %rsi     # 0x3dfa8
callq 0x4390
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/Application.cpp
// Function: Application::findARandomNodeThatIsAlive()
int Application::findARandomNodeThatIsAlive() {
	int number;
	do {
		number = (rand()%par->EN_GPSZ);
	}while (mp2[number]->getMemberNode()->bFailed);
	return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x40e0
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
cltd
idivl 0x18(%rcx)
movl %edx, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14b10
testb $0x1, 0x10(%rax)
jne 0x148e4
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/Application.cpp
// Function: Application::initTestKVPairs()
void Application::initTestKVPairs() {
	srand(time(NULL));
	int i;
	string key;
	key.clear();
	testKVPairs.clear();
	int alphanumLen = sizeof(alphanum) - 1;
	while ( testKVPairs.size() != NUMBER_OF_INSERTS ) {
		for ( i = 0; i < KEY_LENGTH; i++ ) {
			key.push_back(alphanum[rand()%alphanumLen]);
		}
		string value = "value" + to_string(rand()%NUMBER_OF_INSERTS);
		testKVPairs[key] = value;
		key.clear();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x42f0
movl %eax, %edi
callq 0x4320
leaq -0x30(%rbp), %rdi
callq 0x44b0
leaq -0x30(%rbp), %rdi
callq 0x4470
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
callq 0x14c60
movl $0x3e, -0x34(%rbp)
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
callq 0x14c80
cmpq $0x64, %rax
je 0x14aa9
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x149dc
callq 0x40e0
movl -0x34(%rbp), %ecx
cltd
idivl %ecx
movslq %edx, %rax
leaq 0x17e61(%rip), %rcx     # 0x2c810
movsbl (%rax,%rcx), %esi
leaq -0x30(%rbp), %rdi
callq 0x42c0
jmp 0x149be
jmp 0x149c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14994
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x14abb
callq 0x40e0
movl %eax, %esi
movslq %esi, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %esi
leaq -0x88(%rbp), %rdi
callq 0x14cf0
jmp 0x14a0d
leaq 0x17978(%rip), %rsi     # 0x2c38c
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x14ca0
jmp 0x14a26
leaq -0x88(%rbp), %rdi
callq 0x4200
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
leaq -0x30(%rbp), %rsi
callq 0x14e10
movq %rax, -0x98(%rbp)
jmp 0x14a4f
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4050
jmp 0x14a61
leaq -0x30(%rbp), %rdi
callq 0x4470
leaq -0x68(%rbp), %rdi
callq 0x4200
jmp 0x14973
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4200
jmp 0x14abb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4200
jmp 0x14abb
leaq -0x30(%rbp), %rdi
callq 0x4200
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x4200
movq -0x40(%rbp), %rdi
callq 0x45b0
nopl (%rax)
// File: tonymuu[P]distributed-kv-store/./Member.h
// Function: Address::getAddress[abi:cxx11]() const
string getAddress() const {
		int id = 0;
		short port;
		memcpy(&id, &addr[0], sizeof(int));
		memcpy(&port, &addr[4], sizeof(short));
		return to_string(id) + ":" + to_string(port);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, -0x14(%rbp)
movl (%rax), %ecx
movl %ecx, -0x14(%rbp)
movw 0x4(%rax), %ax
movw %ax, -0x16(%rbp)
movl -0x14(%rbp), %esi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x14cf0
movq -0x90(%rbp), %rsi
leaq 0x18114(%rip), %rdx     # 0x2ccc1
leaq -0x38(%rbp), %rdi
callq 0x157e0
jmp 0x14bb8
movswl -0x16(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x14cf0
jmp 0x14bca
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x15710
jmp 0x14be3
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x38(%rbp), %rdi
callq 0x4200
leaq -0x58(%rbp), %rdi
callq 0x4200
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x14c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x14c45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4200
leaq -0x38(%rbp), %rdi
callq 0x4200
leaq -0x58(%rbp), %rdi
callq 0x4200
movq -0x60(%rbp), %rdi
callq 0x45b0
// File: tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logCreateSuccess(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::logCreateSuccess(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: create 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x18072
leaq 0x1495f(%rip), %rsi     # 0x2c9aa
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x18056
jmp 0x18086
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x18138
leaq 0x1493d(%rip), %rsi     # 0x2c9b6
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x18084
jmp 0x18086
leaq -0x48(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x74(%rbp)
jmp 0x180a8
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4150
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x2f8c1(%rip), %rdi     # 0x479b0
movq %rdi, -0x90(%rbp)
leaq 0x148c0(%rip), %rsi     # 0x2c9bd
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x18126
leaq -0x48(%rbp), %rdi
callq 0x4200
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x181c2
leaq 0x1480f(%rip), %rsi     # 0x2c9aa
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x181a6
jmp 0x181d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x18288
leaq 0x147ed(%rip), %rsi     # 0x2c9b6
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x181d4
jmp 0x181d6
leaq -0x48(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x74(%rbp)
jmp 0x181f8
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4150
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x2fb61(%rip), %rdi     # 0x47da0
movq %rdi, -0x90(%rbp)
leaq 0x147ac(%rip), %rsi     # 0x2c9f9
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x18276
leaq -0x48(%rbp), %rdi
callq 0x4200
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logUpdateSuccess(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::logUpdateSuccess(Address * address, bool isCoordinator, int transID, string key, string newValue){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: update success at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), newValue.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x18312
leaq 0x146bf(%rip), %rsi     # 0x2c9aa
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x182f6
jmp 0x18326
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x183d8
leaq 0x1469d(%rip), %rsi     # 0x2c9b6
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x18324
jmp 0x18326
leaq -0x48(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x74(%rbp)
jmp 0x18348
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4150
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x2fe01(%rip), %rdi     # 0x48190
movq %rdi, -0x90(%rbp)
leaq 0x14696(%rip), %rsi     # 0x2ca33
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x183c6
leaq -0x48(%rbp), %rdi
callq 0x4200
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x1845a
leaq 0x14577(%rip), %rsi     # 0x2c9aa
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x1843e
jmp 0x1846e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x184f7
leaq 0x14555(%rip), %rsi     # 0x2c9b6
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x1846c
jmp 0x1846e
leaq -0x40(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x64(%rbp)
jmp 0x18490
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x300c6(%rip), %rdi     # 0x48580
movq %rdi, -0x80(%rbp)
leaq 0x145aa(%rip), %rsi     # 0x2ca6f
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x184e5
leaq -0x40(%rbp), %rdi
callq 0x4200
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45b0
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x186ba
leaq 0x14317(%rip), %rsi     # 0x2c9aa
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x1869e
jmp 0x186ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x18757
leaq 0x142f5(%rip), %rsi     # 0x2c9b6
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x186cc
jmp 0x186ce
leaq -0x40(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x64(%rbp)
jmp 0x186f0
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x30646(%rip), %rdi     # 0x48d60
movq %rdi, -0x80(%rbp)
leaq 0x143b5(%rip), %rsi     # 0x2cada
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x18745
leaq -0x40(%rbp), %rdi
callq 0x4200
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45b0
// File: tonymuu[P]distributed-kv-store/Log.cpp
// Function: Log::logUpdateFail(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::logUpdateFail(Address * address, bool isCoordinator, int transID, string key, string newValue){
    static char stdstring[1000];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: update fail at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), newValue.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x187d2
leaq 0x141ff(%rip), %rsi     # 0x2c9aa
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x187b6
jmp 0x187e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4200
jmp 0x18898
leaq 0x141dd(%rip), %rsi     # 0x2c9b6
leaq -0x48(%rbp), %rdi
callq 0x44a0
jmp 0x187e4
jmp 0x187e6
leaq -0x48(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x74(%rbp)
jmp 0x18808
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4150
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x30901(%rip), %rdi     # 0x49150
movq %rdi, -0x90(%rbp)
leaq 0x142aa(%rip), %rsi     # 0x2cb07
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x18886
leaq -0x48(%rbp), %rdi
callq 0x4200
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x44b0
testb $0x1, -0x11(%rbp)
je 0x1891a
leaq 0x140b7(%rip), %rsi     # 0x2c9aa
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x188fe
jmp 0x1892e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4200
jmp 0x189b7
leaq 0x14095(%rip), %rsi     # 0x2c9b6
leaq -0x40(%rbp), %rdi
callq 0x44a0
jmp 0x1892c
jmp 0x1892e
leaq -0x40(%rbp), %rdi
callq 0x4150
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x18c60
movl %eax, -0x64(%rbp)
jmp 0x18950
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4150
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x30bc6(%rip), %rdi     # 0x49540
movq %rdi, -0x80(%rbp)
leaq 0x141bb(%rip), %rsi     # 0x2cb40
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x17ae0
jmp 0x189a5
leaq -0x40(%rbp), %rdi
callq 0x4200
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45b0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x18e70
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movb 0xe(%rax), %al
andb $0x1, %al
movb %al, 0xe(%rdi)
movq -0x10(%rbp), %rax
movb 0xf(%rax), %al
andb $0x1, %al
movb %al, 0xf(%rdi)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, 0x10(%rdi)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, 0x14(%rdi)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x24(%rdi)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x19450
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x40(%rdi)
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x196a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x98, %rsi
addq $0x98, %rdi
callq 0x196a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xf1a5(%rip), %rdi      # 0x2cc27
leaq 0xeeb2(%rip), %rsi      # 0x2c93b
callq 0x4410
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1dab1
leaq 0xf190(%rip), %rdi      # 0x2cc33
movb $0x0, %al
callq 0x4070
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xf166(%rip), %rsi      # 0x2cc5b
movb $0x0, %al
callq 0x44d0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x4400
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xf0e7(%rip), %rsi      # 0x2cc64
movb $0x0, %al
callq 0x44d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4400
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0xf09d(%rip), %rsi      # 0x2cc70
movb $0x0, %al
callq 0x44d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4400
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x15010
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x15010
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x70(%rbp)
callq 0x15010
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x68(%rbp)
callq 0x44b0
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x60(%rbp)
callq 0x219c0
movq -0x50(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x219e0
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x38, %edi
callq 0x4350
movq %rax, -0x48(%rbp)
jmp 0x1dcb6
movq -0x48(%rbp), %rdi
callq 0x263a0
jmp 0x1dcc1
movq -0x80(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rsi
movq 0x50(%rax), %rdi
addq $0x8, %rdi
callq 0x18e70
jmp 0x1dce0
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
leaq 0xefd1(%rip), %rsi      # 0x2ccc0
callq 0x44a0
jmp 0x1dcf6
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1dd27
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x4360
movq -0x58(%rbp), %rdi
callq 0x21a00
movq -0x60(%rbp), %rdi
callq 0x21a20
movq -0x68(%rbp), %rdi
callq 0x4200
movq -0x70(%rbp), %rdi
callq 0x15080
movq -0x78(%rbp), %rdi
callq 0x15080
movq -0x50(%rbp), %rdi
callq 0x15080
movq -0x38(%rbp), %rdi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x15010
movl $0x0, -0x14(%rbp)
movq -0x68(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rcx, -0x80(%rbp)
movq 0x50(%rax), %rdi
addq $0x28, %rdi
callq 0x7330
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x1e12b
leaq -0x1c(%rbp), %rdi
callq 0x71f0
jmp 0x1e039
movq -0x68(%rbp), %rax
movq 0x50(%rax), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x21e80
movq %rax, -0x88(%rbp)
jmp 0x1e058
movq -0x88(%rbp), %rdi
callq 0x19050
movl %eax, -0x8c(%rbp)
jmp 0x1e06c
movq -0x68(%rbp), %rax
movl -0x8c(%rbp), %ecx
movl %ecx, -0x30(%rbp)
movq 0x50(%rax), %rdi
addq $0x28, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x21e80
movq %rax, -0x98(%rbp)
jmp 0x1e094
movq -0x98(%rbp), %rdi
callq 0x19060
movw %ax, -0x9a(%rbp)
jmp 0x1e0a9
movw -0x9a(%rbp), %ax
movw %ax, -0x32(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
movw -0x32(%rbp), %ax
movw %ax, -0x18(%rbp)
leaq -0x5e(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x18e40
jmp 0x1e0d1
leaq -0x58(%rbp), %rdi
leaq -0x5e(%rbp), %rsi
callq 0x26100
jmp 0x1e0e0
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x21ec0
jmp 0x1e0ef
leaq -0x58(%rbp), %rdi
callq 0x26200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1e14b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x26200
jmp 0x1e14b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1e13e
movq -0x78(%rbp), %rdi
callq 0x15080
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x15080
movq -0x28(%rbp), %rdi
callq 0x45b0
nopl (%rax)