LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::piggyPingMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::piggyPingMsg( Message msg, std::string sender )
{
    msg.type = MSG_PIGGY_ACK;
    //ipString2Char4(char42String(msg.carrierAdd), msg.carrierAdd); //Original Sender as carrier
    sendUDP( sockfd,  sender, port, (char*)&msg, sizeof(Message) );

    //Just in case, we can send the message back to the original sender
    // Because we can!
    std::string original = char42String(msg.carrierAdd);
    msg.type = MSG_ACK;
    sendUDP( sockfd,  original, port, (char*)&msg, sizeof(Message) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x4, (%rcx)
movl 0x298(%rax), %edx
movl 0x29c(%rax), %edi
movl $0x14, %r8d
movl %r8d, -0x40(%rbp)
callq 0x1a870
movq -0x48(%rbp), %rsi
addq $0x5, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1a480
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
movl -0x40(%rbp), %r8d
movl $0x1, (%rcx)
movl 0x298(%rax), %edx
movl 0x29c(%rax), %edi
callq 0x1a870
jmp 0x9b5f
leaq -0x30(%rbp), %rdi
callq 0x42a0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x38(%rbp), %rdi
callq 0x46a0
nopl (%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::piggyAckMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::piggyAckMsg( Message msg, std::string sender )
{
    std::string target = char42String(msg.carrierAdd);
    msg.type = MSG_ACK;

    ipString2Char4(sender, msg.carrierAdd); //Dont care, but meh

    sendUDP( sockfd,  target, port, (char*)&msg, sizeof(Message) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, %rax
movq %rax, -0x68(%rbp)
leaq 0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x5, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a480
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rsi
movl $0x1, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x41e0
jmp 0x9be0
movq -0x70(%rbp), %rsi
addq $0x5, %rsi
leaq -0x50(%rbp), %rdi
callq 0x1a2b0
jmp 0x9bf3
leaq -0x50(%rbp), %rdi
callq 0x42a0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movl 0x298(%rax), %edx
movl 0x29c(%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x14, %r8d
callq 0x1a870
jmp 0x9c21
leaq -0x30(%rbp), %rdi
callq 0x42a0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42a0
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x58(%rbp), %rdi
callq 0x46a0
nopl (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::leaveMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::leaveMsg( Message msg, std::string sender )
{
    std::string carrier = char42String(msg.carrierAdd);

    if ( !checkMember(carrier) ) return; // Already deleted

	failMember(carrier, msg.timeStamp);
    
    logFile<<"leaveMsg: node "<<carrier<<" has left"<<std::endl;

    if(msg.TTL == 0)
    {
        return;
    }
    else{
        msg.TTL--;
        spreadMessage(msg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x5, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1a480
movq -0xa8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x41e0
jmp 0x9e82
movq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa780
movl %eax, -0xbc(%rbp)
jmp 0x9e9a
movl -0xbc(%rbp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xbd(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42a0
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x9ec3
jmp 0x9efa
movl $0x1, -0x60(%rbp)
jmp 0xa015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa027
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x42a0
jmp 0xa027
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x41e0
jmp 0x9f09
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x80(%rbp), %rsi
callq 0x8f40
jmp 0x9f25
leaq -0x80(%rbp), %rdi
callq 0x42a0
movq -0xb0(%rbp), %rdi
leaq 0x12817(%rip), %rsi     # 0x1c753
callq 0x43f0
movq %rax, -0xc8(%rbp)
jmp 0x9f4a
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4370
movq %rax, -0xd0(%rbp)
jmp 0x9f63
movq -0xd0(%rbp), %rdi
leaq 0x127f2(%rip), %rsi     # 0x1c763
callq 0x43f0
movq %rax, -0xd8(%rbp)
jmp 0x9f7f
movq -0xd8(%rbp), %rdi
movq 0x1d01b(%rip), %rsi     # 0x26fa8
callq 0x4410
jmp 0x9f94
movq -0xb8(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x0, %eax
jne 0x9fc4
movl $0x1, -0x60(%rbp)
jmp 0xa015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x42a0
jmp 0xa027
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movb 0x10(%rax), %cl
decb %cl
movb %cl, 0x10(%rax)
movl 0x10(%rax), %ecx
movl %ecx, -0x90(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xa0(%rbp)
movl -0x90(%rbp), %ecx
movq %rsp, %rax
movl %ecx, 0x10(%rax)
movaps -0xa0(%rbp), %xmm0
movups %xmm0, (%rax)
xorl %esi, %esi
callq 0x8a90
jmp 0xa00c
jmp 0xa00e
movl $0x0, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x42a0
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x58(%rbp), %rdi
callq 0x46a0
nopl (%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::electionMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::electionMsg( Message msg, std::string sender )
{
	logFile << "Election received! I am gonna bully that guy :)" << std::endl;
    msg.type = MSG_BULLY;
    ipString2Char4(sender, msg.carrierAdd); //Dont care, but meh

    sendUDP( sockfd,  sender, port, (char*)&msg, sizeof(Message) );

	runLeaderElection();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq 0x127ea(%rip), %rsi     # 0x1c855
callq 0x43f0
movq %rax, %rdi
movq 0x1cf2e(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rax
movl $0xa, (%rax)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x41e0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x5, %rsi
callq 0x1a2b0
jmp 0xa0ad
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movl 0x29c(%rax), %edi
movl 0x298(%rax), %edx
movl $0x14, %r8d
callq 0x1a870
movq -0x60(%rbp), %rdi
callq 0xabb0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x42a0
movq -0x38(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::checkLeader()
void Membership::checkLeader()
{
	logFile << "Checking leader... " << std::endl;

	if ( !leader.active)
	{
		logFile << "No leader! " << std::endl;
		runLeaderElection();
		return;
	}

	bool exist = false;

	membersLock.lock();

	for (int i = 0; i < members.size(); ++i)
	{
		if( leader.ip_str.compare(members.at(i).ip_str) == 0)
		{
			exist = true;
		}
	}

	membersLock.unlock();

	if (!exist)
	{
		leader.active = false;
		runLeaderElection();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x1249a(%rip), %rsi     # 0x1c835
callq 0x43f0
movq %rax, %rdi
movq 0x1cbfe(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x18(%rbp), %rax
cmpl $0x0, 0x294(%rax)
jne 0xa3e9
movq -0x18(%rbp), %rdi
leaq 0x12482(%rip), %rsi     # 0x1c849
callq 0x43f0
movq %rax, %rdi
movq 0x1cbd2(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x18(%rbp), %rdi
callq 0xabb0
jmp 0xa494
movq -0x18(%rbp), %rdi
movb $0x0, -0x9(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0xb5f0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x258, %rdi            # imm = 0x258
callq 0xb990
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xa46b
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x270, %rax            # imm = 0x270
movq %rax, -0x28(%rbp)
addq $0x258, %rdi            # imm = 0x258
movslq -0x10(%rbp), %rsi
callq 0xb950
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4040
cmpl $0x0, %eax
jne 0xa45e
movb $0x1, -0x9(%rbp)
jmp 0xa460
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa404
movq -0x18(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xb620
testb $0x1, -0x9(%rbp)
jne 0xa494
movq -0x18(%rbp), %rdi
movl $0x0, 0x294(%rdi)
callq 0xabb0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::printMember[abi:cxx11]()
std::string Membership::printMember(){

    std::stringstream ret;
    membersLock.lock();
    for(int i=0; i < members.size(); i++){
        ret<<"Member["<<i<<"]: "<<members[i].ip_str<<" "<<members[i].timeStamp<<" "<<members[i].active<<std::endl;
    }
    membersLock.unlock();  

    return ret.str();  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1b0(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xb5f0
jmp 0xa4f0
movl $0x0, -0x1a8(%rbp)
movq -0x1b0(%rbp), %rdi
movslq -0x1a8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
addq $0x258, %rdi            # imm = 0x258
callq 0xb990
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
cmpq %rcx, %rax
jae 0xa69a
leaq -0x188(%rbp), %rdi
leaq 0x123e6(%rip), %rsi     # 0x1c922
callq 0x43f0
movq %rax, -0x1d0(%rbp)
jmp 0xa54a
movq -0x1d0(%rbp), %rdi
movl -0x1a8(%rbp), %esi
callq 0x4670
movq %rax, -0x1d8(%rbp)
jmp 0xa565
movq -0x1d8(%rbp), %rdi
leaq 0x123b7(%rip), %rsi     # 0x1c92a
callq 0x43f0
movq %rax, -0x1e0(%rbp)
jmp 0xa581
movq -0x1b0(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x1a8(%rbp), %rsi
callq 0xb8d0
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, -0x1e8(%rbp)
jmp 0xa5b3
movq -0x1e8(%rbp), %rdi
leaq 0x11d61(%rip), %rsi     # 0x1c322
callq 0x43f0
movq %rax, -0x1f0(%rbp)
jmp 0xa5cf
movq -0x1b0(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x1a8(%rbp), %rsi
callq 0xb8d0
movq -0x1f0(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x4670
movq %rax, -0x1f8(%rbp)
jmp 0xa601
movq -0x1f8(%rbp), %rdi
leaq 0x11d13(%rip), %rsi     # 0x1c322
callq 0x43f0
movq %rax, -0x200(%rbp)
jmp 0xa61d
movq -0x1b0(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x1a8(%rbp), %rsi
callq 0xb8d0
movq -0x200(%rbp), %rdi
movl 0x24(%rax), %esi
callq 0x4670
movq %rax, -0x208(%rbp)
jmp 0xa64f
movq -0x208(%rbp), %rdi
movq 0x1c94b(%rip), %rsi     # 0x26fa8
callq 0x4410
jmp 0xa664
jmp 0xa666
movl -0x1a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0xa4fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42f0
jmp 0xa6e0
movq -0x1b0(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xb620
jmp 0xa6af
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x43e0
jmp 0xa6c4
leaq -0x198(%rbp), %rdi
callq 0x42f0
movq -0x1b8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x46a0
nopl (%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::ackMsgQueue()
bool Membership::ackMsgQueue(){
    bool acked = false;
    while(!msgQueueEmpty()){
        Message receive = popMsgQueue();
        if(receive.roundId==roundId)
            acked = true;
    }
    return acked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x28(%rbp), %rdi
callq 0xafe0
xorb $-0x1, %al
testb $0x1, %al
jne 0xa749
jmp 0xa76c
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xb020
movq -0x28(%rbp), %rcx
movzbl -0x1c(%rbp), %eax
cmpl 0x2c8(%rcx), %eax
jne 0xa76a
movb $0x1, -0x9(%rbp)
jmp 0xa738
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::checkMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Membership::checkMember(std::string ip_str){
    bool exist = false;
    
    membersLock.lock();
    
    for(int i=0; i<members.size(); i++){
        if( members[i].ip_str.compare( ip_str )==0 ){
            exist = true;
        }
    }

    membersLock.unlock();

    return exist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0xb5f0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x258, %rdi            # imm = 0x258
callq 0xb990
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xa80d
movq -0x20(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x18(%rbp), %rsi
callq 0xb8d0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x4040
cmpl $0x0, %eax
jne 0xa800
movb $0x1, -0x11(%rbp)
jmp 0xa802
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa7b3
movq -0x20(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xb620
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::isBiggerThanMine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Membership::isBiggerThanMine(std::string other, std::string mine)
{
	char other_char[4];
	char me_char[4];
	ipString2Char4(other, other_char);
	ipString2Char4(mine, me_char);

	for (int i = 0; i < 4; ++i)
	{
		unsigned int me = (uint8_t) me_char[i];
		unsigned int ot = (uint8_t) other_char[i];
		logFile << ot << " > " << me << std::endl;
		if( ot > me){
			logFile << ot << " > " << me << std::endl;
			return true;
		}
		if( me > ot){
			logFile << ot << " < " << me << std::endl;
			return false;
		}
	}
	
	logFile << "comparing with myself: this code sucks!" << std::endl;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x41e0
movq -0x90(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x1a2b0
jmp 0xa8ab
leaq -0x48(%rbp), %rdi
callq 0x42a0
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x41e0
movq -0xa8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a2b0
jmp 0xa8dd
leaq -0x78(%rbp), %rdi
callq 0x42a0
movl $0x0, -0x7c(%rbp)
cmpl $0x4, -0x7c(%rbp)
jge 0xaa2c
movq -0x98(%rbp), %rdi
movslq -0x7c(%rbp), %rax
movzbl -0x28(%rbp,%rax), %eax
movl %eax, -0x80(%rbp)
movslq -0x7c(%rbp), %rax
movzbl -0x24(%rbp,%rax), %eax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
leaq 0x11e8e(%rip), %rsi     # 0x1c7bc
callq 0x43f0
movq %rax, %rdi
movl -0x80(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
movq 0x1c660(%rip), %rsi     # 0x26fa8
callq 0x4410
movl -0x84(%rbp), %eax
cmpl -0x80(%rbp), %eax
jbe 0xa9d0
movq -0x98(%rbp), %rdi
movl -0x84(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
leaq 0x11e48(%rip), %rsi     # 0x1c7bc
callq 0x43f0
movq %rax, %rdi
movl -0x80(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
movq 0x1c61a(%rip), %rsi     # 0x26fa8
callq 0x4410
movb $0x1, -0x1(%rbp)
jmp 0xaa52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x42a0
jmp 0xaa60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x42a0
jmp 0xaa60
movl -0x80(%rbp), %eax
cmpl -0x84(%rbp), %eax
jbe 0xaa1c
movq -0x98(%rbp), %rdi
movl -0x84(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
leaq 0x11dc9(%rip), %rsi     # 0x1c7c0
callq 0x43f0
movq %rax, %rdi
movl -0x80(%rbp), %esi
callq 0x44e0
movq %rax, %rdi
movq 0x1c597(%rip), %rsi     # 0x26fa8
callq 0x4410
movb $0x0, -0x1(%rbp)
jmp 0xaa52
jmp 0xaa1e
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0xa8ed
movq -0x98(%rbp), %rdi
leaq 0x11d8a(%rip), %rsi     # 0x1c7c4
callq 0x43f0
movq %rax, %rdi
movq 0x1c55f(%rip), %rsi     # 0x26fa8
callq 0x4410
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x46a0
nopl (%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::getMembershipList()
std::vector<Node> Membership::getMembershipList()
{

    membersLock.lock();
    std::vector<Node> ret = members;
    membersLock.unlock();

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x230, %rdi            # imm = 0x230
movq %rdi, -0x30(%rbp)
callq 0xb5f0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
movb $0x0, -0x11(%rbp)
addq $0x258, %rsi            # imm = 0x258
callq 0xbc10
movq -0x30(%rbp), %rdi
callq 0xb620
jmp 0xab66
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xab92
jmp 0xab89
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb810
jmp 0xab9c
movq -0x38(%rbp), %rdi
callq 0xb810
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::checkMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Membership::checkMember(std::string ip_str, int timeStamp){
    bool exist = false;
    
    membersLock.lock();
    
    for(int i=0; i<members.size(); i++){
        if( members[i].ip_str.compare( ip_str )==0 && members[i].timeStamp == timeStamp){
            exist = true;
        }
    }

    membersLock.unlock();

    return exist;   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x0, -0x15(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0xb5f0
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x258, %rdi            # imm = 0x258
callq 0xb990
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xafbc
movq -0x28(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x1c(%rbp), %rsi
callq 0xb8d0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x4040
cmpl $0x0, %eax
jne 0xafaf
movq -0x28(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movslq -0x1c(%rbp), %rsi
callq 0xb8d0
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xafaf
movb $0x1, -0x15(%rbp)
jmp 0xafb1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xaf46
movq -0x28(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0xb620
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::msgQueueEmpty()
bool Membership::msgQueueEmpty(){
	bool empty;
	if(msgQueue.size()==0)
		empty = true;
	else
		empty = false;
	return empty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xbe20
cmpq $0x0, %rax
jne 0xb008
movb $0x1, -0x9(%rbp)
jmp 0xb00c
movb $0x0, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::popMsgQueue()
Message Membership::popMsgQueue(){
	Message msg;
	msg.type= MSG_EMPTY;

	if(msgQueue.size()!=0){
		msg = msgQueue.back();
		msgQueue.pop_back();
	}
	
	return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0xd, (%rax)
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xbe20
cmpq $0x0, %rax
je 0xb095
movq -0x10(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xbe50
movq -0x10(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xbe90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::failureDetected(Node)
void Membership::failureDetected(Node process) // This is the method we call when we detect a failure
{
    Message msg;
    msg.type = MSG_FAIL;
    msg.roundId = 0;
    ipString2Char4( process.ip_str, msg.carrierAdd );
    msg.timeStamp = process.timeStamp;
    msg.TTL = K_FORWARD;

    spreadMessage(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x5, -0x24(%rbp)
movb $0x0, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x41e0
movq -0x70(%rbp), %rdi
leaq -0x1f(%rbp), %rsi
callq 0x1a2b0
jmp 0xb0e6
leaq -0x48(%rbp), %rdi
callq 0x42a0
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rdi
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
movb $0x4, -0x14(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x68(%rbp), %rax
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x8a90
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x42a0
movq -0x50(%rbp), %rdi
callq 0x46a0
// File: luisremis[P]SDFS/Membership.cpp
// Function: MemberUpdateMsg::operator=(MemberUpdateMsg const&)
MemberUpdateMsg & MemberUpdateMsg::operator=( MemberUpdateMsg const & msg){
    this->type = msg.type;
    this->node = msg.node;
    this->fileSystemRead = msg.fileSystemRead;
    return *this;   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0xbbd0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::pullMsgFromFileSysQueue()
MemberUpdateMsg Membership::pullMsgFromFileSysQueue(){
    std::unique_lock<std::mutex> locker( fileSysMsgQueueLock );

    while( fileSysMsgQueue.size()==0 ){
        this->fileSysMsgQueueCV.wait( locker );
    }
    
    MemberUpdateMsg msg = fileSysMsgQueue[ 0 ];
    fileSysMsgQueue.erase( fileSysMsgQueue.begin() );
    
    return msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
addq $0x370, %rsi            # imm = 0x370
leaq -0x20(%rbp), %rdi
callq 0xbf30
movq -0x58(%rbp), %rdi
addq $0x358, %rdi            # imm = 0x358
callq 0xc020
cmpq $0x0, %rax
jne 0xb302
movq -0x58(%rbp), %rdi
addq $0x398, %rdi            # imm = 0x398
leaq -0x20(%rbp), %rsi
callq 0x4160
jmp 0xb2d6
movq -0x58(%rbp), %rdi
movb $0x0, -0x21(%rbp)
addq $0x358, %rdi            # imm = 0x358
xorl %eax, %eax
movl %eax, %esi
callq 0xc050
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xb1d0
jmp 0xb328
movq -0x58(%rbp), %rdi
addq $0x358, %rdi            # imm = 0x358
movq %rdi, -0x78(%rbp)
callq 0xc0e0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc110
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc070
movq %rax, -0x70(%rbp)
jmp 0xb360
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xb3a2
jmp 0xb399
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb3b8
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb930
jmp 0xb3b8
movq -0x68(%rbp), %rdi
callq 0xb930
leaq -0x20(%rbp), %rdi
callq 0xbfe0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xbfe0
movq -0x30(%rbp), %rdi
callq 0x46a0
nopw (%rax,%rax)
// File: luisremis[P]SDFS/Membership.cpp
// Function: Membership::emptyFileSysQueue()
bool Membership::emptyFileSysQueue(){
    fileSysMsgQueueLock.lock();
    bool ret = fileSysMsgQueue.size();
    fileSysMsgQueueLock.unlock();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x370, %rdi            # imm = 0x370
callq 0xb5f0
movq -0x18(%rbp), %rdi
addq $0x358, %rdi            # imm = 0x358
callq 0xc020
movq -0x18(%rbp), %rdi
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x370, %rdi            # imm = 0x370
callq 0xb620
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::FileSystem(int, Membership&)
FileSystem::FileSystem(int port, Membership& m) :
    membership(m), port(port)
{
	logFile.open("logFileSystem.log"); // we can make all the logs going to a single file, but nah.

    std::thread th2(&FileSystem::updateThread, this);
    ringUpdating.swap(th2);

    std::thread th1(&FileSystem::listeningThread, this);
    listening.swap(th1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x4630
movq -0x70(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x200(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x208(%rdi)
addq $0x210, %rdi            # imm = 0x210
movq %rdi, -0xa0(%rbp)
callq 0x162b0
movq -0x70(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0xb550
movq -0x70(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movq %rdi, -0x98(%rbp)
callq 0x162d0
movq -0x70(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0xb550
movq -0x70(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
movq %rdi, -0x90(%rbp)
callq 0x162f0
movq -0x70(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
movq %rdi, -0x88(%rbp)
callq 0xb570
movq -0x70(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
movq %rdi, -0x80(%rbp)
callq 0xb5b0
movq -0x70(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movq %rdi, -0x78(%rbp)
callq 0xb5b0
movq -0x70(%rbp), %rdi
leaq 0xc344(%rip), %rsi      # 0x1ca64
movl $0x10, %edx
callq 0x4070
jmp 0x1072c
movq -0xa8(%rbp), %rax
leaq 0x116(%rip), %rcx       # 0x10850
movq %rcx, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x16310
jmp 0x1075d
movq -0xa8(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
leaq -0x30(%rbp), %rsi
callq 0xb700
movq -0xa8(%rbp), %rax
leaq 0x33e(%rip), %rcx       # 0x10ac0
movq %rcx, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x16310
jmp 0x107a5
movq -0xa8(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xb700
leaq -0x50(%rbp), %rdi
callq 0x5840
leaq -0x30(%rbp), %rdi
callq 0x5840
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x107fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5840
movq -0x78(%rbp), %rdi
callq 0x5840
movq -0x80(%rbp), %rdi
callq 0x5840
movq -0x88(%rbp), %rdi
callq 0xb7f0
movq -0x90(%rbp), %rdi
callq 0x163d0
movq -0x98(%rbp), %rdi
callq 0x163f0
movq -0xa0(%rbp), %rdi
callq 0x16450
movq -0x70(%rbp), %rdi
callq 0x4768
movq -0x20(%rbp), %rdi
callq 0x46a0
nop
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::findPositionByKey(int)
int FileSystem::findPositionByKey( int key ){
    int position = 0;
    virtualRingLock.lock();
    for(int i=0; i < virtualRing.size(); i++){
        if(virtualRing[i].key >= key ){ //find the first virtual node with n.key >= key. If not, return the first Node.
            position = i;
            break;
        }
    }
    virtualRingLock.unlock();
    return position;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
addq $0x268, %rdi            # imm = 0x268
callq 0xb5f0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x11096
movq -0x20(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0x14(%rbp), %rsi
callq 0x164a0
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x11089
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x11096
jmp 0x1108b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11041
movq -0x20(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0xb620
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::deleteFromAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool FileSystem::deleteFromAddress(std::string address, std::string remoteFile)
{
    int connectionToServer; //TCP connect to introducer/other nodes

    // printf("Local file: %s\n", localFile.c_str());
    // printf("Remote file: %s\n", remoteFile.c_str());

    logFile << "Deleting -  Connecting to "<< address << "..." << std::endl;

    int ret = connect_to_server(address.c_str(), port, &connectionToServer);
    if(ret!=0)
    {
        logFile <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        std::cout <<"ERROR putToAddress: Cannot connect to "<<address<< std::endl;
        return false;
    }
    else{

        Message_fs msg;
        msg.type = MSG_DELETE;

        memset(msg.filename, '\0', 200);
        remoteFile.copy(msg.filename, remoteFile.length());
        msg.filename[remoteFile.length()+1] = '\0';
        msg.size = 0;

        write(connectionToServer, &msg, sizeof(Message_fs) );   

        close(connectionToServer);
        return true;
    }   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0x118(%rbp)
movq %rdx, -0x120(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq 0xb323(%rip), %rsi      # 0x1cc2a
callq 0x43f0
movq -0x118(%rbp), %rsi
movq %rax, %rdi
callq 0x4370
movq %rax, %rdi
leaq 0xae93(%rip), %rsi      # 0x1c7b8
callq 0x43f0
movq %rax, %rdi
movq 0x15674(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x118(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
movq -0x110(%rbp), %rax
movl 0x200(%rax), %esi
leaq -0x24(%rbp), %rdx
callq 0x1aaf0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x119d2
movq -0x110(%rbp), %rdi
leaq 0xb28e(%rip), %rsi      # 0x1cc03
callq 0x43f0
movq -0x118(%rbp), %rsi
movq %rax, %rdi
callq 0x4370
movq %rax, %rdi
movq 0x15615(%rip), %rsi     # 0x26fa8
callq 0x4410
movq 0x15621(%rip), %rdi     # 0x26fc0
leaq 0xb25d(%rip), %rsi      # 0x1cc03
callq 0x43f0
movq -0x118(%rbp), %rsi
movq %rax, %rdi
callq 0x4370
movq %rax, %rdi
movq 0x155e4(%rip), %rsi     # 0x26fa8
callq 0x4410
movb $0x0, -0x1(%rbp)
jmp 0x11a67
movl $0x2, -0x108(%rbp)
leaq -0x108(%rbp), %rdi
addq $0x4, %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x4240
movq -0x120(%rbp), %rdi
leaq -0x108(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x128(%rbp)
callq 0x4590
movq -0x128(%rbp), %rsi
movq -0x120(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x40c0
movq -0x120(%rbp), %rdi
callq 0x4590
movb $0x0, -0x103(%rbp,%rax)
movq $0x0, -0x38(%rbp)
movl -0x24(%rbp), %edi
leaq -0x108(%rbp), %rsi
movl $0xe0, %edx
callq 0x4190
movl -0x24(%rbp), %edi
callq 0x4740
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::where(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FileSystem::where(std::string remoteFile)
{    
    int fileKey = hashString(remoteFile);
    int position = findPositionByKey(fileKey);

    std::cout<< "Master Replica: " << virtualRing[position].ip_str << std::endl;
    std::cout<< "Second Replica: " << virtualRing[ (position+1) % virtualRing.size()].ip_str << std::endl;
    std::cout<< "Second Replica: " << virtualRing[ (position+2) % virtualRing.size()].ip_str << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41e0
leaq -0x38(%rbp), %rdi
callq 0x10600
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x42a0
movl -0x84(%rbp), %eax
movq -0x60(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x11010
movl %eax, -0x3c(%rbp)
movq 0x14ae5(%rip), %rdi     # 0x26fc0
leaq 0xa5a7(%rip), %rsi      # 0x1ca89
callq 0x43f0
movq -0x60(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x250, %rdi            # imm = 0x250
movslq -0x3c(%rbp), %rsi
callq 0x164a0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, %rdi
movq 0x14a93(%rip), %rsi     # 0x26fa8
callq 0x4410
movq 0x14a9f(%rip), %rdi     # 0x26fc0
leaq 0xa572(%rip), %rsi      # 0x1ca9a
callq 0x43f0
movq -0x60(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq %rdi, %rax
addq $0x250, %rax            # imm = 0x250
movq %rax, -0x78(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x70(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movq -0x70(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0x164a0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, %rdi
movq 0x14a20(%rip), %rsi     # 0x26fa8
callq 0x4410
movq 0x14a2c(%rip), %rdi     # 0x26fc0
leaq 0xa4ff(%rip), %rsi      # 0x1ca9a
callq 0x43f0
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rdi, %rax
addq $0x250, %rax            # imm = 0x250
movq %rax, -0x58(%rbp)
movl -0x3c(%rbp), %eax
addl $0x2, %eax
cltq
movq %rax, -0x50(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0x164a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, %rdi
movq 0x149ad(%rip), %rsi     # 0x26fa8
callq 0x4410
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: inRange(int, int, int)
bool inRange(int key, int min, int max){
    if(min < max)
        return (min<key && key<=max);
    else
        return ( (0 <= key && key <= max) || (min < key && key <= RING_SIZE)  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x14098
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x11(%rbp)
jge 0x1408e
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
setle %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x140d4
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0x140ac
movl -0x8(%rbp), %ecx
movb $0x1, %al
cmpl -0x10(%rbp), %ecx
movb %al, -0x12(%rbp)
jle 0x140cc
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x8(%rbp), %ecx
movb %al, -0x13(%rbp)
jge 0x140c6
cmpl $0x3e8, -0x8(%rbp)      # imm = 0x3E8
setle %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::getFileList[abi:cxx11]()
std::string FileSystem::getFileList()
{
    std::stringstream ss;

    checkFiles();

    filesLock.lock();
    for (std::list<FileEntry>::iterator it=files.begin(); it != files.end(); ++it)
    {
        ss << (*it).filename << " " << (*it).key << std::endl;
    }
    filesLock.unlock();

    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1c0(%rbp), %rdi
callq 0x12610
jmp 0x14129
movq -0x1c0(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0xb5f0
jmp 0x1413e
movq -0x1c0(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x164c0
movq %rax, -0x1b0(%rbp)
movq -0x1c0(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x164f0
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x16520
testb $0x1, %al
jne 0x1418e
jmp 0x14248
leaq -0x188(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x16550
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x4370
movq %rax, -0x1d8(%rbp)
jmp 0x141c0
movq -0x1d8(%rbp), %rdi
leaq 0x8154(%rip), %rsi      # 0x1c322
callq 0x43f0
movq %rax, -0x1e8(%rbp)
jmp 0x141dc
leaq -0x1b0(%rbp), %rdi
callq 0x16550
movq -0x1e8(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x4670
movq %rax, -0x1f0(%rbp)
jmp 0x14200
movq -0x1f0(%rbp), %rdi
movq 0x12d9a(%rip), %rsi     # 0x26fa8
callq 0x4410
jmp 0x14215
jmp 0x14217
leaq -0x1b0(%rbp), %rdi
callq 0x16570
jmp 0x14158
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42f0
jmp 0x1428e
movq -0x1c0(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0xb620
jmp 0x1425d
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x43e0
jmp 0x14272
leaq -0x198(%rbp), %rdi
callq 0x42f0
movq -0x1c8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x46a0
nopw (%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::printVirtualRing()
void FileSystem::printVirtualRing()
{
    virtualRingLock.lock();
    for(int i=0; i < virtualRing.size(); i++)
    {
        std::cout << virtualRing[i].ip_str << " " << virtualRing[i].key;
        if (virtualRing[i].key == myself.key)
            std::cout << " X ";
        std::cout << std::endl;
    }
    std::cout<<std::endl;
    virtualRingLock.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x268, %rdi            # imm = 0x268
callq 0xb5f0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x14eac
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0xc(%rbp), %rsi
callq 0x164a0
movq %rax, %rsi
movq 0x121a3(%rip), %rdi     # 0x26fc0
callq 0x4370
movq %rax, %rdi
leaq 0x74f6(%rip), %rsi      # 0x1c322
callq 0x43f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x250, %rdi            # imm = 0x250
movslq -0xc(%rbp), %rsi
callq 0x164a0
movq -0x28(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x4670
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0xc(%rbp), %rsi
callq 0x164a0
movq -0x18(%rbp), %rcx
movl 0x20(%rax), %eax
cmpl 0x2b8(%rcx), %eax
jne 0x14e8b
movq 0x12141(%rip), %rdi     # 0x26fc0
leaq 0x7e73(%rip), %rsi      # 0x1ccf9
callq 0x43f0
movq 0x1212e(%rip), %rdi     # 0x26fc0
movq 0x1210f(%rip), %rsi     # 0x26fa8
callq 0x4410
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14dd7
movq 0x1210d(%rip), %rdi     # 0x26fc0
movq 0x120ee(%rip), %rsi     # 0x26fa8
callq 0x4410
movq -0x18(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0xb620
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::nNodeLater(int, int)
FileSystem::VirtualNode FileSystem::nNodeLater(int n, int current)
{
    int position = current + n;
    while(position < 0)
        position += virtualRing.size();
    while(position >= virtualRing.size())
        position -= virtualRing.size();
    
    return virtualRing[position];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x15637
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x15612
jmp 0x15639
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x1567c
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x15639
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0x1c(%rbp), %rsi
callq 0x164a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x16be0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::nNodeBefore(int, int)
FileSystem::VirtualNode FileSystem::nNodeBefore(int n, int current)
{
    int position = current - n;
    while(position < 0)
        position += virtualRing.size();
    while(position >= virtualRing.size())
        position -= virtualRing.size();
    
    return virtualRing[position];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x15707
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x156e2
jmp 0x15709
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x1574c
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x16470
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x15709
movq -0x28(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
movslq -0x1c(%rbp), %rsi
callq 0x164a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x16be0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/FileSystem.cpp
// Function: FileSystem::myselfLeave(Node)
bool FileSystem::myselfLeave( Node myNodeToChange ){
    deleteFromVirtualRing( myNodeToChange );
    
    filesLock.lock();
    files.clear();
    //system("rm files/*");
    filesLock.unlock();

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb8f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x14ac0
jmp 0x16164
leaq -0x38(%rbp), %rdi
callq 0xb7f0
movq -0x58(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0xb5f0
movq -0x58(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x16c20
movq -0x58(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0xb620
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb7f0
movq -0x40(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)
// File: luisremis[P]SDFS/connections.cpp
// Function: ipString2Char4(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*)
void ipString2Char4(std::string ip, char* buf) // buf must be size 4
{
    ip.replace(ip.find("."),1," ");
    ip.replace(ip.find("."),1," ");
    ip.replace(ip.find("."),1," ");
    
    std::stringstream ssip(ip);
    int a;
    ssip >> a; buf[0] = (char)a; 
    ssip >> a; buf[1] = (char)a; 
    ssip >> a; buf[2] = (char)a; 
    ssip >> a; buf[3] = (char)a; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x24e9(%rip), %rsi      # 0x1c7ba
movq %rsi, -0x1e0(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x1d8(%rbp)
callq 0x4750
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
leaq 0x2029(%rip), %rcx      # 0x1c322
movq %rcx, -0x1c8(%rbp)
movl $0x1, %edx
movq %rdx, -0x1d0(%rbp)
callq 0x4280
movq -0x1e0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
movq -0x1c0(%rbp), %rdi
callq 0x4750
movq -0x1d0(%rbp), %rdx
movq -0x1c8(%rbp), %rcx
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
callq 0x4280
movq -0x1e0(%rbp), %rsi
movq -0x1d8(%rbp), %rdx
movq -0x1c0(%rbp), %rdi
callq 0x4750
movq -0x1d0(%rbp), %rdx
movq -0x1c8(%rbp), %rcx
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
callq 0x4280
movl $0x10, %edi
movl $0x8, %esi
callq 0x1b0f0
movq -0x1c0(%rbp), %rsi
movl %eax, %edx
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x45e0
movq -0x1b8(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x4290
jmp 0x1a3bf
movb -0x19c(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
leaq -0x198(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x4290
jmp 0x1a3e0
movb -0x19c(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
leaq -0x198(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x4290
jmp 0x1a402
movb -0x19c(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
leaq -0x198(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x4290
jmp 0x1a424
movl -0x19c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
leaq -0x198(%rbp), %rdi
callq 0x42f0
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x42f0
movq -0x1a8(%rbp), %rdi
callq 0x46a0
nopw %cs:(%rax,%rax)