LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x6e83(%rip), %r14      # 0xd110
movq (%r14), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leal 0x1a(%rbx), %edx
leaq 0x480f(%rip), %rcx      # 0xaab8
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 0x47de(%rip), %rcx      # 0xaabe
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 0x4910(%rip), %rcx      # 0xac27
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_O1/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 0x6dcd(%rip), %rbx      # 0xd110
movq (%rbx), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %edx, %edx
callq 0x1110
movq (%rbx), %rdi
leaq 0x4766(%rip), %rcx      # 0xaac2
movl $0xa, %esi
movl $0x19, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x475a(%rip), %rcx      # 0xaad1
movl $0xb, %esi
movl $0x1d, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4746(%rip), %rcx      # 0xaad8
movl $0xc, %esi
movl $0x1c, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4734(%rip), %rcx      # 0xaae1
movl $0xd, %esi
movl $0x1b, %edx
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
leaq 0x4724(%rip), %rcx      # 0xaaec
movl $0xe, %esi
movl $0x1a, %edx
xorl %eax, %eax
popq %rbx
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O1/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 0x6d27(%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 0x46b0(%rip), %rcx      # 0xaab8
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 0x4682(%rip), %rcx      # 0xaabe
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 0x4850(%rip), %rcx      # 0xacc0
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_O1/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 0x6c75(%rip), %r14      # 0xd110
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x1110
movq (%r14), %rdi
leaq 0x47c2(%rip), %rbx      # 0xac76
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 0x45af(%rip), %rcx      # 0xaab6
movl $0xb, %esi
movl $0xe, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x458d(%rip), %rbx      # 0xaaaf
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 0x453b(%rip), %rcx      # 0xaa92
movl $0xe, %esi
movl $0xd, %edx
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rdi
leaq 0x44ee(%rip), %rcx      # 0xaa60
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_O1/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 0x6745(%rip), %r14      # 0xd118
movq (%r14), %rdi
callq 0x1090
decl %ebx
cmpl $0x6, %ebx
ja 0x69fc
movl %ebx, %eax
leaq 0x41dd(%rip), %rcx      # 0xabc8
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_O1/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 0x4224(%rip), %rdi      # 0x7fd0
xorl %esi, %esi
callq 0x4690
movq %rax, %rbx
leaq 0x155b(%rip), %r14      # 0x5318
movq %rax, %rdi
movq %r14, %rsi
callq 0x46ea
leaq 0x154d(%rip), %rsi      # 0x531c
movq %rbx, %rdi
callq 0x46ea
movq %rbx, %rdi
callq 0x46e6
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x1531(%rip), %rsi      # 0x5320
leaq 0x1622(%rip), %rcx      # 0x5418
leaq 0x152b(%rip), %r8       # 0x5328
movl $0x12, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3ea1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4912
movq %rax, %r13
leaq 0x14f6(%rip), %r15      # 0x531c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4912
movq %rax, %r12
xorl %edi, %edi
cmpq %r14, %r13
sete %dil
leaq 0x14dc(%rip), %rsi      # 0x5320
leaq 0x15cd(%rip), %rcx      # 0x5418
leaq 0x14e9(%rip), %r8       # 0x533b
movl $0x17, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3ea1
xorl %edi, %edi
cmpq %r15, %r12
sete %dil
leaq 0x14ae(%rip), %rsi      # 0x5320
leaq 0x159f(%rip), %rcx      # 0x5418
leaq 0x14c8(%rip), %r8       # 0x5348
movl $0x18, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3ea1
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4974
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/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       # 0x3ea6
xorl %esi, %esi
callq 0x4690
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x46ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46ea
movq %rbx, %rdi
callq 0x46e6
xorl %edi, %edi
cmpl $0x2, %eax
sete %dil
leaq 0x1411(%rip), %rsi      # 0x5320
leaq 0x1502(%rip), %rcx      # 0x5418
leaq 0x140b(%rip), %r8       # 0x5328
movl $0x2c, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3fd2
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rsp, %r12
movl $0x2a, (%r12)
movq %rbx, %rdi
callq 0x4912
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4912
movq %rax, %r12
xorl %edi, %edi
cmpq %r15, %r13
sete %dil
leaq 0x13b0(%rip), %rsi      # 0x5320
leaq 0x14a1(%rip), %rcx      # 0x5418
leaq 0x13d7(%rip), %r8       # 0x5355
movl $0x33, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3fd2
xorl %edi, %edi
cmpq %r14, %r12
sete %dil
leaq 0x1382(%rip), %rsi      # 0x5320
leaq 0x1473(%rip), %rcx      # 0x5418
leaq 0x13b7(%rip), %r8       # 0x5363
movl $0x34, %edx
xorl %eax, %eax
callq 0x25bc
testl %eax, %eax
je 0x3fd2
movq %rbx, %rdi
callq 0x4974
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/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      # 0x3ea6
movq 0x3faf(%rip), %rsi      # 0x7fb0
callq 0x4690
movq %rax, %rbx
xorl %ebp, %ebp
movl $0x4, %edi
callq 0x2190
movl %ebp, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x46ea
incl %ebp
cmpl $0x64, %ebp
jne 0x400b
movq %rbx, %rdi
callq 0x49cc
testq %rax, %rax
je 0x4095
movq %rax, %r14
leaq 0x12e0(%rip), %r15      # 0x5320
leaq 0x13d1(%rip), %r12      # 0x5418
leaq 0x1323(%rip), %r13      # 0x5371
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ab5
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 0x4116
incl %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a55
movq %rax, %r14
testq %rax, %rax
jne 0x4050
movq %rbx, %rdi
callq 0x49e2
testq %rax, %rax
je 0x4100
movq %rax, %r14
movl $0x63, %ebp
leaq 0x126f(%rip), %r15      # 0x5320
leaq 0x1360(%rip), %r12      # 0x5418
leaq 0x12c0(%rip), %r13      # 0x537f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ab5
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 0x4116
decl %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49f9
movq %rax, %r14
testq %rax, %rax
jne 0x40bf
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4974
callq 0x2e03
// File: /workspace/github_c_makefile_star2_O1/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 0x325d6(%rip), %rdi     # 0x41028
callq 0xe250
movq %rax, 0x58a6a(%rip)     # 0x674c8
leaq 0x325c7(%rip), %rsi     # 0x4102c
xorl %edi, %edi
callq 0xe230
movq %rax, 0x58a5d(%rip)     # 0x674d0
movq 0x58a4e(%rip), %rdi     # 0x674c8
movq %rax, %rsi
callq 0xe320
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x12566
movq %rax, %rbx
movq (%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xeb1c
leaq 0x56fb2(%rip), %r12     # 0x65a58
leaq 0x56fb3(%rip), %r13     # 0x65a60
movq 0x8(%rsp), %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xeb11
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xead1
testq %r14, %r14
je 0xeb02
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeb5d
movq %r14, %rdi
callq 0x1280e
movq (%r12), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xeb5d
movq (%r13), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xeb5d
incq %r15
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xeabd
movq 0x10(%rbp), %rbp
cmpq 0x8(%rsp), %rbp
jne 0xeab2
movq 0x589a5(%rip), %rsi     # 0x674c8
leaq 0x3a93f(%rip), %rdi     # 0x49469
leaq 0x32501(%rip), %rdx     # 0x41032
movl $0x1, %ecx
callq 0xe280
movq 0x58986(%rip), %rdi     # 0x674c8
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_O1/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 0x600ce(%rip), %r12     # 0x6ec40
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x0, (%r12)
jle 0xeba7
movq %rdi, %r14
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x22334
movq %r14, %rdi
movq %rax, %rsi
callq 0xe2a0
testl %eax, %eax
je 0xeba4
incl %ebp
cmpl (%r12), %ebp
jl 0xeb84
jmp 0xeba7
movl %ebp, %r15d
testq %rbx, %rbx
je 0xeccd
leaq 0x3244d(%rip), %r12     # 0x41004
leaq 0x786c2(%rip), %r13     # 0x87280
movq %rbx, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xecc0
xorl %r14d, %r14d
movq 0x18(%rbp,%r14,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xebe8
testq %rdi, %rdi
je 0xecad
movq 0x4(%rdi), %rax
movl %eax, %ecx
shrl $0x6, %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
cmpl %r15d, %ecx
jne 0xecad
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xec13
testb $0x2, 0x11(%rcx)
jne 0xecad
movl (%rdi), %esi
shrl $0x8, %esi
andl $0x1ff, %esi            # imm = 0x1FF
cmpl $0xf, %esi
jg 0xec56
cmpl $0x8, %esi
ja 0xecdc
movl %esi, %ecx
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
movq 0x48(%rdi), %rdx
cmpq %r13, %rdx
je 0xec8c
xorl %esi, %esi
movq %rsi, %rcx
movq %rdx, %rsi
movq 0x8(%rdx), %r8
movq %r8, %rdx
cmpq %r13, %r8
jne 0xec42
jmp 0xec8e
cmpl $0x3f, %esi
jle 0xec72
cmpl $0x40, %esi
je 0xecad
cmpl $0x80, %esi
je 0xecad
cmpl $0x100, %esi            # imm = 0x100
je 0xecad
jmp 0xecdc
cmpl $0x10, %esi
je 0xec7e
cmpl $0x20, %esi
je 0xecad
jmp 0xecdc
movq 0x5884b(%rip), %rsi     # 0x674d0
callq 0xecea
jmp 0xecad
xorl %ecx, %ecx
testq %rcx, %rcx
je 0xec96
movq (%rcx), %rax
movq 0x58833(%rip), %rdx     # 0x674d0
movq %rax, 0xc(%rdi)
leaq 0x36fe6(%rip), %rsi     # 0x45c8e
callq 0xf006
incq %r14
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r14
jl 0xebd0
movq 0x10(%rbp), %rbp
cmpq %rbx, %rbp
jne 0xebc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32355(%rip), %rdi     # 0x41038
xorl %eax, %eax
callq 0x123ce
// File: /workspace/github_c_makefile_star2_O1/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 0x11fa
leaq 0xe6a(%rip), %r14       # 0x200e
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdx
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1050
incq %r15
cmpq $0x3, %r15
jne 0x11a7
movq 0x8(%rbx), %rdi
callq 0x1060
movl %eax, %ebp
movq 0x10(%rbx), %rdi
callq 0x1040
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe3d(%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 0xe43(%rip), %rdi       # 0x2044
callq 0x1030
leaq 0xe64(%rip), %rdi       # 0x2071
callq 0x1030
xorl %edi, %edi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x18, %edi
callq 0x2160
movq %r14, 0x8(%rax)
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %edi
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_O1/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
movl $0x28, %edi
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_O1/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
movl $0x20, %edi
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_O1/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
movl $0x20, %edi
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_O1/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 0x2593
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 0x260f
movl (%rsp), %ecx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
cmpl $0x28, %ecx
ja 0x25f3
movq %rdi, %r8
movl %ecx, %edi
addq %rdx, %rdi
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x25fc
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 0x25de
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2644
movq %rbx, %rax
incq %r12
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2638
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 0x2680
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 0x266d
movq %rbx, %rdi
callq 0x2698
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x2160
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2726
movq 0x20(%rdi), %rax
movq %rax, (%rsi)
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0xaa7e(%rip), %rdi      # 0xd1ac
leaq 0xaa99(%rip), %rsi      # 0xd1ce
leaq 0xaab2(%rip), %rcx      # 0xd1ee
leaq 0xaac3(%rip), %r8       # 0xd206
movl $0x7a, %edx
xorl %eax, %eax
callq 0x4f1c
// File: /workspace/github_c_makefile_star2_O1/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 0x2829
testq %rsi, %rsi
je 0x284c
movq 0x18(%rdi), %rax
movq %rax, (%rsi)
addq $0x20, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0xa97c(%rip), %rdi      # 0xd1ac
leaq 0xa997(%rip), %rsi      # 0xd1ce
leaq 0xaa06(%rip), %rcx      # 0xd244
leaq 0xaa1d(%rip), %r8       # 0xd262
movl $0x99, %edx
jmp 0x286d
leaq 0xa959(%rip), %rdi      # 0xd1ac
leaq 0xa974(%rip), %rsi      # 0xd1ce
leaq 0xaa0a(%rip), %rcx      # 0xd26b
leaq 0xa9fa(%rip), %r8       # 0xd262
movl $0x9a, %edx
xorl %eax, %eax
callq 0x4f1c
// File: /workspace/github_c_makefile_star2_O1/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 0x10b95(%rip), %ecx     # 0x13d98
leal 0x1(%rcx), %eax
movl %eax, 0x10b8c(%rip)     # 0x13d98
leaq 0xa6f4(%rip), %rdx      # 0xd907
movl $0xd, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
movq %r15, 0x8(%r14)
movb %bpl, 0x10(%r14)
movq 0x10b5f(%rip), %rax     # 0x13d90
movq %rax, 0x20(%r14)
movq %r14, 0x10b54(%rip)     # 0x13d90
leaq 0x10bdd(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xb484
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32c9
movq %rdi, %rbx
cmpb $0x0, 0x10(%rdi)
je 0x32cb
movq (%rbx), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x3297
movq %rbx, %rdi
popq %rbx
jmp 0x2030
popq %rbx
retq
movq (%rbx), %rdx
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0xa38b(%rip), %rsi      # 0xd668
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/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 0x10b2b(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %r14, %rsi
callq 0xb3ff
testq %rax, %rax
jne 0x3313
movq %r14, %rdi
xorl %esi, %esi
callq 0x31cc
movq %rbx, 0x18(%rax)
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10af6(%rip), %rax     # 0x13e20
movq (%rax), %rdi
movq %rbx, %rsi
callq 0xb3ff
testq %rax, %rax
je 0x3340
movb $0x1, 0x10(%rax)
jmp 0x334d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x31cc
movq 0x8(%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x33b7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
testq %rsi, %rsi
je 0x33af
leaq 0xfee1(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
decq %rbx
jne 0x339f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1020f(%rip), %rdi     # 0x13660
callq 0xb136
movq 0x8(%rbx), %rcx
testb $0x30, (%rcx)
je 0x347d
leaq 0xfe3a(%rip), %rdi      # 0x132a0
movq %rax, %rsi
callq 0xb136
leaq 0xfe4b(%rip), %rsi      # 0x132c0
movq %rax, %rdi
callq 0xb136
movq 0x8(%rbx), %rsi
movq %rax, %rdi
popq %rbx
jmp 0x348a
// File: /workspace/github_c_makefile_star2_O1/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 0xfd5c(%rip), %rsi      # 0x132a0
callq 0xb136
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x35c2
cmpq $0x0, 0x10(%rbx)
je 0x35a1
xorl %r12d, %r12d
leaq 0xff9c(%rip), %r15      # 0x13500
movq 0x20(%rbx,%r12,8), %rsi
xorl %edi, %edi
callq 0x348a
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %r14
movq 0x10(%rbx), %rax
decq %rax
cmpq %rax, %r12
je 0x3598
movq %r14, %rdi
movq %r15, %rsi
callq 0xb136
movq %rax, %r14
incq %r12
cmpq 0x10(%rbx), %r12
jb 0x3564
cmpb $0x0, 0x18(%rbx)
je 0x35da
leaq 0xff52(%rip), %rsi      # 0x13500
movq %r14, %rdi
callq 0xb136
leaq 0xff83(%rip), %rsi      # 0x13540
movq %rax, %rdi
jmp 0x35d2
cmpb $0x0, 0x18(%rbx)
jne 0x35da
leaq 0xff91(%rip), %rsi      # 0x13560
movq %r14, %rdi
callq 0xb136
movq %rax, %r14
leaq 0xfcdf(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0xb136
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x348a
// File: /workspace/github_c_makefile_star2_O1/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 0xb15d
leaq 0x100ae(%rip), %rdi     # 0x13700
movq %rax, %rsi
callq 0xb136
leaq 0x1001f(%rip), %rsi     # 0x13680
movq %rax, %rdi
callq 0xb136
leaq 0xfcf0(%rip), %rsi      # 0x13360
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x36ac
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x3600
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %r14
incq %r12
addq $0x10, %r15
cmpq 0x10(%rbx), %r12
jb 0x3689
leaq 0xfd0d(%rip), %rsi      # 0x133c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb136
// File: /workspace/github_c_makefile_star2_O1/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 0xb15d
leaq 0x10026(%rip), %rdi     # 0x13700
movq %rax, %rsi
callq 0xb136
testq %rbx, %rbx
je 0x3702
leaq 0xff92(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xb136
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xb136
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3781
movq %rdi, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x633e
cmpl $0x4000, (%rbx)         # imm = 0x4000
jne 0x3785
xorl %eax, %eax
popq %rbx
retq
leaq 0xfd54(%rip), %rsi      # 0x134e0
movq %rdx, %rdi
callq 0xb136
movq %rax, %rdi
popq %rbx
jmp 0x33f7
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x27c8
movq %rax, %r12
movl $0x1, %esi
movq %r15, %rdi
callq 0x27c8
movq %rax, %r14
movl $0x2, %esi
movq %r15, %rdi
callq 0x27c8
movq %rax, %rbx
leaq 0x10606(%rip), %r13     # 0x13de0
movq (%r13), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb2b4
movq %rax, (%r13)
testq %r12, %r12
je 0x3815
xorl %edi, %edi
movq %r12, %rsi
callq 0x633e
testb $-0x80, (%rax)
je 0x38a6
leaq 0xfd70(%rip), %rdi      # 0x13580
movq %rdx, %rsi
jmp 0x3823
leaq 0xfd64(%rip), %rdi      # 0x13580
leaq 0xff1d(%rip), %rsi      # 0x13740
callq 0xb136
leaq 0xfad1(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
movq %r14, %rdi
callq 0x38b8
movq %r15, %rdi
movq %rax, %rsi
callq 0xb136
testq %rbx, %rbx
je 0x3889
leaq 0xfda7(%rip), %rsi      # 0x13600
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
cmpl $0x4101, (%rbx)         # imm = 0x4101
jne 0x3876
movq %rbx, %rdi
callq 0x379d
jmp 0x387e
movq %rbx, %rdi
callq 0x38b8
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
movq (%r13), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%r13)
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x33f7
movq 0x8(%r15), %rdi
leaq 0x9dd0(%rip), %rsi      # 0xd681
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/codegen.c
// Function: block_to_c
struct rope *block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;
    zc_indent_level++;

    rope = stmt_list_to_c(rope, ast, NULL);

    zc_indent_level--;
    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
leaq 0x1050d(%rip), %r14     # 0x13dd4
incl (%r14)
leaq 0xfa8f(%rip), %rdi      # 0x13360
xorl %edx, %edx
callq 0x3ac1
movq %rax, %rbx
movslq (%r14), %r15
decq %r15
movl %r15d, (%r14)
leaq 0xfad5(%rip), %rax      # 0x133c0
testl %r15d, %r15d
je 0x3907
leaq 0xf989(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
decq %r15
jne 0x38f7
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb136
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/codegen.c
// Function: stmt_list_to_c
struct rope *stmt_list_to_c(struct rope *rope, struct ast *ast,
        bool *fallthrough)
{
    size_t n_stmt_asts;
    struct ast **stmt_asts = ast_asts(ast, &n_stmt_asts);

    for (size_t i = 0; i < n_stmt_asts; ++i) {
        if (stmt_asts[i]->tag == FALLTHROUGH_STMT) {
            if (fallthrough == NULL || i != n_stmt_asts - 1)
                fatal(stmt_asts[i]->loc, "fallthrough not allowed here");

            *fallthrough = true;
            break;
        }

        struct rope *c_stmt = stmt_to_c(stmt_asts[i]);
        rope = rope_new_tree(rope, c_stmt);
    }

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x2805
movq %rax, %r15
movq (%r12), %rax
testq %rax, %rax
je 0x3b38
movq (%r15), %rdi
cmpl $0x5, (%rdi)
jne 0x3af6
xorl %r12d, %r12d
jmp 0x3b27
movl $0x1, %r12d
callq 0x3f9c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %rbx
movq (%rsp), %rax
cmpq %rax, %r12
jae 0x3b38
movq (%r15,%r12,8), %rdi
incq %r12
cmpl $0x5, (%rdi)
jne 0x3afc
decq %r12
testq %r14, %r14
je 0x3b47
decq %rax
cmpq %rax, %r12
jne 0x3b47
movb $0x1, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rdi), %rdi
leaq 0x9c25(%rip), %rsi      # 0xd777
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/codegen.c
// Function: switch_block_to_c
struct rope *switch_block_to_c(struct ast *ast)
{
    struct rope *rope = lcurly_nl_rope;

    size_t n_clause_asts;
    struct ast **clause_asts = ast_asts(ast, &n_clause_asts);

    for (size_t i = 0; i < n_clause_asts; ++i) {
        struct rope *c_clause = clause_to_c(clause_asts[i]);
	if (rope != NULL)
	    rope = rope_new_tree(rope, c_clause);
    }

    rope = rope_new_tree(rope, add_indent(rcurly_rope));

    return rope;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x2805
cmpq $0x0, (%rbx)
je 0x3bae
movq %rax, %r14
leaq 0xf7e1(%rip), %rbx      # 0x13360
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x3917
testq %rbx, %rbx
je 0x3ba0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb136
movq %rax, %rbx
jmp 0x3ba2
xorl %ebx, %ebx
incq %r15
cmpq 0x8(%rsp), %r15
jb 0x3b82
jmp 0x3bb5
leaq 0xf7ab(%rip), %rbx      # 0x13360
leaq 0x10218(%rip), %rax     # 0x13dd4
movslq (%rax), %r15
leaq 0xf7fa(%rip), %rax      # 0x133c0
testq %r15, %r15
je 0x3be2
leaq 0xf6ae(%rip), %r14      # 0x13280
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
decq %r15
jne 0x3bd2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb136
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/codegen.c
// Function: switch_stmt_to_c
struct rope *switch_stmt_to_c(struct ast *ast)
{
    struct rope *rope = switch_sp_lparen_rope;
    struct ast *expr_ast = ast_ast(ast, 0);
    struct ast *block_ast = ast_ast(ast, 1);

    push_scope();

    struct expr expr = eval_expr(NULL, expr_ast);
    if (!is_bool_type(expr.type) && !is_int_type(expr.type))
        fatal(ast->loc, "expression has to be of boolean or integer type");

    rope = rope_new_tree(rope, expr.rope);
    rope = rope_new_tree(rope, rparen_sp_rope);

    rope = rope_new_tree(rope, switch_block_to_c(block_ast));

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %esi, %esi
callq 0x27c8
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
callq 0x27c8
movq %rax, %rbx
leaq 0x101bd(%rip), %r12     # 0x13de0
movq (%r12), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb2b4
movq %rax, (%r12)
xorl %edi, %edi
movq %r15, %rsi
callq 0x633e
testb $-0x7e, (%rax)
je 0x3c9c
leaq 0x10030(%rip), %rdi     # 0x13c80
movq %rdx, %rsi
callq 0xb136
leaq 0xf6a1(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
movq %rbx, %rdi
callq 0x3b59
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
movq (%r12), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%r12)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x33f7
movq 0x8(%r14), %rdi
leaq 0x99fe(%rip), %rsi      # 0xd6a5
xorl %eax, %eax
callq 0x5011
// File: /workspace/github_c_makefile_star2_O1/ryvnf[P]czc/codegen.c
// Function: for_stmt_to_c
struct rope *for_stmt_to_c(struct ast *ast)
{
    struct rope *rope = for_sp_lparen_rope;
    struct ast *init_expr_ast = ast_ast(ast, 0);
    struct ast *cond_expr_ast = ast_ast(ast, 1);
    struct ast *update_expr_ast = ast_ast(ast, 2);
    struct ast *block_ast = ast_ast(ast, 3);

    push_scope();

    if (init_expr_ast != NULL) {
        struct expr init_expr = eval_expr(NULL, init_expr_ast);
        rope = rope_new_tree(rope, init_expr.rope);
    }
    rope = rope_new_tree(rope, semi_rope);

    if (cond_expr_ast != NULL) {
        rope = rope_new_tree(rope, sp_rope);

        struct expr cond_expr = eval_expr(NULL, cond_expr_ast);
        if (!is_bool_type(cond_expr.type))
            fatal(ast->loc, "condition has to be of boolean type");

        rope = rope_new_tree(rope, cond_expr.rope);
    }
    rope = rope_new_tree(rope, semi_rope);

    if (update_expr_ast != NULL) {
        rope = rope_new_tree(rope, sp_rope);

        struct expr update_expr = eval_expr(NULL, update_expr_ast);
        rope = rope_new_tree(rope, update_expr.rope);
    }
    rope = rope_new_tree(rope, rparen_sp_rope);

    zc_loop_level++;
    rope = rope_new_tree(rope, block_to_c(block_ast));
    zc_loop_level--;

    pop_scope();

    return add_indent_nl(rope);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
xorl %esi, %esi
callq 0x27c8
movq %rax, %r13
movl $0x1, %esi
movq %r15, %rdi
callq 0x27c8
movq %rax, %r12
movl $0x2, %esi
movq %r15, %rdi
callq 0x27c8
movq %rax, %r14
movl $0x3, %esi
movq %r15, %rdi
callq 0x27c8
movq %rax, %rbx
leaq 0x100e3(%rip), %rbp     # 0x13de0
movq (%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x10, %edx
callq 0xb2b4
movq %rax, (%rbp)
testq %r13, %r13
je 0x3d37
xorl %edi, %edi
movq %r13, %rsi
callq 0x633e
leaq 0xf896(%rip), %rdi      # 0x135c0
movq %rdx, %rsi
callq 0xb136
movq %rax, %rdi
jmp 0x3d3e
leaq 0xf882(%rip), %rdi      # 0x135c0
leaq 0xf79b(%rip), %rsi      # 0x134e0
callq 0xb136
testq %r12, %r12
je 0x3d7f
leaq 0xf92a(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xb136
movq %rax, %r13
xorl %edi, %edi
movq %r12, %rsi
callq 0x633e
testb $-0x80, (%rax)
je 0x3e0e
movq %r13, %rdi
movq %rdx, %rsi
callq 0xb136
leaq 0xf75a(%rip), %rsi      # 0x134e0
movq %rax, %rdi
callq 0xb136
testq %r14, %r14
je 0x3dba
leaq 0xf8e6(%rip), %rsi      # 0x13680
movq %rax, %rdi
callq 0xb136
movq %rax, %r15
xorl %edi, %edi
movq %r14, %rsi
callq 0x633e
movq %r15, %rdi
movq %rdx, %rsi
callq 0xb136
leaq 0xf53f(%rip), %rsi      # 0x13300
movq %rax, %rdi
callq 0xb136
movq %rax, %r14
leaq 0xfffd(%rip), %r15      # 0x13dd0
incl (%r15)
movq %rbx, %rdi
callq 0x38b8
movq %r14, %rdi
movq %rax, %rsi
callq 0xb136
decl (%r15)
movq (%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, (%rbp)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33f7
movq 0x8(%r15), %rdi
leaq 0x9868(%rip), %rsi      # 0xd681
xorl %eax, %eax
callq 0x5011