LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-arm.c
// Function: init_arm
static void init_arm(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	if (arch_os == OS_NONE) {
		int32_ctype = &long_ctype;
		uint32_ctype = &ulong_ctype;
		fast8_ctype = &int_ctype;
		ufast8_ctype = &uint_ctype;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x483c1(%rip), %rax     # 0x8a690
leaq 0x4f842(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x483b8(%rip), %rax     # 0x8a698
leaq 0x4f9f1(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x483af(%rip), %rax     # 0x8a6a0
leaq 0x4f820(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x483a6(%rip), %rax     # 0x8a6a8
leaq 0x4f9cf(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x424d1(%rip), %rax     # 0x847e4
cmpl $0x1, (%rax)
jne 0x4235c
leaq 0x48301(%rip), %rax     # 0x8a620
leaq 0x4fa92(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
leaq 0x482f8(%rip), %rax     # 0x8a628
leaq 0x4fc41(%rip), %rcx     # 0x91f78
movq %rcx, (%rax)
leaq 0x4833f(%rip), %rax     # 0x8a680
leaq 0x4f7d0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x48336(%rip), %rax     # 0x8a688
leaq 0x4f97f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-arm.c
// Function: predefine_arm
static void predefine_arm(const struct target *self)
{
	predefine("__arm__", 1, "1");
	predefine("__VFP_FP__", 1, "1");

	switch (arch_fp_abi) {
	case FP_ABI_HARD:
		predefine("__ARM_PCS_VFP", 1, "1");
		break;
	case FP_ABI_SOFT:
		predefine("__SOFTFP__", 1, "1");
		/* fall-through */
	case FP_ABI_HYBRID:
		predefine("__ARM_PCS", 1, "1");
		break;
	}

	if (arch_big_endian)
		predefine("__ARMEB__", 0, "1");
	else
		predefine("__ARMEL__", 0, "1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x27488(%rip), %rdi     # 0x697fb
leaq 0x2abfd(%rip), %rdx     # 0x6cf77
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movb %al, -0xd(%rbp)
movl $0x1, %esi
movl %esi, -0x1c(%rbp)
callq 0x2b3a0
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
movb -0xd(%rbp), %al
leaq 0x27462(%rip), %rdi     # 0x69803
callq 0x2b3a0
leaq 0x4242f(%rip), %rax     # 0x847dc
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x423cc
jmp 0x423b8
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x423e8
jmp 0x423c2
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x42402
jmp 0x4241c
leaq 0x2743b(%rip), %rdi     # 0x6980e
movl $0x1, %esi
leaq 0x2ab98(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x4241c
leaq 0x2742d(%rip), %rdi     # 0x6981c
movl $0x1, %esi
leaq 0x2ab7c(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x2741e(%rip), %rdi     # 0x69827
movl $0x1, %esi
leaq 0x2ab62(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4ad55(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x42441
leaq 0x27402(%rip), %rdi     # 0x69831
xorl %esi, %esi
leaq 0x2ab3f(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x42458
leaq 0x273f3(%rip), %rdi     # 0x6983b
xorl %esi, %esi
leaq 0x2ab26(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-arm64.c
// Function: predefine_arm64
static void predefine_arm64(const struct target *self)
{
	static const char *cmodels[CMODEL_LAST] = {
		[CMODEL_LARGE] = "LARGE",
		[CMODEL_SMALL] = "SMALL",
		[CMODEL_TINY]  = "TINY",
	};
	const char *cmodel = cmodels[arch_cmodel];

	predefine("__aarch64__", 1, "1");

	if (arch_big_endian)
		predefine("__AARCH64EB__", 0, "1");
	else
		predefine("__AARCH64EL__", 0, "1");

	if (cmodel)
		predefine_strong("__AARCH64_CMODEL_%s__", cmodel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4aca9(%rip), %rax     # 0x8d17c
movslq (%rax), %rcx
leaq 0x48313(%rip), %rax     # 0x8a7f0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
leaq 0x2736a(%rip), %rdi     # 0x69856
movl $0x1, %esi
leaq 0x2aa7f(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4ac72(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x42524
leaq 0x27350(%rip), %rdi     # 0x69862
xorl %esi, %esi
leaq 0x2aa5c(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x4253b
leaq 0x27345(%rip), %rdi     # 0x69870
xorl %esi, %esi
leaq 0x2aa43(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
cmpq $0x0, -0x10(%rbp)
je 0x42554
movq -0x10(%rbp), %rsi
leaq 0x27331(%rip), %rdi     # 0x6987e
movb $0x0, %al
callq 0x2b7e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-h8300.c
// Function: init_h8300
static void init_h8300(const struct target *self)
{
	intptr_ctype = &int_ctype;
	uintptr_ctype = &uint_ctype;
	ssize_t_ctype = &long_ctype;
	size_t_ctype = &ulong_ctype;
	wchar_ctype = &ushort_ctype;

	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x51d19(%rip), %rax     # 0x94368
leaq 0x4f4c2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x51d10(%rip), %rax     # 0x94370
leaq 0x4f671(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47f87(%rip), %rax     # 0x8a5f8
leaq 0x4f740(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
leaq 0x47f6e(%rip), %rax     # 0x8a5f0
leaq 0x4f8ef(%rip), %rcx     # 0x91f78
movq %rcx, (%rax)
leaq 0x47f9d(%rip), %rax     # 0x8a630
leaq 0x4f39e(%rip), %rcx     # 0x91a38
movq %rcx, (%rax)
leaq 0x47fec(%rip), %rax     # 0x8a690
leaq 0x4f46d(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47fe3(%rip), %rax     # 0x8a698
leaq 0x4f61c(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47fda(%rip), %rax     # 0x8a6a0
leaq 0x4f44b(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47fd1(%rip), %rax     # 0x8a6a8
leaq 0x4f5fa(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-m68k.c
// Function: init_m68k
static void init_m68k(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47f31(%rip), %rax     # 0x8a690
leaq 0x4f3b2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47f28(%rip), %rax     # 0x8a698
leaq 0x4f561(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47f1f(%rip), %rax     # 0x8a6a0
leaq 0x4f390(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47f16(%rip), %rax     # 0x8a6a8
leaq 0x4f53f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-microblaze.c
// Function: init_microblaze
static void init_microblaze(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47e81(%rip), %rax     # 0x8a690
leaq 0x4f302(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47e78(%rip), %rax     # 0x8a698
leaq 0x4f4b1(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47e6f(%rip), %rax     # 0x8a6a0
leaq 0x4f2e0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47e66(%rip), %rax     # 0x8a6a8
leaq 0x4f48f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-microblaze.c
// Function: predefine_microblaze
static void predefine_microblaze(const struct target *self)
{
	predefine("__MICROBLAZE__", 1, "1");
	predefine("__microblaze__", 1, "1");

	if (arch_big_endian)
		predefine("__MICROBLAZEEB__", 1, "1");
	else
		predefine("__MICROBLAZEEL__", 1, "1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x27111(%rip), %rdi     # 0x69974
movl $0x1, %esi
leaq 0x2a708(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x27106(%rip), %rdi     # 0x69983
movl $0x1, %esi
leaq 0x2a6ee(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4a8e1(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x428b8
leaq 0x270ef(%rip), %rdi     # 0x69992
movl $0x1, %esi
leaq 0x2a6c8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x428d2
leaq 0x270e4(%rip), %rdi     # 0x699a3
movl $0x1, %esi
leaq 0x2a6ac(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-mips.c
// Function: predefine_mips
static void predefine_mips(const struct target *self)
{
	predefine("__mips__", 1, "1");
	predefine("__mips", 1, "%d", ptr_ctype.bit_size);
	predefine("_MIPS_SZINT", 1, "%d", int_ctype.bit_size);
	predefine("_MIPS_SZLONG", 1, "%d", long_ctype.bit_size);
	predefine("_MIPS_SZPTR", 1, "%d", ptr_ctype.bit_size);

	if (arch_big_endian) {
		predefine("_MIPSEB", 1, "1");
		predefine("__MIPSEB", 1, "1");
		predefine("__MIPSEB__", 1, "1");
	} else {
		predefine("_MIPSEL", 1, "1");
		predefine("__MIPSEL", 1, "1");
		predefine("__MIPSEL__", 1, "1");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x27031(%rip), %rdi     # 0x699b4
movl $0x1, %esi
leaq 0x2a5e8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4ff7b(%rip), %rax     # 0x92918
movl 0x50(%rax), %ecx
leaq 0x27016(%rip), %rdi     # 0x699bd
movl $0x1, %esi
leaq 0x20c78(%rip), %rdx     # 0x6362b
movb $0x0, %al
callq 0x2b3a0
leaq 0x4f157(%rip), %rax     # 0x91b18
movl 0x50(%rax), %ecx
leaq 0x26ff9(%rip), %rdi     # 0x699c4
movl $0x1, %esi
leaq 0x20c54(%rip), %rdx     # 0x6362b
movb $0x0, %al
callq 0x2b3a0
leaq 0x4f3d3(%rip), %rax     # 0x91db8
movl 0x50(%rax), %ecx
leaq 0x26fe1(%rip), %rdi     # 0x699d0
movl $0x1, %esi
leaq 0x20c30(%rip), %rdx     # 0x6362b
movb $0x0, %al
callq 0x2b3a0
leaq 0x4ff0f(%rip), %rax     # 0x92918
movl 0x50(%rax), %ecx
leaq 0x26fca(%rip), %rdi     # 0x699dd
movl $0x1, %esi
leaq 0x20c0c(%rip), %rdx     # 0x6362b
movb $0x0, %al
callq 0x2b3a0
leaq 0x4a74b(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x42a82
leaq 0x26fb1(%rip), %rdi     # 0x699ea
movl $0x1, %esi
leaq 0x2a532(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26f96(%rip), %rdi     # 0x699e9
movl $0x1, %esi
leaq 0x2a518(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26f85(%rip), %rdi     # 0x699f2
movl $0x1, %esi
leaq 0x2a4fe(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x42ad0
leaq 0x26f75(%rip), %rdi     # 0x699fe
movl $0x1, %esi
leaq 0x2a4e2(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26f5a(%rip), %rdi     # 0x699fd
movl $0x1, %esi
leaq 0x2a4c8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26f49(%rip), %rdi     # 0x69a06
movl $0x1, %esi
leaq 0x2a4ae(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-nds32.c
// Function: init_nds32
static void init_nds32(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	wchar_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47b71(%rip), %rax     # 0x8a690
leaq 0x4eff2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47b68(%rip), %rax     # 0x8a698
leaq 0x4f1a1(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47b5f(%rip), %rax     # 0x8a6a0
leaq 0x4efd0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47b56(%rip), %rax     # 0x8a6a8
leaq 0x4f17f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47acd(%rip), %rax     # 0x8a630
leaq 0x4f16e(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-nios2.c
// Function: init_nios2
static void init_nios2(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47a71(%rip), %rax     # 0x8a690
leaq 0x4eef2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47a68(%rip), %rax     # 0x8a698
leaq 0x4f0a1(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x47a5f(%rip), %rax     # 0x8a6a0
leaq 0x4eed0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47a56(%rip), %rax     # 0x8a6a8
leaq 0x4f07f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-nios2.c
// Function: predefine_nios2
static void predefine_nios2(const struct target *self)
{
	predefine("__NIOS2", 1, "1");
	predefine("__NIOS2__", 1, "1");
	predefine("__nios2", 1, "1");
	predefine("__nios2__", 1, "1");

	if (arch_big_endian) {
		predefine("__nios2_big_endian", 1, "1");
		predefine("__nios2_big_endian__", 1, "1");
	} else {
		predefine("__nios2_little_endian", 1, "1");
		predefine("__nios2_little_endian__", 1, "1");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x26dfe(%rip), %rdi     # 0x69a71
movl $0x1, %esi
leaq 0x2a2f8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26dec(%rip), %rdi     # 0x69a79
movl $0x1, %esi
leaq 0x2a2de(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26ddc(%rip), %rdi     # 0x69a83
movl $0x1, %esi
leaq 0x2a2c4(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26dca(%rip), %rdi     # 0x69a8b
movl $0x1, %esi
leaq 0x2a2aa(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4a49d(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x42d16
leaq 0x26dae(%rip), %rdi     # 0x69a95
movl $0x1, %esi
leaq 0x2a284(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26da7(%rip), %rdi     # 0x69aa8
movl $0x1, %esi
leaq 0x2a26a(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
jmp 0x42d4a
leaq 0x26da0(%rip), %rdi     # 0x69abd
movl $0x1, %esi
leaq 0x2a24e(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26d9c(%rip), %rdi     # 0x69ad3
movl $0x1, %esi
leaq 0x2a234(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-openrisc.c
// Function: init_openrisc
static void init_openrisc(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	wchar_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47901(%rip), %rax     # 0x8a690
leaq 0x4ed82(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x478f8(%rip), %rax     # 0x8a698
leaq 0x4ef31(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x478ef(%rip), %rax     # 0x8a6a0
leaq 0x4ed60(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x478e6(%rip), %rax     # 0x8a6a8
leaq 0x4ef0f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4785d(%rip), %rax     # 0x8a630
leaq 0x4eefe(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-ppc.c
// Function: init_ppc32
static void init_ppc32(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x47841(%rip), %rax     # 0x8a690
leaq 0x4ecc2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47838(%rip), %rax     # 0x8a698
leaq 0x4ee71(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4782f(%rip), %rax     # 0x8a6a0
leaq 0x4eca0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47826(%rip), %rax     # 0x8a6a8
leaq 0x4ee4f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-ppc.c
// Function: predefine_ppc64
static void predefine_ppc64(const struct target *self)
{
	predefine("__powerpc64__", 1, "1");
	predefine("__ppc64__", 1, "1");
	predefine("__PPC64__", 1, "1");
	predefine("_ARCH_PPC64", 1, "1");

	predefine_ppc(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x26c70(%rip), %rdi     # 0x69b63
movl $0x1, %esi
leaq 0x2a078(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26c64(%rip), %rdi     # 0x69b71
movl $0x1, %esi
leaq 0x2a05e(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26c54(%rip), %rdi     # 0x69b7b
movl $0x1, %esi
leaq 0x2a044(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26c44(%rip), %rdi     # 0x69b85
movl $0x1, %esi
leaq 0x2a02a(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
movq -0x8(%rbp), %rdi
callq 0x42f70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-ppc.c
// Function: predefine_ppc
static void predefine_ppc(const struct target *self)
{
	predefine("__powerpc__", 1, "1");
	predefine("__powerpc", 1, "1");
	predefine("__ppc__", 1, "1");
	predefine("__PPC__", 1, "1");
	predefine("__PPC", 1, "1");
	predefine("_ARCH_PPC", 1, "1");
	if (arch_big_endian)
		predefine("_BIG_ENDIAN", 1, "1");
	if (ldouble_ctype.bit_size == 128) {
		predefine("__LONGDOUBLE128", 1, "1");
		predefine("__LONG_DOUBLE_128__", 1, "1");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x26b7a(%rip), %rdi     # 0x69afd
movl $0x1, %esi
leaq 0x29fe8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26b6c(%rip), %rdi     # 0x69b09
movl $0x1, %esi
leaq 0x29fce(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26b5c(%rip), %rdi     # 0x69b13
movl $0x1, %esi
leaq 0x29fb4(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26b4a(%rip), %rdi     # 0x69b1b
movl $0x1, %esi
leaq 0x29f9a(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26b38(%rip), %rdi     # 0x69b23
movl $0x1, %esi
leaq 0x29f80(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26b24(%rip), %rdi     # 0x69b29
movl $0x1, %esi
leaq 0x29f66(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4a159(%rip), %rax     # 0x8d178
cmpl $0x0, (%rax)
je 0x4303e
leaq 0x26b08(%rip), %rdi     # 0x69b33
movl $0x1, %esi
leaq 0x29f40(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x4f713(%rip), %rax     # 0x92758
cmpl $0x80, 0x50(%rax)
jne 0x43082
leaq 0x26aea(%rip), %rdi     # 0x69b3f
movl $0x1, %esi
leaq 0x29f16(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26ae0(%rip), %rdi     # 0x69b4f
movl $0x1, %esi
leaq 0x29efc(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-riscv.c
// Function: init_riscv32
static void init_riscv32(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	init_riscv(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x475bd(%rip), %rax     # 0x8a690
leaq 0x4ea3e(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x475b4(%rip), %rax     # 0x8a698
leaq 0x4ebed(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x475ab(%rip), %rax     # 0x8a6a0
leaq 0x4ea1c(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x475a2(%rip), %rax     # 0x8a6a8
leaq 0x4ebcb(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x43550
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-riscv.c
// Function: init_riscv
static void init_riscv(const struct target *self)
{
	if (arch_cmodel == CMODEL_UNKNOWN)
		arch_cmodel = CMODEL_MEDLOW;
	if (fpic)
		arch_cmodel = CMODEL_PIC;

	if (riscv_flags == 0)
		riscv_flags = self->flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x49c1d(%rip), %rax     # 0x8d17c
cmpl $0x0, (%rax)
jne 0x43571
leaq 0x49c11(%rip), %rax     # 0x8d17c
movl $0x5, (%rax)
leaq 0x49c34(%rip), %rax     # 0x8d1ac
cmpl $0x0, (%rax)
je 0x4358a
leaq 0x49bf8(%rip), %rax     # 0x8d17c
movl $0x6, (%rax)
cmpl $0x0, 0x50de7(%rip)     # 0x94378
jne 0x435a1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, 0x50dd7(%rip)     # 0x94378
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-s390.c
// Function: init_s390
static void init_s390(const struct target *self)
{
	intptr_ctype = &int_ctype;
	uintptr_ctype = &uint_ctype;

	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x50d79(%rip), %rax     # 0x94368
leaq 0x4e522(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x50d70(%rip), %rax     # 0x94370
leaq 0x4e6d1(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4707f(%rip), %rax     # 0x8a690
leaq 0x4e500(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47076(%rip), %rax     # 0x8a698
leaq 0x4e6af(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4706d(%rip), %rax     # 0x8a6a0
leaq 0x4e4de(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x47064(%rip), %rax     # 0x8a6a8
leaq 0x4e68d(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-sh.c
// Function: init_sh
static void init_sh(const struct target *self)
{
	int64_ctype = &llong_ctype;
	uint64_ctype = &ullong_ctype;
	intptr_ctype = &int_ctype;
	uintptr_ctype = &uint_ctype;

	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	wchar_ctype = &long_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x46ec1(%rip), %rax     # 0x8a610
leaq 0x4e902(%rip), %rcx     # 0x92058
movq %rcx, (%rax)
leaq 0x46eb8(%rip), %rax     # 0x8a618
leaq 0x4eab1(%rip), %rcx     # 0x92218
movq %rcx, (%rax)
leaq 0x50bf7(%rip), %rax     # 0x94368
leaq 0x4e3a0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x50bee(%rip), %rax     # 0x94370
leaq 0x4e54f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46efd(%rip), %rax     # 0x8a690
leaq 0x4e37e(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46ef4(%rip), %rax     # 0x8a698
leaq 0x4e52d(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46eeb(%rip), %rax     # 0x8a6a0
leaq 0x4e35c(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46ee2(%rip), %rax     # 0x8a6a8
leaq 0x4e50b(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46e59(%rip), %rax     # 0x8a630
leaq 0x4e5da(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-sparc.c
// Function: init_sparc32
static void init_sparc32(const struct target *target)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	if (!sparc_version)
		sparc_version = 8;

	if (arch_os == OS_SUNOS) {
		wint_ctype = &long_ctype;
		wchar_ctype = &long_ctype;

		bits_in_longdouble = 128;
		max_fp_alignment = 16;

		funsigned_char = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x46e31(%rip), %rax     # 0x8a690
leaq 0x4e2b2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46e28(%rip), %rax     # 0x8a698
leaq 0x4e461(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46e1f(%rip), %rax     # 0x8a6a0
leaq 0x4e290(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46e16(%rip), %rax     # 0x8a6a8
leaq 0x4e43f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
cmpl $0x0, 0x50ad9(%rip)     # 0x9437c
jne 0x438af
movl $0x8, 0x50acd(%rip)     # 0x9437c
leaq 0x40f2e(%rip), %rax     # 0x847e4
cmpl $0x9, (%rax)
jne 0x43904
leaq 0x46d76(%rip), %rax     # 0x8a638
leaq 0x4e4ef(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
leaq 0x46d5d(%rip), %rax     # 0x8a630
leaq 0x4e4de(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
leaq 0x46e10(%rip), %rax     # 0x8a6f4
movl $0x80, (%rax)
leaq 0x46e07(%rip), %rax     # 0x8a6f8
movl $0x10, (%rax)
leaq 0x498be(%rip), %rax     # 0x8d1bc
movl $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-sparc.c
// Function: predefine_sparc
static void predefine_sparc(const struct target *self)
{
	predefine("__sparc__", 1, "1");
	predefine("__sparc", 1, "1");
	predefine_nostd("sparc");

	predefine_weak("__sparc_v%d__", sparc_version);
	predefine_weak("__sparcv%d__", sparc_version);
	predefine_weak("__sparcv%d", sparc_version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2633b(%rip), %rdi     # 0x69cee
movl $0x1, %esi
leaq 0x295b8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x2632b(%rip), %rdi     # 0x69cf8
movl $0x1, %esi
leaq 0x2959e(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x26313(%rip), %rdi     # 0x69cfa
callq 0x2b790
movl 0x5098a(%rip), %esi     # 0x9437c
leaq 0x26307(%rip), %rdi     # 0x69d00
movb $0x0, %al
callq 0x2b8d0
movl 0x50976(%rip), %esi     # 0x9437c
leaq 0x26301(%rip), %rdi     # 0x69d0e
movb $0x0, %al
callq 0x2b8d0
movl 0x50962(%rip), %esi     # 0x9437c
leaq 0x262fa(%rip), %rdi     # 0x69d1b
movb $0x0, %al
callq 0x2b8d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-x86.c
// Function: init_i386
static void init_i386(const struct target *target)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	init_x86_common(target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x46c1d(%rip), %rax     # 0x8a690
leaq 0x4e09e(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46c14(%rip), %rax     # 0x8a698
leaq 0x4e24d(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46c0b(%rip), %rax     # 0x8a6a0
leaq 0x4e07c(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46c02(%rip), %rax     # 0x8a6a8
leaq 0x4e22b(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x43de0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-x86.c
// Function: predefine_x86_64
static void predefine_x86_64(const struct target *self)
{
	predefine("__x86_64__", 1, "1");
	predefine("__x86_64", 1, "1");
	predefine("__amd64__", 1, "1");
	predefine("__amd64", 1, "1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2600a(%rip), %rdi     # 0x69d7d
movl $0x1, %esi
leaq 0x291f8(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x25ffb(%rip), %rdi     # 0x69d88
movl $0x1, %esi
leaq 0x291de(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x25fea(%rip), %rdi     # 0x69d91
movl $0x1, %esi
leaq 0x291c4(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
leaq 0x25fda(%rip), %rdi     # 0x69d9b
movl $0x1, %esi
leaq 0x291aa(%rip), %rdx     # 0x6cf77
movb $0x0, %al
callq 0x2b3a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-x86.c
// Function: init_x86_common
static void init_x86_common(const struct target *target)
{
	switch (arch_os) {
	case OS_CYGWIN:
		wchar_ctype = &ushort_ctype;
		break;
	case OS_FREEBSD:
		wint_ctype = &int_ctype;
		break;
	case OS_OPENBSD:
		size_t_ctype = &ulong_ctype;
		ssize_t_ctype = &long_ctype;
		wchar_ctype = &int_ctype;
		wint_ctype = &int_ctype;
		fast16_ctype = &short_ctype;
		ufast16_ctype = &ushort_ctype;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x409f5(%rip), %rax     # 0x847e4
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x3, %eax
je 0x43e12
jmp 0x43dfb
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x43e25
jmp 0x43e05
movl -0xc(%rbp), %eax
subl $0x8, %eax
je 0x43e38
jmp 0x43e9e
leaq 0x46817(%rip), %rax     # 0x8a630
leaq 0x4dc18(%rip), %rcx     # 0x91a38
movq %rcx, (%rax)
jmp 0x43e9e
leaq 0x4680c(%rip), %rax     # 0x8a638
leaq 0x4dce5(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
jmp 0x43e9e
leaq 0x467b1(%rip), %rax     # 0x8a5f0
leaq 0x4e132(%rip), %rcx     # 0x91f78
movq %rcx, (%rax)
leaq 0x467a8(%rip), %rax     # 0x8a5f8
leaq 0x4df61(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
leaq 0x467cf(%rip), %rax     # 0x8a630
leaq 0x4dcb0(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x467c6(%rip), %rax     # 0x8a638
leaq 0x4dc9f(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x4680d(%rip), %rax     # 0x8a690
leaq 0x4d9ee(%rip), %rcx     # 0x91878
movq %rcx, (%rax)
leaq 0x46804(%rip), %rax     # 0x8a698
leaq 0x4db9d(%rip), %rcx     # 0x91a38
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-x86.c
// Function: init_x86_x32
static void init_x86_x32(const struct target *target)
{
	init_x86_common(target);

	max_int_alignment = 8;

	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;
	wchar_ctype = &long_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x43de0
leaq 0x4682c(%rip), %rax     # 0x8a6e8
movl $0x8, (%rax)
leaq 0x467c7(%rip), %rax     # 0x8a690
leaq 0x4dc48(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x467be(%rip), %rax     # 0x8a698
leaq 0x4ddf7(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x467b5(%rip), %rax     # 0x8a6a0
leaq 0x4dc26(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x467ac(%rip), %rax     # 0x8a6a8
leaq 0x4ddd5(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x46723(%rip), %rax     # 0x8a630
leaq 0x4dea4(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/target-xtensa.c
// Function: init_xtensa
static void init_xtensa(const struct target *self)
{
	fast16_ctype = &int_ctype;
	ufast16_ctype = &uint_ctype;
	fast32_ctype = &int_ctype;
	ufast32_ctype = &uint_ctype;

	wchar_ctype = &long_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x46731(%rip), %rax     # 0x8a690
leaq 0x4dbb2(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46728(%rip), %rax     # 0x8a698
leaq 0x4dd61(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4671f(%rip), %rax     # 0x8a6a0
leaq 0x4db90(%rip), %rcx     # 0x91b18
movq %rcx, (%rax)
leaq 0x46716(%rip), %rax     # 0x8a6a8
leaq 0x4dd3f(%rip), %rcx     # 0x91cd8
movq %rcx, (%rax)
leaq 0x4668d(%rip), %rax     # 0x8a630
leaq 0x4de0e(%rip), %rcx     # 0x91db8
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: stream_prev
int stream_prev(int stream)
{
	if (stream < 0 || stream > input_stream_nr)
		return -1;
	stream = input_streams[stream].pos.stream;
	if (stream > input_stream_nr)
		return -1;
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x44098
movl -0x8(%rbp), %eax
cmpl 0x502ea(%rip), %eax     # 0x94380
jle 0x440a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x440de
movq 0x502e0(%rip), %rax     # 0x94388
movslq -0x8(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
shrq $0x6, %rax
andq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x502b3(%rip), %eax     # 0x94380
jle 0x440d8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x440de
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: show_special
const char *show_special(int val)
{
	static char buffer[4];

	buffer[0] = val;
	buffer[1] = 0;
	if (val >= SPECIAL_BASE)
		strcpy(buffer, (char *) combinations[val - SPECIAL_BASE]);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movb %al, 0x5028c(%rip)      # 0x94390
movb $0x0, 0x50286(%rip)     # 0x94391
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jl 0x44138
movl -0x4(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
cltq
leaq 0x4695b(%rip), %rsi     # 0x8aa80
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x5025d(%rip), %rdi     # 0x94390
callq 0x11090
leaq 0x50251(%rip), %rax     # 0x94390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: show_ident
const char *show_ident(const struct ident *ident)
{
	static char buff[4][256];
	static int n;
	char *buffer;

	if (!ident)
		return "<noident>";
	buffer = buff[3 & ++n];
	sprintf(buffer, "%.*s", ident->len, ident->name);
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44170
leaq 0x25f54(%rip), %rax     # 0x6a0be
movq %rax, -0x8(%rbp)
jmp 0x441c1
movl 0x5062a(%rip), %eax     # 0x947a0
addl $0x1, %eax
movl %eax, 0x50621(%rip)     # 0x947a0
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x50214(%rip), %rax     # 0x943a0
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edx
movq -0x10(%rbp), %rcx
addq $0x12, %rcx
leaq 0x280c0(%rip), %rsi     # 0x6c272
movb $0x0, %al
callq 0x112c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: show_string
const char *show_string(const struct string *string)
{
	static char buffer[4 * MAX_STRING + 3];
	char *ptr;
	int i;

	if (!string || !string->length)
		return "<bad_string>";
	ptr = buffer;
	*ptr++ = '"';
	for (i = 0; i < string->length-1; i++) {
		const char *p = string->data + i;
		ptr = charstr(ptr, p[0], '"', p[1]);
	}
	*ptr++ = '"';
	*ptr = '\0';
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x441f3
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x44203
leaq 0x25ece(%rip), %rax     # 0x6a0c8
movq %rax, -0x8(%rbp)
jmp 0x442a2
leaq 0x505a6(%rip), %rax     # 0x947b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x22, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4427e
movq -0x10(%rbp), %rax
addq $0x4, %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movl $0x22, %edx
movzbl %cl, %esi
movzbl 0x1(%rax), %ecx
callq 0x442b0
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x44227
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x22, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
leaq 0x50512(%rip), %rax     # 0x947b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: charstr
static char *charstr(char *ptr, unsigned char c, unsigned char escape, unsigned char next)
{
	if (isprint(c)) {
		if (c == escape || c == '\\')
			*ptr++ = '\\';
		*ptr++ = c;
		return ptr;
	}
	*ptr++ = '\\';
	switch (c) {
	case '\n':
		*ptr++ = 'n';
		return ptr;
	case '\t':
		*ptr++ = 't';
		return ptr;
	}
	if (!isdigit(next))
		return ptr + sprintf(ptr, "%o", c);
		
	return ptr + sprintf(ptr, "%03o", c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
callq 0x112f0
movq (%rax), %rax
movzbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x44331
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
je 0x442fe
movzbl -0x11(%rbp), %eax
cmpl $0x5c, %eax
jne 0x44310
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44410
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movb $0x5c, (%rax)
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x9, %eax
je 0x44379
jmp 0x44350
movl -0x18(%rbp), %eax
subl $0xa, %eax
jne 0x44395
jmp 0x4435a
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x6e, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44410
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x74, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44410
callq 0x112f0
movq (%rax), %rax
movzbl -0x13(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x443e2
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x25dd9(%rip), %rsi     # 0x6a1a2
movb $0x0, %al
callq 0x112c0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x44410
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %edx
leaq 0x25dac(%rip), %rsi     # 0x6a1a5
movb $0x0, %al
callq 0x112c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: show_char
static const char *show_char(const char *s, size_t len, char prefix, char delim)
{
	static char buffer[MAX_STRING + 4];
	char *p = buffer;
	if (prefix)
		*p++ = prefix;
	*p++ = delim;
	memcpy(p, s, len);
	p += len;
	*p++ = delim;
	*p++ = '\0';
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
leaq 0x682bf(%rip), %rax     # 0xac9e0
movq %rax, -0x20(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x4473f
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movb -0x12(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x111d0
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x12(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
leaq 0x68243(%rip), %rax     # 0xac9e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: quote_char
static const char *quote_char(const char *s, size_t len, char prefix, char delim)
{
	static char buffer[2*MAX_STRING + 6];
	size_t i;
	char *p = buffer;
	if (prefix)
		*p++ = prefix;
	if (delim == '"')
		*p++ = '\\';
	*p++ = delim;
	for (i = 0; i < len; i++) {
		if (s[i] == '"' || s[i] == '\\')
			*p++ = '\\';
		*p++ = s[i];
	}
	if (delim == '"')
		*p++ = '\\';
	*p++ = delim;
	*p++ = '\0';
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
leaq 0x6a023(%rip), %rax     # 0xae9f0
movq %rax, -0x28(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0x449eb
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movsbl -0x12(%rbp), %eax
cmpl $0x22, %eax
jne 0x44a06
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x5c, (%rax)
movb -0x12(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x44a8a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x44a4e
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x44a60
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x5c, (%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x44a22
movsbl -0x12(%rbp), %eax
cmpl $0x22, %eax
jne 0x44aa5
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x5c, (%rax)
movb -0x12(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
leaq 0x69f1e(%rip), %rax     # 0xae9f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: hash_stream
int *hash_stream(const char *name)
{
	uint32_t hash = 0;
	unsigned char c;

	while ((c = *name++) != 0)
		hash = (hash + (c << 4) + (c >> 4)) * 11;

	hash *= HASH_PRIME;
	hash >>= 32 - HASHED_INPUT_BITS;
	return input_stream_hashes + hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0xd(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x44b28
movl -0xc(%rbp), %eax
movzbl -0xd(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movzbl -0xd(%rbp), %ecx
sarl $0x4, %ecx
addl %ecx, %eax
imull $0xb, %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x44aef
movl -0xc(%rbp), %eax
movabsq $0x9e370001, %rcx       # imm = 0x9E370001
imulq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x45e2f(%rip), %rax     # 0x8a980
shlq $0x2, %rcx
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: init_stream
int init_stream(const struct position *pos, const char *name, int fd, const char **next_path)
{
	int stream = input_stream_nr, *hash;
	struct stream *current;

	if (stream >= input_streams_allocated) {
		int newalloc = stream * 4 / 3 + 10;
		input_streams = realloc(input_streams, newalloc * sizeof(struct stream));
		if (!input_streams)
			die("Unable to allocate more streams space");
		input_streams_allocated = newalloc;
	}
	current = input_streams + stream;
	memset(current, 0, sizeof(*current));
	current->name = name;
	current->fd = fd;
	current->next_path = next_path;
	current->path = NULL;
	current->constant = CONSTANT_FILE_MAYBE;
	if (pos)
		current->pos = *pos;
	else
		current->pos.stream = -1;
	input_stream_nr = stream+1;
	hash = hash_stream(name);
	current->next_stream = *hash;
	*hash = stream;
	return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl 0x4f803(%rip), %eax     # 0x94380
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x57e27(%rip), %eax     # 0x9c9b0
jl 0x44bdb
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl $0xa, %eax
movl %eax, -0x3c(%rbp)
movq 0x4f7e2(%rip), %rdi     # 0x94388
movslq -0x3c(%rbp), %rax
imulq $0x50, %rax, %rsi
callq 0x11230
movq %rax, 0x4f7ce(%rip)     # 0x94388
cmpq $0x0, 0x4f7c6(%rip)     # 0x94388
jne 0x44bd2
leaq 0x2557f(%rip), %rdi     # 0x6a14a
movb $0x0, %al
callq 0x17190
movl -0x3c(%rbp), %eax
movl %eax, 0x57dd5(%rip)     # 0x9c9b0
movq 0x4f7a6(%rip), %rax     # 0x94388
movslq -0x24(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x11130
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x28(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x44c51
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x44c6b
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
andq $-0xfffc1, %rcx         # imm = 0xFFF0003F
orq $0xfffc0, %rcx          # imm = 0xFFFC0
movq %rcx, 0x20(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x4f709(%rip)     # 0x94380
movq -0x10(%rbp), %rdi
callq 0x44ae0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: show_identifier_stats
void show_identifier_stats(void)
{
	int i;
	int distribution[100];

	fprintf(stderr, "identifiers: %d hits, %d misses\n",
		ident_hit, ident_miss);

	for (i = 0; i < 100; i++)
		distribution[i] = 0;

	for (i = 0; i < IDENT_HASH_SIZE; i++) {
		struct ident * ident = hash_table[i];
		int count = 0;

		while (ident) {
			count++;
			ident = ident->next;
		}
		if (count > 99)
			count = 99;
		distribution[count]++;
	}

	for (i = 0; i < 100; i++) {
		if (distribution[i])
			fprintf(stderr, "%2d: %d buckets\n", i, distribution[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq 0x3f32e(%rip), %rax     # 0x83ff0
movq (%rax), %rdi
movl 0x57ce9(%rip), %edx     # 0x9c9b4
movl 0x57ce7(%rip), %ecx     # 0x9c9b8
leaq 0x25498(%rip), %rsi     # 0x6a170
movb $0x0, %al
callq 0x111c0
movl $0x0, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jge 0x44d06
movslq -0x4(%rbp), %rax
movl $0x0, -0x1a0(%rbp,%rax,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x44ce6
movl $0x0, -0x4(%rbp)
cmpl $0x2000, -0x4(%rbp)     # imm = 0x2000
jge 0x44d9f
movslq -0x4(%rbp), %rcx
leaq 0x57c9b(%rip), %rax     # 0x9c9c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x1a8(%rbp)
movl $0x0, -0x1ac(%rbp)
cmpq $0x0, -0x1a8(%rbp)
je 0x44d66
movl -0x1ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1ac(%rbp)
movq -0x1a8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
jmp 0x44d3a
cmpl $0x63, -0x1ac(%rbp)
jle 0x44d79
movl $0x63, -0x1ac(%rbp)
movslq -0x1ac(%rbp), %rax
movl -0x1a0(%rbp,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, -0x1a0(%rbp,%rax,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x44d0d
movl $0x0, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jge 0x44ded
movslq -0x4(%rbp), %rax
cmpl $0x0, -0x1a0(%rbp,%rax,4)
je 0x44de0
movq 0x3f22f(%rip), %rax     # 0x83ff0
movq (%rax), %rdi
movl -0x4(%rbp), %edx
movslq -0x4(%rbp), %rax
movl -0x1a0(%rbp,%rax,4), %ecx
leaq 0x253b8(%rip), %rsi     # 0x6a191
movb $0x0, %al
callq 0x111c0
jmp 0x44de2
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x44da6
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: insert_hash
static struct ident * insert_hash(struct ident *ident, unsigned long hash)
{
	ident->next = hash_table[hash];
	hash_table[hash] = ident;
	ident_miss++;
	return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x57b69(%rip), %rax     # 0x9c9c0
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x57b4f(%rip), %rax     # 0x9c9c0
movq %rdx, (%rax,%rcx,8)
movl 0x57b3d(%rip), %eax     # 0x9c9b8
addl $0x1, %eax
movl %eax, 0x57b34(%rip)     # 0x9c9b8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)