LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]minlex/minlex.cpp
// Function: main
int main(int argc, char **argv) {
  init_bits();
  if (argc > 1) {
    input(argv[1]);
  } else {
    std::cout << "Usage: ./minlex inputfile" << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x8, %eax
movl $0x1, %edx
leaq 0x48fb(%rip), %r8       # 0x71a0
xorl %ecx, %ecx
shlxl %eax, %edx, %r9d
movq (%rcx,%r8), %r11
decl %eax
movq %r9, %r14
movq %r9, %r13
shlq $0x12, %r14
shlq $0x24, %r13
movq %r9, %rbp
shlq $0x36, %rbp
movq %r9, %r10
movq %r9, %r15
movq %r9, %r12
shlq $0x9, %r10
shlq $0x1b, %r15
shlq $0x2d, %r12
movl %r9d, %ebx
shrl $0x13, %ebx
orq %r14, %r13
orq %r10, %r15
movl %r9d, %r10d
shrl $0x1c, %r10d
orq 0x8(%rcx,%r8), %r10
movl %r9d, %r14d
shrl $0xa, %r14d
orq %r13, %rbp
movq %r9, %r13
shlq $0x3f, %r13
orq %r12, %r13
orq %r15, %r13
orq %r9, %r11
orq %rbp, %r13
orq %r11, %r13
movl %r9d, %r11d
shrl %r11d
shlq $0x8, %r9
orl %ebx, %r11d
orq %r14, %r9
vmovq %r13, %xmm1
orq %r11, %r9
orq %r10, %r9
vmovq %r9, %xmm0
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovdqa %xmm0, (%rcx,%r8)
addq $0x10, %rcx
cmpq $0x90, %rcx
jne 0x28a7
cmpl $0x2, %edi
jl 0x295f
movq 0x8(%rsi), %rdi
callq 0x26ee
jmp 0x29a1
movq 0x4672(%rip), %rbx      # 0x6fd8
leaq 0x275d(%rip), %rsi      # 0x50ca
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::Sudoku(char const*)
Sudoku(const char *str) {
    for (int i = 0; i < 81; i++) {
      data[i] = str[i] - '0';
      if (str[i] == '.') {
        data[i] = 0;
      }
    }
    array2bit();
  }

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
addb $-0x30, %dl
movb %dl, (%rdi,%rcx)
movzbl %dl, %edx
cmpb $0x2e, (%rsi,%rcx)
cmovel %eax, %edx
movb %dl, (%rdi,%rcx)
incq %rcx
cmpq $0x51, %rcx
jne 0x29b6
vxorps %xmm0, %xmm0, %xmm0
leaq 0x60(%rdi), %rax
movl $0x50, %ecx
movl $0x1, %esi
xorl %edx, %edx
vmovups %zmm0, 0xb0(%rdi)
vmovups %zmm0, 0xa0(%rdi)
vmovups %zmm0, 0x60(%rdi)
movzbl (%rdi), %r8d
testq %r8, %r8
je 0x2a37
xorl %r9d, %r9d
shldq %cl, %rsi, %r9
shlxq %rcx, %rsi, %r10
testb $0x40, %cl
cmovneq %r10, %r9
cmovneq %rdx, %r10
decl %r8d
shlq $0x4, %r8
orq %r10, (%rax,%r8)
orq %r9, 0x8(%rax,%r8)
incq %rdi
addq $-0x1, %rcx
jb 0x2a07
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::show()
void show(void) {
    bit2array();
    for (int i = 0; i < 81; i++) {
      printf("%c", data[i] + '0');
    }
    printf("\n");
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2d94
xorl %r14d, %r14d
movzbl (%rbx,%r14), %edi
addl $0x30, %edi
callq 0x2140
incq %r14
cmpq $0x51, %r14
jne 0x2a53
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::perm_rbox(int*)
Sudoku perm_rbox(int a[3]) {
    mbit bdata2[9];
    mbit v[3];
    mbit t0 = (mbit(1) << 27) - 1;
    mbit t1 = t0 << 27;
    mbit t2 = t0 << 54;
    for (int i = 0; i < 9; i++) {
      v[0] = bdata[i] & t0;
      v[1] = (bdata[i] & t1) >> 27;
      v[2] = (bdata[i] & t2) >> 54;
      bdata2[i] = v[2 - a[2]];
      bdata2[i] |= v[2 - a[1]] << 27;
      bdata2[i] |= v[2 - a[0]] << 54;
    }
    return Sudoku(bdata2);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movslq 0x8(%rdx), %rcx
movslq 0x4(%rdx), %r11
movslq (%rdx), %rdx
movl $0x2, %r8d
movl $0x2, %r9d
movq %rdi, %rax
movl $0x2, %edi
xorl %r10d, %r10d
subq %rcx, %rdi
subq %r11, %r9
subq %rdx, %r8
shlq $0x4, %rdi
shlq $0x4, %r8
shlq $0x4, %r9
leaq -0x80(%rsp,%rdi), %rcx
leaq -0x80(%rsp,%r9), %rdi
leaq -0x80(%rsp,%r8), %rdx
movl $0x1b1b, %r9d           # imm = 0x1B1B
xorl %r8d, %r8d
movl 0x68(%rsi,%r10), %r11d
movq 0x60(%rsi,%r10), %rbx
movq %r8, -0x78(%rsp)
movl %ebx, %r14d
bextrq %r9, %rbx, %r15
shll $0xa, %r11d
shrq $0x36, %rbx
andl $0x7ffffff, %r14d       # imm = 0x7FFFFFF
orl %r11d, %ebx
movq %r14, -0x80(%rsp)
movq %r8, -0x68(%rsp)
movq %r15, -0x70(%rsp)
movq %r8, -0x58(%rsp)
andl $0x7ffffff, %ebx        # imm = 0x7FFFFFF
movq %rbx, -0x60(%rsp)
movq 0x8(%rdi), %r11
movq (%rdi), %rbx
movq 0x8(%rdx), %r14
movq (%rdx), %r15
shldq $0x1b, %rbx, %r11
shlq $0x1b, %rbx
orq (%rcx), %rbx
orq 0x8(%rcx), %r11
shldq $0x36, %r15, %r14
shlq $0x36, %r15
orq %r11, %r14
orq %rbx, %r15
movq %r15, -0x50(%rsp,%r10)
movq %r14, -0x48(%rsp,%r10)
addq $0x10, %r10
cmpq $0x90, %r10
jne 0x2e6c
vmovups -0x50(%rsp), %zmm0
vmovups (%rsp), %zmm2
vmovups -0x10(%rsp), %zmm1
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/kaityo256[P]minlex/minlex.cpp
// Function: Sudoku::headbox_index(bool)
int headbox_index(bool sort) {
    int min = 16 * 3 + 4 * 3 + 3;
    mbit v = 0;
    for (int i = 0; i < 9; i++) {
      v |= bdata[i];
    }
    for (int i = 0; i < 3; 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 + i * 3) * 3))) a[j]++;
        }
      }
      if (sort) {
        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;
      }
      if (index < min) {
        min = index;
      }
    }
    return min;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x60, %eax
movl %esi, 0x10(%rsp)
xorl %r12d, %r12d
xorl %r13d, %r13d
orq (%rdi,%rax), %r12
orq 0x8(%rdi,%rax), %r13
addq $0x10, %rax
cmpq $0xf0, %rax
jne 0x2f99
movl $0x50, %eax
movl $0x1, %ebp
xorl %ebx, %ebx
movl $0x3f, 0xc(%rsp)
movl $0xc, %edi
movl %eax, %r15d
callq 0x2110
movq %rax, %r14
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl %r15d, 0x14(%rsp)
movl %r15d, %eax
xorl %edx, %edx
xorl %esi, %esi
leal (%rax,%rsi), %ecx
xorl %edi, %edi
shldq %cl, %rbp, %rdi
shlxq %rcx, %rbp, %r8
testb $0x40, %cl
movl $0x0, %ecx
cmoveq %r8, %rcx
cmovneq %r8, %rdi
andq %r12, %rcx
andq %r13, %rdi
orq %rdi, %rcx
je 0x3019
incl (%r14,%rdx,4)
decl %esi
cmpl $-0x3, %esi
jne 0x2fec
incq %rdx
addl $-0x3, %eax
cmpq $0x3, %rdx
jne 0x2fea
cmpb $0x0, 0x10(%rsp)
je 0x3055
movq %r14, %r15
addq $0xc, %r15
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x352f
movq %r14, %rdi
movq %r15, %rsi
callq 0x3612
movb $0x7, %al
vpcmpeqd %xmm1, %xmm1, %xmm1
movl 0xc(%rsp), %ecx
movq %r14, %rdi
kmovd %eax, %k1
vmovdqu32 (%r14), %xmm0 {%k1} {z}
vpsllvd %xmm0, %xmm1, %xmm0
vpxor %xmm1, %xmm1, %xmm1
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpsllvd 0x1f8b(%rip), %xmm0, %xmm0 # 0x5010
vpblendd $0x8, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2],xmm1[3]
vphaddd %xmm0, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vmovd %xmm0, %eax
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0xc(%rsp)
callq 0x20f0
movl 0x14(%rsp), %eax
incq %rbx
addl $-0x9, %eax
cmpq $0x3, %rbx
jne 0x2fc2
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rax, %rbx
callq 0x20f0
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0x2d94
movq %rsp, %rax
xorl %ecx, %ecx
movq $-0x9, %rdx
movq %r14, %rsi
movb (%rsi), %dil
addq $0x9, %rsi
movb %dil, 0x9(%rax,%rdx)
incq %rdx
jne 0x3106
incq %rcx
addq $0x9, %rax
incq %r14
cmpq $0x9, %rcx
jne 0x30fc
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3852
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x3fda(%rip), %rbp      # 0x7130
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq %rsp, %r12
leaq (%rbp,%r13), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x38d2
movq %r12, %rdi
xorl %esi, %esi
callq 0x2f7c
cmpl %ebx, %eax
jg 0x318f
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x39fe
addq $0xc, %r13
cmpq $0x48, %r13
jne 0x3164
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0x2d94
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 0x31d8
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2160
movq 0x3dbe(%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 0x322b
movq 0x3d8e(%rip), %rsi      # 0x6fc0
movq %rsp, %rdi
movq %rax, %rbx
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/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
movslq (%rdx), %r8
movslq 0x4(%rdx), %r9
movslq 0x8(%rdx), %rdx
movq %rdi, %rax
movl $0x703, %ecx            # imm = 0x703
movabsq $-0x7e3f1f8fc7e3f1f9, %rdi # imm = 0x81C0E070381C0E07
xorl %r10d, %r10d
shlq $0x4, %r8
shlq $0x4, %r9
shlq $0x4, %rdx
leaq -0x80(%rsp,%r8), %r8
leaq -0x80(%rsp,%r9), %r9
leaq -0x80(%rsp,%rdx), %rdx
movq 0x68(%rsi,%r10), %r11
movq 0x60(%rsi,%r10), %rbx
movq %r11, %r14
shldq $0x3a, %rbx, %r14
movl %r11d, %r15d
shrl $0x6, %r15d
andl %ecx, %r15d
andq %rdi, %r14
movq %r15, -0x78(%rsp)
movl %r11d, %r15d
shrl $0x3, %r15d
movq %r14, -0x80(%rsp)
movq %r11, %r14
shldq $0x3d, %rbx, %r14
andl %ecx, %r15d
andl %ecx, %r11d
andq %rdi, %rbx
movq %r15, -0x68(%rsp)
andq %rdi, %r14
movq %r14, -0x70(%rsp)
movq %rbx, -0x60(%rsp)
movq %r11, -0x58(%rsp)
movq (%r8), %r11
movq 0x8(%r8), %rbx
movq (%r9), %r14
movq 0x8(%r9), %r15
shldq $0x6, %r11, %rbx
shldq $0x3, %r14, %r15
shlq $0x6, %r11
shlq $0x3, %r14
orq %r11, %r14
orq (%rdx), %r14
orq %rbx, %r15
orq 0x8(%rdx), %r15
movq %r14, -0x50(%rsp,%r10)
movq %r15, -0x48(%rsp,%r10)
addq $0x10, %r10
cmpq $0x90, %r10
jne 0x3916
vmovups -0x50(%rsp), %zmm0
vmovups (%rsp), %zmm2
vmovups -0x10(%rsp), %zmm1
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x371a(%rip), %rbp      # 0x7130
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq %rsp, %r12
leaq (%rbp,%r13), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3a68
movq %r12, %rdi
callq 0x3b8e
cmpl %ebx, %eax
jg 0x3a4b
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ca4
addq $0xc, %r13
cmpq $0x48, %r13
jne 0x3a24
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movslq (%rdx), %rcx
movq %rdi, %rax
movslq 0x4(%rdx), %rdi
movslq 0x8(%rdx), %rdx
movabsq $0x7fc0000000000000, %r9 # imm = 0x7FC0000000000000
movb $0x36, %r10b
xorl %r8d, %r8d
xorl %r11d, %r11d
shlq $0x4, %rcx
shlq $0x4, %rdi
shlq $0x4, %rdx
leaq -0x80(%rsp,%rcx), %rcx
leaq -0x80(%rsp,%rdi), %rdi
leaq -0x80(%rsp,%rdx), %rdx
movq 0x68(%rsi,%r11), %r14
movq 0x60(%rsi,%r11), %rbx
movq %r8, -0x78(%rsp)
movl %r14d, %r15d
shldq $0x37, %rbx, %r14
andl $0x1ff00, %r15d         # imm = 0x1FF00
shlq $0x2e, %r15
andq %r9, %r14
movq %r15, -0x80(%rsp)
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
movq 0x8(%rdi), %r12
movq (%rdi), %r13
shldq $0x12, %r15, %rbx
shldq $0x9, %r13, %r12
shlq $0x12, %r15
shlq $0x9, %r13
orq %r14, %r15
orq %rbx, %r12
orq %r15, %r13
orq (%rdx), %r13
orq 0x8(%rdx), %r12
movq %r12, -0x48(%rsp,%r11)
movq %r13, -0x50(%rsp,%r11)
addq $0x10, %r11
cmpq $0x90, %r11
jne 0x3ab1
vmovups -0x50(%rsp), %zmm0
vmovups (%rsp), %zmm2
vmovups -0x10(%rsp), %zmm1
vmovups %zmm2, 0xb0(%rax)
vmovups %zmm1, 0xa0(%rax)
vmovups %zmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ba1
movl $0xc, %edi
callq 0x2110
movq %rax, %r14
movq %rax, %rbx
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x50, %eax
movl $0x1, %esi
xorl %edx, %edx
xorl %edi, %edi
leal (%rax,%rdi), %ecx
xorl %r8d, %r8d
shldq %cl, %rsi, %r8
shlxq %rcx, %rsi, %r9
testb $0x40, %cl
movl $0x0, %ecx
cmoveq %r9, %rcx
cmovneq %r9, %r8
andq %r15, %rcx
andq %r12, %r8
orq %r8, %rcx
je 0x3c0f
incl (%rbx,%rdx,4)
decl %edi
cmpl $-0x3, %edi
jne 0x3be2
incq %rdx
addl $-0x3, %eax
cmpq $0x3, %rdx
jne 0x3be0
addq $0xc, %r14
movl $0x2, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x352f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3612
movb $0x7, %al
vpcmpeqd %xmm1, %xmm1, %xmm1
movq %rbx, %rdi
kmovd %eax, %k1
vmovdqu32 (%rbx), %xmm0 {%k1} {z}
vpsllvd %xmm0, %xmm1, %xmm0
vpxor %xmm1, %xmm1, %xmm1
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpsllvd 0x13a3(%rip), %xmm0, %xmm0 # 0x5010
vpblendd $0x8, %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2],xmm1[3]
vphaddd %xmm0, %xmm0, %xmm0
vphaddd %xmm0, %xmm0, %xmm0
vmovd %xmm0, %ebp
callq 0x20f0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x20f0
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f72
pushq %r15
pushq %r14
pushq %rbx
movl $0x4a, %edi
movl $0x1, %r11d
movl $0x1, %ebx
xorl %r10d, %r10d
movl %r10d, (%rsi)
movl %r10d, (%rdx)
movl %r10d, (%rax)
leal 0x6(%rdi), %ecx
xorl %r14d, %r14d
shldq %cl, %r11, %r14
shlxq %rcx, %r11, %r15
testb $0x40, %cl
movl $0x0, %ecx
cmoveq %r15, %rcx
cmovneq %r15, %r14
andq %r8, %rcx
andq %r9, %r14
orq %r14, %rcx
je 0x3fdd
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
movl $0x0, %ecx
cmoveq %r15, %rcx
cmovneq %r15, %r14
andq %r8, %rcx
andq %r9, %r14
orq %r14, %rcx
je 0x4011
leal -0x48(%rdi), %ecx
shlxl %ecx, %ebx, %ecx
addl %ecx, (%rdx)
movl %edi, %ecx
xorl %r14d, %r14d
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 0x4040
leal -0x48(%rdi), %ecx
shlxl %ecx, %ebx, %ecx
addl %ecx, (%rax)
decl %edi
cmpl $0x47, %edi
jne 0x3fa9
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %r8d
xorl %edx, %edx
xorl %r9d, %r9d
xorl %eax, %eax
movq 0x8(%rsi,%rcx), %rbx
movq 0x8(%rdi,%rcx), %r10
movq (%rdi,%rcx), %r11
movq (%rsi,%rcx), %r14
movq %rbx, %r15
xorq %r10, %r15
je 0x42d9
lzcntq %r15, %r15
notb %r15b
shlxq %r15, %r8, %r12
xorl %r15d, %r15d
jmp 0x42f6
movq %r14, %r15
xorq %r11, %r15
je 0x42f0
lzcntq %r15, %r15
notb %r15b
shlxq %r15, %r8, %r15
jmp 0x42f3
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r14, %r11
movq %r12, %r11
movzbl %al, %eax
sbbq %rbx, %r10
setb %r10b
cmpq %rdx, %r15
sbbq %r9, %r11
movzbl %r10b, %r10d
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 0x42ad
andb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x1f0(%rsp), %rbx
leaq 0x100(%rsp), %r12
leaq 0x280(%rsp), %r15
leaq 0xa0(%rsp), %rbp
movq %rsi, (%rsp)
movq %rdi, %r14
xorl %eax, %eax
movq (%rsp), %rsi
leaq 0x2dab(%rip), %rcx      # 0x7130
movq %rax, 0x8(%rsp)
movq %r15, %rdi
leaq (%rcx,%rax), %rdx
xorl %ecx, %ecx
vzeroupper
callq 0x44d4
xorl %r13d, %r13d
leaq 0x2d8b(%rip), %rax      # 0x7130
leaq 0x190(%rsp), %rdi
movl $0x1, %ecx
movq %r15, %rsi
leaq (%rax,%r13), %rdx
vzeroupper
callq 0x44d4
vmovups (%rbx), %zmm0
vmovups 0x50(%rbx), %zmm2
vmovups 0x40(%rbx), %zmm1
leaq 0x10(%rsp), %rdi
vmovups %zmm2, 0x60(%rsp)
vmovups %zmm1, 0x50(%rsp)
vmovups %zmm0, 0x10(%rsp)
vzeroupper
callq 0x233c
vmovups 0x10(%rsp), %zmm0
vmovups 0x60(%rsp), %zmm2
vmovups 0x50(%rsp), %zmm1
movq %rbp, %rdi
movq %r14, %rsi
vmovups %zmm2, 0x50(%r12)
vmovups %zmm1, 0x40(%r12)
vmovups %zmm0, (%r12)
vzeroupper
callq 0x4294
testb %al, %al
je 0x449d
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 0x439e
movq 0x8(%rsp), %rax
addq $0xc, %rax
cmpq $0x48, %rax
jne 0x437a
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_O3/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 0x86c9(%rip), %rax      # 0xaca0
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 0x554e
movq $0x0, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2628
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
leaq 0x8(%r9), %rsi
addq $0x48, %r9
leaq 0xd(%rip), %rdx         # 0x2648
xorl %ecx, %ecx
movl $0x1, %r8d
jmp 0x3fb4
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2712
movq %rcx, 0x30(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27af
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 0x554e
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x48d4(%rip), %rdx      # 0x7055
xorl %eax, %eax
callq 0x502c
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3da0
movq %r15, %rdi
callq 0x2200
jmp 0x27cc
movq 0x10(%rbx), %rdi
leaq 0x4886(%rip), %rdx      # 0x7040
movq %r12, %rsi
xorl %eax, %eax
callq 0x502c
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_O3/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 0x2859
addq $0x48, %rdi
movq (%rax), %r14
movl 0x8(%rax), %ebp
callq 0x37c2
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x29de
movq 0x20(%rbx), %rdi
jmp 0x282d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdx
movq 0x30(%rax), %rcx
cmpq %rcx, %rdx
je 0x29dd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x24(%rax)
jne 0x28b7
movl $0x14, 0x24(%rax)
cmpb $0x0, 0x28(%rbx)
jne 0x28b7
leaq 0x29(%rbx), %rsi
movq %rbx, %rdi
callq 0x3098
movq %rbx, %rdi
callq 0x3134
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
subq %rdx, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rcx, 0x30(%rbx)
jne 0x2990
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2160
movq 0x20(%rbx), %rax
movq 0x28(%rax), %rbp
movq 0x30(%rax), %r13
cmpq %r13, %rbp
je 0x2988
leaq 0x18(%rbp), %rcx
cmpq %r13, %rcx
je 0x2988
movq %rbx, 0x8(%rsp)
movl $0x18, %ebx
leaq 0x10(%rsp), %r14
callq 0x2050
cltq
movq %rbx, %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, %rbx
je 0x296e
leaq (%rbx,%rbp), %r12
addq %rbp, %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x558c
movq %r12, %rdi
movq %r15, %rsi
callq 0x55aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x55aa
leaq (%rbx,%rbp), %rax
addq $0x18, %rax
addq $0x18, %rbx
cmpq %r13, %rax
jne 0x2915
movq 0x8(%rsp), %rbx
movq 0x20(%rbx), %rax
movq $0x0, 0x30(%rbx)
movl 0x24(%rax), %ecx
cmpl $0x14, %ecx
jne 0x29a7
movq %rbx, %rdi
callq 0x321a
movq 0x20(%rbx), %rax
movl 0x24(%rax), %ecx
cmpl $0x13, %ecx
jg 0x29c7
cmpb $0x0, 0x28(%rbx)
jne 0x29c7
cmpl $0x0, 0x20(%rax)
jne 0x29c7
movq %rbx, %rdi
callq 0x32fa
movq 0x20(%rbx), %rax
movl 0x24(%rax), %ecx
decl 0x20(%rax)
decl %ecx
movl %ecx, 0x24(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a2e
leaq 0x4617(%rip), %rsi      # 0x7004
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
movq %rdx, %rsi
jmp 0x2a32
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2f66
movq %rdx, %rsi
jmp 0x3048
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2da6
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2b74
movq %rdx, %rsi
movl %ecx, %edx
jmp 0x2e84
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2de8
movl 0x26(%rsi), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%rsi), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x2e7f
leaq 0x20(%rsi), %r12
addq $0x26, %rsi
leaq 0xa(%rsp), %r13
movq %r13, %rdi
callq 0x5540
leaq 0x4(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x5540
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 0x554e
leaq 0x26(%r12), %rdi
movq %r13, %rsi
callq 0x554e
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebx, %r8d
callq 0x3da0
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 0x2e71
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ec1
movl 0x26(%rsi), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%rsi), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x2f62
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 0x2f4f
addq $0x26, %rsi
leaq 0x2(%rsp), %r15
movq %r15, %rdi
callq 0x5540
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 0x554e
leaq 0x26(%r12), %rdi
movq %r15, %rsi
callq 0x554e
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebx, %r8d
callq 0x3da0
movq %r12, %rdi
callq 0x2200
jmp 0x2f54
movb $0x1, 0x28(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x2f56
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fad
movl 0x26(%r15), %eax
xorl 0x38(%r14), %eax
movzwl 0x2a(%r15), %ecx
xorw 0x3c(%r14), %cx
movzwl %cx, %ecx
orl %eax, %ecx
je 0x3043
leaq 0x20(%r15), %rsi
leaq 0xa(%rsp), %r13
movq %r13, %rdi
callq 0x5540
addq $0x26, %r15
leaq 0x4(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5540
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 0x554e
leaq 0x26(%r15), %rdi
movq %r13, %rsi
callq 0x554e
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %r12, %rdx
movq %r15, %rcx
movl %ebx, %r8d
callq 0x3da0
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 0x3035
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3123
movq %rsi, %rbx
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
movsbl (%rbx), %ebp
addq %r15, %rdi
callq 0x55c2
cmpl %ebp, %eax
je 0x30fb
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 0x30c7
jmp 0x3123
movq 0x20(%r14), %rdi
addq 0x28(%rdi), %r15
addq $0x28, %rdi
movq %r15, %rsi
callq 0x3b34
movq 0x10(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdx
callq 0x535e
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_O3/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 0x3208
movq %rdi, %rbx
leaq 0x29(%rdi), %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x558c
movw $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0x55c2
movb %al, 0x8(%rsp)
movq %r12, %rdi
callq 0x55c6
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 0x554e
leaq 0x26(%rbp), %rdi
movq %r15, %rsi
callq 0x554e
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdx
movq %rbp, %rcx
movl $0x30, %r8d
callq 0x3da0
movq %rbp, %rdi
callq 0x2200
addq $0x18, %r14
cmpq %r13, %r14
jne 0x3163
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_O3/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 0x55c2
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 0x55c6
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 0x554e
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x26(%r15), %rdi
callq 0x554e
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3da0
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_O3/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 0xa(%rsp), %r14
movb $0x0, 0x5(%r14)
movl $0x0, 0x1(%r14)
movq 0x20(%rdi), %rax
movq 0x30(%rdi), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x55c2
movb %al, (%r14)
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq 0x28(%rax), %rdi
callq 0x55c6
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 0x554e
leaq 0x29(%rbx), %rsi
leaq 0x26(%r15), %rdi
callq 0x554e
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
movq %r14, %rdx
movq %r15, %rcx
movl $0x30, %r8d
callq 0x3da0
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7121(%rip), %rax      # 0xacd0
movq %rax, (%rdi)
leaq 0x7147(%rip), %rax      # 0xad00
movq %rax, 0x1b7e498(%rdi)
movq %rsi, 0x8(%rdi)
movq $0x1, 0x1b7e4a0(%rdi)
movl $0x0, 0x1b7e490(%rdi)
addq $0xdbf250, %rdi         # imm = 0xDBF250
xorl %eax, %eax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movups %xmm0, -0xdbf240(%rdi,%rcx,4)
movups %xmm0, (%rdi,%rcx,4)
addq $0x4, %rcx
cmpq $0xe10, %rcx            # imm = 0xE10
jne 0x3be7
incq %rax
addq $0x3840, %rdi           # imm = 0x3840
cmpq $0x3e8, %rax            # imm = 0x3E8
jne 0x3be5
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x70b5(%rip), %rax      # 0xacd0
movq %rax, (%rdi)
leaq 0x70db(%rip), %rax      # 0xad00
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 0x3c57
incq %rdx
addq %r8, %rcx
addq %r8, %rax
cmpq $0x3e8, %rdx            # imm = 0x3E8
jne 0x3c54
movl 0x1b7e4a0(%rsi), %eax
movl %eax, 0x1b7e4a0(%rdi)
movq 0x1b7e4a4(%rsi), %rax
movq %rax, 0x1b7e4a4(%rdi)
testl %eax, %eax
jle 0x3cce
movl %eax, %eax
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
ja 0x3cb3
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cfd
incq %rdi
addq %r8, %rdx
addq %r8, %rcx
cmpq $0x3e8, %rdi            # imm = 0x3E8
jne 0x3cfa
movl 0x1b7e4a0(%rsi), %ecx
movl %ecx, 0x1b7e4a0(%rax)
movq 0x1b7e4a4(%rsi), %rcx
movq %rcx, 0x1b7e4a4(%rax)
testl %ecx, %ecx
jle 0x3d76
movl %ecx, %ecx
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
ja 0x3d5a
retq
nop