LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printEnemies
void printEnemies(const int x) {
	switch(x) {
		case 1:printSwordsman();
			break;
		case 2:printSkeleton();
			break;
		case 3:printSlinger();
			break;	
		case 4:printTheif();
			break;	
		case 5:printArcher();
			break;
		case 6:printSpearman();
			break;
		case 7:printDog();
			break;
		case 8:printMage();
			break;
		case 9:printScrugg();
			break;
		case 10:printHalflings();
			break;
		case 11:printMonster();
			break;
		case 12:printDelmer();
			break;
		case 13:printHalflingL();
			break;
		case 14:printHalflingR();
			break;
		case 15:printMonsterL();
			break;
		case 16:printMonsterR();
			break;
		case 17:printDelmerL();
			break;			
		case 18:printDelmerR();
			break;	
		case 19: printBoss();
			break;
		default : //do nothing
			break;
	}
	wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x12, %eax
ja 0x7afb
movq -0x10(%rbp), %rax
leaq 0x60b6(%rip), %rcx      # 0xdb20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x7b20
jmp 0x7afd
callq 0x7d60
jmp 0x7afd
callq 0x7f90
jmp 0x7afd
callq 0x8190
jmp 0x7afd
callq 0x8320
jmp 0x7afd
callq 0x8700
jmp 0x7afd
callq 0x7790
jmp 0x7afd
callq 0x88a0
jmp 0x7afd
callq 0x8ac0
jmp 0x7afd
callq 0x8d20
jmp 0x7afd
callq 0x8d30
jmp 0x7afd
callq 0x8d50
jmp 0x7afd
callq 0x8d60
jmp 0x7afd
callq 0x8e80
jmp 0x7afd
callq 0x8fa0
jmp 0x7afd
callq 0x8fc0
jmp 0x7afd
callq 0x7a30
jmp 0x7afd
callq 0x8ff0
jmp 0x7afd
callq 0x9010
jmp 0x7afd
jmp 0x7afd
leaq 0x961c(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printTheif
static void printTheif(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,11,27,"O"); //head
	wattroff(game_win,YELLOW);
	wattron(game_win,WHITE);
	mvwprintw(game_win,12,24,"\\"); //daggers
	mvwprintw(game_win,13,30,"\\"); //daggers
	wattroff(game_win,WHITE);
	wattron(game_win,GREEN);
	mvwprintw(game_win,12,25,"__|__"); //upperbody
	mvwprintw(game_win,13,27,"|"); //lowerbody
	mvwprintw(game_win,14,25," / \\"); //legs
	mvwprintw(game_win,15,25,"/   \\"); //lower legs
	wattroff(game_win,GREEN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8f85(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x8f6d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xb, %esi
movl $0x1b, %edx
leaq 0x59fb(%rip), %rcx      # 0xdbc2
movb $0x0, %al
callq 0x10d0
leaq 0x8f4b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x8f33(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x8f1b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0x18, %edx
leaq 0x5a40(%rip), %rcx      # 0xdc59
movb $0x0, %al
callq 0x10d0
leaq 0x8ef9(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1e, %edx
leaq 0x5a1e(%rip), %rcx      # 0xdc59
movb $0x0, %al
callq 0x10d0
leaq 0x8ed7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x8ebf(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x8ea7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0x19, %edx
leaq 0x591a(%rip), %rcx      # 0xdba7
movb $0x0, %al
callq 0x10d0
leaq 0x8e85(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1b, %edx
leaq 0x5ad3(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x8e63(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x19, %edx
leaq 0x58dc(%rip), %rcx      # 0xdbad
movb $0x0, %al
callq 0x10d0
leaq 0x8e41(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xf, %esi
movl $0x19, %edx
leaq 0x5879(%rip), %rcx      # 0xdb6c
movb $0x0, %al
callq 0x10d0
leaq 0x8e1f(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printSpearman
static void printSpearman(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,13,26,"____ _ _ __"); //spear
	wattroff(game_win,YELLOW);	
	wattron(game_win,WHITE);
	mvwprintw(game_win,11,32,"O"); //head
	mvwprintw(game_win,12,30,"__|__"); //upper torso and arms
	mvwprintw(game_win,13,25,"_"); //spearpoint
	mvwprintw(game_win,13,32,"|"); //lower torso
	mvwprintw(game_win,13,30,"\\"); //hands
	mvwprintw(game_win,13,34,"/"); //other hands
	mvwprintw(game_win,14,31,"/ \\"); //legs
	mvwprintw(game_win,15,30,"/   \\"); //lower legs
	wattroff(game_win,WHITE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8a15(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x89fd(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1a, %edx
leaq 0x547b(%rip), %rcx      # 0xdbb2
movb $0x0, %al
callq 0x10d0
leaq 0x89db(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x89c3(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x89ab(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xb, %esi
movl $0x20, %edx
leaq 0x5439(%rip), %rcx      # 0xdbc2
movb $0x0, %al
callq 0x10d0
leaq 0x8989(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0x1e, %edx
leaq 0x53fc(%rip), %rcx      # 0xdba7
movb $0x0, %al
callq 0x10d0
leaq 0x8967(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x19, %edx
leaq 0x5566(%rip), %rcx      # 0xdd33
movb $0x0, %al
callq 0x10d0
leaq 0x8945(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x20, %edx
leaq 0x5593(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x8923(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1e, %edx
leaq 0x5448(%rip), %rcx      # 0xdc59
movb $0x0, %al
callq 0x10d0
leaq 0x8901(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x22, %edx
leaq 0x543a(%rip), %rcx      # 0xdc6d
movb $0x0, %al
callq 0x10d0
leaq 0x88df(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x1f, %edx
leaq 0x5359(%rip), %rcx      # 0xdbae
movb $0x0, %al
callq 0x10d0
leaq 0x88bd(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xf, %esi
movl $0x1e, %edx
leaq 0x52f5(%rip), %rcx      # 0xdb6c
movb $0x0, %al
callq 0x10d0
leaq 0x889b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printHalflingL
static void printHalflingL(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,13,30,"0"); //head
	mvwprintw(game_win,14,28,"-- --"); //arms
	wattroff(game_win,YELLOW);	
	wattron(game_win,GREEN);
	mvwprintw(game_win,14,30,"|"); //torso
	wattroff(game_win,GREEN);
	wattron(game_win,BLUE);
	mvwprintw(game_win,15,29,"/ \\"); //legs
	wattroff(game_win,BLUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x83b5(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x839d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1e, %edx
leaq 0x4e05(%rip), %rcx      # 0xdb9c
movb $0x0, %al
callq 0x10d0
leaq 0x837b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x1c, %edx
leaq 0x4e4c(%rip), %rcx      # 0xdc05
movb $0x0, %al
callq 0x10d0
leaq 0x8359(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x8341(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x8329(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x1e, %edx
leaq 0x4f77(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x8307(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x82ef(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x82d7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xf, %esi
movl $0x1d, %edx
leaq 0x4d51(%rip), %rcx      # 0xdbae
movb $0x0, %al
callq 0x10d0
leaq 0x82b5(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printHalflingR
static void printHalflingR(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,13,40,"0"); //head
	mvwprintw(game_win,14,38,"-- --"); //arms
	wattroff(game_win,YELLOW);	
	wattron(game_win,MAGENTA);
	mvwprintw(game_win,14,40,"|"); //torso
	wattroff(game_win,MAGENTA);
	wattron(game_win,CYAN);
	mvwprintw(game_win,15,39,"/ \\"); //legs
	wattroff(game_win,CYAN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8295(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x827d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x28, %edx
leaq 0x4ce5(%rip), %rcx      # 0xdb9c
movb $0x0, %al
callq 0x10d0
leaq 0x825b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x26, %edx
leaq 0x4d2c(%rip), %rcx      # 0xdc05
movb $0x0, %al
callq 0x10d0
leaq 0x8239(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x8221(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x8209(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x28, %edx
leaq 0x4e57(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x81e7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x81cf(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x81b7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xf, %esi
movl $0x27, %edx
leaq 0x4c31(%rip), %rcx      # 0xdbae
movb $0x0, %al
callq 0x10d0
leaq 0x8195(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printMonsterHead
static void printMonsterHead(const int x) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,9,26+x,"(   )"); //facce
	wattroff(game_win,YELLOW);
	wattron(game_win,WHITE);
	mvwprintw(game_win,9,27+x,". ."); //eyes
	wattroff(game_win,WHITE);
	wattron(game_win,RED);
	mvwprintw(game_win,9,28+x,"_"); //mouth
	wattroff(game_win,RED);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x7eae(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7e96(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %edx
addl $0x1a, %edx
movl $0x9, %esi
leaq 0x4925(%rip), %rcx      # 0xdbc4
movb $0x0, %al
callq 0x10d0
leaq 0x7e73(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7e5b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7e43(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %edx
addl $0x1b, %edx
movl $0x9, %esi
leaq 0x48d8(%rip), %rcx      # 0xdbca
movb $0x0, %al
callq 0x10d0
leaq 0x7e20(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7e08(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7df0(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %edx
addl $0x1c, %edx
movl $0x9, %esi
leaq 0x49ee(%rip), %rcx      # 0xdd33
movb $0x0, %al
callq 0x10d0
leaq 0x7dcd(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printMonsterBody
static void printMonsterBody(void) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,10,25,"____\\----/____");
	mvwprintw(game_win,11,29,"|____|");
	mvwprintw(game_win,12,28,"/      \\");
	mvwprintw(game_win,13,27,"/        \\");
	mvwprintw(game_win,14,26,"/          \\");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7da5(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7d8d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xa, %esi
movl $0x19, %edx
leaq 0x4827(%rip), %rcx      # 0xdbce
movb $0x0, %al
callq 0x10d0
leaq 0x7d6b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xb, %esi
movl $0x1d, %edx
leaq 0x4814(%rip), %rcx      # 0xdbdd
movb $0x0, %al
callq 0x10d0
leaq 0x7d49(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0x1c, %edx
leaq 0x47f9(%rip), %rcx      # 0xdbe4
movb $0x0, %al
callq 0x10d0
leaq 0x7d27(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x1b, %edx
leaq 0x47e0(%rip), %rcx      # 0xdbed
movb $0x0, %al
callq 0x10d0
leaq 0x7d05(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0x1a, %edx
leaq 0x47c9(%rip), %rcx      # 0xdbf8
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printenemy.c
// Function: printMonsterSeveredHead
static void printMonsterSeveredHead(const int y, const int x) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,16+y,20+x,"(   )"); //severed head face
	wattroff(game_win,YELLOW);
	wattron(game_win,WHITE);
	mvwprintw(game_win,16+y,21+x,". ."); //severed head eyes
	wattroff(game_win,WHITE);
	wattron(game_win,RED);
	mvwprintw(game_win,16+y,22+x,"-"); //severed head mouth
	wattroff(game_win,RED);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x7ccb(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7cb3(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x10, %esi
movl -0x8(%rbp), %edx
addl $0x14, %edx
leaq 0x4741(%rip), %rcx      # 0xdbc4
movb $0x0, %al
callq 0x10d0
leaq 0x7c8f(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7c77(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7c5f(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x10, %esi
movl -0x8(%rbp), %edx
addl $0x15, %edx
leaq 0x46f3(%rip), %rcx      # 0xdbca
movb $0x0, %al
callq 0x10d0
leaq 0x7c3b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7c23(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7c0b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x10, %esi
movl -0x8(%rbp), %edx
addl $0x16, %edx
leaq 0x48a1(%rip), %rcx      # 0xddcc
movb $0x0, %al
callq 0x10d0
leaq 0x7be7(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printHeroPlaces
void printHeroPlaces(void){
	wattron(game_win,COLOR_PAIR(3));
	mvwprintw(game_win,12,14,"|");
	mvwprintw(game_win,13,14,"|");
	wattroff(game_win,COLOR_PAIR(3));
	wattron(game_win,COLOR_PAIR(4));
	mvwprintw(game_win,11,14,"O");
	mvwprintw(game_win,12,12,"__");
	mvwprintw(game_win,12,15,"__");
	mvwprintw(game_win,14,13,"/ \\ ");
	mvwprintw(game_win,15,12,"/   \\");
	wattroff(game_win,COLOR_PAIR(4));
	wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bc5(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7bad(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0xe, %edx
leaq 0x47fb(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x7b8b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0xe, %edx
leaq 0x47d9(%rip), %rcx      # 0xdd82
movb $0x0, %al
callq 0x10d0
leaq 0x7b69(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7b51(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0x7b39(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xb, %esi
movl $0xe, %edx
leaq 0x45c7(%rip), %rcx      # 0xdbc2
movb $0x0, %al
callq 0x10d0
leaq 0x7b17(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %edx
leaq 0x45a3(%rip), %rcx      # 0xdbbb
movl %edx, %esi
movb $0x0, %al
callq 0x10d0
leaq 0x7af8(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0xf, %edx
leaq 0x457f(%rip), %rcx      # 0xdbbb
movb $0x0, %al
callq 0x10d0
leaq 0x7ad6(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xe, %esi
movl $0xd, %edx
leaq 0x4540(%rip), %rcx      # 0xdb9e
movb $0x0, %al
callq 0x10d0
leaq 0x7ab4(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x44ec(%rip), %rcx      # 0xdb6c
movb $0x0, %al
callq 0x10d0
leaq 0x7a92(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %edx
callq 0x11c0
leaq 0x7a7a(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printPlaces
void printPlaces(const int x) {
	switch(x){
		case 1: printHH();
			break;
		case 2:printHouse();
			break;
		case 3:printGC();
			break;
		case 4:printShrine();
			break;
		case 5:printCamp();
			break;		
		case 6: printWell();
			break;
		default: //do nothing
			break;
	}
	wrefresh(game_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x5, %eax
ja 0x9709
movq -0x10(%rbp), %rax
leaq 0x45e6(%rip), %rcx      # 0xdcbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x9720
jmp 0x970b
callq 0x9800
jmp 0x970b
callq 0x9900
jmp 0x970b
callq 0x99d0
jmp 0x970b
callq 0x9b10
jmp 0x970b
callq 0x9c10
jmp 0x970b
jmp 0x970b
leaq 0x7a0e(%rip), %rax      # 0x11120
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printHH
static void printHH(void) {
	mvwprintw(game_win,4,29,"  (");
	mvwprintw(game_win,5,29,"  )");
	mvwprintw(game_win,6,29," (");
	mvwprintw(game_win,7,29," )           _ ");
	mvwprintw(game_win,8,29,"           _(_)__");
	mvwprintw(game_win,9,29,"/\\        (_) (__)");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x79f5(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x4, %esi
movl $0x1d, %edx
leaq 0x45b1(%rip), %rcx      # 0xdcf0
movb $0x0, %al
callq 0x10d0
leaq 0x79d3(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x5, %esi
movl $0x1d, %edx
leaq 0x4465(%rip), %rcx      # 0xdbc6
movb $0x0, %al
callq 0x10d0
leaq 0x79b1(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x6, %esi
movl $0x1d, %edx
leaq 0x456e(%rip), %rcx      # 0xdcf1
movb $0x0, %al
callq 0x10d0
leaq 0x798f(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x7, %esi
movl $0x1d, %edx
leaq 0x454f(%rip), %rcx      # 0xdcf4
movb $0x0, %al
callq 0x10d0
leaq 0x796d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x8, %esi
movl $0x1d, %edx
leaq 0x453d(%rip), %rcx      # 0xdd04
movb $0x0, %al
callq 0x10d0
leaq 0x794b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x9, %esi
movl $0x1d, %edx
leaq 0x452d(%rip), %rcx      # 0xdd16
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printHouse
static void printHouse(void) {
	mvwprintw(game_win,1,33,"          _");
	mvwprintw(game_win,2,33,"   ______| |_");
	mvwprintw(game_win,3,33,"  /\\         \\");
	mvwprintw(game_win,4,33," /  \\         \\");
	mvwprintw(game_win,5,33,"/____\\_________\\");
	mvwprintw(game_win,6,33,"| _  |  []  [] |");
	mvwprintw(game_win,7,33,"||_|_|_________|");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7915(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x1, %esi
movl $0x21, %edx
leaq 0x450a(%rip), %rcx      # 0xdd29
movb $0x0, %al
callq 0x10d0
leaq 0x78f3(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x2, %esi
movl $0x21, %edx
leaq 0x44f4(%rip), %rcx      # 0xdd35
movb $0x0, %al
callq 0x10d0
leaq 0x78d1(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x3, %esi
movl $0x21, %edx
leaq 0x44e0(%rip), %rcx      # 0xdd43
movb $0x0, %al
callq 0x10d0
leaq 0x78af(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x4, %esi
movl $0x21, %edx
leaq 0x44cd(%rip), %rcx      # 0xdd52
movb $0x0, %al
callq 0x10d0
leaq 0x788d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x5, %esi
movl $0x21, %edx
leaq 0x44bb(%rip), %rcx      # 0xdd62
movb $0x0, %al
callq 0x10d0
leaq 0x786b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x6, %esi
movl $0x21, %edx
leaq 0x44aa(%rip), %rcx      # 0xdd73
movb $0x0, %al
callq 0x10d0
leaq 0x7849(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x7, %esi
movl $0x21, %edx
leaq 0x4499(%rip), %rcx      # 0xdd84
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printGC
static void printGC(void) {
	mvwprintw(game_win,0,27,"             --");
	mvwprintw(game_win,1,27,"                   ");
	mvwprintw(game_win,2,27,"--   - -|--        -");
	mvwprintw(game_win,3,27,"                  (_)");
	mvwprintw(game_win,4,27,"      -");
	mvwprintw(game_win,5,27,"        ---       --");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7815(%rip), %rax      # 0x11120
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1b, %edx
leaq 0x4479(%rip), %rcx      # 0xdd95
movb $0x0, %al
callq 0x10d0
leaq 0x77f6(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x1, %esi
movl $0x1b, %edx
leaq 0x4467(%rip), %rcx      # 0xdda5
movb $0x0, %al
callq 0x10d0
leaq 0x77d4(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x2, %esi
movl $0x1b, %edx
leaq 0x4459(%rip), %rcx      # 0xddb9
movb $0x0, %al
callq 0x10d0
leaq 0x77b2(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x3, %esi
movl $0x1b, %edx
leaq 0x444c(%rip), %rcx      # 0xddce
movb $0x0, %al
callq 0x10d0
leaq 0x7790(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x4, %esi
movl $0x1b, %edx
leaq 0x4422(%rip), %rcx      # 0xddc6
movb $0x0, %al
callq 0x10d0
leaq 0x776e(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x5, %esi
movl $0x1b, %edx
leaq 0x441e(%rip), %rcx      # 0xdde4
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printShrine
static void printShrine(void) {
	mvwprintw(game_win,2,20,"       __I__");
	mvwprintw(game_win,3,20,"     .' ... '.");
	mvwprintw(game_win,4,20,".__.' ........ '.__,");
	mvwprintw(game_win,5,20," ~----------------~");
	mvwprintw(game_win,6,20,"  |=||:|    |:||=|");
	mvwprintw(game_win,7,20,"  |=||:|    |:||=|");
	mvwprintw(game_win,8,20,"  |=||:|    |:||=|");
	mvwprintw(game_win,9,20,"  |=||:|    |:||=|");
	mvwprintw(game_win,10,20,"  |=||:|    |:||=|");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7745(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x2, %esi
movl $0x14, %edx
leaq 0x440a(%rip), %rcx      # 0xddf9
movb $0x0, %al
callq 0x10d0
leaq 0x7723(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x3, %esi
movl $0x14, %edx
leaq 0x43f5(%rip), %rcx      # 0xde06
movb $0x0, %al
callq 0x10d0
leaq 0x7701(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x4, %esi
movl $0x14, %edx
leaq 0x43e2(%rip), %rcx      # 0xde15
movb $0x0, %al
callq 0x10d0
leaq 0x76df(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x5, %esi
movl $0x14, %edx
leaq 0x43d5(%rip), %rcx      # 0xde2a
movb $0x0, %al
callq 0x10d0
leaq 0x76bd(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x6, %esi
movl $0x14, %edx
leaq 0x43c7(%rip), %rcx      # 0xde3e
movb $0x0, %al
callq 0x10d0
leaq 0x769b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x7, %esi
movl $0x14, %edx
leaq 0x43a5(%rip), %rcx      # 0xde3e
movb $0x0, %al
callq 0x10d0
leaq 0x7679(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x8, %esi
movl $0x14, %edx
leaq 0x4383(%rip), %rcx      # 0xde3e
movb $0x0, %al
callq 0x10d0
leaq 0x7657(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x9, %esi
movl $0x14, %edx
leaq 0x4361(%rip), %rcx      # 0xde3e
movb $0x0, %al
callq 0x10d0
leaq 0x7635(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xa, %esi
movl $0x14, %edx
leaq 0x433f(%rip), %rcx      # 0xde3e
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printCamp
static void printCamp(void) {
	mvwprintw(game_win,7,36,"   /|\\");
	mvwprintw(game_win,8,36,"  / |\\\\");
	mvwprintw(game_win,9,36," /  |\\\\\\ ");
	mvwprintw(game_win,10,36,"   / \\\\\\");
	mvwprintw(game_win,11,36,"  /   \\\\\\");
	mvwprintw(game_win,12,36," / []  \\\\");
	mvwprintw(game_win,13,36,"/ [] [] \\");                              
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7605(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x7, %esi
movl $0x24, %edx
leaq 0x4322(%rip), %rcx      # 0xde51
movb $0x0, %al
callq 0x10d0
leaq 0x75e3(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x8, %esi
movl $0x24, %edx
leaq 0x4307(%rip), %rcx      # 0xde58
movb $0x0, %al
callq 0x10d0
leaq 0x75c1(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0x9, %esi
movl $0x24, %edx
leaq 0x42ed(%rip), %rcx      # 0xde60
movb $0x0, %al
callq 0x10d0
leaq 0x759f(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xa, %esi
movl $0x24, %edx
leaq 0x42d5(%rip), %rcx      # 0xde6a
movb $0x0, %al
callq 0x10d0
leaq 0x757d(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xb, %esi
movl $0x24, %edx
leaq 0x42bc(%rip), %rcx      # 0xde73
movb $0x0, %al
callq 0x10d0
leaq 0x755b(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xc, %esi
movl $0x24, %edx
leaq 0x42a4(%rip), %rcx      # 0xde7d
movb $0x0, %al
callq 0x10d0
leaq 0x7539(%rip), %rax      # 0x11120
movq (%rax), %rdi
movl $0xd, %esi
movl $0x24, %edx
leaq 0x428c(%rip), %rcx      # 0xde87
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/return5[P]c_ish_one/./src/printobjects.c
// Function: printOptionsPlaces
void printOptionsPlaces(const int x) {
	wclear(prompt_win);
	switch(x){
		case 1: printHHPrompt();
			break;
		case 2: printHousePrompt();
			break;
		case 3: printGCPrompt();
			break;
		case 4: printShrinePrompt();
			break;
		case 5: printCampPrompt();
			break;	
		case 6: printWellPrompt();
			break;
		case 7: printWellPromptEmpty();
			break;
		default: //do nothing
			break;
	}
	wrefresh(prompt_win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x74b6(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x1090
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x6, %eax
ja 0x9ccf
movq -0x10(%rbp), %rax
leaq 0x403f(%rip), %rcx      # 0xdcd4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x9cf0
jmp 0x9cd1
callq 0x9d10
jmp 0x9cd1
callq 0x9d30
jmp 0x9cd1
callq 0x9d50
jmp 0x9cd1
callq 0x9d70
jmp 0x9cd1
callq 0x9d90
jmp 0x9cd1
callq 0x9db0
jmp 0x9cd1
jmp 0x9cd1
leaq 0x7450(%rip), %rax      # 0x11128
movq (%rax), %rdi
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/tests.c
// Function: strings
void strings(void) {
	char* s1 = "FOO";
	char* s2 = "BAR";

	Set set = set_create((CompareFunc)strcmp, NULL);
	set_insert(set, s1);
	set_insert(set, s2);

	TEST_ASSERT(set_size(set) == 2);

	char* value1 = set_find(set, "FOO");
	char* value2 = set_find(set, "BAR");

	TEST_ASSERT(s1 == value1);
	TEST_ASSERT(s2 == value2);

	set_destroy(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x2f42(%rip), %rax      # 0x72e1
movq %rax, -0x8(%rbp)
leaq 0x2f3b(%rip), %rax      # 0x72e5
movq %rax, -0x10(%rbp)
movq 0x5c1b(%rip), %rdi      # 0x9fd0
xorl %eax, %eax
movl %eax, %esi
callq 0x52e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5380
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5380
movq -0x18(%rbp), %rdi
callq 0x5360
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2ef2(%rip), %rsi      # 0x72e9
movl $0x12, %edx
leaq 0x2fe0(%rip), %rcx      # 0x73e3
leaq 0x2ee7(%rip), %r8       # 0x72f1
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x441b
callq 0x2e40
jmp 0x441d
movq -0x18(%rbp), %rdi
leaq 0x2eb9(%rip), %rsi      # 0x72e1
callq 0x56f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2ea9(%rip), %rsi      # 0x72e5
callq 0x56f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2e8d(%rip), %rsi      # 0x72e9
movl $0x17, %edx
leaq 0x2f7b(%rip), %rcx      # 0x73e3
leaq 0x2e95(%rip), %r8       # 0x7304
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x4480
callq 0x2e40
jmp 0x4482
jmp 0x4484
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2e4e(%rip), %rsi      # 0x72e9
movl $0x18, %edx
leaq 0x2f3c(%rip), %rcx      # 0x73e3
leaq 0x2e63(%rip), %r8       # 0x7311
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x44bf
callq 0x2e40
jmp 0x44c1
movq -0x18(%rbp), %rdi
callq 0x5810
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/tests.c
// Function: integers
void integers(void) {
	int a1 = 5;
	int a2 = 42;

	Set set = set_create((CompareFunc)compare_ints, NULL);

	// ΠΡΟΣΟΧΗ: προσθέτουμε στο set pointers προς τοπικές μεταβλητές! Αυτό είναι ok αν το set
	// χρησιμοποιείται ΜΟΝΟ όσο οι μεταβλητές βρίσκονται στο scope! (δλαδή μέχρι το τέλος της κλήσης της συνάρτησης)
	set_insert(set, &a1);
	set_insert(set, &a2);

	TEST_ASSERT(set_size(set) == 2);

	int b1 = 5;
	int b2 = 42;
	int* value1 = set_find(set, &b1);
	int* value2 = set_find(set, &b2);

	TEST_ASSERT(value1 == &a1);
	TEST_ASSERT(value2 == &a2);

	set_destroy(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x5, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
leaq -0x3d(%rip), %rdi       # 0x44d0
xorl %eax, %eax
movl %eax, %esi
callq 0x52e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0x5380
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x5380
movq -0x10(%rbp), %rdi
callq 0x5360
cmpl $0x2, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2d9a(%rip), %rsi      # 0x72e9
movl $0x2c, %edx
leaq 0x2e88(%rip), %rcx      # 0x73e3
leaq 0x2d8f(%rip), %r8       # 0x72f1
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x4573
callq 0x2e40
jmp 0x4575
movl $0x5, -0x14(%rbp)
movl $0x2a, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x56f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x56f0
movq %rax, -0x28(%rbp)
leaq -0x4(%rbp), %rax
cmpq %rax, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2d2d(%rip), %rsi      # 0x72e9
movl $0x33, %edx
leaq 0x2e1b(%rip), %rcx      # 0x73e3
leaq 0x2d4f(%rip), %r8       # 0x731e
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x45e0
callq 0x2e40
jmp 0x45e2
jmp 0x45e4
leaq -0x8(%rbp), %rax
cmpq %rax, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2cee(%rip), %rsi      # 0x72e9
movl $0x34, %edx
leaq 0x2ddc(%rip), %rcx      # 0x73e3
leaq 0x2d1e(%rip), %r8       # 0x732c
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x461f
callq 0x2e40
jmp 0x4621
movq -0x10(%rbp), %rdi
callq 0x5810
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/set_example/tests.c
// Function: integers_loop
void integers_loop(void) {
	// Χρησιμοποιούμε destroy_value = free ώστε να γίνονται αυτόματα free οι τιμές που αφαιρούνται
	Set set = set_create((CompareFunc)compare_ints, free);

	// Για να αποθηκεύσουμε 100 διαφορετικούς ακεραίους
	// πρέπει κάθε φορά να δημιουργήσουμε έναν νέο ακέραιο.
	for (int i = 0; i < 100; i++)
		set_insert(set, create_int(i));

	// set_min and set_next
	int i = 0;
	for (SetNode node = set_first(set); node != SET_EOF; node = set_next(set, node)) {
		int* value = set_node_value(set, node);
		TEST_ASSERT(*value == i++);
	}

	// set_max and set_previous
	i = 99;
	for (SetNode node = set_last(set); node != SET_BOF; node = set_previous(set, node)) {
		int* value = set_node_value(set, node);
		TEST_ASSERT(*value == i--);
	}

	// destroy, με free_values = true για να κάνουμε free και τα περιεχόμενα
	set_destroy(set);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x19f(%rip), %rdi      # 0x44d0
movq 0x593a(%rip), %rsi      # 0x9fb0
callq 0x52e0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x46b3
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %edi
callq 0x4630
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5380
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4686
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x58a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x473c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2be8(%rip), %rsi      # 0x72e9
movl $0x4d, %edx
leaq 0x2cd6(%rip), %rcx      # 0x73e3
leaq 0x2c26(%rip), %r8       # 0x733a
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x4725
callq 0x2e40
jmp 0x4727
jmp 0x4729
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5a60
movq %rax, -0x18(%rbp)
jmp 0x46c7
movl $0x63, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5910
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x47c5
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5b40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x10(%rbp)
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x2b5f(%rip), %rsi      # 0x72e9
movl $0x54, %edx
leaq 0x2c4d(%rip), %rcx      # 0x73e3
leaq 0x2bab(%rip), %r8       # 0x7348
movb $0x0, %al
callq 0x2360
cmpl $0x0, %eax
jne 0x47ae
callq 0x2e40
jmp 0x47b0
jmp 0x47b2
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5980
movq %rax, -0x28(%rbp)
jmp 0x4750
movq -0x8(%rbp), %rdi
callq 0x5810
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	struct symbol_list *symlist = NULL;
	char *file;

	doc = xmlNewDoc(BAD_CAST "1.0");
	root_node = xmlNewNode(NULL, BAD_CAST "parse");
	xmlDocSetRootElement(doc, root_node);

/* - A DTD is probably unnecessary for something like this

	dtd = xmlCreateIntSubset(doc, "parse", "http://www.kernel.org/pub/software/devel/sparse/parse.dtd" NULL, "parse.dtd");

	ns = xmlNewNs (root_node, "http://www.kernel.org/pub/software/devel/sparse/parse.dtd", NULL);

	xmlSetNs(root_node, ns);
*/
	symlist = sparse_initialize(argc, argv, &filelist);

	FOR_EACH_PTR(filelist, file) {
		examine_symbol_list(file, symlist);
		sparse_keep_tokens(file);
		examine_symbol_list(file, file_scope->symbols);
		examine_symbol_list(file, global_scope->symbols);
	} END_FOR_EACH_PTR(file);


	xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
	xmlFreeDoc(doc);
	xmlCleanupParser();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x50b17(%rip), %rdi     # 0x62004
callq 0x11230
movq %rax, 0x7b3cf(%rip)     # 0x8c8c8
xorl %eax, %eax
movl %eax, %edi
leaq 0x50b04(%rip), %rsi     # 0x62008
callq 0x11210
movq %rax, 0x7b3c0(%rip)     # 0x8c8d0
movq 0x7b3b1(%rip), %rdi     # 0x8c8c8
movq 0x7b3b2(%rip), %rsi     # 0x8c8d0
callq 0x11310
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17e80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1155b
jmp 0x11610
jmp 0x1155d
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x115f8
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x115a8
cmpq $0x0, -0x28(%rbp)
jne 0x115a8
jmp 0x115ea
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11650
movq -0x28(%rbp), %rdi
callq 0x181e0
movq -0x28(%rbp), %rdi
leaq 0x7852f(%rip), %rax     # 0x89af8
movq (%rax), %rax
movq (%rax), %rsi
callq 0x11650
movq -0x28(%rbp), %rdi
leaq 0x78521(%rip), %rax     # 0x89b00
movq (%rax), %rax
movq (%rax), %rsi
callq 0x11650
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x11564
jmp 0x115fa
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x1155d
movq 0x7b2b1(%rip), %rsi     # 0x8c8c8
leaq 0x586f3(%rip), %rdi     # 0x69d11
leaq 0x509e9(%rip), %rdx     # 0x6200e
movl $0x1, %ecx
callq 0x11260
movq 0x7b292(%rip), %rdi     # 0x8c8c8
callq 0x11370
callq 0x11340
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_symbol_list
static inline void examine_symbol_list(const char *file, struct symbol_list *list)
{
	struct symbol *sym;
	int stream_id = get_stream_id (file);

	if (!list)
		return;
	FOR_EACH_PTR(list, sym) {
		if (sym->pos.stream == stream_id)
			examine_namespace(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11740
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11678
jmp 0x11730
jmp 0x1167a
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1169e
jmp 0x11730
jmp 0x116a0
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11718
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x116eb
cmpq $0x0, -0x18(%rbp)
jne 0x116eb
jmp 0x1170d
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
cmpl -0x1c(%rbp), %eax
jne 0x1170b
movq -0x18(%rbp), %rdi
callq 0x117b0
jmp 0x1170d
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x116a7
jmp 0x1171a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x116a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: get_stream_id
static int get_stream_id (const char *name)
{
	int i;
	for (i=0; i<input_stream_nr; i++) {
		if (strcmp(name, stream_name(i))==0)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x828d3(%rip), %rcx     # 0x94030
cmpl (%rcx), %eax
jge 0x11797
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x31e40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x11280
cmpl $0x0, %eax
jne 0x1178a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1179e
jmp 0x1178c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11753
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_namespace
static void examine_namespace(struct symbol *sym)
{
	if (sym->ident && sym->ident->reserved)
		return;

	switch(sym->namespace) {
	case NS_MACRO:
		examine_macro(sym, root_node);
		break;
	case NS_TYPEDEF:
	case NS_STRUCT:
	case NS_SYMBOL:
		examine_symbol(sym, root_node);
		break;
	case NS_NONE:
	case NS_LABEL:
	case NS_ITERATOR:
	case NS_UNDEF:
	case NS_PREPROCESSOR:
	case NS_KEYWORD:
		break;
	default:
		die("Unrecognised namespace type %d",sym->namespace);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x117e3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb 0x11(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x117e3
jmp 0x1189d
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, -0xc(%rbp)
je 0x1187e
jmp 0x117fc
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x1185a
jmp 0x11806
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x1186c
jmp 0x11810
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x1186c
jmp 0x1181a
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0x1187e
jmp 0x11824
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0x1186c
jmp 0x1182e
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x1187e
jmp 0x11838
movl -0xc(%rbp), %eax
subl $0x40, %eax
je 0x1187e
jmp 0x11842
movl -0xc(%rbp), %eax
subl $0x80, %eax
je 0x1187e
jmp 0x1184e
movl -0xc(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x1187e
jmp 0x11880
movq -0x8(%rbp), %rdi
movq 0x7b06b(%rip), %rsi     # 0x8c8d0
callq 0x118b0
jmp 0x1189d
movq -0x8(%rbp), %rdi
movq 0x7b059(%rip), %rsi     # 0x8c8d0
callq 0x11920
jmp 0x1189d
jmp 0x1189d
movq -0x8(%rbp), %rax
movl (%rax), %esi
shrl $0x8, %esi
andl $0x1ff, %esi            # imm = 0x1FF
leaq 0x5077e(%rip), %rdi     # 0x62014
movb $0x0, %al
callq 0x17cb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_macro
static void examine_macro(struct symbol *sym, xmlNodePtr node)
{
	struct position *pos;

	/* this should probably go in the main codebase*/
	pos = get_expansion_end(sym->expansion);
	if (pos)
		sym->endpos = *pos;
	else
		sym->endpos = sym->pos;

	new_sym_node(sym, "macro", node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x11b10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x118e9
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
jmp 0x118f9
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x4(%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x54d4a(%rip), %rsi     # 0x66652
callq 0x11b80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: get_expansion_end
static struct position *get_expansion_end (struct token *token)
{
	struct token *p1, *p2;

	for (p1=NULL, p2=NULL;
	     !eof_token(token);
	     p2 = p1, p1 = token, token = token->next);

	if (p2)
		return &(p2->pos);
	else
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x9ab41(%rip), %rax     # 0xac670
cmpq %rax, -0x10(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11b3e
jmp 0x11b5e
jmp 0x11b40
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11b28
cmpq $0x0, -0x20(%rbp)
je 0x11b6f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11b77
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_modifiers
static void examine_modifiers(struct symbol *sym, xmlNodePtr node)
{
	const char *modifiers[] = {
			"auto",
			"register",
			"static",
			"extern",
			"const",
			"volatile",
			"signed",
			"unsigned",
			"char",
			"short",
			"long",
			"long-long",
			"typedef",
			NULL,
			NULL,
			NULL,
			NULL,
			NULL,
			"inline",
			"addressable",
			"nocast",
			"noderef",
			"accessed",
			"toplevel",
			"label",
			"assigned",
			"type-type",
			"safe",
			"user-type",
			"force",
			"explicitly-signed",
			"bitwise"};

	int i;

	if (sym->namespace != NS_SYMBOL)
		return;

	/*iterate over the 32 bit bitfield*/
	for (i=0; i < 32; i++) {
		if ((sym->ctype.modifiers & 1<<i) && modifiers[i])
			newProp(node, modifiers[i], "1");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x6be4f(%rip), %rsi     # 0x7dd30
movl $0x100, %edx            # imm = 0x100
callq 0x11180
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x10, %eax
je 0x11f00
jmp 0x11f7a
movl $0x0, -0x114(%rbp)
cmpl $0x20, -0x114(%rbp)
jge 0x11f7a
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x114(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x11f67
movslq -0x114(%rbp), %rax
cmpq $0x0, -0x110(%rbp,%rax,8)
je 0x11f67
movq -0x10(%rbp), %rdi
movslq -0x114(%rbp), %rax
movq -0x110(%rbp,%rax,8), %rsi
leaq 0x5b3b9(%rip), %rdx     # 0x6d31b
callq 0x11df0
jmp 0x11f69
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x11f0a
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_layout
static void
examine_layout(struct symbol *sym, xmlNodePtr node)
{
	examine_symbol_type(sym);

	newNumProp(node, "bit-size", sym->bit_size);
	newNumProp(node, "alignment", sym->ctype.alignment);
	newNumProp(node, "offset", sym->offset);
	if (is_bitfield_type(sym)) {
		newNumProp(node, "bit-offset", sym->bit_offset);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2d460
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edx
leaq 0x501de(%rip), %rsi     # 0x62199
callq 0x11e70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movl %eax, %edx
leaq 0x518d9(%rip), %rsi     # 0x638ae
callq 0x11e70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, %edx
leaq 0x501b7(%rip), %rsi     # 0x621a6
callq 0x11e70
movq -0x8(%rbp), %rdi
callq 0x120e0
cmpl $0xb, %eax
jne 0x1201f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x54(%rax), %edx
andl $0xff, %edx
leaq 0x50188(%rip), %rsi     # 0x621a2
callq 0x11e70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)