LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4(%rdx), %rsi
movl (%rdx), %eax
cmpl $0x2, %eax
je 0x2918
cmpl $0x1, %eax
je 0x2910
testl %eax, %eax
jne 0x2924
movzwl 0x4(%rsi), %eax
leaq 0x4(%rsp), %r14
movw %ax, 0x4(%r14)
movl (%rsi), %eax
movl %eax, (%r14)
movq 0xb(%rdx), %r15
leaq 0x12(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4a30
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x276e
leaq 0xc(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2932
jmp 0x2920
movq 0x20(%rbx), %rax
movb $0x1, 0xf(%rax)
movq %rbx, %rdi
callq 0x295c
movb $0x1, %al
jmp 0x2926
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %eax
movq %rdi, %r14
imulq $0x18, %rax, %rbp
leaq 0x12(%rsp), %r15
leaq 0xc(%rsp), %r12
cmpq %r13, %rbp
je 0x29c3
movl 0x4(%rbx,%r13), %eax
movzwl 0x8(%rbx,%r13), %ecx
movl %eax, 0xc(%rsp)
movw %cx, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a30
movq 0xc(%rbx,%r13), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x276e
addq $0x18, %r13
jmp 0x2989
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
incq 0x18(%rsi)
movq 0x28(%rsi), %r15
leaq 0x8(%rsp), %r14
cmpq 0x30(%rsi), %r15
je 0x2a3b
movl (%r15), %eax
movzwl 0x4(%r15), %ecx
movl %eax, 0x8(%rsp)
movw %cx, 0xc(%rsp)
addq $0x8, %rsi
movq %r14, %rdi
callq 0x4a4e
testb %al, %al
jne 0x2a20
addq $0x18, %r15
movq 0x20(%rbx), %rsi
jmp 0x29ef
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%r15)
movq 0x18(%rbx), %rdi
callq 0x4a24
cltq
movq %rax, 0x10(%r15)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x4a24
movslq %eax, %r12
movq 0x20(%rbx), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
addq $-0x13, %r12
movl %eax, %r13d
decq %r13
leaq 0x8(%rsp), %r14
testl %r13d, %r13d
js 0x2ae1
movq 0x20(%rbx), %rsi
movl %r13d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq 0x28(%rsi), %rax
imulq $0x18, %rcx, %r15
cmpq %r12, 0x10(%rax,%r15)
jge 0x2adc
addq %r15, %rax
movl (%rax), %ecx
movzwl 0x4(%rax), %eax
movl %ecx, 0x8(%rsp)
movw %ax, 0xc(%rsp)
movq 0x10(%rbx), %rdi
addq $0x8, %rsi
movq %r14, %rdx
callq 0x481e
movq 0x20(%rbx), %rdi
addq 0x28(%rdi), %r15
addq $0x28, %rdi
movq %r15, %rsi
callq 0x2cc6
decq %r13
jmp 0x2a85
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x4a24
movl %eax, %ebp
movslq %eax, %r13
addq $-0x4, %r13
pushq $0x2
popq %r14
pushq $0x18
popq %r12
leaq 0x12(%rsp), %r15
subl $0x1, %r14d
jb 0x2b91
movl %ebp, %edi
callq 0x2160
callq 0x2050
movslq %eax, %rcx
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rax
subq %rdi, %rax
cqto
idivq %r12
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movslq %edx, %rax
imulq $0x18, %rax, %rax
cmpq %r13, 0x10(%rdi,%rax)
jl 0x2b20
addq %rax, %rdi
movl (%rdi), %eax
movzwl 0x4(%rdi), %ecx
movl %eax, 0xc(%rsp)
movw %cx, 0x10(%rsp)
movq %r15, %rdi
leaq 0xc(%rsp), %rsi
callq 0x4a30
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x2
popq %rdx
callq 0x2be4
jmp 0x2b20
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x20(%rdi), %r14
movq 0x28(%r14), %rbx
movq 0x30(%r14), %rbp
movq %rbp, %rax
subq %rbx, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movslq %eax, %r15
imulq $0x18, %r15, %r12
addq $0xc, %r12
movq %r12, %rdi
callq 0x2230
movq %rax, %r13
movl 0x4(%rsp), %eax
movl %eax, (%r13)
movl %r15d, 0x4(%r13)
xorl %eax, %eax
leaq (%rbx,%rax), %rcx
cmpq %rbp, %rcx
je 0x2c63
leaq (%rax,%r13), %rdx
addq $0x8, %rdx
movq 0x10(%rcx), %rsi
movq %rsi, 0x10(%rdx)
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
addq $0x18, %rax
jmp 0x2c3e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %r14
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movl %r12d, %r8d
callq 0x3456
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
leaq 0x7a11(%rip), %rax      # 0xacd0
movq %rax, (%rdi)
leaq 0x7a37(%rip), %rax      # 0xad00
movq %rax, 0x1b7e498(%rdi)
movq %rsi, 0x8(%rdi)
movq $0x1, 0x1b7e4a0(%rdi)
andl $0x0, 0x1b7e490(%rdi)
addq $0xdbf250, %rdi         # imm = 0xDBF250
xorl %eax, %eax
cmpq $0x3e8, %rax            # imm = 0x3E8
je 0x331f
xorl %ecx, %ecx
cmpq $0xe10, %rcx            # imm = 0xE10
je 0x3313
andl $0x0, -0xdbf240(%rdi,%rcx,4)
andl $0x0, (%rdi,%rcx,4)
incq %rcx
jmp 0x32f9
incq %rax
addq $0x3840, %rdi           # imm = 0x3840
jmp 0x32ef
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
leaq 0x79a6(%rip), %rcx      # 0xacd0
movq %rcx, (%rdi)
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
leaq 0x79c5(%rip), %rcx      # 0xad00
movq %rcx, 0x1b7e498(%rax)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movl 0x1b7e490(%rsi), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0xdbf250, %ecx         # imm = 0xDBF250
leaq (%rsi,%rcx), %rdx
addq %rax, %rcx
xorl %eax, %eax
movl $0x3840, %r8d           # imm = 0x3840
cmpq $0x3e8, %rax            # imm = 0x3E8
je 0x33a6
xorl %r9d, %r9d
cmpq $0xe10, %r9             # imm = 0xE10
je 0x339b
movl -0xdbf240(%rdx,%r9,4), %r10d
movl %r10d, -0xdbf240(%rcx,%r9,4)
movl (%rdx,%r9,4), %r10d
movl %r10d, (%rcx,%r9,4)
incq %r9
jmp 0x3375
incq %rax
addq %r8, %rdx
addq %r8, %rcx
jmp 0x336a
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
jmp 0x3926
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x1b7e490(%rsi), %eax
movl %eax, 0x1b7e490(%rdi)
movl $0xdbf250, %eax         # imm = 0xDBF250
leaq (%rsi,%rax), %rcx
addq %rdi, %rax
xorl %edx, %edx
movl $0x3840, %edi           # imm = 0x3840
cmpq $0x3e8, %rdx            # imm = 0x3E8
je 0x341a
xorl %r8d, %r8d
cmpq $0xe10, %r8             # imm = 0xE10
je 0x340f
movl -0xdbf240(%rcx,%r8,4), %r9d
movl %r9d, -0xdbf240(%rax,%r8,4)
movl (%rcx,%r8,4), %r9d
movl %r9d, (%rax,%r8,4)
incq %r8
jmp 0x33e9
incq %rdx
addq %rdi, %rcx
addq %rdi, %rax
jmp 0x33dd
movl $0x1b7e498, %edi        # imm = 0x1B7E498
addq %rdi, %rsi
addq %rbx, %rdi
callq 0x3926
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rax
movl 0x1b7e4a0(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x1b7e4a0(%rdi)
movl %ecx, (%rsi)
andw $0x0, 0x4(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::ENsend(Address*, Address*, char*, int)
int EmulNet::ENsend(Address *myaddr, Address *toaddr, char *data, int size) {
	en_msg *em;
	static char temp[2048];
	int sendmsg = rand() % 100;

	if( (emulnet.currbuffsize >= ENBUFFSIZE) || (size + (int)sizeof(en_msg) >= par->MAX_MSG_SIZE) || (par->dropmsg && sendmsg < (int) (par->MSG_DROP_PROB * 100)) ) {
		return 0;
	}

	em = (en_msg *)malloc(sizeof(en_msg) + size);
	em->size = size;

	memcpy(&(em->from.addr), &(myaddr->addr), sizeof(em->from.addr));
	memcpy(&(em->to.addr), &(toaddr->addr), sizeof(em->from.addr));
	memcpy(em + 1, data, size);

	emulnet.buff[emulnet.currbuffsize++] = em;

	int src = *(int *)(myaddr->addr);
	int time = par->getcurrtime();

	assert(src <= MAX_NODES);
	assert(time < MAX_TIME);

	sent_msgs[src][time]++;

	#ifdef DEBUGLOG
		sprintf(temp, "Sending 4+%d B msg type %d to %d.%d.%d.%d:%d ", size-4, *(int *)data, toaddr->addr[0], toaddr->addr[1], toaddr->addr[2], toaddr->addr[3], *(short *)&toaddr->addr[4]);
	#endif

	return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
callq 0x2050
pushq $0x64
popq %rcx
cltd
idivl %ecx
movslq 0x1b7e4a4(%r12), %r15
xorl %eax, %eax
cmpq $0x752f, %r15           # imm = 0x752F
jg 0x359e
leal 0x10(%rbx), %esi
movq 0x8(%r12), %rcx
cmpl 0x1c(%rcx), %esi
jge 0x359e
cmpl $0x0, 0x24(%rcx)
je 0x34c5
movsd 0x8(%rcx), %xmm0
mulsd 0x3bd7(%rip), %xmm0     # 0x7090
cvttsd2si %xmm0, %ecx
cmpl %ecx, %edx
jl 0x359e
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rax), %rdi
callq 0x2230
movq %rbp, %rsi
movq %rax, %rbp
movl %ebx, (%rax)
movl (%r13), %eax
movl %eax, 0x4(%rbp)
movzwl 0x4(%r13), %eax
movw %ax, 0x8(%rbp)
movl (%r14), %eax
movl %eax, 0xa(%rbp)
movzwl 0x4(%r14), %eax
movw %ax, 0xe(%rbp)
leaq 0x10(%rbp), %rdi
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdx
callq 0x2110
leal 0x1(%r15), %eax
movl %eax, 0x1b7e4a4(%r12)
movq %rbp, 0x1b7e4b0(%r12,%r15,8)
movslq (%r13), %r15
movq 0x8(%r12), %rdi
callq 0x4a24
cmpq $0x3e9, %r15            # imm = 0x3E9
jge 0x35ad
cmpl $0xe10, %eax            # imm = 0xE10
jge 0x35c6
imulq $0x3840, %r15, %rcx     # imm = 0x3840
addq %rcx, %r12
cltq
incl 0x10(%r12,%rax,4)
leal -0x4(%rbx), %edx
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movsbl (%r14), %r8d
movsbl 0x1(%r14), %r9d
movsbl 0x2(%r14), %r10d
movsbl 0x3(%r14), %r11d
movswl 0x4(%r14), %r14d
subq $0x8, %rsp
leaq 0x806c(%rip), %rdi      # 0xb5f0
leaq 0x3b71(%rip), %rsi      # 0x70fc
xorl %eax, %eax
pushq %r14
pushq %r11
pushq %r10
callq 0x2040
addq $0x20, %rsp
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ae4(%rip), %rdi      # 0x7098
leaq 0x3aee(%rip), %rsi      # 0x70a9
leaq 0x3af3(%rip), %rcx      # 0x70b5
pushq $0x6c
jmp 0x35dd
leaq 0x3b1f(%rip), %rdi      # 0x70ec
leaq 0x3ad5(%rip), %rsi      # 0x70a9
leaq 0x3ada(%rip), %rcx      # 0x70b5
pushq $0x6d
popq %rdx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rcx), %r13
movq %r13, %rdi
callq 0x2230
movq %rax, %rbp
movq (%rbx), %rsi
movq %rax, %rdi
movq %r13, %rdx
callq 0x2110
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movl %r13d, %r8d
callq 0x3456
movl %eax, %ebx
movq %rbp, %rdi
callq 0x21f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl 0x1b7e4a4(%rdi), %r14d
leaq 0xdbf250(%rdi), %rax
movq %rax, (%rsp)
testl %r14d, %r14d
jle 0x372c
movq 0x1b7e4a8(%r12,%r14,8), %r13
leaq 0xa(%r13), %rdi
movq %r15, %rsi
callq 0x2240
testl %eax, %eax
jne 0x3724
movl (%r13), %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x10(%r13), %rsi
movq %rax, %rdi
movq %rbp, %rdx
callq 0x2110
movslq 0x1b7e4a4(%r12), %rax
leal -0x1(%rax), %ecx
movq 0x1b7e4a8(%r12,%rax,8), %rax
movq %rax, 0x1b7e4a8(%r12,%r14,8)
movl %ecx, 0x1b7e4a4(%r12)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%rsp)
movq %r13, %rdi
callq 0x21f0
movslq (%r15), %rbx
movq 0x8(%r12), %rdi
callq 0x4a24
cmpq $0x3e9, %rbx            # imm = 0x3E9
jge 0x373d
cmpl $0xe10, %eax            # imm = 0xE10
jge 0x375c
cltq
imulq $0x3840, %rbx, %rcx     # imm = 0x3840
addq (%rsp), %rcx
incl (%rcx,%rax,4)
decq %r14
jmp 0x3678
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39e6(%rip), %rdi      # 0x712a
leaq 0x395e(%rip), %rsi      # 0x70a9
leaq 0x39e9(%rip), %rcx      # 0x713b
movl $0xa9, %edx
callq 0x20e0
leaq 0x3989(%rip), %rdi      # 0x70ec
leaq 0x393f(%rip), %rsi      # 0x70a9
leaq 0x39ca(%rip), %rcx      # 0x713b
movl $0xaa, %edx
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/csMOOC[P]UIUC/EmulNet.cpp
// Function: EmulNet::ENcleanup()
int EmulNet::ENcleanup() {
	emulnet.nextid=0;
	int i, j;
	int sent_total, recv_total;

	FILE* file = fopen("msgcount.log", "w+");

	while(emulnet.currbuffsize > 0) {
		free(emulnet.buff[--emulnet.currbuffsize]);
	}

	for ( i = 1; i <= par->EN_GPSZ; i++ ) {
		fprintf(file, "node %3d ", i);
		sent_total = 0;
		recv_total = 0;

		for (j = 0; j < par->getcurrtime(); j++) {

			sent_total += sent_msgs[i][j];
			recv_total += recv_msgs[i][j];
			if (i != 67) {
				fprintf(file, " (%4d, %4d)", sent_msgs[i][j], recv_msgs[i][j]);
				if (j % 10 == 9) {
					fprintf(file, "\n         ");
				}
			}
			else {
				fprintf(file, "special %4d %4d %4d\n", j, sent_msgs[i][j], recv_msgs[i][j]);
			}
		}
		fprintf(file, "\n");
		fprintf(file, "node %3d sent_total %6u  recv_total %6u\n\n", i, sent_total, recv_total);
	}

	fclose(file);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r13
andl $0x0, 0x1b7e4a0(%rdi)
leaq 0x39fc(%rip), %rdi      # 0x7197
leaq 0x3a02(%rip), %rsi      # 0x71a4
callq 0x21e0
movq %rax, 0x8(%rsp)
movl 0x1b7e4a4(%r13), %eax
testl %eax, %eax
jle 0x37cf
decl %eax
movl %eax, 0x1b7e4a4(%r13)
movq 0x1b7e4b0(%r13,%rax,8), %rdi
callq 0x21f0
jmp 0x37ac
leaq 0xdc2a90(%r13), %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %r14
movq 0x8(%r13), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jg 0x3908
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
leaq 0x39a9(%rip), %rsi      # 0x71a7
movq %r14, 0x20(%rsp)
movl %r14d, %edx
xorl %eax, %eax
callq 0x2250
pushq $0x9
popq %r12
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl %ebp, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
movl %eax, %r15d
movq 0x8(%r13), %rdi
callq 0x4a24
cltq
cmpq %rax, %rbp
jge 0x38c5
movq 0x18(%rsp), %rax
movl -0xdbf240(%rax,%rbp,4), %r14d
movl (%rax,%rbp,4), %ebx
cmpq $0x43, 0x20(%rsp)
jne 0x3876
movq 0x8(%rsp), %rdi
leaq 0x3963(%rip), %rsi      # 0x71c8
movl %ebp, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x2250
jmp 0x38b1
imull $0xa, %r15d, %r15d
addl %r12d, %r15d
movq 0x8(%rsp), %rdi
leaq 0x3928(%rip), %rsi      # 0x71b1
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2250
testl %r15d, %r15d
jne 0x38b1
leaq 0x391c(%rip), %rdi      # 0x71bd
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
movq 0x8(%rsp), %rcx
callq 0x2330
addl %r14d, 0x14(%rsp)
addl %ebx, 0x10(%rsp)
incq %rbp
decl %r12d
jmp 0x3821
pushq $0xa
popq %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2210
movq %r14, %rdi
leaq 0x38fe(%rip), %rsi      # 0x71dd
movq 0x20(%rsp), %r14
movl %r14d, %edx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
xorl %eax, %eax
callq 0x2250
incq %r14
addq $0x3840, 0x18(%rsp)     # imm = 0x3840
jmp 0x37df
movq 0x8(%rsp), %rdi
callq 0x2180
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movl 0x8(%rsi), %ecx
movl %ecx, 0x8(%rdi)
movq 0xc(%rsi), %rcx
movq %rcx, 0xc(%rdi)
movl %ecx, %ecx
testl %ecx, %ecx
jle 0x394c
movq 0x18(%rsi,%rcx,8), %rdx
movq %rdx, 0x18(%rax,%rcx,8)
decq %rcx
jmp 0x3939
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
movq %rsp, %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x2270
movl %eax, %ebp
movq 0x765f(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x3891(%rip), %rsi      # 0x7214
movl %ebx, %edx
xorl %eax, %eax
callq 0x2250
pushq $0x2
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x39d9
movq %rsi, %r14
pushq $0x48
popq %rdi
callq 0x2190
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x3a96
movq %rbx, %rdi
callq 0x3a16
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x39f7
movq 0x75f0(%rip), %rdi      # 0xafd0
leaq 0x3840(%rip), %rsi      # 0x7227
callq 0x2170
movq %rax, %rdi
callq 0x20c0
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x40(%rbx), %rax
andl $0x0, 0x28(%rax)
cmpl $0x2bb, %r14d           # imm = 0x2BB
jg 0x3a60
movq %rbx, %rdi
callq 0x3cf0
movq %rbx, %rdi
callq 0x3eb2
movq 0x40(%rbx), %rax
movl 0x28(%rax), %r14d
incl %r14d
movl %r14d, 0x28(%rax)
jmp 0x3a36
movq 0x28(%rbx), %rdi
callq 0x377c
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jge 0x3a8b
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2744
incq %r14
jmp 0x3a6c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/csMOOC[P]UIUC/Application.cpp
// Function: Application::Application(char*)
Application::Application(char *infile) {
	int i;
	par = new Params();
	srand (time(NULL));
	par->setparams(infile);
	log = new Log(par);
	en = new EmulNet(par);
	mp1 = (MP1Node **) malloc(par->EN_GPSZ * sizeof(MP1Node *));

	/*
	 * Init all nodes
	 */
	for( i = 0; i < par->EN_GPSZ; i++ ) {
		Member *memberNode = new Member;
		memberNode->inited = false;
		Address *addressOfMemberNode = new Address();
		Address joinaddr;
		joinaddr = getjoinaddr();
		addressOfMemberNode = (Address *) en->ENinit(addressOfMemberNode, par->PORTNUM);
		mp1[i] = new MP1Node(memberNode, par, en, log, addressOfMemberNode);
		log->LOG(&(mp1[i]->getMemberNode()->addr), "APP");
		delete addressOfMemberNode;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x727f(%rip), %rax      # 0xad30
movq %rax, (%rdi)
pushq $0x38
popq %rdi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x496c
movq %r15, 0x40(%rbx)
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x4974
pushq $0x18
popq %rdi
callq 0x2190
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x44b4
movq %r14, 0x30(%rbx)
movl $0x1bb8e30, %edi        # imm = 0x1BB8E30
callq 0x2190
movq %rax, %r14
movq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x32b8
movq %r14, 0x28(%rbx)
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %r15
movq %r15, %rdi
shlq $0x3, %rdi
callq 0x2230
movq %rax, 0x38(%rbx)
pushq $0x6
popq %r14
xorl %ebp, %ebp
movslq %r15d, %rax
cmpq %rax, %rbp
jge 0x3c0a
movl $0x98, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x3ffa
movb $0x0, 0xe(%r15)
movq %r14, %rdi
callq 0x2190
movq %rax, %r12
movl $0x1, 0xc(%rsp)
andw $0x0, 0x10(%rsp)
leaq 0x12(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x4a3e
movq 0x28(%rbx), %rdi
movq 0x40(%rbx), %rax
movswl 0x30(%rax), %edx
movq %r12, %rsi
callq 0x343c
movq %rax, %r12
pushq $0x30
popq %rdi
callq 0x2190
movq %rax, %r13
movq 0x40(%rbx), %rdx
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %r8
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %r9
callq 0x2546
movq 0x38(%rbx), %rax
movq %r13, (%rax,%rbp,8)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rax
movq (%rax,%rbp,8), %rax
movq 0x20(%rax), %rsi
addq $0x8, %rsi
leaq 0x366f(%rip), %rdx      # 0x7257
xorl %eax, %eax
callq 0x44fe
movq %r12, %rdi
movq %r14, %rsi
callq 0x21a0
incq %rbp
movq 0x40(%rbx), %rax
movl 0x18(%rax), %r15d
jmp 0x3b3b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x1bb8e30, %esi        # imm = 0x1BB8E30
jmp 0x3c29
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
jmp 0x3c4c
movq %rax, %rbx
pushq $0x38
popq %rsi
jmp 0x3c49
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r13, %rdi
jmp 0x3c4c
movq %rax, %rbx
movl $0x98, %esi
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70b8(%rip), %rax      # 0xad30
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x3c8a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x3c99
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jge 0x3cc1
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x3cbc
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
jmp 0x3c9c
callq 0x21f0
movq 0x40(%rbx), %rdi
pushq $0x38
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/csMOOC[P]UIUC/Application.cpp
// Function: Application::fail()
void Application::fail() {
	int i, removed;

	// fail half the members at time t=400
	if( par->DROP_MSG && par->getcurrtime() == 50 ) {
		par->dropmsg = 1;
	}

	if( par->SINGLE_FAILURE && par->getcurrtime() == 100 ) {
		removed = (rand() % par->EN_GPSZ);
		#ifdef DEBUGLOG
		log->LOG(&mp1[removed]->getMemberNode()->addr, "Node failed at time=%d", par->getcurrtime());
		#endif
		mp1[removed]->getMemberNode()->bFailed = true;
	}
	else if( par->getcurrtime() == 100 ) {
		removed = rand() % par->EN_GPSZ/2;
		for ( i = removed; i < removed + par->EN_GPSZ/2; i++ ) {
			#ifdef DEBUGLOG
			log->LOG(&mp1[i]->getMemberNode()->addr, "Node failed at time = %d", par->getcurrtime());
			#endif
			mp1[i]->getMemberNode()->bFailed = true;
		}
	}

	if( par->DROP_MSG && par->getcurrtime() == 300) {
		par->dropmsg=0;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x3edf
callq 0x4a24
movq 0x40(%rbx), %rdi
cmpl $0x32, %eax
jne 0x3edf
movl $0x1, 0x24(%rdi)
cmpl $0x0, 0x4(%rdi)
je 0x3f47
callq 0x4a24
cmpl $0x64, %eax
jne 0x3f43
callq 0x2050
movq 0x40(%rbx), %rdi
cltd
idivl 0x18(%rdi)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rax
movslq %edx, %r12
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %r15
addq $0x8, %r15
callq 0x4a24
leaq 0x3379(%rip), %rdx      # 0x7298
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x44fe
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
jmp 0x3fcc
movq 0x40(%rbx), %rdi
callq 0x4a24
cmpl $0x64, %eax
jne 0x3fcc
callq 0x2050
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
cltd
idivl %ecx
movl %edx, %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
movl %eax, %ebp
movslq %eax, %r13
leaq 0x333b(%rip), %r14      # 0x72af
movl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
addl %ebp, %eax
cltq
cmpq %rax, %r13
jge 0x3fcc
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %r12
addq $0x8, %r12
callq 0x4a24
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x44fe
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
incq %r13
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
jmp 0x3f74
movq 0x40(%rbx), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x3fea
callq 0x4a24
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x3fea
movq 0x40(%rbx), %rax
andl $0x0, 0x24(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
movswl 0x4(%rsi), %ebp
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x43bf
leaq 0x3251(%rip), %rdx      # 0x72c8
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x43a0
movq %rsp, %rdi
movl %ebp, %esi
callq 0x43bf
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4339
movq %rsp, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20a0
jmp 0x40d6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20a0
jmp 0x40e5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2acc(%rip), %rsi      # 0x7451
movq %rax, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x2abc(%rip), %rsi      # 0x7453
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2300
leaq 0x4(%rbx), %rdx
leaq 0x2aae(%rip), %rsi      # 0x745f
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
leaq 0x20(%rbx), %rdx
leaq 0x2aad(%rip), %rsi      # 0x7473
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
leaq 0x8(%rbx), %rdx
leaq 0x2aa6(%rip), %rsi      # 0x7481
movq %r14, %rdi
xorl %eax, %eax
callq 0x2300
movl (%rbx), %eax
movl %eax, 0x18(%rbx)
movabsq $0x3fd0000000000000, %rcx # imm = 0x3FD0000000000000
movq %rcx, 0x10(%rbx)
movl $0xfa0, 0x1c(%rbx)      # imm = 0xFA0
andq $0x0, 0x24(%rbx)
andl $0x0, 0x2c(%rbx)
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x4a17
addl %ecx, %ebp
movl %ebp, 0x2c(%rbx)
incl %ecx
jmp 0x4a0a
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x6273(%rip), %rax      # 0xad60
movq %rax, (%rdi)
leaq 0x28(%rdi), %rbx
leaq 0x48(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %r14, %rdi
callq 0x40f8
movzwl 0xc(%r15), %eax
movw %ax, 0xc(%r12)
movl 0x8(%r15), %eax
movl %eax, 0x8(%r12)
movb 0xe(%r15), %al
movb %al, 0xe(%r12)
movb 0xf(%r15), %al
movb %al, 0xf(%r12)
movb 0x10(%r15), %al
movb %al, 0x10(%r12)
movl 0x14(%r15), %eax
movl %eax, 0x14(%r12)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r12)
movq 0x20(%r15), %rax
movq %rax, 0x20(%r12)
leaq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x4c16
movq 0x40(%r15), %rax
movq %rax, 0x40(%r12)
addq $0x48, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4cdc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x4b95
movq %rax, %r15
movq %r14, %rdi
callq 0x430c
movq %rbx, %rdi
callq 0x42e6
movq %r15, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movl %edi, %ebx
movq 0xa2e2(%rip), %rdi      # 0xefc8
callq 0x41d0
leaq 0x5312(%rip), %rsi      # 0xa004
movq %rax, %rdi
callq 0x4400
movq %rax, %rdi
callq 0x41d0
leaq 0xa857(%rip), %rdi      # 0xf560
callq 0x655c
callq 0x923c
movl %ebx, %edi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x52cb(%rip), %rdi      # 0xa012
xorl %eax, %eax
callq 0x4040
movl %ebp, %r15d
leaq 0x52cd(%rip), %r14      # 0xa025
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x4d74
movzbl (%rbx,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x4040
incq %r12
jmp 0x4d5b
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
leaq 0x4(%rsp), %rbx
andl $0x0, 0x8(%rbx)
movq %rdi, %rax
andq $0x0, (%rbx)
movw $0x2, -0x4(%rbx)
rolw $0x8, %si
movw %si, -0x2(%rbx)
pushq $0x2
popq %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x4820
movq -0x4(%rbx), %rax
movq 0x4(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0xa170(%rip), %rdi      # 0xefc8
leaq 0x5299(%rip), %rsi      # 0xa0f8
callq 0x4400
movq %rax, %rdi
callq 0x41d0
callq 0x923c
leaq 0xa6e8(%rip), %rdi      # 0xf560
callq 0x655c
xorl %edi, %edi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movl %edi, 0xc(%rsp)
movq %rsp, %rdi
callq 0x74b8
leaq 0x28(%rsp), %rdi
callq 0x93ac
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x9428
movl $0x4, 0x38(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x9450
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x75b6
testb %al, %al
je 0x4f25
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x7634
testb %al, %al
je 0x4f25
leaq 0x10(%rsp), %rdi
callq 0x94b6
movl 0x20(%rsp), %edx
leaq 0xa664(%rip), %rdi      # 0xf560
movq %rax, %rsi
callq 0x6a96
movb $0x1, %bl
testb %al, %al
jne 0x4f27
movq 0xa0b7(%rip), %rdi      # 0xefc8
leaq 0x51f3(%rip), %rsi      # 0xa10b
callq 0x4400
movq %rax, %rdi
callq 0x41d0
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x945e
leaq 0x28(%rsp), %rdi
callq 0x93ba
movq %rsp, %rdi
callq 0x7542
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x4f4d
movq %rax, %rbx
jmp 0x4f64
movq %rax, %rbx
jmp 0x4f6e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x945e
leaq 0x28(%rsp), %rdi
callq 0x93ba
movq %rsp, %rdi
callq 0x7542
movq %rbx, %rdi
callq 0x47a0
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/client_files/client.cpp
// Function: cmd_get()
bool cmd_get(){

	//if(!server_socket.sendInt(GET_COMMAND)) return;
	if(!send_command(GET_COMMAND)) return false;
	string filename;
	cin >> setw(MAX_FILENAME_LENGTH) >> filename;

	//clears the overflow, if any
	pulisci_buff();

	string path(CLIENT_PATH);

	EncryptManager em;
	Chunk c;
	c.setPlainText((char*)filename.c_str(),false);		//i don't need to free memory
	c.size = filename.size()+1;

	EncryptedChunk ec;

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


	if(!sendDataHMAC(server_socket,ec.getCipherText(),ec.size)) return false;			
	if(!ReceiveFile(path,filename,server_socket,public_key_rsa,true)){
		//cout << "[Error] ReceiveFile" << endl;
		return false;
	}
	else{
		//cout << "[LOG] ReceiveFile Correct" << endl;
		return true;
	}
	
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
pushq $0x2
popq %rdi
callq 0x4e84
testb %al, %al
je 0x560c
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x9aab(%rip), %rdi      # 0xefd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x64, 0x10(%rdi,%rax)
leaq 0x40(%rsp), %rsi
callq 0x4590
callq 0x4d1a
leaq 0x4c30(%rip), %rsi      # 0xa183
leaq 0x60(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x639e
leaq 0x8(%rsp), %rdi
callq 0x74b8
leaq 0x28(%rsp), %rdi
callq 0x93ac
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x9402
movl 0x48(%rsp), %eax
incl %eax
movl %eax, 0x38(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x9450
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x75b6
testb %al, %al
je 0x5610
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7634
testb %al, %al
je 0x5610
leaq 0x10(%rsp), %rdi
callq 0x94b6
movl 0x20(%rsp), %edx
leaq 0x9f85(%rip), %rdi      # 0xf560
movq %rax, %rsi
callq 0x6a96
testb %al, %al
je 0x5610
leaq 0x9f72(%rip), %rdx      # 0xf560
leaq 0x9f63(%rip), %rcx      # 0xf558
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %r8
callq 0x83a6
movl %eax, %ebx
jmp 0x5612
xorl %ebx, %ebx
jmp 0x5644
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x945e
leaq 0x28(%rsp), %rdi
callq 0x93ba
leaq 0x8(%rsp), %rdi
callq 0x7542
leaq 0x60(%rsp), %rdi
callq 0x41b0
leaq 0x40(%rsp), %rdi
callq 0x41b0
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
retq
jmp 0x5651
movq %rax, %rbx
jmp 0x5674
movq %rax, %rbx
jmp 0x567e
movq %rax, %rbx
jmp 0x5688
jmp 0x5662
movq %rax, %rbx
jmp 0x5692
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x945e
leaq 0x28(%rsp), %rdi
callq 0x93ba
leaq 0x8(%rsp), %rdi
callq 0x7542
leaq 0x60(%rsp), %rdi
callq 0x41b0
leaq 0x40(%rsp), %rdi
callq 0x41b0
movq %rbx, %rdi
callq 0x47a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4b45(%rip), %rsi      # 0xa1f7
callq 0x4110
testl %eax, %eax
je 0x576d
leaq 0x4b37(%rip), %rsi      # 0xa1fd
movq %rbx, %rdi
callq 0x4110
testl %eax, %eax
je 0x577c
leaq 0x4b26(%rip), %rsi      # 0xa203
movq %rbx, %rdi
callq 0x4110
testl %eax, %eax
je 0x57a0
leaq 0x4b15(%rip), %rsi      # 0xa209
movq %rbx, %rdi
callq 0x4110
testl %eax, %eax
je 0x5788
leaq 0x4b03(%rip), %rsi      # 0xa20e
movq %rbx, %rdi
callq 0x4110
testl %eax, %eax
je 0x5794
movq 0x98aa(%rip), %r14      # 0xefc8
leaq 0x4af1(%rip), %rsi      # 0xa216
movq %r14, %rdi
callq 0x4400
movq %rax, %rdi
movq %rbx, %rsi
callq 0x43d0
leaq 0x4ad9(%rip), %rsi      # 0xa218
movq %rax, %rdi
callq 0x4400
movq %rax, %rdi
callq 0x41d0
leaq 0x4ac4(%rip), %rsi      # 0xa21a
movq %r14, %rdi
callq 0x4400
movq %rax, %rdi
callq 0x41d0
callq 0x4d1a
jmp 0x5772
callq 0x4dc3
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4f7e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x54fd
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5280
callq 0x4e50
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/library.cpp
// Function: NetSocket::sendInt(int)
bool NetSocket::sendInt(int value){
	if(isClosed)
		return false;

	int status;
	uint32_t tosend;

	tosend = htonl(value);
	//status = send(sd, &tosend, sizeof(uint32_t), 0);
	status = sendto(this->socket, &tosend, sizeof(int32_t), 0,NULL,0);
	if(status < (int)sizeof(int32_t))	{
		perror("[Error] send");
		return false;
	}

	return (status==sizeof(uint32_t));

}

// Assembly:
cmpb $0x0, 0x4(%rdi)
je 0x657d
xorl %eax, %eax
retq
pushq %rax
bswapl %esi
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movl (%rdi), %edi
pushq $0x4
popq %rdx
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4070
cmpl $0x3, %eax
jle 0x65b1
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x4, %eax
sete %al
addq $0x8, %rsp
retq
leaq 0x3b53(%rip), %rdi      # 0xa10b
callq 0x43a0
xorl %eax, %eax
jmp 0x65ac
nop
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/library.cpp
// Function: NetSocket::utilitySend(char const*, unsigned int)
bool NetSocket::utilitySend(const char* buffer,uint32_t len){

	if(isClosed)
		return false;

	uint32_t inviati = 0;
	int32_t ret =  0;

	while(inviati < len){

		ret = sendto(this->socket,buffer+inviati,len-inviati,0,NULL,0);
		if(ret == -1){
			perror("[Error] send");
			return false;
		} 
		inviati += ret;
	}
	
	return (inviati == len);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x0, 0x4(%rdi)
jne 0x660e
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl %ebp, %edx
subl %ebx, %edx
jbe 0x660b
movl (%r15), %edi
movl %ebx, %esi
addq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4070
addl %eax, %ebx
cmpl $-0x1, %eax
jne 0x65d9
leaq 0x3b09(%rip), %rdi      # 0xa10b
callq 0x43a0
xorl %ebx, %ebx
jmp 0x660e
sete %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luigix25[P]SSLP/library/library.cpp
// Function: NetSocket::utilityRecv(char*, unsigned int)
bool NetSocket::utilityRecv(char* buffer,uint32_t len){
	uint32_t ricevuti = 0;
	int ret = 0;

	while(ricevuti < len){ 										//posso leggere meno byte
		ret = recvfrom(this->socket,buffer+ricevuti,len-ricevuti,0,NULL,0);
		if(ret == -1){
			perror("[Error] recv");
			return false;	
		}
		ricevuti += ret;
	}

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %ecx, %ecx
movl %ecx, %r12d
movl %ebx, %edx
subl %ecx, %edx
jbe 0x6662
movl (%r15), %edi
movl %r12d, %esi
addq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4350
leal (%r12,%rax), %ecx
cmpl $-0x1, %eax
jne 0x662e
leaq 0x3e13(%rip), %rdi      # 0xa470
callq 0x43a0
cmpl %r12d, %ebx
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq