LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/symbol.c
// Function: create_symbol
struct symbol *create_symbol(int stream, const char *name, int type, int namespace)
{
	struct ident *ident = built_in_ident(name);
	struct symbol *sym = lookup_symbol(ident, namespace);

	if (sym && sym->type != type)
		die("symbol %s created with different types: %d old %d", name,
				type, sym->type);

	if (!sym) {
		struct token *token = built_in_token(stream, ident);

		sym = alloc_symbol(token->pos, type);
		bind_symbol(sym, token->ident, namespace);
	}
	return sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %r12d
movq %rsi, %rdi
callq 0x2edd4
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x2c446
movl %ebx, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl (%r14), %edx
movl %edx, %esi
shrl $0x8, %esi
testl %esi, %ecx
jne 0x2c44b
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x2c431
xorl %r14d, %r14d
jmp 0x2c454
orl $0x20000, %edx          # imm = 0x20000
movl %edx, (%r14)
testq %r14, %r14
je 0x2c474
movzbl (%r14), %ecx
cmpl %ebp, %ecx
je 0x2c4cc
leaq 0x1c3a7(%rip), %rdi     # 0x4880f
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x11bea
movl %r12d, %edi
movq %rax, %rsi
callq 0x2eebe
movq %rax, %r15
movq (%rax), %r12
xorl %edi, %edi
callq 0x2ff60
movq %rax, %r14
movb %bpl, (%rax)
movq %r12, 0x4(%rax)
andb $-0x40, 0xc(%rax)
cmpl $0x1, %ebx
jne 0x2c4a8
leaq 0x388f2(%rip), %rax     # 0x64d98
jmp 0x2c4af
leaq 0x388d9(%rip), %rax     # 0x64d88
movq 0x10(%r15), %rsi
cmpl $0x8, %ebx
jne 0x2c4bf
leaq 0x388d1(%rip), %rax     # 0x64d90
movq (%rax), %rcx
movq %r14, %rdi
movl %ebx, %edx
callq 0x2c259
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/symbol.c
// Function: lay_out_union
static void lay_out_union(struct symbol *sym, struct struct_union_info *info)
{
	if (sym->bit_size < 0 && is_array_type(sym))
		sparse_error(sym->pos, "flexible array member '%s' in a union", show_ident(sym->ident));

	if (sym->bit_size > info->bit_size)
		info->bit_size = sym->bit_size;

	sym->offset = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x50(%rdi)
jns 0x2cb7b
cmpb $0x3, (%rbx)
movq %rbx, %rax
jne 0x2cb58
movq 0x60(%rbx), %rax
cmpb $0x6, (%rax)
jne 0x2cb7b
movq 0x18(%rbx), %rdi
callq 0x2e465
movq 0x4(%rbx), %rdi
leaq 0x1bd65(%rip), %rsi     # 0x488d6
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a38
movslq 0x50(%rbx), %rax
cmpq %rax, 0x8(%r14)
jae 0x2cb89
movq %rax, 0x8(%r14)
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/symbol.c
// Function: examine_anonymous_member
static void examine_anonymous_member(struct symbol *sym)
{
	unsigned long mod = sym->ctype.modifiers & MOD_QUALIFIER;
	struct symbol *sub;

	if (sym->type == SYM_NODE)
		sym = sym->ctype.base_type;
	if (sym->type != SYM_STRUCT && sym->type != SYM_UNION)
		return;

	FOR_EACH_PTR(sym->symbol_list, sub) {
		assert(sub->type == SYM_NODE);
		sub->ctype.modifiers |= mod;

		// if nested, propagate all the way down
		if (!sub->ident)
			examine_anonymous_member(sub);
	} END_FOR_EACH_PTR(sub);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x3, (%rdi)
movq %rdi, %rax
jne 0x2cbad
movq 0x60(%rdi), %rax
movzbl (%rax), %ecx
addl $-0x7, %ecx
cmpl $0x1, %ecx
ja 0x2cc1e
movq 0x98(%rax), %rbx
testq %rbx, %rbx
je 0x2cc1e
movq 0x68(%rdi), %r14
andl $0xe00, %r14d           # imm = 0xE00
movq %rbx, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x2cc15
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x2cbf1
testq %rdi, %rdi
je 0x2cc06
cmpb $0x3, (%rdi)
jne 0x2cc2a
orq %r14, 0x68(%rdi)
cmpq $0x0, 0x18(%rdi)
jne 0x2cc06
callq 0x2cb99
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x2cbdd
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x2cbd2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1bccb(%rip), %rdi     # 0x488fc
leaq 0x1bcda(%rip), %rsi     # 0x48912
leaq 0x1bcdc(%rip), %rcx     # 0x4891b
movl $0xc3, %edx
callq 0xe120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/target.c
// Function: target_parse
enum machine target_parse(const char *name)
{
	static const struct arch {
		const char *name;
		enum machine mach;
		char bits;
	} archs[] = {
		{ "alpha",	MACH_ALPHA,	64, },
		{ "aarch64",	MACH_ARM64,	64, },
		{ "arm64",	MACH_ARM64,	64, },
		{ "arm",	MACH_ARM,	32, },
		{ "bfin",	MACH_BFIN,	32, },
		{ "h8300",	MACH_H8300,	32, },
		{ "i386",	MACH_I386,	32, },
		{ "m68k",	MACH_M68K,	32, },
		{ "microblaze",	MACH_MICROBLAZE,32, },
		{ "mips",	MACH_MIPS32,	0,  },
		{ "nds32",	MACH_NDS32,	32, },
		{ "nios2",	MACH_NIOS2,	32, },
		{ "openrisc",	MACH_OPENRISC,	32, },
		{ "powerpc",	MACH_PPC32,	0,  },
		{ "ppc",	MACH_PPC32,	0,  },
		{ "riscv",	MACH_RISCV32,	0,  },
		{ "s390x",	MACH_S390X,	64, },
		{ "s390",	MACH_S390,	32, },
		{ "sparc",	MACH_SPARC32,	0,  },
		{ "x86_64",	MACH_X86_64,	64, },
		{ "x86-64",	MACH_X86_64,	64, },
		{ "sh",		MACH_SH,	32, },
		{ "xtensa",	MACH_XTENSA,	32, },
		{ NULL },
	};
	const struct arch *p;

	for (p = &archs[0]; p->name; p++) {
		size_t len = strlen(p->name);
		if (strncmp(p->name, name, len) == 0) {
			enum machine mach = p->mach;
			const char *suf = name + len;
			int bits = p->bits;

			if (bits == 0) {
				if (!strcmp(suf, "") || !strcmp(suf, "32")) {
					;
				} else if (!strcmp(suf, "64")) {
					mach += 1;
				} else {
					die("invalid architecture: %s", name);
				}
			} else {
				if (strcmp(suf, ""))
					die("invalid architecture: %s", name);
			}

			return mach;
		}
	}

	return MACH_UNKNOWN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1bebc(%rip), %r12     # 0x48b1d
leaq 0x2e8a8(%rip), %r15     # 0x5b510
leaq 0x19de1(%rip), %r14     # 0x46a50
movq %r12, %rdi
callq 0xe0d0
movq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xe080
movl %eax, %r12d
testl %eax, %eax
jne 0x2cca2
movl -0x8(%r15), %ebp
cmpb $0x0, -0x4(%r15)
movb (%rbx,%r13), %al
je 0x2ccb5
testb %al, %al
jne 0x2ccf8
testl %r12d, %r12d
je 0x2cce7
movq (%r15), %r12
addq $0x10, %r15
testq %r12, %r12
jne 0x2cc6f
jmp 0x2cce2
testb %al, %al
je 0x2cca2
addq %rbx, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xe1c0
testl %eax, %eax
je 0x2cca2
movq %r13, %rdi
leaq 0x1bd3a(%rip), %rsi     # 0x48a0f
callq 0xe1c0
testl %eax, %eax
jne 0x2ccf8
incl %ebp
jmp 0x2cca2
movl $0x18, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bd1d(%rip), %rdi     # 0x48a1c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/target.c
// Function: target_config
void target_config(enum machine mach)
{
	const struct target *target = targets[mach];

	arch_target = target;
	arch_m64 = target->bitness;
	arch_big_endian = target->big_endian;

	funsigned_char = target->unsigned_char;
}

// Assembly:
movl %edi, %eax
leaq 0x2e9c3(%rip), %rcx     # 0x5b730
movq (%rcx,%rax,8), %rax
movq %rax, 0x389c8(%rip)     # 0x65740
movl 0x4(%rax), %ecx
leaq 0x347de(%rip), %rdx     # 0x61560
movl %ecx, (%rdx)
movzbl 0x8(%rax), %eax
movl %eax, %ecx
andl $0x1, %ecx
leaq 0x3b004(%rip), %rdx     # 0x67d98
movl %ecx, (%rdx)
shrl %eax
andl $0x1, %eax
leaq 0x3b03a(%rip), %rcx     # 0x67ddc
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f799(%rip), %rax     # 0x6c738
leaq 0x3871a(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f948(%rip), %rcx     # 0x6c8f8
leaq 0x38711(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x3870f(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x3870d(%rip), %rdx     # 0x656d8
movq %rcx, (%rdx)
leaq 0x3458f(%rip), %rdx     # 0x61564
cmpl $0x1, (%rdx)
jne 0x2d010
leaq 0x3f9f7(%rip), %rdx     # 0x6c9d8
leaq 0x38668(%rip), %rsi     # 0x65650
movq %rdx, (%rsi)
leaq 0x3fba6(%rip), %rdx     # 0x6cb98
leaq 0x3865f(%rip), %rsi     # 0x65658
movq %rdx, (%rsi)
leaq 0x386ad(%rip), %rdx     # 0x656b0
movq %rax, (%rdx)
leaq 0x386ab(%rip), %rax     # 0x656b8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1bb0a(%rip), %rdi     # 0x48b23
leaq 0x1f293(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1baf5(%rip), %rdi     # 0x48b2b
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x34510(%rip), %rax     # 0x6155c
movl (%rax), %eax
testl %eax, %eax
je 0x2d07f
cmpl $0x2, %eax
je 0x2d076
cmpl $0x1, %eax
jne 0x2d099
leaq 0x1bae1(%rip), %rdi     # 0x48b44
leaq 0x1f249(%rip), %rdx     # 0x4c2b3
movl $0x1, %esi
xorl %eax, %eax
callq 0x1edb4
leaq 0x1bad2(%rip), %rdi     # 0x48b4f
jmp 0x2d086
leaq 0x1bab0(%rip), %rdi     # 0x48b36
leaq 0x1f226(%rip), %rdx     # 0x4c2b3
movl $0x1, %esi
xorl %eax, %eax
callq 0x1edb4
leaq 0x3acf8(%rip), %rax     # 0x67d98
cmpl $0x0, (%rax)
leaq 0x1bab9(%rip), %rax     # 0x48b63
leaq 0x1baa8(%rip), %rdi     # 0x48b59
cmoveq %rax, %rdi
leaq 0x1f1f7(%rip), %rdx     # 0x4c2b3
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x1edb4
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x3acb4(%rip), %rax     # 0x67d9c
movslq (%rax), %r15
leaq 0x2eb1e(%rip), %rax     # 0x5bc10
movq (%rax,%r15,8), %rbx
leaq 0x1ba81(%rip), %rdi     # 0x48b7e
leaq 0x1f1af(%rip), %r14     # 0x4c2b3
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3ac7e(%rip), %rax     # 0x67d98
cmpl $0x0, (%rax)
leaq 0x1ba74(%rip), %rax     # 0x48b98
leaq 0x1ba5f(%rip), %rdi     # 0x48b8a
cmoveq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
movl $0x7b, %eax
btq %r15, %rax
jb 0x2d15c
leaq 0x1ba59(%rip), %rdi     # 0x48ba6
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1f363
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f595(%rip), %rax     # 0x6c738
leaq 0x41dde(%rip), %rcx     # 0x6ef88
movq %rax, (%rcx)
leaq 0x3f744(%rip), %rcx     # 0x6c8f8
leaq 0x41dd5(%rip), %rdx     # 0x6ef90
movq %rcx, (%rdx)
leaq 0x3f813(%rip), %rdx     # 0x6c9d8
leaq 0x3845c(%rip), %rsi     # 0x65628
movq %rdx, (%rsi)
leaq 0x3f9c2(%rip), %rdx     # 0x6cb98
leaq 0x38443(%rip), %rsi     # 0x65620
movq %rdx, (%rsi)
leaq 0x3f471(%rip), %rdx     # 0x6c658
leaq 0x38472(%rip), %rsi     # 0x65660
movq %rdx, (%rsi)
leaq 0x384c8(%rip), %rdx     # 0x656c0
movq %rax, (%rdx)
leaq 0x384c6(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x384c4(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x384c2(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f4fd(%rip), %rax     # 0x6c738
leaq 0x3847e(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f6ac(%rip), %rcx     # 0x6c8f8
leaq 0x38475(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x38473(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x38471(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f4a9(%rip), %rax     # 0x6c738
leaq 0x3842a(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f658(%rip), %rcx     # 0x6c8f8
leaq 0x38421(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x3841f(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x3841d(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x1b990(%rip), %rdi     # 0x48cdc
leaq 0x1ef60(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x401cf(%rip), %r15     # 0x6d538
movl 0x50(%r15), %ecx
leaq 0x1b971(%rip), %rdi     # 0x48ce5
leaq 0x153a6(%rip), %r14     # 0x42721
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3f3a7(%rip), %rax     # 0x6c738
movl 0x50(%rax), %ecx
leaq 0x1b951(%rip), %rdi     # 0x48cec
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3f627(%rip), %rax     # 0x6c9d8
movl 0x50(%rax), %ecx
leaq 0x1b93d(%rip), %rdi     # 0x48cf8
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
movl 0x50(%r15), %ecx
leaq 0x1b930(%rip), %rdi     # 0x48d05
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3a9ad(%rip), %rax     # 0x67d98
cmpl $0x0, (%rax)
leaq 0x1b931(%rip), %rax     # 0x48d26
leaq 0x1b916(%rip), %rdi     # 0x48d12
cmoveq %rax, %rdi
leaq 0x1b91e(%rip), %rax     # 0x48d25
leaq 0x1b903(%rip), %r14     # 0x48d11
cmoveq %rax, %r14
leaq 0x1b915(%rip), %rax     # 0x48d2e
leaq 0x1b8fa(%rip), %r15     # 0x48d1a
cmoveq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1edb4
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f2d5(%rip), %rax     # 0x6c738
leaq 0x38256(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f484(%rip), %rcx     # 0x6c8f8
leaq 0x3824d(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x3824b(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x38249(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x381c7(%rip), %rax     # 0x65660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f239(%rip), %rax     # 0x6c738
leaq 0x381ba(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f3e8(%rip), %rcx     # 0x6c8f8
leaq 0x381b1(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x381af(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x381ad(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x1b85f(%rip), %rdi     # 0x48d99
leaq 0x1ed72(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b84a(%rip), %rdi     # 0x48da1
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b83e(%rip), %rdi     # 0x48dab
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b830(%rip), %rdi     # 0x48db3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3a7ff(%rip), %rax     # 0x67d98
cmpl $0x0, (%rax)
leaq 0x1b842(%rip), %rax     # 0x48de5
leaq 0x1b813(%rip), %rdi     # 0x48dbd
cmoveq %rax, %rdi
leaq 0x1b846(%rip), %rax     # 0x48dfb
leaq 0x1b814(%rip), %r14     # 0x48dd0
cmoveq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1edb4
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f149(%rip), %rax     # 0x6c738
leaq 0x380ca(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f2f8(%rip), %rcx     # 0x6c8f8
leaq 0x380c1(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x380bf(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x380bd(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x3803b(%rip), %rax     # 0x65660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3f0e9(%rip), %rax     # 0x6c738
leaq 0x3806a(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f298(%rip), %rcx     # 0x6c8f8
leaq 0x38061(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x3805f(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x3805d(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1b7f5(%rip), %rdi     # 0x48e8b
leaq 0x1ec16(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b7e6(%rip), %rdi     # 0x48e99
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b7da(%rip), %rdi     # 0x48ea3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b7ce(%rip), %rdi     # 0x48ead
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
popq %rbx
jmp 0x2d6f1
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1b72c(%rip), %rdi     # 0x48e25
leaq 0x1ebb3(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b71b(%rip), %rdi     # 0x48e31
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b70f(%rip), %rdi     # 0x48e3b
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b701(%rip), %rdi     # 0x48e43
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b6f3(%rip), %rdi     # 0x48e4b
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b6e3(%rip), %rdi     # 0x48e51
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x3a614(%rip), %rax     # 0x67d98
cmpl $0x0, (%rax)
je 0x2d7a3
leaq 0x1b6cb(%rip), %rdi     # 0x48e5b
leaq 0x1eb1c(%rip), %rdx     # 0x4c2b3
movl $0x1, %esi
xorl %eax, %eax
callq 0x1edb4
leaq 0x3fbce(%rip), %rax     # 0x6d378
cmpl $0x80, 0x50(%rax)
jne 0x2d7e7
leaq 0x1b6ad(%rip), %rdi     # 0x48e67
leaq 0x1eaf2(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b6a0(%rip), %rdi     # 0x48e77
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x1edb4
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3ef45(%rip), %rax     # 0x6c738
leaq 0x37ec6(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3f0f4(%rip), %rcx     # 0x6c8f8
leaq 0x37ebd(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x37ebb(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x37eb9(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x3a573(%rip), %rax     # 0x67d9c
cmpl $0x0, (%rax)
jne 0x2d834
movl $0x5, (%rax)
leaq 0x3a591(%rip), %rcx     # 0x67dcc
cmpl $0x0, (%rcx)
je 0x2d846
movl $0x6, (%rax)
cmpl $0x0, 0x4174b(%rip)     # 0x6ef98
je 0x2d850
retq
movl 0x10(%rdi), %eax
movl %eax, 0x4173f(%rip)     # 0x6ef98
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/target-riscv.c
// Function: parse_march_riscv
static void parse_march_riscv(const char *arg)
{
	static struct {
		const char *pattern;
		unsigned int flags;
	} basic_sets[] = {
		{ "rv32i",	RISCV_32BIT },
		{ "rv32e",	RISCV_32BIT|RISCV_EMBD },
		{ "rv32g",	RISCV_32BIT|RISCV_GENERIC },
		{ "rv64i",	RISCV_64BIT },
		{ "rv64g",	RISCV_64BIT|RISCV_GENERIC },
	}, extensions[] = {
		{ "m",		RISCV_MUL|RISCV_DIV },
		{ "a",		RISCV_ATOMIC },
		{ "f",		RISCV_FLOAT|RISCV_FDIV|RISCV_ZICSR },
		{ "d",		RISCV_DOUBLE|RISCV_FDIV|RISCV_ZICSR },
		{ "c",		RISCV_COMP },
		{ "_zicsr",	RISCV_ZICSR },
		{ "_zifencei",	RISCV_ZIFENCEI },
		{ "_zicbom",	RISCV_ZICBOM },
		{ "_zihintpause",	RISCV_ZIHINTPAUSE },
	};
	int i;

	// Each -march=.. options entirely overrides previous ones
	riscv_flags = 0;

	for (i = 0; i < ARRAY_SIZE(basic_sets); i++) {
		const char *pat = basic_sets[i].pattern;
		size_t len = strlen(pat);

		if (!strncmp(arg, pat, len)) {
			riscv_flags |= basic_sets[i].flags;
			arg += len;
			goto ext;
		}
	}

unknown:
	fprintf(stderr, "WARNING: invalid argument to '-march': '%s'\n", arg);
	return;

ext:
	for (i = 0; i < ARRAY_SIZE(extensions); i++) {
		const char *pat = extensions[i].pattern;
		size_t len = strlen(pat);

		if (!strncmp(arg, pat, len)) {
			riscv_flags |= extensions[i].flags;
			arg += len;
		}
	}
	if (arg[0])
		goto unknown;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x41726(%rip)     # 0x6ef98
xorl %ebp, %ebp
movl $0x8, %r12d
leaq 0x2ec4f(%rip), %r13     # 0x5c4d0
movq -0x8(%r12,%r13), %r15
movq %r15, %rdi
callq 0xe0d0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe080
testl %eax, %eax
je 0x2d8a7
xorl %eax, %eax
jmp 0x2d8b9
orl (%r12,%r13), %ebp
movl %ebp, 0x416e7(%rip)     # 0x6ef98
addq %r14, %rbx
movl $0x5, %eax
testl %eax, %eax
jne 0x2d8c9
addq $0x10, %r12
cmpq $0x58, %r12
jne 0x2d881
jmp 0x2d931
cmpl $0x5, %eax
jne 0x2d922
movl $0x8, %r12d
movl 0x416be(%rip), %ebp     # 0x6ef98
leaq 0x2ec3f(%rip), %r13     # 0x5c520
movq -0x8(%r12,%r13), %r15
movq %r15, %rdi
callq 0xe0d0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe080
testl %eax, %eax
jne 0x2d910
orl (%r12,%r13), %ebp
movl %ebp, 0x4168b(%rip)     # 0x6ef98
addq %r14, %rbx
addq $0x10, %r12
cmpq $0x98, %r12
jne 0x2d8e1
cmpb $0x0, (%rbx)
jne 0x2d931
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x336b8(%rip), %rax     # 0x60ff0
movq (%rax), %rdi
leaq 0x1b595(%rip), %rsi     # 0x48ed7
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe1d0
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3a1e5(%rip), %rax     # 0x67d9c
cmpl $0x0, (%rax)
jne 0x2dbc2
movl $0x5, (%rax)
leaq 0x3a203(%rip), %rcx     # 0x67dcc
cmpl $0x0, (%rcx)
je 0x2dbd4
movl $0x6, (%rax)
cmpl $0x0, 0x413bd(%rip)     # 0x6ef98
je 0x2dbde
retq
movl 0x10(%rdi), %eax
movl %eax, 0x413b1(%rip)     # 0x6ef98
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3eb49(%rip), %rax     # 0x6c738
leaq 0x41392(%rip), %rcx     # 0x6ef88
movq %rax, (%rcx)
leaq 0x3ecf8(%rip), %rcx     # 0x6c8f8
leaq 0x41389(%rip), %rdx     # 0x6ef90
movq %rcx, (%rdx)
leaq 0x37aaf(%rip), %rdx     # 0x656c0
movq %rax, (%rdx)
leaq 0x37aad(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x37aab(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x37aa9(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3efc9(%rip), %rax     # 0x6cc78
leaq 0x3798a(%rip), %rcx     # 0x65640
movq %rax, (%rcx)
leaq 0x3f178(%rip), %rax     # 0x6ce38
leaq 0x37981(%rip), %rcx     # 0x65648
movq %rax, (%rcx)
leaq 0x3ea67(%rip), %rax     # 0x6c738
leaq 0x412b0(%rip), %rcx     # 0x6ef88
movq %rax, (%rcx)
leaq 0x3ec16(%rip), %rcx     # 0x6c8f8
leaq 0x412a7(%rip), %rdx     # 0x6ef90
movq %rcx, (%rdx)
leaq 0x379cd(%rip), %rdx     # 0x656c0
movq %rax, (%rdx)
leaq 0x379cb(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x379c9(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x379c7(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x3ecbd(%rip), %rax     # 0x6c9d8
leaq 0x3793e(%rip), %rcx     # 0x65660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3e9ed(%rip), %rax     # 0x6c738
leaq 0x3796e(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3eb9c(%rip), %rcx     # 0x6c8f8
leaq 0x37965(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x37963(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x37961(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
cmpl $0x0, 0x4121b(%rip)     # 0x6ef9c
jne 0x2dd8d
movl $0x8, 0x4120f(%rip)     # 0x6ef9c
leaq 0x337d0(%rip), %rax     # 0x61564
cmpl $0x9, (%rax)
jne 0x2dddb
leaq 0x3ec38(%rip), %rax     # 0x6c9d8
leaq 0x378c1(%rip), %rcx     # 0x65668
movq %rax, (%rcx)
leaq 0x378af(%rip), %rcx     # 0x65660
movq %rax, (%rcx)
leaq 0x37969(%rip), %rax     # 0x65724
movl $0x80, (%rax)
leaq 0x37960(%rip), %rax     # 0x65728
movl $0x10, (%rax)
leaq 0x3a007(%rip), %rax     # 0x67ddc
movl $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1b1e4(%rip), %rdi     # 0x49016
leaq 0x1e47a(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b1d1(%rip), %rdi     # 0x49020
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1b1bd(%rip), %rdi     # 0x49022
callq 0x1f338
movl 0x4112c(%rip), %esi     # 0x6ef9c
leaq 0x1b1b1(%rip), %rdi     # 0x49028
xorl %eax, %eax
callq 0x1f415
movl 0x41118(%rip), %esi     # 0x6ef9c
leaq 0x1b1ab(%rip), %rdi     # 0x49036
xorl %eax, %eax
callq 0x1f415
movl 0x41104(%rip), %esi     # 0x6ef9c
leaq 0x1b1a4(%rip), %rdi     # 0x49043
xorl %eax, %eax
popq %rbx
jmp 0x1f415
nop
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3e889(%rip), %rax     # 0x6c738
leaq 0x3780a(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3ea38(%rip), %rsi     # 0x6c8f8
leaq 0x37801(%rip), %rdx     # 0x656c8
movq %rsi, (%rdx)
leaq 0x377ff(%rip), %rdi     # 0x656d0
movq %rax, (%rdi)
leaq 0x377fd(%rip), %rdi     # 0x656d8
movq %rsi, (%rdi)
leaq 0x3367f(%rip), %rsi     # 0x61564
movl (%rsi), %esi
cmpl $0x8, %esi
je 0x2df11
cmpl $0x5, %esi
je 0x2df06
cmpl $0x3, %esi
jne 0x2df5b
leaq 0x3e75b(%rip), %rax     # 0x6c658
leaq 0x3775c(%rip), %rcx     # 0x65660
jmp 0x2df0d
leaq 0x3775b(%rip), %rcx     # 0x65668
movq %rax, (%rcx)
retq
leaq 0x3ec80(%rip), %rsi     # 0x6cb98
leaq 0x37701(%rip), %rdi     # 0x65620
movq %rsi, (%rdi)
leaq 0x3eaaf(%rip), %rsi     # 0x6c9d8
leaq 0x376f8(%rip), %rdi     # 0x65628
movq %rsi, (%rdi)
leaq 0x37726(%rip), %rsi     # 0x65660
movq %rax, (%rsi)
leaq 0x37724(%rip), %rsi     # 0x65668
movq %rax, (%rsi)
leaq 0x3e54a(%rip), %rax     # 0x6c498
movq %rax, (%rcx)
leaq 0x3e700(%rip), %rax     # 0x6c658
movq %rax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1aebb(%rip), %rdi     # 0x490b9
leaq 0x1e0ae(%rip), %rbx     # 0x4c2b3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1aea9(%rip), %rdi     # 0x490c4
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1ae9c(%rip), %rdi     # 0x490cd
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1edb4
leaq 0x1ae90(%rip), %rdi     # 0x490d7
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x1edb4
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/target-x86.c
// Function: init_x86_x32
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:
leaq 0x33306(%rip), %rax     # 0x61564
movl (%rax), %eax
cmpl $0x8, %eax
je 0x2e28f
cmpl $0x5, %eax
je 0x2e27f
cmpl $0x3, %eax
jne 0x2e2ee
leaq 0x3e3e2(%rip), %rax     # 0x6c658
leaq 0x373e3(%rip), %rcx     # 0x65660
jmp 0x2e2eb
leaq 0x3e4b2(%rip), %rax     # 0x6c738
leaq 0x373db(%rip), %rcx     # 0x65668
jmp 0x2e2eb
leaq 0x3e902(%rip), %rax     # 0x6cb98
leaq 0x37383(%rip), %rcx     # 0x65620
movq %rax, (%rcx)
leaq 0x3e731(%rip), %rax     # 0x6c9d8
leaq 0x3737a(%rip), %rcx     # 0x65628
movq %rax, (%rcx)
leaq 0x3e480(%rip), %rax     # 0x6c738
leaq 0x373a1(%rip), %rcx     # 0x65660
movq %rax, (%rcx)
leaq 0x3739f(%rip), %rcx     # 0x65668
movq %rax, (%rcx)
leaq 0x3e1c5(%rip), %rax     # 0x6c498
leaq 0x373e6(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3e374(%rip), %rax     # 0x6c658
leaq 0x373dd(%rip), %rcx     # 0x656c8
movq %rax, (%rcx)
leaq 0x37423(%rip), %rax     # 0x65718
movl $0x8, (%rax)
leaq 0x3e436(%rip), %rax     # 0x6c738
leaq 0x373b7(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3e5e5(%rip), %rcx     # 0x6c8f8
leaq 0x373ae(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x373ac(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x373aa(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x3e6a0(%rip), %rax     # 0x6c9d8
leaq 0x37321(%rip), %rcx     # 0x65660
movq %rax, (%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x3e3ed(%rip), %rax     # 0x6c738
leaq 0x3736e(%rip), %rcx     # 0x656c0
movq %rax, (%rcx)
leaq 0x3e59c(%rip), %rcx     # 0x6c8f8
leaq 0x37365(%rip), %rdx     # 0x656c8
movq %rcx, (%rdx)
leaq 0x37363(%rip), %rdx     # 0x656d0
movq %rax, (%rdx)
leaq 0x37361(%rip), %rax     # 0x656d8
movq %rcx, (%rax)
leaq 0x3e657(%rip), %rax     # 0x6c9d8
leaq 0x372d8(%rip), %rcx     # 0x65660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb %dil, 0x40b7f(%rip)     # 0x6efb0
movb $0x0, 0x40b79(%rip)     # 0x6efb1
cmpl $0x100, %edi            # imm = 0x100
jl 0x2e45d
addl $0xffffff00, %edi       # imm = 0xFFFFFF00
leaq 0x37413(%rip), %rax     # 0x65860
leaq (%rax,%rdi,4), %rsi
leaq 0x40b58(%rip), %rdi     # 0x6efb0
jmp 0xe090
leaq 0x40b4c(%rip), %rax     # 0x6efb0
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0x1affd(%rip), %rax     # 0x494b7
testq %rdi, %rdi
je 0x2e5bf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
je 0x2e5b1
movb $0x22, 0x40eec(%rip)    # 0x6f3d0
testl $0x7ffffffe, (%rbx)     # imm = 0x7FFFFFFE
je 0x2e59d
leaq 0x40eda(%rip), %r14     # 0x6f3d1
callq 0xe300
movq %rax, %r15
leaq 0x1b08b(%rip), %r12     # 0x49591
leaq 0x1b087(%rip), %r13     # 0x49594
xorl %ebp, %ebp
movb 0x4(%rbx,%rbp), %al
movzbl %al, %edx
movq (%r15), %rcx
testb $0x40, 0x1(%rcx,%rdx,2)
jne 0x2e53a
movzbl 0x5(%rbx,%rbp), %eax
movb $0x5c, (%r14)
cmpl $0x9, %edx
je 0x2e553
cmpl $0xa, %edx
jne 0x2e55e
movb $0x6e, 0x1(%r14)
jmp 0x2e558
cmpl $0x5c, %edx
je 0x2e544
cmpl $0x22, %edx
jne 0x2e54b
movb $0x5c, (%r14)
incq %r14
movb %al, (%r14)
incq %r14
jmp 0x2e585
movb $0x74, 0x1(%r14)
addq $0x2, %r14
jmp 0x2e585
incq %r14
movq (%r15), %rcx
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x2e573
movq %r14, %rdi
movq %r12, %rsi
jmp 0x2e579
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0xe2c0
cltq
addq %rax, %r14
incq %rbp
movl (%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
decq %rax
cmpq %rax, %rbp
jl 0x2e50f
jmp 0x2e5a4
leaq 0x40e2d(%rip), %r14     # 0x6f3d1
movw $0x22, (%r14)
leaq 0x40e1f(%rip), %rax     # 0x6f3d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x2ec2e
incq %rdi
movzbl %dl, %ecx
movl %ecx, %edx
shll $0x4, %edx
addl %eax, %edx
shrl $0x4, %ecx
addl %edx, %ecx
leal (%rcx,%rcx,4), %eax
leal (%rcx,%rax,2), %eax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x2ec07
imull $0xcc5d000b, %ecx, %eax # imm = 0xCC5D000B
shrl $0x1a, %eax
leaq 0x36b2b(%rip), %rcx     # 0x65760
leaq (%rcx,%rax,4), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl 0x4034a(%rip), %ebx     # 0x6efa0
cmpl 0x48974(%rip), %ebx     # 0x775d0
jl 0x2ecac
leal (,%rbx,4), %eax
movl $0xaaaaaaab, %r13d      # imm = 0xAAAAAAAB
imulq %rax, %r13
shrq $0x21, %r13
movq %r13, %rax
shlq $0x4, %rax
movq 0x40327(%rip), %rdi     # 0x6efa8
leaq (%rax,%rax,4), %rsi
addq $0x320, %rsi            # imm = 0x320
callq 0xe230
movq %rax, 0x40310(%rip)     # 0x6efa8
testq %rax, %rax
je 0x2ed73
addl $0xa, %r13d
movl %r13d, 0x48924(%rip)    # 0x775d0
movslq %ebx, %rax
movq 0x402f2(%rip), %rcx     # 0x6efa8
leaq (%rax,%rax,4), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rcx,%rdx)
movups %xmm0, 0x10(%rcx,%rdx)
movups %xmm0, 0x20(%rcx,%rdx)
movups %xmm0, 0x40(%rcx,%rdx)
movups %xmm0, 0x30(%rcx,%rdx)
movq %r14, 0x8(%rcx,%rdx)
movl %ebp, (%rcx,%rdx)
movq %r12, 0x18(%rcx,%rdx)
movq $0x0, 0x10(%rcx,%rdx)
movl $0x0, 0x28(%rcx,%rdx)
testq %r15, %r15
je 0x2ed05
movq (%r15), %rcx
jmp 0x2ed0e
movl $0xfffc0, %ecx          # imm = 0xFFFC0
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
leal 0x1(%rbx), %ecx
movl %ecx, 0x40285(%rip)     # 0x6efa0
movb (%r14), %sil
xorl %ecx, %ecx
testb %sil, %sil
je 0x2ed52
incq %r14
movzbl %sil, %edx
movl %edx, %esi
shll $0x4, %esi
addl %ecx, %esi
shrl $0x4, %edx
addl %esi, %edx
leal (%rdx,%rdx,4), %ecx
leal (%rdx,%rcx,2), %ecx
movb (%r14), %sil
incq %r14
testb %sil, %sil
jne 0x2ed28
imull $0xcc5d000b, %edx, %ecx # imm = 0xCC5D000B
shrl $0x1a, %ecx
leaq 0x36a07(%rip), %rdx     # 0x65760
movl (%rdx,%rcx,4), %esi
movl %esi, 0x30(%rax)
movl %ebx, (%rdx,%rcx,4)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a7bf(%rip), %rdi     # 0x49539
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/tokenize.c
// Function: create_hashed_ident
static struct ident *create_hashed_ident(const char *name, int len, unsigned long hash)
{
	struct ident *ident;
	struct ident **p;

	p = &hash_table[hash];
	while ((ident = *p) != NULL) {
		if (ident->len == (unsigned char) len) {
			if (strncmp(name, ident->name, len) != 0)
				goto next;

			ident_hit++;
			return ident;
		}
next:
		//misses++;
		p = &ident->next;
	}
	ident = alloc_ident(name, len);
	*p = ident;
	ident->next = NULL;
	ident_miss++;
	idents++;
	return ident;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x487b4(%rip), %rcx     # 0x775e0
movq (%rcx,%rdx,8), %rax
movslq %esi, %r15
testq %rax, %rax
je 0x2ee65
leaq 0x48795(%rip), %r13     # 0x775d4
movq %rax, %r14
cmpb %bpl, 0x10(%rax)
jne 0x2ee5b
leaq 0x12(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe080
testl %eax, %eax
je 0x2eea8
movq (%r14), %rax
testq %rax, %rax
jne 0x2ee3f
jmp 0x2ee69
leaq (%rcx,%rdx,8), %r14
movl %ebp, %edi
callq 0x2fe37
movq %rax, %r12
xorl %r13d, %r13d
movq %r13, 0x8(%rax)
movb %bpl, 0x10(%rax)
andb $-0x2, 0x11(%rax)
leaq 0x12(%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xe1e0
movq %r12, (%r14)
movq %r13, (%r12)
incl 0x4873a(%rip)           # 0x775d8
leaq 0x5e76f(%rip), %r13     # 0x8d614
movq %r12, %r14
incl (%r13)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/tokenize.c
// Function: built_in_token
struct token *built_in_token(int stream, struct ident *ident)
{
	struct token *token;

	token = __alloc_token(0);
	token->pos.stream = stream;
	token_type(token) = TOKEN_IDENT;
	token->ident = ident;
	return token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %edi, %edi
callq 0x2fe9a
shll $0x6, %r14d
andl $0xfffc0, %r14d         # imm = 0xFFFC0
movq $-0x100000, %rcx        # imm = 0xFFF00000
andq (%rax), %rcx
addq %r14, %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/tokenize.c
// Function: tokenize_buffer
struct token * tokenize_buffer(void *buffer, unsigned long size, struct token **endtoken)
{
	stream_t stream;
	struct token *begin;

	begin = setup_stream(&stream, 0, -1, buffer, size);
	*endtoken = tokenize_stream(&stream);
	return begin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
leaq 0x8(%rsp), %r14
movl $0x0, 0x1c(%r14)
movaps 0x1a576(%rip), %xmm0    # 0x49490
movups %xmm0, 0xc(%r14)
movq $0x0, 0x28(%r14)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%r14)
movl %esi, 0x8(%r14)
movq %rdi, 0x30(%r14)
xorl %edi, %edi
callq 0x2fe9a
movq %rax, %r15
movabsq $0x100100013, %rax      # imm = 0x100100013
movq %rax, (%r15)
leaq 0x8(%r15), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x2ef6e
movq %rax, (%rbx)
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/tokenize.c
// Function: tokenize
struct token * tokenize(const struct position *pos, const char *name, int fd, struct token *endtoken, const char **next_path)
{
	struct token *begin, *end;
	stream_t stream;
	unsigned char buffer[BUFSIZE];
	int idx;

	idx = init_stream(pos, name, fd, next_path);
	if (idx < 0) {
		// info(endtoken->pos, "File %s is const", name);
		return endtoken;
	}

	begin = setup_stream(&stream, idx, fd, buffer, 0);
	end = tokenize_stream(&stream);
	if (endtoken)
		end->next = endtoken;
	return begin;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rcx, %rbx
movl %edx, %ebp
movq %r8, %rcx
callq 0x2ec3a
testl %eax, %eax
js 0x2f47e
movl %eax, %r12d
leaq 0x8(%rsp), %r15
movl %eax, 0x14(%r15)
movq $0x1, 0x18(%r15)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xc(%r15)
xorl %eax, %eax
movq %rax, 0x28(%r15)
movl %ebp, (%r15)
movq %rax, 0x4(%r15)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%r15)
xorl %edi, %edi
callq 0x2fe9a
movq %rax, %r14
shll $0x6, %r12d
andl $0xfffc0, %r12d         # imm = 0xFFFC0
movabsq $0x100100013, %rax      # imm = 0x100100013
orq %r12, %rax
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x2ef6e
testq %rbx, %rbx
je 0x2f481
movq %rbx, 0x8(%rax)
jmp 0x2f481
movq %rbx, %r14
movq %r14, %rax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq