LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_assign_nbyte
void gen_assign_nbyte(int n)
{
	memo2(__func__, "%d", n);
	switch (n) {
	case 1:
		gen_assign_1byte();
		break;
	case 4:
		gen_assign_4byte();
		break;
	case 8:
		gen_assign_8byte();
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x606b(%rip), %rdi      # 0x10e77
leaq 0x6395(%rip), %rsi      # 0x111a8
movl %ebx, %edx
xorl %eax, %eax
callq 0xa456
cmpl $0x8, %ebx
je 0xae41
cmpl $0x4, %ebx
je 0xae36
cmpl $0x1, %ebx
jne 0xae4c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe1a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbddf
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbda4
leaq 0x59c8(%rip), %rdi      # 0x1081b
callq 0xa3e0
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_mul_by_const
void gen_mul_by_const(int mul)
{
	memo2(__func__, "%d", mul);
	printf("  movq (%%rsp), %%rax\n");
	printf((mul == 1 || mul == 2 || mul == 4 || mul == 8)
	           ? "  leaq 0(,%%rax,%d), %%rdx\n"
	           : "  imulq $%d, %%rax, %%rdx\n",
	       mul);

	printf("  movq %%rdx, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6074(%rip), %rdi      # 0x10fc3
leaq 0x6252(%rip), %rsi      # 0x111a8
movl %ebx, %edx
xorl %eax, %eax
callq 0xa456
leaq 0x606e(%rip), %rdi      # 0x10fd4
xorl %eax, %eax
callq 0x1070
cmpl $0x4, %ebx
ja 0xaf85
movl $0x16, %eax
btl %ebx, %eax
jae 0xaf85
leaq 0x6068(%rip), %rdi      # 0x10feb
jmp 0xaf9a
cmpl $0x8, %ebx
leaq 0x605c(%rip), %rax      # 0x10feb
leaq 0x6071(%rip), %rdi      # 0x11007
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6078(%rip), %rdi      # 0x11022
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6073(%rip), %rdi      # 0x11039
leaq 0x61db(%rip), %rsi      # 0x111a8
movl %ebx, %edx
xorl %eax, %eax
callq 0xa456
cmpl $0x1, %ebx
jne 0xafe2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6061(%rip), %rdi      # 0x1104a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5fdb(%rip), %rdi      # 0x10fd4
xorl %eax, %eax
callq 0x1070
cmpl $0x8, %ebx
je 0xb021
cmpl $0x4, %ebx
je 0xb018
cmpl $0x2, %ebx
jne 0xb043
leaq 0x604c(%rip), %rdi      # 0x11062
jmp 0xb028
leaq 0x6055(%rip), %rdi      # 0x11074
jmp 0xb028
leaq 0x605e(%rip), %rdi      # 0x11086
xorl %eax, %eax
callq 0x1070
leaq 0x6f0b(%rip), %rdi      # 0x11f41
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
leaq 0x604e(%rip), %rdi      # 0x11098
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6051(%rip), %rdi      # 0x110ab
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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 0x6098(%rip), %rdi      # 0x11132
leaq 0x6107(%rip), %rsi      # 0x111a8
movl %ebx, %edx
xorl %eax, %eax
callq 0xa456
cmpl $0x8, %ebx
je 0xb0cf
cmpl $0x4, %ebx
je 0xb0c4
cmpl $0x1, %ebx
jne 0xb0da
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb946
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb8ef
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb90c
leaq 0x573a(%rip), %rdi      # 0x1081b
callq 0xa3e0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leaq 0x5fea(%rip), %rdi      # 0x112cf
leaq 0x601d(%rip), %rsi      # 0x11309
movq %r12, %rdx
movl %r15d, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0xa456
leaq 0x4f00(%rip), %rbx      # 0x10203
movq %rbx, %rdi
movq %r12, %rsi
callq 0xba84
callq 0xbc0f
leaq 0x5ffc(%rip), %rdi      # 0x11316
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6375(%rip), %rdi      # 0x116a0
leaq 0x5b40(%rip), %rsi      # 0x10e72
movl %r14d, %edx
callq 0xb37e
leaq 0x5a9e(%rip), %r14      # 0x10ddf
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa456
leaq 0x5a78(%rip), %r15      # 0x10dcd
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa456
movq %r15, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x8, %r13d
leaq 0x63f3(%rip), %rdi      # 0x1179c
cmpl $0x7, %eax
jg 0xb3d1
movl $0x4, %r13d
leaq 0x6434(%rip), %rdi      # 0x117ef
cmpl $0x3, %eax
jg 0xb3d1
movl $0x1, %r13d
leaq 0x6475(%rip), %rdi      # 0x11842
testl %eax, %eax
jle 0xb3e9
movq %r14, %rsi
movl %r12d, %edx
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
addl %r13d, %r12d
jmp 0xb397
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5f5b(%rip), %rdi      # 0x1136c
leaq 0x5ef1(%rip), %rsi      # 0x11309
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa456
leaq 0x5f84(%rip), %rdi      # 0x113b3
movq %r15, %rsi
callq 0xba84
callq 0xbc0f
leaq 0x5ed3(%rip), %rdi      # 0x11316
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x624c(%rip), %rdi      # 0x116a0
leaq 0x5a17(%rip), %rsi      # 0x10e72
movl %ebx, %edx
callq 0xb37e
leaq 0x5976(%rip), %rbx      # 0x10ddf
leaq 0x4d93(%rip), %r14      # 0x10203
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa456
leaq 0x5949(%rip), %r15      # 0x10dcd
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa456
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x5ecc(%rip), %rdi      # 0x1146b
leaq 0x5ee9(%rip), %rsi      # 0x1148f
movl %r15d, %edx
movl %r14d, %ecx
movl %r12d, %r8d
movl %ebx, %r9d
xorl %eax, %eax
callq 0xa456
leaq 0x5ede(%rip), %rdi      # 0x1149e
movl %r12d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5ee6(%rip), %rdi      # 0x114b7
xorl %eax, %eax
callq 0x1070
leaq 0x554e(%rip), %rdi      # 0x10b2d
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
movl %r15d, %edi
movl %r14d, %esi
callq 0xa5b7
leaq 0x3c4d(%rip), %rdi      # 0xf247
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x629d(%rip), %rdi      # 0x118a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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 0x5e9a(%rip), %rdi      # 0x114ce
leaq 0x5e58(%rip), %rsi      # 0x11493
movl %r14d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa456
leaq 0x5e94(%rip), %rdi      # 0x114e6
callq 0x1050
cmpl $0x5, %r15d
jg 0xb68d
leal (%r14,%r15,8), %r12d
leaq 0x5c4f(%rip), %r13      # 0x112b7
movl %r15d, %edi
callq 0xb6e6
movq %r13, %rdi
movq %rax, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1070
incl %r15d
addl $0x8, %r12d
cmpl $0x6, %r15d
jne 0xb668
leaq 0x54dc(%rip), %rdi      # 0x10b70
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
addl $0x30, %r14d
leaq 0x5e4f(%rip), %r15      # 0x114f7
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1070
incl %r12d
addl $0x10, %r14d
cmpl $0x8, %r12d
jne 0xb6ab
leaq 0x3b78(%rip), %rdi      # 0xf247
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_O1/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 0x5def(%rip), %rdi      # 0x11514
leaq 0x5d67(%rip), %rsi      # 0x11493
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa456
leaq 0x5dde(%rip), %rdi      # 0x11521
xorl %eax, %eax
callq 0x1070
leaq 0x5de7(%rip), %rdi      # 0x11538
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5dec(%rip), %rdi      # 0x1154e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5df2(%rip), %rdi      # 0x11565
xorl %eax, %eax
callq 0x1070
leaq 0x5e14(%rip), %rdi      # 0x11595
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5e1d(%rip), %rdi      # 0x115ae
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x243c
leaq 0x60de(%rip), %rdi      # 0x118bf
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x60e8(%rip), %rdi      # 0x118d9
xorl %eax, %eax
callq 0x1070
leaq 0x60f1(%rip), %rdi      # 0x118f0
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x243c
leaq 0x60e2(%rip), %rdi      # 0x11909
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x579d(%rip), %rdi      # 0x10fd4
xorl %eax, %eax
callq 0x1070
leaq 0x67ad(%rip), %rdi      # 0x11ff2
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x243c
leaq 0x60bc(%rip), %rdi      # 0x11929
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x60cc(%rip), %rdi      # 0x11949
xorl %eax, %eax
callq 0x1070
leaq 0x59b8(%rip), %rdi      # 0x11243
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6261(%rip), %rdi      # 0x11c85
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x63bf(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x63c2(%rip), %rdi      # 0x11e05
leaq 0x47b9(%rip), %rsi      # 0x10203
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x65b0(%rip), %rdi      # 0x1200b
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x65b3(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x622b(%rip), %rdi      # 0x11ca4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6206(%rip), %rdi      # 0x11cd0
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x6319(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x631c(%rip), %rdi      # 0x11e05
leaq 0x4713(%rip), %rsi      # 0x10203
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x650a(%rip), %rdi      # 0x1200b
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x650d(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x6460(%rip), %rdi      # 0x11f7f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x61b2(%rip), %rdi      # 0x11cef
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x62a6(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x62a9(%rip), %rdi      # 0x11e05
leaq 0x46a0(%rip), %rsi      # 0x10203
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6497(%rip), %rdi      # 0x1200b
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x649a(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x63af(%rip), %rdi      # 0x11f41
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6161(%rip), %rdi      # 0x11d0e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x6236(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x6239(%rip), %rdi      # 0x11e05
leaq 0x57e0(%rip), %rsi      # 0x113b3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6427(%rip), %rdi      # 0x1200b
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x642a(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x60a2(%rip), %rdi      # 0x11ca4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x60f8(%rip), %rdi      # 0x11d3a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x61a1(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x61a4(%rip), %rdi      # 0x11e05
leaq 0x574b(%rip), %rsi      # 0x113b3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6392(%rip), %rdi      # 0x1200b
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6395(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x62e8(%rip), %rdi      # 0x11f7f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x60b2(%rip), %rdi      # 0x11d66
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x612f(%rip), %rdi      # 0x11df4
xorl %eax, %eax
callq 0x1070
leaq 0x6132(%rip), %rdi      # 0x11e05
leaq 0x56d9(%rip), %rsi      # 0x113b3
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6320(%rip), %rdi      # 0x1200b
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6323(%rip), %rdi      # 0x1201e
xorl %eax, %eax
callq 0x1070
leaq 0x6238(%rip), %rdi      # 0x11f41
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6369(%rip), %rdi      # 0x12118
callq 0x1050
leaq 0x5219(%rip), %rdi      # 0x10fd4
xorl %eax, %eax
callq 0x1070
leaq 0x6139(%rip), %rdi      # 0x11f02
xorl %eax, %eax
callq 0x1070
leaq 0x6143(%rip), %rdi      # 0x11f1a
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6343(%rip), %rdi      # 0x1212d
callq 0x1050
leaq 0x5ae3(%rip), %rdi      # 0x118d9
xorl %eax, %eax
callq 0x1070
leaq 0x60fe(%rip), %rdi      # 0x11f02
xorl %eax, %eax
callq 0x1070
leaq 0x6146(%rip), %rdi      # 0x11f58
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x631d(%rip), %rdi      # 0x12142
callq 0x1050
leaq 0x5b18(%rip), %rdi      # 0x11949
xorl %eax, %eax
callq 0x1070
leaq 0x60c3(%rip), %rdi      # 0x11f02
xorl %eax, %eax
callq 0x1070
leaq 0x6149(%rip), %rdi      # 0x11f96
xorl %eax, %eax
callq 0x1070
leaq 0x4f72(%rip), %rdi      # 0x10dcd
xorl %eax, %eax
callq 0x1070
leaq 0x6143(%rip), %rdi      # 0x11fac
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 0x6137(%rip), %r12      # 0x11fc2
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 0x6129(%rip), %rdi      # 0x11fda
xorl %eax, %eax
callq 0x1070
leaq 0x56d6(%rip), %rdi      # 0x11595
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
addl $0x10, %ebx
leaq 0x611f(%rip), %rdi      # 0x11ff2
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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)
callq 0xa39e
movq %rax, %r15
cmpl $0x0, (%r14)
jle 0xbf5a
xorl %r13d, %r13d
movabsq $0x100000004, %rbx      # imm = 0x100000004
callq 0x5b39
movq %rax, %r12
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rbx, (%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x5ba7
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xa2d8
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0xbf17
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xd31c
movq %rdx, %r14
movslq %eax, %rdi
movl $0x20, %esi
callq 0x10d0
movq %rax, %r15
xorl %eax, %eax
movl (%r14), %ecx
andl $-0x2, %ecx
cmpl $0x4c, %ecx
je 0xbfac
cltq
movq %rax, %rcx
shlq $0x5, %rcx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%r15,%rcx)
movups %xmm1, 0x10(%r15,%rcx)
incl %eax
cmpl $0x2, (%r15,%rcx)
je 0xbfb2
addq $0x20, %r14
jmp 0xbf7b
movslq %eax, %rdi
movl $0x20, %esi
callq 0x10d0
movq %r15, %rcx
addq $0x20, %rcx
movq %rcx, -0x40(%rbp)
xorl %edx, %edx
xorl %r14d, %r14d
movq %r15, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq %rdx, %rsi
shlq $0x5, %rsi
movslq %r14d, %rbx
movq %rbx, %rcx
shlq $0x5, %rcx
movups (%r15,%rcx), %xmm0
movups 0x10(%r15,%rcx), %xmm1
movups %xmm0, (%rax,%rsi)
movups %xmm1, 0x10(%rax,%rsi)
movl (%rax,%rsi), %ecx
cmpl $0x39, %ecx
jne 0xc094
incq %rbx
shlq $0x5, %rbx
cmpl $0x39, (%r15,%rbx)
jne 0xc094
movl %ecx, -0x34(%rbp)
movq %rdx, -0x30(%rbp)
addq %rax, %rsi
movq %rsi, -0x58(%rbp)
movq 0x10(%rsi), %r12
addq -0x40(%rbp), %rbx
movq %r12, %r15
movq %r12, %rdi
callq 0x1060
movq %rax, %r12
movq -0x10(%rbx), %r13
movq %r13, %rdi
callq 0x1060
addl %r12d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x10d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r12, %rdi
movq %r13, %rsi
callq 0x1150
incl %r14d
cmpl $0x39, (%rbx)
leaq 0x20(%rbx), %rbx
je 0xc02c
movq -0x58(%rbp), %rax
movq %r12, 0x10(%rax)
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
cmpl $0x2, %ecx
je 0xc0a4
incq %rdx
incl %r14d
jmp 0xbfd7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
leaq 0x1(%rax), %rdi
movl $0x1, %esi
callq 0x10d0
leaq 0xb006(%rip), %rcx      # 0x170dc
movl (%rcx), %ecx
xorl %edx, %edx
leaq 0x6077(%rip), %rsi      # 0x12158
movq %rax, %r8
movl %edx, %edx
movzbl (%rbx,%rdx), %r10d
cmpl $0x5c, %r10d
je 0xc107
testl %r10d, %r10d
je 0xc16f
movl $0x1, %r9d
movb %r10b, (%r8)
addl %r9d, %edx
incq %r8
jmp 0xc0e4
movb 0x1(%rbx,%rdx), %r10b
movzbl %r10b, %edi
movl $0x2, %r9d
cmpl $0x64, %edi
jg 0xc12c
cmpl $0x22, %edi
je 0xc0fc
cmpl $0x27, %edi
je 0xc0fc
cmpl $0x5c, %edi
je 0xc0fc
jmp 0xc176
leal -0x6e(%rdi), %r10d
cmpl $0x8, %r10d
ja 0xc145
movslq (%rsi,%r10,4), %r10
addq %rsi, %r10
jmpq *%r10
movb $0xa, %r10b
jmp 0xc0fc
cmpl $0x65, %edi
je 0xc163
cmpl $0x66, %edi
jne 0xc176
movb $0xc, %r10b
jmp 0xc0fc
movb $0xb, %r10b
jmp 0xc0fc
movb $0xd, %r10b
jmp 0xc0fc
movb $0x9, %r10b
jmp 0xc0fc
movb $0x1b, %r10b
testl %ecx, %ecx
je 0xc0fc
callq 0x2177
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x219f
// File: /workspace/github_c_makefile_star2_O1/hsjoihs[P]c-compiler/lexer.c
// Function: escape
char *escape(const char *str)
{
	char *ans =
	    calloc(strlen(str) * 4 /* length of "\\013" */ + 1, sizeof(char));
	int j = 0;
	for (int i = 0; str[i]; i++) {
		switch (str[i]) {
		case 92:
			ans[j] = 92;
			ans[j + 1] = 92;
			j += 2;
			break;
		case 9:
			ans[j] = 92;
			ans[j + 1] = 't';
			j += 2;
			break;
		case 10:
			ans[j] = 92;
			ans[j + 1] = 'n';
			j += 2;
			break;
		case 11: /* somehow \v fails */
			ans[j] = 92;
			ans[j + 1] = '0';
			ans[j + 2] = '1';
			ans[j + 3] = '3';
			j += 4;
			break;
		case 12:
			ans[j] = 92;
			ans[j + 1] = 'f';
			j += 2;
			break;
		case 13:
			ans[j] = 92;
			ans[j + 1] = 'r';
			j += 2;
			break;
		case '"':
			ans[j] = 92;
			ans[j + 1] = '"';
			j += 2;
			break;
		case 0x1b:
			ans[j] = 92;
			ans[j + 1] = '0';
			ans[j + 2] = '3';
			ans[j + 3] = '3';
			j += 4;
			break;
		/* single quote need not be re-escaped */
		default:
			ans[j] = str[i];
			j++;
			break;
		}
	}

	/* calloc means automatically null terminated */
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
leaq 0x1(,%rax,4), %rdi
movl $0x1, %esi
callq 0x10d0
xorl %ecx, %ecx
leaq 0x5fd8(%rip), %rdx      # 0x1217c
movb (%rbx), %sil
movzbl %sil, %edi
cmpl $0x1a, %edi
jg 0xc1ca
cmpl $0xd, %edi
ja 0xc233
movl %edi, %edi
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
movl %ecx, %esi
movw $0x745c, (%rax,%rsi)    # imm = 0x745C
jmp 0xc224
cmpl $0x1b, %edi
je 0xc20c
cmpl $0x22, %edi
je 0xc21c
cmpl $0x5c, %edi
jne 0xc233
movl %ecx, %esi
movw $0x5c5c, (%rax,%rsi)    # imm = 0x5C5C
jmp 0xc224
movl %ecx, %esi
movw $0x665c, (%rax,%rsi)    # imm = 0x665C
jmp 0xc224
movl %ecx, %esi
movw $0x725c, (%rax,%rsi)    # imm = 0x725C
jmp 0xc224
movl %ecx, %esi
movl $0x3331305c, (%rax,%rsi) # imm = 0x3331305C
jmp 0xc215
movl %ecx, %esi
movw $0x6e5c, (%rax,%rsi)    # imm = 0x6E5C
jmp 0xc224
movl %ecx, %esi
movl $0x3333305c, (%rax,%rsi) # imm = 0x3333305C
movl $0x4, %esi
jmp 0xc229
movl %ecx, %esi
movw $0x225c, (%rax,%rsi)    # imm = 0x225C
movl $0x2, %esi
addl %esi, %ecx
incq %rbx
jmp 0xc1a4
movl %ecx, %edi
movb %sil, (%rax,%rdi)
movl $0x1, %esi
jmp 0xc229
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc2c2
cmpl $0x3, %eax
je 0xc2bb
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq %rsi, %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0xc2c7
xorl %r15d, %r15d
movq 0xad78(%rip), %r12      # 0x16ff8
movabsq $0x100003e00, %r13      # imm = 0x100003E00
movzbl (%rax,%r15), %eax
cmpq $0x20, %rax
ja 0xc29b
btq %rax, %r13
jb 0xc2c7
movsbl %al, %edi
movq (%r12), %rsi
callq 0x1090
incq %r15
movq 0x18(%r14), %rax
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jg 0xc28a
jmp 0xc2c7
callq 0x21c7
jmp 0xc2c7
callq 0x21f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, -0x30(%rbp)
leaq -0x58(%rbp), %r14
movq %rdi, (%r14)
movl $0x2, %ebx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xc3c0
incq %rbx
cmpl $0x2, -0x50(%rbp)
jne 0xc309
movl $0x20, %esi
movq %rbx, %rdi
callq 0x10d0
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq (%r15), %rax
movl $0x3, (%r14)
movq $0x0, 0x8(%r14)
movq %rax, 0x18(%r14)
movq %r14, %r13
addq $0x38, %r13
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc3c0
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 0xc352
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_O1/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 0x5af4
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq -0x60(%rbp), %rsi
callq 0x5bff
movl (%rbx), %eax
cmpl $0x5, %eax
ja 0xd24f
movl $0x3a, %ecx
btl %eax, %ecx
jae 0xd20d
movq -0xc0(%rbp), %rdi
callq 0xd196
leaq -0x48(%rbp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq -0x38(%rbp), %rdi
callq 0x5bff
jmp 0xd24f
movl -0x3d0(%rbp), %r15d
testq %r15, %r15
je 0xd24f
movq -0x3c8(%rbp), %r12
xorl %r13d, %r13d
leaq -0x38(%rbp), %rbx
leaq -0x48(%rbp), %r14
movq (%r12,%r13,8), %rdi
callq 0xd196
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5bff
incq %r13
cmpq %r13, %r15
jne 0xd22b
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %r12d
movl $0xc350, %edi           # imm = 0xC350
movl $0x1, %esi
callq 0x10d0
movq %rax, %r14
leaq -0x430(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
je 0xd305
movl $0xc350, %r13d          # imm = 0xC350
leaq -0x430(%rbp), %r15
movq %r15, %rdi
callq 0x1060
movslq %r12d, %r12
addq %rax, %r12
cmpl %r12d, %r13d
jge 0xd2e5
addl %r13d, %r13d
movslq %r13d, %rsi
movq %r14, %rdi
callq 0x1120
movq %rax, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1150
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
jne 0xd2c1
movq %r14, %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_O1/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 0xd978
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r12), %rsi
callq 0xa389
testl %eax, %eax
je 0xd978
movq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0xa389
testl %eax, %eax
je 0xd999
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 0xa32d
movq 0x8(%rax), %rax
movq (%rax), %r13
movq 0x8(%r12), %rsi
leaq -0x2c(%rbp), %rdx
movq %r14, %rdi
callq 0xa2d8
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xd93a
jmp 0xd98a
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x74(%rdi)
je 0x1997
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x80(%rdi), %r13
addq %rsi, %rbx
xorl %r12d, %r12d
testb $0x2, (%r13)
je 0x1983
movq 0x8(%r13), %rax
cmpq %r14, %rax
setb %cl
cmpq %rbx, %rax
setae %al
orb %cl, %al
jne 0x1983
movq %r15, %rdi
movl %r12d, %esi
callq 0x19a9
testl %eax, %eax
js 0x199a
movl $0x0, (%r13)
incq %r12
movl 0x74(%r15), %eax
addq $0x10, %r13
cmpq %rax, %r12
jb 0x1951
xorl %eax, %eax
jmp 0x199f
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
shlq $0x4, %rax
movl 0x80(%rdi,%rax), %ecx
notl %ecx
xorl %ebx, %ebx
testb $0x3, %cl
jne 0x1a79
movl %esi, %ebp
movq %rdi, %r14
leaq (%rdi,%rax), %r15
addq $0x80, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rsi
movb (%rdi), %cl
movl %ebp, %eax
shll %cl, %eax
leaq (%r14,%rax), %rcx
addq $0x180, %rcx            # imm = 0x180
movl $0x1, %edx
callq *0x10(%rdi)
testl %eax, %eax
js 0x1a74
incl 0x24(%r14)
incl 0xc(%r14)
incl 0x14(%r14)
movq %r15, (%rsp)
movq 0x8(%r15), %r15
movq 0x30(%r14), %rax
cmpq %rax, %r15
jb 0x1a6b
addq 0x38(%r14), %rax
cmpq %rax, %r15
jae 0x1a6b
cmpl $0x2, 0x40(%r14)
jb 0x1a6b
leaq 0x180(%r14), %r13
movl $0x1, %r12d
addq 0x38(%r14), %r15
movq (%r14), %rdi
movb (%rdi), %cl
movl %ebp, %eax
shll %cl, %eax
addq %r13, %rax
movl $0x1, %edx
movq %r15, %rsi
movq %rax, %rcx
callq *0x10(%rdi)
incl 0xc(%r14)
incl 0x14(%r14)
incl %r12d
cmpl 0x40(%r14), %r12d
jb 0x1a3c
movq (%rsp), %rax
andb $-0x2, (%rax)
jmp 0x1a79
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
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_O1/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
testq %rax, %rax
je 0x1ad4
addq %rsi, %rdx
shlq $0x4, %rax
xorl %ecx, %ecx
testb $0x2, 0x80(%rdi,%rcx)
je 0x1acb
movq 0x88(%rdi,%rcx), %r8
cmpq %rsi, %r8
setb %r9b
cmpq %rdx, %r8
setae %r8b
orb %r9b, %r8b
jne 0x1acb
movl $0x0, 0x80(%rdi,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x1a9b
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x74(%rdi)
je 0x1f14
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19a9
testl %eax, %eax
cmovnel %eax, %ebp
incl %r14d
cmpl 0x74(%rbx), %r14d
jb 0x1ef9
jmp 0x1f16
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl 0x50(%rdi), %r13d
movl $0x0, %r14d
cmpl $0x3, %r13d
jb 0x1f95
movq %rdi, %r15
xorl %r14d, %r14d
movl $0x2, %ebp
leaq 0xc(%rsp), %r12
cmpl $0xff0, %ebp            # imm = 0xFF0
jne 0x1f64
movl $0x4, %ecx
cmpl $0xc, 0x28(%r15)
je 0x1f89
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x1fb2
testl %eax, %eax
js 0x1f82
cmpl $0x1, 0xc(%rsp)
adcl $0x0, %r14d
xorl %ecx, %ecx
jmp 0x1f89
movl $0x1, %ecx
movl %eax, %ebx
testb $0x3, %cl
jne 0x1fae
incl %ebp
cmpl %ebp, %r13d
jne 0x1f50
movq 0x10(%rsp), %rax
movl %r14d, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %eax
jmp 0x1f9f