LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/symbol.c
// Function: check_declaration
void check_declaration(struct symbol *sym)
{
	int warned = 0;
	struct symbol *next = sym;

	while ((next = next->next_id) != NULL) {
		if (next->namespace != sym->namespace)
			continue;
		if (sym->scope == next->scope) {
			sym->same_symbol = next;
			inherit_declaration(sym, next);
			return;
		}
		/* Extern in block level matches a TOPLEVEL non-static symbol */
		if (sym->ctype.modifiers & MOD_EXTERN) {
			if ((next->ctype.modifiers & (MOD_TOPLEVEL|MOD_STATIC)) == MOD_TOPLEVEL) {
				sym->same_symbol = next;
				return;
			}
		}

		if (!Wshadow || warned)
			continue;
		if (get_sym_type(next) == SYM_FN)
			continue;
		warned = 1;
		warning(sym->pos, "symbol '%s' shadows an earlier one", show_ident(sym->ident));
		info(next->pos, "originally declared here");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r12
testq %r12, %r12
je 0x2bd40
movq %rdi, %rbx
leaq 0x3b1df(%rip), %r13     # 0x66e30
movl (%r13), %eax
leaq 0x1ba84(%rip), %r14     # 0x476e0
leaq 0x1baa0(%rip), %r15     # 0x47703
xorl %edx, %edx
movl (%rbx), %ecx
testl %eax, %eax
sete %dil
testl %edx, %edx
setne %sil
orb %dil, %sil
movl (%r12), %edx
movl %ecx, %edi
xorl %edx, %edi
testl $0x1ff00, %edi          # imm = 0x1FF00
jne 0x2bcb1
movq 0x30(%rbx), %rdi
cmpq 0x30(%r12), %rdi
je 0x2bd28
testb $0x8, 0x68(%rbx)
je 0x2bcac
movl 0x68(%r12), %edi
andl $0x14, %edi
cmpl $0x10, %edi
je 0x2bd3c
testb %sil, %sil
je 0x2bcc0
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x2bc76
jmp 0x2bd40
movq %r12, %rcx
cmpb $0x3, %dl
jne 0x2bcd0
movq 0x60(%r12), %rcx
movzbl (%rcx), %edx
movzbl %dl, %esi
cmpl $0x9, %esi
jne 0x2bcdf
movq 0x60(%rcx), %rcx
movzbl (%rcx), %esi
xorl %edx, %edx
cmpl $0x5, %esi
je 0x2bd18
movq 0x18(%rbx), %rdi
callq 0x2de35
movq 0x4(%rbx), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
movq 0x4(%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1178c
movl (%r13), %eax
movl $0x1, %edx
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x2bc65
jmp 0x2bd40
movq %r12, 0x38(%rbx)
movq 0x68(%r12), %rax
andl $0x11000000, %eax       # imm = 0x11000000
orq %rax, 0x68(%rbx)
jmp 0x2bd40
movq %r12, 0x38(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/symbol.c
// Function: bind_symbol_with_scope
void bind_symbol_with_scope(struct symbol *sym, struct ident *ident, enum namespace ns, struct scope *scope)
{
	if (sym->bound) {
		sparse_error(sym->pos, "internal error: symbol type already bound");
		return;
	}
	if (ident->reserved && (ns & (NS_TYPEDEF | NS_STRUCT | NS_LABEL | NS_SYMBOL))) {
		sparse_error(sym->pos, "Trying to use reserved word '%s' as identifier", show_ident(ident));
		return;
	}
	sym->namespace = ns;
	sym->next_id = ident->symbols;
	ident->symbols = sym;
	if (sym->ident && sym->ident != ident)
		warning(sym->pos, "Symbol '%s' already bound", show_ident(sym->ident));
	sym->ident = ident;
	sym->bound = 1;

	if (ns == NS_SYMBOL && toplevel(scope)) {
		unsigned mod = MOD_ADDRESSABLE | MOD_TOPLEVEL;

		inherit_static(sym);

		scope = global_scope;
		if (sym->ctype.modifiers & MOD_STATIC ||
		    is_extern_inline(sym)) {
			scope = file_scope;
			mod = MOD_TOPLEVEL;
		}
		sym->ctype.modifiers |= mod;
	}
	bind_scope(sym, scope);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
btl $0x15, %eax
jb 0x2bd9a
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testb $0x1e, %bpl
je 0x2bdb6
movb 0x11(%r15), %cl
andb $0x2, %cl
je 0x2bdb6
movq %r15, %rdi
callq 0x2de35
movq 0x4(%rbx), %rdi
leaq 0x1b9c0(%rip), %rsi     # 0x47746
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a80
movq 0x4(%rbx), %rdi
leaq 0x1b977(%rip), %rsi     # 0x4771c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a80
movl %ebp, %ecx
shll $0x8, %ecx
andl $0x1ff00, %ecx          # imm = 0x1FF00
andl $0xffde00ff, %eax       # imm = 0xFFDE00FF
orl %ecx, %eax
movl %eax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x20(%rbx)
movq %rbx, 0x8(%r15)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
sete %al
cmpq %r15, %rdi
sete %cl
orb %al, %cl
jne 0x2be04
callq 0x2de35
movq 0x4(%rbx), %rdi
leaq 0x1b97b(%rip), %rsi     # 0x47775
movq %rax, %rdx
xorl %eax, %eax
callq 0x118fc
movq %r15, 0x18(%rbx)
orb $0x20, 0x2(%rbx)
cmpl $0x10, %ebp
jne 0x2be74
leaq 0x37f80(%rip), %rax     # 0x63d98
movq (%rax), %rdx
cmpq %r14, %rdx
setne %cl
leaq 0x37f78(%rip), %rax     # 0x63da0
movq (%rax), %rax
cmpq %r14, %rax
setne %sil
testb %sil, %cl
jne 0x2be74
movq 0x68(%rbx), %rcx
testb $0xc, %cl
je 0x2be89
testb $0x4, %cl
jne 0x2be62
movl %ecx, %edi
notl %edi
movl $0x110, %esi            # imm = 0x110
testb $0x48, %dil
jne 0x2be6a
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2be6a
cmpb $0x5, (%rdi)
jne 0x2be6a
movl $0x10, %esi
movq %rdx, %rax
orq %rcx, %rsi
movq %rsi, 0x68(%rbx)
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22ca0
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x2be40
movl $0x1ff00, %edi          # imm = 0x1FF00
movl (%rsi), %r8d
andl %edi, %r8d
cmpl $0x1000, %r8d           # imm = 0x1000
jne 0x2beac
cmpq %rdx, 0x30(%rsi)
je 0x2beb7
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
jne 0x2be97
jmp 0x2be40
movq 0x68(%rsi), %rsi
andl $0x4, %esi
orq %rsi, %rcx
movq %rcx, 0x68(%rbx)
jmp 0x2be40
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/symbol.c
// Function: bind_symbol
void bind_symbol(struct symbol *sym, struct ident *ident, enum namespace ns)
{
	struct scope *scope = block_scope;;

	if (ns == NS_MACRO)
		scope = file_scope;
	if (ns == NS_LABEL)
		scope = function_scope;
	bind_symbol_with_scope(sym, ident, ns, scope);
}

// Assembly:
cmpl $0x8, %edx
jne 0x2bee3
leaq 0x37eba(%rip), %rax     # 0x63d90
movq (%rax), %rcx
movl $0x8, %edx
jmp 0x2bd4a
cmpl $0x1, %edx
jne 0x2bef1
leaq 0x37ea9(%rip), %rax     # 0x63d98
jmp 0x2bef8
leaq 0x37e90(%rip), %rax     # 0x63d88
movq (%rax), %rcx
jmp 0x2bd4a
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movl %edx, %ebx
movq %rsi, %r15
movl %edi, %r12d
movq %rsi, %rdi
callq 0x2e793
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x2bf40
movl %ebp, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl (%r14), %edx
movl %edx, %esi
shrl $0x8, %esi
testl %esi, %ecx
jne 0x2bf75
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x2bf2b
movl %r12d, %edi
movq %rax, %rsi
callq 0x2e87e
movq %rax, %r15
movq (%rax), %r12
xorl %edi, %edi
callq 0x2f92c
movq %rax, %r14
movb %bl, (%rax)
movq %r12, 0x4(%rax)
andb $-0x40, 0xc(%rax)
movq 0x10(%r15), %rsi
movq %rax, %rdi
movl %ebp, %edx
callq 0x2beca
jmp 0x2bf86
movl %edx, %eax
orl $0x20000, %eax          # imm = 0x20000
movl %eax, (%r14)
movzbl %dl, %ecx
cmpl %ebx, %ecx
jne 0x2bf92
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b7f6(%rip), %rdi     # 0x4778f
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x50(%rdi), %eax
testl %eax, %eax
jns 0x2c654
movzbl (%rbx), %ecx
cmpl $0x3, %ecx
jne 0x2c62e
movq 0x60(%rbx), %rcx
movzbl (%rcx), %ecx
cmpl $0x6, %ecx
jne 0x2c654
movq 0x18(%rbx), %rdi
callq 0x2de35
movq 0x4(%rbx), %rdi
leaq 0x1b20f(%rip), %rsi     # 0x47856
movq %rax, %rdx
xorl %eax, %eax
callq 0x11a80
movl 0x50(%rbx), %eax
cltq
cmpq %rax, 0x8(%r14)
jae 0x2c660
movq %rax, 0x8(%r14)
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movzbl (%rdi), %ecx
movq %rdi, %rax
cmpl $0x3, %ecx
jne 0x2c68a
movq 0x60(%rdi), %rax
movzbl (%rax), %ecx
addl $-0x7, %ecx
cmpl $0x1, %ecx
ja 0x2c6f8
movq 0x98(%rax), %rbx
testq %rbx, %rbx
je 0x2c6f8
movq 0x68(%rdi), %r14
andl $0xe00, %r14d           # imm = 0xE00
movq %rbx, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x2c6ef
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x2c6cb
testq %rdi, %rdi
je 0x2c6e0
cmpb $0x3, (%rdi)
jne 0x2c704
orq %r14, 0x68(%rdi)
cmpq $0x0, 0x18(%rdi)
jne 0x2c6e0
callq 0x2c670
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x2c6b7
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x2c6ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b171(%rip), %rdi     # 0x4787c
leaq 0x1b180(%rip), %rsi     # 0x47892
leaq 0x1b182(%rip), %rcx     # 0x4789b
movl $0xc3, %edx
callq 0xe120
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2df07(%rip), %rcx     # 0x5a740
movq (%rcx,%rax,8), %rax
movq %rax, 0x37efc(%rip)     # 0x64740
movl 0x4(%rax), %ecx
leaq 0x33d12(%rip), %rdx     # 0x60560
movl %ecx, (%rdx)
movzbl 0x8(%rax), %eax
movl %eax, %ecx
andl $0x1, %ecx
leaq 0x3a538(%rip), %rdx     # 0x66d98
movl %ecx, (%rdx)
shrl %eax
andl $0x1, %eax
leaq 0x3a56e(%rip), %rcx     # 0x66ddc
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3eccd(%rip), %rax     # 0x6b738
leaq 0x37c4e(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3ee7c(%rip), %rcx     # 0x6b8f8
leaq 0x37c45(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x37c43(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x37c41(%rip), %rdx     # 0x646d8
movq %rcx, (%rdx)
leaq 0x33ac3(%rip), %rdx     # 0x60564
cmpl $0x1, (%rdx)
jne 0x2cadc
leaq 0x3ef2b(%rip), %rdx     # 0x6b9d8
leaq 0x37b9c(%rip), %rsi     # 0x64650
movq %rdx, (%rsi)
leaq 0x3f0da(%rip), %rdx     # 0x6bb98
leaq 0x37b93(%rip), %rsi     # 0x64658
movq %rdx, (%rsi)
leaq 0x37be1(%rip), %rdx     # 0x646b0
movq %rax, (%rdx)
leaq 0x37bdf(%rip), %rax     # 0x646b8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1afbe(%rip), %rdi     # 0x47aa3
leaq 0x1e737(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1afa9(%rip), %rdi     # 0x47aab
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x33a44(%rip), %rax     # 0x6055c
movl (%rax), %eax
testl %eax, %eax
je 0x2cb4b
cmpl $0x2, %eax
je 0x2cb42
cmpl $0x1, %eax
jne 0x2cb65
leaq 0x1af95(%rip), %rdi     # 0x47ac4
leaq 0x1e6ed(%rip), %rdx     # 0x4b223
movl $0x1, %esi
xorl %eax, %eax
callq 0x1eec8
leaq 0x1af86(%rip), %rdi     # 0x47acf
jmp 0x2cb52
leaq 0x1af64(%rip), %rdi     # 0x47ab6
leaq 0x1e6ca(%rip), %rdx     # 0x4b223
movl $0x1, %esi
xorl %eax, %eax
callq 0x1eec8
leaq 0x3a22c(%rip), %rax     # 0x66d98
cmpl $0x0, (%rax)
leaq 0x1af6d(%rip), %rax     # 0x47ae3
leaq 0x1af5c(%rip), %rdi     # 0x47ad9
cmoveq %rax, %rdi
leaq 0x1e69b(%rip), %rdx     # 0x4b223
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x1eec8
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3a1e8(%rip), %rax     # 0x66d9c
movslq (%rax), %r15
leaq 0x2e062(%rip), %rax     # 0x5ac20
movq (%rax,%r15,8), %rbx
leaq 0x1af35(%rip), %rdi     # 0x47afe
leaq 0x1e653(%rip), %r14     # 0x4b223
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x3a1b2(%rip), %rax     # 0x66d98
cmpl $0x0, (%rax)
leaq 0x1af28(%rip), %rax     # 0x47b18
leaq 0x1af13(%rip), %rdi     # 0x47b0a
cmoveq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
movl $0x7b, %eax
btq %r15, %rax
jb 0x2cc28
leaq 0x1af0d(%rip), %rdi     # 0x47b26
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1f414
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3eac9(%rip), %rax     # 0x6b738
leaq 0x41312(%rip), %rcx     # 0x6df88
movq %rax, (%rcx)
leaq 0x3ec78(%rip), %rcx     # 0x6b8f8
leaq 0x41309(%rip), %rdx     # 0x6df90
movq %rcx, (%rdx)
leaq 0x3ed47(%rip), %rdx     # 0x6b9d8
leaq 0x37990(%rip), %rsi     # 0x64628
movq %rdx, (%rsi)
leaq 0x3eef6(%rip), %rdx     # 0x6bb98
leaq 0x37977(%rip), %rsi     # 0x64620
movq %rdx, (%rsi)
leaq 0x3e9a5(%rip), %rdx     # 0x6b658
leaq 0x379a6(%rip), %rsi     # 0x64660
movq %rdx, (%rsi)
leaq 0x379fc(%rip), %rdx     # 0x646c0
movq %rax, (%rdx)
leaq 0x379fa(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x379f8(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x379f6(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ea31(%rip), %rax     # 0x6b738
leaq 0x379b2(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3ebe0(%rip), %rcx     # 0x6b8f8
leaq 0x379a9(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x379a7(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x379a5(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e9dd(%rip), %rax     # 0x6b738
leaq 0x3795e(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3eb8c(%rip), %rcx     # 0x6b8f8
leaq 0x37955(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x37953(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x37951(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ae44(%rip), %rdi     # 0x47c5c
leaq 0x1e404(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x3f703(%rip), %r15     # 0x6c538
movl 0x50(%r15), %ecx
leaq 0x1ae25(%rip), %rdi     # 0x47c65
leaq 0x148aa(%rip), %r14     # 0x416f1
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x3e8db(%rip), %rax     # 0x6b738
movl 0x50(%rax), %ecx
leaq 0x1ae05(%rip), %rdi     # 0x47c6c
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x3eb5b(%rip), %rax     # 0x6b9d8
movl 0x50(%rax), %ecx
leaq 0x1adf1(%rip), %rdi     # 0x47c78
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
movl 0x50(%r15), %ecx
leaq 0x1ade4(%rip), %rdi     # 0x47c85
movl $0x1, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x39ee1(%rip), %rax     # 0x66d98
cmpl $0x0, (%rax)
leaq 0x1ade5(%rip), %rax     # 0x47ca6
leaq 0x1adca(%rip), %rdi     # 0x47c92
cmoveq %rax, %rdi
leaq 0x1add2(%rip), %rax     # 0x47ca5
leaq 0x1adb7(%rip), %r14     # 0x47c91
cmoveq %rax, %r14
leaq 0x1adc9(%rip), %rax     # 0x47cae
leaq 0x1adae(%rip), %r15     # 0x47c9a
cmoveq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
movq %r15, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1eec8
// File: /workspace/github_c_makefile_star2_O3/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 0x3e809(%rip), %rax     # 0x6b738
leaq 0x3778a(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e9b8(%rip), %rcx     # 0x6b8f8
leaq 0x37781(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x3777f(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x3777d(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x376fb(%rip), %rax     # 0x64660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e76d(%rip), %rax     # 0x6b738
leaq 0x376ee(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e91c(%rip), %rcx     # 0x6b8f8
leaq 0x376e5(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x376e3(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x376e1(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad13(%rip), %rdi     # 0x47d19
leaq 0x1e216(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1acfe(%rip), %rdi     # 0x47d21
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1acf2(%rip), %rdi     # 0x47d2b
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ace4(%rip), %rdi     # 0x47d33
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x39d33(%rip), %rax     # 0x66d98
cmpl $0x0, (%rax)
leaq 0x1acf6(%rip), %rax     # 0x47d65
leaq 0x1acc7(%rip), %rdi     # 0x47d3d
cmoveq %rax, %rdi
leaq 0x1acfa(%rip), %rax     # 0x47d7b
leaq 0x1acc8(%rip), %r14     # 0x47d50
cmoveq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1eec8
// File: /workspace/github_c_makefile_star2_O3/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 0x3e67d(%rip), %rax     # 0x6b738
leaq 0x375fe(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e82c(%rip), %rcx     # 0x6b8f8
leaq 0x375f5(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x375f3(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x375f1(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x3756f(%rip), %rax     # 0x64660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e61d(%rip), %rax     # 0x6b738
leaq 0x3759e(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e7cc(%rip), %rcx     # 0x6b8f8
leaq 0x37595(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x37593(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x37591(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1aca9(%rip), %rdi     # 0x47e0b
leaq 0x1e0ba(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ac9a(%rip), %rdi     # 0x47e19
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ac8e(%rip), %rdi     # 0x47e23
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ac82(%rip), %rdi     # 0x47e2d
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
popq %rbx
jmp 0x2d1bd
// File: /workspace/github_c_makefile_star2_O3/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 0x1abe0(%rip), %rdi     # 0x47da5
leaq 0x1e057(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1abcf(%rip), %rdi     # 0x47db1
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1abc3(%rip), %rdi     # 0x47dbb
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1abb5(%rip), %rdi     # 0x47dc3
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1aba7(%rip), %rdi     # 0x47dcb
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ab97(%rip), %rdi     # 0x47dd1
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x39b48(%rip), %rax     # 0x66d98
cmpl $0x0, (%rax)
je 0x2d26f
leaq 0x1ab7f(%rip), %rdi     # 0x47ddb
leaq 0x1dfc0(%rip), %rdx     # 0x4b223
movl $0x1, %esi
xorl %eax, %eax
callq 0x1eec8
leaq 0x3f102(%rip), %rax     # 0x6c378
cmpl $0x80, 0x50(%rax)
jne 0x2d2b3
leaq 0x1ab61(%rip), %rdi     # 0x47de7
leaq 0x1df96(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1ab54(%rip), %rdi     # 0x47df7
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x1eec8
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x3e479(%rip), %rax     # 0x6b738
leaq 0x373fa(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e628(%rip), %rcx     # 0x6b8f8
leaq 0x373f1(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x373ef(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x373ed(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x39aa7(%rip), %rax     # 0x66d9c
cmpl $0x0, (%rax)
jne 0x2d300
movl $0x5, (%rax)
leaq 0x39ac5(%rip), %rcx     # 0x66dcc
cmpl $0x0, (%rcx)
je 0x2d312
movl $0x6, (%rax)
cmpl $0x0, 0x40c7f(%rip)     # 0x6df98
je 0x2d31c
retq
movl 0x10(%rdi), %eax
movl %eax, 0x40c73(%rip)     # 0x6df98
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x40c5a(%rip)     # 0x6df98
movl $0x8, %r12d
leaq 0x2e195(%rip), %r13     # 0x5b4e0
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 0x2d379
addq $0x10, %r12
cmpq $0x58, %r12
jne 0x2d34b
jmp 0x2d3e3
movl (%r12,%r13), %ebp
movl %ebp, 0x40c15(%rip)     # 0x6df98
addq %r14, %rbx
movl $0x8, %r12d
leaq 0x2e19d(%rip), %r13     # 0x5b530
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 0x2d3c2
orl (%r12,%r13), %ebp
movl %ebp, 0x40bd9(%rip)     # 0x6df98
addq %r14, %rbx
addq $0x10, %r12
cmpq $0x98, %r12
jne 0x2d393
cmpb $0x0, (%rbx)
jne 0x2d3e3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x32c0e(%rip), %rax     # 0x5fff8
movq (%rax), %rdi
leaq 0x1aa63(%rip), %rsi     # 0x47e57
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_O3/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 0x39717(%rip), %rax     # 0x66d9c
cmpl $0x0, (%rax)
jne 0x2d690
movl $0x5, (%rax)
leaq 0x39735(%rip), %rcx     # 0x66dcc
cmpl $0x0, (%rcx)
je 0x2d6a2
movl $0x6, (%rax)
cmpl $0x0, 0x408ef(%rip)     # 0x6df98
je 0x2d6ac
retq
movl 0x10(%rdi), %eax
movl %eax, 0x408e3(%rip)     # 0x6df98
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3e079(%rip), %rax     # 0x6b738
leaq 0x408c2(%rip), %rcx     # 0x6df88
movq %rax, (%rcx)
leaq 0x3e228(%rip), %rcx     # 0x6b8f8
leaq 0x408b9(%rip), %rdx     # 0x6df90
movq %rcx, (%rdx)
leaq 0x36fdf(%rip), %rdx     # 0x646c0
movq %rax, (%rdx)
leaq 0x36fdd(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x36fdb(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x36fd9(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e4f9(%rip), %rax     # 0x6bc78
leaq 0x36eba(%rip), %rcx     # 0x64640
movq %rax, (%rcx)
leaq 0x3e6a8(%rip), %rax     # 0x6be38
leaq 0x36eb1(%rip), %rcx     # 0x64648
movq %rax, (%rcx)
leaq 0x3df97(%rip), %rax     # 0x6b738
leaq 0x407e0(%rip), %rcx     # 0x6df88
movq %rax, (%rcx)
leaq 0x3e146(%rip), %rcx     # 0x6b8f8
leaq 0x407d7(%rip), %rdx     # 0x6df90
movq %rcx, (%rdx)
leaq 0x36efd(%rip), %rdx     # 0x646c0
movq %rax, (%rdx)
leaq 0x36efb(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x36ef9(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x36ef7(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x3e1ed(%rip), %rax     # 0x6b9d8
leaq 0x36e6e(%rip), %rcx     # 0x64660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3df1d(%rip), %rax     # 0x6b738
leaq 0x36e9e(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3e0cc(%rip), %rcx     # 0x6b8f8
leaq 0x36e95(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x36e93(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x36e91(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
cmpl $0x0, 0x4074b(%rip)     # 0x6df9c
jne 0x2d85d
movl $0x8, 0x4073f(%rip)     # 0x6df9c
leaq 0x32d00(%rip), %rax     # 0x60564
cmpl $0x9, (%rax)
jne 0x2d8ab
leaq 0x3e168(%rip), %rax     # 0x6b9d8
leaq 0x36df1(%rip), %rcx     # 0x64668
movq %rax, (%rcx)
leaq 0x36ddf(%rip), %rcx     # 0x64660
movq %rax, (%rcx)
leaq 0x36e99(%rip), %rax     # 0x64724
movl $0x80, (%rax)
leaq 0x36e90(%rip), %rax     # 0x64728
movl $0x10, (%rax)
leaq 0x39537(%rip), %rax     # 0x66ddc
movl $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a694(%rip), %rdi     # 0x47f96
leaq 0x1d91a(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1a681(%rip), %rdi     # 0x47fa0
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1a66d(%rip), %rdi     # 0x47fa2
callq 0x1f3e9
movl 0x4065c(%rip), %esi     # 0x6df9c
leaq 0x1a661(%rip), %rdi     # 0x47fa8
xorl %eax, %eax
callq 0x1f4c6
movl 0x40648(%rip), %esi     # 0x6df9c
leaq 0x1a65b(%rip), %rdi     # 0x47fb6
xorl %eax, %eax
callq 0x1f4c6
movl 0x40634(%rip), %esi     # 0x6df9c
leaq 0x1a654(%rip), %rdi     # 0x47fc3
xorl %eax, %eax
popq %rbx
jmp 0x1f4c6
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3ddb9(%rip), %rax     # 0x6b738
leaq 0x36d3a(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3df68(%rip), %rcx     # 0x6b8f8
leaq 0x36d31(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x36d2f(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x36d2d(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
jmp 0x2dc1e
// File: /workspace/github_c_makefile_star2_O3/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 0x1a45c(%rip), %rdi     # 0x48021
leaq 0x1d657(%rip), %rbx     # 0x4b223
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1a44a(%rip), %rdi     # 0x4802c
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1a43d(%rip), %rdi     # 0x48035
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1eec8
leaq 0x1a431(%rip), %rdi     # 0x4803f
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x1eec8
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x3293f(%rip), %rax     # 0x60564
movl (%rax), %eax
cmpl $0x8, %eax
je 0x2dc56
cmpl $0x5, %eax
je 0x2dc46
cmpl $0x3, %eax
jne 0x2dcb5
leaq 0x3da1b(%rip), %rax     # 0x6b658
leaq 0x36a1c(%rip), %rcx     # 0x64660
jmp 0x2dcb2
leaq 0x3daeb(%rip), %rax     # 0x6b738
leaq 0x36a14(%rip), %rcx     # 0x64668
jmp 0x2dcb2
leaq 0x3df3b(%rip), %rax     # 0x6bb98
leaq 0x369bc(%rip), %rcx     # 0x64620
movq %rax, (%rcx)
leaq 0x3dd6a(%rip), %rax     # 0x6b9d8
leaq 0x369b3(%rip), %rcx     # 0x64628
movq %rax, (%rcx)
leaq 0x3dab9(%rip), %rax     # 0x6b738
leaq 0x369da(%rip), %rcx     # 0x64660
movq %rax, (%rcx)
leaq 0x369d8(%rip), %rcx     # 0x64668
movq %rax, (%rcx)
leaq 0x3d7fe(%rip), %rax     # 0x6b498
leaq 0x36a1f(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3d9ad(%rip), %rax     # 0x6b658
leaq 0x36a16(%rip), %rcx     # 0x646c8
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
callq 0x2dc1e
leaq 0x36a55(%rip), %rax     # 0x64718
movl $0x8, (%rax)
leaq 0x3da68(%rip), %rax     # 0x6b738
leaq 0x369e9(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3dc17(%rip), %rcx     # 0x6b8f8
leaq 0x369e0(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x369de(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x369dc(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x3dcd2(%rip), %rax     # 0x6b9d8
leaq 0x36953(%rip), %rcx     # 0x64660
movq %rax, (%rcx)
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3da1d(%rip), %rax     # 0x6b738
leaq 0x3699e(%rip), %rcx     # 0x646c0
movq %rax, (%rcx)
leaq 0x3dbcc(%rip), %rcx     # 0x6b8f8
leaq 0x36995(%rip), %rdx     # 0x646c8
movq %rcx, (%rdx)
leaq 0x36993(%rip), %rdx     # 0x646d0
movq %rax, (%rdx)
leaq 0x36991(%rip), %rax     # 0x646d8
movq %rcx, (%rax)
leaq 0x3dc87(%rip), %rax     # 0x6b9d8
leaq 0x36908(%rip), %rcx     # 0x64660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x401af(%rip)     # 0x6dfb0
movb $0x0, 0x401a9(%rip)     # 0x6dfb1
cmpl $0x100, %edi            # imm = 0x100
jl 0x2de2d
addl $0xffffff00, %edi       # imm = 0xFFFFFF00
leaq 0x36a43(%rip), %rax     # 0x64860
leaq (%rax,%rdi,4), %rsi
leaq 0x40188(%rip), %rdi     # 0x6dfb0
jmp 0xe090
leaq 0x4017c(%rip), %rax     # 0x6dfb0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a59d(%rip), %rax     # 0x48427
testq %rdi, %rdi
je 0x2df8f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
je 0x2df81
movb $0x22, 0x4051c(%rip)    # 0x6e3d0
testl $0x7ffffffe, (%rbx)     # imm = 0x7FFFFFFE
je 0x2df6d
leaq 0x4050a(%rip), %r14     # 0x6e3d1
callq 0xe300
movq %rax, %r15
leaq 0x1a62b(%rip), %r12     # 0x48501
leaq 0x1a627(%rip), %r13     # 0x48504
xorl %ebp, %ebp
movb 0x4(%rbx,%rbp), %al
movzbl %al, %edx
movq (%r15), %rcx
testb $0x40, 0x1(%rcx,%rdx,2)
jne 0x2df0a
movzbl 0x5(%rbx,%rbp), %eax
movb $0x5c, (%r14)
cmpl $0x9, %edx
je 0x2df23
cmpl $0xa, %edx
jne 0x2df2e
movb $0x6e, 0x1(%r14)
jmp 0x2df28
cmpl $0x5c, %edx
je 0x2df14
cmpl $0x22, %edx
jne 0x2df1b
movb $0x5c, (%r14)
incq %r14
movb %al, (%r14)
incq %r14
jmp 0x2df55
movb $0x74, 0x1(%r14)
addq $0x2, %r14
jmp 0x2df55
incq %r14
movq (%r15), %rcx
testb $0x8, 0x1(%rcx,%rax,2)
jne 0x2df43
movq %r14, %rdi
movq %r12, %rsi
jmp 0x2df49
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 0x2dedf
jmp 0x2df74
leaq 0x4045d(%rip), %r14     # 0x6e3d1
movw $0x22, (%r14)
leaq 0x4044f(%rip), %rax     # 0x6e3d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e5fe
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 0x2e5d7
imull $0xcc5d000b, %ecx, %eax # imm = 0xCC5D000B
shrl $0x1a, %eax
leaq 0x3615b(%rip), %rcx     # 0x64760
leaq (%rcx,%rax,4), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f97a(%rip), %ebx     # 0x6dfa0
movq 0x3f97b(%rip), %rax     # 0x6dfa8
cmpl 0x47f9d(%rip), %ebx     # 0x765d0
jl 0x2e67f
leal (,%rbx,4), %ecx
movl $0xaaaaaaab, %r13d      # imm = 0xAAAAAAAB
imulq %rcx, %r13
shrq $0x21, %r13
movq %r13, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %rsi
addq $0x320, %rsi            # imm = 0x320
movq %rax, %rdi
callq 0xe230
movq %rax, 0x3f93d(%rip)     # 0x6dfa8
testq %rax, %rax
je 0x2e732
addl $0xa, %r13d
movl %r13d, 0x47f51(%rip)    # 0x765d0
movslq %ebx, %rcx
leaq (%rcx,%rcx,4), %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rdx)
movups %xmm0, 0x10(%rax,%rdx)
movups %xmm0, 0x20(%rax,%rdx)
movups %xmm0, 0x40(%rax,%rdx)
movups %xmm0, 0x30(%rax,%rdx)
movq %r14, 0x8(%rax,%rdx)
movl %ebp, (%rax,%rdx)
movq %r12, 0x18(%rax,%rdx)
movl $0x0, 0x28(%rax,%rdx)
testq %r15, %r15
je 0x2e6c8
movq (%r15), %rax
jmp 0x2e6cd
movl $0xfffc0, %eax          # imm = 0xFFFC0
movq %rax, 0x20(%rcx)
leal 0x1(%rbx), %eax
movl %eax, 0x3f8c6(%rip)     # 0x6dfa0
movb (%r14), %sil
xorl %eax, %eax
testb %sil, %sil
je 0x2e711
incq %r14
movzbl %sil, %edx
movl %edx, %esi
shll $0x4, %esi
addl %eax, %esi
shrl $0x4, %edx
addl %esi, %edx
leal (%rdx,%rdx,4), %eax
leal (%rdx,%rax,2), %eax
movb (%r14), %sil
incq %r14
testb %sil, %sil
jne 0x2e6e7
imull $0xcc5d000b, %edx, %eax # imm = 0xCC5D000B
shrl $0x1a, %eax
leaq 0x36048(%rip), %rdx     # 0x64760
movl (%rdx,%rax,4), %esi
movl %esi, 0x30(%rcx)
movl %ebx, (%rdx,%rax,4)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19d70(%rip), %rdi     # 0x484a9
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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 0x47df5(%rip), %rcx     # 0x765e0
movq (%rcx,%rdx,8), %rax
movslq %esi, %r15
testq %rax, %rax
je 0x2e824
leaq 0x47dd6(%rip), %r13     # 0x765d4
movq %rax, %r14
cmpb %bpl, 0x10(%rax)
jne 0x2e81a
leaq 0x12(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe080
testl %eax, %eax
je 0x2e868
movq (%r14), %rax
testq %rax, %rax
jne 0x2e7fe
jmp 0x2e828
leaq (%rcx,%rdx,8), %r14
movl %r15d, %edi
callq 0x2f803
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 0x47d7a(%rip)           # 0x765d8
leaq 0x5ddaf(%rip), %r13     # 0x8c614
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_O3/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 0x19b16(%rip), %xmm0    # 0x483f0
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 0x2f866
movq %rax, %r15
movabsq $0x100100013, %rax      # imm = 0x100100013
movq %rax, (%r15)
leaq 0x8(%r15), %rax
movq %rax, 0x20(%r14)
movq %r14, %rdi
callq 0x2e92e
movq %rax, (%rbx)
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e60a
testl %eax, %eax
js 0x2edf4
movl %eax, %r15d
leaq 0x8(%rsp), %r12
movl %eax, 0x14(%r12)
movq $0x1, 0x18(%r12)
movq $0x0, 0x28(%r12)
movl %ebp, (%r12)
movaps 0x19660(%rip), %xmm0    # 0x48400
movups %xmm0, 0x4(%r12)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%r12)
xorl %edi, %edi
callq 0x2f866
movq %rax, %r14
shll $0x6, %r15d
andl $0xfffc0, %r15d         # imm = 0xFFFC0
movabsq $0x100100013, %rax      # imm = 0x100100013
orq %r15, %rax
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rax
movq %rax, 0x20(%r12)
movq %r12, %rdi
callq 0x2e92e
testq %rbx, %rbx
je 0x2edf7
movq %rbx, 0x8(%rax)
jmp 0x2edf7
movq %rbx, %r14
movq %r14, %rax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq