LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zkl94[P]distributed-key-value-store/Application.cpp
// Function: Application::~Application()
Application::~Application() {
	delete log;
	delete en;
	delete en1;
	for ( int i = 0; i < par->EN_GPSZ; i++ ) {
		delete mp1[i];
		delete mp2[i];
	}
	free(mp1);
	free(mp2);
	delete par;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x2a0f5(%rip), %rcx     # 0x35cb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbbda
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 0xbbf6
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbc12
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x50(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0xbc8b
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xbc4d
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbc7e
movq -0x40(%rbp), %rdi
callq 0x19f40
movq -0x40(%rbp), %rdi
movl $0xc0, %esi
callq 0x4320
jmp 0xbc80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbc19
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x43e0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x43e0
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xbcc5
movq -0x48(%rbp), %rdi
movl $0x38, %esi
callq 0x4320
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0x10750
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Application.cpp
// Function: Application::findARandomNodeThatIsAlive()
int Application::findARandomNodeThatIsAlive() {
	int number;
	do {
		number = (rand()%par->EN_GPSZ);
	}while (mp2[number]->getMemberNode()->bFailed);
	return number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x40e0
movq -0x18(%rbp), %rcx
movq 0x50(%rcx), %rcx
cltd
idivl 0x18(%rcx)
movl %edx, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10730
testb $0x1, 0x10(%rax)
jne 0x10434
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logCreateSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logCreateSuccess(Address * address, bool isCoordinator, int transID, string key, string value){
	static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: create success at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), value.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14502
leaq 0x1346c(%rip), %rsi     # 0x27947
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x144e6
jmp 0x14516
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x145c8
leaq 0x1344a(%rip), %rsi     # 0x27953
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14514
jmp 0x14516
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x74(%rbp)
jmp 0x14538
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4140
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x29c41(%rip), %rdi     # 0x3e1c0
movq %rdi, -0x90(%rbp)
leaq 0x133cd(%rip), %rsi     # 0x2795a
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x145b6
leaq -0x48(%rbp), %rdi
callq 0x41e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logReadSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logReadSuccess(Address * address, bool isCoordinator, int transID, string key, string value){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: read success at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), value.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14652
leaq 0x1331c(%rip), %rsi     # 0x27947
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14636
jmp 0x14666
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x14718
leaq 0x132fa(%rip), %rsi     # 0x27953
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14664
jmp 0x14666
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x74(%rbp)
jmp 0x14688
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4140
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x29b61(%rip), %rdi     # 0x3e230
movq %rdi, -0x90(%rbp)
leaq 0x132b9(%rip), %rsi     # 0x27996
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14706
leaq -0x48(%rbp), %rdi
callq 0x41e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logUpdateSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logUpdateSuccess(Address * address, bool isCoordinator, int transID, string key, string newValue){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: update success at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), newValue.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x147a2
leaq 0x131cc(%rip), %rsi     # 0x27947
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14786
jmp 0x147b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x14868
leaq 0x131aa(%rip), %rsi     # 0x27953
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x147b4
jmp 0x147b6
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x74(%rbp)
jmp 0x147d8
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4140
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x29a81(%rip), %rdi     # 0x3e2a0
movq %rdi, -0x90(%rbp)
leaq 0x131a3(%rip), %rsi     # 0x279d0
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14856
leaq -0x48(%rbp), %rdi
callq 0x41e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logDeleteSuccess(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logDeleteSuccess(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: delete success at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x148ea
leaq 0x13084(%rip), %rsi     # 0x27947
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x148ce
jmp 0x148fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41e0
jmp 0x14987
leaq 0x13062(%rip), %rsi     # 0x27953
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x148fc
jmp 0x148fe
leaq -0x40(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x64(%rbp)
jmp 0x14920
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x299c6(%rip), %rdi     # 0x3e310
movq %rdi, -0x80(%rbp)
leaq 0x130b7(%rip), %rsi     # 0x27a0c
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14975
leaq -0x40(%rbp), %rdi
callq 0x41e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4550
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logCreateFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logCreateFail(Address * address, bool isCoordinator, int transID, string key, string value){
	static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: create fail at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), value.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14a02
leaq 0x12f6c(%rip), %rsi     # 0x27947
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x149e6
jmp 0x14a16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x14ac8
leaq 0x12f4a(%rip), %rsi     # 0x27953
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14a14
jmp 0x14a16
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x74(%rbp)
jmp 0x14a38
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4140
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x29901(%rip), %rdi     # 0x3e380
movq %rdi, -0x90(%rbp)
leaq 0x12fb1(%rip), %rsi     # 0x27a3e
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14ab6
leaq -0x48(%rbp), %rdi
callq 0x41e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logReadFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logReadFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: read fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14b4a
leaq 0x12e24(%rip), %rsi     # 0x27947
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x14b2e
jmp 0x14b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41e0
jmp 0x14be7
leaq 0x12e02(%rip), %rsi     # 0x27953
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x14b5c
jmp 0x14b5e
leaq -0x40(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x64(%rbp)
jmp 0x14b80
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x29846(%rip), %rdi     # 0x3e3f0
movq %rdi, -0x80(%rbp)
leaq 0x12ec2(%rip), %rsi     # 0x27a77
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14bd5
leaq -0x40(%rbp), %rdi
callq 0x41e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4550
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logUpdateFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logUpdateFail(Address * address, bool isCoordinator, int transID, string key, string newValue){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: update fail at time %d, transID=%d, key=%s, value=%s", str.c_str(), par->getcurrtime(), transID, key.c_str(), newValue.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r9, -0x70(%rbp)
movq %r8, -0x68(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14c62
leaq 0x12d0c(%rip), %rsi     # 0x27947
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14c46
jmp 0x14c76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x14d28
leaq 0x12cea(%rip), %rsi     # 0x27953
leaq -0x48(%rbp), %rdi
callq 0x4450
jmp 0x14c74
jmp 0x14c76
leaq -0x48(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x74(%rbp)
jmp 0x14c98
movq -0x68(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x9c(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4140
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %ecx
movl -0x9c(%rbp), %r8d
movq -0x98(%rbp), %r9
movq %rax, %rsi
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x29781(%rip), %rdi     # 0x3e460
movq %rdi, -0x90(%rbp)
leaq 0x12db7(%rip), %rsi     # 0x27aa4
xorl %eax, %eax
movb %al, -0x81(%rbp)
callq 0x40a0
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rdx
movb -0x81(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14d16
leaq -0x48(%rbp), %rdi
callq 0x41e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/Log.cpp
// Function: Log::logDeleteFail(Address*, bool, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Log::logDeleteFail(Address * address, bool isCoordinator, int transID, string key){
    static char stdstring[100];
	string str;
	if (isCoordinator)
		str = "coordinator";
	else
		str = "server";
	sprintf(stdstring, "%s: delete fail at time %d, transID=%d, key=%s", str.c_str(), par->getcurrtime(), transID, key.c_str());
    LOG(address, stdstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %r8, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4460
testb $0x1, -0x11(%rbp)
je 0x14daa
leaq 0x12bc4(%rip), %rsi     # 0x27947
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x14d8e
jmp 0x14dbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41e0
jmp 0x14e47
leaq 0x12ba2(%rip), %rsi     # 0x27953
leaq -0x40(%rbp), %rdi
callq 0x4450
jmp 0x14dbc
jmp 0x14dbe
leaq -0x40(%rbp), %rdi
callq 0x4140
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq 0x8(%rax), %rdi
callq 0x15020
movl %eax, -0x64(%rbp)
jmp 0x14de0
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x84(%rbp)
callq 0x4140
movq -0x70(%rbp), %rdx
movl -0x64(%rbp), %ecx
movl -0x84(%rbp), %r8d
movq %rax, %r9
leaq 0x296c6(%rip), %rdi     # 0x3e4d0
movq %rdi, -0x80(%rbp)
leaq 0x12cc8(%rip), %rsi     # 0x27add
xorl %eax, %eax
movb %al, -0x71(%rbp)
callq 0x40a0
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x10(%rbp), %rsi
callq 0x13f70
jmp 0x14e35
leaq -0x40(%rbp), %rdi
callq 0x41e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4550
// File: zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::MP2Node(Member*, Params*, EmulNet*, Log*, Address*)
MP2Node::MP2Node(Member *memberNode, Params *par, EmulNet *emulNet, Log *log, Address *address) {
    this->memberNode = memberNode;
    this->par = par;
    this->emulNet = emulNet;
    this->log = log;
    ht = new HashTable();
    this->memberNode->addr = *address;
    this->lowestTransID = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x10bf0
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0x10bf0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x68(%rbp)
callq 0x10bf0
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x60(%rbp)
callq 0x10bf0
movq -0x50(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1e560
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x38, %edi
callq 0x4310
movq %rax, -0x48(%rbp)
jmp 0x19e92
movq -0x48(%rbp), %rdi
callq 0x238b0
jmp 0x19e9d
movq -0x78(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rsi
movq 0x50(%rax), %rdi
addq $0x8, %rdi
callq 0x150a0
jmp 0x19ebc
movq -0x78(%rbp), %rax
movl $0x0, 0x88(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x19efb
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x4320
movq -0x58(%rbp), %rdi
callq 0x1e580
movq -0x60(%rbp), %rdi
callq 0x10c60
movq -0x68(%rbp), %rdi
callq 0x10c60
movq -0x70(%rbp), %rdi
callq 0x10c60
movq -0x50(%rbp), %rdi
callq 0x10c60
movq -0x38(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReply(int, bool)
void MP2Node::handleReply(int transID, bool success) {
    if (success) {
        transID2Bundle[transID]->success_responses++;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x1bf84
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1eab0
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1bfa4
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1eab0
movq (%rax), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: MP2Node::handleReadReply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void MP2Node::handleReadReply(string value, int transID) {
    if (!value.empty()) {
        transID2Bundle[transID]->success_responses++;
        // @TODO: here we are assuming all responses are latest
        transID2Bundle[transID]->value = value;
    } else {
        transID2Bundle[transID]->failure_responses++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4530
testb $0x1, %al
jne 0x1c027
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1eab0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x90, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1eab0
movq -0x28(%rbp), %rsi
movq (%rax), %rdi
addq $0x30, %rdi
callq 0x4050
jmp 0x1c047
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1eab0
movq (%rax), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zkl94[P]distributed-key-value-store/MP2Node.cpp
// Function: vector_diff(std::vector<Node, std::allocator<Node>>, std::vector<Node, std::allocator<Node>>)
bool vector_diff(vector<Node> old_nodes, vector<Node> new_nodes) {
    for (Node &new_node : new_nodes) {
        for (Node &old_node : old_nodes) {
            if (new_node.nodeHashCode == old_node.nodeHashCode) {
                return true;
            }
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1e5e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1e610
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1edd0
testb $0x1, %al
jne 0x1e4c8
jmp 0x1e54f
leaq -0x28(%rbp), %rdi
callq 0x1ee10
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1e5e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1e610
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1edd0
testb $0x1, %al
jne 0x1e50d
jmp 0x1e53f
leaq -0x48(%rbp), %rdi
callq 0x1ee10
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x58(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1e532
movb $0x1, -0x1(%rbp)
jmp 0x1e553
jmp 0x1e534
leaq -0x48(%rbp), %rdi
callq 0x1ee30
jmp 0x1e4fa
jmp 0x1e541
leaq -0x28(%rbp), %rdi
callq 0x1ee30
jmp 0x1e4b2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: zkl94[P]distributed-key-value-store/./MP2Node.h
// Function: Bundle::Bundle(MessageType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Bundle(MessageType t, string key, string value) {
		this->success_responses = 0;
		this->failure_responses = 0;
		this->t = t;
		this->key = key;
		this->value = value;
		this->iteration = 0; // the times being read by checkMessages
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x38(%rbp)
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x4460
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4460
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
callq 0x4050
jmp 0x1ea1b
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
callq 0x4050
jmp 0x1ea2e
movq -0x48(%rbp), %rax
movl $0x0, 0x50(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x41e0
movq -0x40(%rbp), %rdi
callq 0x41e0
movq -0x28(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/examples/51Peg/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    /* set the RV data file */
    datafile = "51Peg.rv";

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

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xae238(%rip), %rdi     # 0x11b7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x59423(%rip), %rsi     # 0xc69b1
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq 0x4af41(%rip), %rsi     # 0xb84e9
leaq -0x14(%rbp), %rdx
callq 0x6dd40
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6de80
movq -0x6e8(%rbp), %rdi
movl $0x32, %esi
callq 0x6df20
jmp 0x6d5de
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e340
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e340
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: wichtounet[P]articles/src/threads/part3/call_once.cpp
// Function: main
int main(){
    std::thread t1(do_something);
    std::thread t2(do_something);
    std::thread t3(do_something);
    std::thread t4(do_something);

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

    return 0;
}

// Assembly:
subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
leaq -0xe3(%rip), %rsi       # 0x1250
movq %rsi, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x15f0
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x15f0
jmp 0x1353
leaq -0x10a(%rip), %rsi      # 0x1250
leaq 0x18(%rsp), %rdi
callq 0x15f0
jmp 0x1366
leaq -0x11d(%rip), %rsi      # 0x1250
leaq 0x10(%rsp), %rdi
callq 0x15f0
jmp 0x1379
leaq 0x38(%rsp), %rdi
callq 0x10f0
jmp 0x1385
leaq 0x30(%rsp), %rdi
callq 0x10f0
jmp 0x1391
leaq 0x18(%rsp), %rdi
callq 0x10f0
jmp 0x139d
leaq 0x10(%rsp), %rdi
callq 0x10f0
jmp 0x13a9
movl $0x0, 0x44(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16b0
leaq 0x18(%rsp), %rdi
callq 0x16b0
leaq 0x30(%rsp), %rdi
callq 0x16b0
leaq 0x38(%rsp), %rdi
callq 0x16b0
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x143e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x142a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x16b0
leaq 0x18(%rsp), %rdi
callq 0x16b0
leaq 0x30(%rsp), %rdi
callq 0x16b0
leaq 0x38(%rsp), %rdi
callq 0x16b0
movq 0x28(%rsp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/examples/health_echo/main.cpp
// Function: main
int main(int argc, char** argv)
{
    try
    {
        auto interface = nshdev::NetInterfaceFactory::CreateInterfaceFromArgs(argc, argv);
        if(interface == nullptr)
        {
            std::cerr << "Failed to create interface" << std::endl;
            return 2;
        }

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

        nshdev::Scheduler scheduler(*interface);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x3ec0
jmp 0x367c
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3840
testb $0x1, %al
jne 0x368f
jmp 0x36ec
movq 0x7952(%rip), %rdi      # 0xafe8
leaq 0x3967(%rip), %rsi      # 0x7004
callq 0x3220
movq %rax, -0x50(%rbp)
jmp 0x36a8
movq -0x50(%rbp), %rdi
movq 0x78dd(%rip), %rsi      # 0xaf90
callq 0x3250
jmp 0x36ba
movl $0x2, -0x4(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x3749
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3783
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x377a
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3870
leaq -0x18(%rbp), %rdi
callq 0x38b0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x38d0
jmp 0x3710
leaq -0x18(%rbp), %rdi
callq 0x3930
movq %rax, -0x60(%rbp)
jmp 0x371f
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x60d0
jmp 0x372e
leaq -0x40(%rbp), %rdi
callq 0x6100
jmp 0x3739
leaq -0x30(%rbp), %rdi
callq 0x3960
movl $0x0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3980
movl -0x28(%rbp), %eax
testl %eax, %eax
je 0x3760
jmp 0x375b
jmp 0x3823
jmp 0x3805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3960
leaq -0x18(%rbp), %rdi
callq 0x3980
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x382f
movq -0x20(%rbp), %rdi
callq 0x30f0
movq %rax, -0x48(%rbp)
movq 0x7841(%rip), %rdi      # 0xafe8
leaq 0x3871(%rip), %rsi      # 0x701f
callq 0x3220
movq %rax, -0x68(%rbp)
jmp 0x37b9
movq -0x68(%rbp), %rdi
movq 0x77cc(%rip), %rsi      # 0xaf90
callq 0x3250
movq %rax, -0x70(%rbp)
jmp 0x37cf
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3220
movq %rax, -0x78(%rbp)
jmp 0x37ee
movq -0x78(%rbp), %rdi
movq 0x7797(%rip), %rsi      # 0xaf90
callq 0x3250
jmp 0x3800
callq 0x3330
movl $0x1, -0x4(%rbp)
jmp 0x3823
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3330
jmp 0x3821
jmp 0x382f
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3390
movq %rax, %rdi
callq 0x39f0
// File: dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/NetInterfaceFactory.cpp
// Function: nshdev::CreateDpdkIf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::unique_ptr<DpdkNetInterface> CreateDpdkIf(std::string pciAddr)
{
    std::string progName = "CreateDpdkIf";
    std::string dashW = "-w";
    char * argv[] =
    {
        // ugh
        &progName[0],
        &dashW[0],
        &pciAddr[0]
    };

    const uint32_t numInterfaces = DpdkSetup(3, argv);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xc0(%rbp)
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x33a0
movq -0xa8(%rbp), %rdx
leaq 0x33bc(%rip), %rsi      # 0x70b5
leaq -0x30(%rbp), %rdi
callq 0x4100
jmp 0x3d04
leaq -0x31(%rbp), %rdi
callq 0x3270
leaq -0x69(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x33a0
movq -0xc8(%rbp), %rdx
leaq 0x3397(%rip), %rsi      # 0x70c2
leaq -0x68(%rbp), %rdi
callq 0x4100
jmp 0x3d36
leaq -0x69(%rbp), %rdi
callq 0x3270
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x3400
movq %rax, -0xd0(%rbp)
jmp 0x3d55
movq -0xd0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0xe0(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x3400
movq %rax, -0xd8(%rbp)
jmp 0x3d87
movq -0xc0(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x80(%rbp), %rax
movq %rax, -0xf0(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3400
movq %rax, -0xe8(%rbp)
jmp 0x3dbc
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rcx, (%rax)
movl $0x3, %edi
leaq -0x90(%rbp), %rsi
callq 0x5ea0
movl %eax, -0xf4(%rbp)
jmp 0x3de6
movl -0xf4(%rbp), %eax
movl %eax, -0x94(%rbp)
cmpl $0x1, -0x94(%rbp)
jae 0x3e5b
movq -0xb8(%rbp), %rdi
callq 0x41b0
movl $0x1, -0x98(%rbp)
jmp 0x3e84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3270
jmp 0x3eaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x3270
jmp 0x3ea6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3150
jmp 0x3ea6
movq -0xb8(%rbp), %rdi
movl $0x0, -0x9c(%rbp)
leaq -0x9c(%rbp), %rsi
callq 0x41e0
jmp 0x3e7a
movl $0x1, -0x98(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0xb0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: ResolveInterface(char const*)
int ResolveInterface(const char* name)
{
    unsigned i = if_nametoindex(name);
    if( i == 0 )
    {
        std::cerr << "Unknown interface name " << name << std::endl;
	exit(1);
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3090
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x50b6
movq 0x5f63(%rip), %rdi      # 0xafe8
leaq 0x2063(%rip), %rsi      # 0x70ef
callq 0x3220
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
movq 0x5ee9(%rip), %rsi      # 0xaf90
callq 0x3250
movl $0x1, %edi
callq 0x32a0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: dcdolson[P]nsh-sf-devkit/src/NetInterfaceFactory/InterfaceOptions.cpp
// Function: InterfaceOptions::InterfaceOptions(int, char**)
InterfaceOptions::InterfaceOptions(int argc, char** argv):
    m_ifIndex(0),
    m_numArgsConsumed(0)
{
    while(1)
    {
        int option_index = 0;
        int c = getopt_long(argc, argv, "i:", long_options, &option_index);
        if ( c == -1 )
        {
            break;
        }
        switch(c)
        {
        case 'i':
            m_ifIndex = ResolveInterface(optarg);
            break;
        case 'd':
            m_dpdkPciAddress = optarg;
            break;
        case '?':
            Usage(basename(argv[0]));
            exit(1);
        }
    }

    m_numArgsConsumed = optind;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x0, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x32e0
movq -0x38(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0x515b
movl $0x0, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
leaq 0x1fd9(%rip), %rdx      # 0x7149
leaq 0x60b9(%rip), %rcx      # 0xb230
leaq -0x1c(%rbp), %r8
callq 0x3340
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x518e
jmp 0x5225
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x3f, %eax
je 0x5200
jmp 0x519b
movl -0x44(%rbp), %eax
subl $0x64, %eax
je 0x51e5
jmp 0x51a5
movl -0x44(%rbp), %eax
subl $0x69, %eax
jne 0x5220
jmp 0x51af
movq 0x5de2(%rip), %rax      # 0xaf98
movq (%rax), %rdi
callq 0x5060
movl %eax, -0x48(%rbp)
jmp 0x51c3
movq -0x38(%rbp), %rax
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5220
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3150
jmp 0x523b
movq -0x38(%rbp), %rdi
movq 0x5da8(%rip), %rax      # 0xaf98
movq (%rax), %rsi
addq $0x8, %rdi
callq 0x32d0
jmp 0x51fe
jmp 0x5220
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3380
movq %rax, %rdi
callq 0x50c0
jmp 0x5216
movl $0x1, %edi
callq 0x32a0
jmp 0x5159
movq -0x38(%rbp), %rax
movq 0x5d98(%rip), %rcx      # 0xafc8
movl (%rcx), %ecx
movl %ecx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::dump_ll(sockaddr_ll&, unsigned int)
void dump_ll(struct sockaddr_ll& addr, unsigned length)
    {
	printf("addr: len=%d %u/%u index %d hatype %u pkttype %u halen %u addr %02x:%02x:%02x:%02x:%02x:%02x\n",
            length,
	    addr.sll_family,
	    addr.sll_protocol,
	    addr.sll_ifindex,
	    addr.sll_hatype,
	    addr.sll_pkttype,
	    addr.sll_halen,
	    addr.sll_addr[0],
	    addr.sll_addr[1],
	    addr.sll_addr[2],
	    addr.sll_addr[3],
	    addr.sll_addr[4],
	    addr.sll_addr[5]);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rax
movzwl (%rax), %edx
movq -0x30(%rbp), %rax
movzwl 0x2(%rax), %ecx
movq -0x30(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x30(%rbp), %rax
movzwl 0x8(%rax), %r9d
movq -0x30(%rbp), %rax
movzbl 0xa(%rax), %r13d
movq -0x30(%rbp), %rax
movzbl 0xb(%rax), %r12d
movq -0x30(%rbp), %rax
movzbl 0xc(%rax), %r15d
movq -0x30(%rbp), %rax
movzbl 0xd(%rax), %r14d
movq -0x30(%rbp), %rax
movzbl 0xe(%rax), %ebx
movq -0x30(%rbp), %rax
movzbl 0xf(%rax), %r11d
movq -0x30(%rbp), %rax
movzbl 0x10(%rax), %r10d
movq -0x30(%rbp), %rax
movzbl 0x11(%rax), %eax
leaq 0x1e32(%rip), %rdi      # 0x715a
movl %r13d, (%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movb $0x0, %al
callq 0x3040
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::Run()
void PacketSocket::Run()
    {
	uint8_t data[2000];
	LinkAddr from;
	from.length = sizeof(from.addr);
	ssize_t read = recvfrom(m_socket, data, sizeof(data),
				/* flags */ 0,
				reinterpret_cast<struct sockaddr*>(&from.addr),
				&from.length);
	if(read < 0)
	{
	    throw ErrMsg("Error from recvfrom", errno);
	}
	//printf("Send addr: ");
	//dump_ll(from.addr, from.length);
        if( from.addr.sll_pkttype == PACKET_HOST ) // for us
	{
	    PacketRef pref(data, read, &from);
	    Forward(pref);
	}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp            # imm = 0x870
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x858(%rbp)
movl $0x14, -0x7e4(%rbp)
movl 0x10(%rax), %edi
leaq -0x7e0(%rbp), %rsi
leaq -0x7f8(%rbp), %r8
leaq -0x7f8(%rbp), %r9
addq $0x14, %r9
movl $0x7d0, %edx            # imm = 0x7D0
xorl %ecx, %ecx
callq 0x31c0
movq %rax, -0x800(%rbp)
cmpq $0x0, -0x800(%rbp)
jge 0x57d1
movb $0x1, -0x835(%rbp)
movl $0x28, %edi
callq 0x3130
movq %rax, -0x868(%rbp)
leaq -0x821(%rbp), %rdi
movq %rdi, -0x860(%rbp)
callq 0x33a0
movq -0x860(%rbp), %rdx
leaq 0x1ab9(%rip), %rsi      # 0x71e3
leaq -0x820(%rbp), %rdi
callq 0x4100
jmp 0x5738
callq 0x3030
movq -0x868(%rbp), %rdi
movl (%rax), %edx
leaq -0x820(%rbp), %rsi
callq 0x5930
jmp 0x5754
movq -0x868(%rbp), %rdi
movb $0x0, -0x835(%rbp)
leaq 0x5507(%rip), %rsi      # 0xac70
leaq 0x360(%rip), %rdx       # 0x5ad0
callq 0x3360
jmp 0x5828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x830(%rbp)
movl %eax, -0x834(%rbp)
jmp 0x57ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x830(%rbp)
movl %eax, -0x834(%rbp)
leaq -0x820(%rbp), %rdi
callq 0x3150
leaq -0x821(%rbp), %rdi
callq 0x3270
testb $0x1, -0x835(%rbp)
jne 0x57c3
jmp 0x57cf
movq -0x868(%rbp), %rdi
callq 0x31a0
jmp 0x581c
movzbl -0x7ee(%rbp), %eax
cmpl $0x0, %eax
jne 0x5813
leaq -0x7e0(%rbp), %rsi
movq -0x800(%rbp), %rax
movl %eax, %edx
leaq -0x850(%rbp), %rdi
leaq -0x7f8(%rbp), %rcx
callq 0x5b10
movq -0x858(%rbp), %rdi
leaq -0x850(%rbp), %rsi
callq 0x60a0
addq $0x870, %rsp            # imm = 0x870
popq %rbp
retq
movq -0x830(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/src/PacketSocket/PacketSocket.cpp
// Function: nshdev::PacketSocket::ReturnToSender(nshdev::PacketRef&)
void PacketSocket::ReturnToSender(PacketRef& packetRef)
    {
        const LinkAddr& from = static_cast<const LinkAddr&>(*packetRef.From());
	struct sockaddr_ll to = from.addr;
	//printf("Return addr: ");
	//dump_ll(to, from.length);

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

// Assembly:
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 -0x10(%rbp), %rdi
callq 0x5b40
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, -0x2c(%rbp)
movq 0x8(%rcx), %rdx
movq %rdx, -0x24(%rbp)
movl 0x10(%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b60
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b80
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
movl $0x40, %ecx
leaq -0x2c(%rbp), %r8
movl $0x14, %r9d
callq 0x3060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x58f7
movq 0x56fe(%rip), %rax      # 0xafc0
movq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x3030
movl (%rax), %eax
movl %eax, -0x54(%rbp)
callq 0x3030
movl (%rax), %edi
callq 0x30d0
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %edx
movq %rax, %rcx
leaq 0x1907(%rip), %rsi      # 0x71f7
movb $0x0, %al
callq 0x32f0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcdolson[P]nsh-sf-devkit/src/HealthEcho/HealthEcho.cpp
// Function: HealthEcho::Receive(nshdev::PacketRef&, nshdev::NetInterface&)
void HealthEcho::Receive(nshdev::PacketRef& packetRef, nshdev::NetInterface& receiveInterface)
{
    const nsh_hdr* nsh = reinterpret_cast<const nsh_hdr*>(packetRef.Data());
    unsigned next = nsh_get_next_header(nsh);
    bool oam = nsh_is_oam_packet(nsh);
//    std::cout << "Received NSH packet SPI=" << nsh_get_path_id(&nsh->service_hdr) << ", SI=" << unsigned(nsh_get_service_index(&nsh->service_hdr)) << ", OAM=" << oam << ", next type=" << next << std::endl;
    if(oam && next == 254)
    {
        uint8_t* pEcho = packetRef.Data() + nsh_get_size(nsh);
        nsh_oam_echo* echo = reinterpret_cast<nsh_oam_echo*>(pEcho);
//        std::cout << "Echo subcode="<< nsh_oam_get_subcode(echo) << ", length=" << nsh_oam_get_length(echo) << ", dst=" << nsh_oam_get_dst_id(echo) << ", trn=" << nsh_oam_get_trn_id(echo) << std::endl;
	if(nsh_oam_get_subcode(echo) == NSH_ECHO_REQUEST)
	{
	    nsh_oam_set_subcode(echo, NSH_ECHO_RESPOND);
	    receiveInterface.ReturnToSender(packetRef);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5fc0
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5fe0
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
je 0x5fb9
cmpl $0xfe, -0x24(%rbp)
jne 0x5fb9
movq -0x10(%rbp), %rdi
callq 0x5b60
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6000
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6020
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0x5fb7
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x6040
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x5fb9
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dcdolson[P]nsh-sf-devkit/src/Scheduler/Scheduler.cpp
// Function: nshdev::Scheduler::RunSyncPollLoop()
void Scheduler::RunSyncPollLoop()
{
    int fd = m_if.GetWaitFD();
	while(1)
	{
	    struct pollfd fds;
	    fds.fd = fd;
	    fds.events = POLLIN;
	    fds.revents = 0;
	   
	    int ready = poll(&fds, 1, m_syncTimeout_ms );
	    if(ready > 0)
	    {
		    m_if.Run();
	    }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movw $0x1, -0x10(%rbp)
movw $0x0, -0xe(%rbp)
movl 0xc(%rax), %edx
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x3310
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x61dd
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x61a0
nop