LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nwieder[P]SSTS/src/main/execSim.cpp
// Function: main
int main(int argc, char* argv[]){
/* argv[1]: Input file path (string)
 * argv[2]: output directory (string)
 * argv[3]: number of iterations (int)
 * */
  
	for (int i = 1; i <= atoi(argv[3]); i++){ // 3. Number of iterations
		_Input *ipt = new Standard_Ipt(argv[1],argv[2]); //1. Input File path 2. Output directory
		ipt->get_System()->go(i);
//		Release memory!
		if(ipt){delete ipt;ipt = NULL;}
//		Sleep for two seconds to get new seed for random generator
		sleep(2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5590
movl %eax, %ecx
movl -0x80(%rbp), %eax
cmpl %ecx, %eax
jg 0x1baf7
movl $0x498, %edi            # imm = 0x498
callq 0x5320
movq %rax, -0x98(%rbp)
movb $0x1, -0x7a(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5660
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xed50
jmp 0x1b9ad
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5660
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xed50
jmp 0x1b9e5
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x1bb10
jmp 0x1b9fb
movb $0x0, -0x7a(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5768
leaq -0x79(%rbp), %rdi
callq 0x5360
leaq -0x40(%rbp), %rdi
callq 0x5768
leaq -0x41(%rbp), %rdi
callq 0x5360
movq -0x98(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x1badf
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
je 0x1ba6e
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x20(%rbp)
jmp 0x1badf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1babb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1baa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5768
leaq -0x79(%rbp), %rdi
callq 0x5360
leaq -0x40(%rbp), %rdi
callq 0x5768
leaq -0x41(%rbp), %rdi
callq 0x5360
testb $0x1, -0x7a(%rbp)
jne 0x1bacc
jmp 0x1badd
movq -0x98(%rbp), %rdi
movl $0x498, %esi            # imm = 0x498
callq 0x5330
jmp 0x1bb03
movl $0x2, %edi
callq 0x5240
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b940
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5650
nopl (%rax)
// File: nwieder[P]SSTS/src/main/../Input/Standard_Ipt.h
// Function: nw::Standard_Ipt::Standard_Ipt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Standard_Ipt(string input_path, string output_dir_path){
		this->p = (char*)input_path.c_str();
		xml_parse_result result = doc.load_file(p); // load xml file
		this->output_dir_path = output_dir_path;
		rg = new Uni_Rnd();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1bd10
movq -0x50(%rbp), %rdi
leaq 0x41e09(%rip), %rax     # 0x5d950
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x60(%rbp)
callq 0x54f0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1bd30
movq -0x50(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
movq %rdi, -0x48(%rbp)
callq 0x23450
jmp 0x1bb82
movq -0x50(%rbp), %rdi
addq $0x248, %rdi            # imm = 0x248
movq %rdi, -0x78(%rbp)
callq 0x5610
jmp 0x1bb98
movq -0x50(%rbp), %rdi
addq $0x450, %rdi            # imm = 0x450
movq %rdi, -0x90(%rbp)
callq 0x12850
movq -0x50(%rbp), %rdi
addq $0x468, %rdi            # imm = 0x468
movq %rdi, -0x88(%rbp)
callq 0x10440
movq -0x50(%rbp), %rdi
addq $0x480, %rdi            # imm = 0x480
movq %rdi, -0x80(%rbp)
callq 0x10490
movq -0x70(%rbp), %rdi
callq 0x5120
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x240(%rax)
movq %rax, %rsi
addq $0x170, %rsi            # imm = 0x170
movq 0x240(%rax), %rdx
leaq -0x40(%rbp), %rdi
movl $0x74, %ecx
xorl %r8d, %r8d
callq 0x241e0
jmp 0x1bc15
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0x5050
jmp 0x1bc28
movl $0x18, %edi
callq 0x5320
movq %rax, -0x98(%rbp)
jmp 0x1bc3b
movq -0x98(%rbp), %rdi
callq 0x1bdf0
jmp 0x1bc49
movq -0x50(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, 0x448(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1bcde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1bcd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1bcab
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x5330
movq -0x80(%rbp), %rdi
callq 0xf0d0
movq -0x88(%rbp), %rdi
callq 0xf130
movq -0x90(%rbp), %rdi
callq 0x63c0
movq -0x78(%rbp), %rdi
callq 0x5550
movq -0x48(%rbp), %rdi
callq 0x235b0
movq -0x58(%rbp), %rdi
callq 0xf190
movq -0x60(%rbp), %rdi
callq 0x5768
movq -0x50(%rbp), %rdi
callq 0xf250
movq -0x20(%rbp), %rdi
callq 0x5650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nwieder[P]SSTS/src/pugi/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::node_copy_tree(pugi::xml_node_struct*, pugi::xml_node_struct*)
PUGI__FN void node_copy_tree(xml_node_struct* dn, xml_node_struct* sn)
	{
		xml_allocator& alloc = get_allocator(dn);
		xml_allocator* shared_alloc = (&alloc == &get_allocator(sn)) ? &alloc : 0;

		node_copy_contents(dn, sn, shared_alloc);

		xml_node_struct* dit = dn;
		xml_node_struct* sit = sn->first_child;

		while (sit && sit != sn)
		{
			// when a tree is copied into one of the descendants, we need to skip that subtree to avoid an infinite loop
			if (sit != dn)
			{
				xml_node_struct* copy = append_new_node(dit, alloc, PUGI__NODETYPE(sit));

				if (copy)
				{
					node_copy_contents(copy, sit, shared_alloc);

					if (sit->first_child)
					{
						dit = copy;
						sit = sit->first_child;
						continue;
					}
				}
			}

			// continue to the next node
			do
			{
				if (sit->next_sibling)
				{
					sit = sit->next_sibling;
					break;
				}

				sit = sit->parent;
				dit = dit->parent;
			}
			while (sit != sn);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1eac0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1eac0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x1fd54
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1fd5c
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1fd5c
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b7e0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x49(%rbp)
je 0x1fda3
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1fdaf
jmp 0x1fe59
movq -0x30(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x1fe17
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq $0xf, %rax
movl %eax, %edx
callq 0x2b8f0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1fe15
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2b7e0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1fe13
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1fd89
jmp 0x1fe15
jmp 0x1fe17
jmp 0x1fe19
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1fe32
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1fe54
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x1fe19
jmp 0x1fd89
addq $0x50, %rsp
popq %rbp
retq
nop
// File: sotrteacher[P]1MM1INTRO/20190906_1MM1_INTRO_pista_prac01/segundos_a_formato.c
// Function: main
int main(int argc,char *argv[])
{
  int S,s,m,h;
  printf("Segundos: ");
  scanf("%d",&S);
  (!(S/60))?printf("%s:%s:%.2d\n","00","00",S):
((S/60)<60)?printf("%s:%.2d:%.2d\n","00",S/60,S%60):
printf("%.2d:%.2d:%.2d\n",S/3600,(S%3600)/60,(S%3600)%60);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0xe94(%rip), %rdi       # 0x200f
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %eax
jne 0x11b6
movl -0x14(%rbp), %ecx
leaq 0xe72(%rip), %rdi       # 0x2012
leaq 0xe77(%rip), %rdx       # 0x201e
movq %rdx, %rsi
movb $0x0, %al
callq 0x1030
jmp 0x1251
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x3c, %eax
jge 0x11fe
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x28(%rbp), %edx
leaq 0xe36(%rip), %rdi       # 0x2021
leaq 0xe2c(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1030
movl %eax, -0x24(%rbp)
jmp 0x124e
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, %esi
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %edx, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %edx, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x2c(%rbp), %edx
leaq 0xdeb(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 5hubh4m[P]snake-ncurses/main.cpp
// Function: main
int main(void) {
	Score S;
	S.fileread();
	int ch;
	while(1) {
		ch=show_menu();
		switch(ch) {
			case 1:
				S.addscore(classic_game());
				break;
			case 2:
				fun_snake_game();
				break;
			case 3:
				S.showscores();
				break;
			case 4:
				S.filewrite();
				endwin();
				return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6620
leaq -0x40(%rbp), %rdi
callq 0x6770
callq 0x6bb0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x3, %eax
ja 0x2577
movq -0x50(%rbp), %rax
leaq 0x5ad0(%rip), %rcx      # 0x8004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x71b0
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x6920
jmp 0x2577
callq 0x7500
jmp 0x2577
leaq -0x40(%rbp), %rdi
callq 0x6990
jmp 0x2577
leaq -0x40(%rbp), %rdi
callq 0x6660
callq 0x21f0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
jmp 0x2511
nopl (%rax)
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::Snake(int)
Snake::Snake(int len) {
	int i;
	Cell temp;
	fdir=RIGHT;
	temp.p.row=0;
	temp.c='@';
	for(i=0; i<len-1; i++) {
		temp.p.col=i;
		cells.push_front(temp);
	}
	temp.c='O';
	temp.p.col=i;
	cells.push_front(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0xa7a2(%rip), %rax      # 0xcd40
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2e40
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2e60
jmp 0x25c1
movq -0x40(%rbp), %rax
movl $0x1, 0xa8(%rax)
movl $0x0, -0x2c(%rbp)
movb $0x40, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2639
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x8, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2e80
jmp 0x2607
jmp 0x2609
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x265c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2ee0
jmp 0x265c
movq -0x40(%rbp), %rdi
movb $0x4f, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x8, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2e80
jmp 0x2656
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2f50
movq -0x18(%rbp), %rdi
callq 0x22e0
nop
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::createNode(int)
void Snake::createNode(int d) {
		fdir=d;
		Node n;
		n.p.row=cells.front().p.row;
		n.p.col=cells.front().p.col;
		n.dir=d;
		nodes.push_back(n);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0xa8(%rdi)
addq $0x8, %rdi
callq 0x2fc0
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x2fc0
movq -0x20(%rbp), %rdi
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
addq $0x58, %rdi
leaq -0x18(%rbp), %rsi
callq 0x2ff0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::render()
void Snake::render(void) {
		erase();
		for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
			mvaddch(it->p.row, it->p.col, it->c);
		}
		refresh();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x21b0
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3050
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x30b0
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3080
testb $0x1, %al
jne 0x271e
jmp 0x278b
movq 0xa8b3(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movl 0x4(%rax), %edx
callq 0x21a0
cmpl $-0x1, %eax
jne 0x2759
jmp 0x277d
movq 0xa878(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movq -0x68(%rbp), %rdi
movsbl 0x8(%rax), %esi
callq 0x2080
leaq -0x28(%rbp), %rdi
callq 0x3100
jmp 0x26fa
callq 0x22d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Snake::movesnake()
void Snake::movesnake(void) {
		Point f, b;
		Cell temp;
		f=cells.front().p;
		b=cells.back().p;
		cells.front().c='@';
		switch(fdir) {
			case UP:
				f.row=getrow(f.row-1);
				break;
			case DOWN:
				f.row=getrow(f.row+1);
				break;
			case RIGHT:
				f.col=getcol(f.col+1);
				break;
			case LEFT:
				f.col=getcol(f.col-1);
				break;
		}
		temp.p=f;
		temp.c='O';
		cells.push_front(temp);
		if(!nodes.empty()) {
			if(b.row==nodes.front().p.row && b.col==nodes.front().p.col) {
				nodes.pop_front();
			}
		}
		cells.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2fc0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x3150
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x2fc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movb $0x40, 0x8(%rcx)
movl 0xa8(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x284e
movq -0x30(%rbp), %rax
leaq 0x580d(%rip), %rcx      # 0x8014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x10(%rbp), %edi
subl $0x1, %edi
callq 0x78b0
movl %eax, -0x10(%rbp)
jmp 0x284e
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x78b0
movl %eax, -0x10(%rbp)
jmp 0x284e
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x78f0
movl %eax, -0xc(%rbp)
jmp 0x284e
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x78f0
movl %eax, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x24(%rbp)
movb $0x4f, -0x1c(%rbp)
addq $0x8, %rdi
leaq -0x24(%rbp), %rsi
callq 0x2e80
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x3190
testb $0x1, %al
jne 0x28c6
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x58, %rdi
callq 0x31c0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jne 0x28c4
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
addq $0x58, %rdi
callq 0x31c0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x28c4
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x31f0
jmp 0x28c6
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3260
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::Classic_Snake()
Classic_Snake::Classic_Snake():Snake(2) {
	T.p.row=12;
	T.p.col=39;
	T.points=1;
	T.c='&';
	score=0;
	coll=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x2, %esi
callq 0x2580
movq -0x10(%rbp), %rax
leaq 0xa407(%rip), %rcx      # 0xcd50
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0xc, 0xb4(%rax)
movl $0x27, 0xb8(%rax)
movl $0x1, 0xbc(%rax)
movb $0x26, 0xc0(%rax)
movl $0x0, 0xac(%rax)
movl $0x0, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::movesnake()
void Classic_Snake::movesnake(void) {
	Point f, b;
	Cell temp;
	f=cells.front().p;
	b=cells.back().p;
	cells.front().c='@';
	switch(fdir) {
		case UP:
			f.row=getrow(f.row-1);
			break;
		case DOWN:
			f.row=getrow(f.row+1);
			break;
		case RIGHT:
			f.col=getcol(f.col+1);
			break;
		case LEFT:
			f.col=getcol(f.col-1);
			break;
	}
	temp.p=f;
	temp.c='O';
	cells.push_front(temp);
	if(collide()) {
		coll=1;
		return;
	}
	if(cells.front().p.row!=T.p.row || cells.front().p.col!=T.p.col) {
		if(!nodes.empty()) {
			if(b.row==nodes.front().p.row && b.col==nodes.front().p.col) {
				nodes.pop_front();
			}
		}
		cells.pop_back();
	}
	else {
		score+=T.points;
		addtreat();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2fc0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x3150
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x2fc0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movb $0x40, 0x8(%rcx)
movl 0xa8(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x2aee
movq -0x30(%rbp), %rax
leaq 0x557d(%rip), %rcx      # 0x8024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x10(%rbp), %edi
subl $0x1, %edi
callq 0x78b0
movl %eax, -0x10(%rbp)
jmp 0x2aee
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x78b0
movl %eax, -0x10(%rbp)
jmp 0x2aee
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x78f0
movl %eax, -0xc(%rbp)
jmp 0x2aee
movl -0xc(%rbp), %edi
subl $0x1, %edi
callq 0x78f0
movl %eax, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x24(%rbp)
movb $0x4f, -0x1c(%rbp)
addq $0x8, %rdi
leaq -0x24(%rbp), %rsi
callq 0x2e80
movq -0x38(%rbp), %rdi
callq 0x2bf0
cmpl $0x0, %eax
je 0x2b2c
movq -0x38(%rbp), %rax
movl $0x1, 0xb0(%rax)
jmp 0x2be8
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x2fc0
movq -0x38(%rbp), %rcx
movl (%rax), %eax
cmpl 0xb4(%rcx), %eax
jne 0x2b63
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x2fc0
movq -0x38(%rbp), %rcx
movl 0x4(%rax), %eax
cmpl 0xb8(%rcx), %eax
je 0x2bcd
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x3190
testb $0x1, %al
jne 0x2bbe
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x58, %rdi
callq 0x31c0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jne 0x2bbc
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
addq $0x58, %rdi
callq 0x31c0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x2bbc
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x31f0
jmp 0x2bbe
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x3260
jmp 0x2be8
movq -0x38(%rbp), %rdi
movl 0xbc(%rdi), %eax
addl 0xac(%rdi), %eax
movl %eax, 0xac(%rdi)
callq 0x2990
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::collide()
int Classic_Snake::collide(void) {
	for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
		if(cells.front().p.row==it->p.row && cells.front().p.col==it->p.col && it!=cells.begin()) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3050
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x30b0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3080
testb $0x1, %al
jne 0x2c3b
jmp 0x2cda
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x2fc0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30e0
movl -0x80(%rbp), %ecx
movq %rax, %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x79(%rbp)
jne 0x2cb8
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
callq 0x2fc0
movl 0x4(%rax), %eax
movl %eax, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30e0
movl -0x84(%rbp), %ecx
movq %rax, %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x79(%rbp)
jne 0x2cb8
movq -0x78(%rbp), %rsi
addq $0x8, %rsi
leaq -0x70(%rbp), %rdi
callq 0x3050
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3080
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x2cc1
jmp 0x2cca
movl $0x1, -0x4(%rbp)
jmp 0x2ce1
jmp 0x2ccc
leaq -0x30(%rbp), %rdi
callq 0x3100
jmp 0x2c14
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 5hubh4m[P]snake-ncurses/snake.cpp
// Function: Classic_Snake::render()
void Classic_Snake::render(void) {
	erase();
	for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
		mvaddch(it->p.row, it->p.col, it->c);
	}
	mvaddch(T.p.row, T.p.col, T.c);
	refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x21b0
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3050
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x30b0
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3080
testb $0x1, %al
jne 0x2d3e
jmp 0x2dab
movq 0xa293(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movq -0x60(%rbp), %rdi
movl -0x54(%rbp), %esi
movl 0x4(%rax), %edx
callq 0x21a0
cmpl $-0x1, %eax
jne 0x2d79
jmp 0x2d9d
movq 0xa258(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30e0
movq -0x68(%rbp), %rdi
movsbl 0x8(%rax), %esi
callq 0x2080
leaq -0x28(%rbp), %rdi
callq 0x3100
jmp 0x2d1a
movq -0x50(%rbp), %rax
movq 0xa222(%rip), %rcx      # 0xcfd8
movq (%rcx), %rdi
movl 0xb4(%rax), %esi
movl 0xb8(%rax), %edx
callq 0x21a0
cmpl $-0x1, %eax
jne 0x2dd1
jmp 0x2deb
movq -0x50(%rbp), %rax
movq 0xa1fc(%rip), %rcx      # 0xcfd8
movq (%rcx), %rdi
movsbl 0xc0(%rax), %esi
callq 0x2080
callq 0x22d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::filewrite()
void Score::filewrite() {
  std::ofstream file;
  if(head>-1) {
    if(file.is_open()) {
      file.close();
    }
    file.open(FILE_NAME, std::ios::trunc | std::ios::binary);
    file.write((char *)this, sizeof(Score));
    file.close();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22c0
movq -0x220(%rbp), %rax
cmpl $-0x1, 0x38(%rax)
jle 0x6743
leaq -0x208(%rbp), %rdi
callq 0x2110
movb %al, -0x221(%rbp)
jmp 0x66ab
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x66b7
jmp 0x66e7
leaq -0x208(%rbp), %rdi
callq 0x2240
jmp 0x66c5
jmp 0x66e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x2260
jmp 0x6758
movl $0x20, %edi
movl $0x4, %esi
callq 0x6ac0
movl %eax, -0x228(%rbp)
jmp 0x66fe
movl -0x228(%rbp), %edx
leaq 0x1970(%rip), %rsi      # 0x807b
leaq -0x208(%rbp), %rdi
callq 0x2030
jmp 0x6719
movq -0x220(%rbp), %rsi
leaq -0x208(%rbp), %rdi
movl $0x3c, %edx
callq 0x2230
jmp 0x6733
leaq -0x208(%rbp), %rdi
callq 0x2240
jmp 0x6741
jmp 0x6743
leaq -0x208(%rbp), %rdi
callq 0x2260
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::fileread()
void Score::fileread() {
  std::ifstream file;
  file.open(FILE_NAME, std::ios::in | std::ios::binary);
  if(file.is_open()) {
    file.read((char *)this, sizeof(Score));
  }
  file.close();
  sortscore();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x21c0
movl $0x8, %edi
movl $0x4, %esi
callq 0x6ac0
movl %eax, -0x220(%rbp)
jmp 0x67ad
movl -0x220(%rbp), %edx
leaq 0x18c1(%rip), %rsi      # 0x807b
leaq -0x210(%rbp), %rdi
callq 0x2100
jmp 0x67c8
leaq -0x210(%rbp), %rdi
callq 0x2290
movb %al, -0x229(%rbp)
jmp 0x67dc
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x67e8
jmp 0x6824
movq -0x228(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x3c, %edx
callq 0x2200
jmp 0x6802
jmp 0x6824
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2050
jmp 0x6855
leaq -0x210(%rbp), %rdi
callq 0x2040
jmp 0x6832
movq -0x228(%rbp), %rdi
callq 0x6870
jmp 0x6840
leaq -0x210(%rbp), %rdi
callq 0x2050
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::sortscore()
void Score::sortscore(void) {
  int temp;
  if(head>0) {
    for(int i=0; i<=head; i++) {
      for(int j=0; j<=head-1; j++) {
        if(scores[j]>scores[j+1]) {
          temp=scores[j+1];
          scores[j+1]=scores[j];
          scores[j]=temp;
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x38(%rax)
jle 0x691d
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x38(%rcx), %eax
jg 0x691b
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x690b
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
movl (%rcx,%rax,4), %eax
movl -0x14(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x68fe
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, -0xc(%rbp)
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x6900
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x68a4
jmp 0x690d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6891
jmp 0x691d
popq %rbp
retq
nop
// File: 5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::addscore(int)
void Score::addscore(int s) {
  sortscore();
  if(head<13) {
    scores[++head]=s;
    sortscore();
  }
  else {
    if(s>scores[0]) {
      scores[0]=s;
      sortscore();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6870
movq -0x18(%rbp), %rax
cmpl $0xd, 0x38(%rax)
jge 0x6962
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl 0x38(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x38(%rdi)
cltq
movl %ecx, (%rdi,%rax,4)
callq 0x6870
jmp 0x697d
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jle 0x697b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
callq 0x6870
jmp 0x697d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/score.cpp
// Function: Score::showscores()
void Score::showscores(void) {
  sortscore();
  erase();
  int ch;
  int t=(23-head-1)/2;
  if(head>-1) {
    for(int i=head, j=0; i>=0; i--,  j++) {
      mvprintw(t+j, 36, "%2d. %2u", j+1, scores[i]);
    }
  }
  attron(A_STANDOUT);
  mvprintw(23, 25, "PRESS 'Q' to EXIT BACK TO MENU.");
  attroff(A_STANDOUT);
  refresh();
  while((ch=getch())!='q');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6870
callq 0x21b0
movq -0x20(%rbp), %rcx
movl $0x17, %eax
subl 0x38(%rcx), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $-0x1, 0x38(%rax)
jle 0x6a2c
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6a2a
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %edi
addl -0x18(%rbp), %edi
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq -0x14(%rbp), %rdx
movl (%rax,%rdx,4), %r8d
movl $0x24, %esi
leaq 0x1675(%rip), %rdx      # 0x8084
movb $0x0, %al
callq 0x2220
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x69e5
jmp 0x6a2c
movq 0x65a5(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
movl %eax, %edx
callq 0x20e0
movl $0x17, %edi
movl $0x19, %esi
leaq 0x1638(%rip), %rdx      # 0x808d
movb $0x0, %al
callq 0x2220
movq 0x6575(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %eax, %eax
movl %eax, %edx
callq 0x2210
callq 0x22d0
movq 0x6558(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
callq 0x20b0
movl %eax, -0xc(%rbp)
cmpl $0x71, %eax
je 0x6a92
jmp 0x6a79
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: print_snake()
void print_snake(void) {
	mvprintw(0, 14, " $$$$$$\\  $$\\   $$\\  $$$$$$\\  $$\\   $$\\ $$$$$$$$\\\n");
	mvprintw(1, 14, "$$  __$$\\ $$$\\  $$ |$$  __$$\\ $$ | $$  |$$  _____|\n");
	mvprintw(2, 14, "$$ /  \\__|$$$$\\ $$ |$$ /  $$ |$$ |$$  / $$ |\n");
	mvprintw(3, 14, "\\$$$$$$\\  $$ $$\\$$ |$$$$$$$$ |$$$$$  /  $$$$$\\\n");
	mvprintw(4, 14, " \\____$$\\ $$ \\$$$$ |$$  __$$ |$$  $$<   $$  __|\n");
	mvprintw(5, 14, "$$\\   $$ |$$ |\\$$$ |$$ |  $$ |$$ |\\$$\\  $$ |\n");
	mvprintw(6, 14, "\\$$$$$$  |$$ | \\$$ |$$ |  $$ |$$ | \\$$\\ $$$$$$$$\\\n");
	mvprintw(7, 14, " \\______/ \\__|  \\__|\\__|  \\__|\\__|  \\__|\\________|\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
movl $0xe, %esi
leaq 0x15f5(%rip), %rdx      # 0x80e7
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
movl $0xe, %esi
leaq 0x1610(%rip), %rdx      # 0x811a
movb $0x0, %al
callq 0x2220
movl $0x2, %edi
movl $0xe, %esi
leaq 0x162c(%rip), %rdx      # 0x814e
movb $0x0, %al
callq 0x2220
movl $0x3, %edi
movl $0xe, %esi
leaq 0x1642(%rip), %rdx      # 0x817c
movb $0x0, %al
callq 0x2220
movl $0x4, %edi
movl $0xe, %esi
leaq 0x165a(%rip), %rdx      # 0x81ac
movb $0x0, %al
callq 0x2220
movl $0x5, %edi
movl $0xe, %esi
leaq 0x1673(%rip), %rdx      # 0x81dd
movb $0x0, %al
callq 0x2220
movl $0x6, %edi
movl $0xe, %esi
leaq 0x1689(%rip), %rdx      # 0x820b
movb $0x0, %al
callq 0x2220
movl $0x7, %edi
movl $0xe, %esi
leaq 0x16a4(%rip), %rdx      # 0x823e
movb $0x0, %al
callq 0x2220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: diff(int, int)
int diff(int a, int b) {
	if((a-b)>0) {
		return a-b;
	}
	else {
		return b-a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x74f0
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x74f9
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: rand_point(std::deque<Cell, std::allocator<Cell>>)
Point rand_point(std::deque<Cell> cells) {
	Point p;
	int flag;
	srand(time(NULL));
	do {
		flag=0;
		p.row=rand()%(MAX_ROW+1);
		p.col=rand()%(MAX_COL+1);
		for(std::deque<Cell>::iterator it=cells.begin(); it!=cells.end(); ++it){
			if(p.row==it->p.row && p.col==it->p.col) {
				flag=1;
			}
		}
	}while(flag);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2150
movl %eax, %edi
callq 0x2160
movl $0x0, -0x14(%rbp)
callq 0x2060
movl $0x13, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
callq 0x2060
movq -0x60(%rbp), %rsi
movl $0x50, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3050
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x30b0
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3080
testb $0x1, %al
jne 0x77d4
jmp 0x781b
movl -0x8(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30e0
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl (%rcx), %eax
jne 0x780e
movl -0x4(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x30e0
movq %rax, %rcx
movl -0x68(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x780e
movl $0x1, -0x14(%rbp)
jmp 0x7810
leaq -0x38(%rbp), %rdi
callq 0x3100
jmp 0x77b4
jmp 0x781d
cmpl $0x0, -0x14(%rbp)
jne 0x7780
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: getrow(int)
int getrow(int row) {
	if(row>=0 && row<=MAX_ROW) {
		return row;
	}
	else if(row<0) {
		return MAX_ROW+row+1;
	}
	else {
		return row-MAX_ROW-1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x78cb
cmpl $0x12, -0x8(%rbp)
jg 0x78cb
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x78eb
cmpl $0x0, -0x8(%rbp)
jge 0x78df
movl -0x8(%rbp), %eax
addl $0x12, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x78eb
movl -0x8(%rbp), %eax
subl $0x12, %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 5hubh4m[P]snake-ncurses/snake_ncurses.cpp
// Function: getcol(int)
int getcol(int col) {
	if(col>=0 && col<=MAX_COL) {
		return col;
	}
	else if(col<0) {
		return MAX_COL+col+1;
	}
	else {
		return col-MAX_COL-1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x790b
cmpl $0x4f, -0x8(%rbp)
jg 0x790b
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x792b
cmpl $0x0, -0x8(%rbp)
jge 0x791f
movl -0x8(%rbp), %eax
addl $0x4f, %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x792b
movl -0x8(%rbp), %eax
subl $0x4f, %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: attractivechaos[P]udb2/unordered_dense/./unordered_dense.h
// Function: ankerl::unordered_dense::v4_1_2::detail::table<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>, ankerl::unordered_dense::v4_1_2::bucket_type::standard, false>::erase(__gnu_cxx::__normal_iterator<std::pair<unsigned int, unsigned int>*, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>>)
auto erase(iterator it) -> iterator {
        auto hash = mixed_hash(get_key(*it));
        auto bucket_idx = bucket_idx_from_hash(hash);

        auto const value_idx_to_remove = static_cast<value_idx_type>(it - cbegin());
        while (at(m_buckets, bucket_idx).m_value_idx != value_idx_to_remove) {
            bucket_idx = next(bucket_idx);
        }

        do_erase(bucket_idx);
        return begin() + static_cast<difference_type>(value_idx_to_remove);
    }

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3b30
movq %rax, %rdi
callq 0x29f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2b80
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x2bd0
movq 0x8(%rsp), %rdi
movl %eax, 0x24(%rsp)
callq 0x3c80
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3c40
movl %eax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x2bf0
movl 0x4(%rax), %eax
cmpl 0x20(%rsp), %eax
je 0x1982
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x2c20
movl %eax, 0x24(%rsp)
jmp 0x1951
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x3cb0
movq 0x8(%rsp), %rdi
callq 0x30f0
movq %rax, 0x10(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %esi
leaq 0x10(%rsp), %rdi
callq 0x3120
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: MP1Node::MP1Node(Member*, Params*, EmulNet*, Log*, Address*)
MP1Node::MP1Node(Member *member, Params *params, EmulNet *emul, Log *log, Address *address) {
    for( int i = 0; i < 6; i++ ) {
        NULLADDR[i] = 0;
    }
    this->memberNode = member;
    this->emulNet = emul;
    this->log = log;
    this->par = params;
    this->memberNode->addr = *address;
    this->broadcast = 0;
    this->tobedeleted = new std::map<int, int>;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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), %rax
movq %rax, -0x40(%rbp)
leaq 0x311b1(%rip), %rcx     # 0x35bf0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x6, -0x34(%rbp)
jge 0x4a6b
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4a4d
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rsi
movq 0x20(%rax), %rdi
addq $0x8, %rdi
callq 0x150a0
movq -0x40(%rbp), %rax
movl $0x0, 0x30(%rax)
movl $0x30, %edi
callq 0x4310
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x6d00
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: MP1Node::nodeStart(char*, short)
void MP1Node::nodeStart(char *servaddrstr, short servport) {
    // join address is the address of the introducer
    Address joinaddr;
    joinaddr = getJoinAddress();

    Address *my_addr = &this->memberNode->addr;

    // Self booting routines
    if( initThisNode(my_addr) == -1 ) {
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, "init_thisnode failed. Exit.");
#endif
        exit(1);
    }

    if( !introduceSelfToGroup(&joinaddr) ) {
        finishUpThisNode();
#ifdef DEBUGLOG
        log->LOG(&memberNode->addr, "Unable to join self to group. Exiting.");
#endif
        exit(1);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6d90
movq -0x30(%rbp), %rsi
leaq -0x1e(%rbp), %rdi
callq 0x4ca0
leaq -0x18(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
callq 0x150a0
movq -0x30(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x4cf0
cmpl $-0x1, %eax
jne 0x4c6a
movl $0x1, %edi
callq 0x43f0
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4d60
cmpl $0x0, %eax
jne 0x4c8f
movq -0x30(%rbp), %rdi
callq 0x4ee0
movl $0x1, %edi
callq 0x43f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: MP1Node::getJoinAddress()
Address MP1Node::getJoinAddress() {
    Address joinaddr;

// 1.0.0.0:0
    memset(&joinaddr, 0, sizeof(Address));
    *(int *)(&joinaddr.addr) = 1;
    *(short *)(&joinaddr.addr[4]) = 0;

    return joinaddr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6d90
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x41a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x1, (%rdi)
movw $0x0, 0x4(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: MP1Node::recvCallBack(void*, char*, int)
bool MP1Node::recvCallBack(void *env, char *data, int size) {

    // for introduction:
    // two message types: JOINREQ, JOINREP
    // 1. when introducer receives JOINREQ, add the node to member list, and return JOINREP with cluster member list
    // 2. when cluster member receives JOINREP, add the cluster member list

    // for membership:
    // one message type: MEMBERLIST
    // 1. when receive MEMBERLIST, update you own member list accordingly

    MsgTypes msgType = ((MessageHdr *)data)->msgType;

    switch (msgType) {
        case JOINREQ:
            handleJOINREQ(env, data, size);
            break;
        case JOINREP:
            handleJOINREP(env, data, size);
            break;
        case MEMBERLIST:
            handleMEMBERLIST(env, data, size);
            break;
        default:
            cout << "unknown message type" <<endl;
            break;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x5c88
jmp 0x5c74
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x5c9e
jmp 0x5c7e
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x5cb4
jmp 0x5cca
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x5ec0
jmp 0x5cec
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x6440
jmp 0x5cec
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x6490
jmp 0x5cec
movq 0x302f7(%rip), %rdi     # 0x35fc8
leaq 0x2132c(%rip), %rsi     # 0x27004
callq 0x42f0
movq %rax, %rdi
movq 0x302d1(%rip), %rsi     # 0x35fb8
callq 0x4350
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: MP1Node::logNodeAddWrapper(Member*, int, short)
void MP1Node::logNodeAddWrapper(Member *memberNode, int id, short port) {
    Address address;
    string _address = to_string(id) + ":" + to_string(port);
    address = Address(_address);
    log->logNodeAdd(&memberNode->addr, &address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x6d90
movl -0x14(%rbp), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6f90
movq -0xe0(%rbp), %rsi
leaq 0x21f57(%rip), %rdx     # 0x27ca9
leaq -0x60(%rbp), %rdi
callq 0x6f40
jmp 0x5d5d
movswl -0x16(%rbp), %esi
leaq -0xb0(%rbp), %rdi
callq 0x6f90
jmp 0x5d6f
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x6e70
jmp 0x5d85
leaq -0xb0(%rbp), %rdi
callq 0x41e0
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x80(%rbp), %rdi
callq 0x41e0
leaq -0xd8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4150
jmp 0x5db5
leaq -0xb6(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x70b0
jmp 0x5dca
leaq -0x1c(%rbp), %rdi
leaq -0xb6(%rbp), %rsi
callq 0x150a0
jmp 0x5ddc
leaq -0xd8(%rbp), %rdi
callq 0x41e0
movq -0xe8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x1c(%rbp), %rdx
callq 0x14330
jmp 0x5e06
leaq -0x40(%rbp), %rdi
callq 0x41e0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5e67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5e5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x41e0
leaq -0x60(%rbp), %rdi
callq 0x41e0
leaq -0x80(%rbp), %rdi
callq 0x41e0
jmp 0x5ead
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5ea4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x41e0
leaq -0x40(%rbp), %rdi
callq 0x41e0
movq -0x88(%rbp), %rdi
callq 0x4550
nopl (%rax)
// File: zkl94[P]distributed-key-value-store/MP1Node.cpp
// Function: isEntryInvalid(Member*, MemberListEntry&)
bool isEntryInvalid(Member *memberNode, MemberListEntry& memberListEntry) {
    long entry_timestamp = memberListEntry.gettimestamp();
    long node_timestamp = memberNode->memberList[0].gettimestamp();

    if (node_timestamp - entry_timestamp > TFAIL) {
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15290
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x74c0
movq %rax, %rdi
callq 0x15290
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
cmpq $0x5, %rax
jle 0x684e
movb $0x1, -0x1(%rbp)
jmp 0x6852
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zkl94[P]distributed-key-value-store/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();

		// Wait for all nodes to join
		if ( par->allNodesJoined == nodeCount && !allNodesJoined ) {
			timeWhenAllNodesHaveJoined = par->getcurrtime();
			allNodesJoined = true;
		}
		if ( par->getcurrtime() > timeWhenAllNodesHaveJoined + 50 ) {
			// Call the KV store functionalities
			mp2Run();
		}
		// Fail some nodes
		//fail();
	}

	// Clean up
	en->ENcleanup();
	en1->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 0x42b0
movl %eax, %edi
callq 0x42e0
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
cmpl $0x2bc, 0x28(%rax)      # imm = 0x2BC
jge 0xb65a
movq -0x20(%rbp), %rdi
callq 0xbd10
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movl 0x2c(%rax), %eax
cmpl 0x2b53b(%rip), %eax     # 0x36b44
jne 0xb625
testb $0x1, -0x11(%rbp)
jne 0xb625
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x15020
movl %eax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x15020
movl -0x10(%rbp), %ecx
addl $0x32, %ecx
cmpl %ecx, %eax
jle 0xb645
movq -0x20(%rbp), %rdi
callq 0xbf40
jmp 0xb647
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0xb5de
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0xb0a0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xb0a0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x50(%rcx), %rcx
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xb6b0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4ee0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb67b
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)