LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: operator<<(std::ostream&, Input&)
ostream& operator<<(ostream& output, Input& rhs) { 
  output << "JID = " << rhs.getJID() << ", In foreground? " << rhs.isForeground() << endl;
  for(unsigned int i = 0, s = rhs.getProcesses().size(); i < s; i++) {
    output << "Process " << i << " (PID/PGID = " << rhs.getProcesses()[i].PID << "/" << rhs.getProcesses()[i].PGID << ") argv: ";
    for(unsigned int j = 0; j < rhs.getProcesses()[i].args.size(); j++) {
      output << rhs.getProcesses()[i].args[j] << " ";
    } // for
    if(i != s-1) { output << endl; } // if not last iter
  } // for
  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x27e4(%rip), %rsi      # 0xeb13
movl $0x6, %edx
callq 0x3300
movl (%r14), %esi
movq %rbx, %rdi
callq 0x3510
movq %rax, %r15
leaq 0x27cc(%rip), %rsi      # 0xeb1a
movl $0x11, %edx
movq %rax, %rdi
callq 0x3300
movzbl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x34b0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x38(%r14), %rcx
subq 0x30(%r14), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
testl %eax, %eax
je 0xc500
leal -0x1(%rax), %ecx
movq %rcx, -0x40(%rbp)
movl %eax, %eax
movq %rax, -0x38(%rbp)
xorl %r15d, %r15d
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x2759(%rip), %rsi      # 0xeb2c
callq 0x3300
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %r13
movl $0xd, %edx
movq %rax, %rdi
leaq 0x2740(%rip), %rsi      # 0xeb35
callq 0x3300
movq 0x30(%r14), %rax
movq %r15, -0x30(%rbp)
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,4), %r12
movl (%rax,%r12), %esi
movq %r13, %rdi
callq 0x3510
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x24c8(%rip), %rsi      # 0xe8f4
callq 0x3300
movq 0x30(%r14), %rax
movl 0x4(%rax,%r12), %esi
movq %r13, %rdi
callq 0x3510
movl $0x8, %edx
movq %rax, %rdi
leaq 0x26f2(%rip), %rsi      # 0xeb43
callq 0x3300
movq 0x30(%r14), %rcx
movq 0x10(%rcx,%r12), %rax
cmpq %rax, 0x18(%rcx,%r12)
leaq 0x12b7(%rip), %r15      # 0xd722
je 0xc4c2
movl $0x1, %r13d
movq -0x30(%rbp), %rcx
leaq (%rcx,%rcx,4), %r12
xorl %ecx, %ecx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %rbx, %rdi
callq 0x3300
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3300
movl %r13d, %ecx
movq 0x30(%r14), %rdx
movq 0x10(%rdx,%r12,8), %rax
movq 0x18(%rdx,%r12,8), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
incl %r13d
cmpq %rcx, %rdx
ja 0xc47d
movq -0x30(%rbp), %r15
cmpq -0x40(%rbp), %r15
je 0xc4f3
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3290
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
incq %r15
cmpq -0x38(%rbp), %r15
jne 0xc3c4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string trim(string input) {
  string s = input;
  const char * ws = " \t"; // chars to trim
  s = s.erase(s.find_last_not_of(ws) + 1); // trims end 
  s = s.erase(0, s.find_first_not_of(ws)); // trims beginning  
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x9f52
leaq 0x25d1(%rip), %rsi      # 0xeb10
movl $0x2, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x3480
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0xc5b1
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3180
leaq 0x2594(%rip), %rsi      # 0xeb10
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x34f0
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x3080
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25aa(%rip), %rdi      # 0xeb62
leaq 0x258f(%rip), %rsi      # 0xeb4e
movq %rax, %rdx
xorl %eax, %eax
callq 0x3440
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xc5df
movq (%r15), %rsi
incq %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: sanitize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string sanitize(string input, string charsToRemove) {
  const string unwanted = charsToRemove ;
  std::string sanitized_str = "";
  for(char c : input) {
    if(unwanted.find(c) == string::npos) {
      sanitized_str += c;
    } // if
  } // for
  return sanitized_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x9f52
leaq 0x10(%rbx), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rbx)
leaq 0x24e7(%rip), %rdx      # 0xeb12
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x9ff0
movq 0x8(%r14), %r12
testq %r12, %r12
je 0xc679
movq (%r14), %r13
xorl %ebx, %ebx
leaq -0x58(%rbp), %r14
movsbl (%r13,%rbx), %r15d
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x3390
cmpq $-0x1, %rax
jne 0xc671
movq -0x30(%rbp), %rdi
movl %r15d, %esi
callq 0x3250
incq %rbx
cmpq %rbx, %r12
jne 0xc64c
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xc692
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x32c0
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xc6c9
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0xc6c9
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x32c0
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xc6e2
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: hasQuotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool hasQuotes(string input) {
  for(unsigned int i = 0; i < input.length(); i++) {
    if(i == 0) {
      if(input[i] == '"') return true;
    } else {
      if(input[i] == '"' && input[i-1] != '\\') return true;
    } // if/else
  } // for
  return false;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xc72e
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movl $0x1, %edx
xorl %esi, %esi
movb (%rcx,%rsi), %sil
cmpl $0x1, %edx
jne 0xc712
cmpb $0x22, %sil
jne 0xc721
jmp 0xc731
cmpb $0x22, %sil
jne 0xc721
leal -0x2(%rdx), %esi
cmpb $0x5c, (%rcx,%rsi)
jne 0xc731
movl %edx, %esi
incl %edx
cmpq %rsi, %rax
ja 0xc701
xorl %eax, %eax
jmp 0xc733
xorl %eax, %eax
retq
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brandoncanaday[P]1730sh/Input.cpp
// Function: pos_of_first_quote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned int pos_of_first_quote(string input) {
  int pos = 0;
  for(unsigned int i = 0; i < input.length(); i++) {
    if(i == 0) {
      if(input[i] == '"') {
	pos = i; 
	break;
      } // if
    } else {
      if(input[i] == '"' && input[i-1] != '\\') {
	pos = i;
	break;
      } // if
    } // if/else
  } // for
  return pos;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xc781
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rsi
xorl %edx, %edx
xorl %edi, %edi
movb (%rsi,%rdi), %dil
testl %edx, %edx
je 0xc76a
cmpb $0x22, %dil
jne 0xc760
leal -0x1(%rdx), %eax
cmpb $0x5c, (%rsi,%rax)
jne 0xc788
leal 0x1(%rdx), %edi
cmpq %rdi, %rcx
ja 0xc77d
jmp 0xc784
xorl %eax, %eax
cmpb $0x22, %dil
je 0xc78a
movl $0x1, %edi
cmpq $0x1, %rcx
je 0xc78a
incl %edx
jmp 0xc749
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0xc78a
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/main.cpp
// Function: main
int main (int argc, char* argv[])
{
    srand (time(NULL));

    system("rm files/*");
    system("clear");

    std::cout << std::endl << "CS425 - MP3: Distributed File System" ;
    std::cout << std::endl << std::endl;

    logFile.open("log.log");
    logFile << "Inicializing! " << std::endl;

    int port = atoi(argv[1]);
    bool isIntroducer = atoi(argv[2]);

    Membership m(isIntroducer, port);
    FileSystem fs (port + 21, m);

    std::thread cinListening(listeningCin, &m, &fs);
    cinListening.join();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x6d8, %rsp            # imm = 0x6D8
movq %rsi, %rbx
xorl %edi, %edi
callq 0x4340
movl %eax, %edi
callq 0x4370
leaq 0xde43(%rip), %rdi      # 0x132dd
callq 0x4300
leaq 0xdd9b(%rip), %rdi      # 0x13241
callq 0x4300
movq 0x13b0e(%rip), %r14     # 0x18fc0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq 0xde08(%rip), %rsi      # 0x132e8
movl $0x24, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq 0x13e43(%rip), %r14     # 0x19388
leaq 0xddc1(%rip), %rsi      # 0x1330d
movq %r14, %rdi
movl $0x10, %edx
callq 0x4060
leaq 0xddb5(%rip), %rsi      # 0x13315
movl $0xe, %edx
movq %r14, %rdi
callq 0x43f0
movq 0x13e14(%rip), %rax     # 0x19388
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movq 0x8(%rbx), %rdi
callq 0x4520
movl %eax, %r15d
movq 0x10(%rbx), %rdi
callq 0x4520
xorl %esi, %esi
testl %eax, %eax
setne %sil
leaq -0x6f0(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %edx
callq 0x57c8
addl $0x15, %r15d
leaq -0x328(%rbp), %r14
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0xb214
leaq -0x30(%rbp), %rdx
movq %rbx, (%rdx)
leaq -0x28(%rbp), %rcx
movq %r14, (%rcx)
leaq -0xc49(%rip), %rsi      # 0x49ac
leaq -0x20(%rbp), %rdi
callq 0x566a
leaq -0x20(%rbp), %rdi
callq 0x45e0
cmpq $0x0, -0x20(%rbp)
jne 0x563d
leaq -0x328(%rbp), %rdi
callq 0xb9dc
leaq -0x6f0(%rbp), %rdi
callq 0x73a0
xorl %eax, %eax
addq $0x6d8, %rsp            # imm = 0x6D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, -0x20(%rbp)
je 0x5642
callq 0x4110
movq %rax, %rbx
leaq -0x328(%rbp), %rdi
callq 0xb9dc
jmp 0x5656
movq %rax, %rbx
leaq -0x6f0(%rbp), %rdi
callq 0x73a0
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::join()
void Membership::join()
{
	bool joined = firstJoin();
    while( !isIntroducer && !joined)
    {   //introducer will firstJoin() once. Other node will keep firstJoin() until it enter the group.
        joined = firstJoin();
        //usleep( 1000*1000 );
    }


    MemberUpdateMsg msg( MSG_JOIN_FINISH , members[0]);
    pushMsgToFileSysQueue(msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
callq 0x7546
testb %al, %al
jne 0x5edc
cmpb $0x0, 0x2cc(%rbx)
jne 0x5edc
movq %rbx, %rdi
jmp 0x5ec5
movq 0x258(%rbx), %r12
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x56fa
movq 0x20(%r12), %rax
movq %rax, 0x20(%r14)
leaq -0xb8(%rbp), %rdi
movl $0x8, %esi
movq %r14, %rdx
callq 0x9ede
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x5f2e
callq 0x4360
leaq -0x80(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x9f42
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x7a90
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f5c
callq 0x4360
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f71
callq 0x4360
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f9b
callq 0x4360
jmp 0x5f9b
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fb0
callq 0x4360
movq %rbx, %rdi
callq 0x4630
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
jne 0x5fab
jmp 0x5fb0
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::~Membership()
Membership::~Membership()
{
	//Kill threads
	killListeningThread = true;
	killDetectingThread = true;

	listening.join();
	detecting.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw $0x101, 0x350(%rdi)     # imm = 0x101
leaq 0x338(%rdi), %r14
movq %r14, %rdi
callq 0x45e0
leaq 0x340(%rbx), %r15
movq %r15, %rdi
callq 0x45e0
leaq 0x398(%rbx), %rdi
callq 0x4660
leaq 0x358(%rbx), %rdi
callq 0xa1bc
cmpq $0x0, 0x348(%rbx)
jne 0x74ae
cmpq $0x0, (%r15)
jne 0x74ae
cmpq $0x0, (%r14)
jne 0x74ae
movq 0x2f8(%rbx), %rdi
testq %rdi, %rdi
je 0x741f
callq 0x4360
movq 0x2d8(%rbx), %rdi
leaq 0x2e8(%rbx), %rax
cmpq %rax, %rdi
je 0x7437
callq 0x4360
movq 0x270(%rbx), %rdi
leaq 0x280(%rbx), %rax
cmpq %rax, %rdi
je 0x744f
callq 0x4360
leaq 0x258(%rbx), %rdi
callq 0xa246
leaq 0x218(%rbx), %rdi
callq 0xa246
leaq 0x200(%rbx), %rdi
callq 0xa29e
movq 0x11b3e(%rip), %rax     # 0x18fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, (%rbx)
movq -0x18(%rcx), %rcx
movq %rax, (%rbx,%rcx)
leaq 0x8(%rbx), %rdi
callq 0x42f0
addq $0xf8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4160
callq 0x4110
movq %rax, %r15
leaq 0x398(%rbx), %rdi
callq 0x4660
leaq 0x358(%rbx), %rdi
callq 0xa1bc
leaq 0x348(%rbx), %rdi
callq 0xa1ac
leaq 0x340(%rbx), %rdi
callq 0xa1ac
movq %r14, %rdi
callq 0xa1ac
leaq 0x2f8(%rbx), %rdi
callq 0xa216
leaq 0x2d8(%rbx), %rdi
callq 0x41c0
leaq 0x270(%rbx), %rdi
callq 0xa22a
leaq 0x258(%rbx), %rdi
callq 0xa246
leaq 0x218(%rbx), %rdi
callq 0xa246
leaq 0x200(%rbx), %rdi
callq 0xa29e
movq %rbx, %rdi
callq 0x46c8
movq %r15, %rdi
callq 0x4440
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::pushMsgToFileSysQueue(MemberUpdateMsg)
void Membership::pushMsgToFileSysQueue(MemberUpdateMsg msg){
    std::unique_lock<std::mutex> locker( fileSysMsgQueueLock );

    this->fileSysMsgQueue.push_back(msg);

    this->fileSysMsgQueueCV.notify_all();
    usleep(5000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x370(%rdi), %rax
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0xae10
movb $0x1, 0x8(%r15)
leaq 0x358(%rbx), %rdi
movq %r14, %rsi
callq 0xa52e
addq $0x398, %rbx            # imm = 0x398
movq %rbx, %rdi
callq 0x45d0
movl $0x1388, %edi           # imm = 0x1388
callq 0x4490
leaq -0x28(%rbp), %rdi
callq 0xa56a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0xa56a
movq %rbx, %rdi
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::leave()
void Membership::leave()
{
    membersLock.lock();
    Message msg;
    msg.type = MSG_LEAVE;
    msg.TTL = 1; // Just in case
    ipString2Char4(members.at(0).ip_str, msg.carrierAdd);
    msg.timeStamp = members.at(0).timeStamp;
    membersLock.unlock();
    spreadMessage(msg); // this method wants the lock!
    
    while(members.size()!=0){
        failMember(members[0].ip_str, members[0].timeStamp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x230(%rdi), %r14
movq %r14, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x7c50
movl $0x7, -0x38(%rbp)
movb $0x1, -0x28(%rbp)
movq 0x258(%rbx), %rax
cmpq %rax, 0x260(%rbx)
je 0x7c3e
leaq -0x68(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x56fa
leaq -0x33(%rbp), %rsi
movq %r15, %rdi
callq 0x10fc0
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x7b95
callq 0x4360
movq 0x258(%rbx), %rax
cmpq %rax, 0x260(%rbx)
je 0x7c3e
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
callq 0x42a0
movl -0x28(%rbp), %eax
movl %eax, 0x10(%rsp)
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7c7e
movq 0x258(%rbx), %rax
cmpq %rax, 0x260(%rbx)
je 0x7c31
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
movq %r15, -0x58(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x56fa
movq 0x258(%rbx), %rax
movl 0x20(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7fc0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x7c21
callq 0x4360
movq 0x258(%rbx), %rax
cmpq %rax, 0x260(%rbx)
jne 0x7be8
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbd30(%rip), %rdi      # 0x13975
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x44e0
movl %eax, %edi
callq 0x4240
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
jne 0x7c71
jmp 0x7c76
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x7c76
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::failMember(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Membership::failMember(std::string ip_str, int timeStamp){

    membersLock.lock();

    bool exist = false;
    int position = 0;

    for(int i=0; i<members.size(); i++){
        if( members[i].ip_str.compare( ip_str )==0 && members[i].timeStamp == timeStamp ){
            exist = true;
            position = i;
            break;
        }
    }
    
    if(exist){
        MemberUpdateMsg msg(MSG_LEAVE, members[position]);
        pushMsgToFileSysQueue(msg);

        members.erase( members.begin()+position );
    }
    
    membersLock.unlock();

    checkLeader();

    return !exist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r13
movq %rdi, %r15
leaq 0x230(%rdi), %rbx
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x8158
movq 0x258(%r15), %r14
movl $0x1, %r12d
cmpq %r14, 0x260(%r15)
je 0x8133
movq %rbx, -0x38(%rbp)
movq %r15, %rbx
leaq 0x258(%r15), %rax
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
xorl %r15d, %r15d
addq %r12, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4050
movq -0x40(%rbp), %rcx
movq (%rcx), %r14
testl %eax, %eax
jne 0x8049
movl -0x2c(%rbp), %eax
cmpl %eax, 0x20(%r14,%r12)
je 0x8083
incq %r15
movq 0x260(%rbx), %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq $0x28, %r12
cmpq %r15, %rax
ja 0x8026
movq %rbx, %r15
movq -0x38(%rbp), %rbx
movl $0x1, %r12d
jmp 0x8133
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14,%r12), %rsi
movq 0x8(%r14,%r12), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x56fa
movq 0x20(%r14,%r12), %rax
movq %rax, 0x20(%r13)
leaq -0xd8(%rbp), %rdi
movl $0x7, %esi
movq %r13, %rdx
callq 0x9ede
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
movq %rbx, %r15
je 0x80d1
callq 0x4360
leaq -0xa0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x9f42
leaq -0xa0(%rbp), %rsi
movq %r15, %rdi
callq 0x7a90
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8108
callq 0x4360
movq -0x40(%rbp), %rdi
addq (%rdi), %r12
movq %r12, %rsi
callq 0xabfc
leaq -0xc0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
movq -0x38(%rbp), %rbx
je 0x8130
callq 0x4360
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x42a0
movq %r15, %rdi
callq 0x920c
movl %r12d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x4240
jmp 0x817b
movq %rax, %rbx
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x817e
callq 0x4360
jmp 0x817e
movq %rax, %rbx
leaq -0xc0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8193
callq 0x4360
movq %rbx, %rdi
callq 0x4630
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
jne 0x818e
jmp 0x8193
nop
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::broadcastJoin(Message, int)
int Membership::broadcastJoin(Message income, int i)
{
	income.TTL = 0;
	int connectionToServer;
    //TCP connect to members of introducer
    logFile<<"broadcastJoin: Introducer trying to broadcast join to "<<members[i].ip_str << std::endl;
    int ret = connect_to_server(members[i].ip_str.c_str(), port + 1, &connectionToServer);
    if(ret!=0){
        logFile<<"broadcastJoin: cannot connect to "<<members[i].ip_str << std::endl;
        return 1;
    }
    else{
    	ret = write(connectionToServer, &income, sizeof(Message) );
    	close(connectionToServer);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movb $0x0, 0x20(%rbp)
leaq 0xae42(%rip), %rsi      # 0x134fe
movl $0x36, %edx
callq 0x43f0
movslq %r14d, %r15
movq 0x258(%rbx), %rax
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,4), %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movq 0x258(%rbx), %rax
movq (%rax,%r12), %rdi
movl 0x298(%rbx), %esi
incl %esi
leaq -0x24(%rbp), %rdx
callq 0x1161a
testl %eax, %eax
je 0x8798
leaq 0xadf7(%rip), %rsi      # 0x13535
movl $0x21, %edx
movq %rbx, %rdi
callq 0x43f0
movq 0x258(%rbx), %rax
leaq (%r15,%r15,4), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rax,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movl $0x1, %eax
jmp 0x87b3
leaq 0x10(%rbp), %rsi
movl -0x24(%rbp), %edi
movl $0x14, %edx
callq 0x4170
movl -0x24(%rbp), %edi
callq 0x46b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::piggyMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::piggyMsg( Message msg, std::string sender )
{
    std::string target = char42String(msg.carrierAdd);
    msg.type = MSG_PIGGY_PING;

    ipString2Char4(sender, msg.carrierAdd); //Original Sender as carrier

    sendUDP( sockfd,  target, port, (char*)&msg, sizeof(Message) );
    logFile << "Weired!: " << sender << " says that " << target << " did not responde..." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15(%rbp), %r15
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x11124
movl $0x3, -0x5(%r15)
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x56fa
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x10fc0
leaq 0x10(%rbp), %r15
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x88d3
callq 0x4360
movl 0x298(%rbx), %edx
movl 0x29c(%rbx), %edi
leaq -0x40(%rbp), %rsi
movq %r15, %rcx
movl $0x14, %r8d
callq 0x1142c
leaq 0xaec1(%rip), %rsi      # 0x137b9
movl $0x9, %edx
movq %rbx, %rdi
callq 0x43f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0xaea5(%rip), %rsi      # 0x137c3
movl $0xb, %edx
movq %rax, %rdi
callq 0x43f0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %rbx
leaq 0xae8a(%rip), %rsi      # 0x137cf
movl $0x14, %edx
movq %rax, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x898b
callq 0x4360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x89ae
callq 0x4360
jmp 0x89ae
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89c0
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl $0x4, (%r14)
movl 0x298(%rdi), %edx
movl 0x29c(%rdi), %edi
movq %r14, %rcx
movl $0x14, %r8d
callq 0x1142c
leaq 0x15(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x11124
movl $0x1, -0x5(%r15)
movl 0x298(%rbx), %edx
movl 0x29c(%rbx), %edi
movq %r12, %rsi
movq %r14, %rcx
movl $0x14, %r8d
callq 0x1142c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a49
callq 0x4360
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a6b
callq 0x4360
movq %rbx, %rdi
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x15(%rbp), %r14
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x11124
movl $0x1, -0x5(%r14)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x56fa
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x10fc0
leaq 0x10(%rbp), %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8adb
callq 0x4360
movl 0x298(%rbx), %edx
movl 0x29c(%rbx), %edi
leaq -0x60(%rbp), %rsi
movq %r14, %rcx
movl $0x14, %r8d
callq 0x1142c
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b0b
callq 0x4360
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x8b2e
callq 0x4360
jmp 0x8b2e
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b40
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/luisremis[P]SDFS/Membership.cpp
// Function: Membership::failMsg(Message, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Membership::failMsg( Message msg, std::string sender )
{
	std::string carrier = char42String(msg.carrierAdd);
/*
    if ( my_ip_str.compare(carrier) == 0) // THIS IS MY! I NEED TO REJOIN
    {
        std::cout <<"they are trying to kill me!" << std::endl;
        membersLock.lock();
        members.clear();
        membersLock.unlock();
        usleep( 2000*1000 ); // wait 2 second and rejoin
        bool joined = firstJoin();
        while( !isIntroducer && !joined)
        {   //introducer will firstJoin() once. Other node will keep firstJoin() until it enter the group.
            joined = firstJoin();
            usleep( 1000*1000 );
        }
        return;
    }
*/
    failMember(carrier, msg.timeStamp);
	logFile<<"failMsg: node "<<carrier<<" failed acording to " << sender << std::endl;
/*
    int select = rand()%10;

    if (select <= 7) // 1 and 2
    //if (true) // 1 and 2
    {
        Message justInCase;
        justInCase.type = MSG_FAIL;
        msg.TTL = 0;
        ipString2Char4(carrier, justInCase.carrierAdd);
        sendUDP( sockfd,  carrier, port, (char*)&justInCase, sizeof(Message) );
        // Just in case let the node know so it can rejoin
    }
*/
    if(msg.TTL==0)
    {
        return;
    }
    else{
    	msg.TTL--;
    	spreadMessage(msg);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15(%rbp), %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x11124
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x56fa
leaq 0x10(%rbp), %r12
movl 0xc(%r12), %edx
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x7fc0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8bad
callq 0x4360
leaq 0xabe1(%rip), %rsi      # 0x13795
movl $0xe, %edx
movq %rbx, %rdi
callq 0x43f0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r15
leaq 0xabc9(%rip), %rsi      # 0x137a4
movl $0x14, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x43f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movb 0x10(%r12), %al
testb %al, %al
je 0x8c4d
decb %al
movb %al, 0x10(%r12)
movl 0x10(%r12), %eax
movl %eax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7c7e
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c5f
callq 0x4360
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8c84
callq 0x4360
jmp 0x8c84
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8c96
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x15(%rbp), %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x11124
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x56fa
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x95bc
movl %eax, %r14d
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x8cfc
callq 0x4360
testl %r14d, %r14d
je 0x8dcd
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x56fa
leaq 0x10(%rbp), %r15
movl 0xc(%r15), %edx
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x7fc0
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8d43
callq 0x4360
leaq 0xaa31(%rip), %rsi      # 0x1377b
movl $0xf, %edx
movq %rbx, %rdi
callq 0x43f0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %r14
leaq 0xaa1a(%rip), %rsi      # 0x1378b
movl $0x9, %edx
movq %rax, %rdi
callq 0x43f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movb 0x10(%r15), %al
testb %al, %al
je 0x8dcd
decb %al
movb %al, 0x10(%r15)
movl 0x10(%r15), %eax
movl %eax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7c7e
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ddf
callq 0x4360
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
jne 0x8e04
jmp 0x8e0e
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x8e0e
callq 0x4360
jmp 0x8e0e
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8e20
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaa37(%rip), %rsi      # 0x1387d
movl $0x2f, %edx
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
leaq 0x15(%rbp), %r15
movl $0xa, -0x5(%r15)
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x56fa
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fc0
leaq 0x10(%rbp), %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ebe
callq 0x4360
movl 0x298(%rbx), %edx
movl 0x29c(%rbx), %edi
movq %r14, %rsi
movq %r15, %rcx
movl $0x14, %r8d
callq 0x1142c
movq %rbx, %rdi
callq 0x9932
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8f03
callq 0x4360
movq %rbx, %rdi
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa639(%rip), %rsi      # 0x1385d
movl $0x13, %edx
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
cmpl $0x0, 0x294(%rbx)
je 0x9301
leaq 0x230(%rbx), %r14
movq %r14, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x9366
movq 0x258(%rbx), %rsi
cmpq %rsi, 0x260(%rbx)
je 0x933e
movq %r14, -0x30(%rbp)
leaq 0x270(%rbx), %r15
xorl %r12d, %r12d
xorl %r14d, %r14d
xorl %r13d, %r13d
addq %r12, %rsi
movq %r15, %rdi
callq 0x4050
testl %eax, %eax
sete %al
orb %al, %r13b
incq %r14
movq 0x258(%rbx), %rsi
movq 0x260(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq $0x28, %r12
cmpq %r14, %rax
ja 0x92a1
movq -0x30(%rbp), %rdi
callq 0x42a0
testb $0x1, %r13b
je 0x9346
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa569(%rip), %rsi      # 0x13871
movl $0xb, %edx
movq %rbx, %rdi
callq 0x43f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
jmp 0x9350
movq %r14, %rdi
callq 0x42a0
movl $0x0, 0x294(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9932
movl %eax, %edi
callq 0x4240
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x4270
leaq 0x230(%r14), %rdi
movq %rdi, -0x30(%rbp)
callq 0x44d0
testl %eax, %eax
jne 0x951c
movq 0x260(%r14), %rax
cmpq 0x258(%r14), %rax
je 0x94cc
xorl %r12d, %r12d
leaq 0x9f57(%rip), %r15      # 0x13322
xorl %r13d, %r13d
movl $0x7, %edx
leaq -0x1b0(%rbp), %rdi
leaq 0xa569(%rip), %rsi      # 0x1394a
callq 0x43f0
leaq -0x1b0(%rbp), %rdi
movl %r13d, %esi
callq 0x45f0
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
leaq 0xa54b(%rip), %rsi      # 0x13952
callq 0x43f0
movq 0x258(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x43f0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x43f0
movq 0x258(%r14), %rax
movl 0x20(%rax,%r12), %esi
movq %rbx, %rdi
callq 0x45f0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x43f0
movq 0x258(%r14), %rax
movl 0x24(%rax,%r12), %esi
movq %rbx, %rdi
callq 0x45f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
incq %r13
movq 0x260(%r14), %rax
subq 0x258(%r14), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq $0x28, %r12
cmpq %r13, %rax
ja 0x93ce
movq -0x30(%rbp), %rdi
callq 0x42a0
leaq -0x1a8(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4540
movq 0xfab1(%rip), %rsi      # 0x18fa0
leaq -0x1c0(%rbp), %rdi
callq 0x4290
leaq -0x140(%rbp), %rdi
callq 0x4160
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x4240
jmp 0x9525
movq %rax, %rbx
movq 0xfa71(%rip), %rsi      # 0x18fa0
leaq -0x1c0(%rbp), %rdi
callq 0x4290
leaq -0x140(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4630
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x2f8(%rdi), %rcx
movq 0x300(%rdi), %rdx
cmpq %rcx, %rdx
je 0x95b6
pushq %rbp
movq %rsp, %rbp
movl 0x2c8(%rdi), %esi
addq $-0x14, %rdx
xorl %eax, %eax
movzbl 0x4(%rdx), %r8d
movq %rdx, 0x300(%rdi)
cmpl %r8d, %esi
sete %r8b
orb %r8b, %al
leaq -0x14(%rdx), %r8
cmpq %rcx, %rdx
movq %r8, %rdx
jne 0x9591
popq %rbp
jmp 0x95b8
xorl %eax, %eax
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x230(%rdi), %rbx
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x9677
movq 0x258(%r15), %rdi
cmpq %rdi, 0x260(%r15)
je 0x965a
movq %rbx, -0x30(%rbp)
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
addq %r12, %rdi
movq %r14, %rsi
callq 0x4050
testl %eax, %eax
movzbl %r13b, %r13d
movl $0x1, %eax
cmovel %eax, %r13d
incq %rbx
movq 0x258(%r15), %rdi
movq 0x260(%r15), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq $0x28, %r12
cmpq %rbx, %rax
ja 0x9603
andb $0x1, %r13b
movzbl %r13b, %r14d
movq -0x30(%rbp), %rbx
jmp 0x965d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x42a0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x4240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x56fa
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
callq 0x10fc0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x970d
callq 0x4360
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x56fa
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x10fc0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x9745
callq 0x4360
xorl %r12d, %r12d
movzbl -0x2c(%rbp,%r12), %r14d
movzbl -0x30(%rbp,%r12), %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0xa073(%rip), %rsi      # 0x137e4
callq 0x43f0
movq %r13, %rdi
movq %r14, %rsi
callq 0x4250
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %r13, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
cmpb %r14b, %r15b
ja 0x97d4
cmpb %r15b, %r14b
ja 0x97eb
incq %r12
cmpq $0x4, %r12
jne 0x9748
leaq 0xa027(%rip), %rsi      # 0x137ec
movl $0x27, %edx
movq %rbx, %rdi
callq 0x43f0
jmp 0x981b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rbx
leaq 0x9ffb(%rip), %rsi      # 0x137e4
jmp 0x9800
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rbx
leaq 0x9fe8(%rip), %rsi      # 0x137e8
movl $0x3, %edx
movq %rax, %rdi
callq 0x43f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4250
movq %rax, %rbx
cmpb %r14b, %r15b
seta %r14b
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4260
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x9875
jmp 0x987a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x987a
callq 0x4360
movq %rbx, %rdi
callq 0x4630
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x230(%rsi), %r14
movq %r14, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x992b
addq $0x258, %r15            # imm = 0x258
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa492
movq %r14, %rdi
callq 0x42a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x4240
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x230(%rdi), %rbx
movq %rbx, %rdi
callq 0x44d0
testl %eax, %eax
jne 0x9ddb
movq 0x258(%r12), %rdi
cmpq %rdi, 0x260(%r12)
je 0x9dbe
movq %rbx, -0x38(%rbp)
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %r14d, %r14d
addq %r13, %rdi
movq %r15, %rsi
callq 0x4050
movq 0x258(%r12), %rdi
testl %eax, %eax
jne 0x9d87
movl -0x2c(%rbp), %eax
cmpl %eax, 0x20(%rdi,%r13)
movzbl %r14b, %r14d
movl $0x1, %eax
cmovel %eax, %r14d
incq %rbx
movq 0x260(%r12), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq $0x28, %r13
cmpq %rbx, %rax
ja 0x9d5b
andb $0x1, %r14b
movzbl %r14b, %r14d
movq -0x38(%rbp), %rbx
jmp 0x9dc1
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x42a0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x4240
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movl $0xd, (%rdi)
movq 0x300(%rsi), %rcx
cmpq 0x2f8(%rsi), %rcx
je 0x9e30
pushq %rbp
movq %rsp, %rbp
leaq -0x14(%rcx), %rdx
movl -0x4(%rcx), %edi
movl %edi, 0x10(%rax)
movups -0x14(%rcx), %xmm0
movups %xmm0, (%rax)
movq %rdx, 0x300(%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x3b(%rbp), %r15
movl $0x5, -0x5(%r15)
movb $0x0, -0x1(%r15)
leaq -0x50(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x56fa
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fc0
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x9e91
callq 0x4360
movl 0x20(%r14), %eax
movl %eax, -0x34(%rbp)
movb $0x4, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7c7e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x9ed5
callq 0x4360
movq %rbx, %rdi
callq 0x4630
nop