LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_direct_declarator
static void
parse_direct_declarator(const struct Token **ptr_tokvec,
                        const char **ptr_to_ident_str,
                        struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct Vector vec = *ptr_vec;
	if (tokvec[0].kind == LEFT_PAREN) {
		++tokvec;
		parse_declarator(&tokvec, ptr_to_ident_str, &vec);
		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "closing parenthesis inside direct declarator");
		*ptr_tokvec = tokvec;
	} else if (tokvec[0].kind == IDENT_OR_RESERVED) {
		*ptr_to_ident_str = tokvec[0].ident_str;
		++tokvec;
	} else {
		error_unexpected_token(tokvec, "an identifier in the declarator");
	}

	parse_dcl_postfixes(&tokvec, &vec);

	*ptr_tokvec = tokvec;
	*ptr_vec = vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xc5ea
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xbdf0
leaq -0x20(%rbp), %rdi
movl $0x7, %esi
leaq 0x91cc(%rip), %rdx      # 0x157a4
callq 0xb190
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc622
movq -0x20(%rbp), %rax
cmpl $0x18, (%rax)
jne 0xc610
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0xc620
movq -0x20(%rbp), %rdi
leaq 0x91b6(%rip), %rsi      # 0x157d1
callq 0xb070
jmp 0xc622
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc660
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_dcl_postfixes
static void parse_dcl_postfixes(const struct Token **ptr_tokvec,
                                struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct Vector vec = *ptr_vec;

	// The parser must handle cases like `int test()[3];` (which tries to define
	// an array of functions) or `int test()()` (which tries to define a
	// function returning a function). While these declarations are semantically
	// forbidden, they are syntactically legal.
	while (1) {
		if (tokvec[0].kind == LEFT_BRACKET) {
			++tokvec;
			expect_and_consume(&tokvec, LIT_DEC_INTEGER,
			                   "an integer while parsing a declaration");
			int length = tokvec[-1].int_value;
			expect_and_consume(&tokvec, RIGHT_BRACKET,
			                   "closing ] while parsing a declaration");

			struct TypeNode a;
			a.type_category = ARRAY;
			a.array_length = length;
			struct TypeNode *ptr = calloc(1, sizeof(struct TypeNode));
			*ptr = a;
			push_vector(&vec, ptr);
			continue;
		} else if (tokvec[0].kind == LEFT_PAREN &&
		           (can_start_a_type(&tokvec[1]) ||
		            tokvec[1].kind == RIGHT_PAREN)) {
			++tokvec;
			parse_parameter_type_list(&tokvec, &vec);
			expect_and_consume(&tokvec, RIGHT_PAREN,
			                   "closing ) while parsing functional type");
			continue;
		} else {
			break;
		}
	}

	*ptr_tokvec = tokvec;
	*ptr_vec = vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x36, (%rax)
jne 0xc72b
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
leaq 0x9137(%rip), %rdx      # 0x157f1
callq 0xb190
movq -0x18(%rbp), %rax
movl -0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x37, %esi
leaq 0x913f(%rip), %rdx      # 0x15818
callq 0xb190
movl $0x2, -0x80(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x70(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x10b0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x62c0
jmp 0xc691
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xc783
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xc270
cmpl $0x0, %eax
jne 0xc750
movq -0x18(%rbp), %rax
cmpl $0x7, 0x20(%rax)
jne 0xc783
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc7b0
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0x90c5(%rip), %rdx      # 0x1583e
callq 0xb190
jmp 0xc691
jmp 0xc785
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_type.c
// Function: parse_direct_abstract_declarator
static void
parse_direct_abstract_declarator(const struct Token **ptr_tokvec,
                                 struct Vector /*<struct TypeNode>*/ *ptr_vec)
{
	const struct Token *tokvec = *ptr_tokvec;

	struct Vector vec = *ptr_vec;
	if (tokvec[0].kind == LEFT_PAREN && !can_start_a_type(&tokvec[1]) &&
	    tokvec[1].kind !=
	        RIGHT_PAREN) { /* an empty parenthesis must be of a function */
		++tokvec;
		parse_abstract_declarator(&tokvec, &vec);
		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "closing parenthesis inside direct declarator");
	}

	parse_dcl_postfixes(&tokvec, &vec);

	*ptr_tokvec = tokvec;
	*ptr_vec = vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0xcb11
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xc270
cmpl $0x0, %eax
jne 0xcb11
movq -0x18(%rbp), %rax
cmpl $0x7, 0x20(%rax)
je 0xcb11
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc490
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0x8c98(%rip), %rdx      # 0x157a4
callq 0xb190
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc660
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/map.c
// Function: insert
void insert(struct Map2 *map, const char *key, void *value)
{
	struct _mapchip a;
	a.ptr = key;
	a.value = value;
	if (map->_alloc < map->_length + 1) {

		map->_vec =
		    realloc(map->_vec, map->_alloc * 2 * sizeof(struct _mapchip));

		map->_alloc *= 2;
	}

	map->_vec[map->_length] = a;
	++(map->_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xcbbc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x1100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/map.c
// Function: lookup
void *lookup(const struct Map2 *m, const char *key)
{
	for (int i = (m->_length) - 1; i >= 0; --i) {
		if (strcmp(m->_vec[i].ptr, key) == 0) {
			return m->_vec[i].value;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xcc70
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0xcc63
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc78
jmp 0xcc65
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcc1c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/map.c
// Function: init_map
struct Map2 *init_map(void)
{
	struct Map2 *res;
	res = calloc(1, sizeof(struct Map2));
	res->_length = 0;
	res->_alloc = 256;
	res->_vec = calloc(res->_alloc, sizeof(struct _mapchip));
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x100, 0x4(%rax)       # imm = 0x100
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
movl $0x10, %esi
callq 0x10b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_prologue
void gen_prologue(int alloc_size, const char *fname)
{
	memo2(__func__, "%d, \"%s\"", alloc_size, fname);
	printf(".global " PREFIX "%s\n" PREFIX "%s:\n"
	       "  pushq %%rbp\n"
	       "  movq %%rsp, %%rbp\n",
	       fname, fname);
	if (alloc_size) {
		printf("  subq $%d, %%rsp\n", alloc_size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x8b84(%rip), %rdi      # 0x158f1
leaq 0x8b8a(%rip), %rsi      # 0x158fe
movb $0x0, %al
callq 0xcdb0
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x8b7d(%rip), %rdi      # 0x15907
movb $0x0, %al
callq 0x1080
cmpl $0x0, -0x4(%rbp)
je 0xcda8
movl -0x4(%rbp), %esi
leaq 0x8b98(%rip), %rdi      # 0x15939
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: memo2
static void memo2(const char *funcname, const char *fmt, ...)
{
	printf("//%s(", funcname);

#ifdef __STDC__
	va_list ap;
#endif
#ifndef __STDC__
	struct va_list_tag ap[1];
#endif

	va_start(ap, fmt);
	vprintf(fmt, ap);
	va_end(ap);

	printf(");\n");

	if (global_ir) {
		fprintf(global_ir, "%s(", funcname);
		va_start(ap, fmt);
		vfprintf(global_ir, fmt, ap);
		va_end(ap);

		fprintf(global_ir, ");\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xcde8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9967(%rip), %rdi      # 0x1677e
movb $0x0, %al
callq 0x1080
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10f0
leaq -0x30(%rbp), %rax
leaq 0x992a(%rip), %rdi      # 0x16784
movb $0x0, %al
callq 0x1080
cmpq $0x0, 0xf25f(%rip)      # 0x1c0c8
je 0xced5
movq 0xf256(%rip), %rdi      # 0x1c0c8
movq -0x8(%rbp), %rdx
leaq 0x9903(%rip), %rsi      # 0x16780
movb $0x0, %al
callq 0x10d0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xf219(%rip), %rdi      # 0x1c0c8
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1120
leaq -0x30(%rbp), %rax
movq 0xf201(%rip), %rdi      # 0x1c0c8
leaq 0x98b6(%rip), %rsi      # 0x16784
movb $0x0, %al
callq 0x10d0
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_prologue_static
void gen_prologue_static(int alloc_size, const char *fname)
{
	memo2(__func__, "%d, \"%s\"", alloc_size, fname);
	printf(PREFIX "%s:\n"
	              "  pushq %%rbp\n"
	              "  movq %%rsp, %%rbp\n",
	       fname);
	if (alloc_size) {
		printf("  subq $%d, %%rsp\n", alloc_size);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x8a4f(%rip), %rdi      # 0x1594c
leaq 0x89fa(%rip), %rsi      # 0x158fe
movb $0x0, %al
callq 0xcdb0
movq -0x10(%rbp), %rsi
leaq 0x89fc(%rip), %rdi      # 0x15912
movb $0x0, %al
callq 0x1080
cmpl $0x0, -0x4(%rbp)
je 0xcf34
movl -0x4(%rbp), %esi
leaq 0x8a0c(%rip), %rdi      # 0x15939
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.c
// Function: gen_epilogue_nbyte
void gen_epilogue_nbyte(int n, int label_name)
{
	memo2(__func__, "%d, %d", n, label_name);
	switch (n) {
	case 1:
	case 4:
		gen_epilogue(label_name);
		break;
	case 8:
		gen_epilogue_8byte(label_name);
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x8a05(%rip), %rdi      # 0x15960
leaq 0x9505(%rip), %rsi      # 0x16467
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0xcf8a
jmp 0xcf76
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0xcf8a
jmp 0xcf80
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0xcf94
jmp 0xcf9e
movl -0x8(%rbp), %edi
callq 0xeb10
jmp 0xcfaa
movl -0x8(%rbp), %edi
callq 0xeb50
jmp 0xcfaa
leaq 0x89ce(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_epilogue_returning_integerclass_struct_or_union
void gen_epilogue_returning_integerclass_struct_or_union(int size, int label)
{
	memo2(__func__, "%d, %d", size, label);
	printf(".L%d:", label);

	puts("  movq (%rsp), %rcx");

	if (size > 8) {
		printf("  movq (%%rcx), %%rax\n"
		       "  addq $8, %%rcx\n");
		copy_to_8byte_reg(size - 8, "edx", "rdx");
	} else {
		copy_to_8byte_reg(size, "eax", "rax");
	}
	printf("  leave\n"
	       "  ret\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x89c9(%rip), %rdi      # 0x15994
leaq 0x9495(%rip), %rsi      # 0x16467
movb $0x0, %al
callq 0xcdb0
movl -0x8(%rbp), %esi
leaq 0x89e5(%rip), %rdi      # 0x159c8
movb $0x0, %al
callq 0x1080
leaq 0x89dd(%rip), %rdi      # 0x159ce
callq 0x1050
cmpl $0x8, -0x4(%rbp)
jle 0xd025
leaq 0x89df(%rip), %rdi      # 0x159e2
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
subl $0x8, %edi
leaq 0x89f3(%rip), %rsi      # 0x15a0a
leaq 0x89f0(%rip), %rdx      # 0x15a0e
callq 0xd050
jmp 0xd03b
movl -0x4(%rbp), %edi
leaq 0x89e3(%rip), %rsi      # 0x15a12
leaq 0x8f52(%rip), %rdx      # 0x15f88
callq 0xd050
leaq 0xa0a0(%rip), %rdi      # 0x170e2
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: copy_to_8byte_reg
static void copy_to_8byte_reg(int size, const char *reg_4byte,
                              const char *reg_8byte)
{
	if (size == 8) {
		printf("  movq (%%rcx), %%%s\n", reg_8byte);
		return;
	}
	if (size >= 4) {
		printf("  movl (%%rcx), %%%s\n", reg_4byte);
		if (size == 4) {
			return;
		}

		if (size == 7) {
			puts("  movzwl 4(%rcx), %edi\n"
			     "  movzbl 6(%rcx), %esi\n"
			     "  shll $16, %esi\n"
			     "  orl %esi,  %edi\n"
			     "  shlq $32, %rdi");
		} else if (size == 6) {
			puts("  movzwl 4(%rcx), %edi\n"
			     "  shlq $32, %rdi");
		} else if (size == 5) {
			puts("  movzbl 4(%rcx), %edi\n"
			     "  shlq $32, %rdi");
		}
		printf("  orq %%rdi, %%%s\n", reg_8byte);
	} else if (size == 3) {
		printf("  movzwl (%%rcx), %%%s\n"
		       "  movzbl 2(%%rcx), %%edi\n"
		       "  shll $16, %%edi\n"
		       "  orl %%edi, %%%s\n",
		       reg_4byte, reg_4byte);
	} else if (size == 2) {
		printf("  movzwl (%%rcx), %%%s\n", reg_4byte);
	} else if (size == 1) {
		printf("  movzbl (%%rcx), %%%s\n", reg_4byte);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x8, -0x4(%rbp)
jne 0xd080
movq -0x18(%rbp), %rsi
leaq 0x9714(%rip), %rdi      # 0x16788
movb $0x0, %al
callq 0x1080
jmp 0xd14b
cmpl $0x4, -0x4(%rbp)
jl 0xd0f5
movq -0x10(%rbp), %rsi
leaq 0x970d(%rip), %rdi      # 0x1679e
movb $0x0, %al
callq 0x1080
cmpl $0x4, -0x4(%rbp)
jne 0xd0a3
jmp 0xd14b
cmpl $0x7, -0x4(%rbp)
jne 0xd0b7
leaq 0x9704(%rip), %rdi      # 0x167b4
callq 0x1050
jmp 0xd0e1
cmpl $0x6, -0x4(%rbp)
jne 0xd0cb
leaq 0x9752(%rip), %rdi      # 0x16816
callq 0x1050
jmp 0xd0df
cmpl $0x5, -0x4(%rbp)
jne 0xd0dd
leaq 0x9766(%rip), %rdi      # 0x1683e
callq 0x1050
jmp 0xd0df
jmp 0xd0e1
movq -0x18(%rbp), %rsi
leaq 0x977a(%rip), %rdi      # 0x16866
movb $0x0, %al
callq 0x1080
jmp 0xd14b
cmpl $0x3, -0x4(%rbp)
jne 0xd113
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x976f(%rip), %rdi      # 0x16879
movb $0x0, %al
callq 0x1080
jmp 0xd149
cmpl $0x2, -0x4(%rbp)
jne 0xd12d
movq -0x10(%rbp), %rsi
leaq 0x97aa(%rip), %rdi      # 0x168ce
movb $0x0, %al
callq 0x1080
jmp 0xd147
cmpl $0x1, -0x4(%rbp)
jne 0xd145
movq -0x10(%rbp), %rsi
leaq 0x97a8(%rip), %rdi      # 0x168e6
movb $0x0, %al
callq 0x1080
jmp 0xd147
jmp 0xd149
jmp 0xd14b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_push_address_of_local
void gen_push_address_of_local(int offset)
{
	memo2(__func__, "%d", offset);
	assert(offset < 0);
	printf("  subq $8, %%rsp\n"
	       "  leaq %d(%%rbp), %%rax\n"
	       "  movq %%rax, (%%rsp)\n",
	       offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x8899(%rip), %rdi      # 0x15a7e
leaq 0x9114(%rip), %rsi      # 0x16300
movb $0x0, %al
callq 0xcdb0
cmpl $0x0, -0x4(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0x1260
movl -0x4(%rbp), %esi
leaq 0x8888(%rip), %rdi      # 0x15a98
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.c
// Function: gen_push_from_local_nbyte
void gen_push_from_local_nbyte(int n, int offset)
{
	memo2(__func__, "%d", n, offset);
	switch (n) {
	case 1:
		gen_push_from_local_1byte(offset);
		break;
	case 4:
		gen_push_from_local_4byte(offset);
		break;
	case 8:
		gen_push_from_local_8byte(offset);
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x88ba(%rip), %rdi      # 0x15b35
leaq 0x907e(%rip), %rsi      # 0x16300
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0xd2aa
jmp 0xd296
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0xd2b4
jmp 0xd2a0
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0xd2be
jmp 0xd2c8
movl -0x8(%rbp), %edi
callq 0xe7e0
jmp 0xd2d4
movl -0x8(%rbp), %edi
callq 0xe670
jmp 0xd2d4
movl -0x8(%rbp), %edi
callq 0xe790
jmp 0xd2d4
leaq 0x86a4(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_push_address_of_global
void gen_push_address_of_global(const char *ident)
{
	memo2(__func__, "\"%s\"", ident);
	printf("  subq $8, %%rsp\n");
#ifdef OSX
	printf("  movq " PREFIX "%s@GOTPCREL(%%rip), %%rax\n", ident);
#endif
#ifndef OSX
	printf("  leaq " PREFIX "%s(%%rip), %%rax\n", ident);
#endif
	printf("  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x8858(%rip), %rdi      # 0x15b4f
leaq 0x8604(%rip), %rsi      # 0x15902
movb $0x0, %al
callq 0xcdb0
leaq 0x885e(%rip), %rdi      # 0x15b6a
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rsi
leaq 0x885e(%rip), %rdi      # 0x15b7c
movb $0x0, %al
callq 0x1080
leaq 0x9e5e(%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.c
// Function: gen_push_ret_of_nbyte
void gen_push_ret_of_nbyte(int n, const char *ident_str, int arg_stacksize)
{
	memo2(__func__, "%d, \"%s\"", n, ident_str);

	switch (n) {
	case 1:
		gen_push_ret_of_1byte(ident_str, arg_stacksize);
		break;
	case 4:
		gen_push_ret_of_4byte(ident_str, arg_stacksize);
		break;
	case 8:
		gen_push_ret_of_8byte(ident_str, arg_stacksize);
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x8835(%rip), %rdi      # 0x15b95
leaq 0x8597(%rip), %rsi      # 0x158fe
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0xd38f
jmp 0xd37b
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0xd39d
jmp 0xd385
movl -0x18(%rbp), %eax
subl $0x8, %eax
je 0xd3ab
jmp 0xd3b9
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe860
jmp 0xd3c5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe920
jmp 0xd3c5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xe970
jmp 0xd3c5
leaq 0x85b3(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_call_reg_and_push_ret_of_nbyte
void gen_call_reg_and_push_ret_of_nbyte(int n, const char *reg)
{
	memo2(__func__, "%d, \"%s\"", n, reg);

	switch (n) {
	case 1:
		gen_call_reg_and_push_ret_of_1byte(reg);
		break;
	case 4:
		gen_call_reg_and_push_ret_of_4byte(reg);
		break;
	case 8:
		gen_call_reg_and_push_ret_of_8byte(reg);
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0x87c4(%rip), %rdi      # 0x15be1
leaq 0x84da(%rip), %rsi      # 0x158fe
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xd44c
jmp 0xd438
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0xd457
jmp 0xd442
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0xd462
jmp 0xd46d
movq -0x10(%rbp), %rdi
callq 0xe9c0
jmp 0xd479
movq -0x10(%rbp), %rdi
callq 0xea20
jmp 0xd479
movq -0x10(%rbp), %rdi
callq 0xea70
jmp 0xd479
leaq 0x84ff(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_peek_deref_push_nbyte
void gen_peek_deref_push_nbyte(int n)
{
	memo2(__func__, "%d", n);
	switch (n) {
	case 1:
		gen_peek_deref_push_1byte();
		break;
	case 4:
		gen_peek_deref_push_4byte();
		break;
	case 8:
		gen_peek_deref_push_8byte();
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x876f(%rip), %rdi      # 0x15c04
leaq 0x8e64(%rip), %rsi      # 0x16300
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0xd4c4
jmp 0xd4b0
movl -0x8(%rbp), %eax
subl $0x4, %eax
je 0xd4cb
jmp 0xd4ba
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0xd4d2
jmp 0xd4d9
callq 0xe770
jmp 0xd4e5
callq 0xe6c0
jmp 0xd4e5
callq 0xe720
jmp 0xd4e5
leaq 0x8493(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: cmp
static const char *cmp(int n)
{
	switch (n) {
	case 1:
		return "cmpb";
	case 4:
		return "cmpl";
	case 8:
		return "cmpq";
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0xd5ec
jmp 0xd5d8
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0xd5f9
jmp 0xd5e2
movl -0x10(%rbp), %eax
subl $0x8, %eax
je 0xd606
jmp 0xd613
leaq 0x930b(%rip), %rax      # 0x168fe
movq %rax, -0x8(%rbp)
jmp 0xd61f
leaq 0x9303(%rip), %rax      # 0x16903
movq %rax, -0x8(%rbp)
jmp 0xd61f
leaq 0x92fb(%rip), %rax      # 0x16908
movq %rax, -0x8(%rbp)
jmp 0xd61f
leaq 0x8359(%rip), %rdi      # 0x15973
callq 0xcd20
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_compare_ptrs
void gen_compare_ptrs(const char *str)
{
	memo2(__func__, "\"%s\"", str);
	puts("  movq 8(%rsp), %rax\n"
	     "  cmpq (%rsp), %rax");
	printf("  %s %%al\n", str);
	puts("  movzbl %al, %eax\n"
	     "  movl %eax, 8(%rsp)\n"
	     "  addq $8, %rsp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x865b(%rip), %rdi      # 0x15f52
leaq 0x8004(%rip), %rsi      # 0x15902
movb $0x0, %al
callq 0xcdb0
leaq 0x8657(%rip), %rdi      # 0x15f63
callq 0x1050
movq -0x8(%rbp), %rsi
leaq 0x8670(%rip), %rdi      # 0x15f8c
movb $0x0, %al
callq 0x1080
leaq 0x866d(%rip), %rdi      # 0x15f97
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x867a(%rip), %rdi      # 0x15fcf
leaq 0x89a4(%rip), %rsi      # 0x16300
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0xd984
jmp 0xd970
movl -0x8(%rbp), %eax
subl $0x4, %eax
je 0xd98b
jmp 0xd97a
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0xd992
jmp 0xd999
callq 0xec10
jmp 0xd9a5
callq 0xebd0
jmp 0xd9a5
callq 0xeb90
jmp 0xd9a5
leaq 0x7fd3(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x8646(%rip), %rdi      # 0x1611b
leaq 0x8824(%rip), %rsi      # 0x16300
movb $0x0, %al
callq 0xcdb0
leaq 0x8642(%rip), %rdi      # 0x1612c
movb $0x0, %al
callq 0x1080
movb $0x1, %al
cmpl $0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0xdb1c
movb $0x1, %al
cmpl $0x2, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0xdb1c
movb $0x1, %al
cmpl $0x4, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0xdb1c
cmpl $0x8, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %cl
leaq 0x8639(%rip), %rdi      # 0x1615f
leaq 0x8616(%rip), %rax      # 0x16143
testb $0x1, %cl
cmovneq %rax, %rdi
movl -0x4(%rbp), %esi
movb $0x0, %al
callq 0x1080
leaq 0x8635(%rip), %rdi      # 0x1617a
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.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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x861c(%rip), %rdi      # 0x16191
leaq 0x8784(%rip), %rsi      # 0x16300
movb $0x0, %al
callq 0xcdb0
cmpl $0x1, -0x4(%rbp)
jne 0xdb8e
jmp 0xdc49
movl -0x4(%rbp), %esi
leaq 0x860a(%rip), %rdi      # 0x161a2
xorl %eax, %eax
movb %al, -0x9(%rbp)
callq 0x1080
movb -0x9(%rbp), %al
leaq 0x8580(%rip), %rdi      # 0x1612c
callq 0x1080
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0xdbd2
jmp 0xdbbe
movl -0x8(%rbp), %eax
subl $0x4, %eax
je 0xdbf0
jmp 0xdbc8
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0xdc0e
jmp 0xdc2c
leaq 0x85e1(%rip), %rdi      # 0x161ba
movb $0x0, %al
callq 0x1080
leaq 0x95a3(%rip), %rdi      # 0x1718a
movb $0x0, %al
callq 0x1080
jmp 0xdc49
leaq 0x85d5(%rip), %rdi      # 0x161cc
movb $0x0, %al
callq 0x1080
leaq 0x9585(%rip), %rdi      # 0x1718a
movb $0x0, %al
callq 0x1080
jmp 0xdc49
leaq 0x85c9(%rip), %rdi      # 0x161de
movb $0x0, %al
callq 0x1080
leaq 0x9567(%rip), %rdi      # 0x1718a
movb $0x0, %al
callq 0x1080
jmp 0xdc49
movl -0x4(%rbp), %esi
leaq 0x85ba(%rip), %rdi      # 0x161f0
movb $0x0, %al
callq 0x1080
leaq 0x85bf(%rip), %rdi      # 0x16203
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x85f5(%rip), %rdi      # 0x1628a
leaq 0x8664(%rip), %rsi      # 0x16300
xorl %eax, %eax
callq 0xcdb0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x1, %eax
je 0xdcc4
jmp 0xdcb0
movl -0x8(%rbp), %eax
subl $0x4, %eax
je 0xdccb
jmp 0xdcba
movl -0x8(%rbp), %eax
subl $0x8, %eax
je 0xdcd2
jmp 0xdcd9
callq 0xe740
jmp 0xdce5
callq 0xe6e0
jmp 0xdce5
callq 0xe700
jmp 0xdce5
leaq 0x7c93(%rip), %rdi      # 0x15973
callq 0xcd20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_write_register_to_local_1byte
void gen_write_register_to_local_1byte(const char *str, int offset)
{
	memo2(__func__, "\"%s\", %d", str, offset);
	assert(offset < 0);
	printf("  movl %%%s, %%eax\n"
	       "  movb %%al, %d(%%rbp)\n",
	       str, offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x8519(%rip), %rdi      # 0x16366
leaq 0x84a6(%rip), %rsi      # 0x162fa
movb $0x0, %al
callq 0xcdb0
cmpl $0x0, -0xc(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %edi
movb $0x0, %al
callq 0x1260
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq 0x850c(%rip), %rdi      # 0x16388
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.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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x84b3(%rip), %rdi      # 0x16427
leaq 0x84e6(%rip), %rsi      # 0x16461
movb $0x0, %al
callq 0xcdb0
movq -0x8(%rbp), %rsi
leaq 0x7408(%rip), %rdi      # 0x15395
callq 0xe8b0
callq 0xea10
movl -0xc(%rbp), %esi
leaq 0x84cd(%rip), %rdi      # 0x1646e
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %edx
leaq 0x885f(%rip), %rdi      # 0x16811
leaq 0x8011(%rip), %rsi      # 0x15fca
callq 0xdfd0
callq 0xd880
callq 0xd880
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x8, %eax
jl 0xe01d
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rcx
movl -0x18(%rbp), %r8d
leaq 0x8902(%rip), %rdi      # 0x1690d
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x18(%rbp)
jmp 0xe089
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x4, %eax
jl 0xe050
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rcx
movl -0x18(%rbp), %r8d
leaq 0x8922(%rip), %rdi      # 0x16960
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0xe087
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl $0x1, %eax
jl 0xe083
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rcx
movl -0x18(%rbp), %r8d
leaq 0x8942(%rip), %rdi      # 0x169b3
movb $0x0, %al
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe085
jmp 0xe08e
jmp 0xe087
jmp 0xe089
jmp 0xdfea
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x8400(%rip), %rdi      # 0x164c4
leaq 0x8396(%rip), %rsi      # 0x16461
movb $0x0, %al
callq 0xcdb0
movq -0x8(%rbp), %rsi
leaq 0x842e(%rip), %rdi      # 0x1650b
callq 0xe8b0
callq 0xea10
movl -0xc(%rbp), %esi
leaq 0x837d(%rip), %rdi      # 0x1646e
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %edx
leaq 0x870f(%rip), %rdi      # 0x16811
leaq 0x7ec1(%rip), %rsi      # 0x15fca
callq 0xdfd0
callq 0xd880
callq 0xd880
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
movl -0x10(%rbp), %r9d
leaq 0x838a(%rip), %rdi      # 0x165c3
leaq 0x83a7(%rip), %rsi      # 0x165e7
movb $0x0, %al
callq 0xcdb0
movl -0xc(%rbp), %esi
leaq 0x83a5(%rip), %rdi      # 0x165f6
movb $0x0, %al
callq 0x1080
leaq 0x83b0(%rip), %rdi      # 0x1660f
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %esi
leaq 0x7a15(%rip), %rdi      # 0x15c85
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xcf40
movl -0x10(%rbp), %esi
leaq 0x6077(%rip), %rdi      # 0x14303
movb $0x0, %al
callq 0x1080
leaq 0x838c(%rip), %rdi      # 0x16626
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.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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0x836d(%rip), %rdi      # 0x1663f
leaq 0x8312(%rip), %rsi      # 0x165eb
movb $0x0, %al
callq 0xcdb0
leaq 0x8370(%rip), %rdi      # 0x16657
callq 0x1050
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jg 0xe327
movl -0x10(%rbp), %edi
callq 0xe390
movq %rax, %rsi
movl -0x4(%rbp), %edx
movl -0x10(%rbp), %eax
shll $0x3, %eax
addl %eax, %edx
leaq 0x80fa(%rip), %rdi      # 0x1640f
movb $0x0, %al
callq 0x1080
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xe2f2
movl -0xc(%rbp), %esi
leaq 0x7997(%rip), %rdi      # 0x15cc8
movb $0x0, %al
callq 0x1080
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xe372
movl -0x14(%rbp), %esi
movl -0x4(%rbp), %edx
addl $0x8, %edx
addl $0x28, %edx
movl -0x14(%rbp), %eax
shll $0x4, %eax
addl %eax, %edx
leaq 0x8308(%rip), %rdi      # 0x16668
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe33f
movl -0xc(%rbp), %esi
leaq 0x5f87(%rip), %rdi      # 0x14303
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/print_x86_64.c
// Function: get_reg_name_from_arg_pos_8byte
const char *get_reg_name_from_arg_pos_8byte(int counter)
{
	switch (counter) {
	case 0:
		return "rdi";
	case 1:
		return "rsi";
	case 2:
		return "rdx";
	case 3:
		return "rcx";
	case 4:
		return "r8";
	case 5:
		return "r9";
	default:
		poison_and_die("tried to pass the 7th argument or later");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xe40a
movq -0x18(%rbp), %rax
leaq 0x74d9(%rip), %rcx      # 0x1588c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x844f(%rip), %rax      # 0x16812
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x83a4(%rip), %rax      # 0x16774
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x7631(%rip), %rax      # 0x15a0e
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x75f4(%rip), %rax      # 0x159de
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x8381(%rip), %rax      # 0x16778
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x8377(%rip), %rax      # 0x1677b
movq %rax, -0x8(%rbp)
jmp 0xe416
leaq 0x833b(%rip), %rdi      # 0x1674c
callq 0xcd20
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0x8243(%rip), %rdi      # 0x16685
leaq 0x81a2(%rip), %rsi      # 0x165eb
movb $0x0, %al
callq 0xcdb0
leaq 0x823b(%rip), %rdi      # 0x16692
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x8241(%rip), %rdi      # 0x166a9
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %esi
leaq 0x8246(%rip), %rdi      # 0x166bf
movb $0x0, %al
callq 0x1080
leaq 0x824f(%rip), %rdi      # 0x166d6
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %esi
leaq 0x826e(%rip), %rdi      # 0x16706
movb $0x0, %al
callq 0x1080
leaq 0x8279(%rip), %rdi      # 0x1671f
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.c
// Function: get_reg_name_from_arg_pos_4byte
const char *get_reg_name_from_arg_pos_4byte(int counter)
{
	switch (counter) {
	case 0:
		return "edi";
	case 1:
		return "esi";
	case 2:
		return "edx";
	case 3:
		return "ecx";
	case 4:
		return "r8d";
	case 5:
		return "r9d";
	default:
		poison_and_die("tried to pass the 7th argument or later");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xe53a
movq -0x18(%rbp), %rax
leaq 0x73c1(%rip), %rcx      # 0x158a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8245(%rip), %rax      # 0x16738
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x823c(%rip), %rax      # 0x1673c
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x74fd(%rip), %rax      # 0x15a0a
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x8226(%rip), %rax      # 0x16740
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x821d(%rip), %rax      # 0x16744
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x8214(%rip), %rax      # 0x16748
movq %rax, -0x8(%rbp)
jmp 0xe546
leaq 0x820b(%rip), %rdi      # 0x1674c
callq 0xcd20
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
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 0x848f(%rip), %rdi      # 0x16a07
movb $0x0, %al
callq 0x1080
leaq 0x849b(%rip), %rdi      # 0x16a21
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x84a1(%rip), %rdi      # 0x16a38
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_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
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 0x8479(%rip), %rdi      # 0x16a51
movb $0x0, %al
callq 0x1080
leaq 0x7b46(%rip), %rdi      # 0x1612c
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x8c70(%rip), %rdi      # 0x17267
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_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
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 0x8439(%rip), %rdi      # 0x16a71
movb $0x0, %al
callq 0x1080
leaq 0x844b(%rip), %rdi      # 0x16a91
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x7d44(%rip), %rdi      # 0x1639b
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_4byte
void gen_push_from_local_4byte(int offset)
{
	assert(offset < 0);
	printf("//gen_push_from_local_4byte(%d)\n", offset);
	printf("  subq $8, %%rsp\n"
	       "  movl %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 0x840f(%rip), %rdi      # 0x16aa7
movb $0x0, %al
callq 0x1080
movl -0x4(%rbp), %esi
leaq 0x841f(%rip), %rdi      # 0x16ac8
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)