LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logReadFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logReadFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: read fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0xabb5(%rip), %rax      # 0x1793f
leaq 0xabba(%rip), %rcx      # 0x1794b
testl %edx, %edx
cmovneq %rax, %rcx
movl %edx, %eax
leaq (%rax,%rax,4), %r8
addq $0x6, %r8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33f0
movq 0x8(%rsp), %r12
movq 0x8(%r14), %rdi
callq 0xd162
movq (%r15), %r9
leaq 0x19d59(%rip), %r15     # 0x26b20
leaq 0xaca1(%rip), %rsi      # 0x17a6f
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3080
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc4a8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xce07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xce30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logUpdateFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logUpdateFail(Address * address, bool isCoordinator, int transID, string key, string newValue){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: update fail at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), newValue.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r12
movl %ecx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq 0xaace(%rip), %rax      # 0x1793f
leaq 0xaad3(%rip), %rcx      # 0x1794b
testl %edx, %edx
cmovneq %rax, %rcx
movl %edx, %eax
leaq (%rax,%rax,4), %r8
addq $0x6, %r8
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33f0
movq 0x18(%rsp), %r13
movq 0x8(%r14), %rdi
callq 0xd162
movq (%r12), %r9
movq (%r15), %rcx
movq %rcx, (%rsp)
leaq 0x19cda(%rip), %r15     # 0x26b90
leaq 0xabdf(%rip), %rsi      # 0x17a9c
movq %r15, %rdi
movq %r13, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3080
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc4a8
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcef8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcf21
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logDeleteFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logDeleteFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: delete fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0xa9df(%rip), %rax      # 0x1793f
leaq 0xa9e4(%rip), %rcx      # 0x1794b
testl %edx, %edx
cmovneq %rax, %rcx
movl %edx, %eax
leaq (%rax,%rax,4), %r8
addq $0x6, %r8
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33f0
movq 0x8(%rsp), %r12
movq 0x8(%r14), %rdi
callq 0xd162
movq (%r15), %r9
leaq 0x19c63(%rip), %r15     # 0x26c00
leaq 0xab31(%rip), %rsi      # 0x17ad5
movq %r15, %rdi
movq %r12, %rdx
movl %eax, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x3080
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xc4a8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xcfdd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xd006
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/Params.cpp
// Function: Params::setparams(char*)
void Params::setparams(char *config_file) {
	//trace.funcEntry("Params::setparams");
	char CRUD[10];
	FILE *fp = fopen(config_file,"r");

	fscanf(fp,"MAX_NNB: %d", &MAX_NNB);
	fscanf(fp,"\nSINGLE_FAILURE: %d", &SINGLE_FAILURE);
	fscanf(fp,"\nDROP_MSG: %d", &DROP_MSG);
	fscanf(fp,"\nMSG_DROP_PROB: %lf", &MSG_DROP_PROB);
	fscanf(fp,"\nCRUD_TEST: %s", CRUD);

	if ( 0 == strcmp(CRUD, "CREATE") ) {
		this->CRUDTEST = CREATE_TEST;
	}
	else if ( 0 == strcmp(CRUD, "READ") ) {
		this->CRUDTEST = READ_TEST;
	}
	else if ( 0 == strcmp(CRUD, "UPDATE") ) {
		this->CRUDTEST = UPDATE_TEST;
	}
	else if ( 0 == strcmp(CRUD, "DELETE") ) {
		this->CRUDTEST = DELETE_TEST;
	}

	//printf("Parameters of the test case: %d %d %d %lf\n", MAX_NNB, SINGLE_FAILURE, DROP_MSG, MSG_DROP_PROB);

	EN_GPSZ = MAX_NNB;
	STEP_RATE=.25;
	MAX_MSG_SIZE = 4000;
	globaltime = 0;
	dropmsg = 0;
	allNodesJoined = 0;
	for ( unsigned int i = 0; i < EN_GPSZ; i++ ) {
		allNodesJoined += i;
	}
	fclose(fp);
	//trace.funcExit("Params::setparams", SUCCESS);
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xa921(%rip), %rsi      # 0x17950
movq %rax, %rdi
callq 0x3310
movq %rax, %r14
leaq 0xab0c(%rip), %rsi      # 0x17b4d
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3470
leaq 0x4(%rbx), %rdx
leaq 0xaafe(%rip), %rsi      # 0x17b59
movq %r14, %rdi
xorl %eax, %eax
callq 0x3470
leaq 0x20(%rbx), %rdx
leaq 0xaafd(%rip), %rsi      # 0x17b6d
movq %r14, %rdi
xorl %eax, %eax
callq 0x3470
leaq 0x8(%rbx), %rdx
leaq 0xaaf6(%rip), %rsi      # 0x17b7b
movq %r14, %rdi
xorl %eax, %eax
callq 0x3470
leaq 0xaaf9(%rip), %rsi      # 0x17b8f
leaq 0xe(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3470
movl $0x41455243, %eax       # imm = 0x41455243
xorl (%r15), %eax
movl $0x455441, %ecx         # imm = 0x455441
xorl 0x3(%r15), %ecx
orl %eax, %ecx
je 0xd10e
movl $0x44414552, %eax       # imm = 0x44414552
xorl 0xe(%rsp), %eax
movzbl 0x12(%rsp), %ecx
orl %eax, %ecx
je 0xd102
movl $0x41445055, %eax       # imm = 0x41445055
xorl 0xe(%rsp), %eax
movl $0x455441, %ecx         # imm = 0x455441
xorl 0x11(%rsp), %ecx
orl %eax, %ecx
je 0xd109
movl $0x454c4544, %eax       # imm = 0x454C4544
xorl 0xe(%rsp), %eax
movl $0x455445, %ecx         # imm = 0x455445
xorl 0x11(%rsp), %ecx
orl %eax, %ecx
jne 0xd111
movl $0x3, %ebp
jmp 0xd10e
movl $0x1, %ebp
jmp 0xd10e
movl $0x2, %ebp
movl %ebp, 0x34(%rbx)
movl (%rbx), %eax
movl %eax, 0x18(%rbx)
movabsq $0x3fd0000000000000, %rcx # imm = 0x3FD0000000000000
movq %rcx, 0x10(%rbx)
movl $0xfa0, 0x1c(%rbx)      # imm = 0xFA0
movq $0x0, 0x24(%rbx)
testl %eax, %eax
je 0xd14a
leal -0x1(%rax), %ecx
leal -0x2(%rax), %edx
imulq %rcx, %rdx
shrq %rdx
addl %edx, %eax
decl %eax
jmp 0xd14c
xorl %eax, %eax
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x3260
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::MP2Node(Member*, Params*, EmulNet*, Log*, Address*)
MP2Node::MP2Node(Member *memberNode, Params *par, EmulNet *emulNet, Log *log, Address *address) {
    this->memberNode = memberNode;
    this->par = par;
    this->emulNet = emulNet;
    this->log = log;
    ht = new HashTable();
    this->memberNode->addr = *address;
    this->lowestTransID = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
xorl %eax, %eax
movq %rax, 0x80(%rdi)
addq $0x98, %rdi
movl $0x0, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movq %rdi, 0xa8(%rbx)
movq %rdi, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movq %rsi, 0x50(%rbx)
movq %rdx, 0x58(%rbx)
movq %rcx, 0x60(%rbx)
movq %r8, 0x68(%rbx)
movl $0x38, %edi
callq 0x3270
movq %rax, %r15
movq %rax, %rdi
callq 0x1442c
movq %r15, 0x48(%rbx)
movq 0x50(%rbx), %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0xd17e
movl $0x0, 0x88(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x3280
jmp 0xef8d
movq %rax, %r14
leaq 0x70(%rbx), %r15
leaq 0x30(%rbx), %r12
leaq 0x18(%rbx), %r13
leaq 0x90(%rbx), %rdi
callq 0x1317c
movq %r15, %rdi
callq 0xbc10
movq %r12, %rdi
callq 0xbc10
movq %r13, %rdi
callq 0xbc10
movq %rbx, %rdi
callq 0xbc10
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::updateRing()
void MP2Node::updateRing() {
    vector<Node> curMemList;

    /*
     *  Step 1. Get the current membership list from Membership Protocol / MP1
     */
    curMemList = getMembershipList();

    /*
     * Step 2: Construct the ring
     */
    // Sort the list based on the hashCode
    sort(curMemList.begin(), curMemList.end());

    /*
     * Step 3: Run the stabilization protocol IF REQUIRED
     */
    // Run stabilization protocol if the hash table size is greater than zero and if there has been changes in the ring

    // if stabilization protocol needs to be run, cache the list (now the old list and new list are both present)
    // and then let the stabilization protocol do the work

    // for testing purpose
    // this->ring = curMemList;

    if (this->ring.size() == 0) {
        this->ring = curMemList;
        return;
    }

    // first compare the size
    if (this->ring.size() != curMemList.size()) {
        this->new_ring = curMemList;
        this->stabilizationProtocol();
        return;
    }

    // compare every node hash
    for (int i = 0; i < this->ring.size(); ++i) {
        if (this->ring[i].nodeHashCode != curMemList[i].nodeHashCode) {
            this->new_ring = curMemList;
            this->stabilizationProtocol();
            return;
        }
    }

    // it doesn't change
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0xf188
leaq 0x30(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r14
movups (%r14), %xmm1
movaps %xmm1, (%rsp)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rsp)
movaps (%rdi), %xmm1
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
movups %xmm1, (%r14)
movq $0x0, 0x10(%r14)
callq 0xbc10
movq %r14, %rdi
callq 0xbc10
movq (%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0xf0d1
movq %r15, %rax
subq %r14, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1322f
movq %r14, %rdi
movq %r15, %rsi
callq 0x132e5
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
movq %rsi, %rdi
subq %rax, %rdi
je 0xf123
movq (%rsp), %rdx
movq 0x8(%rsp), %r8
subq %rdx, %r8
cmpq %r8, %rdi
jne 0xf134
cmpq %rax, %rsi
je 0xf15e
sarq $0x5, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movl $0x10, %esi
movq (%rax,%rsi), %rdi
cmpq (%rdx,%rsi), %rdi
jne 0xf14a
addq $0x20, %rsi
decq %rcx
jne 0xf10e
jmp 0xf15e
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12dfa
jmp 0xf15e
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0x12dfa
movq %rbx, %rdi
callq 0xf2da
jmp 0xf15e
leaq 0x70(%rbx), %rdi
movq %rsp, %rsi
callq 0x12dfa
movq %rbx, %rdi
callq 0xf2da
movq %rsp, %rdi
callq 0xbc10
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf174
jmp 0xf174
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbc10
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::getMembershipList()
vector<Node> MP2Node::getMembershipList() {
    unsigned int i;
    vector<Node> curMemList;
    for ( i = 0 ; i < this->memberNode->memberList.size(); i++ ) {
        Address addressOfThisMember;
        int id = this->memberNode->memberList.at(i).getid();
        short port = this->memberNode->memberList.at(i).getport();
        memcpy(&addressOfThisMember.addr[0], &id, sizeof(int));
        memcpy(&addressOfThisMember.addr[4], &port, sizeof(short));
        curMemList.emplace_back(Node(addressOfThisMember));
    }
    return curMemList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rsp)
movq 0x50(%rsi), %rcx
movq 0x28(%rcx), %rax
cmpq %rax, 0x30(%rcx)
je 0xf28a
movl $0x1, %ebx
xorl %ebp, %ebp
leaq 0x22(%rsp), %r13
leaq 0x28(%rsp), %r14
leaq (,%rbp,2), %r15
addq %rbp, %r15
leaq (%rax,%r15,8), %rdi
callq 0xd1f2
movl %eax, %r12d
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rbp, %rdx
jbe 0xf29e
leaq (%rax,%r15,8), %rdi
callq 0xd1f6
movl %r12d, 0x10(%rsp)
movw %ax, 0x14(%rsp)
movq %r13, %rdi
leaq 0x10(%rsp), %rsi
callq 0xd170
movq %r14, %rdi
movq %r13, %rsi
callq 0x142f8
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x12f38
movq %r14, %rdi
callq 0x1439a
movl %ebx, %ebp
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
incl %ebx
cmpq %rbp, %rcx
ja 0xf1d1
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7e46(%rip), %rdi      # 0x170eb
movq %rbp, %rsi
xorl %eax, %eax
callq 0x33c0
jmp 0xf2c4
jmp 0xf2c4
jmp 0xf2c4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x1439a
jmp 0xf2c7
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xbc10
movq %r14, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReply(int, bool)
void MP2Node::handleReply(int transID, bool success) {
    if (success) {
        transID2Bundle[transID]->success_responses++;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
addq $0x90, %rdi
movq %rax, %rsi
callq 0x13022
movq (%rax), %rax
testl %ebx, %ebx
je 0x10d12
incl (%rax)
jmp 0x10d15
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReadReply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void MP2Node::handleReadReply(string value, int transID) {
    if (!value.empty()) {
        transID2Bundle[transID]->success_responses++;
        // @TODO: here we are assuming all responses are latest
        transID2Bundle[transID]->value = value;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movq 0x8(%rbx), %r15
addq $0x90, %r14
movq %r14, %rdi
callq 0x13022
movq (%rax), %rax
testq %r15, %r15
je 0x10d6d
incl (%rax)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x13022
movq (%rax), %rdi
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x3140
jmp 0x10d70
incl 0x4(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/zkl94[P]distributed-key-value-store/./MP2Node.h
// Function: Bundle::Bundle(MessageType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Bundle(MessageType t, string key, string value) {
		this->success_responses = 0;
		this->failure_responses = 0;
		this->t = t;
		this->key = key;
		this->value = value;
		this->iteration = 0; // the times being read by checkMessages
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r14
movq %r14, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r13
leaq 0x40(%rdi), %rbp
movq %rbp, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3140
movq %r13, %rdi
movq %r12, %rsi
callq 0x3140
movl $0x0, 0x50(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x1300e
movq (%rbp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
movq %r14, %rsi
callq 0x35c1
movq %r15, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/51Peg/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "51Peg.rv";

    // the second argument is the units of the RVs
    // the third (optional) argument, tells kima not to skip any line in the header of the file
    load(datafile, "ms", 0);

    // set the sampler and run it!
    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50); // print to terminal every 50th iteration

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x323f3(%rip), %rdx     # 0x53548
leaq 0x323e4(%rip), %r14     # 0x53540
leaq 0x2422e(%rip), %rcx     # 0x45391
movl $0x8, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x1e364(%rip), %rsi     # 0x3f4e9
movq %r14, %rdi
callq 0x2137d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21480
movq %r14, %rdi
movl $0x32, %esi
callq 0x21552
leaq 0x8(%rsp), %rdi
callq 0x21730
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21730
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/threads/part3/call_once.cpp
// Function: main
int main(){
    std::thread t1(do_something);
    std::thread t2(do_something);
    std::thread t3(do_something);
    std::thread t4(do_something);

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq -0xc1(%rip), %rbx       # 0x124c
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x140a
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x140a
leaq -0xe2(%rip), %rsi       # 0x124c
leaq 0x8(%rsp), %rdi
callq 0x140a
leaq -0xf3(%rip), %rsi       # 0x124c
movq %rsp, %rdi
callq 0x140a
leaq 0x18(%rsp), %rdi
callq 0x1100
leaq 0x10(%rsp), %rdi
callq 0x1100
leaq 0x8(%rsp), %rdi
callq 0x1100
movq %rsp, %rdi
callq 0x1100
cmpq $0x0, (%rsp)
jne 0x13c1
cmpq $0x0, 0x8(%rsp)
jne 0x13c1
cmpq $0x0, 0x10(%rsp)
jne 0x13c1
cmpq $0x0, 0x18(%rsp)
jne 0x13c1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x13a1
jmp 0x13a9
jmp 0x13b1
cmpq $0x0, (%rsp)
jne 0x13c1
cmpq $0x0, 0x8(%rsp)
jne 0x13c1
cmpq $0x0, 0x10(%rsp)
jne 0x13c1
cmpq $0x0, 0x18(%rsp)
jne 0x13c1
movq %rax, %rdi
callq 0x1110
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/examples/health_echo/main.cpp
// Function: main
int main(int argc, char** argv)
{
    try
    {
        auto interface = nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(argc, argv);
        if(interface == nullptr)
        {
            std::cerr << "Failed to create interface" << std::endl;
            return 2;
        }

        HealthEcho echo;
        interface->SetConsumer(&echo);

        nshdev::Scheduler scheduler(*interface);

        scheduler.SchedulePackets();
    }
    catch(const std::exception& e)
    {
        std::cerr << "Caught exception (aborting)" << std::endl << e.what() << std::endl;
    }

    return 1;  // can only get here by exception
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x14(%rsp), %rax
movl %edi, (%rax)
leaq 0x28(%rsp), %rdx
movq %rsi, (%rdx)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x27ec
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x2586
leaq 0x47f2(%rip), %rax      # 0x6d40
addq $0x10, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rbx)
jne 0x25f5
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3470
leaq 0x18(%rsp), %rdi
callq 0x3482
xorl %ebp, %ebp
jmp 0x25d1
movq 0x4a5b(%rip), %r14      # 0x6fe8
leaq 0x1a70(%rip), %rsi      # 0x4004
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2200
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x4a29(%rip), %rdi      # 0x6fe8
callq 0x2030
movl $0x2, %ebp
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25e0
movq (%rdi), %rax
callq *0x8(%rax)
testq %rbx, %rbx
je 0x25ea
movl $0x1, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a3f(%rip), %rdi      # 0x403b
leaq 0x1a44(%rip), %rsi      # 0x4047
leaq 0x1a65(%rip), %rcx      # 0x406f
movl $0x1b, %edx
callq 0x2130
movq %rdx, %r14
movq %rax, %rbx
jmp 0x263b
jmp 0x261e
movq %rdx, %r14
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2633
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
cmpl $0x1, %r14d
jne 0x26a1
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
movq 0x4995(%rip), %rdi      # 0x6fe8
leaq 0x19c5(%rip), %rsi      # 0x401f
movl $0x1b, %edx
callq 0x2200
movq 0x497d(%rip), %rdi      # 0x6fe8
callq 0x2110
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
callq 0x2280
jmp 0x25e5
movq %rax, %rbx
callq 0x2280
movq %rbx, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0x26b1
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/NetInterfaceFactory.cpp
// Function: nshdev::CreateDpdkIf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::unique_ptr<DpdkNetInterface> CreateDpdkIf(std::string pciAddr)
{
    std::string progName = "CreateDpdkIf";
    std::string dashW = "-w";
    char * argv[] =
    {
        // ugh
        &progName[0],
        &dashW[0],
        &pciAddr[0]
    };

    const uint32_t numInterfaces = DpdkSetup(3, argv);

    if(numInterfaces < 1)
    {
        return std::unique_ptr<DpdkNetInterface>();
    }

    return std::make_unique<DpdkNetInterface>(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19c5(%rip), %rsi      # 0x40a2
leaq 0x19ca(%rip), %rdx      # 0x40ae
leaq 0x20(%rsp), %rdi
callq 0x2a28
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x19b0(%rip), %rsi      # 0x40af
leaq 0x19ab(%rip), %rdx      # 0x40b1
movq %rsp, %rdi
callq 0x2a28
movq 0x20(%rsp), %rax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq (%rsp), %rax
movq %rax, 0x8(%rsi)
movq (%r14), %rax
movq %rax, 0x10(%rsi)
movl $0x3, %edi
callq 0x33c8
testl %eax, %eax
je 0x2751
movl $0x38, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
callq 0x3274
jmp 0x275b
movq $0x0, (%rbx)
xorl %r14d, %r14d
movq %r14, (%rbx)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2774
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x278b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x21f0
jmp 0x27b1
jmp 0x27ae
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x27cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x27cc
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x27e3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/NetInterfaceFactory.cpp
// Function: nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(int&, char**&)
std::unique_ptr<NetInterface>
NetInterfaceFactory::CreateInterfaceFromArgs(int& argc,
                                             char**& argv)
{
	// cache the "starting" values so that later users of the args can use getopt

	const int old_optind = optind;
	const int old_optopt = optopt;
	char * const old_optarg = optarg;

    InterfaceOptions options(argc, argv);
	
	// restore
	optind = old_optind;
	optopt = old_optopt;
	optarg = old_optarg;

    argc -= options.GetNumArgsConsumed();
    argv += options.GetNumArgsConsumed();

	if(!options.GetDpdkPciAddress().empty())
    {
        return CreateDpdkIf(options.GetDpdkPciAddress());
    }
    else
    {
        return std::make_unique<PacketSocket>(options.GetIfIndex());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq 0x47bc(%rip), %rax      # 0x6fc8
movl (%rax), %ebp
movq 0x47a3(%rip), %rax      # 0x6fb8
movl (%rax), %r13d
movq 0x4781(%rip), %rax      # 0x6fa0
movq (%rax), %rbx
movl (%rsi), %esi
movq (%rdx), %rdx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x2ba8
movq 0x478d(%rip), %rax      # 0x6fc8
movl %ebp, (%rax)
movq 0x4774(%rip), %rax      # 0x6fb8
movl %r13d, (%rax)
movq 0x4752(%rip), %rax      # 0x6fa0
movq %rbx, (%rax)
movq %r12, %rdi
callq 0x2d02
subl %eax, (%r15)
leaq 0x38(%rsp), %rdi
callq 0x2d02
movl %eax, %eax
shlq $0x3, %rax
addq %rax, (%r14)
leaq 0x38(%rsp), %rdi
callq 0x2cfc
cmpq $0x0, 0x8(%rax)
je 0x28e8
leaq 0x38(%rsp), %rdi
callq 0x2cfc
movq 0x10(%rsp), %rbx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x2998
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x26bc
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq %rax, (%rbx)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2918
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2918
leaq 0x38(%rsp), %rdi
callq 0x2cf8
movq 0x10(%rsp), %rbx
movl %eax, %ebp
movl $0x18, %edi
callq 0x21e0
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
movl $0x894f, %edx           # imm = 0x894F
callq 0x2d74
movq %r14, (%rbx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2933
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
jmp 0x2967
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2975
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2975
jmp 0x2972
jmp 0x2972
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2990
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: ResolveInterface(char const*)
int ResolveInterface(const char* name)
{
    unsigned i = if_nametoindex(name);
    if( i == 0 )
    {
        std::cerr << "Unknown interface name " << name << std::endl;
	exit(1);
    }
    return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2080
testl %eax, %eax
je 0x2ac7
popq %rbx
retq
movq 0x451a(%rip), %rdi      # 0x6fe8
leaq 0x1607(%rip), %rsi      # 0x40dc
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2110
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: InterfaceOptions::InterfaceOptions(int, char**)
InterfaceOptions::InterfaceOptions(int argc, char** argv):
    m_ifIndex(0),
    m_numArgsConsumed(0)
{
    while(1)
    {
        int option_index = 0;
        int c = getopt_long(argc, argv, "i:", long_options, &option_index);
        if ( c == -1 )
        {
            break;
        }
        switch(c)
        {
        case 'i':
            m_ifIndex = ResolveInterface(optarg);
            break;
        case 'd':
            m_dpdkPciAddress = optarg;
            break;
        case '?':
            Usage(basename(argv[0]));
            exit(1);
        }
    }

    m_numArgsConsumed = optind;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r13
xorl %eax, %eax
movl %eax, (%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %eax, 0x28(%rdi)
leaq 0x1548(%rip), %r12      # 0x4136
leaq 0x45bb(%rip), %rbx      # 0x71b0
leaq 0xc(%rsp), %r15
movl %esi, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl %ebp, %edi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2290
cmpl $0x68, %eax
jg 0x2c6a
cmpl $0x64, %eax
jne 0x2c87
movq %rbx, %r14
movq %r12, %rbx
movq 0x436b(%rip), %rax      # 0x6fa0
movq (%rax), %r12
movq 0x10(%r13), %rbp
movq %r12, %rdi
callq 0x2100
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq %rbx, %r12
movq %r14, %rbx
movq 0x20(%rsp), %r14
movl 0x8(%rsp), %ebp
movq %rax, %r8
callq 0x2260
jmp 0x2c03
cmpl $0x69, %eax
jne 0x2c03
movq 0x432a(%rip), %rax      # 0x6fa0
movq (%rax), %rdi
callq 0x2ab8
movl %eax, (%r13)
jmp 0x2c03
cmpl $-0x1, %eax
je 0x2caf
cmpl $0x3f, %eax
jne 0x2c03
movq (%r14), %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x2af7
movl $0x1, %edi
callq 0x2210
movq 0x4312(%rip), %rax      # 0x6fc8
movl (%rax), %eax
movl %eax, 0x28(%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ccd
movq %rax, %rbx
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x2cef
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::dump_ll(sockaddr_ll&, unsigned int)
void dump_ll(struct sockaddr_ll& addr, unsigned length)
    {
	printf("addr: len=%d %u/%u index %d hatype %u pkttype %u halen %u addr %02x:%02x:%02x:%02x:%02x:%02x\n",
            length,
	    addr.sll_family,
	    addr.sll_protocol,
	    addr.sll_ifindex,
	    addr.sll_hatype,
	    addr.sll_pkttype,
	    addr.sll_halen,
	    addr.sll_addr[0],
	    addr.sll_addr[1],
	    addr.sll_addr[2],
	    addr.sll_addr[3],
	    addr.sll_addr[4],
	    addr.sll_addr[5]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl (%rdi), %edx
movzwl 0x2(%rdi), %ecx
movl 0x4(%rdi), %r8d
movzwl 0x8(%rdi), %r9d
movzbl 0xa(%rdi), %r10d
movzbl 0xb(%rdi), %r11d
movzbl 0xc(%rdi), %ebx
movzbl 0xd(%rdi), %r14d
movzbl 0xe(%rdi), %r15d
movzbl 0xf(%rdi), %r12d
movzbl 0x10(%rdi), %r13d
movzbl 0x11(%rdi), %ebp
leaq 0x13f7(%rip), %rdi      # 0x4147
xorl %eax, %eax
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x2050
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::PacketSocket(int, unsigned short)
PacketSocket::PacketSocket(int ifIndex, uint16_t etherType)
    {
	// looking for specified Ethertype, with Ethernet header removed.
	m_socket = socket(AF_PACKET, SOCK_DGRAM, htons(etherType));
	if(m_socket < 0)
	{
	    throw ErrMsg("Couldn't open socket", errno);
	}
	struct sockaddr_ll  bind_addr;
	memset(&bind_addr, 0, sizeof(bind_addr));
	bind_addr.sll_family = AF_PACKET;
	bind_addr.sll_ifindex = ifIndex;
	bind_addr.sll_protocol = htons(etherType);
	int const bind_result = bind(m_socket, reinterpret_cast<const struct sockaddr*>(&bind_addr), sizeof(bind_addr));
	if(bind_result != 0)
	{
	    close(m_socket);
	    throw ErrMsg("Unable to bind socket", errno);
	}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x3e93(%rip), %rax      # 0x6c28
movq %rax, (%rdi)
rolw $0x8, %bp
movzwl %bp, %edx
movl $0x11, %edi
movl $0x2, %esi
callq 0x2090
movl %eax, 0x10(%rbx)
testl %eax, %eax
js 0x2def
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movw $0x11, (%rsi)
movl %r14d, 0x4(%rsi)
movw %bp, 0x2(%rsi)
movl %eax, %edi
movl $0x14, %edx
callq 0x2070
testl %eax, %eax
jne 0x2e4a
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2120
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1399(%rip), %rsi      # 0x41a5
leaq 0x13a6(%rip), %rdx      # 0x41b9
movq %rsp, %rdi
callq 0x2a28
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x306a
xorl %ebp, %ebp
leaq 0x3e2f(%rip), %rsi      # 0x6c68
leaq 0x3be(%rip), %rdx       # 0x31fe
movq %r14, %rdi
callq 0x22b0
jmp 0x2eab
movl 0x10(%rbx), %edi
callq 0x2310
movl $0x28, %edi
callq 0x2120
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x134b(%rip), %rsi      # 0x41ba
leaq 0x1359(%rip), %rdx      # 0x41cf
movq %rsp, %rdi
callq 0x2a28
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x306a
xorl %ebp, %ebp
leaq 0x3dcc(%rip), %rsi      # 0x6c68
leaq 0x35b(%rip), %rdx       # 0x31fe
movq %r14, %rdi
callq 0x22b0
jmp 0x2eb4
jmp 0x2ecf
movq %rax, %rbx
jmp 0x2ee2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2ed5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2ed5
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2ee2
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::Run()
void PacketSocket::Run()
    {
	uint8_t data[2000];
	LinkAddr from;
	from.length = sizeof(from.addr);
	ssize_t read = recvfrom(m_socket, data, sizeof(data),
				/* flags */ 0,
				reinterpret_cast<struct sockaddr*>(&from.addr),
				&from.length);
	if(read < 0)
	{
	    throw ErrMsg("Error from recvfrom", errno);
	}
	//printf("Send addr: ");
	//dump_ll(from.addr, from.length);
        if( from.addr.sll_pkttype == PACKET_HOST ) // for us
	{
	    PacketRef pref(data, read, &from);
	    Forward(pref);
	}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rdi, %rbx
leaq 0x3c(%rsp), %r9
movl $0x14, (%r9)
movl 0x10(%rdi), %edi
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r14
movl $0x7d0, %edx            # imm = 0x7D0
movq %r15, %rsi
xorl %ecx, %ecx
movq %r14, %r8
callq 0x2190
testq %rax, %rax
js 0x2f90
cmpb $0x0, 0x32(%rsp)
jne 0x2f82
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movl %eax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x3460
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2120
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1223(%rip), %rsi      # 0x41d0
leaq 0x122f(%rip), %rdx      # 0x41e3
leaq 0x8(%rsp), %rdi
callq 0x2a28
callq 0x2040
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x306a
xorl %ebp, %ebp
leaq 0x3c8a(%rip), %rsi      # 0x6c68
leaq 0x219(%rip), %rdx       # 0x31fe
movq %rbx, %rdi
callq 0x22b0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x300f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x300f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x301c
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::ReturnToSender(nshdev::PacketRef&)
void PacketSocket::ReturnToSender(PacketRef& packetRef)
    {
        const LinkAddr& from = static_cast<const LinkAddr&>(*packetRef.From());
	struct sockaddr_ll to = from.addr;
	//printf("Return addr: ");
	//dump_ll(to, from.length);

	ssize_t written = sendto(m_socket, packetRef.Data(), packetRef.Length(), MSG_DONTWAIT,
	                         reinterpret_cast<struct sockaddr*>(&to), sizeof(to));
	if(written < 0)
	{
	    fprintf(stderr, "Error %d from sendto (%s)\n", errno, strerror(errno));
	}
    }

// Assembly:
subq $0x18, %rsp
movq 0x10(%rsi), %rax
movl 0x10(%rax), %ecx
movq %rsp, %r8
movl %ecx, 0x10(%r8)
movups (%rax), %xmm0
movaps %xmm0, (%r8)
movl 0x10(%rdi), %edi
movq (%rsi), %rax
movl 0x8(%rsi), %edx
movq %rax, %rsi
movl $0x40, %ecx
movl $0x14, %r9d
callq 0x2060
testq %rax, %rax
js 0x3063
addq $0x18, %rsp
retq
callq 0x2332
jmp 0x305e
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/Scheduler/Scheduler.cpp
// Function: nshdev::Scheduler::SchedulePackets()
void Scheduler::SchedulePackets()
{
    if(m_if.GetWaitFD() < 0)
    {
        RunAsyncPollLoop();
    }
    else
    {
        RunSyncPollLoop();
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
testl %eax, %eax
jns 0x349b
callq 0x34a0
callq 0x3506
// File: /workspace/github_cpp_makefile_star2_O1/dcdolson[P]nsh-sf-devkit/src/Scheduler/Scheduler.cpp
// Function: nshdev::Scheduler::RunSyncPollLoop()
void Scheduler::RunSyncPollLoop()
{
    int fd = m_if.GetWaitFD();
	while(1)
	{
	    struct pollfd fds;
	    fds.fd = fd;
	    fds.events = POLLIN;
	    fds.revents = 0;
	   
	    int ready = poll(&fds, 1, m_syncTimeout_ms );
	    if(ready > 0)
	    {
		    m_if.Run();
	    }
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movl %ebp, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rbx), %edx
movl $0x1, %esi
movq %r14, %rdi
callq 0x2240
testl %eax, %eax
jle 0x3521
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x3521
// File: /workspace/github_cpp_makefile_star2_O1/ef-gy[P]libefgy/src/test-case/cube-mask.cpp
// Function: bool analyseCubeMaskProperties<efgy::geometry::generators::mask::cube<3ul>>(std::ostream&)
bool analyseCubeMaskProperties(std::ostream &log) {
  auto faces = C::faces();

  long c = 0;

  for (auto &f : faces) {
    std::cerr << "\n[";
    for (auto v : f) {
      log << "  (";
      for (auto w : v) {
        log << " " << w;
      }
      log << " )";
    }
    log << " ]";

    auto t = f;
    c++;
  }

  if (C::size() != faces.size()) {
    log << "wrong size() result; object said it would have " << C::size()
        << " elements, but iterator gave us " << c << " elements.\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x139a4
movq 0x18(%rbx), %r15
leaq 0x20(%rsp), %rax
cmpq %rax, %r15
je 0x5359
movq $0x0, 0x10(%rsp)
leaq 0x117da(%rip), %r12     # 0x16a71
movl $0x2, %edx
movq 0x1ad4d(%rip), %rdi     # 0x1fff0
leaq 0x11816(%rip), %rsi     # 0x16ac0
callq 0x42b0
movl $0x20, %ebx
movb 0x2(%r15,%rbx), %al
movb %al, 0xe(%rsp)
movzwl (%r15,%rbx), %eax
movw %ax, 0xc(%rsp)
movl $0x3, %edx
movq %r14, %rdi
leaq 0x117ed(%rip), %rsi     # 0x16ac3
callq 0x42b0
xorl %ebp, %ebp
movb 0xc(%rsp,%rbp), %r13b
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x42b0
movzbl %r13b, %esi
movq %r14, %rdi
callq 0x4390
incq %rbp
cmpq $0x3, %rbp
jne 0x52dd
movl $0x2, %edx
movq %r14, %rdi
leaq 0x117b1(%rip), %rsi     # 0x16ac7
callq 0x42b0
addq $0x3, %rbx
cmpq $0x2c, %rbx
jne 0x52b4
movl $0x2, %edx
movq %r14, %rdi
leaq 0x11796(%rip), %rsi     # 0x16aca
callq 0x42b0
incq 0x10(%rsp)
movq %r15, %rdi
callq 0x42d0
movq %rax, %r15
leaq 0x20(%rsp), %rax
cmpq %rax, %r15
jne 0x5297
jmp 0x5362
movq $0x0, 0x10(%rsp)
movq 0x40(%rsp), %rbx
cmpq $0x6, %rbx
je 0x53c6
leaq 0x11759(%rip), %rsi     # 0x16acd
movl $0x2f, %edx
movq %r14, %rdi
callq 0x42b0
movl $0x6, %esi
movq %r14, %rdi
callq 0x4190
movq %rax, %r14
leaq 0x11765(%rip), %rsi     # 0x16afd
movl $0x20, %edx
movq %rax, %rdi
callq 0x42b0
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x4220
leaq 0x11765(%rip), %rsi     # 0x16b1e
movl $0xb, %edx
movq %rax, %rdi
callq 0x42b0
cmpq $0x6, %rbx
sete %bl
leaq 0x18(%rsp), %rdi
callq 0x13d04
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53ee
jmp 0x53ee
jmp 0x53ee
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x13d04
movq %rbx, %rdi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O1/matengyue[P]Similar_test_demo/./src/cosSimilar.h
// Function: cosSimilar(int, int*, int*)
double cosSimilar(int dimension, int vector_A[], int vector_B[]){
    double score = 0;
    double sum = 0;
    double sq_A = 0, sq_B = 0;

    for (int i = 0; i < dimension; i++){
        sum += vector_A[i] * vector_B[i];
        sq_A += vector_A[i] * vector_A[i];
        sq_B += vector_B[i] * vector_B[i];
    }

    score = sum / (sqrt(sq_A) * sqrt(sq_B));

    return score;
}

// Assembly:
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
xorpd %xmm0, %xmm0
xorpd %xmm5, %xmm5
testl %edi, %edi
jle 0x2434
movl %edi, %eax
xorl %ecx, %ecx
movl (%rsi,%rcx,4), %edi
movl (%rdx,%rcx,4), %r8d
movl %r8d, %r9d
imull %edi, %r9d
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
imull %edi, %edi
xorps %xmm3, %xmm3
cvtsi2sd %edi, %xmm3
addsd %xmm2, %xmm4
imull %r8d, %r8d
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
addsd %xmm3, %xmm0
addsd %xmm2, %xmm5
incq %rcx
cmpq %rcx, %rax
jne 0x23f4
subq $0x18, %rsp
ucomisd %xmm1, %xmm0
movsd %xmm4, 0x10(%rsp)
jb 0x244d
xorps %xmm2, %xmm2
sqrtsd %xmm0, %xmm2
jmp 0x2462
movsd %xmm5, 0x8(%rsp)
callq 0x2140
movsd 0x8(%rsp), %xmm5
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
jb 0x2475
xorps %xmm0, %xmm0
sqrtsd %xmm5, %xmm0
jmp 0x248a
movapd %xmm5, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x2140
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm2
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matengyue[P]Similar_test_demo/./src/deleteStopWords.h
// Function: ReadAllLinesFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> ReadAllLinesFromFile(const string &fn){
    vector<string> result;
    ifstream ifs(fn);

    //文件异常
    if (!ifs){
        throw runtime_error("Cannot open file!");
    }
    string tmp;
    while (ifs){
        getline(ifs, tmp);
        result.push_back(tmp);
    }
    result.erase(result.end() - 1);

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x2230
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x296e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x292c
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3738
jmp 0x28ef
movq 0x8(%rbx), %rsi
addq $-0x20, %rsi
movq %rbx, %rdi
callq 0x3c42
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2952
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %r15
leaq 0x169e(%rip), %rsi      # 0x4020
movq %rax, %rdi
callq 0x20b0
movq 0x365f(%rip), %rsi      # 0x5ff0
movq 0x3630(%rip), %rdx      # 0x5fc8
movq %r15, %rdi
callq 0x2250
movq %rax, %r14
jmp 0x29d2
movq %rax, %r14
movq %r15, %rdi
callq 0x2120
jmp 0x29d2
jmp 0x29b9
movq %rax, %r14
jmp 0x29dc
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29d2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x20(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x3776
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/matengyue[P]Similar_test_demo/./src/deleteStopWords.h
// Function: deleteStopWords(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<string> deleteStopWords(vector<string> vectorwords){
    vector<string> vectorwordsNStop;

    vector<string> stopwords = ReadAllLinesFromFile("../src/StopWord.txt");

    for (int i = 0; i < vectorwords.size(); i++){
        int flag = 1;
        for (int j = 0; j < stopwords.size(); j++){
            if (vectorwords[i] == stopwords[j]){
                flag = 0;
                break;
            }
        }
        if (flag){
            string word = vectorwords[i];
            vectorwordsNStop.push_back(word);    
        }
    }
    
    return vectorwordsNStop;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1611(%rip), %rsi      # 0x4032
leaq 0x161d(%rip), %rdx      # 0x4045
leaq 0x8(%rsp), %rdi
callq 0x3cba
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x288d
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2a58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x28(%rsp), %rax
movq (%rax), %rbx
cmpq %rbx, 0x8(%rax)
je 0x2b2e
xorl %ebp, %ebp
movq 0x30(%rsp), %r13
movq 0x38(%rsp), %r15
subq %r13, %r15
je 0x2ac2
sarq $0x5, %r15
movq %rbp, %rax
shlq $0x5, %rax
leaq (%rbx,%rax), %r14
movq 0x8(%rbx,%rax), %r12
cmpq $0x1, %r15
adcq $0x0, %r15
addq $0x8, %r13
cmpq (%r13), %r12
jne 0x2ab9
testq %r12, %r12
je 0x2b0f
movq -0x8(%r13), %rsi
movq (%r14), %rdi
movq %r12, %rdx
callq 0x21b0
testl %eax, %eax
je 0x2b0f
addq $0x20, %r13
decq %r15
jne 0x2a9b
movq %rbp, %rax
shlq $0x5, %rax
leaq 0x18(%rsp), %r15
movq %r15, 0x8(%rsp)
movq (%rbx,%rax), %rsi
movq 0x8(%rbx,%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x392e
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x3738
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b0f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
incq %rbp
movq 0x28(%rsp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rax
subq %rbx, %rax
sarq $0x5, %rax
cmpq %rbp, %rax
ja 0x2a6c
leaq 0x30(%rsp), %rdi
callq 0x3776
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2b95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2b95
movq %rax, %r14
jmp 0x2b95
movq %rax, %r14
jmp 0x2b8b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b8b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x30(%rsp), %rdi
callq 0x3776
movq (%rsp), %rdi
callq 0x3776
movq %r14, %rdi
callq 0x2260