LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0xdb79(%rip), %rax      # 0x15cb8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
movq %rdi, -0x38(%rbp)
callq 0x8b00
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x1b7e490(%rcx), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x8234
movl $0x0, -0x18(%rbp)
cmpl $0xe10, -0x18(%rbp)     # imm = 0xE10
jge 0x8224
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq %rax, %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rcx
addq $0xdbf250, %rcx         # imm = 0xDBF250
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x14(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8191
jmp 0x8226
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x817d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
callq 0x8b70
jmp 0x8251
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8b60
movq -0x20(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x1b7e490(%rcx), %ecx
movl %ecx, 0x1b7e490(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3e8, -0x14(%rbp)     # imm = 0x3E8
jge 0x8372
movl $0x0, -0x18(%rbp)
cmpl $0xe10, -0x18(%rbp)     # imm = 0xE10
jge 0x8362
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
movq %rax, %rcx
addq $0x10, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq -0x10(%rbp), %rcx
addq $0xdbf250, %rcx         # imm = 0xDBF250
movslq -0x14(%rbp), %rdx
imulq $0x3840, %rdx, %rdx     # imm = 0x3840
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x14(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82cf
jmp 0x8364
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x82bb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1b7e498, %rsi        # imm = 0x1B7E498
addq $0x1b7e498, %rdi        # imm = 0x1B7E498
callq 0x8b70
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x1b7e4a4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x88ad
movq -0x60(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x1b7e4b0(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0xa, %rdi
movq -0x10(%rbp), %rsi
callq 0x32f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x889d
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x44(%rbp), %rdi
shlq $0x0, %rdi
callq 0x32e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x10, %rsi
movslq -0x44(%rbp), %rdx
callq 0x3180
movq -0x60(%rbp), %rax
movl 0x1b7e4a4(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x1b7e4b0(%rax,%rcx,8), %rdx
movslq -0x34(%rbp), %rcx
movq %rdx, 0x1b7e4b0(%rax,%rcx,8)
movl 0x1b7e4a4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1b7e4a4(%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %edx
callq *%rax
movq -0x50(%rbp), %rdi
callq 0x32b0
movq -0x60(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x54(%rbp)
movq 0x8(%rax), %rdi
callq 0xae20
movl %eax, -0x58(%rbp)
cmpl $0x3e8, -0x54(%rbp)     # imm = 0x3E8
jg 0x882f
jmp 0x884e
leaq 0x695c(%rip), %rdi      # 0xf192
leaq 0x68d4(%rip), %rsi      # 0xf111
movl $0xa9, %edx
leaq 0x695a(%rip), %rcx      # 0xf1a3
callq 0x3120
cmpl $0xe10, -0x58(%rbp)     # imm = 0xE10
jge 0x8859
jmp 0x8878
leaq 0x68f4(%rip), %rdi      # 0xf154
leaq 0x68aa(%rip), %rsi      # 0xf111
movl $0xaa, %edx
leaq 0x6930(%rip), %rcx      # 0xf1a3
callq 0x3120
movq -0x60(%rbp), %rax
addq $0xdbf250, %rax         # imm = 0xDBF250
movslq -0x54(%rbp), %rcx
imulq $0x3840, %rcx, %rcx     # imm = 0x3840
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x889f
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8754
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
movl $0xa, %esi
callq 0x3320
cltq
movq %rax, -0x68(%rbp)
movq 0xd322(%rip), %rax      # 0x15fd8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x65b9(%rip), %rsi      # 0xf27c
movb $0x0, %al
callq 0x3300
leaq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
movl %eax, %esi
movl $0x2, %edx
callq 0x3360
movl $0x1, %edi
callq 0x32c0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x8d37
movq 0xd2bd(%rip), %rdi      # 0x15fd0
leaq 0x6575(%rip), %rsi      # 0xf28f
callq 0x31f0
movq %rax, %rdi
movq 0xd297(%rip), %rsi      # 0x15fc0
callq 0x3230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8da8
movl $0x48, %edi
callq 0x3210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x8e90
jmp 0x8d5a
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8dc0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8d83
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8da8
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x3220
jmp 0x8db1
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x31c0
movl %eax, %edi
callq 0x31e0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x2bc, 0x28(%rax)      # imm = 0x2BC
jge 0x8e34
movq -0x20(%rbp), %rdi
callq 0x9310
movq -0x20(%rbp), %rdi
callq 0x95b0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x8dfe
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x88c0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x40(%rcx), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x8e7d
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3b40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8e48
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xcafd(%rip), %rcx      # 0x15d18
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x923a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9256
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x40(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x929e
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9291
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x9293
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x925d
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x32b0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x92cb
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0x3220
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4795(%rip), %rsi      # 0xf4d8
callq 0x32a0
movq -0x28(%rbp), %rdx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x477f(%rip), %rsi      # 0xf4da
movb $0x0, %al
callq 0x33e0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x4, %rdx
leaq 0x4771(%rip), %rsi      # 0xf4e6
movb $0x0, %al
callq 0x33e0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x20, %rdx
leaq 0x476b(%rip), %rsi      # 0xf4fa
movb $0x0, %al
callq 0x33e0
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0x8, %rdx
leaq 0x475f(%rip), %rsi      # 0xf508
movb $0x0, %al
callq 0x33e0
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl %ecx, 0x18(%rax)
movsd 0x470f(%rip), %xmm0     # 0xf4d0
movsd %xmm0, 0x10(%rax)
movl $0xfa0, 0x1c(%rax)      # imm = 0xFA0
movl $0x0, 0x28(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jae 0xae0d
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl 0x2c(%rax), %ecx
movl %ecx, 0x2c(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xade9
movq -0x18(%rbp), %rdi
callq 0x3200
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/test/pairs_and_sequences.cpp
// Function: nested_pair_print()
TEST(nested_pair_print) {
  map<pair<string, string>, int> m1;
  map<pair<string, string>, int> m2;
  m1[{ "hello", "world" }] = 3;
  m1[{ "foo", "bar" }] = -1;
  m2[{ "hello", "world" }] = 3;
  m2[{ "bar", "foo" }] = -1;
  ASSERT_EQUAL(m1, m2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
leaq -0x30(%rbp), %rdi
callq 0xb230
leaq -0x60(%rbp), %rdi
callq 0xb230
leaq 0xcc64(%rip), %rsi      # 0x11088
leaq 0xcc78(%rip), %rdx      # 0x110a3
leaq -0xa0(%rbp), %rdi
callq 0xb330
jmp 0x4439
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xb250
movq %rax, -0x178(%rbp)
jmp 0x4452
movq -0x178(%rbp), %rax
movl $0x3, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0xb410
leaq 0xcc63(%rip), %rsi      # 0x110d5
leaq 0xcc60(%rip), %rdx      # 0x110d9
leaq -0xf0(%rbp), %rdi
callq 0xb440
jmp 0x4487
leaq -0x30(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0xb250
movq %rax, -0x180(%rbp)
jmp 0x44a0
movq -0x180(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq -0xf0(%rbp), %rdi
callq 0xb410
leaq 0xcbc8(%rip), %rsi      # 0x11088
leaq 0xcbdc(%rip), %rdx      # 0x110a3
leaq -0x130(%rbp), %rdi
callq 0xb330
jmp 0x44d5
leaq -0x60(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0xb250
movq %rax, -0x188(%rbp)
jmp 0x44ee
movq -0x188(%rbp), %rax
movl $0x3, (%rax)
leaq -0x130(%rbp), %rdi
callq 0xb410
leaq 0xcbcb(%rip), %rsi      # 0x110d9
leaq 0xcbc0(%rip), %rdx      # 0x110d5
leaq -0x170(%rbp), %rdi
callq 0xb440
jmp 0x4523
leaq -0x60(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0xb250
movq %rax, -0x190(%rbp)
jmp 0x453c
movq -0x190(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq -0x170(%rbp), %rdi
callq 0xb410
leaq 0xcb4d(%rip), %rcx      # 0x110a9
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x2c, %edx
callq 0xb520
jmp 0x4570
leaq -0x60(%rbp), %rdi
callq 0xb690
leaq -0x30(%rbp), %rdi
callq 0xb690
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x461d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xb410
jmp 0x461d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0xb410
jmp 0x461d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x130(%rbp), %rdi
callq 0xb410
jmp 0x461d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x170(%rbp), %rdi
callq 0xb410
leaq -0x60(%rbp), %rdi
callq 0xb690
leaq -0x30(%rbp), %rdi
callq 0xb690
movq -0xa8(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: 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>>, int>(std::ostream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int> 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x71d0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x32d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x6c10
movq -0x8(%rbp), %rdi
movl $0x29, %esi
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x5210
movq -0x38(%rbp), %rdi
callq 0x7850
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x7a80
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x64b3
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7b20
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7ab0
jmp 0x648c
jmp 0x648e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6454
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x78e0
jmp 0x64d0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x64c6
movq -0x38(%rbp), %rdi
callq 0x78e0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x56d0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x7a80
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x6556
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b20
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7b40
testb $0x1, %al
jne 0x653c
jmp 0x6546
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
jmp 0x6548
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6500
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x51e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x2ec31(%rip), %rsi     # 0x351a4
leaq -0x38(%rbp), %rdi
callq 0x7450
jmp 0x657e
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7560
jmp 0x658d
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x474e4(%rip), %rsi     # 0x4da80
leaq 0x105d(%rip), %rdx      # 0x7600
callq 0x5690
jmp 0x65e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x65cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5270
testb $0x1, -0x45(%rbp)
jne 0x65d5
jmp 0x65de
movq -0x60(%rbp), %rdi
callq 0x5300
jmp 0x65e0
movq -0x40(%rbp), %rdi
callq 0x56d0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x135d
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1366
jmp 0x13ac
cmpq $0x0, -0x28(%rbp)
jae 0x1383
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1379
jmp 0x1333
movq $-0x1, -0x8(%rbp)
jmp 0x13b4
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1333
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1443
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x30(%rbp), %rdx
callq 0x10b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
ja 0x1429
cmpq $-0x1, -0x28(%rbp)
jne 0x141f
callq 0x1040
cmpl $0x4, (%rax)
jne 0x141f
jmp 0x13e3
movq $-0x1, -0x8(%rbp)
jmp 0x144b
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x13e3
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KinderRiven[P]rdma_demo/server.cc
// Function: main
int main(int argc, char** argv)
{
    rdma_context_t _ctx;
    memset(&_ctx, 0, sizeof(_ctx));
    _ctx.num_qps = 1;
    _ctx.ib_buf_size = 2UL * 1024 * 1024;

    rdma_init(&_ctx);
    connect_qpair(&_ctx);

#if 1
    int tmp;
    printf("[addr:%llx][data:%llx]\n", (uint64_t*)_ctx.local_qp->addr, *(uint64_t*)_ctx.local_qp->addr);
    while (true) {
        scanf("%d", &tmp);
        if (tmp) {
            printf("[addr:%llx][data:%llx]\n", (uint64_t*)_ctx.local_qp->addr, *(uint64_t*)_ctx.local_qp->addr);
        } else {
            break;
        }
    }
#endif
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5a0, %rsp            # imm = 0x5A0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x598(%rbp), %rdi
xorl %esi, %esi
movl $0x588, %edx            # imm = 0x588
callq 0x10c0
movl $0x1, -0x28(%rbp)
movq $0x200000, -0x20(%rbp)  # imm = 0x200000
leaq -0x598(%rbp), %rdi
callq 0x1520
leaq -0x598(%rbp), %rdi
callq 0x1550
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x1b75(%rip), %rdi      # 0x3040
movb $0x0, %al
callq 0x1050
leaq 0x1b7f(%rip), %rdi      # 0x3058
leaq -0x59c(%rbp), %rsi
movb $0x0, %al
callq 0x1130
cmpl $0x0, -0x59c(%rbp)
je 0x1511
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x1b38(%rip), %rdi      # 0x3040
movb $0x0, %al
callq 0x1050
jmp 0x1513
jmp 0x1515
jmp 0x14d2
xorl %eax, %eax
addq $0x5a0, %rsp            # imm = 0x5A0
popq %rbp
retq
// File: KinderRiven[P]rdma_demo/server.cc
// Function: modify_qp_to_init(ibv_qp*)
static int modify_qp_to_init(struct ibv_qp* qp)
{
    struct ibv_qp_attr attr;
    int flags;

    memset(&attr, 0, sizeof(attr));
    attr.qp_state = IBV_QPS_INIT;
    attr.port_num = 1;
    attr.pkey_index = 0;
    attr.qp_access_flags = IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_READ | IBV_ACCESS_REMOTE_WRITE;
    flags = IBV_QP_STATE | IBV_QP_PKEY_INDEX | IBV_QP_PORT | IBV_QP_ACCESS_FLAGS;
    return ibv_modify_qp(qp, &attr, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x10c0
movl $0x1, -0x98(%rbp)
movb $0x1, -0x17(%rbp)
movw $0x0, -0x20(%rbp)
movl $0x7, -0x78(%rbp)
movl $0x39, -0x9c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x9c(%rbp), %edx
leaq -0x98(%rbp), %rsi
callq 0x11e0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: KinderRiven[P]rdma_demo/server.cc
// Function: modify_qp_to_rtr(ibv_qp*, unsigned int, unsigned short, unsigned char*)
static int modify_qp_to_rtr(struct ibv_qp* qp, uint32_t remote_qpn, uint16_t dlid, uint8_t* dgid)
{
    struct ibv_qp_attr attr;
    int flags;
    memset(&attr, 0, sizeof(attr));

    attr.qp_state = IBV_QPS_RTR;
    attr.path_mtu = IBV_MTU_256;
    attr.dest_qp_num = remote_qpn;
    attr.rq_psn = 0;
    attr.max_dest_rd_atomic = 1;
    attr.min_rnr_timer = 0x12;
    attr.ah_attr.is_global = 0;
    attr.ah_attr.dlid = dlid;
    attr.ah_attr.sl = 0;
    attr.ah_attr.src_path_bits = 0;
    attr.ah_attr.port_num = 1;

    attr.ah_attr.is_global = 1;
    attr.ah_attr.port_num = 1;
    memcpy(&attr.ah_attr.grh.dgid, dgid, 16);
    attr.ah_attr.grh.flow_label = 0;
    attr.ah_attr.grh.hop_limit = 1;
    attr.ah_attr.grh.sgid_index = 2; // important
    attr.ah_attr.grh.traffic_class = 0;

    flags = IBV_QP_STATE | IBV_QP_AV | IBV_QP_PATH_MTU | IBV_QP_DEST_QPN | IBV_QP_RQ_PSN | IBV_QP_MAX_DEST_RD_ATOMIC | IBV_QP_MIN_RNR_TIMER;
    return ibv_modify_qp(qp, &attr, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x10c0
movl $0x2, -0xa8(%rbp)
movl $0x1, -0xa0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl $0x0, -0x94(%rbp)
movb $0x1, -0x29(%rbp)
movb $0x12, -0x28(%rbp)
movb $0x0, -0x53(%rbp)
movw -0xe(%rbp), %ax
movw %ax, -0x58(%rbp)
movb $0x0, -0x56(%rbp)
movb $0x0, -0x55(%rbp)
movb $0x1, -0x52(%rbp)
movb $0x1, -0x53(%rbp)
movb $0x1, -0x52(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x60(%rbp)
movb $0x1, -0x5b(%rbp)
movb $0x2, -0x5c(%rbp)
movb $0x0, -0x5a(%rbp)
movl $0x129181, -0xac(%rbp)  # imm = 0x129181
movq -0x8(%rbp), %rdi
movl -0xac(%rbp), %edx
leaq -0xa8(%rbp), %rsi
callq 0x11e0
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: KinderRiven[P]rdma_demo/server.cc
// Function: modify_qp_to_rts(ibv_qp*)
static int modify_qp_to_rts(struct ibv_qp* qp)
{
    int flags;
    struct ibv_qp_attr attr;
    memset(&attr, 0, sizeof(attr));

    attr.qp_state = IBV_QPS_RTS;
    attr.timeout = 12; // 18
    attr.retry_cnt = 6;
    attr.rnr_retry = 0;
    attr.sq_psn = 0;
    attr.max_rd_atomic = 1;

    flags = IBV_QP_STATE | IBV_QP_TIMEOUT | IBV_QP_RETRY_CNT | IBV_QP_RNR_RETRY | IBV_QP_SQ_PSN | IBV_QP_MAX_QP_RD_ATOMIC;
    return ibv_modify_qp(qp, &attr, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x10c0
movl $0x3, -0xa0(%rbp)
movb $0xc, -0x1e(%rbp)
movb $0x6, -0x1d(%rbp)
movb $0x0, -0x1c(%rbp)
movl $0x0, -0x88(%rbp)
movb $0x1, -0x22(%rbp)
movl $0x12e01, -0xc(%rbp)    # imm = 0x12E01
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0xa0(%rbp), %rsi
callq 0x11e0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1a8(%rbp)
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
testb $0x1, 0x5e36(%rip)      # 0x9220
je 0x348f
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x2320
movq -0x1b8(%rbp), %rdi
leaq 0x2d69(%rip), %rsi      # 0x617a
callq 0x2220
movq %rax, -0x1b0(%rbp)
jmp 0x341f
movq -0x1b0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2380
movq %rax, -0x1c0(%rbp)
jmp 0x3437
movq -0x1c0(%rbp), %rdi
leaq 0x2d3a(%rip), %rsi      # 0x617f
callq 0x2220
jmp 0x344c
movq -0x1a8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2260
jmp 0x3461
leaq -0x188(%rbp), %rdi
callq 0x2060
jmp 0x34ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2060
jmp 0x34fc
leaq -0x195(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x23b0
movq -0x1a8(%rbp), %rdi
movq -0x1c8(%rbp), %rdx
leaq 0x2c4d(%rip), %rsi      # 0x6104
callq 0x3930
jmp 0x34be
leaq -0x195(%rbp), %rdi
callq 0x2290
jmp 0x34ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x195(%rbp), %rdi
callq 0x2290
jmp 0x34fc
movq -0x1a0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x2390
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1a8(%rbp)
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
testb $0x1, 0x5ce6(%rip)      # 0x9220
je 0x35df
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x2320
movq -0x1b8(%rbp), %rdi
leaq 0x2c19(%rip), %rsi      # 0x617a
callq 0x2220
movq %rax, -0x1b0(%rbp)
jmp 0x356f
movq -0x1b0(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2380
movq %rax, -0x1c0(%rbp)
jmp 0x3587
movq -0x1c0(%rbp), %rdi
leaq 0x2c16(%rip), %rsi      # 0x61ab
callq 0x2220
jmp 0x359c
movq -0x1a8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2260
jmp 0x35b1
leaq -0x188(%rbp), %rdi
callq 0x2060
jmp 0x363c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2060
jmp 0x364c
leaq -0x195(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x23b0
movq -0x1a8(%rbp), %rdi
movq -0x1c8(%rbp), %rdx
leaq 0x2afd(%rip), %rsi      # 0x6104
callq 0x3930
jmp 0x360e
leaq -0x195(%rbp), %rdi
callq 0x2290
jmp 0x363c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x195(%rbp), %rdi
callq 0x2290
jmp 0x364c
movq -0x1a0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x2390
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x466d
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x462c
jmp 0x466f
cmpq $0x64, -0x30(%rbp)
jae 0x4690
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x466f
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x46d9
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x4698
jmp 0x46db
cmpq $0x80, -0x30(%rbp)
jae 0x46ff
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x46db
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2210
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x23e0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4c30
testb $0x1, %al
jne 0x4734
jmp 0x4769
leaq -0x50(%rbp), %rdi
callq 0x4c70
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movb (%rax), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4c90
jmp 0x4721
jmp 0x476b
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x478f
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x476b
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x4421(%rip), %rdi      # 0x8fc8
movq 0x440a(%rip), %rsi      # 0x8fb8
callq 0x2270
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4c13
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x4beb
movq 0x43eb(%rip), %rdi      # 0x8fc8
leaq 0x1594(%rip), %rsi      # 0x6178
callq 0x2220
jmp 0x4c03
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x43ce(%rip), %rdi      # 0x8fc8
movsbl (%rax,%rcx), %esi
callq 0x22d0
jmp 0x4c05
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4bbb
movq 0x43ae(%rip), %rdi      # 0x8fc8
movq 0x4397(%rip), %rsi      # 0x8fb8
callq 0x2270
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x8750
testb $0x1, %al
jne 0x47d5
jmp 0x48c7
movl $0xb0, %edi
callq 0x3230
movq %rax, (%rsp)
movb $0x1, 0x1b(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33e0
movq 0x8(%rsp), %rdx
leaq 0x17c54(%rip), %rsi     # 0x1c457
leaq 0x30(%rsp), %rdi
callq 0x44e0
jmp 0x480f
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7970
jmp 0x481f
movb $0x0, 0x1b(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3160
leaq 0x2f(%rsp), %rdi
callq 0x3270
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x87a0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x50(%rsp), %rsi
callq 0x5530
movq 0x10(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x60(%rsp)
jmp 0x48df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x48a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3160
leaq 0x2f(%rsp), %rdi
callq 0x3270
testb $0x1, 0x1b(%rsp)
jne 0x48b7
jmp 0x48c5
movq (%rsp), %rdi
movl $0xb0, %esi
callq 0x3240
jmp 0x48e9
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x8800
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x494d
movl $0x8, %edi
callq 0x3120
movq %rax, %rdi
leaq 0x17b1f(%rip), %rax     # 0x1c459
movq %rax, (%rdi)
movq 0x22674(%rip), %rsi     # 0x26fb8
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0x5f80
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x87a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq $0x0, 0x8(%rcx)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0xb0, %edi
callq 0x3230
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7960
movq %rax, 0x28(%rsp)
jmp 0x7778
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x7970
jmp 0x7789
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rdi, 0x28(%rax)
addq $0x30, %rdi
movl $0x2, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x6110
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
leaq 0x50(%rsp), %rsi
callq 0x5530
movq 0x18(%rsp), %rax
movb $0x0, 0xa9(%rax)
movb $0x0, 0xa8(%rax)
movq 0x58(%rsp), %rsi
addq $0x48, %rsi
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
callq 0x7a10
movq 0x58(%rsp), %rsi
addq $0x30, %rsi
movq 0x50(%rsp), %rdi
addq $0x30, %rdi
callq 0x7a50
movq 0x58(%rsp), %rsi
addq $0x60, %rsi
movq 0x50(%rsp), %rdi
addq $0x60, %rdi
callq 0x7a90
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x7940
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x7895
movq 0x58(%rsp), %rdi
addq $0x60, %rdi
movq 0x38(%rsp), %rsi
callq 0x7ad0
movq $0x0, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x782b
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0xb0, %esi
callq 0x3240
jmp 0x78fb
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7940
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x78f6
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
addq $0x60, %rdi
movq 0x30(%rsp), %rsi
callq 0x7ad0
movq (%rsp), %rcx
movq (%rax), %rax
movq %rcx, 0x28(%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x789e
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x60, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5530
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movl $0x2, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x6110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, 0x28(%rcx)
movb $0x0, 0xa9(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
jne 0x9da0
jmp 0x9dcd
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x17bb0
jmp 0x9db0
movq (%rsp), %rdi
callq 0x186b0
jmp 0x9dbb
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ad80
jmp 0x9dcb
jmp 0x9dcd
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x5c50
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, (%rax)
je 0x9e60
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x64(%rsp), %esi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0xca00
movq %rax, 0x34(%rsp)
cmpl $0x0, 0x38(%rsp)
setg %al
andb $0x1, %al
movb %al, 0x3f(%rsp)
movb 0x3f(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x9edb
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x30d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rdi
callq 0x3180
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rax
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %r9
movq 0x40(%rsp), %r10
movb 0x8(%rax), %al
andb $0x1, %al
movq %r10, (%rsp)
movzbl %al, %eax
movl %eax, 0x8(%rsp)
callq 0xcc70
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x2c(%rsp)
setg %al
andb $0x1, %al
movb %al, 0x33(%rsp)
movb 0x33(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)