LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_div_by_const
void gen_div_by_const(int num)
{
	memo2(__func__, "%d", num);
	if (num == 1) { /* do nothing */
		return;
	}

	printf("//gen_div_by_const(%d)\n", num);
	printf("  movq (%%rsp), %%rax\n");

	switch (num) {
	case 2:
		printf("  sarq $1, %%rax\n");
		printf("  movq %%rax, (%%rsp)\n");
		return;
	case 4:
		printf("  sarq $2, %%rax\n");
		printf("  movq %%rax, (%%rsp)\n");
		return;
	case 8:
		printf("  sarq $3, %%rax\n");
		printf("  movq %%rax, (%%rsp)\n");
		return;
	default:
		printf("  movl $%d, %%ecx\n", num);
		puts("  cqto\n"
		     "  idivq %rcx\n"
		     "  movl %eax, (%rsp)");
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6118(%rip), %rdi      # 0x10029
leaq 0x6280(%rip), %rsi      # 0x10198
movl %ebx, %edx
xorl %eax, %eax
callq 0x93c8
cmpl $0x1, %ebx
jne 0x9f2d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6106(%rip), %rdi      # 0x1003a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6080(%rip), %rdi      # 0xffc4
xorl %eax, %eax
callq 0x1070
cmpl $0x8, %ebx
je 0x9f6c
cmpl $0x4, %ebx
je 0x9f63
cmpl $0x2, %ebx
jne 0x9f8e
leaq 0x60f1(%rip), %rdi      # 0x10052
jmp 0x9f73
leaq 0x60fa(%rip), %rdi      # 0x10064
jmp 0x9f73
leaq 0x6103(%rip), %rdi      # 0x10076
xorl %eax, %eax
callq 0x1070
leaq 0x6fb0(%rip), %rdi      # 0x10f31
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
leaq 0x60f3(%rip), %rdi      # 0x10088
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x60f6(%rip), %rdi      # 0x1009b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_peek_and_dereference_nbyte
void gen_peek_and_dereference_nbyte(int n)
{
	memo2(__func__, "%d", n);
	switch (n) {
	case 1:
		gen_peek_and_dereference_1byte();
		break;
	case 4:
		gen_peek_and_dereference_4byte();
		break;
	case 8:
		gen_peek_and_dereference_8byte();
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x613d(%rip), %rdi      # 0x10122
leaq 0x61ac(%rip), %rsi      # 0x10198
movl %ebx, %edx
xorl %eax, %eax
callq 0x93c8
cmpl $0x8, %ebx
je 0xa01a
cmpl $0x4, %ebx
je 0xa00f
cmpl $0x1, %ebx
jne 0xa025
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa81a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa7c3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa7e0
leaq 0x57df(%rip), %rdi      # 0xf80b
callq 0x9354
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_call_and_assign_integerclass_struct_or_union_to_local
void gen_call_and_assign_integerclass_struct_or_union_to_local(
    const char *fname, int offset, int size)
{
	memo2(__func__, "\"%s\", %d, %d", fname, offset, size);

	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC();
	printf("  movq %%rdx, (%%rsp)\n"
	       "  subq $8, %%rsp\n"
	       "  movq %%rax, (%%rsp)\n"
	       "  leaq %d(%%rbp), %%rdi\n",
	       offset);
	gen_memcpy("%rdi", "%rsp", size);

	gen_discard();
	gen_discard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x6091(%rip), %rdi      # 0x102bf
leaq 0x60c4(%rip), %rsi      # 0x102f9
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x93c8
leaq 0x4fa7(%rip), %rdi      # 0xf1f3
movq %r15, %rsi
callq 0xa92a
callq 0xaa4c
leaq 0x60a6(%rip), %rdi      # 0x10306
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x641f(%rip), %rdi      # 0x10690
leaq 0x5bea(%rip), %rsi      # 0xfe62
movl %ebx, %edx
callq 0xa293
callq 0x9caa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9caa
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_memcpy
static void gen_memcpy(const char *dst, const char *src, int size)
{
	int next_copy_begins_at = 0;
	while (1) {
		if (size - next_copy_begins_at >= 8) {
			printf("  movq %s, %%rdx\n"
			       "  movq %d(%%rdx), %%rax\n"
			       "  movq %s, %%rdx\n"
			       "  movq %%rax, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 8;
		} else if (size - next_copy_begins_at >= 4) {
			printf("  movq %s, %%rdx\n"
			       "  movl %d(%%rdx), %%eax\n"
			       "  movq %s, %%rdx\n"
			       "  movl %%eax, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 4;
		} else if (size - next_copy_begins_at >= 1) {
			printf("  movq %s, %%rdx\n"
			       "  movzbl %d(%%rdx), %%eax\n"
			       "  movq %s, %%rdx\n"
			       "  movb %%al, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 1;
		} else {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl %ebx, %eax
subl %r12d, %eax
leaq 0x64d4(%rip), %rdi      # 0x1078c
pushq $0x8
popq %r13
cmpl $0x7, %eax
jg 0xa2e0
leaq 0x6517(%rip), %rdi      # 0x107df
pushq $0x4
popq %r13
cmpl $0x3, %eax
jg 0xa2e0
leaq 0x655a(%rip), %rdi      # 0x10832
pushq $0x1
popq %r13
testl %eax, %eax
jle 0xa2f8
movq %r14, %rsi
movl %r12d, %edx
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
addl %r13d, %r12d
jmp 0xa2ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_call_reg_and_assign_integerclass_struct_or_union_or_union_to_local
void gen_call_reg_and_assign_integerclass_struct_or_union_or_union_to_local(
    const char *regname, int offset, int size)
{
	memo2(__func__, "\"%s\", %d, %d", regname, offset, size);

	gen_raw_call_partB("*%", regname);
	gen_raw_call_partC();
	printf("  movq %%rdx, (%%rsp)\n"
	       "  subq $8, %%rsp\n"
	       "  movq %%rax, (%%rsp)\n"
	       "  leaq %d(%%rbp), %%rdi\n",
	       offset);
	gen_memcpy("%rdi", "%rsp", size);

	gen_discard();
	gen_discard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x603c(%rip), %rdi      # 0x1035c
leaq 0x5fd2(%rip), %rsi      # 0x102f9
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x93c8
leaq 0x6065(%rip), %rdi      # 0x103a3
movq %r15, %rsi
callq 0xa92a
callq 0xaa4c
leaq 0x5fb4(%rip), %rdi      # 0x10306
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x632d(%rip), %rdi      # 0x10690
leaq 0x5af8(%rip), %rsi      # 0xfe62
movl %ebx, %edx
callq 0xa293
callq 0x9caa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9caa
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_epilogue_nbyte_with_stack_check
void gen_epilogue_nbyte_with_stack_check(int n, int return_label_name,
                                         int checksum_offset,
                                         int failing_label_name)
{
	memo2(__func__, "%d, %d, %d, %d", n, return_label_name, checksum_offset,
	      failing_label_name);
#ifdef OSX
	gen_push_address_of_global("__stack_chk_guard");
	gen_peek_and_dereference_nbyte(8);
	gen_pop_to_reg_8byte("rax");
	printf("  cmpq %d(%%rbp), %%rax\n", checksum_offset);
#endif

#ifdef LINUX
	printf("  movq %d(%%rbp), %%rax\n", checksum_offset);
	printf("  cmpq %%fs:40, %%rax\n");
#endif

	printf("  jne .L%d\n", failing_label_name);
	gen_epilogue_nbyte(n, return_label_name);
	printf(".L%d:\n", failing_label_name);
	printf("  call " PREFIX "__stack_chk_fail\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %r14d
movl %edi, %r15d
leaq 0x5fe6(%rip), %rdi      # 0x1045b
leaq 0x6003(%rip), %rsi      # 0x1047f
movl %r15d, %edx
movl %r14d, %ecx
movl %r12d, %r8d
movl %ebx, %r9d
xorl %eax, %eax
callq 0x93c8
leaq 0x5ff8(%rip), %rdi      # 0x1048e
movl %r12d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6000(%rip), %rdi      # 0x104a7
xorl %eax, %eax
callq 0x1070
leaq 0x5668(%rip), %rdi      # 0xfb1d
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
movl %r15d, %edi
movl %r14d, %esi
callq 0x9525
leaq 0x3d77(%rip), %rdi      # 0xe247
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x63b7(%rip), %rdi      # 0x10897
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_store_regs_to_local
void gen_store_regs_to_local(int offset, int start_from, int label_name)
{
	memo2(__func__, "%d, %d, %d", offset, start_from, label_name);
	puts("  testb %al, %al");
	for (int i = start_from; i <= 5; i++) {
		printf("  movq %%%s, %d(%%rbp)\n", get_reg_name_from_arg_pos_8byte(i),
		       offset + i * 8);
	}
	printf("  je .L%d\n", label_name);
	for (int i = 0; i < 8; i++) {
		printf("  movaps %%xmm%d, %d(%%rbp)\n", i, 8 + offset + 40 + 16 * i);
	}
	printf(".L%d:\n", label_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movl %edi, %r14d
leaq 0x5fb4(%rip), %rdi      # 0x104be
leaq 0x5f72(%rip), %rsi      # 0x10483
movl %r14d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x93c8
leaq 0x5fae(%rip), %rdi      # 0x104d6
callq 0x1050
leal (%r14,%r15,8), %r12d
leaq 0x5d6f(%rip), %r13      # 0x102a7
cmpl $0x6, %r15d
jge 0xa55f
movl %r15d, %edi
callq 0xa5ba
movq %r13, %rdi
movq %rax, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1070
incl %r15d
addl $0x8, %r12d
jmp 0xa538
leaq 0x55fa(%rip), %rdi      # 0xfb60
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
addl $0x30, %r14d
leaq 0x5f6d(%rip), %r15      # 0x104e7
xorl %r12d, %r12d
cmpl $0x8, %r12d
je 0xa59c
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1070
incl %r12d
addl $0x10, %r14d
jmp 0xa57d
leaq 0x3ca4(%rip), %rdi      # 0xe247
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_va_start
void gen_va_start(int gp_offset, int fp_offset, int reg_save_area_offset)
{
	memo2(__func__, "%d, %d, %d", gp_offset, fp_offset, reg_save_area_offset);
	printf("  movq (%%rsp), %%rdx\n");
	printf("  movl $%d,  (%%rdx)\n", gp_offset);
	printf("  movl $%d,  4(%%rdx)\n", fp_offset);

	printf("  leaq 16(%%rbp), %%rax\n"
	       "  movq %%rax, 8(%%rdx)\n");

	printf("  leaq %d(%%rbp), %%rax\n", reg_save_area_offset);
	printf("  movq %%rax, 16(%%rdx)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
leaq 0x5f0b(%rip), %rdi      # 0x10504
leaq 0x5e83(%rip), %rsi      # 0x10483
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x93c8
leaq 0x5efa(%rip), %rdi      # 0x10511
xorl %eax, %eax
callq 0x1070
leaq 0x5f03(%rip), %rdi      # 0x10528
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5f08(%rip), %rdi      # 0x1053e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5f0e(%rip), %rdi      # 0x10555
xorl %eax, %eax
callq 0x1070
leaq 0x5f30(%rip), %rdi      # 0x10585
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5f39(%rip), %rdi      # 0x1059e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local
void gen_write_to_local(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local(%d)\n", offset);
	printf("  movl (%%rsp), %%eax\n");
	printf("  movl %%eax, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x128c
leaq 0x61fa(%rip), %rdi      # 0x108af
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6204(%rip), %rdi      # 0x108c9
xorl %eax, %eax
callq 0x1070
leaq 0x620d(%rip), %rdi      # 0x108e0
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local_8byte
void gen_write_to_local_8byte(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local_8byte(%d)\n", offset);
	printf("  movq (%%rsp), %%rax\n");
	printf("  movq %%rax, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x128c
leaq 0x61fe(%rip), %rdi      # 0x108f9
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x58b9(%rip), %rdi      # 0xffc4
xorl %eax, %eax
callq 0x1070
leaq 0x68c9(%rip), %rdi      # 0x10fe2
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local_1byte
void gen_write_to_local_1byte(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local_1byte(%d)\n", offset);
	printf("  movb (%%rsp), %%al\n");
	printf("  movb %%al, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x128c
leaq 0x61d8(%rip), %rdi      # 0x10919
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x61e8(%rip), %rdi      # 0x10939
xorl %eax, %eax
callq 0x1070
leaq 0x5ad4(%rip), %rdi      # 0x10233
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_1byte
void gen_push_ret_of_1byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_1byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);

	printf("  movsbl %%al, %%eax\n"
	       "  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x637d(%rip), %rdi      # 0x10c75
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x48ea(%rip), %rdi      # 0xf1f3
movq %r14, %rsi
callq 0xa92a
movl %ebx, %edi
callq 0xa95d
leaq 0x6375(%rip), %rdi      # 0x10c94
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_4byte
void gen_push_ret_of_4byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_4byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);
	printf("  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x632d(%rip), %rdi      # 0x10cc0
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x484f(%rip), %rdi      # 0xf1f3
movq %r14, %rsi
callq 0xa92a
movl %ebx, %edi
callq 0xa95d
leaq 0x65b5(%rip), %rdi      # 0x10f6f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_8byte
void gen_push_ret_of_8byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_8byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);
	printf("  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6307(%rip), %rdi      # 0x10cdf
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x480a(%rip), %rdi      # 0xf1f3
movq %r14, %rsi
callq 0xa92a
movl %ebx, %edi
callq 0xa95d
leaq 0x6532(%rip), %rdi      # 0x10f31
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_1byte
void gen_call_reg_and_push_ret_of_1byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_1byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movsbl %%al, %%eax\n"
	       "  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x62e4(%rip), %rdi      # 0x10cfe
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x5978(%rip), %rdi      # 0x103a3
movq %rbx, %rsi
callq 0xa92a
callq 0xaa4c
leaq 0x6255(%rip), %rdi      # 0x10c94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_4byte
void gen_call_reg_and_push_ret_of_4byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_4byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x62c2(%rip), %rdi      # 0x10d2a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x592a(%rip), %rdi      # 0x103a3
movq %rbx, %rsi
callq 0xa92a
callq 0xaa4c
leaq 0x64e2(%rip), %rdi      # 0x10f6f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_8byte
void gen_call_reg_and_push_ret_of_8byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_8byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x62ac(%rip), %rdi      # 0x10d56
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x58e8(%rip), %rdi      # 0x103a3
movq %rbx, %rsi
callq 0xa92a
callq 0xaa4c
leaq 0x6462(%rip), %rdi      # 0x10f31
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_assign_8byte
void gen_assign_8byte(void)
{
	printf("//gen_assign_8byte()\n");
	printf("  movq (%%rsp), %%rax\n");
	printf("  movq 8(%%rsp), %%rdx\n");

	printf("  movq %%rax, (%%rdx)\n"
	       "  addq $8, %%rsp\n"
	       "  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6593(%rip), %rdi      # 0x11108
callq 0x1050
leaq 0x5443(%rip), %rdi      # 0xffc4
xorl %eax, %eax
callq 0x1070
leaq 0x6363(%rip), %rdi      # 0x10ef2
xorl %eax, %eax
callq 0x1070
leaq 0x636d(%rip), %rdi      # 0x10f0a
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_assign_4byte
void gen_assign_4byte(void)
{
	printf("//gen_assign_4byte()\n");
	printf("  movl (%%rsp), %%eax\n");
	printf("  movq 8(%%rsp), %%rdx\n");

	printf("  movl %%eax, (%%rdx)\n"
	       "  addq $8, %%rsp\n"
	       "  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x656d(%rip), %rdi      # 0x1111d
callq 0x1050
leaq 0x5d0d(%rip), %rdi      # 0x108c9
xorl %eax, %eax
callq 0x1070
leaq 0x6328(%rip), %rdi      # 0x10ef2
xorl %eax, %eax
callq 0x1070
leaq 0x6370(%rip), %rdi      # 0x10f48
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_assign_1byte
void gen_assign_1byte(void)
{
	printf("//gen_assign_1byte()\n");
	printf("  movb (%%rsp), %%al\n");
	printf("  movq 8(%%rsp), %%rdx\n");

	printf("  movb %%al, (%%rdx)\n");
	printf("  addq $8, %%rsp\n");
	printf("  movb %%al, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6547(%rip), %rdi      # 0x11132
callq 0x1050
leaq 0x5d42(%rip), %rdi      # 0x10939
xorl %eax, %eax
callq 0x1070
leaq 0x62ed(%rip), %rdi      # 0x10ef2
xorl %eax, %eax
callq 0x1070
leaq 0x6373(%rip), %rdi      # 0x10f86
xorl %eax, %eax
callq 0x1070
leaq 0x519c(%rip), %rdi      # 0xfdbd
xorl %eax, %eax
callq 0x1070
leaq 0x636d(%rip), %rdi      # 0x10f9c
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_initialize_va_list
void gen_initialize_va_list(int dst_struct_offset, int gp_offset, int fp_offset,
                            int reg_save_area_offset)
{
	printf("  movl $%d,  %d(%%rbp)\n", gp_offset, dst_struct_offset);
	printf("  movl $%d,  %d(%%rbp)\n", fp_offset, dst_struct_offset + 4);

	printf("  leaq 16(%%rbp), %%rax\n"
	       "  movq %%rax, %d(%%rbp)\n",
	       dst_struct_offset + 8);

	printf("  leaq %d(%%rbp), %%rax\n", reg_save_area_offset);
	printf("  movq %%rax, %d(%%rbp)\n", dst_struct_offset + 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %edi, %ebx
leaq 0x6361(%rip), %r12      # 0x10fb2
movq %r12, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1070
leal 0x4(%rbx), %edx
movq %r12, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leal 0x8(%rbx), %esi
leaq 0x6353(%rip), %rdi      # 0x10fca
xorl %eax, %eax
callq 0x1070
leaq 0x5900(%rip), %rdi      # 0x10585
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
addl $0x10, %ebx
leaq 0x6349(%rip), %rdi      # 0x10fe2
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1070
nop
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/lexer.c
// Function: read_and_preprocess
struct Token *
read_and_preprocess(const char *str,
                    struct Vector /*<struct Token>*/ *ref_cmdline_macros)
{
	struct Map2 /*<struct Vector<struct Token>*/ *def_map = init_map();
	for (int i = 0; i < ref_cmdline_macros->length; i++) {
		struct Vector *p = init_vector_();

		struct Token *ptr_token = calloc(1, sizeof(struct Token));
		ptr_token->kind = LIT_DEC_INTEGER;
		ptr_token->int_value = 1;

		push_vector(p, ptr_token);

		insert(def_map, ref_cmdline_macros->vector[i], p);
	}
	struct Tokvec vec1 = preprocess(str, def_map);

	const struct Tokvec vec2 = remove_spaces_and_newlines(&vec1);

	return concat_str_literals(&vec2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
xorl %r12d, %r12d
callq 0x9319
movq %rax, %r15
movabsq $0x100000004, %r13      # imm = 0x100000004
movslq (%r14), %rax
cmpq %rax, %r12
jge 0xad1a
callq 0x49f5
movq %rax, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %r13, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a57
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x9250
incq %r12
jmp 0xacd9
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xbfd8
movq %rdx, %r14
movslq %eax, %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %rax, %r12
xorl %eax, %eax
movl (%r14), %ecx
andl $-0x2, %ecx
cmpl $0x4c, %ecx
je 0xad6a
cltq
movq %rax, %rcx
shlq $0x5, %rcx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%r12,%rcx)
movups %xmm1, 0x10(%r12,%rcx)
incl %eax
cmpl $0x2, (%r12,%rcx)
je 0xad70
addq $0x20, %r14
jmp 0xad39
movslq %eax, %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %rax, -0x40(%rbp)
movq %r12, %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
xorl %ecx, %ecx
xorl %edx, %edx
movq %r12, -0x50(%rbp)
movq %rcx, %r15
shlq $0x5, %r15
movslq %edx, %rbx
shlq $0x5, %rbx
movups (%r12,%rbx), %xmm0
movups 0x10(%r12,%rbx), %xmm1
movq -0x40(%rbp), %rax
movups %xmm0, (%rax,%r15)
movups %xmm1, 0x10(%rax,%r15)
movl (%rax,%r15), %esi
movl %esi, -0x34(%rbp)
cmpl $0x39, %esi
jne 0xae35
movl %edx, -0x30(%rbp)
movq %rcx, -0x58(%rbp)
addq %rax, %r15
addq -0x48(%rbp), %rbx
cmpl $0x39, -0x10(%rbx)
jne 0xae2a
movq 0x10(%r15), %r12
movq %r12, %rdi
callq 0x1060
movq %rax, %r13
movq (%rbx), %r14
movq %r14, %rdi
callq 0x1060
addl %r13d, %eax
incl %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
callq 0x10d0
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x1040
movq %r13, %rdi
movq %r14, %rsi
callq 0x1150
movq %r13, 0x10(%r15)
incl -0x30(%rbp)
addq $0x20, %rbx
jmp 0xadd4
movq -0x50(%rbp), %r12
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %edx
cmpl $0x2, -0x34(%rbp)
movq -0x40(%rbp), %rax
je 0xae49
incq %rcx
incl %edx
jmp 0xad92
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/lexer.c
// Function: unescape
char *unescape(const char *str)
{
	char *ans = calloc(strlen(str) + 1, sizeof(char));
	int j = 0;
	for (int i = 0; str[i];) {
		if (str[i] != 92) {
			ans[j] = str[i];
			i++;
			j++;
		} else {
			switch (str[i + 1]) {
			case 92:
				ans[j] = 92;
				break;
			case 't':
				ans[j] = 9;
				break;
			case 'n':
				ans[j] = 10;
				break;
			case 'v':
				ans[j] = 11;
				break;
			case 'f':
				ans[j] = 12;
				break;
			case 'r':
				ans[j] = 13;
				break;
			case '"':
				ans[j] = '"';
				break;
			case 'e': {
				if (global_flag_pedantic) {
					fprintf(stderr, "escape sequence `\\e` is not in ISO C\n");
					exit(EXIT_FAILURE);
				} else {
					ans[j] = 0x1b;
					break;
				}
			}
			case 39:
				ans[j] = 39;
				break;
			default:
				fprintf(stderr, "unsupported: escape sequence `\\%c`\n",
				        str[i + 1]);
				exit(EXIT_FAILURE);
			}
			i += 2;
			j++;
		}
	}
	/* calloc means automatically null terminated */
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1060
leaq 0x1(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x10d0
leaq 0xb262(%rip), %rcx      # 0x160dc
movl (%rcx), %ecx
xorl %edx, %edx
pushq $0x1
popq %rsi
pushq $0x2
popq %rdi
leaq 0x62bd(%rip), %r8       # 0x11148
movq %rax, %r9
movl %edx, %edx
movzbl (%rbx,%rdx), %r10d
cmpl $0x5c, %r10d
je 0xaea8
movl %esi, %r11d
testl %r10d, %r10d
jne 0xaefd
jmp 0xaf30
movb 0x1(%rbx,%rdx), %r10b
movzbl %r10b, %r11d
leal -0x6e(%r11), %r14d
cmpl $0x8, %r14d
jbe 0xaede
cmpl $0x22, %r11d
je 0xaefa
cmpl $0x27, %r11d
je 0xaefa
cmpl $0x5c, %r11d
je 0xaefa
cmpl $0x65, %r11d
je 0xaf08
cmpl $0x66, %r11d
jne 0xaf35
movb $0xc, %r10b
jmp 0xaefa
movslq (%r8,%r14,4), %r11
addq %r8, %r11
jmpq *%r11
movb $0xa, %r10b
jmp 0xaefa
movb $0x9, %r10b
jmp 0xaefa
movb $0xd, %r10b
jmp 0xaefa
movb $0xb, %r10b
movl %edi, %r11d
movb %r10b, (%r9)
addl %r11d, %edx
incq %r9
jmp 0xae8e
movb $0x1b, %r10b
movl %edi, %r11d
testl %ecx, %ecx
je 0xaefd
movq 0xb0df(%rip), %rax      # 0x15ff8
movq (%rax), %rcx
leaq 0x6391(%rip), %rdi      # 0x112b4
pushq $0x25
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
jmp 0xaf51
popq %rbx
popq %r14
popq %rbp
retq
movsbl %r10b, %edx
movq 0xb0b8(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0x6390(%rip), %rsi      # 0x112da
xorl %eax, %eax
callq 0x10f0
pushq $0x1
popq %rdi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/lexer.c
// Function: print_token
void print_token(const struct Token *ptr_tok, const char *next_token_begins)
{
	if (ptr_tok->kind == END) {
		fprintf(stderr, "DUMMY: END");
		return;
	}
	if (ptr_tok->kind == BEGINNING) {
		fprintf(stderr, "DUMMY: BEGINNING");
		return;
	}
	for (int i = 0; i < next_token_begins - ptr_tok->token_begins_here; i++) {
		char c = ptr_tok->token_begins_here[i];
		if (c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
		    c == '\r') {
			break;
		}
		fprintf(stderr, "%c", c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xb0a4
cmpl $0x3, %eax
je 0xb08f
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0xafb3(%rip), %r12      # 0x15ff8
movabsq $0x100003e00, %r13      # imm = 0x100003E00
movq 0x18(%r14), %rax
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jle 0xb080
movzbl (%rax,%r15), %eax
cmpq $0x20, %rax
ja 0xb06f
btq %rax, %r13
jb 0xb080
movsbl %al, %edi
movq (%r12), %rsi
callq 0x1090
incq %r15
jmp 0xb04f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xaf62(%rip), %rax      # 0x15ff8
movq (%rax), %rcx
leaq 0x6269(%rip), %rdi      # 0x11309
pushq $0x10
jmp 0xb0b7
movq 0xaf4d(%rip), %rax      # 0x15ff8
movq (%rax), %rcx
leaq 0x6249(%rip), %rdi      # 0x112fe
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1180
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/lexer.c
// Function: read_all_tokens
struct Tokvec read_all_tokens(const char *str)
{
	struct Token tok;
	int tok_num;
	{
		const char *str2 = str;
		tok_num = count_all_tokens(str2);
	}

	/* 1 additional for extra NEWLINE */
	struct Token *tokvec = calloc(tok_num + 1, sizeof(struct Token));

	tok.kind = BEGINNING;
	tok.ident_str = 0;
	tok.token_begins_here = str;

	tokvec[0] = tok;

	for (int i = 1;; ++i) {
		tok = get_token(&str);
		tokvec[i] = tok;

		if (tok.kind == END) {
			tokvec[i + 1] = tok;
			tokvec[i].kind = NEWLINE;
			break;
		}
	}

	struct Tokvec t;
	t.tok_num = tok_num + 1;
	t.v = tokvec;
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x58(%rbp), %r14
movq %rdi, (%r14)
pushq $0x2
popq %rbx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xb1ab
incq %rbx
cmpl $0x2, -0x50(%rbp)
jne 0xb102
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x10d0
movq %rax, %r14
movl $0x3, (%rax)
movq %r15, 0x18(%rax)
movq %rax, %r13
addq $0x38, %r13
leaq -0x50(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xb1ab
movl -0x50(%rbp), %edi
movl -0x4c(%rbp), %eax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movl %edi, -0x18(%r13)
movl %eax, -0x14(%r13)
movq %rcx, -0x10(%r13)
movq %rdx, -0x8(%r13)
movq %rsi, (%r13)
addq $0x20, %r13
cmpl $0x2, %edi
jne 0xb13d
movl $0x2, -0x18(%r13)
movl %eax, -0x14(%r13)
movq %rcx, -0x10(%r13)
movq %rdx, -0x8(%r13)
movq %rsi, (%r13)
movl $0x4c, -0x38(%r13)
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/codegen_switch.c
// Function: collect_labels_visible_from_switch
static struct Vector /*<SourceLabel>*/
collect_labels_visible_from_switch(const struct Statement *ptr_sta)
{
	struct Statement sta = *ptr_sta;
	struct Vector /*<SourceLabel>*/ ans = init_vector();
	concat_vector(&ans, &sta.labels);
	switch (sta.category) {
	case RETURN_STATEMENT:
	case BREAK_STATEMENT:
	case CONTINUE_STATEMENT:
	case GOTO_STATEMENT:
	case EXPRESSION_STATEMENT:
	case DECLARATION_STATEMENT:
		/* nothing */
		break;
	case SWITCH_STATEMENT:
		/* do nothing; don't peek labels */
		break;

	case IF_STATEMENT:
	case FOR_STATEMENT:
	case WHILE_STATEMENT:
	case DO_WHILE_STATEMENT: {
		const struct Vector /*<SourceLabel>*/ inner_vec =
		    collect_labels_visible_from_switch(sta.inner_statement);
		concat_vector(&ans, &inner_vec);
		break;
	}

	case COMPOUND_STATEMENT:
	case IF_ELSE_STATEMENT: {
		struct Vector /*<Statement>*/ statement_vec = sta.statement_vector;
		for (int counter = 0; counter != statement_vec.length; ++counter) {
			const struct Statement *ptr_ith = statement_vec.vector[counter];
			const struct Vector /*<SourceLabel>*/ inner_vec =
			    collect_labels_visible_from_switch(ptr_ith);
			concat_vector(&ans, &inner_vec);
		}
		break;
	}
	}
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp            # imm = 0x3B8
movq %rdi, %rsi
leaq -0x3d8(%rbp), %rbx
movl $0x390, %edx            # imm = 0x390
movq %rbx, %rdi
callq 0x1100
callq 0x49e0
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq -0x60(%rbp), %rsi
callq 0x4ab0
movl (%rbx), %eax
cmpl $0x5, %eax
ja 0xbee8
pushq $0x3a
popq %rcx
btl %eax, %ecx
jae 0xbf02
movq -0xc0(%rbp), %rdi
callq 0xbe75
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq -0x38(%rbp), %rdi
callq 0x4ab0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdx
addq $0x3b8, %rsp            # imm = 0x3B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0x3d0(%rbp), %r15d
movq -0x3c8(%rbp), %r12
xorl %r13d, %r13d
leaq -0x38(%rbp), %rbx
leaq -0x48(%rbp), %r14
cmpq %r13, %r15
je 0xbee8
movq (%r12,%r13,8), %rdi
callq 0xbe75
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4ab0
incq %r13
jmp 0xbf1b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/file_io.c
// Function: read_from_file
char *read_from_file(struct __FILE *fp)
{
	int size = 1;
	int capacity = 50000;
	char *str = calloc(capacity, sizeof(char));
	char buffer[1024];

	while (fgets(buffer, 1024, fp)) {
		size += strlen(buffer);
		if (size > capacity) {
			capacity *= 2;
			str = realloc(str, capacity);
		}
		strcat(str, buffer);
	}

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
pushq $0x1
popq %r14
movl $0xc350, %edi           # imm = 0xC350
movq %r14, %rsi
callq 0x10d0
movq %rax, %r15
movl $0xc350, %r13d          # imm = 0xC350
leaq -0x430(%rbp), %r12
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
je 0xbfc2
movq %r12, %rdi
callq 0x1060
movslq %r14d, %r14
addq %rax, %r14
cmpl %r14d, %r13d
jge 0xbfb5
addl %r13d, %r13d
movslq %r13d, %rsi
movq %r15, %rdi
callq 0x1120
movq %rax, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1150
jmp 0xbf7c
movq %r15, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hsjoihs[P]c-compiler/cpp.c
// Function: replace_recursively
static void
replace_recursively(const struct Map2 /*<struct Vector<struct Token>*/ *def_map,
                    struct Map2 *used_map, const struct Token *src,
                    struct Token *ptr_dst)
{
	if (src[0].kind == IDENT_OR_RESERVED && isElem(def_map, src[0].ident_str) &&
	    !isElem(used_map, src[0].ident_str)) {
		struct Vector /*<struct Token>*/ *p = lookup(def_map, src[0].ident_str);

#ifdef __STDC__
#warning only one token
#endif

		const struct Token *replace_with = p->vector[0];

		int u;
		insert(used_map, src[0].ident_str,
		       &u /* this can be any arbitrary non-null pointer*/);

		replace_recursively(def_map, used_map, replace_with, ptr_dst);

	} else {
		*ptr_dst = src[0];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
cmpl $0x18, (%rdx)
jne 0xc5e7
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r12), %rsi
callq 0x9304
testl %eax, %eax
je 0xc5e7
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x9304
testl %eax, %eax
je 0xc608
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x92a8
movq 0x8(%rax), %rax
movq (%rax), %r13
movq 0x8(%r12), %rsi
leaq -0x2c(%rbp), %rdx
movq %r14, %rdi
callq 0x9250
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xc5a9
jmp 0xc5f9
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_cache_evict
int ufat_cache_evict(struct ufat *uf, ufat_block_t start, ufat_block_t count)
{
	unsigned int i;

	for (i = 0; i < uf->cache_size; i++) {
		struct ufat_cache_desc *d = &uf->cache_desc[i];

		if ((d->flags & UFAT_CACHE_FLAG_PRESENT) &&
		    d->index >= start && d->index < start + count) {
			int err = cache_flush(uf, i);

			if (err < 0)
				return err;

			d->flags = 0;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x80(%rdi), %rbp
addq %rsi, %r14
xorl %ebx, %ebx
xorl %r13d, %r13d
movl 0x74(%r12), %eax
cmpq %rax, %r13
jae 0x1374
testb $0x2, (%rbp)
je 0x1366
movq 0x8(%rbp), %rax
cmpq %r15, %rax
setb %cl
cmpq %r14, %rax
setae %al
orb %cl, %al
jne 0x1366
movq %r12, %rdi
movl %r13d, %esi
callq 0x1385
testl %eax, %eax
js 0x136f
andl $0x0, (%rbp)
incq %r13
addq $0x10, %rbp
jmp 0x132f
pushq $-0x1
popq %rax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: cache_flush
static int cache_flush(struct ufat *uf, unsigned int cache_index)
{
	struct ufat_cache_desc *d = &uf->cache_desc[cache_index];

	if (!(d->flags & UFAT_CACHE_FLAG_DIRTY) ||
	    !(d->flags & UFAT_CACHE_FLAG_PRESENT))
		return 0;

	if (uf->dev->write(uf->dev, d->index, 1,
			   ufat_cache_data(uf, cache_index)) < 0)
		return -UFAT_ERR_IO;

	uf->stat.cache_flush++;
	uf->stat.write++;
	uf->stat.write_blocks++;

	/* If this block is part of the FAT, mirror it to the other FATs. Not
	 * a fatal error if this fails.
	 */
	if (d->index >= uf->bpb.fat_start &&
	    d->index < uf->bpb.fat_start + uf->bpb.fat_size) {
		unsigned int i;
		ufat_block_t b = d->index;

		for (i = 1; i < uf->bpb.fat_count; i++) {
			b += uf->bpb.fat_size;
			uf->dev->write(uf->dev, b, 1,
				       ufat_cache_data(uf, cache_index));

			uf->stat.write++;
			uf->stat.write_blocks++;
		}
	}

	d->flags &= ~UFAT_CACHE_FLAG_DIRTY;
	return 0;
}

// Assembly:
movl %esi, %edx
shlq $0x4, %rdx
movl 0x80(%rdi,%rdx), %ecx
notl %ecx
xorl %eax, %eax
testb $0x3, %cl
jne 0x1457
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x80(%rdi,%rdx), %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movb (%rdi), %cl
movl %ebp, %eax
shll %cl, %eax
leaq (%r14,%rax), %rcx
addq $0x180, %rcx            # imm = 0x180
pushq $0x1
popq %rdx
callq *0x10(%rdi)
testl %eax, %eax
js 0x1446
incl 0x24(%r14)
incl 0xc(%r14)
incl 0x14(%r14)
movq %rbx, (%rsp)
movq 0x8(%rbx), %r15
movq 0x30(%r14), %rax
cmpq %rax, %r15
jb 0x143b
addq 0x38(%r14), %rax
cmpq %rax, %r15
jae 0x143b
leaq 0x180(%r14), %r13
pushq $0x1
popq %rbx
pushq $0x1
popq %r12
cmpl 0x40(%r14), %ebx
jae 0x143b
addq 0x38(%r14), %r15
movq (%r14), %rdi
movb (%rdi), %cl
movl %ebp, %eax
shll %cl, %eax
addq %r13, %rax
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq *0x10(%rdi)
incl 0xc(%r14)
incl 0x14(%r14)
incl %ebx
jmp 0x140d
movq (%rsp), %rax
andb $-0x2, (%rax)
xorl %eax, %eax
jmp 0x1449
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_cache_invalidate
void ufat_cache_invalidate(struct ufat *uf, ufat_block_t start,
			   ufat_block_t count)
{
	unsigned int i;

	for (i = 0; i < uf->cache_size; i++) {
		struct ufat_cache_desc *d = &uf->cache_desc[i];

		if ((d->flags & UFAT_CACHE_FLAG_PRESENT) &&
		    d->index >= start && d->index < start + count)
			d->flags = 0;
	}
}

// Assembly:
movl 0x74(%rdi), %eax
subq $-0x80, %rdi
addq %rsi, %rdx
xorl %ecx, %ecx
cmpq %rax, %rcx
jae 0x1491
testb $0x2, (%rdi)
je 0x1488
movq 0x8(%rdi), %r8
cmpq %rsi, %r8
setb %r9b
cmpq %rdx, %r8
setae %r8b
orb %r9b, %r8b
jne 0x1488
andl $0x0, (%rdi)
incq %rcx
addq $0x10, %rdi
jmp 0x1464
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_sync
int ufat_sync(struct ufat *uf)
{
	unsigned int i;
	int ret = 0;

	for (i = 0; i < uf->cache_size; i++) {
		int err = cache_flush(uf, i);

		if (err)
			ret = err;
	}

	return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpl 0x74(%r14), %ebp
jae 0x185b
movq %r14, %rdi
movl %ebp, %esi
callq 0x1385
testl %eax, %eax
cmovnel %eax, %ebx
incl %ebp
jmp 0x1842
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_count_free_clusters
int ufat_count_free_clusters(struct ufat *uf, ufat_cluster_t *free_clusters)
{
	ufat_cluster_t idx;
	ufat_cluster_t local_free_clusters = 0;
	const ufat_cluster_t total = uf->bpb.num_clusters;

	/* Skip first two "special" clusters */
	for (idx = 2; idx < total; idx++) {
		ufat_cluster_t c;
		int err;

		/* Never use this cluster index in a FAT12 system */
		if (idx == 0xff0 && uf->bpb.type == UFAT_TYPE_FAT12)
			continue;

		err = ufat_read_fat(uf, idx, &c);
		if (err < 0)
			return err;

		if (c == UFAT_CLUSTER_FREE)
			local_free_clusters++;
	}

	*free_clusters = local_free_clusters;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x50(%rdi), %r12d
pushq $0x2
popq %rbp
xorl %r13d, %r13d
leaq 0x4(%rsp), %r15
cmpl %r12d, %ebp
jae 0x18b4
cmpl $0xff0, %ebp            # imm = 0xFF0
jne 0x1896
cmpl $0xc, 0x28(%r14)
je 0x18b0
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x18c8
testl %eax, %eax
js 0x18b9
cmpl $0x1, 0x4(%rsp)
adcl $0x0, %r13d
incl %ebp
jmp 0x1882
movl %r13d, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_read_fat
int ufat_read_fat(struct ufat *uf, ufat_cluster_t index,
		  ufat_cluster_t *out)
{
	if (index >= uf->bpb.num_clusters)
		return -UFAT_ERR_INVALID_CLUSTER;

	switch (uf->bpb.type) {
	case UFAT_TYPE_FAT12: return read_fat12(uf, index, out);
	case UFAT_TYPE_FAT16: return read_fat16(uf, index, out);
	case UFAT_TYPE_FAT32: return read_fat32(uf, index, out);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl %esi, 0x50(%rdi)
jbe 0x1953
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movl 0x28(%rdi), %eax
cmpl $0x20, %eax
je 0x19c6
cmpl $0x10, %eax
je 0x1965
xorl %ebp, %ebp
cmpl $0xc, %eax
jne 0x1956
movl %r15d, %r12d
shrl %r12d
leal (%r12,%r12,2), %esi
incl %esi
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1d71
testl %eax, %eax
js 0x1a7b
leal (%r12,%r12,2), %esi
testb $0x1, %r15b
jne 0x1a2a
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x1d71
testl %eax, %eax
js 0x1a7b
movzbl 0xe(%rsp), %ecx
movzbl 0xf(%rsp), %eax
andl $0xf, %eax
shll $0x8, %eax
jmp 0x1a4e
pushq $-0x5
popq %rbp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movl (%rax), %r12d
decl %r12d
movl %r15d, %esi
movl %r12d, %ecx
shrl %cl, %esi
addq 0x30(%r14), %rsi
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x1492
testl %eax, %eax
js 0x1a23
pushq $-0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
notl %edx
movq (%r14), %rcx
movb (%rcx), %cl
shll %cl, %eax
andl %r15d, %edx
addq %r14, %rax
movzwl 0x180(%rax,%rdx,2), %eax
cmpl $0xfff7, %eax           # imm = 0xFFF7
movl $0xffffff7, %ecx        # imm = 0xFFFFFF7
cmovnel %eax, %ecx
movl $0xffffff8, %eax        # imm = 0xFFFFFF8
cmovbel %ecx, %eax
movl %eax, (%rbx)
jmp 0x1956
movq (%r14), %rax
movl (%rax), %r12d
addl $-0x2, %r12d
movl %r15d, %esi
movl %r12d, %ecx
shrl %cl, %esi
addq 0x30(%r14), %rsi
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x1492
testl %eax, %eax
js 0x1a23
pushq $-0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
movq (%r14), %rcx
movb (%rcx), %cl
shll %cl, %eax
notl %edx
andl %r15d, %edx
addq %r14, %rax
shll $0x2, %edx
movl $0xfffffff, %ecx        # imm = 0xFFFFFFF
andl 0x180(%rdx,%rax), %ecx
movl $0xffffff8, %eax        # imm = 0xFFFFFF8
cmpl %eax, %ecx
cmovael %eax, %ecx
movl %ecx, (%rbx)
jmp 0x1956
movl %eax, %ebp
jmp 0x1956
addl $0x2, %esi
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x1d71
testl %eax, %eax
js 0x1a7b
movzbl 0xe(%rsp), %ecx
shll $0x4, %ecx
movzbl 0xf(%rsp), %eax
shrl $0x4, %eax
orl %ecx, %eax
cmpl $0xff7, %eax            # imm = 0xFF7
movl $0xffffff7, %ecx        # imm = 0xFFFFFF7
cmovnel %eax, %ecx
cmpl $0xff0, %eax            # imm = 0xFF0
movl $0xffffff8, %edx        # imm = 0xFFFFFF8
cmovel %edx, %ecx
cmpl $0xff8, %eax            # imm = 0xFF8
cmovael %edx, %ecx
movl %ecx, (%rbx)
xorl %ebp, %ebp
jmp 0x1956
movl %eax, %ebp
jmp 0x1956
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_write_fat
int ufat_write_fat(struct ufat *uf, ufat_cluster_t index,
		   ufat_cluster_t in)
{
	if (index >= uf->bpb.num_clusters)
		return -UFAT_ERR_INVALID_CLUSTER;

	switch (uf->bpb.type) {
	case UFAT_TYPE_FAT12: return write_fat12(uf, index, in);
	case UFAT_TYPE_FAT16: return write_fat16(uf, index, in);
	case UFAT_TYPE_FAT32: return write_fat32(uf, index, in);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl %esi, 0x50(%rdi)
jbe 0x1b1f
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl 0x28(%rdi), %eax
cmpl $0x20, %eax
je 0x1b8b
cmpl $0x10, %eax
je 0x1b2f
xorl %r15d, %r15d
cmpl $0xc, %eax
jne 0x1b23
movl %ebp, %eax
shrl %eax
leal (%rax,%rax,2), %r12d
testb $0x1, %bpl
jne 0x1bf1
movzbl %bl, %edx
movq %r14, %rdi
movl %r12d, %esi
movl $0xff, %ecx
callq 0x1dcf
testl %eax, %eax
js 0x1c31
incl %r12d
shrl $0x8, %ebx
andl $0xf, %ebx
pushq $0xf
popq %rcx
movq %r14, %rdi
movl %r12d, %esi
movl %ebx, %edx
jmp 0x1c24
pushq $-0x5
popq %r15
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movl (%rax), %r12d
decl %r12d
movl %ebp, %esi
movl %r12d, %ecx
shrl %cl, %esi
addq 0x30(%r14), %rsi
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x1492
testl %eax, %eax
js 0x1be9
pushq $-0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
incl 0x20(%r14)
movl %eax, %ecx
shlq $0x4, %rcx
orb $0x1, 0x80(%r14,%rcx)
movq (%r14), %rcx
movb (%rcx), %cl
shll %cl, %eax
notl %edx
andl %ebp, %edx
addq %r14, %rax
movw %bx, 0x180(%rax,%rdx,2)
jmp 0x1b23
movq (%r14), %rax
movl (%rax), %r12d
addl $-0x2, %r12d
movl %ebp, %esi
movl %r12d, %ecx
shrl %cl, %esi
addq 0x30(%r14), %rsi
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x1492
testl %eax, %eax
js 0x1be9
pushq $-0x1
popq %rdx
movl %r12d, %ecx
shll %cl, %edx
incl 0x20(%r14)
movl %eax, %ecx
shlq $0x4, %rcx
orb $0x1, 0x80(%r14,%rcx)
notl %edx
movq (%r14), %rcx
movb (%rcx), %cl
shll %cl, %eax
andl %ebp, %edx
addq %r14, %rax
shll $0x2, %edx
movl %ebx, 0x180(%rdx,%rax)
jmp 0x1b23
movl %eax, %r15d
jmp 0x1b23
leal 0x1(%r12), %esi
movl %ebx, %eax
shlb $0x4, %al
movzbl %al, %edx
movq %r14, %rdi
movl $0xf0, %ecx
callq 0x1dcf
testl %eax, %eax
js 0x1c31
addl $0x2, %r12d
shrl $0x4, %ebx
movzbl %bl, %edx
movq %r14, %rdi
movl %r12d, %esi
movl $0xff, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1dcf
movl %eax, %r15d
jmp 0x1b23
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]ufat/ufat.c
// Function: ufat_free_chain
int ufat_free_chain(struct ufat *uf, ufat_cluster_t c)
{
	while (UFAT_CLUSTER_IS_PTR(c)) {
		ufat_cluster_t next;
		int i = ufat_read_fat(uf, c, &next);

		if (i < 0)
			return i;

		i = ufat_write_fat(uf, c, UFAT_CLUSTER_FREE);
		if (i < 0)
			return i;

		c = next;
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %r14
leaq 0x4(%rsp), %r15
xorl %ebx, %ebx
leal -0x2(%r12), %eax
cmpl $0xfffffed, %eax        # imm = 0xFFFFFED
ja 0x1c86
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x18c8
testl %eax, %eax
js 0x1c84
movq %r14, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x1aac
testl %eax, %eax
js 0x1c84
movl 0x4(%rsp), %r12d
jmp 0x1c4e
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq