LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x8816(%rip), %r14      # 0xe110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x51cd(%rip), %rcx      # 0xaae0
pushq $0xd
popq %rsi
pushq $0x1e
popq %rbx
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x521d(%rip), %rcx      # 0xab49
pushq $0xe
popq %rbp
pushq $0x1c
popq %rdx
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 $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x5363(%rip), %rcx      # 0xacc6
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x515c(%rip), %rcx      # 0xaaf2
pushq $0xf
popq %rsi
pushq $0x1d
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x800, %esi            # imm = 0x800
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
leaq 0x874f(%rip), %r14      # 0xe110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x5106(%rip), %rcx      # 0xaae0
pushq $0xd
popq %rsi
pushq $0x28
popq %rbx
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x5156(%rip), %rcx      # 0xab49
pushq $0xe
popq %rbp
pushq $0x26
popq %rdx
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 $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x529c(%rip), %rcx      # 0xacc6
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x700, %esi            # imm = 0x700
xorl %edx, %edx
callq 0x11b0
movq (%r14), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x5095(%rip), %rcx      # 0xaaf2
pushq $0xf
popq %rsi
pushq $0x27
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
movl $0x500, %esi            # imm = 0x500
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x867c(%rip), %r14      # 0xe110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leal 0x1a(%rbx), %edx
leaq 0x5058(%rip), %rcx      # 0xab08
pushq $0x9
popq %rbp
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 0x1b(%rbx), %edx
leaq 0x5027(%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 $0x1c, %ebx
leaq 0x515c(%rip), %rcx      # 0xac77
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
// File: /workspace/github_c_makefile_star2_O2/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 0x85cf(%rip), %rbx      # 0xe110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4fb8(%rip), %rcx      # 0xab12
pushq $0xa
popq %rsi
pushq $0x19
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4fb0(%rip), %rcx      # 0xab21
pushq $0xb
popq %rsi
pushq $0x1d
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4fa0(%rip), %rcx      # 0xab28
pushq $0xc
popq %rsi
pushq $0x1c
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4f92(%rip), %rcx      # 0xab31
pushq $0xd
popq %rsi
pushq $0x1b
popq %rdx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4f86(%rip), %rcx      # 0xab3c
pushq $0xe
popq %rsi
pushq $0x1a
popq %rdx
xorl %eax, %eax
popq %rbx
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O2/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 0x853d(%rip), %r14      # 0xe110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
addl $0x10, %ebp
leal 0x14(%rbx), %edx
leaq 0x4f16(%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 0x4ee8(%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 0x50b6(%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
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8486(%rip), %r13      # 0xe110
movq (%r13), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r13), %rdi
leaq 0x5021(%rip), %r15      # 0xacc6
pushq $0xc
popq %rbx
pushq $0xe
popq %rbp
movl %ebx, %esi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
pushq $0xd
popq %r14
movl %r14d, %esi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x11b0
movq (%r13), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r13), %rdi
leaq 0x4e0b(%rip), %rcx      # 0xab06
pushq $0xb
popq %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
leaq 0x4ded(%rip), %r15      # 0xaaff
movl %ebx, %esi
movl %ebx, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
pushq $0xf
popq %r12
movl %ebx, %esi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
leaq 0x4da0(%rip), %rcx      # 0xaae2
movl %ebp, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
leaq 0x4d57(%rip), %rcx      # 0xaab0
movl %r12d, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r13), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x11b0
movq (%r13), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O2/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 0x7fff(%rip), %r14      # 0xe118
movq (%r14), %rdi
callq 0x1090
decl %ebx
cmpl $0x6, %ebx
ja 0x6142
movl %ebx, %eax
leaq 0x4ae7(%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_O2/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 0x455f(%rip), %rdi      # 0x7fd0
xorl %esi, %esi
callq 0x42f8
movq %rax, %rbx
leaq 0x1896(%rip), %r14      # 0x5318
movq %rax, %rdi
movq %r14, %rsi
callq 0x434a
leaq 0x1888(%rip), %rsi      # 0x531c
movq %rbx, %rdi
callq 0x434a
movq %rbx, %rdi
callq 0x4346
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x186c(%rip), %rsi      # 0x5320
leaq 0x195d(%rip), %rcx      # 0x5418
leaq 0x1866(%rip), %r8       # 0x5328
pushq $0x12
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3b60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4570
movq %rax, %r13
leaq 0x1833(%rip), %r15      # 0x531c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4570
movq %rax, %r12
xorl %edi, %edi
cmpq %r14, %r13
sete %dil
leaq 0x1819(%rip), %rsi      # 0x5320
leaq 0x190a(%rip), %rcx      # 0x5418
leaq 0x1826(%rip), %r8       # 0x533b
pushq $0x17
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3b60
xorl %edi, %edi
cmpq %r15, %r12
sete %dil
leaq 0x17ed(%rip), %rsi      # 0x5320
leaq 0x18de(%rip), %rcx      # 0x5418
leaq 0x1807(%rip), %r8       # 0x5348
pushq $0x18
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3b60
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x45d0
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/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       # 0x3b65
xorl %esi, %esi
callq 0x42f8
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x434a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x434a
movq %rbx, %rdi
callq 0x4346
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x1752(%rip), %rsi      # 0x5320
leaq 0x1843(%rip), %rcx      # 0x5418
leaq 0x174c(%rip), %r8       # 0x5328
pushq $0x2c
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3c8b
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rsp, %r12
movl $0x2a, (%r12)
movq %rbx, %rdi
callq 0x4570
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4570
movq %rax, %r12
xorl %edi, %edi
cmpq %r15, %r13
sete %dil
leaq 0x16f3(%rip), %rsi      # 0x5320
leaq 0x17e4(%rip), %rcx      # 0x5418
leaq 0x171a(%rip), %r8       # 0x5355
pushq $0x33
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3c8b
xorl %edi, %edi
cmpq %r14, %r12
sete %dil
leaq 0x16c7(%rip), %rsi      # 0x5320
leaq 0x17b8(%rip), %rcx      # 0x5418
leaq 0x16fc(%rip), %r8       # 0x5363
pushq $0x34
popq %rdx
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3c8b
movq %rbx, %rdi
callq 0x45d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/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 -0x14c(%rip), %rdi      # 0x3b65
movq 0x42f8(%rip), %rsi      # 0x7fb0
callq 0x42f8
movq %rax, %rbx
xorl %ebp, %ebp
cmpl $0x64, %ebp
je 0x3cdd
movl %ebp, %edi
callq 0x3c90
movq %rbx, %rdi
movq %rax, %rsi
callq 0x434a
incl %ebp
jmp 0x3cc2
movq %rbx, %rdi
callq 0x4628
movq %rax, %r14
leaq 0x1729(%rip), %r12      # 0x5418
leaq 0x167b(%rip), %r13      # 0x5371
pushq $0x4d
popq %rbp
xorl %r15d, %r15d
movq %rbx, %rdi
testq %r14, %r14
je 0x3d46
movq %r14, %rsi
callq 0x4711
xorl %edi, %edi
cmpl (%rax), %r15d
sete %dil
leaq 0x1604(%rip), %rsi      # 0x5320
movl %ebp, %edx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3dbf
incl %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46b1
movq %rax, %r14
jmp 0x3cfc
callq 0x463e
movq %rax, %r14
pushq $0x63
popq %r15
leaq 0x16bf(%rip), %r12      # 0x5418
leaq 0x161f(%rip), %r13      # 0x537f
pushq $0x54
popq %rbp
testq %r14, %r14
je 0x3da9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4711
xorl %edi, %edi
cmpl (%rax), %r15d
sete %dil
leaq 0x159d(%rip), %rsi      # 0x5320
movl %ebp, %edx
movq %r12, %rcx
movq %r13, %r8
xorl %eax, %eax
callq 0x238c
testl %eax, %eax
je 0x3dbf
decl %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4655
movq %rax, %r14
jmp 0x3d63
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45d0
callq 0x2bb0
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%r14)
leaq 0x2ab59(%rip), %rdi     # 0x39028
callq 0xe260
movq %rax, 0x50ffd(%rip)     # 0x5f4d8
leaq 0x2ab4a(%rip), %rsi     # 0x3902c
xorl %edi, %edi
callq 0xe240
movq %rax, 0x50ff0(%rip)     # 0x5f4e0
movq 0x50fe1(%rip), %rdi     # 0x5f4d8
movq %rax, %rsi
callq 0xe330
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x11c20
movq %rax, %rbx
movq (%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xe58f
leaq 0x4f545(%rip), %r12     # 0x5da68
leaq 0x4f546(%rip), %r13     # 0x5da70
movq 0x8(%rsp), %rbp
xorl %r15d, %r15d
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xe584
movq 0x18(%rbp,%r15,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0xe54e
testq %r14, %r14
je 0xe57f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe5ce
movq %r14, %rdi
callq 0x11eb5
movq (%r12), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xe5ce
movq (%r13), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xe5ce
incq %r15
jmp 0xe532
movq 0x10(%rbp), %rbp
cmpq 0x8(%rsp), %rbp
jne 0xe52f
movq 0x50f42(%rip), %rsi     # 0x5f4d8
leaq 0x32e4e(%rip), %rdi     # 0x413eb
leaq 0x2aa8e(%rip), %rdx     # 0x39032
pushq $0x1
popq %rcx
callq 0xe290
movq 0x50f25(%rip), %rdi     # 0x5f4d8
callq 0xe390
callq 0xe360
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_O2/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
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x58668(%rip), %r12     # 0x66c50
pushq $-0x1
popq %r15
cmpl (%r12), %ebp
jge 0xe60f
movl %ebp, %edi
callq 0x20874
movq %r14, %rdi
movq %rax, %rsi
callq 0xe2b0
testl %eax, %eax
je 0xe60c
incl %ebp
jmp 0xe5ec
movl %ebp, %r15d
testq %rbx, %rbx
je 0xe715
leaq 0x2a9e5(%rip), %r12     # 0x39004
leaq 0x70c6a(%rip), %r13     # 0x7f290
movq %rbx, %rbp
xorl %r14d, %r14d
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r14
jge 0xe708
movq 0x18(%rbp,%r14,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xe650
testq %rdi, %rdi
je 0xe700
movl 0x4(%rdi), %eax
shrl $0x6, %eax
andl $0x3fff, %eax           # imm = 0x3FFF
cmpl %r15d, %eax
jne 0xe700
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xe677
testb $0x2, 0x11(%rax)
jne 0xe700
movl (%rdi), %esi
shrl $0x8, %esi
andl $0x1ff, %esi            # imm = 0x1FF
cmpl $0x8, %esi
jbe 0xe6a8
cmpl $0x10, %esi
je 0xe6b1
cmpl $0x20, %esi
je 0xe700
cmpl $0x40, %esi
je 0xe700
cmpl $0x80, %esi
je 0xe700
cmpl $0x100, %esi            # imm = 0x100
je 0xe700
jmp 0xe724
movslq (%r12,%rsi,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x50e28(%rip), %rsi     # 0x5f4e0
callq 0xe732
jmp 0xe700
leaq 0x4(%rdi), %rax
movq 0x50e16(%rip), %rdx     # 0x5f4e0
leaq 0x48(%rdi), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
movq %r9, %rsi
movq %r8, %r9
movq (%rcx), %r8
leaq 0x8(%r8), %rcx
cmpq %r13, %r8
jne 0xe6d4
testq %rsi, %rsi
cmovneq %rsi, %rax
movq (%rax), %rax
movq %rax, 0xc(%rdi)
leaq 0x2f547(%rip), %rsi     # 0x3dc42
callq 0xe958
incq %r14
jmp 0xe62c
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xe629
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a90d(%rip), %rdi     # 0x39038
xorl %eax, %eax
callq 0x11a8a
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/c2xml.c
// Function: examine_members
static inline void examine_members(struct symbol_list *list, xmlNodePtr node)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		examine_symbol(sym, node);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xebb6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0xeba2
movq 0x18(%r15,%r12,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xeb95
testq %rdi, %rdi
je 0xeb9d
movq %rbx, %rsi
callq 0xe732
incq %r12
jmp 0xeb79
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0xeb76
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/accre[P]Cprogramming/pass_command_line_options.c
// Function: main
int main(int argc, char **argv)
{

   // argc captures the number of command-line arguments
   // note: The executable command (./command_line) is 
   // always the first argument, and the remaining arguments
   // are separated by spaces      
   printf("argc: %d\n",argc);
   if ( argc != 3 ) {
      printf("Usage: ./pass_command_line_options arg1 arg2\n");
      printf("where arg1 is an integer and arg2 is a floating point number\n");
      exit(0);
   }
   
   // argv captures each argument in an array of characters
   // Here we loop over all arguments and print the value
   int i;
   for (i=0;i<argc;i++) {
      // %d is for integers, %s is for an array of characters
      printf("i: %d argv[i]: %s\n",i,argv[i]); 
   }

   // since command-line arguments are read in as an 
   // array of characters, they must be converted
   // to the appropriate type (e.g. int, float)
   i = 1;
   int myarg_int = 0;
   float myarg_float = 0.0;
   if ( argc > 1 ) myarg_int = atoi(argv[i]);
   ++i; 
   if ( argc > 2 ) myarg_float = atof(argv[i]);

   // %d is for integer
   // %10.5f is for the floating point number, 10 is the width of the number
   // and 5 is the precision after the decimal point. If more precision is 
   // needed, 10.5 can be changed.
   printf("myarg_int: %d myarg_float: %10.5f\n",myarg_int,myarg_float);

   return 0;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xe75(%rip), %rdi       # 0x2004
movl %ebp, %esi
xorl %eax, %eax
callq 0x1050
cmpl $0x3, %ebp
jne 0x11fc
leaq 0xe6a(%rip), %r14       # 0x200e
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x11c3
movq (%rbx,%r15,8), %rdx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
incq %r15
jmp 0x11a7
movq 0x8(%rbx), %rdi
callq 0x1060
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe3b(%rip), %rdi       # 0x2021
movl %ebp, %esi
movb $0x1, %al
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe41(%rip), %rdi       # 0x2044
callq 0x1030
leaq 0xe62(%rip), %rdi       # 0x2071
callq 0x1030
xorl %edi, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_new
struct ast *ast_new(struct loc *loc, enum ast_tag tag)
{
    struct ast *ast = malloc(sizeof *ast);
    ast->loc = loc;
    ast->tag = tag;
    return ast;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x2160
movq %r14, 0x8(%rax)
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_new_s
struct ast *ast_new_s(struct loc *loc, enum ast_tag tag, char *s)
{
    struct ast_s *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->s = strdup(s);
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x2160
movq %rax, %r15
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, %rdi
callq 0x2220
movq %rax, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_new_chars
struct ast *ast_new_chars(struct loc *loc, enum ast_tag tag, char *s, size_t n)
{
    struct ast_chars *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->s = strdup(s);
    ast->n = n;
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x2160
movq %rax, %r12
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
callq 0x2220
movq %rax, 0x18(%r12)
movq %rbx, 0x20(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_new_i
struct ast *ast_new_i(struct loc *loc, enum ast_tag tag, long long int i)
{
    struct ast_i *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->i = i;
    return (struct ast *)ast;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x2160
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_new_f
struct ast *ast_new_f(struct loc *loc, enum ast_tag tag, double f)
{
    struct ast_f *ast = malloc(sizeof *ast);
    ast->ast.tag = tag;
    ast->ast.loc = loc;
    ast->f = f;
    return (struct ast *)ast;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x2160
movl %ebx, (%rax)
movq %r14, 0x8(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24b9
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), %rsi
movq %rsi, 0x8(%rsp)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rsp)
pushq $0x18
popq %rcx
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x2528
cmpl $0x28, %ecx
ja 0x250f
movq %rsi, %rdi
movl %ecx, %esi
addq %r15, %rsi
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x2518
leaq 0x8(%rsi), %rdi
movq %rdi, 0x8(%rsp)
movq (%rsi), %rsi
movq %rsi, 0x20(%rax,%rdx,8)
incq %rdx
movq %rdi, %rsi
jmp 0x24f5
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
xorl %r12d, %r12d
movq %rdx, %rax
testq %rax, %rax
je 0x2561
incq %r12
movq 0x8(%rax), %rax
addq $0x8, %rdi
jmp 0x254f
callq 0x2160
movq %rax, %r15
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x18(%rax)
addq $0x20, %rax
movq %rbx, %rcx
testq %rcx, %rcx
je 0x258f
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
addq $0x8, %rax
jmp 0x257a
movq %rbx, %rdi
callq 0x25a7
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_list_new
struct ast_list *ast_list_new(struct ast *ast)
{
    struct ast_list *ast_list = malloc(sizeof *ast_list);
    ast_list->ast = ast;
    ast_list->next = NULL;

    return ast_list;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2160
movq %rbx, (%rax)
andq $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x262e
movq 0x20(%rdi), %rax
movq %rax, (%rsi)
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0x8b76(%rip), %rdi      # 0xb1ac
leaq 0x8b91(%rip), %rsi      # 0xb1ce
leaq 0x8baa(%rip), %rcx      # 0xb1ee
leaq 0x8bbb(%rip), %r8       # 0xb206
pushq $0x7a
popq %rdx
xorl %eax, %eax
callq 0x4918
// File: /workspace/github_c_makefile_star2_O2/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 0x272f
testq %rsi, %rsi
je 0x2752
movq 0x18(%rdi), %rax
movq %rax, (%rsi)
addq $0x20, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x8a76(%rip), %rdi      # 0xb1ac
leaq 0x8a91(%rip), %rsi      # 0xb1ce
leaq 0x8b00(%rip), %rcx      # 0xb244
leaq 0x8b17(%rip), %r8       # 0xb262
movl $0x99, %edx
jmp 0x2773
leaq 0x8a53(%rip), %rdi      # 0xb1ac
leaq 0x8a6e(%rip), %rsi      # 0xb1ce
leaq 0x8b04(%rip), %rcx      # 0xb26b
leaq 0x8af4(%rip), %r8       # 0xb262
movl $0x9a, %edx
xorl %eax, %eax
callq 0x4918
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_print
void ast_print(struct ast *ast, int indent)
{
    for (int j = 0; j < indent; j++)
        fputs("  ", stdout);

    if (ast == NULL) {
        puts("NULL");
        return;
    }

    switch (ast_val_type(ast->tag)) {
        case AST_NO_VAL:
            printf("%s\n", ast_tag_name(ast->tag));
            break;
        case AST_S:
            printf("%s \"%s\"\n", ast_tag_name(ast->tag), ast_s(ast));
            break;
        case AST_I:
            printf("%s %lld\n", ast_tag_name(ast->tag), ast_i(ast));
            break;
        case AST_F:
            printf("%s %f\n", ast_tag_name(ast->tag), ast_f(ast));
            break;
        case AST_AST:
            printf("%s\n", ast_tag_name(ast->tag));
            ast_print_childs(ast, indent);
            break;
        case AST_CHARS:
            printf("%s <CHARS>\n", ast_tag_name(ast->tag));
            break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
movq 0xf3ac(%rip), %r12      # 0x11fd0
leaq 0x9b6d(%rip), %r15      # 0xc798
subl $0x1, %ebp
jb 0x2c3e
movq (%r12), %rsi
movq %r15, %rdi
callq 0x20e0
jmp 0x2c2b
testq %r14, %r14
je 0x2c6d
movl (%r14), %edi
movl %edi, %eax
shrl $0xc, %eax
andl $0xf, %eax
cmpl $0x5, %eax
ja 0x2cbe
leaq 0x8522(%rip), %rcx      # 0xb17c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x277a
movq %rax, %rdi
jmp 0x2c74
leaq 0x895b(%rip), %rdi      # 0xb5cf
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2070
callq 0x277a
movq %rax, %rdi
callq 0x2070
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x270b
movq %rax, %r14
incl %ebx
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
jae 0x2cbe
movq (%r14,%r15,8), %rdi
movl %ebx, %esi
callq 0x2c05
incq %r15
jmp 0x2ca7
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x277a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2655
leaq 0x88fb(%rip), %rdi      # 0xb5dd
jmp 0x2d28
callq 0x277a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2691
leaq 0x88eb(%rip), %rdi      # 0xb5e6
movq %rbx, %rsi
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
callq 0x277a
movq %rax, %rbx
movq %r14, %rdi
callq 0x25da
leaq 0x88ac(%rip), %rdi      # 0xb5d4
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
callq 0x277a
leaq 0x88a0(%rip), %rdi      # 0xb5ed
movq %rax, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/ast.c
// Function: ast_equals
bool ast_equals(struct ast *a, struct ast *b)
{
    if (a->tag != b->tag)
        return false;

    switch (a->tag) {
        case AST_NO_VAL:
            return true;
        case AST_S:
            return strcmp(ast_s(a), ast_s(b));
        case AST_I:
            return ast_i(a) == ast_i(b);
        case AST_F:
            return ast_f(a) == ast_f(b);
        case AST_AST: {
            size_t n_a_asts, n_b_asts;
            struct ast **a_asts = ast_asts(a, &n_a_asts);
            struct ast **b_asts = ast_asts(b, &n_b_asts);

            if (n_a_asts != n_b_asts)
                return false;

            for (size_t i = 0; i < n_a_asts; i++) {
                if (!ast_equals(a_asts[i], b_asts[i]))
                    return false;
            }

            return true;
        }
        case AST_CHARS: {
            size_t a_n, b_n;
            const char *a_s = ast_chars(a, &a_n);
            const char *b_s = ast_chars(b, &b_n);

            if (a_n != b_n)
                return false;

            return memcmp(a_s, b_s, a_n) == 0;
        }
    }

    bug("unknown AST-type");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x2e91
roll $0x14, %eax
cmpl $0x5, %eax
ja 0x2ea3
movq %rsi, %rbx
leaq 0x8404(%rip), %rcx      # 0xb194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %bl
jmp 0x2e93
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x270b
movq %rax, %r14
leaq 0x18(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x270b
movq %rax, %r15
movq (%r12), %rax
cmpq (%r13), %rax
jne 0x2e91
xorl %r12d, %r12d
cmpq 0x8(%rsp), %r12
setae %bl
jae 0x2e93
movq (%r14,%r12,8), %rdi
movq (%r15,%r12,8), %rsi
callq 0x2d63
incq %r12
testb %al, %al
jne 0x2dd4
jmp 0x2e93
callq 0x2655
movq %rax, %r14
movq %rbx, %rdi
callq 0x2655
cmpq %rax, %r14
jmp 0x2e8c
callq 0x2691
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2691
cmpeqsd 0x10(%rsp), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x2e93
callq 0x25da
movq %rax, %r14
movq %rbx, %rdi
callq 0x25da
movq %r14, %rdi
movq %rax, %rsi
callq 0x2100
testl %eax, %eax
setne %bl
jmp 0x2e93
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2614
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2614
movq (%r15), %rdx
cmpq (%r12), %rdx
jne 0x2e91
movq %r14, %rdi
movq %rax, %rsi
callq 0x2180
testl %eax, %eax
sete %bl
jmp 0x2e93
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x874f(%rip), %rdi      # 0xb5f9
xorl %eax, %eax
callq 0x4918
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x2160
movq %rax, %r15
movq %r14, %rdi
callq 0x2220
movq %rax, (%r15)
callq 0x2f11
movq %rax, 0x8(%r15)
movb %bl, 0x10(%r15)
movq 0xfea8(%rip), %rax      # 0x12d90
movq %rax, 0x20(%r15)
movq %r15, 0xfe9d(%rip)      # 0x12d90
leaq 0xff26(%rip), %rax      # 0x12e20
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa187
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2f83
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x2f85
movq (%rbx), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x2f51
movq %rbx, %rdi
popq %rbx
jmp 0x2030
popq %rbx
retq
movq (%rbx), %rdx
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x86d1(%rip), %rsi      # 0xb668
xorl %eax, %eax
callq 0x4a05
// File: /workspace/github_c_makefile_star2_O2/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 0xfe71(%rip), %rax      # 0x12e20
movq (%rax), %rdi
movq %r14, %rsi
callq 0xa103
testq %rax, %rax
jne 0x2fcd
movq %r14, %rdi
xorl %esi, %esi
callq 0x2eb4
movq %rbx, 0x18(%rax)
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfe3c(%rip), %rax      # 0x12e20
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xa103
testq %rax, %rax
je 0x2ffa
movb $0x1, 0x10(%rax)
jmp 0x3005
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2eb4
movq 0x8(%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x306b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
leaq 0xf230(%rip), %r14      # 0x12280
subq $0x1, %rbx
jb 0x3063
movq %r14, %rdi
movq %rax, %rsi
callq 0x9e47
jmp 0x3050
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf5bf(%rip), %rdi      # 0x12660
callq 0x9e47
movq 0x8(%rbx), %rsi
testb $0x30, (%rsi)
je 0x30bb
movq %rax, %rdi
callq 0x30c4
movq 0x8(%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x30e4
// File: /workspace/github_c_makefile_star2_O2/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 0xf117(%rip), %rsi      # 0x122a0
callq 0x9e47
movq %rax, %r14
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3208
xorl %r12d, %r12d
leaq 0xf35c(%rip), %r15      # 0x12500
cmpq %rax, %r12
jae 0x31e7
movq 0x20(%rbx,%r12,8), %rsi
xorl %edi, %edi
callq 0x30e4
movq %r14, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %r14
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r12
je 0x31e2
movq %r14, %rdi
movq %r15, %rsi
callq 0x9e47
movq %rax, %r14
movq 0x10(%rbx), %rax
incq %r12
jmp 0x31a4
cmpb $0x0, 0x18(%rbx)
je 0x3220
leaq 0xf30c(%rip), %rsi      # 0x12500
movq %r14, %rdi
callq 0x9e47
leaq 0xf33d(%rip), %rsi      # 0x12540
movq %rax, %rdi
jmp 0x3218
cmpb $0x0, 0x18(%rbx)
jne 0x3220
leaq 0xf34b(%rip), %rsi      # 0x12560
movq %r14, %rdi
callq 0x9e47
movq %rax, %r14
leaq 0xf099(%rip), %rsi      # 0x122c0
movq %r14, %rdi
callq 0x9e47
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30e4
// File: /workspace/github_c_makefile_star2_O2/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 0x9e6c
leaq 0xf468(%rip), %rdi      # 0x12700
movq %rax, %rsi
callq 0x9e47
leaq 0xf3d9(%rip), %rsi      # 0x12680
movq %rax, %rdi
callq 0x9e47
leaq 0xf0aa(%rip), %rsi      # 0x12360
movq %rax, %rdi
callq 0x9e47
movq %rax, %r14
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
cmpq 0x10(%rbx), %r12
jae 0x32ed
movq %r15, %rdi
callq 0x3246
movq %r14, %rdi
movq %rax, %rsi
callq 0x9e47
movq %rax, %r14
incq %r12
addq $0x10, %r15
jmp 0x32c8
leaq 0xf0cc(%rip), %rsi      # 0x123c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9e47
// File: /workspace/github_c_makefile_star2_O2/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 0x9e6c
leaq 0xf3e5(%rip), %rdi      # 0x12700
movq %rax, %rsi
callq 0x9e47
testq %rbx, %rbx
je 0x3343
leaq 0xf351(%rip), %rsi      # 0x12680
movq %rax, %rdi
callq 0x9e47
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x9e47
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/codegen.c
// Function: expr_stmt_to_c
struct rope *expr_stmt_to_c(struct ast *ast)
{
    if (ast->tag == INIT_EXPR)
        return NULL;

    struct expr expr = eval_expr(NULL, ast);
    if (ast->tag == DECL)
        return NULL;
    return add_indent_nl(rope_new_tree(expr.rope, semi_rope));
}

// Assembly:
pushq %rbx
cmpl $0x42f6, (%rdi)         # imm = 0x42F6
je 0x33c2
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x5b22
cmpl $0x4000, (%rbx)         # imm = 0x4000
jne 0x33c6
xorl %eax, %eax
popq %rbx
retq
leaq 0xf113(%rip), %rsi      # 0x124e0
movq %rdx, %rdi
callq 0x9e47
movq %rax, %rdi
popq %rbx
jmp 0x307d
// File: /workspace/github_c_makefile_star2_O2/ryvnf[P]czc/codegen.c
// Function: if_stmt_to_c
struct rope *if_stmt_to_c(struct ast *ast)
{
    struct rope *rope = if_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *then_block_ast = ast_ast(ast, 1);
    struct ast *else_block_ast = ast_ast(ast, 2);

    push_scope();

    if (expr_ast != NULL) {
        struct expr expr = eval_expr(NULL, expr_ast);
        if (!is_bool_type(expr.type))
            fatal(ast->loc, "condition has to be of boolean type");
        rope = rope_new_tree(rope, expr.rope);
    } else {
        rope = rope_new_tree(rope, one_rope);
    }

    rope = rope_new_tree(rope, rparen_sp_rope);
    rope = rope_new_tree(rope, block_to_c(then_block_ast));

    if (else_block_ast) {
        rope = rope_new_tree(rope, sp_else_sp_rope);
        if (else_block_ast->tag == IF_STMT)
            rope = rope_new_tree(rope, if_stmt_to_c(else_block_ast));
        else 
            rope = rope_new_tree(rope, block_to_c(else_block_ast));
    }

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %esi, %esi
callq 0x26ce
movq %rax, %r12
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x26ce
movq %rax, %r14
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x26ce
movq %rax, %rbx
callq 0x300b
testq %r12, %r12
je 0x3438
xorl %edi, %edi
movq %r12, %rsi
callq 0x5b22
testb $-0x80, (%rax)
je 0x34d0
leaq 0xf14d(%rip), %rdi      # 0x12580
movq %rdx, %rsi
jmp 0x3446
leaq 0xf141(%rip), %rdi      # 0x12580
leaq 0xf2fa(%rip), %rsi      # 0x12740
callq 0x9e47
leaq 0xeeae(%rip), %rsi      # 0x12300
movq %rax, %rdi
callq 0x9e47
movq %rax, %r15
movq %r14, %rdi
callq 0x34e2
movq %r15, %rdi
movq %rax, %rsi
callq 0x9e47
testq %rbx, %rbx
je 0x34ac
leaq 0xf184(%rip), %rsi      # 0x12600
movq %rax, %rdi
callq 0x9e47
movq %rax, %r14
cmpl $0x4101, (%rbx)         # imm = 0x4101
jne 0x3499
movq %rbx, %rdi
callq 0x33de
jmp 0x34a1
movq %rbx, %rdi
callq 0x34e2
movq %r14, %rdi
movq %rax, %rsi
callq 0x9e47
leaq 0xf92d(%rip), %rcx      # 0x12de0
movq (%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, (%rcx)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x307d
movq 0x8(%r15), %rdi
leaq 0x81a6(%rip), %rsi      # 0xb681
xorl %eax, %eax
callq 0x4a05