LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rax), %r14
movq 0x30(%rax), %r13
leaq 0x29(%rdi), %r15
leaq 0x10(%rsp), %r12
cmpq %r13, %r14
je 0x2fd7
movq %r12, %rdi
movq %r14, %rsi
callq 0x524a
andw $0x0, 0xc(%rsp)
andl $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0x5280
movb %al, 0x8(%rsp)
movq %r12, %rdi
callq 0x5284
movb %al, 0xc(%rsp)
pushq $0x30
popq %rdi
callq 0x2180
movq %rax, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movl $0x2, (%rax)
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x5212
leaq 0x26(%rbp), %rdi
movq %r15, %rsi
callq 0x5212
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdx
movq %rbp, %rcx
pushq $0x30
popq %r8
callq 0x3c2a
movq %rbp, %rdi
callq 0x21e0
addq $0x18, %r14
jmp 0x2f38
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andw $0x0, 0x2d(%rdi)
andl $0x0, 0x29(%rdi)
movq 0x20(%rdi), %rax
imulq $0x18, 0x30(%rdi), %rdi
addq 0x28(%rax), %rdi
callq 0x5280
movb %al, 0x29(%rbx)
movq 0x20(%rbx), %rax
imulq $0x18, 0x30(%rbx), %rdi
addq 0x28(%rax), %rdi
callq 0x5284
movb %al, 0x2d(%rbx)
movq 0x20(%rbx), %r12
movl $0x4, 0x20(%r12)
movb $0x0, 0x28(%rbx)
pushq $0x30
popq %rdi
callq 0x2180
movq %rax, %r15
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movl $0x3, (%rax)
addq $0x8, %r12
leaq 0x20(%rax), %rdi
movq %r12, %rsi
callq 0x5212
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x26(%r15), %rdi
callq 0x5212
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
pushq $0x30
popq %r8
movq %r14, %rdx
movq %r15, %rcx
callq 0x3c2a
movq %r15, %rdi
callq 0x21e0
incq 0x30(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andl $0x0, 0x1(%r14)
movq 0x20(%rdi), %rax
imulq $0x18, 0x30(%rdi), %rdi
addq 0x28(%rax), %rdi
callq 0x5280
movb %al, (%r14)
movq 0x20(%rbx), %rax
imulq $0x18, 0x30(%rbx), %rdi
addq 0x28(%rax), %rdi
callq 0x5284
movb %al, 0x4(%r14)
pushq $0x30
popq %rdi
callq 0x2180
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movl $0x3, (%rax)
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
leaq 0x20(%rax), %rdi
callq 0x5212
leaq 0x29(%rbx), %rsi
leaq 0x26(%r15), %rdi
callq 0x5212
movq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
addq $0x8, %rsi
pushq $0x30
popq %r8
movq %r14, %rdx
movq %r15, %rcx
callq 0x3c2a
movq %r15, %rdi
callq 0x21e0
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_O2/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 0x723d(%rip), %rax      # 0xacd0
movq %rax, (%rdi)
leaq 0x7263(%rip), %rax      # 0xad00
movq %rax, 0x1b7e498(%rdi)
movq %rsi, 0x8(%rdi)
movq $0x1, 0x1b7e4a0(%rdi)
andl $0x0, 0x1b7e490(%rdi)
addq $0xdbf250, %rdi         # imm = 0xDBF250
xorl %eax, %eax
cmpq $0x3e8, %rax            # imm = 0x3E8
je 0x3af3
xorl %ecx, %ecx
cmpq $0xe10, %rcx            # imm = 0xE10
je 0x3ae7
andl $0x0, -0xdbf240(%rdi,%rcx,4)
andl $0x0, (%rdi,%rcx,4)
incq %rcx
jmp 0x3acd
incq %rax
addq $0x3840, %rdi           # imm = 0x3840
jmp 0x3ac3
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
leaq 0x71d2(%rip), %rcx      # 0xacd0
movq %rcx, (%rdi)
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
leaq 0x71f1(%rip), %rcx      # 0xad00
movq %rcx, 0x1b7e498(%rax)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movl 0x1b7e490(%rsi), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0xdbf250, %ecx         # imm = 0xDBF250
leaq (%rsi,%rcx), %rdx
addq %rax, %rcx
xorl %eax, %eax
movl $0x3840, %r8d           # imm = 0x3840
cmpq $0x3e8, %rax            # imm = 0x3E8
je 0x3b7a
xorl %r9d, %r9d
cmpq $0xe10, %r9             # imm = 0xE10
je 0x3b6f
movl -0xdbf240(%rdx,%r9,4), %r10d
movl %r10d, -0xdbf240(%rcx,%r9,4)
movl (%rdx,%r9,4), %r10d
movl %r10d, (%rcx,%r9,4)
incq %r9
jmp 0x3b49
incq %rax
addq %r8, %rdx
addq %r8, %rcx
jmp 0x3b3e
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
jmp 0x40fa
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
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, %edi           # imm = 0x3840
cmpq $0x3e8, %rdx            # imm = 0x3E8
je 0x3bee
xorl %r8d, %r8d
cmpq $0xe10, %r8             # imm = 0xE10
je 0x3be3
movl -0xdbf240(%rcx,%r8,4), %r9d
movl %r9d, -0xdbf240(%rax,%r8,4)
movl (%rcx,%r8,4), %r9d
movl %r9d, (%rax,%r8,4)
incq %r8
jmp 0x3bbd
incq %rdx
addq %rdi, %rcx
addq %rdi, %rax
jmp 0x3bb1
movl $0x1b7e498, %edi        # imm = 0x1B7E498
addq %rdi, %rsi
addq %rbx, %rdi
callq 0x40fa
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/EmulNet.cpp
// Function: EmulNet::ENrecv(Address*, int (*)(void*, char*, int), timeval*, int, void*)
int EmulNet::ENrecv(Address *myaddr, int (* enq)(void *, char *, int), struct timeval *t, int times, void *queue){
	// times is always assumed to be 1
	int i;
	char* tmp;
	int sz;
	en_msg *emsg;

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

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

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

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

			free(emsg);

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movl 0x1b7e4a4(%rdi), %r14d
leaq 0xdbf250(%rdi), %rax
movq %rax, (%rsp)
testl %r14d, %r14d
jle 0x3f00
movq 0x1b7e4a8(%r12,%r14,8), %r13
leaq 0xa(%r13), %rdi
movq %r15, %rsi
callq 0x2230
testl %eax, %eax
jne 0x3ef8
movl (%r13), %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x2220
movq %rax, %rbx
leaq 0x10(%r13), %rsi
movq %rax, %rdi
movq %rbp, %rdx
callq 0x2100
movslq 0x1b7e4a4(%r12), %rax
leal -0x1(%rax), %ecx
movq 0x1b7e4a8(%r12,%rax,8), %rax
movq %rax, 0x1b7e4a8(%r12,%r14,8)
movl %ecx, 0x1b7e4a4(%r12)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x8(%rsp)
movq %r13, %rdi
callq 0x21e0
movslq (%r15), %rbx
movq 0x8(%r12), %rdi
callq 0x51f8
cmpq $0x3e9, %rbx            # imm = 0x3E9
jge 0x3f11
cmpl $0xe10, %eax            # imm = 0xE10
jge 0x3f30
cltq
imulq $0x3840, %rbx, %rcx     # imm = 0x3840
addq (%rsp), %rcx
incl (%rcx,%rax,4)
decq %r14
jmp 0x3e4c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x324a(%rip), %rdi      # 0x7162
leaq 0x31c2(%rip), %rsi      # 0x70e1
leaq 0x324d(%rip), %rcx      # 0x7173
movl $0xa9, %edx
callq 0x20d0
leaq 0x31ed(%rip), %rdi      # 0x7124
leaq 0x31a3(%rip), %rsi      # 0x70e1
leaq 0x322e(%rip), %rcx      # 0x7173
movl $0xaa, %edx
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: handler(int)
void handler(int sig) {
	void *array[10];
	size_t size;

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

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
movq %rsp, %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x2260
movl %eax, %ebp
movq 0x6e8b(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x30f5(%rip), %rsi      # 0x724c
movl %ebx, %edx
xorl %eax, %eax
callq 0x2240
pushq $0x2
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x2290
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: main
int main(int argc, char *argv[]) {
	//signal(SIGSEGV, handler);
	if ( argc != ARGS_COUNT ) {
		cout<<"Configuration (i.e., *.conf) file File Required"<<endl;
		return FAILURE;
	}

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

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x41ad
movq %rsi, %r14
pushq $0x48
popq %rdi
callq 0x2180
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x426a
movq %rbx, %rdi
callq 0x41ea
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %eax, %eax
jmp 0x41cb
movq 0x6e1c(%rip), %rdi      # 0xafd0
leaq 0x30a4(%rip), %rsi      # 0x725f
callq 0x2160
movq %rax, %rdi
callq 0x20b0
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::run()
int Application::run()
{
	int i;
	int timeWhenAllNodesHaveJoined = 0;
	// boolean indicating if all nodes have joined
	bool allNodesJoined = false;
	srand(time(NULL));

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

	// Clean up
	en->ENcleanup();

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

	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x2130
movl %eax, %edi
callq 0x2150
movq 0x40(%rbx), %rax
andl $0x0, 0x28(%rax)
cmpl $0x2bb, %r14d           # imm = 0x2BB
jg 0x4234
movq %rbx, %rdi
callq 0x44c4
movq %rbx, %rdi
callq 0x4686
movq 0x40(%rbx), %rax
movl 0x28(%rax), %r14d
incl %r14d
movl %r14d, 0x28(%rax)
jmp 0x420a
movq 0x28(%rbx), %rdi
callq 0x3f50
xorl %r14d, %r14d
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jge 0x425f
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x26ea
incq %r14
jmp 0x4240
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
		delete mp1[i];
	}
	free(mp1);
	delete par;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x68e4(%rip), %rax      # 0xad30
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x445e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x446d
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r14
jge 0x4495
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4490
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
jmp 0x4470
callq 0x21e0
movq 0x40(%rbx), %rdi
pushq $0x38
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Application.cpp
// Function: Application::fail()
void Application::fail() {
	int i, removed;

	// fail half the members at time t=400
	if( par->DROP_MSG && par->getcurrtime() == 50 ) {
		par->dropmsg = 1;
	}

	if( par->SINGLE_FAILURE && par->getcurrtime() == 100 ) {
		removed = (rand() % par->EN_GPSZ);
		#ifdef DEBUGLOG
		log->LOG(&mp1[removed]->getMemberNode()->addr, "Node failed at time=%d", par->getcurrtime());
		#endif
		mp1[removed]->getMemberNode()->bFailed = true;
	}
	else if( par->getcurrtime() == 100 ) {
		removed = rand() % par->EN_GPSZ/2;
		for ( i = removed; i < removed + par->EN_GPSZ/2; i++ ) {
			#ifdef DEBUGLOG
			log->LOG(&mp1[i]->getMemberNode()->addr, "Node failed at time = %d", par->getcurrtime());
			#endif
			mp1[i]->getMemberNode()->bFailed = true;
		}
	}

	if( par->DROP_MSG && par->getcurrtime() == 300) {
		par->dropmsg=0;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x46b3
callq 0x51f8
movq 0x40(%rbx), %rdi
cmpl $0x32, %eax
jne 0x46b3
movl $0x1, 0x24(%rdi)
cmpl $0x0, 0x4(%rdi)
je 0x471b
callq 0x51f8
cmpl $0x64, %eax
jne 0x4717
callq 0x2040
movq 0x40(%rbx), %rdi
cltd
idivl 0x18(%rdi)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rax
movslq %edx, %r12
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %r15
addq $0x8, %r15
callq 0x51f8
leaq 0x2bdd(%rip), %rdx      # 0x72d0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x4cd2
movq 0x38(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
jmp 0x47a0
movq 0x40(%rbx), %rdi
callq 0x51f8
cmpl $0x64, %eax
jne 0x47a0
callq 0x2040
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
cltd
idivl %ecx
movl %edx, %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
movl %eax, %ebp
movslq %eax, %r13
leaq 0x2b9f(%rip), %r14      # 0x72e7
movl %ecx, %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
addl %ebp, %eax
cltq
cmpq %rax, %r13
jge 0x47a0
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %r12
addq $0x8, %r12
callq 0x51f8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x4cd2
movq 0x38(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x20(%rax), %rax
movb $0x1, 0x10(%rax)
incq %r13
movq 0x40(%rbx), %rdi
movl 0x18(%rdi), %ecx
jmp 0x4748
movq 0x40(%rbx), %rdi
cmpl $0x0, 0x20(%rdi)
je 0x47be
callq 0x51f8
cmpl $0x12c, %eax            # imm = 0x12C
jne 0x47be
movq 0x40(%rbx), %rax
andl $0x0, 0x24(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hunterlxt[P]swim-membership-protocol/Params.cpp
// Function: Params::setparams(char*)
void Params::setparams(char *config_file) {
	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);

	//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);
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2338(%rip), %rsi      # 0x7491
movq %rax, %rdi
callq 0x21d0
movq %rax, %r14
leaq 0x2328(%rip), %rsi      # 0x7493
xorl %ebp, %ebp
movq %rax, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22f0
leaq 0x4(%rbx), %rdx
leaq 0x231a(%rip), %rsi      # 0x749f
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
leaq 0x20(%rbx), %rdx
leaq 0x2319(%rip), %rsi      # 0x74b3
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
leaq 0x8(%rbx), %rdx
leaq 0x2312(%rip), %rsi      # 0x74c1
movq %r14, %rdi
xorl %eax, %eax
callq 0x22f0
movl (%rbx), %eax
movl %eax, 0x18(%rbx)
movabsq $0x3fd0000000000000, %rcx # imm = 0x3FD0000000000000
movq %rcx, 0x10(%rbx)
movl $0xfa0, 0x1c(%rbx)      # imm = 0xFA0
andq $0x0, 0x24(%rbx)
andl $0x0, 0x2c(%rbx)
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x51eb
addl %ecx, %ebp
movl %ebp, 0x2c(%rbx)
incl %ecx
jmp 0x51de
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: decltype(print(fp, fp0.first), print(fp, fp0.second))& unit_test_framework::Diagnostic::print_helper<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, int, int)
static auto print_helper(std::ostream& os,
                             const std::pair<First, Second>& t, int,
                             int)
      -> decltype(print(os, t.first), print(os, t.second))& {
      os << '(';
      print(os, t.first);
      os << ',';
      print(os, t.second);
      return os << ')';
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x28
popq %rsi
callq 0x2220
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b0
pushq $0x2c
popq %rsi
movq %r14, %rdi
callq 0x2220
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b0
pushq $0x29
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/tanguysegarra[P]libcsv/src/reader.hxx
// Function: csv::Reader::get_column_names[abi:cxx11]() const
std::vector<std::string> Reader::get_column_names() const
    {
        auto colnames = std::vector<std::string>{};
        for (size_t i = 0; i < rows_.size(); i++)
            colnames.push_back(rows_[i].first);

        return colnames;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r15d, %r15d
pushq $0x38
popq %r12
xorl %r13d, %r13d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x4cfe
addq %r15, %rsi
movq %rbx, %rdi
callq 0x57a8
incq %r13
addq $0x38, %r15
jmp 0x4cd6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x572c
movq %r14, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/tanguysegarra[P]libcsv/src/reader.hxx
// Function: csv::Reader::find_column_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
size_t Reader::find_column_id(const std::string& id) const
    {
        for (size_t i = 0; i < rows_.size(); i++)
            if (rows_[i].first == id)
                return i;

        throw InvalidArgumentException("Could not find column: " + id);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x38
popq %r13
xorl %r15d, %r15d
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %rax, %r15
jae 0x4d7a
addq %r12, %rdi
movq %r14, %rsi
callq 0x57d4
testb %al, %al
jne 0x4d68
incq %r15
addq $0x38, %r12
jmp 0x4d3c
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0xe38c(%rip), %rsi      # 0x13118
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x5501
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5578
xorl %ebp, %ebp
leaq 0x18cfe(%rip), %rsi     # 0x1dab0
leaq 0x831(%rip), %rdx       # 0x55ea
movq %rbx, %rdi
callq 0x4490
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4170
testb %bpl, %bpl
jne 0x4dd8
jmp 0x4de0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
movq %r14, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/tanguysegarra[P]libcsv/src/writer.hxx
// Function: csv::Writer::write_rows() const
void Writer::write_rows() const
    {
        std::ofstream ofs(filename_);
        if (!ofs.is_open())
            throw InvalidArgumentException("Could not open file: " + filename_);

        for (size_t i = 0; i < rows_.size(); i++)
        {
            ofs << rows_[i].first;
            if(i != rows_.size() - 1)
                ofs << delimiter_;
        }
        ofs << "\n";

        for (size_t i = 0; i < rows_[0].second.size(); i++)
        {
            for (size_t j = 0; j < rows_.size(); j++)
            {
                ofs << rows_[j].second[i];
                if (j != rows_.size() - 1)
                    ofs << delimiter_;
            }
            ofs << "\n";
        }

        ofs.close();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x4520
leaq 0x98(%rsp), %rdi
callq 0x40a0
testb %al, %al
je 0x4ff9
xorl %r15d, %r15d
pushq $0x38
popq %r12
leaq 0x28(%rsp), %r14
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x4f2e
addq %r15, %rsi
movq %r14, %rdi
callq 0x4290
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
decq %rax
cmpq %rax, %r13
je 0x4f25
movsbl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x4350
incq %r13
addq $0x38, %r15
jmp 0x4ee6
leaq 0xe2a6(%rip), %rsi      # 0x131db
leaq 0x28(%rsp), %rdi
callq 0x42b0
xorl %r13d, %r13d
leaq 0x28(%rsp), %r14
movq (%rbx), %rcx
movq 0x28(%rcx), %rax
subq 0x20(%rcx), %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0x4fd3
movq %r13, (%rsp)
shlq $0x5, %r13
pushq $0x20
popq %r15
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %rbp
jae 0x4fb8
movq (%rcx,%r15), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x4290
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
decq %rax
cmpq %rax, %rbp
je 0x4faf
movsbl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x4350
movq (%rbx), %rcx
incq %rbp
addq $0x38, %r15
jmp 0x4f69
movq %r14, %rdi
leaq 0xe219(%rip), %rsi      # 0x131db
callq 0x42b0
movq (%rsp), %r13
incq %r13
jmp 0x4f47
leaq 0x28(%rsp), %rdi
callq 0x43f0
leaq 0x28(%rsp), %rdi
callq 0x4410
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x4190
movq %rax, %rbx
leaq 0xe125(%rip), %rsi      # 0x13130
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x5501
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5578
xorl %ebp, %ebp
leaq 0x18a7f(%rip), %rsi     # 0x1dab0
leaq 0x5b2(%rip), %rdx       # 0x55ea
movq %rbx, %rdi
callq 0x4490
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4170
testb %bpl, %bpl
jne 0x5057
jmp 0x506a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4230
jmp 0x506a
jmp 0x5067
jmp 0x5067
jmp 0x5067
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4410
movq %r14, %rdi
callq 0x44b0
// File: /workspace/github_cpp_makefile_star2_O2/KinderRiven[P]rdma_demo/server.cc
// Function: sock_read(int, void*, unsigned long)
size_t sock_read(int sock_fd, void* buffer, size_t len)
{
    size_t nr, tot_read;
    char* buf = (char*)buffer; // avoid pointer arithmetic on void pointer
    tot_read = 0;

    while (len != 0 && (nr = read(sock_fd, buf, len)) != 0) {
        if (nr < 0) {
            if (errno == EINTR) {
                continue;
            } else {
                return -1;
            }
        }
        len -= nr;
        buf += nr;
        tot_read += nr;
    }

    return tot_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r12d
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x1346
movl %r12d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11b0
testq %rax, %rax
je 0x1346
subq %rax, %rbx
addq %rax, %r14
addq %rax, %r15
jmp 0x1323
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/KinderRiven[P]rdma_demo/server.cc
// Function: sock_write(int, void*, unsigned long)
size_t sock_write(int sock_fd, void* buffer, size_t len)
{
    size_t nw, tot_written;
    char* buf = (char*)buffer; // avoid pointer arithmetic on void pointer

    for (tot_written = 0; tot_written < len;) {
        nw = write(sock_fd, buf, len - tot_written);

        if (nw <= 0) {
            if (nw == -1 && errno == EINTR) {
                continue;
            } else {
                return -1;
            }
        }

        tot_written += nw;
        buf += nw;
    }
    return tot_written;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
xorl %ebx, %ebx
pushq $-0x1
popq %r13
movq %r14, %rdx
subq %rbx, %rdx
jbe 0x1392
movl %r12d, %edi
movq %r15, %rsi
callq 0x10b0
testq %rax, %rax
je 0x138f
addq %rax, %rbx
addq %rax, %r15
jmp 0x136f
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]messenger/client.cpp
// Function: main
int main (int argc, char* argv[])
{
    if(argc < 2)
    {
        std::cerr << "Syntax : ./client <server ip address>" << std::endl;
        return 0;
    }

    const char * ip_addres = argv[1];
    const int port_number = 2025;

    int socket_desc;
    struct sockaddr_in server_addr;


    // create socket
    socket_desc = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(socket_desc == -1)
    {
        std::cerr << "Cannot open socket with port number " << port_number << std::endl;
        close(socket_desc);
        return 0;
    }


    bzero((char *) &server_addr, sizeof(server_addr));

    // Set remote server information
	server_addr.sin_addr.s_addr = inet_addr( ip_addres );
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons( port_number );


    if ( connect(socket_desc, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1 )
    {
        std::cerr << "Cannot connect to the server with ip " << ip_addres << std::endl;
        close(socket_desc);
        return 0;
    }


    pthread_t send_thread_id;
    pthread_t recv_thread_id;

    pthread_create(&send_thread_id, NULL, send_thread, (void*)&socket_desc);
    pthread_detach(send_thread_id);

    pthread_create(&recv_thread_id, NULL, recv_thread, (void*)&socket_desc);
    pthread_join(recv_thread_id, NULL);

    pthread_exit(NULL);

    return 0;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jg 0x2449
movq 0x3bc0(%rip), %rdi      # 0x5ff0
leaq 0x1bcd(%rip), %rsi      # 0x4004
callq 0x21c0
movq %rax, %rdi
callq 0x2100
jmp 0x24ef
movq 0x8(%rsi), %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
callq 0x2050
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x24bf
movl %eax, %ebp
leaq 0x20(%rsp), %r14
andq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x21e0
movl %eax, 0x4(%r14)
movl $0xe9070002, (%r14)     # imm = 0xE9070002
pushq $0x10
popq %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x2180
cmpl $-0x1, %eax
jne 0x24fa
movq 0x3b54(%rip), %rdi      # 0x5ff0
leaq 0x1bac(%rip), %rsi      # 0x404f
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2100
movl %ebp, %edi
jmp 0x24ea
movq 0x3b2a(%rip), %rdi      # 0x5ff0
leaq 0x1b5d(%rip), %rsi      # 0x402a
callq 0x21c0
movq %rax, %rdi
movl $0x7e9, %esi            # imm = 0x7E9
callq 0x2270
movq %rax, %rdi
callq 0x2100
pushq $-0x1
popq %rdi
callq 0x22c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x49(%rip), %rdx        # 0x254a
leaq 0x18(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x22b0
movq (%rbx), %rdi
callq 0x2150
leaq 0x39e(%rip), %rdx       # 0x28c5
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x22b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x21b0
xorl %edi, %edi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]messenger/./namespace_terminal.hpp
// Function: terminal::Cursor_Previous_Line[abi:cxx11](int)
inline std::string Cursor_Previous_Line( int n = 1 )
	{
		if ( ::terminal_color ) {
			std::ostringstream stringStream;
			stringStream << "\x1B[" << n << "F";
			return stringStream.str();
		} else {
			return "";
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
cmpb $0x1, 0x35d7(%rip)      # 0x6178
jne 0x2bf3
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2230
leaq 0x15c1(%rip), %rsi      # 0x417a
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2270
leaq 0x15ad(%rip), %rsi      # 0x417f
movq %rax, %rdi
callq 0x21c0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2260
leaq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x2c07
leaq 0x150a(%rip), %rsi      # 0x4104
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2cf6
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]messenger/./namespace_terminal.hpp
// Function: terminal::Erase_Line[abi:cxx11](int)
inline std::string Erase_Line( int n = 2 )
	{
		if ( ::terminal_color ) {
			std::ostringstream stringStream;
			stringStream << "\x1B[" << n << "K";
			return stringStream.str();
		} else {
			return "";
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
cmpb $0x1, 0x3538(%rip)      # 0x6178
jne 0x2c92
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2230
leaq 0x1522(%rip), %rsi      # 0x417a
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2270
leaq 0x153a(%rip), %rsi      # 0x41ab
movq %rax, %rdi
callq 0x21c0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2260
leaq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x2ca6
leaq 0x146b(%rip), %rsi      # 0x4104
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2cf6
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]messenger/encode_decode.cpp
// Function: make_encoded_message(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, char*)
void make_encoded_message( const char * dest_name, const char * message_info,
                          const std::string& message, size_t io_buffer_length, char * output )
{
    size_t j = 0;

    for( size_t i = 0; dest_name[i] != 0; ++i )
    {
        output[j] = dest_name[i];
        ++j;
    }

    for( ; j < 100; )
    {
        output[j] = 0x00;
        ++j;
    }

    for(  size_t i = 0; message_info[i] != 0; ++i  )
    {
        output[j] = message_info[i];
        ++j;
    }

    for( ; j < 128; )
    {
        output[j] = 0x00;
        ++j;
    }

    for(auto& c: message)
    {
        output[j] = c;
        ++j;
    }

        for( ; j < io_buffer_length; )
    {
        output[j] = 0x00;
        ++j;
    }

}

// Assembly:
xorl %eax, %eax
movb (%rdi,%rax), %r9b
testb %r9b, %r9b
je 0x3055
movb %r9b, (%r8,%rax)
incq %rax
jmp 0x3043
addq %rax, %r8
cmpq $0x64, %rax
jae 0x306a
movb $0x0, (%r8)
incq %rax
incq %r8
jmp 0x3058
xorl %edi, %edi
movb (%rsi,%rdi), %r9b
testb %r9b, %r9b
je 0x307e
movb %r9b, (%r8,%rdi)
incq %rdi
jmp 0x306c
addq %rdi, %r8
addq %rdi, %rax
cmpq $0x7f, %rax
ja 0x3096
movb $0x0, (%r8)
incq %rax
incq %r8
jmp 0x3084
movq (%rdx), %rsi
movq 0x8(%rdx), %rdi
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x30b1
movb (%rsi,%rdx), %r9b
movb %r9b, (%r8,%rdx)
incq %rdx
jmp 0x309f
addq %rdx, %r8
addq %rdx, %rax
cmpq %rcx, %rax
jae 0x30c8
movb $0x0, (%r8)
incq %rax
incq %r8
jmp 0x30b7
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]messenger/encode_decode.cpp
// Function: print_encoded_message(char const*, unsigned long)
void print_encoded_message( const char * encoded_message, size_t io_buffer_length )
{
    std::cout << std::endl;
    for( size_t i = 0; i < io_buffer_length; ++i )
    {
        if(encoded_message[i] == 0x00){
            std::cout << ".";
        }else{
            std::cout << encoded_message[i];
        }
    }
    std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2d3a(%rip), %r15      # 0x5fc8
movq %r15, %rdi
callq 0x2100
xorl %r13d, %r13d
leaq 0xed8(%rip), %r12       # 0x4178
cmpq %r13, %rbx
je 0x32ca
movb (%r14,%r13), %al
testb %al, %al
je 0x32ba
movsbl %al, %esi
movq %r15, %rdi
callq 0x2200
jmp 0x32c5
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
incq %r13
jmp 0x32a0
movq 0x2cf7(%rip), %rdi      # 0x5fc8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Maker::EndGroup()
Maker& EndGroup() {
			if (_stack.empty()) {
				UserType* new_ut = new UserType("#");

				new_ut->LinkUserType(ut);
				_stack.push_back(new_ut);
				ut = new_ut;

				return *this;
			}
			_stack.pop_back();
			return *this;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x10(%rdi)
je 0x2bc4
addq $-0x8, %rax
movq %rax, 0x18(%rbx)
jmp 0x2c2a
movl $0xb0, %edi
callq 0x21c0
movq %rax, %r14
leaq 0x6531(%rip), %rsi      # 0x9109
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2a64
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3a08
leaq 0x10(%rbx), %r15
leaq 0x10(%rsp), %rdi
callq 0x20d0
leaq 0x30(%rsp), %r12
movq %r14, (%r12)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3bb2
movq %r15, %rdi
movq %r12, %rsi
callq 0x31f6
movq (%r12), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x2c4b
movq %rax, %rbx
movl $0xb0, %esi
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::Maker::NewGroup(clau_parser::Maker&)
Maker& NewGroup(Maker& other) {
			if (this->ut == other.ut) {
				throw "New Group this == other";
			}

			_stack.back()->LinkUserType(other.ut);
			other.ut = nullptr;
			return *this;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rsi), %rsi
cmpq %rsi, 0x8(%rdi)
je 0x2c91
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq -0x8(%rax), %rdi
callq 0x3bb2
andq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x8
popq %rdi
callq 0x20f0
leaq 0x646b(%rip), %rcx      # 0x910b
movq %rcx, (%rax)
movq 0xb316(%rip), %rsi      # 0xdfc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::AddUserTypeItem(clau_parser::UserType&&)
void AddUserTypeItem(UserType&& item) {
			UserType* temp = new UserType(std::move(item.GetName()));

			temp->parent = this;

			ilist.push_back(2);

			userTypeList.push_back(temp);

			useSortedUserTypeList = false;
			useSortedItemList = false;


			{
				temp->itemList = std::move(item.itemList);
				temp->ilist = std::move(item.ilist);
				temp->userTypeList = std::move(item.userTypeList);

				for (size_t i = 0; i < item.GetUserTypeListSize(); ++i) {
					item.userTypeList[i] = nullptr;
				}
				for (size_t i = 0; i < temp->GetUserTypeListSize(); ++i) {
					temp->userTypeList[i]->parent = temp;
				}
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0xb0, %edi
callq 0x21c0
movq %rax, %r12
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3a08
leaq 0x8(%rsp), %r14
movq %r12, (%r14)
movq %r15, 0x28(%r12)
leaq 0x30(%r15), %rdi
leaq 0x14(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x3780
leaq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0x31f6
andw $0x0, 0xa8(%r15)
leaq 0x48(%rbx), %rsi
movq (%r14), %rdi
addq $0x48, %rdi
callq 0x3a56
leaq 0x30(%rbx), %rsi
movq (%r14), %rdi
addq $0x30, %rdi
callq 0x3af0
leaq 0x60(%rbx), %rsi
movq (%r14), %rdi
addq $0x60, %rdi
callq 0x3b60
xorl %eax, %eax
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x39bc
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x399e
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rcx
movq 0x68(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x39e4
movq (%rcx,%rsi,8), %rdi
movq %rax, 0x28(%rdi)
incq %rsi
jmp 0x39d2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xb0, %esi
movq %r12, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::LinkUserType(clau_parser::UserType*)
void LinkUserType(UserType* ut) // friend?
		{
			userTypeList.push_back(ut);
			ilist.push_back(2);
			ut->parent = this;

			useSortedUserTypeList = false;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %rsi, (%r14)
addq $0x60, %rdi
movq %r14, %rsi
callq 0x31f6
leaq 0x30(%rbx), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x3780
movq (%r14), %rax
movq %rbx, 0x28(%rax)
movb $0x0, 0xa9(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::UserType::operator=(clau_parser::UserType&&)
void operator=(UserType&& ut) noexcept {
			if (this == &ut) { return; }

			Type::operator=(ut);
			RemoveUserTypeList();
			Reset2(std::move(ut));
			return;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, %rdi
je 0x4539
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x84b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8b2e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3353
nop
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::operator()(int, char*&, unsigned long*, long*&, unsigned long*)
bool operator() (int thr_num, char*& buffer, size_t* buffer_len, int64_t*& token_arr, size_t* token_arr_len)
		{
			if (pInFile) {
				bool x = Scan(pInFile, thr_num, buffer, buffer_len, token_arr, token_arr_len, use_simd).second > 0;

				return x;
			}
			else {
				bool x = Scan2(const_cast<char*>(str->c_str()), str->size(), thr_num, buffer, buffer_len, token_arr, token_arr_len, use_simd).second > 0;

				return x;
			}
		}

// Assembly:
pushq %rax
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %edx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x4584
movzbl 0x8(%rdi), %r10d
subq $0x8, %rsp
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
movq %rax, %r9
pushq %r10
callq 0x55c4
jmp 0x459f
movq 0x10(%rdi), %rsi
movq (%rsi), %r10
movq 0x8(%rsi), %rsi
movzbl 0x8(%rdi), %r11d
movq %r10, %rdi
pushq %r11
pushq %rax
callq 0x5700
addq $0x10, %rsp
shrq $0x20, %rax
testl %eax, %eax
setg %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::Scan(_IO_FILE*, int, char*&, unsigned long*, long*&, unsigned long*, bool)
static std::pair<bool, int> Scan(FILE* inFile, int thr_num,
			char*& _buffer, size_t* _buffer_len, int64_t*& _token_arr, size_t* _token_arr_len, bool use_simd)
		{
			if (inFile == nullptr) {
				return { false, 0 };
			}

			std::string temp;
			char* buffer = nullptr;
			size_t file_length;

			{
				fseek(inFile, 0, SEEK_END);
				size_t length = ftell(inFile);
				fseek(inFile, 0, SEEK_SET);

				Utility::BomType x = Utility::ReadBom(inFile);

				//	clau_parser::Out << "length " << length << "\n";
				if (x == Utility::BomType::UTF_8) {
					length = length - 3;
				}

				file_length = length;
				buffer = new char[file_length + 1]; // 

				//int a = clock();
				// read data as a block:
				fread(buffer, sizeof(char), file_length, inFile);
				//int b = clock();
				////std::cout << b - a << " " << file_length <<"\n";

				buffer[file_length] = '\0';

				{
					int64_t* token_arr;
					size_t token_arr_size;

					if (thr_num == 1) {
						Scanning(buffer, file_length, token_arr, token_arr_size);
					}
					else {
						ScanningNew(buffer, file_length, thr_num, token_arr, token_arr_size, use_simd);
					}

					_buffer = buffer;
					_token_arr = token_arr;
					*_token_arr_len = token_arr_size;
					*_buffer_len = file_length;
				}
			}

			return{ true, 1 };
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x5676
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r9, 0x20(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x21f0
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
movq %r14, %rdi
callq 0x57f8
leaq -0x3(%r15), %rbx
testl %eax, %eax
cmovneq %r15, %rbx
leaq 0x1(%rbx), %rdi
callq 0x2040
movq %rax, %r15
pushq $0x1
popq %r13
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x22a0
movb $0x0, (%r15,%rbx)
cmpl $0x1, %ebp
jne 0x567d
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x587a
jmp 0x569b
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x56d4
movzbl 0x80(%rsp), %r9d
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5af8
movq %r15, (%r12)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rsp), %rax
movq %rbx, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x20d0
movabsq $0x100000000, %rax      # imm = 0x100000000
orq %rax, %r13
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56eb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ClauParser[P]ClauParser/./include/clau_parser.h
// Function: clau_parser::InFileReserver::Scan2(char*, unsigned long, int, char*&, unsigned long*, long*&, unsigned long*, bool)
static std::pair<bool, int> Scan2(char* str, size_t len, int thr_num,
			char*& _buffer, size_t* _buffer_len, int64_t*& _token_arr, size_t* _token_arr_len, bool use_simd)
		{
			if (str == nullptr) {
				return { false, 0 };
			}

			std::string temp;
			char* buffer = str;
			size_t file_length;

			{
				size_t length = len;

				Utility::BomType x = Utility::ReadBom(str, length);

				//	clau_parser::Out << "length " << length << "\n";
				if (x == Utility::BomType::UTF_8) {
					length = length - 3;
				}

				file_length = length;

				buffer[file_length] = '\0';

				{
					int64_t* token_arr;
					size_t token_arr_size;

					if (thr_num == 1) {
						Scanning(buffer, file_length, token_arr, token_arr_size);
					}
					else {
						ScanningNew(buffer, file_length, thr_num, token_arr, token_arr_size, use_simd);
					}

					_buffer = buffer;
					_token_arr = token_arr;
					*_token_arr_len = token_arr_size;
					*_buffer_len = file_length;
				}
			}

			return{ true, 1 };
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x576b
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %r14d, %r14d
movb %r14b, (%rax)
callq 0x69d0
leaq -0x3(%rbx), %r13
testl %eax, %eax
cmovneq %rbx, %r13
movb %r14b, (%r12,%r13)
cmpl $0x1, %ebp
jne 0x5771
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
callq 0x587a
jmp 0x5791
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x57d0
movzbl 0x88(%rsp), %r9d
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r12, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x5af8
movq 0x80(%rsp), %rax
movq %r12, (%r15)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %r13, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x20d0
movabsq $0x100000000, %rcx      # imm = 0x100000000
pushq $0x1
popq %rax
orq %rcx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
nop