LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::checkMessages()
void MP1Node::checkMessages() {
    void *ptr;
    int size;

    // Pop waiting messages from memberNode's mp1q
    while ( !memberNode->mp1q.empty() ) {
    	ptr = memberNode->mp1q.front().elt;
    	size = memberNode->mp1q.front().size;
    	memberNode->mp1q.pop();
    	recvCallBack((void *)memberNode, (char *)ptr, size);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x48, %rdi
callq 0x46d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3e4d
jmp 0x3ea9
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x48, %rdi
callq 0x46f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x20(%rax), %rdi
addq $0x48, %rdi
callq 0x46f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0x20(%rax), %rdi
addq $0x48, %rdi
callq 0x4710
movq -0x20(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x3ef0
jmp 0x3e34
addq $0x20, %rsp
popq %rbp
retq
nop
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::nodeLoopOps()
void MP1Node::nodeLoopOps() {

	/*
	 * Your code goes here
	 */
    increaseSelfHeartbeat();
	deleteFailedNodes();
    sendMemberListToGroup();

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x40e0
movq -0x10(%rbp), %rdi
callq 0x41f0
movq -0x10(%rbp), %rdi
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::recvCallBack(void*, char*, int)
bool MP1Node::recvCallBack(void *env, char *data, int size ) {
	/*
	 * Your code goes here
	 */
    MessageHdr *msg = (MessageHdr *) data;
    char *msgBody = (char *)(msg+1);
    Address senderAddr;
    long senderHeartbeat;
    switch (msg->msgType) {
        case JOINREQ:
            // create JOINREP message
            memcpy(&senderAddr, (char *)(msg+1), sizeof(memberNode->addr.addr));
            memcpy(&senderHeartbeat, (char *)(msg+1) + 1 + sizeof(memberNode->addr.addr), sizeof(long));
            addOrUpdateMember(senderAddr, senderHeartbeat);
            sendJoinRepMsg(senderAddr);
            break;
        case JOINREP:
            memberNode->inGroup = true;
            updateMemberList(msgBody);
            break;
        case UPDATEMEMLIST:
            updateMemberList(msgBody);
            break;
        default:
            return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0x4620
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
testl %eax, %eax
je 0x3f4f
jmp 0x3f3b
movl -0x58(%rbp), %eax
subl $0x1, %eax
je 0x3fa7
jmp 0x3f45
movl -0x58(%rbp), %eax
subl $0x2, %eax
je 0x3fbe
jmp 0x3fcd
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movl %ecx, -0x3e(%rbp)
movw 0x8(%rax), %ax
movw %ax, -0x3a(%rbp)
movq -0x30(%rbp), %rax
movq 0xb(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x4e(%rbp), %rdi
leaq -0x3e(%rbp), %rsi
callq 0x9a40
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq -0x4e(%rbp), %rsi
callq 0x3c30
leaq -0x54(%rbp), %rdi
leaq -0x3e(%rbp), %rsi
callq 0x9a40
movq -0x60(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x3ff0
jmp 0x3fd3
movq -0x60(%rbp), %rdi
movq 0x20(%rdi), %rax
movb $0x1, 0xf(%rax)
movq -0x38(%rbp), %rsi
callq 0x4030
jmp 0x3fd3
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4030
jmp 0x3fd3
movb $0x0, -0x1(%rbp)
jmp 0x3fd7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::updateMemberList(char*)
void MP1Node::updateMemberList(char *data)
{
    int numOfMembers;
    memcpy(&numOfMembers, (char *)data, sizeof(int));
    MemberListEntry* memberListEntries = (MemberListEntry*) (data + sizeof(int));
    for (int i = 0; i < numOfMembers; ++i)
    {
        Address address = getAddressFromIPAndPort(memberListEntries[i].id,
                                                  memberListEntries[i].port);
        addOrUpdateMember(address, memberListEntries[i].heartbeat);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x40d1
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
leaq -0x2a(%rbp), %rdi
movswl 0x4(%rax), %edx
callq 0x36d0
leaq -0x30(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0x9a40
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq -0x30(%rbp), %rsi
callq 0x3c30
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4064
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::increaseSelfHeartbeat()
void MP1Node::increaseSelfHeartbeat()
{
    ++memberNode->heartbeat;
    for (vector<MemberListEntry>::iterator iter = memberNode->memberList.begin();
            iter != memberNode->memberList.end(); ++iter)
    {
        Address addr = getAddressFromIPAndPort(iter->id, iter->port);
        if (addr == memberNode->addr)
        {
            iter->heartbeat = memberNode->heartbeat;
            iter->timestamp = par->getcurrtime();
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rcx
movq 0x18(%rcx), %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x47a0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4810
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x47d0
testb $0x1, %al
jne 0x4140
jmp 0x41dc
leaq -0x10(%rbp), %rdi
callq 0x4840
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4840
movl -0x2c(%rbp), %esi
leaq -0x1e(%rbp), %rdi
movswl 0x4(%rax), %edx
callq 0x36d0
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq -0x1e(%rbp), %rdi
callq 0x9aa0
testb $0x1, %al
jne 0x4182
jmp 0x41cc
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4840
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rdx, 0x8(%rcx)
movq 0x18(%rax), %rdi
callq 0x99f0
cltq
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4840
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x41dc
jmp 0x41ce
leaq -0x10(%rbp), %rdi
callq 0x4860
jmp 0x4115
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::deleteFailedNodes()
void MP1Node::deleteFailedNodes()
{
    long currentTime = par->getcurrtime();
    for (int i = memberNode->memberList.size() - 1; i >= 0; i--)
    {
        if (currentTime - memberNode->memberList[i].timestamp >= TREMOVE)
        {
            Address addr = getAddressFromIPAndPort(memberNode->memberList[i].id,
				memberNode->memberList[i].port);
            log->logNodeRemove(&memberNode->addr, &addr);
            memberNode->memberList.erase(begin(memberNode->memberList) + i);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x18(%rax), %rdi
callq 0x99f0
movl %eax, %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x10(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4750
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4325
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4780
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq 0x10(%rcx), %rax
cmpq $0x14, %rax
jl 0x4315
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4780
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x5c(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4780
movl -0x5c(%rbp), %esi
leaq -0x1a(%rbp), %rdi
movswl 0x4(%rax), %edx
callq 0x36d0
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq -0x1a(%rbp), %rdx
callq 0x9500
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x28, %rcx
movq %rcx, -0x58(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4920
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4950
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4990
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x48b0
movq %rax, -0x40(%rbp)
jmp 0x4317
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x422e
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::sendMemberListToGroup()
void MP1Node::sendMemberListToGroup()
{
    long currentTime = par->getcurrtime();

	for (int i = 0; i < TPROP; i++) {

		/* initialize random seed: */
		srand (currentTime);

		/* generate secret number between 1 and 10: */
		int idx = rand() % memberNode->memberList.size();

	    if (currentTime - memberNode->memberList[idx].timestamp >= TFAIL)
	    {
	        continue;
	    }
	    Address addr = getAddressFromIPAndPort(memberNode->memberList[idx].id,
			memberNode->memberList[idx].port);
	    sendMemberListToMember(addr, UPDATEMEMLIST);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0x99f0
cltq
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x443e
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x31f0
callq 0x3070
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x40(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4750
movq %rax, %rcx
movq -0x40(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq -0x30(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4780
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq 0x10(%rcx), %rax
cmpq $0x5, %rax
jl 0x43cf
jmp 0x4430
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4780
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x44(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4780
movl -0x44(%rbp), %esi
leaq -0x1e(%rbp), %rdi
movswl 0x4(%rax), %edx
callq 0x36d0
leaq -0x24(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
callq 0x9a40
movq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x2, %edx
callq 0x44e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x435a
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/MP1Node.cpp
// Function: MP1Node::sendMemberListToMember(Address, MsgTypes)
void MP1Node::sendMemberListToMember(Address toAddress, MsgTypes msgType)
{
    int numOfMembers = memberNode->memberList.size();
    size_t msgsize = sizeof(MessageHdr) + sizeof(long) + numOfMembers * sizeof(MemberListEntry);
    MessageHdr *msg = (MessageHdr *) malloc(msgsize * sizeof(char));

    // create JOINREP message: format of data is {struct MemberListEntry}
    msg->msgType = msgType;
    memcpy((char *)(msg+1), &numOfMembers, sizeof(int));
    char *p = (char *)(msg+1) + sizeof(int);
    for (vector<MemberListEntry>::const_iterator iter = memberNode->memberList.begin();
            iter != memberNode->memberList.end(); ++iter)
    {
        memcpy(p, &(*iter), sizeof(MemberListEntry));
        p += sizeof(MemberListEntry);
    }

    // send JOINREQ message to introducer member
    emulNet->ENsend(&memberNode->addr, &toAddress, (char *)msg, msgsize);

    free(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4750
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
imulq $0x18, %rax, %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
callq 0x32f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rcx
movl %edx, (%rcx)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %edx
movl %edx, 0x4(%rcx)
movq -0x28(%rbp), %rcx
addq $0x4, %rcx
addq $0x4, %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x47a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4990
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x28, %rdi
callq 0x4810
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x49d0
testb $0x1, %al
jne 0x45a0
jmp 0x45e5
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a10
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a30
jmp 0x4578
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rax), %rsi
addq $0x8, %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl %eax, %r8d
callq 0x6e40
movq -0x28(%rbp), %rdi
callq 0x32c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::EmulNet(Params*)
EmulNet::EmulNet(Params *p)
{
	//trace.funcEntry("EmulNet::EmulNet");
	int i,j;
	par = p;
	emulnet.setNextId(1);
	emulnet.settCurrBuffSize(0);
	enInited=0;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			sent_msgs[i][j] = 0;
			recv_msgs[i][j] = 0;
		}
	}
	//trace.funcExit("EmulNet::EmulNet", SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0xe2a9(%rip), %rax      # 0x14cc8
movq %rax, (%rdi)
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
movq %rdi, -0x30(%rbp)
callq 0x7500
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x1, %esi
callq 0x7520
jmp 0x6a4e
movq -0x38(%rbp), %rdi
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
xorl %esi, %esi
callq 0x7540
jmp 0x6a62
movq -0x38(%rbp), %rax
movl $0x0, 0x1b7e490(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x6b09
movl $0x0, -0x18(%rbp)
cmpl $0xe10, -0x18(%rbp)     # imm = 0xE10
jge 0x6af9
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x14(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6a8b
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7560
jmp 0x6b0f
jmp 0x6afb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6a77
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::EmulNet(EmulNet&)
EmulNet::EmulNet(EmulNet &anotherEmulNet) {
	int i, j;
	this->par = anotherEmulNet.par;
	this->enInited = anotherEmulNet.enInited;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			this->sent_msgs[i][j] = anotherEmulNet.sent_msgs[i][j];
			this->recv_msgs[i][j] = anotherEmulNet.recv_msgs[i][j];
		}
	}
	this->emulnet = anotherEmulNet.emulnet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0xe179(%rip), %rax      # 0x14cb8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
movq %rdi, -0x38(%rbp)
callq 0x7500
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x1b7e490(%rcx), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x6c34
movl $0x0, -0x18(%rbp)
cmpl $0xe10, -0x18(%rbp)     # imm = 0xE10
jge 0x6c24
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq %rax, %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rcx
addq $0xdbf250, %rcx         # imm = 0xDBF250
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x14(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6b91
jmp 0x6c26
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b7d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
callq 0x7570
jmp 0x6c51
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7560
movq -0x20(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::operator=(EmulNet&)
EmulNet& EmulNet::operator =(EmulNet &anotherEmulNet) {
	int i, j;
	this->par = anotherEmulNet.par;
	this->enInited = anotherEmulNet.enInited;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			this->sent_msgs[i][j] = anotherEmulNet.sent_msgs[i][j];
			this->recv_msgs[i][j] = anotherEmulNet.recv_msgs[i][j];
		}
	}
	this->emulnet = anotherEmulNet.emulnet;
	return *this;
}

// 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)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x1b7e490(%rcx), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x6d72
movl $0x0, -0x18(%rbp)
cmpl $0xe10, -0x18(%rbp)     # imm = 0xE10
jge 0x6d62
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq %rax, %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rcx
addq $0xdbf250, %rcx         # imm = 0xDBF250
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x14(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6ccf
jmp 0x6d64
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6cbb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
callq 0x7570
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::ENinit(Address*, short)
void *EmulNet::ENinit(Address *myaddr, short port) {
	// Initialize data structures for this member
	*(int *)(myaddr->addr) = emulnet.nextid++;
    *(short *)(&myaddr->addr[4]) = 0;
	return myaddr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movl 0x1b7e4a0(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1b7e4a0(%rax)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::ENsend(Address*, Address*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int EmulNet::ENsend(Address *myaddr, Address *toaddr, string data) {
	char * str = (char *) malloc(data.length() * sizeof(char));
	memcpy(str, data.c_str(), data.size());
	int ret = this->ENsend(myaddr, toaddr, str, (data.length() * sizeof(char)));
	free(str);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rcx, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x3340
movq %rax, %rdi
shlq $0x0, %rdi
callq 0x32f0
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x30b0
movq -0x58(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x3150
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x3190
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3340
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
shlq $0x0, %rax
movl %eax, %r8d
callq 0x6e40
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32c0
movl -0x2c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::ENrecv(Address*, int (*)(void*, char*, int), timeval*, int, void*)
int EmulNet::ENrecv(Address *myaddr, int (* enq)(void *, char *, int), struct timeval *t, int times, void *queue){
	// times is always assumed to be 1
	int i;
	char* tmp;
	int sz;
	en_msg *emsg;

	for( i = emulnet.currbuffsize - 1; i >= 0; i-- ) {
		emsg = emulnet.buff[i];

		if ( 0 == strcmp(emsg->to.addr, myaddr->addr) ) {
			sz = emsg->size;
			tmp = (char *) malloc(sz * sizeof(char));
			memcpy(tmp, (char *)(emsg+1), sz);

			emulnet.buff[i] = emulnet.buff[emulnet.currbuffsize-1];
			emulnet.currbuffsize--;

			(*enq)(queue, (char *)tmp, sz);

			free(emsg);

			int dst = *(int *)(myaddr->addr);
			int time = par->getcurrtime();

			assert(dst <= MAX_NODES);
			assert(time < MAX_TIME);

			recv_msgs[dst][time]++;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x1b7e4a4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x72ad
movq -0x60(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x1b7e4b0(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0xa, %rdi
movq -0x10(%rbp), %rsi
callq 0x3300
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x729d
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rdi
shlq $0x0, %rdi
callq 0x32f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x10, %rsi
movslq -0x44(%rbp), %rdx
callq 0x3190
movq -0x60(%rbp), %rax
movl 0x1b7e4a4(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x1b7e4b0(%rax,%rcx,8), %rdx
movslq -0x34(%rbp), %rcx
movq %rdx, 0x1b7e4b0(%rax,%rcx,8)
movl 0x1b7e4a4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1b7e4a4(%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
callq *%rax
movq -0x50(%rbp), %rdi
callq 0x32c0
movq -0x60(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x54(%rbp)
movq 0x8(%rax), %rdi
callq 0x99f0
movl %eax, -0x58(%rbp)
cmpl $0x3e8, -0x54(%rbp)     # imm = 0x3E8
jg 0x722f
jmp 0x724e
leaq 0x7f44(%rip), %rdi      # 0xf17a
leaq 0x7ebc(%rip), %rsi      # 0xf0f9
movl $0xa9, %edx
leaq 0x7f42(%rip), %rcx      # 0xf18b
callq 0x3130
cmpl $0xe10, -0x58(%rbp)     # imm = 0xE10
jge 0x7259
jmp 0x7278
leaq 0x7edc(%rip), %rdi      # 0xf13c
leaq 0x7e92(%rip), %rsi      # 0xf0f9
movl $0xaa, %edx
leaq 0x7f18(%rip), %rcx      # 0xf18b
callq 0x3130
movq -0x60(%rbp), %rax
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x54(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x729f
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7154
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/./EmulNet.h
// Function: EM::operator=(EM&)
EM& operator = (EM &anotherEM) {
		this->nextid = anotherEM.getNextId();
		this->currbuffsize = anotherEM.getCurrBuffSize();
		this->firsteltindex = anotherEM.getFirstEltIndex();
		int i = this->currbuffsize;
		while (i > 0) {
			this->buff[i] = anotherEM.buff[i];
			i--;
		}
		return *this;
	}

// 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)
movq -0x10(%rbp), %rdi
callq 0x7630
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x7650
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x7670
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0xc(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x75ef
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq 0x18(%rcx,%rdx,8), %rdx
movslq -0x14(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x75c4
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: csMOOC[P]UIUC/Application.cpp
// Function: handler(int)
void handler(int sig) {
	void *array[10];
	size_t size;

	// get void*'s for all entries on the stack
	size = backtrace(array, 10);

	// print out all the frames to stderr
	fprintf(stderr, "Error: signal %d:\n", sig);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
movl $0xa, %esi
callq 0x3330
cltq
movq %rax, -0x68(%rbp)
movq 0xd922(%rip), %rax      # 0x14fd8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x7ba1(%rip), %rsi      # 0xf264
movb $0x0, %al
callq 0x3310
leaq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
movl %eax, %esi
movl $0x2, %edx
callq 0x3370
movl $0x1, %edi
callq 0x32d0
nopl (%rax,%rax)
// File: csMOOC[P]UIUC/Application.cpp
// Function: main
int main(int argc, char *argv[]) {
	//signal(SIGSEGV, handler);
	if ( argc != ARGS_COUNT ) {
		cout<<"Configuration (i.e., *.conf) file File Required"<<endl;
		return FAILURE;
	}

	// Create a new application object
	Application *app = new Application(argv[1]);
	// Call the run function
	app->run();
	// When done delete the application object
	delete(app);

	return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x7737
movq 0xd8bd(%rip), %rdi      # 0x14fd0
leaq 0x7b5d(%rip), %rsi      # 0xf277
callq 0x3200
movq %rax, %rdi
movq 0xd897(%rip), %rsi      # 0x14fc0
callq 0x3240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x77a8
movl $0x48, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7890
jmp 0x775a
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x77c0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x7783
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x77a8
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x3230
jmp 0x77b1
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33b0
nopw (%rax,%rax)
// File: csMOOC[P]UIUC/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();
		// Fail some nodes
		fail();
	}

	// Clean up
	en->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 0x31d0
movl %eax, %edi
callq 0x31f0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2bc, 0x28(%rax)      # imm = 0x2BC
jge 0x7834
movq -0x20(%rbp), %rdi
callq 0x7d10
movq -0x20(%rbp), %rdi
callq 0x7fb0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x77fe
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x72c0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x40(%rcx), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x787d
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3bc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7848
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/Application.cpp
// Function: Application::getjoinaddr()
Address Application::getjoinaddr(void){
	//trace.funcEntry("Application::getjoinaddr");
    Address joinaddr;
    joinaddr.init();
    *(int *)(&(joinaddr.addr))=1;
    *(short *)(&(joinaddr.addr[4]))=0;
    //trace.funcExit("Application::getjoinaddr", SUCCESS);
    return joinaddr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4620
movq -0x20(%rbp), %rdi
callq 0x4630
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x1, (%rdi)
movw $0x0, 0x4(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
		delete mp1[i];
	}
	free(mp1);
	delete par;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xd0fd(%rip), %rcx      # 0x14d18
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7c3a
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 0x7c56
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x40(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x7c9e
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7c91
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7c93
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7c5d
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32c0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x7ccb
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0x3230
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: csMOOC[P]UIUC/./Member.h
// Function: Address::getAddress[abi:cxx11]()
string getAddress() {
		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 0x8c80
movq -0x90(%rbp), %rsi
leaq 0x703b(%rip), %rdx      # 0xf318
leaq -0x38(%rbp), %rdi
callq 0x8c30
jmp 0x82e8
movswl -0x16(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x8c80
jmp 0x82fa
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x8b60
jmp 0x8313
leaq -0x88(%rbp), %rdi
callq 0x3120
leaq -0x38(%rbp), %rdi
callq 0x3120
leaq -0x58(%rbp), %rdi
callq 0x3120
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 0x837e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x8375
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3120
leaq -0x38(%rbp), %rdi
callq 0x3120
leaq -0x58(%rbp), %rdi
callq 0x3120
movq -0x60(%rbp), %rdi
callq 0x33b0
// File: csMOOC[P]UIUC/Params.cpp
// Function: Params::setparams(char*)
void Params::setparams(char *config_file) {
	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);

	//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 ( unsigned int i = 0; i < EN_GPSZ; i++ ) {
		allNodesJoined += i;
	}
	fclose(fp);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5ba5(%rip), %rsi      # 0xf4b8
callq 0x32b0
movq -0x28(%rbp), %rdx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x5b8f(%rip), %rsi      # 0xf4ba
movb $0x0, %al
callq 0x33f0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x4, %rdx
leaq 0x5b81(%rip), %rsi      # 0xf4c6
movb $0x0, %al
callq 0x33f0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x20, %rdx
leaq 0x5b7b(%rip), %rsi      # 0xf4da
movb $0x0, %al
callq 0x33f0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x8, %rdx
leaq 0x5b6f(%rip), %rsi      # 0xf4e8
movb $0x0, %al
callq 0x33f0
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl %ecx, 0x18(%rax)
movsd 0x5b1f(%rip), %xmm0     # 0xf4b0
movsd %xmm0, 0x10(%rax)
movl $0xfa0, 0x1c(%rax)      # imm = 0xFA0
movl $0x0, 0x28(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0x99dd
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x99b9
movq -0x18(%rbp), %rdi
callq 0x3210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: csMOOC[P]UIUC/Member.cpp
// Function: MemberListEntry::MemberListEntry(MemberListEntry const&)
MemberListEntry::MemberListEntry(const MemberListEntry &anotherMLE) {
	this->heartbeat = anotherMLE.heartbeat;
	this->id = anotherMLE.id;
	this->port = anotherMLE.port;
	this->timestamp = anotherMLE.timestamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movw 0x4(%rcx), %cx
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nop
// File: csMOOC[P]UIUC/Member.cpp
// Function: MemberListEntry::operator=(MemberListEntry const&)
MemberListEntry& MemberListEntry::operator =(const MemberListEntry &anotherMLE) {
	MemberListEntry temp(anotherMLE);
	swap(heartbeat, temp.heartbeat);
	swap(id, temp.id);
	swap(port, temp.port);
	swap(timestamp, temp.timestamp);
	return *this;
}

// 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)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9b50
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq 0x9f00
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9f40
movq -0x30(%rbp), %rdi
addq $0x4, %rdi
leaq -0x28(%rbp), %rsi
addq $0x4, %rsi
callq 0x9f70
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x9f00
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: csMOOC[P]UIUC/Member.cpp
// Function: Member::Member(Member const&)
Member::Member(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;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0xb039(%rip), %rax      # 0x14d58
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x4620
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x8390
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x83b0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x28(%rbp)
callq 0x83d0
jmp 0x9d5c
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x9a70
movq -0x30(%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 0x9fb0
jmp 0x9dd6
movq -0x30(%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 0xa200
jmp 0x9df9
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x9e22
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8a60
movq -0x38(%rbp), %rdi
callq 0x8400
movq -0x18(%rbp), %rdi
callq 0x33b0
nopw %cs:(%rax,%rax)
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: close_handler(int)
void close_handler(int s){
	cout<<endl<<"Terminating.."<<endl;
	server_socket.closeConnection();
	KeyManager::destroyKeys();
	exit(s);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xdf56(%rip), %rdi      # 0x12fb8
movq 0xdf3f(%rip), %rsi      # 0x12fa8
callq 0x4500
movq %rax, %rdi
leaq 0x8f8c(%rip), %rsi      # 0xe004
callq 0x44a0
movq %rax, %rdi
movq 0xdf21(%rip), %rsi      # 0x12fa8
callq 0x4500
leaq 0xe58d(%rip), %rdi      # 0x13620
callq 0x7e50
callq 0xd3c0
movl -0x4(%rbp), %edi
callq 0x4640
nopw %cs:(%rax,%rax)
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: print_hex(unsigned char*, unsigned int)
void print_hex(unsigned char* buff, unsigned int size)
{
    printf("Printing %d bytes\n", size);
    for(unsigned int i=0; i<size; i++)
        printf("%02hx", *((unsigned char*)(buff + i)));
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x8f29(%rip), %rdi      # 0xe012
movb $0x0, %al
callq 0x4060
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x5123
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x8f14(%rip), %rdi      # 0xe025
movb $0x0, %al
callq 0x4060
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x50f7
leaq 0x9147(%rip), %rdi      # 0xe271
movb $0x0, %al
callq 0x4060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: setup_sockaddr(char*, int)
struct sockaddr_in setup_sockaddr(char *ip,int port){

	struct sockaddr_in sv_addr;

	memset(&sv_addr,0,sizeof(sv_addr));

	sv_addr.sin_family = AF_INET;
	sv_addr.sin_port = htons(port);
	inet_pton(AF_INET,ip,&sv_addr.sin_addr);
	return sv_addr;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movw $0x2, -0x10(%rbp)
movzwl -0x1c(%rbp), %edi
callq 0x4080
movw %ax, -0xe(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xc(%rbp), %rdx
movl $0x2, %edi
callq 0x4990
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: cmd_help()
bool cmd_help(){

	const char *desc[5] = {"--> show available commands",
			"--> show files saved both on server and client",
			"filename --> download from server filename",
			"filename --> upload to server filename",
			"--> disconnect from server\n"};

	int i;
	cout<<endl;
	cout<<"Available commands:"<<endl;
	for(i=0;i<5;i++){
		cout<<commands_list[i]<<" "<<desc[i]<<endl;
	}

	return true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x30(%rbp), %rdi
leaq 0xdb2d(%rip), %rsi      # 0x12cd0
movl $0x28, %edx
callq 0x4410
movq 0xde04(%rip), %rdi      # 0x12fb8
movq 0xdded(%rip), %rsi      # 0x12fa8
callq 0x4500
movq 0xddf1(%rip), %rdi      # 0x12fb8
leaq 0x8f16(%rip), %rsi      # 0xe0e4
callq 0x44a0
movq %rax, %rdi
movq 0xddcb(%rip), %rsi      # 0x12fa8
callq 0x4500
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jge 0x5244
movslq -0x34(%rbp), %rcx
leaq 0xe346(%rip), %rax      # 0x13540
movq (%rax,%rcx,8), %rsi
movq 0xddb3(%rip), %rdi      # 0x12fb8
callq 0x44a0
movq %rax, %rdi
leaq 0x91dd(%rip), %rsi      # 0xe3f1
callq 0x44a0
movq %rax, %rdi
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rsi
callq 0x44a0
movq %rax, %rdi
movq 0xdd74(%rip), %rsi      # 0x12fa8
callq 0x4500
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x51e9
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: cmd_quit()
void cmd_quit(){

	cout<<"Closing Connection"<<endl;
	KeyManager::destroyKeys();
	server_socket.closeConnection();
	exit(0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xdd5d(%rip), %rdi      # 0x12fb8
leaq 0x8e96(%rip), %rsi      # 0xe0f8
callq 0x44a0
movq %rax, %rdi
movq 0xdd37(%rip), %rsi      # 0x12fa8
callq 0x4500
callq 0xd3c0
leaq 0xe39e(%rip), %rdi      # 0x13620
callq 0x7e50
xorl %edi, %edi
callq 0x4640
nop
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: send_command(unsigned int)
bool send_command(uint32_t command){

	EncryptManager em;

	Chunk c;
	c.setInt(command);
	c.size = 4;

	EncryptedChunk ec;

	if(!em.EncryptUpdate(ec,c)) 	return false;
	if(!em.EncryptFinal(ec))		return false;

	if(!sendDataHMAC(server_socket,ec.getCipherText(),ec.size)){			//aggiorno il nonce
		cout<<"[Error] send"<<endl;
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xa300
leaq -0x28(%rbp), %rdi
callq 0xd6b0
jmp 0x52af
leaq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xd800
jmp 0x52be
movl $0x4, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd860
jmp 0x52d0
leaq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xa490
movb %al, -0x55(%rbp)
jmp 0x52e6
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x533b
jmp 0x52ef
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x53d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5405
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x53fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd880
jmp 0x53fc
leaq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa550
movb %al, -0x56(%rbp)
jmp 0x534d
movb -0x56(%rbp), %al
testb $0x1, %al
jne 0x5363
jmp 0x5356
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x53d6
leaq -0x50(%rbp), %rdi
callq 0xd970
movq %rax, -0x60(%rbp)
jmp 0x5372
movq -0x60(%rbp), %rsi
movl -0x40(%rbp), %edx
leaq 0xe2a0(%rip), %rdi      # 0x13620
callq 0x87a0
movb %al, -0x61(%rbp)
jmp 0x538a
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x53cb
jmp 0x5393
movq 0xdc1e(%rip), %rdi      # 0x12fb8
leaq 0x8d6a(%rip), %rsi      # 0xe10b
callq 0x44a0
movq %rax, -0x70(%rbp)
jmp 0x53ac
movq -0x70(%rbp), %rdi
movq 0xdbf1(%rip), %rsi      # 0x12fa8
callq 0x4500
jmp 0x53be
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x53d6
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd880
leaq -0x28(%rbp), %rdi
callq 0xd6d0
leaq -0x10(%rbp), %rdi
callq 0xa3d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0xd6d0
leaq -0x10(%rbp), %rdi
callq 0xa3d0
movq -0x30(%rbp), %rdi
callq 0x4900
nopw (%rax,%rax)
// File: luigix25[P]SSLP/client_files/client.cpp
// Function: select_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool select_command(string &buffer){


	if(buffer.compare("!help") == 0){
		return cmd_help();
	} else if(buffer.compare("!list") == 0){
		return cmd_list();
	} else if(buffer.compare("!quit") == 0){
		cmd_quit();
		return true;							//will never reach here
	} else if(buffer.compare("!get") == 0){
		return cmd_get();
	} else if (buffer.compare("!upload") == 0){
		return cmd_upload();
	} else {
		cout<<">"<<buffer<<"<"<<endl;
		cout<<"Invalid Command"<<endl;
	//	exit(-1);
		pulisci_buff();
		return true;
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8100(%rip), %rsi      # 0xe1f7
callq 0x4150
cmpl $0x0, %eax
jne 0x6110
callq 0x5190
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6204
movq -0x10(%rbp), %rdi
leaq 0x80e2(%rip), %rsi      # 0xe1fd
callq 0x4150
cmpl $0x0, %eax
jne 0x6134
callq 0x5420
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6204
movq -0x10(%rbp), %rdi
leaq 0x80c4(%rip), %rsi      # 0xe203
callq 0x4150
cmpl $0x0, %eax
jne 0x6157
callq 0x5250
movb $0x1, -0x1(%rbp)
jmp 0x6204
movq -0x10(%rbp), %rdi
leaq 0x80a7(%rip), %rsi      # 0xe209
callq 0x4150
cmpl $0x0, %eax
jne 0x617b
callq 0x5dd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6204
movq -0x10(%rbp), %rdi
leaq 0x8088(%rip), %rsi      # 0xe20e
callq 0x4150
cmpl $0x0, %eax
jne 0x619c
callq 0x5920
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6204
movq 0xce15(%rip), %rdi      # 0x12fb8
leaq 0x806c(%rip), %rsi      # 0xe216
callq 0x44a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4470
movq %rax, %rdi
leaq 0x8053(%rip), %rsi      # 0xe218
callq 0x44a0
movq %rax, %rdi
movq 0xcdd4(%rip), %rsi      # 0x12fa8
callq 0x4500
movq 0xcdd8(%rip), %rdi      # 0x12fb8
leaq 0x8033(%rip), %rsi      # 0xe21a
callq 0x44a0
movq %rax, %rdi
movq 0xcdb2(%rip), %rsi      # 0x12fa8
callq 0x4500
callq 0x50b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop