LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x10, %esi
callq 0x10d0
movq %rax, %rbx
movl $0x100, 0x4(%rax)       # imm = 0x100
movl $0x100, %edi            # imm = 0x100
movl $0x10, %esi
callq 0x10d0
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x62eb(%rip), %rdi      # 0x10769
leaq 0x62f1(%rip), %rsi      # 0x10776
movl %ebx, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xa4c2
leaq 0x62e7(%rip), %rdi      # 0x1077f
movq %r14, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
testl %ebx, %ebx
je 0xa4bd
leaq 0x6301(%rip), %rdi      # 0x107b1
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xf0(%rbp), %r15
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0xa523
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
leaq 0x70b3(%rip), %rdi      # 0x115dd
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq -0x40(%rbp), %rsi
movq %r15, 0x10(%rsi)
leaq 0x10(%rbp), %r12
movq %r12, 0x8(%rsi)
movabsq $0x3000000010, %r13     # imm = 0x3000000010
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0x1110
leaq 0x7306(%rip), %rdi      # 0x11866
callq 0x1050
movq 0xcb74(%rip), %rdi      # 0x170e0
testq %rdi, %rdi
je 0xa5bd
leaq 0x7067(%rip), %rsi      # 0x115df
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
leaq -0x40(%rbp), %rdx
movq %r13, (%rdx)
movq %r12, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq 0xcb48(%rip), %rdi      # 0x170e0
movq %rbx, %rsi
callq 0x1140
movq 0xcb39(%rip), %rcx      # 0x170e0
leaq 0x7035(%rip), %rdi      # 0x115e3
movl $0x3, %esi
movl $0x1, %edx
callq 0x1180
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x61e2(%rip), %rdi      # 0x107c4
leaq 0x618d(%rip), %rsi      # 0x10776
movl %ebx, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xa4c2
leaq 0x618e(%rip), %rdi      # 0x1078a
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
testl %ebx, %ebx
je 0xa61e
leaq 0x61a0(%rip), %rdi      # 0x107b1
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
leaq 0x61a2(%rip), %rdi      # 0x107d8
leaq 0x6ca2(%rip), %rsi      # 0x112df
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x1, %r14d
je 0xa65b
cmpl $0x8, %r14d
je 0xa666
cmpl $0x4, %r14d
jne 0xa671
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xbdb4
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xbde2
leaq 0x6173(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
leaq 0x617c(%rip), %rdi      # 0x1080c
leaq 0x6c48(%rip), %rsi      # 0x112df
movl %ebx, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0xa4c2
leaq 0x6196(%rip), %rdi      # 0x10840
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x618b(%rip), %rdi      # 0x10846
callq 0x1050
cmpl $0x9, %ebx
jl 0xa6e6
leaq 0x618e(%rip), %rdi      # 0x1085a
xorl %eax, %eax
callq 0x1070
addl $-0x8, %ebx
leaq 0x61a5(%rip), %rsi      # 0x10882
leaq 0x61a2(%rip), %rdx      # 0x10886
jmp 0xa6f4
leaq 0x619d(%rip), %rsi      # 0x1088a
leaq 0x670c(%rip), %rdx      # 0x10e00
movl %ebx, %edi
callq 0xa70b
leaq 0x7167(%rip), %rdi      # 0x11869
popq %rbx
popq %r14
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpl $0x8, %edi
jne 0xa726
leaq 0x6ec6(%rip), %rdi      # 0x115e7
jmp 0xa7b9
movl %edi, %r14d
cmpl $0x4, %edi
jl 0xa75f
leaq 0x6ec8(%rip), %rdi      # 0x115fd
xorl %eax, %eax
callq 0x1070
addl $-0x4, %r14d
cmpl $0x3, %r14d
ja 0xa7b2
leaq 0x5fa7(%rip), %rax      # 0x106f4
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x6f40(%rip), %rdi      # 0x1169d
jmp 0xa7ad
cmpl $0x1, %r14d
je 0xa794
cmpl $0x2, %r14d
je 0xa78b
cmpl $0x3, %r14d
jne 0xa786
leaq 0x6f60(%rip), %rdi      # 0x116d8
movq %rsi, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6f9b(%rip), %rdi      # 0x1172d
jmp 0xa7bc
leaq 0x6faa(%rip), %rdi      # 0x11745
jmp 0xa7bc
leaq 0x6ed1(%rip), %rdi      # 0x11675
jmp 0xa7ad
leaq 0x6e66(%rip), %rdi      # 0x11613
callq 0x1050
leaq 0x6f0c(%rip), %rdi      # 0x116c5
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
leaq 0x6100(%rip), %rdi      # 0x109ad
leaq 0x68c4(%rip), %rsi      # 0x11178
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %r14d
je 0xa8e8
cmpl $0x4, %r14d
je 0xa8dd
cmpl $0x1, %r14d
jne 0xa8f3
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xba26
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xb906
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xb9ee
leaq 0x5ef1(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60b8(%rip), %rdi      # 0x109c7
leaq 0x5e64(%rip), %rsi      # 0x1077a
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa4c2
leaq 0x60bb(%rip), %rdi      # 0x109e2
xorl %eax, %eax
callq 0x1070
leaq 0x60bf(%rip), %rdi      # 0x109f4
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x75cb(%rip), %rdi      # 0x11f11
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leaq 0x60a1(%rip), %rdi      # 0x10a0d
leaq 0x5e03(%rip), %rsi      # 0x10776
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %r15d
je 0xa9ba
cmpl $0x4, %r15d
je 0xa9a6
cmpl $0x1, %r15d
jne 0xa9ce
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xba7d
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbb23
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbb96
leaq 0x5e16(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x6043(%rip), %rdi      # 0x10a59
leaq 0x5d59(%rip), %rsi      # 0x10776
movl %r14d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %r14d
je 0xaa54
cmpl $0x4, %r14d
je 0xaa48
cmpl $0x1, %r14d
jne 0xaa60
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbc09
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbc9e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbd10
leaq 0x5d84(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6001(%rip), %rdi      # 0x10a7c
leaq 0x66f6(%rip), %rsi      # 0x11178
movl %ebx, %edx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %ebx
je 0xaab0
cmpl $0x4, %ebx
je 0xaaa5
cmpl $0x1, %ebx
jne 0xaabb
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb9d1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb93e
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb995
leaq 0x5d29(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5fa1(%rip), %rdi      # 0x10dca
leaq 0x594a(%rip), %rsi      # 0x1077a
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa4c2
leaq 0x5f9a(%rip), %rdi      # 0x10ddb
callq 0x1050
leaq 0x5fb7(%rip), %rdi      # 0x10e04
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x5fb1(%rip), %rdi      # 0x10e0f
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_assign_nbyte
void gen_assign_nbyte(int n)
{
	memo2(__func__, "%d", n);
	switch (n) {
	case 1:
		gen_assign_1byte();
		break;
	case 4:
		gen_assign_4byte();
		break;
	case 8:
		gen_assign_8byte();
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5fcf(%rip), %rdi      # 0x10e47
leaq 0x62f9(%rip), %rsi      # 0x11178
movl %ebx, %edx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %ebx
je 0xaead
cmpl $0x4, %ebx
je 0xaea2
cmpl $0x1, %ebx
jne 0xaeb8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe86
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe4b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbe10
leaq 0x592c(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_mul_by_const
void gen_mul_by_const(int mul)
{
	memo2(__func__, "%d", mul);
	printf("  movq (%%rsp), %%rax\n");
	printf((mul == 1 || mul == 2 || mul == 4 || mul == 8)
	           ? "  leaq 0(,%%rax,%d), %%rdx\n"
	           : "  imulq $%d, %%rax, %%rdx\n",
	       mul);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5fd8(%rip), %rdi      # 0x10f93
leaq 0x61b6(%rip), %rsi      # 0x11178
movl %ebx, %edx
xorl %eax, %eax
callq 0xa4c2
leaq 0x5fd2(%rip), %rdi      # 0x10fa4
xorl %eax, %eax
callq 0x1070
cmpl $0x4, %ebx
ja 0xaff1
movl $0x16, %eax
btl %ebx, %eax
jae 0xaff1
leaq 0x5fcc(%rip), %rdi      # 0x10fbb
jmp 0xb006
cmpl $0x8, %ebx
leaq 0x5fc0(%rip), %rax      # 0x10fbb
leaq 0x5fd5(%rip), %rdi      # 0x10fd7
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5fdc(%rip), %rdi      # 0x10ff2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_div_by_const
void gen_div_by_const(int num)
{
	memo2(__func__, "%d", num);
	if (num == 1) { /* do nothing */
		return;
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5fd7(%rip), %rdi      # 0x11009
leaq 0x613f(%rip), %rsi      # 0x11178
movl %ebx, %edx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x1, %ebx
jne 0xb04e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5fc5(%rip), %rdi      # 0x1101a
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5f3f(%rip), %rdi      # 0x10fa4
xorl %eax, %eax
callq 0x1070
cmpl $0x8, %ebx
je 0xb08d
cmpl $0x4, %ebx
je 0xb084
cmpl $0x2, %ebx
jne 0xb0af
leaq 0x5fb0(%rip), %rdi      # 0x11032
jmp 0xb094
leaq 0x5fb9(%rip), %rdi      # 0x11044
jmp 0xb094
leaq 0x5fc2(%rip), %rdi      # 0x11056
xorl %eax, %eax
callq 0x1070
leaq 0x6e6f(%rip), %rdi      # 0x11f11
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
leaq 0x5fb2(%rip), %rdi      # 0x11068
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5fb5(%rip), %rdi      # 0x1107b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_peek_and_dereference_nbyte
void gen_peek_and_dereference_nbyte(int n)
{
	memo2(__func__, "%d", n);
	switch (n) {
	case 1:
		gen_peek_and_dereference_1byte();
		break;
	case 4:
		gen_peek_and_dereference_4byte();
		break;
	case 8:
		gen_peek_and_dereference_8byte();
		break;
	default:
		poison_and_die("Unsupported width; cannot happen");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5ffc(%rip), %rdi      # 0x11102
leaq 0x606b(%rip), %rsi      # 0x11178
movl %ebx, %edx
xorl %eax, %eax
callq 0xa4c2
cmpl $0x8, %ebx
je 0xb13b
cmpl $0x4, %ebx
je 0xb130
cmpl $0x1, %ebx
jne 0xb146
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb9b2
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb95b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb978
leaq 0x569e(%rip), %rdi      # 0x107eb
callq 0xa44c
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_call_and_assign_integerclass_struct_or_union_to_local
void gen_call_and_assign_integerclass_struct_or_union_to_local(
    const char *fname, int offset, int size)
{
	memo2(__func__, "\"%s\", %d, %d", fname, offset, size);

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

	gen_discard();
	gen_discard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leaq 0x5f4e(%rip), %rdi      # 0x1129f
leaq 0x5f81(%rip), %rsi      # 0x112d9
movq %r12, %rdx
movl %r15d, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0xa4c2
leaq 0x4e64(%rip), %rbx      # 0x101d3
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbaf0
callq 0xbc7b
leaq 0x5f60(%rip), %rdi      # 0x112e6
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x62d9(%rip), %rdi      # 0x11670
leaq 0x5aa4(%rip), %rsi      # 0x10e42
movl %r14d, %edx
callq 0xb3ea
leaq 0x5a02(%rip), %r14      # 0x10daf
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa4c2
leaq 0x59dc(%rip), %r15      # 0x10d9d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa4c2
movq %r15, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_memcpy
static void gen_memcpy(const char *dst, const char *src, int size)
{
	int next_copy_begins_at = 0;
	while (1) {
		if (size - next_copy_begins_at >= 8) {
			printf("  movq %s, %%rdx\n"
			       "  movq %d(%%rdx), %%rax\n"
			       "  movq %s, %%rdx\n"
			       "  movq %%rax, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 8;
		} else if (size - next_copy_begins_at >= 4) {
			printf("  movq %s, %%rdx\n"
			       "  movl %d(%%rdx), %%eax\n"
			       "  movq %s, %%rdx\n"
			       "  movl %%eax, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 4;
		} else if (size - next_copy_begins_at >= 1) {
			printf("  movq %s, %%rdx\n"
			       "  movzbl %d(%%rdx), %%eax\n"
			       "  movq %s, %%rdx\n"
			       "  movb %%al, %d(%%rdx)\n",
			       src, next_copy_begins_at, dst, next_copy_begins_at);
			next_copy_begins_at += 1;
		} else {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl %ebx, %eax
subl %r12d, %eax
movl $0x8, %r13d
leaq 0x6357(%rip), %rdi      # 0x1176c
cmpl $0x7, %eax
jg 0xb43d
movl $0x4, %r13d
leaq 0x6398(%rip), %rdi      # 0x117bf
cmpl $0x3, %eax
jg 0xb43d
movl $0x1, %r13d
leaq 0x63d9(%rip), %rdi      # 0x11812
testl %eax, %eax
jle 0xb455
movq %r14, %rsi
movl %r12d, %edx
movq %r15, %rcx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x1070
addl %r13d, %r12d
jmp 0xb403
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_call_reg_and_assign_integerclass_struct_or_union_or_union_to_local
void gen_call_reg_and_assign_integerclass_struct_or_union_or_union_to_local(
    const char *regname, int offset, int size)
{
	memo2(__func__, "\"%s\", %d, %d", regname, offset, size);

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

	gen_discard();
	gen_discard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x5ebf(%rip), %rdi      # 0x1133c
leaq 0x5e55(%rip), %rsi      # 0x112d9
movq %r15, %rdx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa4c2
leaq 0x5ee8(%rip), %rdi      # 0x11383
movq %r15, %rsi
callq 0xbaf0
callq 0xbc7b
leaq 0x5e37(%rip), %rdi      # 0x112e6
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x61b0(%rip), %rdi      # 0x11670
leaq 0x597b(%rip), %rsi      # 0x10e42
movl %ebx, %edx
callq 0xb3ea
leaq 0x58da(%rip), %rbx      # 0x10daf
leaq 0x4cf7(%rip), %r14      # 0x101d3
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa4c2
leaq 0x58ad(%rip), %r15      # 0x10d9d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xa4c2
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_epilogue_nbyte_with_stack_check
void gen_epilogue_nbyte_with_stack_check(int n, int return_label_name,
                                         int checksum_offset,
                                         int failing_label_name)
{
	memo2(__func__, "%d, %d, %d, %d", n, return_label_name, checksum_offset,
	      failing_label_name);
#ifdef OSX
	gen_push_address_of_global("__stack_chk_guard");
	gen_peek_and_dereference_nbyte(8);
	gen_pop_to_reg_8byte("rax");
	printf("  cmpq %d(%%rbp), %%rax\n", checksum_offset);
#endif

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %r14d
movl %edi, %r15d
leaq 0x5e30(%rip), %rdi      # 0x1143b
leaq 0x5e4d(%rip), %rsi      # 0x1145f
movl %r15d, %edx
movl %r14d, %ecx
movl %r12d, %r8d
movl %ebx, %r9d
xorl %eax, %eax
callq 0xa4c2
leaq 0x5e42(%rip), %rdi      # 0x1146e
movl %r12d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5e4a(%rip), %rdi      # 0x11487
xorl %eax, %eax
callq 0x1070
leaq 0x54b2(%rip), %rdi      # 0x10afd
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
movl %r15d, %edi
movl %r14d, %esi
callq 0xa623
leaq 0x3bbd(%rip), %rdi      # 0xf223
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6201(%rip), %rdi      # 0x11877
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_store_regs_to_local
void gen_store_regs_to_local(int offset, int start_from, int label_name)
{
	memo2(__func__, "%d, %d, %d", offset, start_from, label_name);
	puts("  testb %al, %al");
	for (int i = start_from; i <= 5; i++) {
		printf("  movq %%%s, %d(%%rbp)\n", get_reg_name_from_arg_pos_8byte(i),
		       offset + i * 8);
	}
	printf("  je .L%d\n", label_name);
	for (int i = 0; i < 8; i++) {
		printf("  movaps %%xmm%d, %d(%%rbp)\n", i, 8 + offset + 40 + 16 * i);
	}
	printf(".L%d:\n", label_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movl %edi, %r14d
leaq 0x5dfe(%rip), %rdi      # 0x1149e
leaq 0x5dbc(%rip), %rsi      # 0x11463
movl %r14d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa4c2
leaq 0x5df8(%rip), %rdi      # 0x114b6
callq 0x1050
cmpl $0x5, %r15d
jg 0xb6f9
leal (%r14,%r15,8), %r12d
leaq 0x5bb3(%rip), %r13      # 0x11287
movl %r15d, %edi
callq 0xb752
movq %r13, %rdi
movq %rax, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1070
incl %r15d
addl $0x8, %r12d
cmpl $0x6, %r15d
jne 0xb6d4
leaq 0x5440(%rip), %rdi      # 0x10b40
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
addl $0x30, %r14d
leaq 0x5db3(%rip), %r15      # 0x114c7
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
xorl %eax, %eax
callq 0x1070
incl %r12d
addl $0x10, %r14d
cmpl $0x8, %r12d
jne 0xb717
leaq 0x3ae8(%rip), %rdi      # 0xf223
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64.c
// Function: gen_va_start
void gen_va_start(int gp_offset, int fp_offset, int reg_save_area_offset)
{
	memo2(__func__, "%d, %d, %d", gp_offset, fp_offset, reg_save_area_offset);
	printf("  movq (%%rsp), %%rdx\n");
	printf("  movl $%d,  (%%rdx)\n", gp_offset);
	printf("  movl $%d,  4(%%rdx)\n", fp_offset);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
leaq 0x5d53(%rip), %rdi      # 0x114e4
leaq 0x5ccb(%rip), %rsi      # 0x11463
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0xa4c2
leaq 0x5d42(%rip), %rdi      # 0x114f1
xorl %eax, %eax
callq 0x1070
leaq 0x5d4b(%rip), %rdi      # 0x11508
movl %r15d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5d50(%rip), %rdi      # 0x1151e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5d56(%rip), %rdi      # 0x11535
xorl %eax, %eax
callq 0x1070
leaq 0x5d78(%rip), %rdi      # 0x11565
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5d81(%rip), %rdi      # 0x1157e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local
void gen_write_to_local(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local(%d)\n", offset);
	printf("  movl (%%rsp), %%eax\n");
	printf("  movl %%eax, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x243c
leaq 0x6042(%rip), %rdi      # 0x1188f
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x604c(%rip), %rdi      # 0x118a9
xorl %eax, %eax
callq 0x1070
leaq 0x6055(%rip), %rdi      # 0x118c0
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local_8byte
void gen_write_to_local_8byte(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local_8byte(%d)\n", offset);
	printf("  movq (%%rsp), %%rax\n");
	printf("  movq %%rax, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x243c
leaq 0x6046(%rip), %rdi      # 0x118d9
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x5701(%rip), %rdi      # 0x10fa4
xorl %eax, %eax
callq 0x1070
leaq 0x6711(%rip), %rdi      # 0x11fc2
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_write_to_local_1byte
void gen_write_to_local_1byte(int offset)
{
	assert(offset < 0);
	printf("//gen_write_to_local_1byte(%d)\n", offset);
	printf("  movb (%%rsp), %%al\n");
	printf("  movb %%al, %d(%%rbp)\n", offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
shrl $0x1f, %edi
xorl %eax, %eax
callq 0x243c
leaq 0x6020(%rip), %rdi      # 0x118f9
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6030(%rip), %rdi      # 0x11919
xorl %eax, %eax
callq 0x1070
leaq 0x591c(%rip), %rdi      # 0x11213
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_1byte
void gen_push_ret_of_1byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_1byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x61c5(%rip), %rdi      # 0x11c55
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x6323(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x6326(%rip), %rdi      # 0x11dd5
leaq 0x471d(%rip), %rsi      # 0x101d3
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6514(%rip), %rdi      # 0x11fdb
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6517(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x618f(%rip), %rdi      # 0x11c74
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_4byte
void gen_push_ret_of_4byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_4byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);
	printf("  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x616a(%rip), %rdi      # 0x11ca0
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x627d(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x6280(%rip), %rdi      # 0x11dd5
leaq 0x4677(%rip), %rsi      # 0x101d3
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x646e(%rip), %rdi      # 0x11fdb
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6471(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x63c4(%rip), %rdi      # 0x11f4f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_push_ret_of_8byte
void gen_push_ret_of_8byte(const char *fname, int arg_stacksize)
{
	printf("//gen_push_ret_of_8byte(\"%s\")\n", fname);
	gen_raw_call_partB(PREFIX, fname);
	gen_raw_call_partC_with_stacksize(arg_stacksize);
	printf("  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x6116(%rip), %rdi      # 0x11cbf
movq %r14, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x620a(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x620d(%rip), %rdi      # 0x11dd5
leaq 0x4604(%rip), %rsi      # 0x101d3
movq %r14, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x63fb(%rip), %rdi      # 0x11fdb
movl %ebx, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x63fe(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x6313(%rip), %rdi      # 0x11f11
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_1byte
void gen_call_reg_and_push_ret_of_1byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_1byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movsbl %%al, %%eax\n"
	       "  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60c5(%rip), %rdi      # 0x11cde
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x619a(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x619d(%rip), %rdi      # 0x11dd5
leaq 0x5744(%rip), %rsi      # 0x11383
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x638b(%rip), %rdi      # 0x11fdb
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x638e(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x6006(%rip), %rdi      # 0x11c74
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_4byte
void gen_call_reg_and_push_ret_of_4byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_4byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movl %%eax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x605c(%rip), %rdi      # 0x11d0a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x6105(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x6108(%rip), %rdi      # 0x11dd5
leaq 0x56af(%rip), %rsi      # 0x11383
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x62f6(%rip), %rdi      # 0x11fdb
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x62f9(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x624c(%rip), %rdi      # 0x11f4f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_call_reg_and_push_ret_of_8byte
void gen_call_reg_and_push_ret_of_8byte(const char *reg)
{
	printf("//gen_call_reg_and_push_ret_of_8byte(\"%s\")\n", reg);
	gen_raw_call_partB("*%", reg);
	gen_raw_call_partC();
	printf("  movq %%rax, (%%rsp)\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6016(%rip), %rdi      # 0x11d36
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
leaq 0x6093(%rip), %rdi      # 0x11dc4
xorl %eax, %eax
callq 0x1070
leaq 0x6096(%rip), %rdi      # 0x11dd5
leaq 0x563d(%rip), %rsi      # 0x11383
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1070
leaq 0x6284(%rip), %rdi      # 0x11fdb
xorl %esi, %esi
xorl %eax, %eax
callq 0x1070
leaq 0x6287(%rip), %rdi      # 0x11fee
xorl %eax, %eax
callq 0x1070
leaq 0x619c(%rip), %rdi      # 0x11f11
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x62cd(%rip), %rdi      # 0x120e8
callq 0x1050
leaq 0x517d(%rip), %rdi      # 0x10fa4
xorl %eax, %eax
callq 0x1070
leaq 0x609d(%rip), %rdi      # 0x11ed2
xorl %eax, %eax
callq 0x1070
leaq 0x60a7(%rip), %rdi      # 0x11eea
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x62a7(%rip), %rdi      # 0x120fd
callq 0x1050
leaq 0x5a47(%rip), %rdi      # 0x118a9
xorl %eax, %eax
callq 0x1070
leaq 0x6062(%rip), %rdi      # 0x11ed2
xorl %eax, %eax
callq 0x1070
leaq 0x60aa(%rip), %rdi      # 0x11f28
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x6281(%rip), %rdi      # 0x12112
callq 0x1050
leaq 0x5a7c(%rip), %rdi      # 0x11919
xorl %eax, %eax
callq 0x1070
leaq 0x6027(%rip), %rdi      # 0x11ed2
xorl %eax, %eax
callq 0x1070
leaq 0x60ad(%rip), %rdi      # 0x11f66
xorl %eax, %eax
callq 0x1070
leaq 0x4ed6(%rip), %rdi      # 0x10d9d
xorl %eax, %eax
callq 0x1070
leaq 0x60a7(%rip), %rdi      # 0x11f7c
xorl %eax, %eax
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/print_x86_64_unofficial.c
// Function: gen_initialize_va_list
void gen_initialize_va_list(int dst_struct_offset, int gp_offset, int fp_offset,
                            int reg_save_area_offset)
{
	printf("  movl $%d,  %d(%%rbp)\n", gp_offset, dst_struct_offset);
	printf("  movl $%d,  %d(%%rbp)\n", fp_offset, dst_struct_offset + 4);

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

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

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

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

		push_vector(p, ptr_token);

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

	const struct Tokvec vec2 = remove_spaces_and_newlines(&vec1);

	return concat_str_literals(&vec2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
callq 0xa40d
movq %rax, %r15
cmpl $0x0, (%r14)
jle 0xbfc6
xorl %r13d, %r13d
movabsq $0x100000004, %rbx      # imm = 0x100000004
callq 0x5d33
movq %rax, %r12
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rbx, (%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x5d9b
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xa344
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0xbf83
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xd2ec
movq %rdx, %r14
movslq %eax, %rdi
movl $0x20, %esi
callq 0x10d0
movq %rax, %r15
xorl %eax, %eax
movl (%r14), %ecx
andl $-0x2, %ecx
cmpl $0x4c, %ecx
je 0xc018
cltq
movq %rax, %rcx
shlq $0x5, %rcx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%r15,%rcx)
movups %xmm1, 0x10(%r15,%rcx)
incl %eax
cmpl $0x2, (%r15,%rcx)
je 0xc01e
addq $0x20, %r14
jmp 0xbfe7
movslq %eax, %rdi
movl $0x20, %esi
callq 0x10d0
movq %r15, %rcx
addq $0x20, %rcx
movq %rcx, -0x40(%rbp)
xorl %edx, %edx
xorl %r14d, %r14d
movq %r15, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq %rdx, %rsi
shlq $0x5, %rsi
movslq %r14d, %rbx
movq %rbx, %rcx
shlq $0x5, %rcx
movups (%r15,%rcx), %xmm0
movups 0x10(%r15,%rcx), %xmm1
movups %xmm0, (%rax,%rsi)
movups %xmm1, 0x10(%rax,%rsi)
movl (%rax,%rsi), %ecx
cmpl $0x39, %ecx
jne 0xc104
incq %rbx
shlq $0x5, %rbx
cmpl $0x39, (%r15,%rbx)
jne 0xc109
movl %ecx, -0x34(%rbp)
movq %rdx, -0x30(%rbp)
addq %rax, %rsi
movq %rsi, -0x58(%rbp)
movq 0x10(%rsi), %r12
addq -0x40(%rbp), %rbx
movq %r12, %r15
movq %r12, %rdi
callq 0x1060
movq %rax, %r12
movq -0x10(%rbx), %r13
movq %r13, %rdi
callq 0x1060
addl %r12d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x10d0
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
movq %r12, %rdi
movq %r13, %rsi
callq 0x1150
incl %r14d
cmpl $0x39, (%rbx)
leaq 0x20(%rbx), %rbx
je 0xc09c
movq -0x58(%rbp), %rax
movq %r12, 0x10(%rax)
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
cmpl $0x2, %ecx
je 0xc114
incl %r14d
incq %rdx
jmp 0xc043
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/lexer.c
// Function: unescape
char *unescape(const char *str)
{
	char *ans = calloc(strlen(str) + 1, sizeof(char));
	int j = 0;
	for (int i = 0; str[i];) {
		if (str[i] != 92) {
			ans[j] = str[i];
			i++;
			j++;
		} else {
			switch (str[i + 1]) {
			case 92:
				ans[j] = 92;
				break;
			case 't':
				ans[j] = 9;
				break;
			case 'n':
				ans[j] = 10;
				break;
			case 'v':
				ans[j] = 11;
				break;
			case 'f':
				ans[j] = 12;
				break;
			case 'r':
				ans[j] = 13;
				break;
			case '"':
				ans[j] = '"';
				break;
			case 'e': {
				if (global_flag_pedantic) {
					fprintf(stderr, "escape sequence `\\e` is not in ISO C\n");
					exit(EXIT_FAILURE);
				} else {
					ans[j] = 0x1b;
					break;
				}
			}
			case 39:
				ans[j] = 39;
				break;
			default:
				fprintf(stderr, "unsupported: escape sequence `\\%c`\n",
				        str[i + 1]);
				exit(EXIT_FAILURE);
			}
			i += 2;
			j++;
		}
	}
	/* calloc means automatically null terminated */
	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
leaq 0x1(%rax), %rdi
movl $0x1, %esi
callq 0x10d0
leaq 0xaf96(%rip), %rcx      # 0x170dc
movl (%rcx), %ecx
xorl %edx, %edx
leaq 0x5fd7(%rip), %rsi      # 0x12128
movq %rax, %r8
movl %edx, %edx
movzbl (%rbx,%rdx), %r10d
cmpl $0x5c, %r10d
je 0xc177
testl %r10d, %r10d
je 0xc1df
movl $0x1, %r9d
movb %r10b, (%r8)
addl %r9d, %edx
incq %r8
jmp 0xc154
movb 0x1(%rbx,%rdx), %r10b
movzbl %r10b, %edi
movl $0x2, %r9d
cmpl $0x64, %edi
jg 0xc19c
cmpl $0x22, %edi
je 0xc16c
cmpl $0x27, %edi
je 0xc16c
cmpl $0x5c, %edi
je 0xc16c
jmp 0xc1e6
leal -0x6e(%rdi), %r10d
cmpl $0x8, %r10d
ja 0xc1b5
movslq (%rsi,%r10,4), %r10
addq %rsi, %r10
jmpq *%r10
movb $0xa, %r10b
jmp 0xc16c
cmpl $0x65, %edi
je 0xc1d3
cmpl $0x66, %edi
jne 0xc1e6
movb $0xc, %r10b
jmp 0xc16c
movb $0xb, %r10b
jmp 0xc16c
movb $0xd, %r10b
jmp 0xc16c
movb $0x9, %r10b
jmp 0xc16c
movb $0x1b, %r10b
testl %ecx, %ecx
je 0xc16c
callq 0x2174
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x219c
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/lexer.c
// Function: escape
char *escape(const char *str)
{
	char *ans =
	    calloc(strlen(str) * 4 /* length of "\\013" */ + 1, sizeof(char));
	int j = 0;
	for (int i = 0; str[i]; i++) {
		switch (str[i]) {
		case 92:
			ans[j] = 92;
			ans[j + 1] = 92;
			j += 2;
			break;
		case 9:
			ans[j] = 92;
			ans[j + 1] = 't';
			j += 2;
			break;
		case 10:
			ans[j] = 92;
			ans[j + 1] = 'n';
			j += 2;
			break;
		case 11: /* somehow \v fails */
			ans[j] = 92;
			ans[j + 1] = '0';
			ans[j + 2] = '1';
			ans[j + 3] = '3';
			j += 4;
			break;
		case 12:
			ans[j] = 92;
			ans[j + 1] = 'f';
			j += 2;
			break;
		case 13:
			ans[j] = 92;
			ans[j + 1] = 'r';
			j += 2;
			break;
		case '"':
			ans[j] = 92;
			ans[j + 1] = '"';
			j += 2;
			break;
		case 0x1b:
			ans[j] = 92;
			ans[j + 1] = '0';
			ans[j + 2] = '3';
			ans[j + 3] = '3';
			j += 4;
			break;
		/* single quote need not be re-escaped */
		default:
			ans[j] = str[i];
			j++;
			break;
		}
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1060
leaq 0x1(,%rax,4), %rdi
movl $0x1, %esi
callq 0x10d0
xorl %ecx, %ecx
leaq 0x5f38(%rip), %rdx      # 0x1214c
movb (%rbx), %sil
movzbl %sil, %edi
cmpl $0x1a, %edi
jg 0xc23a
cmpl $0xd, %edi
ja 0xc2a3
movl %edi, %edi
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
movl %ecx, %esi
movw $0x745c, (%rax,%rsi)    # imm = 0x745C
jmp 0xc294
cmpl $0x1b, %edi
je 0xc27c
cmpl $0x22, %edi
je 0xc28c
cmpl $0x5c, %edi
jne 0xc2a3
movl %ecx, %esi
movw $0x5c5c, (%rax,%rsi)    # imm = 0x5C5C
jmp 0xc294
movl %ecx, %esi
movw $0x665c, (%rax,%rsi)    # imm = 0x665C
jmp 0xc294
movl %ecx, %esi
movw $0x725c, (%rax,%rsi)    # imm = 0x725C
jmp 0xc294
movl %ecx, %esi
movl $0x3331305c, (%rax,%rsi) # imm = 0x3331305C
jmp 0xc285
movl %ecx, %esi
movw $0x6e5c, (%rax,%rsi)    # imm = 0x6E5C
jmp 0xc294
movl %ecx, %esi
movl $0x3333305c, (%rax,%rsi) # imm = 0x3333305C
movl $0x4, %esi
jmp 0xc299
movl %ecx, %esi
movw $0x225c, (%rax,%rsi)    # imm = 0x225C
movl $0x2, %esi
addl %esi, %ecx
incq %rbx
jmp 0xc214
movl %ecx, %edi
movb %sil, (%rax,%rdi)
movl $0x1, %esi
jmp 0xc299
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hsjoihs[P]c-compiler/lexer.c
// Function: print_token
void print_token(const struct Token *ptr_tok, const char *next_token_begins)
{
	if (ptr_tok->kind == END) {
		fprintf(stderr, "DUMMY: END");
		return;
	}
	if (ptr_tok->kind == BEGINNING) {
		fprintf(stderr, "DUMMY: BEGINNING");
		return;
	}
	for (int i = 0; i < next_token_begins - ptr_tok->token_begins_here; i++) {
		char c = ptr_tok->token_begins_here[i];
		if (c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' ||
		    c == '\r') {
			break;
		}
		fprintf(stderr, "%c", c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl $0x2, %eax
je 0xc332
cmpl $0x3, %eax
je 0xc32b
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq %rsi, %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0xc337
xorl %r15d, %r15d
movq 0xad08(%rip), %r12      # 0x16ff8
movabsq $0x100003e00, %r13      # imm = 0x100003E00
movzbl (%rax,%r15), %eax
cmpq $0x20, %rax
ja 0xc30b
btq %rax, %r13
jb 0xc337
movsbl %al, %edi
movq (%r12), %rsi
callq 0x1090
incq %r15
movq 0x18(%r14), %rax
movq %rbx, %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jg 0xc2fa
jmp 0xc337
callq 0x21c4
jmp 0xc337
callq 0x21f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq