LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::transpose()
Sudoku transpose(void) {
    bit2array();
    unsigned char data2[81];
    for (int i = 0; i < 9; i++) {
      for (int j = 0; j < 9; j++) {
        data2[j + i * 9] = data[i + j * 9];
      }
    }
    return Sudoku(data2);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2e42
movq %rsp, %rax
xorl %ecx, %ecx
movq $-0x9, %rdx
movq %r14, %rsi
movb (%rsi), %dil
movb %dil, 0x9(%rax,%rdx)
addq $0x9, %rsi
incq %rdx
jne 0x31ce
incq %rcx
addq $0x9, %rax
incq %r14
cmpq $0x9, %rcx
jne 0x31c4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x393c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: MinlexSearcher::perm_cbox(Sudoku&, int)
void perm_cbox(Sudoku &g, int hb_min) {
    for (auto a : perm3) {
      Sudoku g2 = g.perm_cbox(a);
      if (g2.headbox_index(false) > hb_min) continue;
      perm_toprbox(g2, hb_min);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x3f07(%rip), %rbp      # 0x7130
movq %rsp, %r12
leaq (%rbp,%r13), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x39bc
movq %r12, %rdi
xorl %esi, %esi
callq 0x3044
cmpl %ebx, %eax
jg 0x3257
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x3afc
addq $0xc, %r13
cmpq $0x48, %r13
jne 0x322c
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::str[abi:cxx11]()
std::string str(void) {
    bit2array();
    std::stringstream ss;
    for (int i = 0; i < 81; i++) {
      ss << (int)(data[i]);
    }
    return ss.str();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2e42
movq %rsp, %rdi
callq 0x2090
leaq 0x10(%rsp), %r15
xorl %r12d, %r12d
movzbl (%r14,%r12), %esi
movq %r15, %rdi
callq 0x2180
incq %r12
cmpq $0x51, %r12
jne 0x32a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2160
movq 0x3cf6(%rip), %rsi      # 0x6fc0
movq %rsp, %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x32f3
movq %rax, %rbx
movq 0x3cc3(%rip), %rsi      # 0x6fc0
movq %rsp, %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::perm_cbox(int*)
Sudoku perm_cbox(int a[3]) {
    mbit bdata2[9];
    mbit t2 = 0;
    for (int i = 0; i < 9; i++) {
      t2 |= (mbit(7) << (i * 9));
    }
    mbit t1 = t2 << 3;
    mbit t0 = t2 << 6;
    mbit v[3];
    for (int i = 0; i < 9; i++) {
      v[0] = (bdata[i] & t0) >> 6;
      v[1] = (bdata[i] & t1) >> 3;
      v[2] = (bdata[i] & t2);
      bdata2[i] = v[a[0]] << 6;
      bdata2[i] |= v[a[1]] << 3;
      bdata2[i] |= v[a[2]];
    }
    return Sudoku(bdata2);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rax
movl $0x703, %ecx            # imm = 0x703
movabsq $-0x7e3f1f8fc7e3f1f9, %rdi # imm = 0x81C0E070381C0E07
movslq (%rdx), %r8
shlq $0x4, %r8
leaq -0x80(%rsp,%r8), %r8
movslq 0x4(%rdx), %r9
shlq $0x4, %r9
leaq -0x80(%rsp,%r9), %r9
movslq 0x8(%rdx), %rdx
shlq $0x4, %rdx
leaq -0x80(%rsp,%rdx), %rdx
xorl %r10d, %r10d
movq 0x60(%rsi,%r10), %r11
movq 0x68(%rsi,%r10), %rbx
movq %rbx, %r14
shldq $0x3a, %r11, %r14
movl %ebx, %r15d
shrl $0x6, %r15d
andl %ecx, %r15d
andq %rdi, %r14
movq %r14, -0x80(%rsp)
movq %r15, -0x78(%rsp)
movq %rbx, %r14
shldq $0x3d, %r11, %r14
movl %ebx, %r15d
shrl $0x3, %r15d
andl %ecx, %r15d
andq %rdi, %r14
movq %r14, -0x70(%rsp)
movq %r15, -0x68(%rsp)
andl %ecx, %ebx
andq %rdi, %r11
movq %r11, -0x60(%rsp)
movq %rbx, -0x58(%rsp)
movq (%r8), %r11
movq 0x8(%r8), %rbx
shldq $0x6, %r11, %rbx
shlq $0x6, %r11
movq %r11, -0x50(%rsp,%r10)
movq (%r9), %r14
movq 0x8(%r9), %r15
shldq $0x3, %r14, %r15
movq %rbx, -0x48(%rsp,%r10)
shlq $0x3, %r14
orq %rbx, %r15
orq %r11, %r14
movq %r15, -0x48(%rsp,%r10)
movq %r14, -0x50(%rsp,%r10)
orq 0x8(%rdx), %r15
orq (%rdx), %r14
movq %r14, -0x50(%rsp,%r10)
movq %r15, -0x48(%rsp,%r10)
addq $0x10, %r10
cmpq $0x90, %r10
jne 0x3a00
vmovups -0x50(%rsp), %zmm0
vmovups -0x10(%rsp), %zmm1
vmovups (%rsp), %zmm2
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: MinlexSearcher::perm_toprbox(Sudoku&, int)
void perm_toprbox(Sudoku &g, int hb_min) {
    for (auto a : perm3) {
      Sudoku g2 = g.perm_toprbox(a);
      if (g2.headline_index() > hb_min) continue;
      perm_columns(g2);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x3611(%rip), %rbp      # 0x7130
movq %rsp, %r12
leaq (%rbp,%r13), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3b66
movq %r12, %rdi
callq 0x3ca6
cmpl %ebx, %eax
jg 0x3b49
movq %r15, %rdi
movq %r12, %rsi
callq 0x3dbc
addq $0xc, %r13
cmpq $0x48, %r13
jne 0x3b22
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::perm_toprbox(int*)
Sudoku perm_toprbox(int a[3]) {
    mbit bdata2[9];
    mbit mask = ((mbit(1) << 54) - 1);
    mbit t0 = ((mbit(1) << 9) - 1) << 72;
    mbit t1 = ((mbit(1) << 9) - 1) << 63;
    mbit t2 = ((mbit(1) << 9) - 1) << 54;
    mbit v[3];
    for (int i = 0; i < 9; i++) {
      v[0] = (bdata[i] & t0) >> 18;
      v[1] = (bdata[i] & t1) >> 9;
      v[2] = (bdata[i] & t2) >> 0;
      bdata2[i] = bdata[i] & mask;
      bdata2[i] |= v[a[0]] << 18;
      bdata2[i] |= v[a[1]] << 9;
      bdata2[i] |= v[a[2]] << 0;
    }
    return Sudoku(bdata2);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rax
movslq (%rdx), %rcx
shlq $0x4, %rcx
leaq -0x80(%rsp,%rcx), %rcx
movslq 0x4(%rdx), %rdi
shlq $0x4, %rdi
leaq -0x80(%rsp,%rdi), %rdi
movslq 0x8(%rdx), %rdx
shlq $0x4, %rdx
leaq -0x80(%rsp,%rdx), %rdx
xorl %r8d, %r8d
movabsq $0x7fc0000000000000, %r9 # imm = 0x7FC0000000000000
movb $0x36, %r10b
xorl %r11d, %r11d
movq 0x60(%rsi,%r11), %rbx
movq 0x68(%rsi,%r11), %r14
movl %r14d, %r15d
andl $0x1ff00, %r15d         # imm = 0x1FF00
shlq $0x2e, %r15
movq %r8, -0x78(%rsp)
movq %r15, -0x80(%rsp)
shldq $0x37, %rbx, %r14
andq %r9, %r14
movq %r8, -0x68(%rsp)
movq %r14, -0x70(%rsp)
bzhiq %r10, %rbx, %r14
andq %r9, %rbx
movq %r8, -0x58(%rsp)
movq %rbx, -0x60(%rsp)
movq 0x8(%rcx), %rbx
movq (%rcx), %r15
shldq $0x12, %r15, %rbx
movq %r8, -0x48(%rsp,%r11)
movq %r14, -0x50(%rsp,%r11)
shlq $0x12, %r15
orq %r14, %r15
movq %rbx, -0x48(%rsp,%r11)
movq 0x8(%rdi), %r14
movq (%rdi), %r12
shldq $0x9, %r12, %r14
movq %r15, -0x50(%rsp,%r11)
shlq $0x9, %r12
orq %r15, %r12
orq %rbx, %r14
movq %r14, -0x48(%rsp,%r11)
movq %r12, -0x50(%rsp,%r11)
orq 0x8(%rdx), %r14
orq (%rdx), %r12
movq %r12, -0x50(%rsp,%r11)
movq %r14, -0x48(%rsp,%r11)
addq $0x10, %r11
cmpq $0x90, %r11
jne 0x3bad
vmovups -0x50(%rsp), %zmm0
vmovups -0x10(%rsp), %zmm1
vmovups (%rsp), %zmm2
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::headline_index()
int headline_index(void) {
    mbit v = 0;
    for (int i = 0; i < 9; i++) {
      v |= bdata[i];
    }
    std::vector<int> a(3, 0);
    for (int j = 0; j < 3; j++) {
      for (int k = 0; k < 3; k++) {
        if (v & (mbit(1) << (80 - k - j * 3))) a[j]++;
      }
    }
    std::sort(a.begin(), a.end());
    int index = 0;
    for (int i = 0; i < 3; i++) {
      int t = ((1 << a[i]) - 1) << (2 - i) * 3;
      index += t;
    }
    return index;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x60, %eax
xorl %r15d, %r15d
xorl %r12d, %r12d
orq (%rdi,%rax), %r15
orq 0x8(%rdi,%rax), %r12
addq $0x10, %rax
cmpq $0xf0, %rax
jne 0x3cb9
movl $0xc, %edi
callq 0x2110
movq %rax, %r14
movq %rax, %rbx
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x50, %eax
xorl %edx, %edx
movl $0x1, %esi
xorl %edi, %edi
leal (%rax,%rdi), %ecx
xorl %r8d, %r8d
shldq %cl, %rsi, %r8
shlxq %rcx, %rsi, %r9
testb $0x40, %cl
cmovneq %r9, %r8
movl $0x0, %ecx
cmoveq %r9, %rcx
andq %r12, %r8
andq %r15, %rcx
orq %r8, %rcx
je 0x3d27
incl (%rbx,%rdx,4)
decl %edi
cmpl $-0x3, %edi
jne 0x3cfa
incq %rdx
addl $-0x3, %eax
cmpq $0x3, %rdx
jne 0x3cf8
addq $0xc, %r14
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36da
movb $0x7, %al
kmovd %eax, %k1
vmovdqu32 (%rbx), %xmm0 {%k1} {z}
vpcmpeqd %xmm1, %xmm1, %xmm1
vpsllvd %xmm0, %xmm1, %xmm0
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpsllvd 0x12a2(%rip), %xmm0, %xmm0 # 0x5020
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x8, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2],xmm1[3]
vphaddd %xmm0, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vmovd %xmm0, %ebp
movq %rbx, %rdi
callq 0x20f0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::headline_bits(int&, int&, int&)
void headline_bits(int &h1, int &h2, int &h3) {
    mbit v = 0;
    for (int i = 0; i < 9; i++) {
      v |= bdata[i];
    }
    h1 = 0;
    h2 = 0;
    h3 = 0;
    for (int i = 0; i < 3; i++) {
      if (v & (mbit(1) << (80 - i))) h1 += (1 << (2 - i));
      if (v & (mbit(1) << (77 - i))) h2 += (1 << (2 - i));
      if (v & (mbit(1) << (74 - i))) h3 += (1 << (2 - i));
    }
  }

// Assembly:
movq %rcx, %rax
movl $0x60, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
orq (%rdi,%rcx), %r8
orq 0x8(%rdi,%rcx), %r9
addq $0x10, %rcx
cmpq $0xf0, %rcx
jne 0x408a
pushq %r15
pushq %r14
pushq %rbx
xorl %r10d, %r10d
movl %r10d, (%rsi)
movl %r10d, (%rdx)
movl %r10d, (%rax)
movl $0x4a, %edi
movl $0x1, %r11d
movl $0x1, %ebx
leal 0x6(%rdi), %ecx
xorl %r14d, %r14d
shldq %cl, %r11, %r14
shlxq %rcx, %r11, %r15
testb $0x40, %cl
cmovneq %r15, %r14
movl $0x0, %ecx
cmoveq %r15, %rcx
andq %r9, %r14
andq %r8, %rcx
orq %r14, %rcx
je 0x40f5
leal -0x48(%rdi), %ecx
shlxl %ecx, %ebx, %ecx
addl %ecx, (%rsi)
leal 0x3(%rdi), %ecx
xorl %r14d, %r14d
shldq %cl, %r11, %r14
shlxq %rcx, %r11, %r15
testb $0x40, %cl
cmovneq %r15, %r14
movl $0x0, %ecx
cmoveq %r15, %rcx
andq %r9, %r14
andq %r8, %rcx
orq %r14, %rcx
je 0x4129
leal -0x48(%rdi), %ecx
shlxl %ecx, %ebx, %ecx
addl %ecx, (%rdx)
xorl %r14d, %r14d
movl %edi, %ecx
shldq %cl, %r11, %r14
shlxq %rdi, %r11, %rcx
testb $0x40, %dil
cmovneq %rcx, %r14
cmovneq %r10, %rcx
andq %r9, %r14
andq %r8, %rcx
orq %r14, %rcx
je 0x4158
leal -0x48(%rdi), %ecx
shlxl %ecx, %ebx, %ecx
addl %ecx, (%rax)
decl %edi
cmpl $0x47, %edi
jne 0x40c1
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::operator<(Sudoku const&) const
bool operator<(const Sudoku &rhs) const {
    mbit vmax = 0;
    bool less = false;
    for (int i = 0; i < 9; i++) {
      mbit v = bdata[i] ^ rhs.bdata[i];
      v = left_most_bit(v);
      if (v >= vmax) {
        vmax = v;
        less = (bdata[i] < rhs.bdata[i]);
      }
    }
    return less;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x60, %ecx
xorl %edx, %edx
movl $0x1, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq (%rdi,%rcx), %r11
movq 0x8(%rdi,%rcx), %r10
movq (%rsi,%rcx), %r14
movq 0x8(%rsi,%rcx), %rbx
movq %rbx, %r15
xorq %r10, %r15
je 0x443d
lzcntq %r15, %r15
notb %r15b
shlxq %r15, %r8, %r12
xorl %r15d, %r15d
jmp 0x445a
movq %r14, %r15
xorq %r11, %r15
je 0x4454
lzcntq %r15, %r15
notb %r15b
shlxq %r15, %r8, %r15
jmp 0x4457
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r14, %r11
sbbq %rbx, %r10
setb %r10b
cmpq %rdx, %r15
movq %r12, %r11
sbbq %r9, %r11
movzbl %r10b, %r10d
movzbl %al, %eax
cmovael %r10d, %eax
cmpq %r15, %rdx
movq %r9, %r10
sbbq %r12, %r10
cmovbq %r12, %r9
cmovbq %r15, %rdx
addq $0x10, %rcx
cmpq $0xf0, %rcx
jne 0x4411
andb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/kaityo256[P]minlex/minlex.cpp
// Function: MinlexSearcher::perm_restrbox(Sudoku&)
void perm_restrbox(Sudoku &g) {
    for (auto ai : perm3) {
      Sudoku g1 = g.perm_restrbox2(ai, 0);
      for (auto aj : perm3) {
        Sudoku g2 = g1.perm_restrbox2(aj, 1).renumbering();
        // Sudoku g2 = g.perm_restrbox(ai,aj).renumbering();
        if (g2 < min) {
          min = g2;
        }
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x378, %rsp            # imm = 0x378
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x1f0(%rsp), %rbx
leaq 0x100(%rsp), %r12
xorl %eax, %eax
leaq 0x280(%rsp), %r15
leaq 0xa0(%rsp), %rbp
movq %rax, 0x8(%rsp)
leaq 0x2c46(%rip), %rcx      # 0x7130
leaq (%rcx,%rax), %rdx
movq %r15, %rdi
movq (%rsp), %rsi
xorl %ecx, %ecx
vzeroupper
callq 0x4638
xorl %r13d, %r13d
leaq 0x2c27(%rip), %rax      # 0x7130
leaq (%rax,%r13), %rdx
leaq 0x190(%rsp), %rdi
movq %r15, %rsi
movl $0x1, %ecx
vzeroupper
callq 0x4638
vmovups (%rbx), %zmm0
vmovups 0x40(%rbx), %zmm1
vmovups 0x50(%rbx), %zmm2
vmovups %zmm2, 0x60(%rsp)
vmovups %zmm1, 0x50(%rsp)
vmovups %zmm0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
vzeroupper
callq 0x233c
vmovups 0x10(%rsp), %zmm0
vmovups 0x50(%rsp), %zmm1
vmovups 0x60(%rsp), %zmm2
vmovups %zmm2, 0x50(%r12)
vmovups %zmm1, 0x40(%r12)
vmovups %zmm0, (%r12)
movq %rbp, %rdi
movq %r14, %rsi
vzeroupper
callq 0x43f8
testb %al, %al
je 0x4601
vmovups 0xa0(%rsp), %zmm0
vmovups 0xe0(%rsp), %zmm1
vmovups 0x120(%rsp), %zmm2
vmovups 0x150(%rsp), %zmm3
vmovups %zmm3, 0xb0(%r14)
vmovups %zmm2, 0x80(%r14)
vmovups %zmm1, 0x40(%r14)
vmovups %zmm0, (%r14)
addq $0xc, %r13
cmpq $0x48, %r13
jne 0x4502
movq 0x8(%rsp), %rax
addq $0xc, %rax
cmpq $0x48, %rax
jne 0x44de
addq $0x378, %rsp            # imm = 0x378
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::MP1Node(Member*, Params*, EmulNet*, Log*, Address*)
MP1Node::MP1Node(Member *member, Params *params, EmulNet *emul, Log *log,
                 Address *address) {
    for (int i = 0; i < 6; i++) {
        NULLADDR[i] = 0;
    }
    this->memberNode = member;
    this->emulNet = emul;
    this->log = log;
    this->par = params;
    this->memberNode->addr = *address;
    this->posInMemberList = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x96b9(%rip), %rax      # 0xbca0
movq %rax, (%rdi)
movl $0x0, 0x38(%rdi)
movw $0x0, 0x3c(%rdi)
movq %rsi, 0x20(%rdi)
movq %rcx, 0x8(%rdi)
movq %r8, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
leaq 0x8(%rsi), %rdi
movq %r9, %rsi
callq 0x55fa
movq $0x0, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::recvLoop()
int MP1Node::recvLoop() {
    if (memberNode->bFailed) {
        return false;
    } else {
        return emulNet->ENrecv(&(memberNode->addr), enqueueWrapper, NULL, 1,
                               &(memberNode->mp1q));
    }
}

// Assembly:
movq 0x20(%rdi), %r9
cmpb $0x0, 0x10(%r9)
je 0x2638
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
leaq 0x8(%r9), %rsi
addq $0x48, %r9
leaq 0xd(%rip), %rdx         # 0x2658
xorl %ecx, %ecx
movl $0x1, %r8d
jmp 0x3ff8
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::initThisNode(Address*)
int MP1Node::initThisNode(Address *joinaddr) {
    memberNode->bFailed = false;
    memberNode->inited = true;
    memberNode->inGroup = false;
    // node is up!
    memberNode->pingCounter = TFAIL;
    memberNode->timeOutCounter = TREMOVE;
    initMemberListTable(memberNode);
    return 0;
}

// Assembly:
movq 0x20(%rdi), %rax
movb $0x0, 0x10(%rax)
movw $0x1, 0xe(%rax)
movabsq $0x1400000004, %rcx     # imm = 0x1400000004
movq %rcx, 0x20(%rax)
movq 0x28(%rax), %rcx
cmpq %rcx, 0x30(%rax)
je 0x2722
movq %rcx, 0x30(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::introduceSelfToGroup(Address*)
int MP1Node::introduceSelfToGroup(Address *joinaddr) {
    if (0 == memcmp((char *)&(memberNode->addr.addr), (char *)&(joinaddr->addr),
                    sizeof(memberNode->addr.addr))) {
        // I am the group booter (first process to join the group). Boot up the
        // group

#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, "Starting up group...");
#endif
        memberNode->inGroup = true;
    } else {
        // create JOINREQ message: format of data is {struct Address myaddr}
        MessageHdr *msg;
        size_t msgsize = sizeof(MessageHdr);
        msg = new MessageHdr;
        msg->msgType = JOINREQ;
        msg->srcAddr = memberNode->addr;

#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, "Trying to join...");
#endif

        // send JOINREQ message to introducer member
        emulNet->ENsend(&memberNode->addr, joinaddr, (char *)msg, msgsize);

        free(msg);
    }

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
leaq 0x8(%rax), %r12
movl 0x8(%rax), %ecx
xorl (%rsi), %ecx
movzwl 0xc(%rax), %eax
xorw 0x4(%rsi), %ax
movzwl %ax, %eax
orl %ecx, %eax
je 0x27bf
movq %rsi, %r14
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, (%rax)
leaq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0x55fa
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x58c4(%rip), %rdx      # 0x8055
xorl %eax, %eax
callq 0x5090
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3de4
movq %r15, %rdi
callq 0x2200
jmp 0x27dc
movq 0x10(%rbx), %rdi
leaq 0x5876(%rip), %rdx      # 0x8040
movq %r12, %rsi
xorl %eax, %eax
callq 0x5090
movq 0x20(%rbx), %rax
movb $0x1, 0xf(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::checkMessages()
void MP1Node::checkMessages() {
    void *ptr;
    int size;

    // Pop waiting messages from memberNode's mp1q
    while (!memberNode->mp1q.empty()) {
        ptr = memberNode->mp1q.front().elt;
        size = memberNode->mp1q.front().size;
        memberNode->mp1q.pop();
        recvCallBack((Member *)memberNode, (MessageHdr *)ptr, size);
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq 0x58(%rdi), %rax
cmpq %rax, 0x78(%rdi)
je 0x2869
addq $0x48, %rdi
movq (%rax), %r14
movl 0x8(%rax), %ebp
callq 0x3802
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x29d8
movq 0x20(%rbx), %rdi
jmp 0x283d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::nodeLoopOps()
void MP1Node::nodeLoopOps() {
    if (memberNode->memberList.empty()) {
        return;
    }

    if (memberNode->timeOutCounter == 0) {
        memberNode->timeOutCounter = TREMOVE;

        if (!finishedPING) {
            // remove the failed node and send out information
            if (!deleteNode(&pingTarget)) {
                exit(1);
            }
            if (!sendFailedNode()) {
                exit(1);
            }
        }
    }

    if (posInMemberList == memberNode->memberList.size()) {
        // random time seed to boost performance
        srand(time(NULL));
        random_shuffle(memberNode->memberList.begin(),
                       memberNode->memberList.end());
        posInMemberList = 0;
    }

    if (memberNode->timeOutCounter == TREMOVE) {
        if (!startPing()) {
            exit(1);
        }
    }

    if (memberNode->timeOutCounter < TREMOVE && !finishedPING &&
        memberNode->pingCounter == 0) {
        if (!startPingREQ()) {
            exit(1);
        }
    }

    memberNode->pingCounter--;
    memberNode->timeOutCounter--;
    return;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq 0x30(%rax), %rcx
je 0x29d7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x24(%rax)
jne 0x28b8
movl $0x14, 0x24(%rax)
cmpb $0x0, 0x28(%rbx)
jne 0x28b8
leaq 0x29(%rbx), %rsi
movq %rbx, %rdi
callq 0x30ea
movq %rbx, %rdi
callq 0x3186
movq 0x20(%rbx), %rax
movq 0x30(%rax), %rcx
subq 0x28(%rax), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq %rcx, 0x30(%rbx)
jne 0x298f
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq %rbx, 0x8(%rsp)
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rbp
movq 0x30(%rax), %r13
cmpq %r13, %rbp
je 0x2982
leaq 0x18(%rbp), %rax
cmpq %r13, %rax
je 0x2982
movl $0x18, %r14d
callq 0x2050
cltq
movq %r14, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
incq %rcx
cqto
idivq %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r15
cmpq %r15, %r14
je 0x2971
leaq (%r14,%rbp), %r12
addq %rbp, %r15
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5638
movq %r12, %rdi
movq %r15, %rsi
callq 0x5656
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5656
leaq (%r14,%rbp), %rax
addq $0x18, %rax
addq $0x18, %r14
cmpq %r13, %rax
jne 0x2913
movq 0x8(%rsp), %rbx
movq $0x0, 0x30(%rbx)
movq 0x20(%rbx), %rax
cmpl $0x14, 0x24(%rax)
jne 0x29a1
movq %rbx, %rdi
callq 0x326c
movq 0x20(%rbx), %rax
cmpl $0x13, 0x24(%rax)
jg 0x29bf
cmpb $0x0, 0x28(%rbx)
jne 0x29bf
cmpl $0x0, 0x20(%rax)
jne 0x29bf
movq %rbx, %rdi
callq 0x334c
movq 0x20(%rbx), %rax
decl 0x20(%rax)
decl 0x24(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::recvCallBack(Member*, MessageHdr*, int)
bool MP1Node::recvCallBack(Member *memberNode, MessageHdr *msg, int size) {
    switch (msg->msgType) {
        case JOINREQ:
            return handleJoinReq(msg, size);
        case JOINREP:
            return handleJoinReply(msg, size);
        case PING:
            return handlePing(msg, size);
        case ACK:
            return handleAck(msg, size);
        case PINGREQ:
            return handlePingReq(msg, size);
        case DELETE:
            return handleDelete(msg, size);
        default:
            break;
    }
    return false;
}

// Assembly:
movl (%rdx), %eax
cmpq $0x5, %rax
ja 0x2a28
leaq 0x561d(%rip), %rsi      # 0x8004
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
movq %rdx, %rsi
jmp 0x2a2c
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2fb8
movq %rdx, %rsi
jmp 0x309a
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2df8
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2b92
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2ed6
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::handlePing(MessageHdr*, int)
bool MP1Node::handlePing(MessageHdr *msg, int size) {
    if (isNullAddress(&msg->srcAddr) && isNullAddress(&msg->endAddr)) {
        return false;
    }

    Address end = msg->endAddr;
    Address dstAddr = msg->srcAddr;

    // create and send the ACK message
    msg = new MessageHdr;
    msg->msgType = ACK;
    msg->srcAddr = memberNode->addr;
    msg->endAddr = end;
    emulNet->ENsend(&memberNode->addr, &dstAddr, (char *)msg, size);

    free(msg);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movl 0x20(%rsi), %eax
xorl 0x38(%rdi), %eax
movzwl 0x24(%rsi), %ecx
xorw 0x3c(%rdi), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0x2e3a
movl 0x26(%rsi), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%rsi), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x2ed1
leaq 0x20(%rsi), %r12
addq $0x26, %rsi
leaq 0xa(%rsp), %r13
movq %r13, %rdi
callq 0x55ec
leaq 0x4(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x55ec
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x5, (%rax)
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x55fa
leaq 0x26(%r12), %rdi
movq %r13, %rsi
callq 0x55fa
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebx, %r8d
callq 0x3de4
movq %r12, %rdi
callq 0x2200
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x2ec3
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::handleAck(MessageHdr*, int)
bool MP1Node::handleAck(MessageHdr *msg, int size) {
    if (isNullAddress(&msg->srcAddr) && isNullAddress(&msg->endAddr)) {
        return false;
    }

    if (0 == memcmp((char *)&(memberNode->addr.addr),
                    (char *)&(msg->endAddr.addr),
                    sizeof(memberNode->addr.addr))) {
        finishedPING = true;
    } else {
        // forward the message to the destination node
        Address end = msg->endAddr;
        msg = new MessageHdr;
        msg->msgType = ACK;
        msg->srcAddr = memberNode->addr;
        msg->endAddr = end;
        emulNet->ENsend(&memberNode->addr, &end, (char *)msg, size);
        free(msg);
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl 0x20(%rsi), %eax
xorl 0x38(%rdi), %eax
movzwl 0x24(%rsi), %ecx
xorw 0x3c(%rdi), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0x2f13
movl 0x26(%rsi), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%rsi), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x2fb4
movq 0x20(%r14), %rax
movl 0x8(%rax), %ecx
xorl 0x26(%rsi), %ecx
movzwl 0xc(%rax), %eax
xorw 0x2a(%rsi), %ax
movzwl %ax, %eax
orl %ecx, %eax
je 0x2fa1
addq $0x26, %rsi
leaq 0x2(%rsp), %r15
movq %r15, %rdi
callq 0x55ec
movl $0x30, %edi
callq 0x2190
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x5, (%rax)
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x55fa
leaq 0x26(%r12), %rdi
movq %r15, %rsi
callq 0x55fa
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebx, %r8d
callq 0x3de4
movq %r12, %rdi
callq 0x2200
jmp 0x2fa6
movb $0x1, 0x28(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x2fa8
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::handlePingReq(MessageHdr*, int)
bool MP1Node::handlePingReq(MessageHdr *msg, int size) {
    if (isNullAddress(&msg->srcAddr) && isNullAddress(&msg->endAddr)) {
        return false;
    }

    Address end = msg->srcAddr;
    Address dstAddr = msg->endAddr;

    // create and send the PING message
    msg = new MessageHdr;
    msg->msgType = PING;
    msg->srcAddr = memberNode->addr;
    msg->endAddr = end;
    emulNet->ENsend(&memberNode->addr, &dstAddr, (char *)msg, size);

    free(msg);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x20(%rsi), %eax
xorl 0x38(%rdi), %eax
movzwl 0x24(%rsi), %ecx
xorw 0x3c(%rdi), %cx
movzwl %cx, %ecx
orl %eax, %ecx
jne 0x2fff
movl 0x26(%r15), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%r15), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x3095
leaq 0x20(%r15), %rsi
leaq 0xa(%rsp), %r13
movq %r13, %rdi
callq 0x55ec
addq $0x26, %r15
leaq 0x4(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x55ec
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x3, (%rax)
movq 0x20(%r14), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x55fa
leaq 0x26(%r15), %rdi
movq %r13, %rsi
callq 0x55fa
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %ebx, %r8d
callq 0x3de4
movq %r15, %rdi
callq 0x2200
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x3087
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::deleteNode(Address*)
bool MP1Node::deleteNode(Address *deleteNodeAddr) {
    for (size_t i = 0; i < memberNode->memberList.size(); i++) {
        if ((int)deleteNodeAddr->addr[0] == memberNode->memberList[i].getid()) {
            memberNode->memberList.erase(memberNode->memberList.begin() + i);
            log->logNodeRemove(&memberNode->addr, deleteNodeAddr);
            break;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rdi
cmpq %rdi, 0x30(%rax)
je 0x3175
movq %rsi, %rbx
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
movsbl (%rbx), %ebp
addq %r15, %rdi
callq 0x566e
cmpl %ebp, %eax
je 0x314d
incq %r13
movq 0x20(%r14), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r15
cmpq %rax, %r13
jb 0x3119
jmp 0x3175
movq 0x20(%r14), %rdi
addq 0x28(%rdi), %r15
addq $0x28, %rdi
movq %r15, %rsi
callq 0x3b70
movq 0x10(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdx
callq 0x5412
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::sendFailedNode()
bool MP1Node::sendFailedNode() {
    for (auto localEntry : memberNode->memberList) {
        // create the dst address
        Address dstAddr;
        dstAddr.init();
        dstAddr.addr[0] = (char)localEntry.getid();
        dstAddr.addr[4] = (char)localEntry.getport();
        // create DELETE message
        MessageHdr *msg = new MessageHdr;
        size_t msgsize = sizeof(MessageHdr);
        msg->msgType = DELETE;
        msg->srcAddr = memberNode->addr;
        msg->endAddr = pingTarget;
        emulNet->ENsend(&memberNode->addr, &dstAddr, (char *)msg, msgsize);
        free(msg);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rax
movq 0x28(%rax), %r14
movq 0x30(%rax), %r13
cmpq %r13, %r14
je 0x325a
movq %rdi, %rbx
leaq 0x29(%rdi), %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5638
movw $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0x566e
movb %al, 0x8(%rsp)
movq %r12, %rdi
callq 0x5672
movb %al, 0xc(%rsp)
movl $0x30, %edi
callq 0x2190
movq %rax, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x2, (%rax)
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x55fa
leaq 0x26(%rbp), %rdi
movq %r15, %rsi
callq 0x55fa
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdx
movq %rbp, %rcx
movl $0x30, %r8d
callq 0x3de4
movq %rbp, %rdi
callq 0x2200
addq $0x18, %r14
cmpq %r13, %r14
jne 0x31b5
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::startPing()
bool MP1Node::startPing() {
    // create pingTarget Address
    pingTarget.init();
    pingTarget.addr[0] = (char)memberNode->memberList[posInMemberList].getid();
    pingTarget.addr[4] =
        (char)memberNode->memberList[posInMemberList].getport();

    memberNode->pingCounter = TFAIL;
    finishedPING = false;
    // memberList and dst is not needed becasuse we just wanna an ACK from
    // the
    MessageHdr *msg = new MessageHdr;
    size_t msgsize = sizeof(MessageHdr);
    msg->msgType = PING;
    msg->srcAddr = memberNode->addr;
    msg->endAddr = memberNode->addr;
    emulNet->ENsend(&memberNode->addr, &pingTarget, (char *)msg, msgsize);
    free(msg);

    posInMemberList++;

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x29(%rdi), %r14
movw $0x0, 0x2d(%rdi)
movl $0x0, 0x29(%rdi)
movq 0x20(%rdi), %rax
movq 0x30(%rdi), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x566e
movb %al, 0x29(%rbx)
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x5672
movb %al, 0x2d(%rbx)
movq 0x20(%rbx), %r12
movl $0x4, 0x20(%r12)
movb $0x0, 0x28(%rbx)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x3, (%rax)
addq $0x8, %r12
leaq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0x55fa
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x26(%r15), %rdi
callq 0x55fa
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3de4
movq %r15, %rdi
callq 0x2200
incq 0x30(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/MP1Node.cpp
// Function: MP1Node::startPingREQ()
bool MP1Node::startPingREQ() {
    // create pingREQtarget Address
    Address pingREQtarget;
    pingREQtarget.init();
    pingREQtarget.addr[0] =
        (char)memberNode->memberList[posInMemberList].getid();
    pingREQtarget.addr[4] =
        (char)memberNode->memberList[posInMemberList].getport();

    MessageHdr *msg = new MessageHdr;
    size_t msgsize = sizeof(MessageHdr);
    msg->msgType = PING;
    msg->srcAddr = memberNode->addr;
    msg->endAddr = pingTarget;
    emulNet->ENsend(&memberNode->addr, &pingREQtarget, (char *)msg, msgsize);
    free(msg);

    memberNode->pingCounter = TFAIL;
    posInMemberList++;
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movw $0x0, 0x4(%r14)
movl $0x0, (%r14)
movq 0x20(%rdi), %rax
movq 0x30(%rdi), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x566e
movb %al, (%r14)
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x5672
movb %al, 0x4(%r14)
movl $0x30, %edi
callq 0x2190
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x3, (%rax)
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x55fa
leaq 0x29(%rbx), %rsi
leaq 0x26(%r15), %rdi
callq 0x55fa
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3de4
movq %r15, %rdi
callq 0x2200
movq 0x20(%rbx), %rax
movl $0x4, 0x20(%rax)
incq 0x30(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::EmulNet(Params*)
EmulNet::EmulNet(Params *p)
{
	//trace.funcEntry("EmulNet::EmulNet");
	int i,j;
	par = p;
	emulnet.setNextId(1);
	emulnet.settCurrBuffSize(0);
	enInited=0;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			sent_msgs[i][j] = 0;
			recv_msgs[i][j] = 0;
		}
	}
	//trace.funcExit("EmulNet::EmulNet", SUCCESS);
}

// Assembly:
leaq 0x80ed(%rip), %rax      # 0xbcd0
movq %rax, (%rdi)
leaq 0x8113(%rip), %rax      # 0xbd00
movq %rax, 0x1b7e498(%rdi)
movq %rsi, 0x8(%rdi)
movq $0x1, 0x1b7e4a0(%rdi)
movl $0x0, 0x1b7e490(%rdi)
addq $0xdbf250, %rdi         # imm = 0xDBF250
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movl %eax, -0xdbf240(%rdi,%rdx,4)
movl %eax, (%rdi,%rdx,4)
incq %rdx
cmpq $0xe10, %rdx            # imm = 0xE10
jne 0x3c1a
incq %rcx
addq $0x3840, %rdi           # imm = 0x3840
cmpq $0x3e8, %rcx            # imm = 0x3E8
jne 0x3c18
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::EmulNet(EmulNet&)
EmulNet::EmulNet(EmulNet &anotherEmulNet) {
	int i, j;
	this->par = anotherEmulNet.par;
	this->enInited = anotherEmulNet.enInited;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			this->sent_msgs[i][j] = anotherEmulNet.sent_msgs[i][j];
			this->recv_msgs[i][j] = anotherEmulNet.recv_msgs[i][j];
		}
	}
	this->emulnet = anotherEmulNet.emulnet;
}

// Assembly:
leaq 0x8085(%rip), %rax      # 0xbcd0
movq %rax, (%rdi)
leaq 0x80ab(%rip), %rax      # 0xbd00
movq %rax, 0x1b7e498(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x1b7e490(%rsi), %eax
movl %eax, 0x1b7e490(%rdi)
movl $0xdbf250, %eax         # imm = 0xDBF250
leaq (%rsi,%rax), %rcx
addq %rdi, %rax
xorl %edx, %edx
movl $0x3840, %r8d           # imm = 0x3840
xorl %r9d, %r9d
movl -0xdbf240(%rcx,%r9,4), %r10d
movl %r10d, -0xdbf240(%rax,%r9,4)
movl (%rcx,%r9,4), %r10d
movl %r10d, (%rax,%r9,4)
incq %r9
cmpq $0xe10, %r9             # imm = 0xE10
jne 0x3c87
incq %rdx
addq %r8, %rcx
addq %r8, %rax
cmpq $0x3e8, %rdx            # imm = 0x3E8
jne 0x3c84
movl 0x1b7e4a0(%rsi), %eax
movl %eax, 0x1b7e4a0(%rdi)
movslq 0x1b7e4a4(%rsi), %rax
movl %eax, 0x1b7e4a4(%rdi)
movl 0x1b7e4a8(%rsi), %ecx
movl %ecx, 0x1b7e4a8(%rdi)
testq %rax, %rax
jle 0x3d08
addq $0x36fc96, %rax         # imm = 0x36FC96
movq (%rsi,%rax,8), %rcx
movq %rcx, (%rdi,%rax,8)
leaq -0x1(%rax), %rcx
addq $-0x36fc96, %rax        # imm = 0xFFC9036A
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x3ced
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::operator=(EmulNet&)
EmulNet& EmulNet::operator =(EmulNet &anotherEmulNet) {
	int i, j;
	this->par = anotherEmulNet.par;
	this->enInited = anotherEmulNet.enInited;
	for ( i = 0; i < MAX_NODES; i++ ) {
		for ( j = 0; j < MAX_TIME; j++ ) {
			this->sent_msgs[i][j] = anotherEmulNet.sent_msgs[i][j];
			this->recv_msgs[i][j] = anotherEmulNet.recv_msgs[i][j];
		}
	}
	this->emulnet = anotherEmulNet.emulnet;
	return *this;
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movl 0x1b7e490(%rsi), %ecx
movl %ecx, 0x1b7e490(%rdi)
leaq 0x10(%rdi), %rcx
leaq 0xdbf250(%rsi), %rdx
xorl %edi, %edi
movl $0x3840, %r8d           # imm = 0x3840
xorl %r9d, %r9d
movl -0xdbf240(%rdx,%r9,4), %r10d
movl %r10d, (%rcx,%r9,4)
movl (%rdx,%r9,4), %r10d
movl %r10d, 0xdbf240(%rcx,%r9,4)
incq %r9
cmpq $0xe10, %r9             # imm = 0xE10
jne 0x3d37
incq %rdi
addq %r8, %rdx
addq %r8, %rcx
cmpq $0x3e8, %rdi            # imm = 0x3E8
jne 0x3d34
movl 0x1b7e4a0(%rsi), %ecx
movl %ecx, 0x1b7e4a0(%rax)
movslq 0x1b7e4a4(%rsi), %rcx
movl %ecx, 0x1b7e4a4(%rax)
movl 0x1b7e4a8(%rsi), %edx
movl %edx, 0x1b7e4a8(%rax)
testq %rcx, %rcx
jle 0x3dba
addq $0x36fc96, %rcx         # imm = 0x36FC96
movq (%rsi,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
leaq -0x1(%rcx), %rdx
addq $-0x36fc96, %rcx        # imm = 0xFFC9036A
cmpq $0x1, %rcx
movq %rdx, %rcx
jg 0x3d9e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::ENrecv(Address*, int (*)(void*, char*, int), timeval*, int, void*)
int EmulNet::ENrecv(Address *myaddr, int (* enq)(void *, char *, int), struct timeval *t, int times, void *queue){
	// times is always assumed to be 1
	int i;
	char* tmp;
	int sz;
	en_msg *emsg;

	for( i = emulnet.currbuffsize - 1; i >= 0; i-- ) {
		emsg = emulnet.buff[i];

		if ( 0 == strcmp(emsg->to.addr, myaddr->addr) ) {
			sz = emsg->size;
			tmp = (char *) malloc(sz * sizeof(char));
			memcpy(tmp, (char *)(emsg+1), sz);

			emulnet.buff[i] = emulnet.buff[emulnet.currbuffsize-1];
			emulnet.currbuffsize--;

			(*enq)(queue, (char *)tmp, sz);

			free(emsg);

			int dst = *(int *)(myaddr->addr);
			int time = par->getcurrtime();

			assert(dst <= MAX_NODES);
			assert(time < MAX_TIME);

			recv_msgs[dst][time]++;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movslq 0x1b7e4a4(%rdi), %r14
testq %r14, %r14
jle 0x40e5
movq %rsi, %r15
movq %rdi, %r12
leaq 0xdbf250(%rdi), %rax
movq %rax, (%rsp)
movq 0x1b7e4a8(%r12,%r14,8), %r13
leaq 0xa(%r13), %rdi
movq %r15, %rsi
callq 0x2240
testl %eax, %eax
jne 0x40d4
movl (%r13), %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x10(%r13), %rsi
movq %rax, %rdi
movq %rbp, %rdx
callq 0x2120
movslq 0x1b7e4a4(%r12), %rax
leal -0x1(%rax), %ecx
movq 0x1b7e4a8(%r12,%rax,8), %rax
movq %rax, 0x1b7e4a8(%r12,%r14,8)
movl %ecx, 0x1b7e4a4(%r12)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%rsp)
movq %r13, %rdi
callq 0x2200
movslq (%r15), %rbx
movq 0x8(%r12), %rdi
callq 0x55e0
cmpq $0x3e9, %rbx            # imm = 0x3E9
jge 0x4115
cmpl $0xe10, %eax            # imm = 0xE10
jge 0x40f6
cltq
imulq $0x3840, %rbx, %rcx     # imm = 0x3840
addq (%rsp), %rcx
incl (%rcx,%rax,4)
decq %r14
leaq 0x1(%r14), %rax
cmpq $0x1, %rax
jg 0x4031
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4027(%rip), %rdi      # 0x8124
leaq 0x3fdd(%rip), %rsi      # 0x80e1
leaq 0x4068(%rip), %rcx      # 0x8173
movl $0xaa, %edx
callq 0x20e0
leaq 0x4046(%rip), %rdi      # 0x8162
leaq 0x3fbe(%rip), %rsi      # 0x80e1
leaq 0x4049(%rip), %rcx      # 0x8173
movl $0xa9, %edx
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: handler(int)
void handler(int sig) {
	void *array[10];
	size_t size;

	// get void*'s for all entries on the stack
	size = backtrace(array, 10);

	// print out all the frames to stderr
	fprintf(stderr, "Error: signal %d:\n", sig);
	backtrace_symbols_fd(array, size, STDERR_FILENO);
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2270
movl %eax, %ebp
movq 0x7c99(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x3f03(%rip), %rsi      # 0x824c
movl %ebx, %edx
xorl %eax, %eax
callq 0x2250
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x22a0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: main
int main(int argc, char *argv[]) {
	//signal(SIGSEGV, handler);
	if ( argc != ARGS_COUNT ) {
		cout<<"Configuration (i.e., *.conf) file File Required"<<endl;
		return FAILURE;
	}

	// Create a new application object
	Application *app = new Application(argv[1]);
	// Call the run function
	app->run();
	// When done delete the application object
	delete(app);

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x43a5
movq %rsi, %r14
movl $0x48, %edi
callq 0x2190
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x448e
movq %rbx, %rdi
callq 0x440c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x43ec
movq 0x7c24(%rip), %rbx      # 0xbfd0
leaq 0x3eac(%rip), %rsi      # 0x825f
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::run()
int Application::run()
{
	int i;
	int timeWhenAllNodesHaveJoined = 0;
	// boolean indicating if all nodes have joined
	bool allNodesJoined = false;
	srand(time(NULL));

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

	// Clean up
	en->ENcleanup();

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

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x40(%rbx), %rax
movl $0x0, 0x28(%rax)
movq %rbx, %rdi
callq 0x471c
movq %rbx, %rdi
callq 0x4964
movq 0x40(%rbx), %rax
movl 0x28(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x28(%rax)
cmpl $0x2bb, %ecx            # imm = 0x2BB
jl 0x442c
movq 0x28(%rbx), %rdi
callq 0x4134
movq 0x40(%rbx), %rax
cmpl $0x0, 0x18(%rax)
jle 0x4484
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x27ee
incq %r14
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jl 0x4467
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
		delete mp1[i];
	}
	free(mp1);
	delete par;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x76a8(%rip), %rax      # 0xbd30
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x469a
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x46a9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rax
cmpl $0x0, 0x18(%rax)
jle 0x46d9
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x46c9
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jl 0x46b6
movq 0x38(%rbx), %rdi
callq 0x2200
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x46fc
movl $0x38, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq