LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_from_local_8byte
void gen_push_from_local_8byte(int offset)
{
	assert(offset < 0);
	printf("//gen_push_from_local_8byte(%d)\n", offset);
	printf("  subq $8, %%rsp\n"
	       "  movq %d(%%rbp), %%rax\n"
	       "  movq %%rax, (%%rsp)\n",
	       offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0x1260
movl -0x4(%rbp), %esi
leaq 0x85bf(%rip), %rdi      # 0x16d77
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x85cf(%rip), %rdi      # 0x16d98
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_from_local_1byte
void gen_push_from_local_1byte(int offset)
{
	assert(offset < 0);
	printf("//gen_push_from_local_1byte(%d)\n", offset);
	printf("  subq $8, %%rsp\n"
	       "  movsbl %d(%%rbp), %%eax\n"
	       "  movl %%eax, (%%rsp)\n",
	       offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0x1260
movl -0x4(%rbp), %esi
leaq 0x85d0(%rip), %rdi      # 0x16dd8
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x85e0(%rip), %rdi      # 0x16df9
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x862a(%rip), %rdi      # 0x16ea4
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x6b09(%rip), %rdi      # 0x15395
callq 0xe8b0
movl -0xc(%rbp), %edi
callq 0xe8f0
leaq 0x8623(%rip), %rdi      # 0x16ec3
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x85b5(%rip), %rdi      # 0x16eef
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x6a49(%rip), %rdi      # 0x15395
callq 0xe8b0
movl -0xc(%rbp), %edi
callq 0xe8f0
leaq 0x887e(%rip), %rdi      # 0x171de
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x8584(%rip), %rdi      # 0x16f0e
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x69f9(%rip), %rdi      # 0x15395
callq 0xe8b0
movl -0xc(%rbp), %edi
callq 0xe8f0
leaq 0x87da(%rip), %rdi      # 0x1718a
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x8556(%rip), %rdi      # 0x16f2d
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x7b22(%rip), %rdi      # 0x1650b
callq 0xe8b0
callq 0xea10
leaq 0x84c9(%rip), %rdi      # 0x16ec3
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x8522(%rip), %rdi      # 0x16f59
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x7ac2(%rip), %rdi      # 0x1650b
callq 0xe8b0
callq 0xea10
leaq 0x8784(%rip), %rdi      # 0x171de
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x84fe(%rip), %rdi      # 0x16f85
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x7a72(%rip), %rdi      # 0x1650b
callq 0xe8b0
callq 0xea10
leaq 0x86e0(%rip), %rdi      # 0x1718a
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x859a(%rip), %rdi      # 0x17135
movb $0x0, %al
callq 0x1080
leaq 0x7583(%rip), %rdi      # 0x1612c
movb $0x0, %al
callq 0x1080
leaq 0x8594(%rip), %rdi      # 0x1714b
movb $0x0, %al
callq 0x1080
leaq 0x859e(%rip), %rdi      # 0x17163
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x85c6(%rip), %rdi      # 0x171a1
movb $0x0, %al
callq 0x1080
leaq 0x7e38(%rip), %rdi      # 0x16a21
movb $0x0, %al
callq 0x1080
leaq 0x8554(%rip), %rdi      # 0x1714b
movb $0x0, %al
callq 0x1080
leaq 0x85b2(%rip), %rdi      # 0x171b7
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x85da(%rip), %rdi      # 0x171f5
movb $0x0, %al
callq 0x1080
leaq 0x7e68(%rip), %rdi      # 0x16a91
movb $0x0, %al
callq 0x1080
leaq 0x8514(%rip), %rdi      # 0x1714b
movb $0x0, %al
callq 0x1080
leaq 0x85c6(%rip), %rdi      # 0x1720b
movb $0x0, %al
callq 0x1080
leaq 0x72d2(%rip), %rdi      # 0x15f25
movb $0x0, %al
callq 0x1080
leaq 0x85c0(%rip), %rdi      # 0x17221
movb $0x0, %al
callq 0x1080
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
leaq 0x85a6(%rip), %rdi      # 0x17237
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %esi
movl -0x4(%rbp), %edx
addl $0x4, %edx
leaq 0x858f(%rip), %rdi      # 0x17237
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
addl $0x8, %esi
leaq 0x8593(%rip), %rdi      # 0x1724f
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %esi
leaq 0x7a39(%rip), %rdi      # 0x16706
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
addl $0x10, %esi
leaq 0x8586(%rip), %rdi      # 0x17267
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xccc0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xed81
callq 0x6200
movq %rax, -0x28(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x4, (%rax)
movq -0x30(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0xcb50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xed10
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x117c0
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xedc0
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xeeb0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/lexer.c
// Function: remove_spaces_and_newlines
static struct Tokvec remove_spaces_and_newlines(const struct Tokvec *ref_t)
{
	const struct Token *tokvec = ref_t->v;

	struct Token *tokvec_new = calloc(ref_t->tok_num, sizeof(struct Token));

	int j = 0;

	for (int k = 0;; k++) {
		if (tokvec[k].kind == NEWLINE || tokvec[k].kind == SPACE) {
			continue;
		}

		tokvec_new[j] = tokvec[k];

		if (tokvec_new[j].kind == END) {
			break;
		}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rdi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x4c, (%rax)
je 0xee23
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x4d, (%rax)
jne 0xee25
jmp 0xee80
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0xee77
jmp 0xee8e
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xedfb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/lexer.c
// Function: concat_str_literals
static struct Token *concat_str_literals(const struct Tokvec *ref_v)
{
	struct Token *tokvec = ref_v->v;

	struct Token *tokvec_new = calloc(ref_v->tok_num, sizeof(struct Token));

	int j = 0;
	int k = 0;
	for (;; j++, k++) {
		tokvec_new[j] = tokvec[k];
		/* token_begins_here is also copied here */
		if (tokvec_new[j].kind == LIT_STRING) {
			while (tokvec[k + 1].kind == LIT_STRING) {
				int total_len = strlen(tokvec_new[j].literal_str) +
				                strlen(tokvec[k + 1].literal_str);
				char *new_str = calloc(total_len + 1, sizeof(char));
				strcpy(new_str, tokvec_new[j].literal_str);
				strcat(new_str, tokvec[k + 1].literal_str);
				tokvec_new[j].literal_str = new_str;
				k++;
			}
		}

		if (tokvec_new[j].kind == END) {
			break;
		}
	}
	return tokvec_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x39, (%rax)
jne 0xf01f
jmp 0xef41
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x39, (%rax)
jne 0xf01d
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1060
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x1040
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x1130
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xef41
jmp 0xf01f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0xf035
jmp 0xf04e
jmp 0xf037
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xeeeb
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0xf506
movq 0xcb08(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
leaq 0x7f50(%rip), %rsi      # 0x1744a
movb $0x0, %al
callq 0x10d0
jmp 0xf5bf
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xf52c
movq 0xcae2(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
leaq 0x7f35(%rip), %rsi      # 0x17455
movb $0x0, %al
callq 0x10d0
jmp 0xf5bf
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jge 0xf5bf
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x20, %eax
je 0xf593
movsbl -0x15(%rbp), %eax
cmpl $0x9, %eax
je 0xf593
movsbl -0x15(%rbp), %eax
cmpl $0xa, %eax
je 0xf593
movsbl -0x15(%rbp), %eax
cmpl $0xb, %eax
je 0xf593
movsbl -0x15(%rbp), %eax
cmpl $0xc, %eax
je 0xf593
movsbl -0x15(%rbp), %eax
cmpl $0xd, %eax
jne 0xf595
jmp 0xf5bf
movq 0xca5c(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
movsbl -0x15(%rbp), %edx
leaq 0x7ebc(%rip), %rsi      # 0x17466
movb $0x0, %al
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf533
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xf760
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x50(%rbp)
movl $0x3, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x1, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xf7c0
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpl $0x2, -0x38(%rbp)
jne 0xf726
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x4c, (%rax)
jmp 0xf736
jmp 0xf728
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xf67b
movl -0x3c(%rbp), %eax
incl %eax
movl %eax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/lexer.c
// Function: count_all_tokens
static int count_all_tokens(const char *str)
{
	struct Token tok;
	int count = 1;
	do {
		tok = get_token(&str);
		++count;
	} while (tok.kind != END);
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xf7c0
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2, -0x28(%rbp)
jne 0xf773
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/lexer.c
// Function: hex_digit
static int hex_digit(char c)
{
	switch (c) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
		return c - '0';

	/* works for EBCDIC, too! */
	case 'a':
	case 'b':
	case 'c':
	case 'd':
	case 'e':
	case 'f':
		return c - 'a' + 10;

	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F':
		return c - 'A' + 10;

	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0x11245
jmp 0x1122b
movl -0xc(%rbp), %eax
addl $-0x41, %eax
subl $0x6, %eax
jb 0x11260
jmp 0x11238
movl -0xc(%rbp), %eax
addl $-0x61, %eax
subl $0x6, %eax
jb 0x11251
jmp 0x1126f
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x11276
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x11276
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x11276
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x3a8(%rbp), %rdi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
callq 0x61d0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x6370
movl -0x3a8(%rbp), %eax
movq %rax, -0x3f0(%rbp)
subq $0xc, %rax
ja 0x116ff
movq -0x3f0(%rbp), %rax
leaq 0x5f69(%rip), %rcx      # 0x1759c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x116ff
jmp 0x116ff
movq -0x90(%rbp), %rdi
callq 0x115d0
movq %rax, -0x3b8(%rbp)
movq %rdx, -0x3b0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x6370
jmp 0x116ff
movq -0x3a0(%rbp), %rax
movq %rax, -0x3c8(%rbp)
movq -0x398(%rbp), %rax
movq %rax, -0x3c0(%rbp)
movl $0x0, -0x3cc(%rbp)
movl -0x3cc(%rbp), %eax
cmpl -0x3c8(%rbp), %eax
je 0x116fd
movq -0x3c0(%rbp), %rax
movslq -0x3cc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x3d8(%rbp)
movq -0x3d8(%rbp), %rdi
callq 0x115d0
movq %rax, -0x3e8(%rbp)
movq %rdx, -0x3e0(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x6370
movl -0x3cc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3cc(%rbp)
jmp 0x1169b
jmp 0x116ff
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0xc350, -0x10(%rbp)    # imm = 0xC350
movslq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x10a0
cmpq $0x0, %rax
je 0x117a6
leaq -0x420(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x11794
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x1130
jmp 0x1173f
movq -0x18(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/cpp.c
// Function: set_line_state
static void set_line_state(enum LineState *ps, enum TokenKind kind)
{
	if (kind == NEWLINE || kind == BEGINNING) {
		*ps = LINE_HAS_JUST_STARTED;
	} else if (kind == SPACE) {
		/* keep the state as is */
	} else {
		*ps = NOTHING_SPECIAL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x4c, -0xc(%rbp)
je 0x11ab7
cmpl $0x3, -0xc(%rbp)
jne 0x11ac3
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
jmp 0x11ad7
cmpl $0x4d, -0xc(%rbp)
jne 0x11acb
jmp 0x11ad5
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
jmp 0x11ad7
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x11b7d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xcc90
cmpl $0x0, %eax
je 0x11b7d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xcc90
cmpl $0x0, %eax
jne 0x11b7d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xcc00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x34(%rbp), %rdx
callq 0xcb50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x11ae0
jmp 0x11ba3
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/cpp.c
// Function: handle_define
static int handle_define(const struct Token **ptr_src,
                         struct Map2 /*<struct Vector<struct Token>*/ *def_map)
{
	expect_and_consume(ptr_src, IDENT_OR_RESERVED,
	                   "macro name after `#define`");
	const char *macro_name = (*ptr_src)[-1].ident_str;

	/* only when the identifier is IMMEDIATELY followed by
	 * LEFT_PAREN */
	if ((*ptr_src)[0].kind == LEFT_PAREN) {
		unsupported("function-style macro");
	}

	/* that's why this must be here, not earlier */
	consume_spaces(ptr_src);

	struct Token *ptr_token = calloc(1, sizeof(struct Token));

	/* empty replacement */
	if ((*ptr_src)[0].kind == NEWLINE) {
		(*ptr_src)++;
		ptr_token->kind = SPACE;
		struct Vector *p = init_vector_();
		push_vector(p, ptr_token);
		insert(def_map, macro_name, p); /*<struct Vector<struct Token>*/
		return 1;
	}

	if ((*ptr_src)[1].kind != NEWLINE) {
		unsupported("`#define` directive that expands to multiple tokens");
	}

	/* one-token replacement */
	*ptr_token = **ptr_src;
	struct Vector *p = init_vector_();
	push_vector(p, ptr_token);
	insert(def_map, macro_name, p);
	(*ptr_src)++;

	if ((*ptr_src)[0].kind == NEWLINE) {
		(*ptr_src)++;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x18, %esi
leaq 0x5adf(%rip), %rdx      # 0x176df
callq 0xb190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, (%rax)
jne 0x11c2c
leaq 0x5ad3(%rip), %rdi      # 0x176fa
callq 0xb1f0
movq -0x10(%rbp), %rdi
callq 0x11bb0
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4c, (%rax)
jne 0x11c9f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x4d, (%rax)
callq 0x6200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xcb50
movl $0x1, -0x4(%rbp)
jmp 0x11d40
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4c, 0x20(%rax)
je 0x11cb8
leaq 0x5a5c(%rip), %rdi      # 0x1770f
callq 0xb1f0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
callq 0x6200
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x62c0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xcb50
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4c, (%rax)
jne 0x11d39
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x11d40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/cpp.c
// Function: handle_ifdef
static int handle_ifdef(int is_ifdef, const struct Token **ptr_src,
                        struct Map2 /*<struct Vector<struct Token>*/ *def_map,
                        int *ptr_ifdef_depth)
{
	expect_and_consume(ptr_src, IDENT_OR_RESERVED,
	                   is_ifdef ? "identifier after `#ifdef`"
	                            : "identifier after `#ifndef`");

	const char *macro_name = (*ptr_src)[-1].ident_str;
	consume_spaces(ptr_src);

	expect_and_consume(ptr_src, NEWLINE,
	                   is_ifdef ? "newline after `#ifdef (macro_name)`"
	                            : "newline after `#ifndef (macro_name)`");
	(*ptr_src)--; /* ad hoc */

	if (is_ifdef == isElem(def_map, macro_name)) { /* true branch */
		(*ptr_ifdef_depth)++;
	} else { /* false branch */
		skip_till_corresponding_endif(ptr_src);

		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %ecx
leaq 0x58af(%rip), %rdx      # 0x177e4
leaq 0x588e(%rip), %rax      # 0x177ca
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl $0x18, %esi
callq 0xb190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11bb0
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %ecx
leaq 0x58b0(%rip), %rdx      # 0x17823
leaq 0x5885(%rip), %rax      # 0x177ff
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl $0x4c, %esi
callq 0xb190
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x20, %rcx
movq %rcx, (%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xcc90
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x11fc2
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x11fd4
movq -0x10(%rbp), %rdi
callq 0x11ff0
movl $0x1, -0x4(%rbp)
jmp 0x11fdb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x74(%rcx), %eax
jae 0x23af
movq 0x28(%rsp), %rax
addq $0x80, %rax
movl 0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x239d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x20(%rsp), %rax
jb 0x239d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
addq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x239d
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x23c0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x2392
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x23b7
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x239f
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x230b
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x74(%rcx), %eax
jae 0x2651
movq -0x8(%rsp), %rax
addq $0x80, %rax
movl -0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2642
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rsp), %rax
jb 0x2642
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
addq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2642
movq -0x28(%rsp), %rax
movl $0x0, (%rax)
jmp 0x2644
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x25d7
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]ufat/ufat.c
// Function: ufat_open
int ufat_open(struct ufat *uf, const struct ufat_device *dev)
{
	uf->dev = dev;

	uf->next_seq = 0;
	uf->cache_size = UFAT_CACHE_BYTES >> dev->log2_block_size;

	if (uf->cache_size > UFAT_CACHE_MAX_BLOCKS)
		uf->cache_size = UFAT_CACHE_MAX_BLOCKS;

	if (!uf->cache_size)
		return -UFAT_ERR_BLOCK_SIZE;

	uf->alloc_ptr = 0;
	memset(&uf->stat, 0, sizeof(uf->stat));
	memset(&uf->cache_desc, 0, sizeof(uf->cache_desc));

	return read_bpb(uf);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x70(%rax)
movq (%rsp), %rax
movl (%rax), %ecx
movl $0x2000, %eax           # imm = 0x2000
sarl %cl, %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x74(%rax)
movq 0x8(%rsp), %rax
cmpl $0x10, 0x74(%rax)
jbe 0x2983
movq 0x8(%rsp), %rax
movl $0x10, 0x74(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x74(%rax)
jne 0x2998
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0x29df
movq 0x8(%rsp), %rax
movl $0x0, 0x78(%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2100
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2100
movq 0x8(%rsp), %rdi
callq 0x29f0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]ufat/ufat.c
// Function: read_bpb
static int read_bpb(struct ufat *uf)
{
	int idx;

	idx = ufat_cache_open(uf, 0, 0);
	if (idx < 0)
		return idx;

	return parse_bpb(uf->dev->log2_block_size, &uf->bpb,
			 ufat_cache_data(uf, idx));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2660
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2a1e
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2a5d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2900
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x3560
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x74(%rcx), %eax
jae 0x2ac7
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x23c0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x2ab8
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x2aba
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2a89
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x14(%rsp)
movl $0x2, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x2b64
cmpl $0xff0, 0x1c(%rsp)      # imm = 0xFF0
jne 0x2b1b
movq 0x28(%rsp), %rax
cmpl $0xc, 0x28(%rax)
jne 0x2b1b
jmp 0x2b57
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x10(%rsp), %rdx
callq 0x2b80
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x2b43
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2b77
cmpl $0x0, 0x10(%rsp)
jne 0x2b55
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2b57
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2afa
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jb 0x2baa
movl $0xfffffffb, 0x24(%rsp) # imm = 0xFFFFFFFB
jmp 0x2c26
movq 0x18(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0xc, %eax
je 0x2bd3
jmp 0x2bbd
movl 0x4(%rsp), %eax
subl $0x10, %eax
je 0x2bec
jmp 0x2bc8
movl 0x4(%rsp), %eax
subl $0x20, %eax
je 0x2c05
jmp 0x2c1e
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2c90
movl %eax, 0x24(%rsp)
jmp 0x2c26
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2de0
movl %eax, 0x24(%rsp)
jmp 0x2c26
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2ef0
movl %eax, 0x24(%rsp)
jmp 0x2c26
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]ufat/ufat.c
// Function: read_fat12
static int read_fat12(struct ufat *uf, ufat_cluster_t index,
		      ufat_cluster_t *out)
{
	unsigned int offset = (index >> 1) * 3;
	uint8_t a;
	uint8_t b;
	uint16_t raw;
	int err;

	err = read_fat_byte(uf, offset + 1, &a);
	if (err < 0)
		return err;

	if (index & 1) {
		err = read_fat_byte(uf, offset + 2, &b);
		if (err < 0)
			return err;

		raw = (((ufat_cluster_t)b) << 4) |
			(((ufat_cluster_t)a) >> 4);
	} else {
		err = read_fat_byte(uf, offset, &b);
		if (err < 0)
			return err;

		raw = ((ufat_cluster_t)b) |
			((((ufat_cluster_t)a) & 0xf) << 8);
	}

	if (raw >= 0xff8 || raw == 0xff0) {
		*out = UFAT_CLUSTER_EOC;
		return 0;
	}

	if (raw == 0xff7) {
		*out = UFAT_CLUSTER_BAD;
		return 0;
	}

	*out = raw;
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x24(%rsp), %eax
shrl %eax
imull $0x3, %eax, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x1, %esi
leaq 0x13(%rsp), %rdx
callq 0x39d0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x2cdd
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2dd1
movl 0x24(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2d30
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
addl $0x2, %esi
leaq 0x12(%rsp), %rdx
callq 0x39d0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x2d17
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2dd1
movzbl 0x12(%rsp), %eax
shll $0x4, %eax
movzbl 0x13(%rsp), %ecx
shrl $0x4, %ecx
orl %ecx, %eax
movw %ax, 0x10(%rsp)
jmp 0x2d6f
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x12(%rsp), %rdx
callq 0x39d0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x2d58
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2dd1
movzbl 0x12(%rsp), %eax
movzbl 0x13(%rsp), %ecx
andl $0xf, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, 0x10(%rsp)
movzwl 0x10(%rsp), %eax
cmpl $0xff8, %eax            # imm = 0xFF8
jge 0x2d87
movzwl 0x10(%rsp), %eax
cmpl $0xff0, %eax            # imm = 0xFF0
jne 0x2d9c
movq 0x18(%rsp), %rax
movl $0xffffff8, (%rax)      # imm = 0xFFFFFF8
movl $0x0, 0x34(%rsp)
jmp 0x2dd1
movzwl 0x10(%rsp), %eax
cmpl $0xff7, %eax            # imm = 0xFF7
jne 0x2dbd
movq 0x18(%rsp), %rax
movl $0xffffff7, (%rax)      # imm = 0xFFFFFF7
movl $0x0, 0x34(%rsp)
jmp 0x2dd1
movzwl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]ufat/ufat.c
// Function: read_fat16
static int read_fat16(struct ufat *uf, ufat_cluster_t index,
		      ufat_cluster_t *out)
{
	const unsigned int shift = uf->dev->log2_block_size - 1;
	const unsigned int b = index >> shift;
	const unsigned int r = index & ((1 << shift) - 1);
	int i = ufat_cache_open(uf, uf->bpb.fat_start + b, 0);
	uint16_t raw;

	if (i < 0)
		return i;

	raw = r16(ufat_cache_data(uf, i) + r * 2);

	if (raw >= 0xfff8) {
		*out = UFAT_CLUSTER_EOC;
		return 0;
	}

	if (raw == 0xfff7) {
		*out = UFAT_CLUSTER_BAD;
		return 0;
	}

	*out = raw;
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x24(%rsp), %eax
movl 0x14(%rsp), %ecx
shrl %cl, %eax
movl %eax, 0x10(%rsp)
movl 0x24(%rsp), %eax
movl 0x14(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rsi
movl 0x10(%rsp), %eax
addq %rax, %rsi
xorl %edx, %edx
callq 0x2660
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jge 0x2e5c
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x2ed8
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x2900
movq %rax, %rdi
movl 0xc(%rsp), %eax
shll %eax
movl %eax, %eax
addq %rax, %rdi
callq 0x38f0
movw %ax, 0x6(%rsp)
movzwl 0x6(%rsp), %eax
cmpl $0xfff8, %eax           # imm = 0xFFF8
jl 0x2ea3
movq 0x18(%rsp), %rax
movl $0xffffff8, (%rax)      # imm = 0xFFFFFF8
movl $0x0, 0x34(%rsp)
jmp 0x2ed8
movzwl 0x6(%rsp), %eax
cmpl $0xfff7, %eax           # imm = 0xFFF7
jne 0x2ec4
movq 0x18(%rsp), %rax
movl $0xffffff7, (%rax)      # imm = 0xFFFFFF7
movl $0x0, 0x34(%rsp)
jmp 0x2ed8
movzwl 0x6(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)