LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/makemap.c
// Function: initPieces
static void initPieces(void) {
	makeList(ENEMY_LIMIT,enemy_x,enemy_y); //make enemy list
	makeList(CAMP_LIMIT,camp_x,camp_y);  //make camp list
	checkLocation(ENEMY_LIMIT,enemy_x,enemy_y,ENEMY_LIMIT,enemy_x,enemy_y); //check if enemy is on another
	checkLocation(CAMP_LIMIT,camp_x,camp_y,CAMP_LIMIT,camp_x,camp_y);  //checks if camp is located at or near another
	makeList(SHRINE_LIMIT, shrine_x,shrine_y); //make shrine list
	makeList(WELL_LIMIT,well_x,well_y);  //make well list
	checkLocation(SHRINE_LIMIT,shrine_x,shrine_y,SHRINE_LIMIT,shrine_x,shrine_y); //checks if shrine is at or near another shrine
	checkLocation(WELL_LIMIT,well_x,well_y,WELL_LIMIT,well_x,well_y); //checks if well is located at or near another one
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xb199(%rip), %rbx      # 0xf0a0
leaq 0xb282(%rip), %r14      # 0xf190
movl $0x3c, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x469f
leaq 0xb35b(%rip), %r15      # 0xf280
leaq 0xb3c4(%rip), %r12      # 0xf2f0
movl $0x19, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x469f
movl $0x3c, %edi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x3c, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x471b
movl $0x19, %edi
movq %r15, %rsi
movq %r12, %rdx
movl $0x19, %ecx
movq %r15, %r8
movq %r12, %r9
callq 0x471b
leaq 0xb3db(%rip), %rbx      # 0xf354
leaq 0xb3e0(%rip), %r14      # 0xf360
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x469f
leaq 0xb3d9(%rip), %r15      # 0xf370
leaq 0xb3f2(%rip), %r12      # 0xf390
movl $0x5, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x469f
movl $0x3, %edi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x3, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x471b
movl $0x5, %edi
movq %r15, %rsi
movq %r12, %rdx
movl $0x5, %ecx
movq %r15, %r8
movq %r12, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x471b
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/makemap.c
// Function: initMap2
void initMap2(void) {
	freeMap();
	free(previous);
	setUpMap();
	setUPtile(getTile2);
	initPieces();
	placePieces();
}

// Assembly:
pushq %rax
callq 0x4533
leaq 0x8c31(%rip), %rax      # 0xd140
movq (%rax), %rdi
callq 0x1030
callq 0x3b21
leaq 0x138(%rip), %rdi       # 0x465b
callq 0x3e46
callq 0x3ef8
popq %rax
jmp 0x3fef
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/makemap.c
// Function: freeMap
void freeMap(void) {
	fruit(int i = 0; i < HEIGHT; i+=2) {
		fruit(int j = 0; j < WIDTH; j+=10) {
			free(map[i][j]);
			free(map[i][j+1]);
			free(map[i][j+2]);
			free(map[i][j+3]);
			free(map[i][j+4]);
			free(map[i][j+5]);
			free(map[i][j+6]);
			free(map[i][j+7]);
			free(map[i][j+8]);
			free(map[i][j+9]);
			free(map[i+1][j]);
			free(map[i+1][j+1]);
			free(map[i+1][j+2]);
			free(map[i+1][j+3]);
			free(map[i+1][j+4]);
			free(map[i+1][j+5]);
			free(map[i+1][j+6]);
			free(map[i+1][j+7]);
			free(map[i+1][j+8]);
			free(map[i+1][j+9]);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8df9(%rip), %rbx      # 0xd338
xorl %r14d, %r14d
movq $-0xa, %r15
movq -0x188(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x180(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x178(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x170(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x168(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x160(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x158(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x150(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x148(%rbx,%r15,8), %rdi
callq 0x1030
movq -0x140(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x8(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x10(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x18(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x20(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x28(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x30(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x38(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x40(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x48(%rbx,%r15,8), %rdi
callq 0x1030
movq 0x50(%rbx,%r15,8), %rdi
callq 0x1030
addq $0xa, %r15
cmpq $0x28, %r15
jb 0x4549
leaq 0x2(%r14), %rax
addq $0x320, %rbx            # imm = 0x320
cmpq $0x12, %r14
movq %rax, %r14
jb 0x4542
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/makemap.c
// Function: makeList
static void makeList(const int limit, int *const x, int *const y) {
	int i;
	fruit(i = 0; i < limit; i++) {
		x[i] = getRand(WIDTH - 1);
		y[i] = getRand(HEIGHT - 1);
	}
}

// Assembly:
testl %edi, %edi
jle 0x471a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r12d, %r12d
callq 0x11c0
cmpl $0x7fffffcf, %eax       # imm = 0x7FFFFFCF
jg 0x46b7
cltq
imulq $0x32000013, %rax, %rax # imm = 0x32000013
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x37, %rax
addl %ecx, %eax
movl %eax, (%r14,%r12,4)
callq 0x11c0
cmpl $0x7ffffff7, %eax       # imm = 0x7FFFFFF7
jg 0x46dd
movslq %eax, %rcx
imulq $-0x5ffffff5, %rcx, %rcx # imm = 0xA000000B
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x1a, %ecx
addl %eax, %ecx
movl %ecx, (%rbx,%r12,4)
incq %r12
cmpq %r15, %r12
jne 0x46b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/makemap.c
// Function: checkLocation
static void checkLocation(const int limit, int *const x, int *const y, const int check_limit, const int *const check_x,const int *const check_y) {
	//im sure there is a better way to do this. need to work on this part. 
	int i,j,k,change;
	i = 0;
	//while i is less than the length of x and y arrays
	while(i < limit) {
		change = 0;
		//loops through each element of check_x and check_y
		fruit(j = 0 ;j < check_limit; j++) {
			//if the elements to be compared are not the same
			if(&x[i] != &check_x[j]) {
				//check location -1, location 0, and then location +1
				fruit(k = -1; k < 2; k++) {
					//if item in x/y is to the left, at, or right of item in check_x/y
					if(x[i] == ((check_x[j]) + k) && y[i] == (check_y[j])) {
						x[i] = getRand(WIDTH-1);
						y[i] = getRand(HEIGHT-1);
						change = 1;
					}
					//if item in x/y is to the bottom, at, or above item in check_x/y
					else if(x[i] == (check_x[j]) && y[i] == ((check_y[j]) + k)) {
						x[i] = getRand(WIDTH - 1);
						y[i] = getRand(HEIGHT-1);
						change = 1;
					}
				}
			}
		}
		//if something was not changed, go to next item in x and y arrays
		if (change == 0) {
			i++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x30(%rsp)
movl %ecx, 0xc(%rsp)
movq %rsi, 0x20(%rsp)
movl %edi, 0x10(%rsp)
testl %edi, %edi
jle 0x4877
movq %rdx, %r15
movl 0xc(%rsp), %eax
movq %rax, 0x28(%rsp)
xorl %eax, %eax
movq %r9, 0x18(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x4866
movl %eax, 0x14(%rsp)
movl %eax, %r13d
movq 0x20(%rsp), %rax
leaq (%rax,%r13,4), %rbp
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x30(%rsp), %rcx
leaq (%rcx,%r14,4), %r12
cmpq %r12, %rbp
je 0x484b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%rbp), %ecx
movl (%r12), %edx
leal (%rdx,%rbx), %esi
cmpl %esi, %ecx
jne 0x47d8
movl (%r15,%r13,4), %esi
cmpl (%r9,%r14,4), %esi
jne 0x47d8
callq 0x11c0
cmpl $0x7fffffcf, %eax       # imm = 0x7FFFFFCF
jg 0x47a5
cltq
imulq $0x32000013, %rax, %rax # imm = 0x32000013
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x37, %rax
addl %ecx, %eax
movl %eax, (%rbp)
callq 0x11c0
cmpl $0x7ffffff7, %eax       # imm = 0x7FFFFFF7
jg 0x47ca
jmp 0x4819
cmpl %edx, %ecx
jne 0x4840
movl (%r9,%r14,4), %ecx
addl %ebx, %ecx
cmpl %ecx, (%r15,%r13,4)
jne 0x4840
callq 0x11c0
cmpl $0x7fffffcf, %eax       # imm = 0x7FFFFFCF
jg 0x47e8
cltq
imulq $0x32000013, %rax, %rax # imm = 0x32000013
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x37, %rax
addl %ecx, %eax
movl %eax, (%rbp)
callq 0x11c0
cmpl $0x7ffffff7, %eax       # imm = 0x7FFFFFF7
jg 0x480d
movq 0x18(%rsp), %r9
cltq
imulq $-0x5ffffff5, %rax, %rcx # imm = 0xA000000B
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x1a, %eax
addl %ecx, %eax
movl %eax, (%r15,%r13,4)
movl $0x1, %eax
incl %ebx
cmpl $0x2, %ebx
jne 0x478d
incq %r14
cmpq 0x28(%rsp), %r14
jne 0x4776
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl 0x14(%rsp), %eax
jmp 0x486b
movl $0x1, %ecx
addl %ecx, %eax
cmpl 0x10(%rsp), %eax
jl 0x4756
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/printenemy.c
// Function: printHero
void printHero(void) {
	wattron(game_win,WHITE);
	mvwprintw(game_win,11,10,"\\"); //sword
	mvwprintw(game_win,12,11,"\\"); //sword
	wattroff(game_win,WHITE);
	wattron(game_win,GREEN);
	mvwprintw(game_win,12,14,"|"); //upper torso
	mvwprintw(game_win,13,14,"|"); //lower torso
	wattroff(game_win,GREEN);
	wattron(game_win,YELLOW);
	mvwprintw(game_win,11,14,"O"); //head
	mvwprintw(game_win,12,12,"__"); //arms
	mvwprintw(game_win,12,15,"__"); //arms
	mvwprintw(game_win,14,13,"/ \\"); //legs
	mvwprintw(game_win,15,12,"/   \\"); //lowr legs
	wattroff(game_win,YELLOW);
	wattron(game_win,RED);
	mvwprintw(game_win,12,17,"|"); //sheild
	mvwprintw(game_win,13,17,"|"); //sheild
	wattroff(game_win,RED);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8354(%rip), %r15      # 0xd110
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5dc8(%rip), %rbx      # 0xab9d
movl $0xb, %esi
movl $0xa, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xc, %esi
movl $0xb, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5e9e(%rip), %rbx      # 0xacc6
movl $0xc, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xd, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
leaq 0x5c8b(%rip), %rcx      # 0xab06
movl $0xb, %esi
movl $0xe, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5c69(%rip), %r14      # 0xaaff
movl $0xc, %esi
movl $0xc, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xc, %esi
movl $0xf, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5c27(%rip), %rcx      # 0xaaf2
movl $0xe, %esi
movl $0xd, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
leaq 0x5bca(%rip), %rcx      # 0xaab0
movl $0xf, %esi
movl $0xc, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r15), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r15), %rdi
movl $0xc, %esi
movl $0x11, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0xd, %esi
movl $0x11, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r15), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/printenemy.c
// Function: printDog
void printDog(void) {
	wattron(game_win,WHITE);
	mvwprintw(game_win,12,26,"_"); //top of head
	mvwprintw(game_win,13,25,"<"); //snout
	wattroff(game_win,WHITE);
	wattron(game_win,RED);
	mvwprintw(game_win,13,26,"="); //eyes?
	wattroff(game_win,RED);	
	wattron(game_win,YELLOW);
	mvwprintw(game_win,12,27,"/"); //ears
	mvwprintw(game_win,13,27,"\\_______/"); //upperbody
	mvwprintw(game_win,14,28,"/\\    /\\"); //upper legs
	mvwprintw(game_win,15,27,"/  \\  /  \\"); //lower legs
	wattroff(game_win,YELLOW);	
}

// Assembly:
pushq %rbx
leaq 0x81b1(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5cff(%rip), %rcx      # 0xac77
movl $0xc, %esi
movl $0x1a, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5b23(%rip), %rcx      # 0xaab6
movl $0xd, %esi
movl $0x19, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5aec(%rip), %rcx      # 0xaab8
movl $0xd, %esi
movl $0x1a, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x5bac(%rip), %rcx      # 0xabb1
movl $0xc, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5a9a(%rip), %rcx      # 0xaaba
movl $0xd, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5a89(%rip), %rcx      # 0xaac4
movl $0xe, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x5a77(%rip), %rcx      # 0xaacd
movl $0xf, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
popq %rbx
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/return5[P]c_ish_one/./src/printenemy.c
// Function: printDelmerBody
void printDelmerBody(const int y, const int x) {
	wattron(game_win,YELLOW);
	mvwprintw(game_win,11+y,29+x,"^"); //top of body
	mvwprintw(game_win,12+y,27+x,"<( )>"); //side of body
	mvwprintw(game_win,13+y,29+x,"v"); // bottom of body
	wattroff(game_win,YELLOW);
	wattron(game_win,RED);
	mvwprintw(game_win,12+y,29+x,"0"); //eye
	wattroff(game_win,RED);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
movl %edi, %r14d
leaq 0x8084(%rip), %r12      # 0xd110
movq (%r12), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r12), %rdi
leal 0xb(%r14), %esi
leal 0x1d(%r15), %ebx
leaq 0x5aaa(%rip), %rcx      # 0xab59
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
leal 0xc(%r14), %ebp
addl $0x1b, %r15d
leaq 0x5a0d(%rip), %rcx      # 0xaad8
movl %ebp, %esi
movl %r15d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
addl $0xd, %r14d
leaq 0x59f8(%rip), %rcx      # 0xaade
movl %r14d, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r12), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r12), %rdi
leaq 0x59c3(%rip), %rcx      # 0xaae0
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r12), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x7066(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4a1d(%rip), %rcx      # 0xaae0
movl $0xd, %esi
movl $0x1e, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4a6b(%rip), %rcx      # 0xab49
movl $0xe, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4baf(%rip), %rcx      # 0xacc6
movl $0xe, %esi
movl $0x1e, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x49a2(%rip), %rcx      # 0xaaf2
movl $0xf, %esi
movl $0x1d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
popq %rbx
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x6f97(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x494e(%rip), %rcx      # 0xaae0
movl $0xd, %esi
movl $0x28, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x499c(%rip), %rcx      # 0xab49
movl $0xe, %esi
movl $0x26, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4ae0(%rip), %rcx      # 0xacc6
movl $0xe, %esi
movl $0x28, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x11b0
movq (%rbx), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x48d3(%rip), %rcx      # 0xaaf2
movl $0xf, %esi
movl $0x27, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
popq %rbx
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6ec3(%rip), %r14      # 0xd110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leal 0x1a(%rbx), %edx
leaq 0x489f(%rip), %rcx      # 0xab08
movl $0x9, %esi
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leal 0x1b(%rbx), %edx
leaq 0x486e(%rip), %rcx      # 0xab0e
movl $0x9, %esi
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
addl $0x1c, %ebx
leaq 0x49a0(%rip), %rcx      # 0xac77
movl $0x9, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x6e0d(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x47f6(%rip), %rcx      # 0xab12
movl $0xa, %esi
movl $0x19, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x47ea(%rip), %rcx      # 0xab21
movl $0xb, %esi
movl $0x1d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x47d6(%rip), %rcx      # 0xab28
movl $0xc, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x47c4(%rip), %rcx      # 0xab31
movl $0xd, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x47b4(%rip), %rcx      # 0xab3c
movl $0xe, %esi
movl $0x1a, %edx
xorl %eax, %eax
popq %rbx
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x6d67(%rip), %r14      # 0xd110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
addl $0x10, %ebp
leal 0x14(%rbx), %edx
leaq 0x4740(%rip), %rcx      # 0xab08
movl %ebp, %esi
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leal 0x15(%rbx), %edx
leaq 0x4712(%rip), %rcx      # 0xab0e
movl %ebp, %esi
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x200, %esi            # imm = 0x200
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
addl $0x16, %ebx
leaq 0x48e0(%rip), %rcx      # 0xad10
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x600, %esi            # imm = 0x600
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x11b0
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
leaq 0x6cb5(%rip), %r14      # 0xd110
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x4852(%rip), %rbx      # 0xacc6
movl $0xc, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0xd, %esi
movl $0xe, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x463f(%rip), %rcx      # 0xab06
movl $0xb, %esi
movl $0xe, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x461d(%rip), %rbx      # 0xaaff
movl $0xc, %esi
movl $0xc, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0xc, %esi
movl $0xf, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x45cb(%rip), %rcx      # 0xaae2
movl $0xe, %esi
movl $0xd, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x457e(%rip), %rcx      # 0xaab0
movl $0xf, %esi
movl $0xc, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6785(%rip), %r14      # 0xd118
movq (%r14), %rdi
callq 0x1090
decl %ebx
cmpl $0x6, %ebx
ja 0x69bc
movl %ebx, %eax
leaq 0x426d(%rip), %rcx      # 0xac18
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq (%r14), %rdi
xorl %eax, %eax
callq 0x1190
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x432c(%rip), %rdi      # 0x7fd0
xorl %esi, %esi
callq 0x4580
movq %rax, %rbx
leaq 0x1663(%rip), %r14      # 0x5318
movq %rax, %rdi
movq %r14, %rsi
callq 0x45da
leaq 0x1655(%rip), %rsi      # 0x531c
movq %rbx, %rdi
callq 0x45da
movq %rbx, %rdi
callq 0x45d6
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x1639(%rip), %rsi      # 0x5320
leaq 0x172a(%rip), %rcx      # 0x5418
leaq 0x1633(%rip), %r8       # 0x5328
movl $0x12, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3d99
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4805
movq %rax, %r13
leaq 0x15fe(%rip), %r15      # 0x531c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4805
movq %rax, %r12
xorl %edi, %edi
cmpq %r14, %r13
sete %dil
leaq 0x15e4(%rip), %rsi      # 0x5320
leaq 0x16d5(%rip), %rcx      # 0x5418
leaq 0x15f1(%rip), %r8       # 0x533b
movl $0x17, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3d99
xorl %edi, %edi
cmpq %r15, %r12
sete %dil
leaq 0x15b6(%rip), %rsi      # 0x5320
leaq 0x16a7(%rip), %rcx      # 0x5418
leaq 0x15d0(%rip), %r8       # 0x5348
movl $0x18, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3d99
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x485c
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r15
movl $0x5, (%r15)
leaq 0x8(%rsp), %r14
movl $0x2a, (%r14)
leaq -0x31(%rip), %rdi       # 0x3d9e
xorl %esi, %esi
callq 0x4580
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x45da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45da
movq %rbx, %rdi
callq 0x45d6
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x1519(%rip), %rsi      # 0x5320
leaq 0x160a(%rip), %rcx      # 0x5418
leaq 0x1513(%rip), %r8       # 0x5328
movl $0x2c, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3eca
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rsp, %r12
movl $0x2a, (%r12)
movq %rbx, %rdi
callq 0x4805
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4805
movq %rax, %r12
xorl %edi, %edi
cmpq %r15, %r13
sete %dil
leaq 0x14b8(%rip), %rsi      # 0x5320
leaq 0x15a9(%rip), %rcx      # 0x5418
leaq 0x14df(%rip), %r8       # 0x5355
movl $0x33, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3eca
xorl %edi, %edi
cmpq %r14, %r12
sete %dil
leaq 0x148a(%rip), %rsi      # 0x5320
leaq 0x157b(%rip), %rcx      # 0x5418
leaq 0x14bf(%rip), %r8       # 0x5363
movl $0x34, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3eca
movq %rbx, %rdi
callq 0x485c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x154(%rip), %rdi      # 0x3d9e
movq 0x40b7(%rip), %rsi      # 0x7fb0
callq 0x4580
movq %rax, %rbx
xorl %ebp, %ebp
movl $0x4, %edi
callq 0x2190
movl %ebp, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45da
incl %ebp
cmpl $0x64, %ebp
jne 0x3f03
movq %rbx, %rdi
callq 0x48b4
testq %rax, %rax
je 0x3f8d
movq %rax, %r14
leaq 0x13e8(%rip), %r15      # 0x5320
leaq 0x14d9(%rip), %r12      # 0x5418
leaq 0x142b(%rip), %r13      # 0x5371
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49bb
xorl %edi, %edi
cmpl (%rax), %ebp
sete %dil
movq %r15, %rsi
movl $0x4d, %edx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x400e
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x494c
movq %rax, %r14
testq %rax, %rax
jne 0x3f48
movq %rbx, %rdi
callq 0x48c8
testq %rax, %rax
je 0x3ff8
movq %rax, %r14
movl $0x63, %ebp
leaq 0x1377(%rip), %r15      # 0x5320
leaq 0x1468(%rip), %r12      # 0x5418
leaq 0x13c8(%rip), %r13      # 0x537f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49bb
xorl %edi, %edi
cmpl (%rax), %ebp
sete %dil
movq %r15, %rsi
movl $0x54, %edx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x400e
decl %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48dd
movq %rax, %r14
testq %rax, %rax
jne 0x3fb7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x485c
callq 0x2e1b
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
leaq 0x315c6(%rip), %rdi     # 0x40028
callq 0xe250
movq %rax, 0x56a5a(%rip)     # 0x654c8
leaq 0x315b7(%rip), %rsi     # 0x4002c
xorl %edi, %edi
callq 0xe230
movq %rax, 0x56a4d(%rip)     # 0x654d0
movq 0x56a3e(%rip), %rdi     # 0x654c8
movq %rax, %rsi
callq 0xe320
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1259e
movq %rax, %rbx
movq (%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xeb35
leaq 0x54f9e(%rip), %r12     # 0x63a58
leaq 0x54f9f(%rip), %r13     # 0x63a60
movq 0x8(%rsp), %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xeb2a
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %r14
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xeae6
testq %r14, %r14
je 0xeb1b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeb76
movq %r14, %rdi
callq 0x12844
movq (%r12), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xeb76
movq (%r13), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xeb76
movzwl (%rbp), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xead1
movq 0x10(%rbp), %rbp
cmpq 0x8(%rsp), %rbp
jne 0xeac6
movq 0x5698c(%rip), %rsi     # 0x654c8
leaq 0x398e6(%rip), %rdi     # 0x48429
leaq 0x314e8(%rip), %rdx     # 0x40032
movl $0x1, %ecx
callq 0xe280
movq 0x5696d(%rip), %rdi     # 0x654c8
callq 0xe380
callq 0xe350
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x5e0b5(%rip), %r12     # 0x6cc40
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x0, (%r12)
jle 0xebc0
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x22144
movq %r14, %rdi
movq %rax, %rsi
callq 0xe2a0
testl %eax, %eax
je 0xebbd
incl %ebp
cmpl (%r12), %ebp
jl 0xeb9d
jmp 0xebc0
movl %ebp, %r15d
testq %rbx, %rbx
je 0xece2
leaq 0x31434(%rip), %r12     # 0x40004
leaq 0x766a9(%rip), %r13     # 0x85280
movq %rbx, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xecd5
xorl %r14d, %r14d
movq 0x18(%rbp,%r14,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xec01
testq %rdi, %rdi
je 0xecc2
movl 0x4(%rdi), %eax
shrl $0x6, %eax
andl $0x3fff, %eax           # imm = 0x3FFF
cmpl %r15d, %eax
jne 0xecc2
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xec28
testb $0x2, 0x11(%rax)
jne 0xecc2
movl (%rdi), %esi
shrl $0x8, %esi
andl $0x1ff, %esi            # imm = 0x1FF
cmpl $0xf, %esi
jg 0xec8e
cmpl $0x8, %esi
ja 0xecf1
movl %esi, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x48(%rdi), %rcx
cmpq %r13, %rcx
je 0xec6e
xorl %edx, %edx
movq %rdx, %rax
movq %rcx, %rdx
movq 0x8(%rcx), %rsi
movq %rsi, %rcx
cmpq %r13, %rsi
jne 0xec57
testq %rax, %rax
jne 0xec72
leaq 0x4(%rdi), %rax
movq 0x56857(%rip), %rdx     # 0x654d0
movq (%rax), %rax
movq %rax, 0xc(%rdi)
leaq 0x35fbb(%rip), %rsi     # 0x44c42
callq 0xf033
jmp 0xecc2
cmpl $0x3f, %esi
jle 0xecaa
cmpl $0x40, %esi
je 0xecc2
cmpl $0x80, %esi
je 0xecc2
cmpl $0x100, %esi            # imm = 0x100
je 0xecc2
jmp 0xecf1
cmpl $0x10, %esi
je 0xecb6
cmpl $0x20, %esi
je 0xecc2
jmp 0xecf1
movq 0x56813(%rip), %rsi     # 0x654d0
callq 0xecff
incq %r14
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r14
jl 0xebe9
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xebda
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31340(%rip), %rdi     # 0x40038
xorl %eax, %eax
callq 0x12406
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/ast.c
// Function: ast_new_ast
struct ast *ast_new_ast(struct loc *loc, enum ast_tag tag, size_t n_childs, ...)
{
    struct ast_ast *ast = malloc(sizeof *ast + n_childs * sizeof *ast->childs);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->n_childs = n_childs;
    
    va_list va;
    va_start(va, n_childs);

    for (size_t i = 0; i < n_childs; i++)
        ast->childs[i] = va_arg(va, struct ast *);

    va_end(va);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x25b3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(,%rdx,8), %rdi
callq 0x2160
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x10(%rsp)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rsp)
testq %rbx, %rbx
je 0x262f
movl (%rsp), %ecx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
cmpl $0x28, %ecx
ja 0x2613
movq %rdi, %r8
movl %ecx, %edi
addq %rdx, %rdi
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x261c
leaq 0x8(%rdi), %r8
movq %r8, 0x8(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rax,%rsi,8)
incq %rsi
movq %r8, %rdi
cmpq %rsi, %rbx
jne 0x25fe
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/ast.c
// Function: ast_new_list
struct ast *ast_new_list(struct loc *loc, enum ast_tag tag, struct ast_list *ast_list)
{
    size_t n_childs = 0;
    for (struct ast_list *i = ast_list; i != NULL; i = i->next)
        n_childs++;

    struct ast_ast *ast = malloc(sizeof *ast + n_childs * sizeof *ast->childs);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->n_childs = n_childs;

    size_t i = 0;
    for (struct ast_list *j = ast_list; j != NULL; j = j->next)
        ast->childs[i++] = ast_ref(j->ast);

    ast_list_del(ast_list);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x2664
movq %rbx, %rax
incq %r12
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2658
leaq 0x20(,%r12,8), %rdi
callq 0x2160
movq %rax, %r15
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x18(%rax)
testq %rbx, %rbx
je 0x26a0
movq %r15, %rax
addq $0x20, %rax
movq %rbx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
addq $0x8, %rax
testq %rcx, %rcx
jne 0x268d
movq %rbx, %rdi
callq 0x26b8
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/ast.c
// Function: ast_chars
const char *ast_chars(struct ast *ast, size_t *n)
{
    assert(ast_has_chars(ast->tag));
    struct ast_chars *a = (struct ast_chars *)ast;
    *n = a->n;
    return a->s;
}

// Assembly:
movl $0xf000, %eax           # imm = 0xF000
andl (%rdi), %eax
cmpl $0x5000, %eax           # imm = 0x5000
jne 0x2746
movq 0x20(%rdi), %rax
movq %rax, (%rsi)
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0xaa5e(%rip), %rdi      # 0xd1ac
leaq 0xaa79(%rip), %rsi      # 0xd1ce
leaq 0xaa92(%rip), %rcx      # 0xd1ee
leaq 0xaaa3(%rip), %r8       # 0xd206
movl $0x7a, %edx
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/ast.c
// Function: ast_asts
struct ast **ast_asts(struct ast *ast, size_t *n_childs)
{
    assert(ast_has_ast(ast->tag));
    assert(n_childs);

    *n_childs = ((struct ast_ast *)ast)->n_childs;
    return ((struct ast_ast *)ast)->childs;
}

// Assembly:
pushq %rax
movl $0xf000, %eax           # imm = 0xF000
andl (%rdi), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x2849
testq %rsi, %rsi
je 0x286c
movq 0x18(%rdi), %rax
movq %rax, (%rsi)
addq $0x20, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0xa95c(%rip), %rdi      # 0xd1ac
leaq 0xa977(%rip), %rsi      # 0xd1ce
leaq 0xa9e6(%rip), %rcx      # 0xd244
leaq 0xa9fd(%rip), %r8       # 0xd262
movl $0x99, %edx
jmp 0x288d
leaq 0xa939(%rip), %rdi      # 0xd1ac
leaq 0xa954(%rip), %rsi      # 0xd1ce
leaq 0xa9ea(%rip), %rcx      # 0xd26b
leaq 0xa9da(%rip), %r8       # 0xd262
movl $0x9a, %edx
xorl %eax, %eax
callq 0x4eac
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: new_lbl
struct lbl *new_lbl(const char *name, bool defined)
{
    struct lbl *lbl = malloc(sizeof *lbl);
    lbl->name = strdup(name);
    lbl->c_name = gen_c_ident();
    lbl->defined = defined;
    lbl->next = lbl_list;
    lbl_list = lbl;

    strmap_add(zc_func_labels, name, lbl);

    return lbl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x28, %edi
callq 0x2160
movq %rax, %r14
movq %rbx, %rdi
callq 0x2220
movq %rax, (%r14)
movl $0xd, %edi
callq 0x2160
movq %rax, %r15
movl 0x10bf5(%rip), %ecx     # 0x13d98
leal 0x1(%rcx), %eax
movl %eax, 0x10bec(%rip)     # 0x13d98
leaq 0xa754(%rip), %rdx      # 0xd907
movl $0xd, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
movq %r15, 0x8(%r14)
movb %bpl, 0x10(%r14)
movq 0x10bbf(%rip), %rax     # 0x13d90
movq %rax, 0x20(%r14)
movq %r14, 0x10bb4(%rip)     # 0x13d90
leaq 0x10c3d(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xb210
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: check_lbl_list
void check_lbl_list(struct lbl *lbl_node)
{
    if (lbl_node == NULL)
        return;

    if (!lbl_node->defined)
        fatal(lbl_node->first_use->loc, "undefined label %s", lbl_node->name);

    free(lbl_node->name);
    free(lbl_node->c_name);
    check_lbl_list(lbl_node->next);
    free(lbl_node);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3269
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x326b
movq (%rbx), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x3237
movq %rbx, %rdi
popq %rbx
jmp 0x2030
popq %rbx
retq
movq (%rbx), %rdx
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0xa3eb(%rip), %rsi      # 0xd668
xorl %eax, %eax
callq 0x4fa1
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: goto_label
const char *goto_label(const char *name, struct ast *goto_stmt)
{
    struct lbl *lbl = strmap_get(zc_func_labels, name);

    if (lbl != NULL)
        return lbl->c_name;

    lbl = new_lbl(name, false);
    lbl->first_use = goto_stmt;

    return lbl->c_name;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10b8b(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb18b
testq %rax, %rax
jne 0x32b3
movq %r14, %rdi
xorl %esi, %esi
callq 0x316c
movq %rbx, 0x18(%rax)
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: define_label
const char *define_label(const char *name)
{
    struct lbl *lbl = strmap_get(zc_func_labels, name);

    if (lbl != NULL) {
        lbl->defined = true;
        return lbl->c_name;
    }

    lbl = new_lbl(name, true);
    return lbl->c_name;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10b56(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xb18b
testq %rax, %rax
je 0x32e0
movb $0x1, 0x10(%rax)
jmp 0x32ed
movq %rbx, %rdi
movl $0x1, %esi
callq 0x316c
movq 0x8(%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: add_indent_lev
struct rope *add_indent_lev(struct rope *rope, size_t lev)
{
    if (rope == NULL)
        return NULL;
    for (int i = 0; i < lev; i++)
        rope = rope_new_tree(indent_rope, rope);
    return rope;
}

// Assembly:
testq %rdi, %rdi
je 0x3357
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
testq %rsi, %rsi
je 0x334f
leaq 0xff41(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
decq %rbx
jne 0x333f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: ptr_type_to_c
struct rope *ptr_type_to_c(struct rope *decl, struct ptr_type *type)
{
    decl = rope_new_tree(star_rope, decl);
    if (is_func_type(type->to) || is_array_type(type->to))
        decl = add_paren(decl);

    return type_to_c(decl, type->to);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x1026f(%rip), %rdi     # 0x13660
callq 0xaebf
movq 0x8(%rbx), %rsi
testb $0x30, (%rsi)
je 0x3421
leaq 0xfe9a(%rip), %rdi      # 0x132a0
movq %rax, %rsi
callq 0xaebf
leaq 0xfeab(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xaebf
movq 0x8(%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x342a
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: func_type_to_c
struct rope *func_type_to_c(struct rope *decl, struct func_type *type)
{
    decl = rope_new_tree(decl, lparen_rope);

    if (type->n_params == 0) {
        if (!type->has_vararg)
            decl = rope_new_tree(decl, void_rope);
    } else {
        for (size_t i = 0; i < type->n_params; ++i) {
            struct rope *param = type_to_c(NULL, type->params[i]);
            decl = rope_new_tree(decl, param);

            if (i != type->n_params - 1)
                decl = rope_new_tree(decl, comma_sp_rope);
        }
        if (type->has_vararg) {
            decl = rope_new_tree(decl, comma_sp_rope);
            decl = rope_new_tree(decl, ellipsis_rope);
        }
    }

    decl = rope_new_tree(decl, rparen_rope);

    return type_to_c(decl, type->ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xfdbc(%rip), %rsi      # 0x132a0
callq 0xaebf
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x355f
xorl %r12d, %r12d
leaq 0x10003(%rip), %r15     # 0x13500
movq 0x20(%rbx,%r12,8), %rsi
xorl %edi, %edi
callq 0x342a
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %r14
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r12
je 0x3536
movq %r14, %rdi
movq %r15, %rsi
callq 0xaebf
movq %rax, %r14
movq 0x10(%rbx), %rax
incq %r12
cmpq %rax, %r12
jb 0x34fd
cmpb $0x0, 0x18(%rbx)
je 0x3577
leaq 0xffb5(%rip), %rsi      # 0x13500
movq %r14, %rdi
callq 0xaebf
leaq 0xffe6(%rip), %rsi      # 0x13540
movq %rax, %rdi
jmp 0x356f
cmpb $0x0, 0x18(%rbx)
jne 0x3577
leaq 0xfff4(%rip), %rsi      # 0x13560
movq %r14, %rdi
callq 0xaebf
movq %rax, %r14
leaq 0xfd42(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0xaebf
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x342a
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: struct_def_to_c
struct rope *struct_def_to_c(struct struct_type *type)
{
    struct rope *rope;
    rope = rope_new_tree(struct_sp_rope, rope_new_s(type->cname));
    rope = rope_new_tree(rope, sp_rope);
    rope = rope_new_tree(rope, lcurly_nl_rope);

    for (size_t i = 0; i < type->n_fields; ++i)
        rope = rope_new_tree(rope, field_to_c(&type->fields[i]));

    return rope_new_tree(rope, rcurly_rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xaee6
leaq 0x10111(%rip), %rdi     # 0x13700
movq %rax, %rsi
callq 0xaebf
leaq 0x10082(%rip), %rsi     # 0x13680
movq %rax, %rdi
callq 0xaebf
leaq 0xfd53(%rip), %rsi      # 0x13360
movq %rax, %rdi
callq 0xaebf
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x3649
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x359d
movq %r14, %rdi
movq %rax, %rsi
callq 0xaebf
movq %rax, %r14
incq %r12
addq $0x10, %r15
cmpq 0x10(%rbx), %r12
jb 0x3626
leaq 0xfd70(%rip), %rsi      # 0x133c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaebf
// File: /workspace/github_c_makefile_star2_O3/ryvnf[P]czc/codegen.c
// Function: struct_type_to_c
struct rope *struct_type_to_c(struct rope *decl, struct struct_type *type)
{
    struct rope *rope = rope_new_tree(struct_sp_rope, rope_new_s(type->cname));
    if (decl != NULL) {
        rope = rope_new_tree(rope, sp_rope);
        rope = rope_new_tree(rope, decl);
    }
    return rope;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
callq 0xaee6
leaq 0x10089(%rip), %rdi     # 0x13700
movq %rax, %rsi
callq 0xaebf
testq %rbx, %rbx
je 0x369f
leaq 0xfff5(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xaebf
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xaebf
popq %rbx
retq