LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x27c65
movq 0x60(%rdi), %rax
movzbl (%rax), %ecx
addl $-0x7, %ecx
cmpl $0x1, %ecx
ja 0x27cc9
movq 0x98(%rax), %rbx
testq %rbx, %rbx
je 0x27cc9
movq 0x68(%rdi), %r14
andl $0xe00, %r14d           # imm = 0xE00
movq %rbx, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0x27cc0
movq 0x18(%r15,%r12,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0x27ca6
testq %rdi, %rdi
je 0x27cbb
cmpb $0x3, (%rdi)
jne 0x27cd5
orq %r14, 0x68(%rdi)
cmpq $0x0, 0x18(%rdi)
jne 0x27cbb
callq 0x27c4b
incq %r12
jmp 0x27c8a
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x27c87
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18d70(%rip), %rdi     # 0x40a4c
leaq 0x18d7f(%rip), %rsi     # 0x40a62
leaq 0x18d81(%rip), %rcx     # 0x40a6b
movl $0xc3, %edx
callq 0xe120
// File: /workspace/github_c_makefile_star2_O2/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 0x2c92f(%rip), %rcx     # 0x54740
movq (%rcx,%rax,8), %rax
movq %rax, 0x36924(%rip)     # 0x5e740
movl 0x4(%rax), %ecx
leaq 0x3273a(%rip), %rdx     # 0x5a560
movl %ecx, (%rdx)
movzbl 0x8(%rax), %eax
movl %eax, %ecx
andl $0x1, %ecx
leaq 0x38f60(%rip), %rdx     # 0x60d98
movl %ecx, (%rdx)
shrl %eax
andl $0x1, %eax
leaq 0x38f96(%rip), %rcx     # 0x60ddc
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d6f9(%rip), %rax     # 0x65738
leaq 0x3667a(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d8a8(%rip), %rcx     # 0x658f8
leaq 0x36671(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x3666f(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x3666d(%rip), %rdx     # 0x5e6d8
movq %rcx, (%rdx)
leaq 0x324ef(%rip), %rdx     # 0x5a564
cmpl $0x1, (%rdx)
jne 0x280b0
leaq 0x3d957(%rip), %rdx     # 0x659d8
leaq 0x365c8(%rip), %rsi     # 0x5e650
movq %rdx, (%rsi)
leaq 0x3db06(%rip), %rdx     # 0x65b98
leaq 0x365bf(%rip), %rsi     # 0x5e658
movq %rdx, (%rsi)
leaq 0x3660d(%rip), %rdx     # 0x5e6b0
movq %rax, (%rdx)
leaq 0x3660b(%rip), %rax     # 0x5e6b8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-arm.c
// Function: predefine_arm
static void predefine_arm(const struct target *self)
{
	predefine("__arm__", 1, "1");
	predefine("__VFP_FP__", 1, "1");

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x18bb8(%rip), %rdi     # 0x40c73
leaq 0x1c3b1(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x18ba3(%rip), %rdi     # 0x40c7b
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x32471(%rip), %rax     # 0x5a55c
movl (%rax), %eax
testl %eax, %eax
je 0x2811c
cmpl $0x2, %eax
je 0x28113
cmpl $0x1, %eax
jne 0x28134
leaq 0x18b92(%rip), %rdi     # 0x40c94
leaq 0x1c36a(%rip), %rdx     # 0x44473
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x1c59c
leaq 0x18b85(%rip), %rdi     # 0x40c9f
jmp 0x28123
leaq 0x18b63(%rip), %rdi     # 0x40c86
leaq 0x1c349(%rip), %rdx     # 0x44473
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x1c59c
leaq 0x38c5d(%rip), %rax     # 0x60d98
cmpl $0x0, (%rax)
leaq 0x18b6e(%rip), %rax     # 0x40cb3
leaq 0x18b5d(%rip), %rdi     # 0x40ca9
cmoveq %rax, %rdi
leaq 0x1c31c(%rip), %rdx     # 0x44473
xorl %esi, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c59c
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x38c14(%rip), %rax     # 0x60d9c
movslq (%rax), %r15
leaq 0x2ca8e(%rip), %rax     # 0x54c20
movq (%rax,%r15,8), %rbx
leaq 0x18b31(%rip), %rdi     # 0x40cce
leaq 0x1c2cf(%rip), %r14     # 0x44473
pushq $0x1
popq %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x38be0(%rip), %rax     # 0x60d98
cmpl $0x0, (%rax)
leaq 0x18b26(%rip), %rax     # 0x40ce8
leaq 0x18b11(%rip), %rdi     # 0x40cda
cmoveq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
pushq $0x7b
popq %rax
btq %r15, %rax
jb 0x281f8
leaq 0x18b0d(%rip), %rdi     # 0x40cf6
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1cabc
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3d4f5(%rip), %rax     # 0x65738
leaq 0x3fd3e(%rip), %rcx     # 0x67f88
movq %rax, (%rcx)
leaq 0x3d6a4(%rip), %rcx     # 0x658f8
leaq 0x3fd35(%rip), %rdx     # 0x67f90
movq %rcx, (%rdx)
leaq 0x3d773(%rip), %rdx     # 0x659d8
leaq 0x363bc(%rip), %rsi     # 0x5e628
movq %rdx, (%rsi)
leaq 0x3d922(%rip), %rdx     # 0x65b98
leaq 0x363a3(%rip), %rsi     # 0x5e620
movq %rdx, (%rsi)
leaq 0x3d3d1(%rip), %rdx     # 0x65658
leaq 0x363d2(%rip), %rsi     # 0x5e660
movq %rdx, (%rsi)
leaq 0x36428(%rip), %rdx     # 0x5e6c0
movq %rax, (%rdx)
leaq 0x36426(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x36424(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x36422(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d45d(%rip), %rax     # 0x65738
leaq 0x363de(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d60c(%rip), %rcx     # 0x658f8
leaq 0x363d5(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x363d3(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x363d1(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d40d(%rip), %rax     # 0x65738
leaq 0x3638e(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d5bc(%rip), %rcx     # 0x658f8
leaq 0x36385(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x36383(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x36381(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-mips.c
// Function: predefine_mips
static void predefine_mips(const struct target *self)
{
	predefine("__mips__", 1, "1");
	predefine("__mips", 1, "%d", ptr_ctype.bit_size);
	predefine("_MIPS_SZINT", 1, "%d", int_ctype.bit_size);
	predefine("_MIPS_SZLONG", 1, "%d", long_ctype.bit_size);
	predefine("_MIPS_SZPTR", 1, "%d", ptr_ctype.bit_size);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x18a44(%rip), %rdi     # 0x40e2c
leaq 0x1c084(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x3e133(%rip), %r15     # 0x66538
movl 0x50(%r15), %ecx
leaq 0x18a25(%rip), %rdi     # 0x40e35
leaq 0x1233a(%rip), %r14     # 0x3a751
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x3d30e(%rip), %rax     # 0x65738
movl 0x50(%rax), %ecx
leaq 0x18a08(%rip), %rdi     # 0x40e3c
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x3d591(%rip), %rax     # 0x659d8
movl 0x50(%rax), %ecx
leaq 0x189f7(%rip), %rdi     # 0x40e48
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
movl 0x50(%r15), %ecx
leaq 0x189ed(%rip), %rdi     # 0x40e55
movl %ebp, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x3891d(%rip), %rax     # 0x60d98
cmpl $0x0, (%rax)
leaq 0x189f1(%rip), %rax     # 0x40e76
leaq 0x189d6(%rip), %rdi     # 0x40e62
cmoveq %rax, %rdi
leaq 0x189de(%rip), %rax     # 0x40e75
leaq 0x189c3(%rip), %r14     # 0x40e61
cmoveq %rax, %r14
leaq 0x189d5(%rip), %rax     # 0x40e7e
leaq 0x189ba(%rip), %r15     # 0x40e6a
cmoveq %rax, %r15
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c59c
// File: /workspace/github_c_makefile_star2_O2/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 0x3d249(%rip), %rax     # 0x65738
leaq 0x361ca(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d3f8(%rip), %rcx     # 0x658f8
leaq 0x361c1(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x361bf(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x361bd(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
leaq 0x3613b(%rip), %rax     # 0x5e660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d1ad(%rip), %rax     # 0x65738
leaq 0x3612e(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d35c(%rip), %rcx     # 0x658f8
leaq 0x36125(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x36123(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x36121(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-nios2.c
// Function: predefine_nios2
static void predefine_nios2(const struct target *self)
{
	predefine("__NIOS2", 1, "1");
	predefine("__NIOS2__", 1, "1");
	predefine("__nios2", 1, "1");
	predefine("__nios2__", 1, "1");

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x18923(%rip), %rdi     # 0x40ee9
leaq 0x1bea6(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x1890e(%rip), %rdi     # 0x40ef1
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x18905(%rip), %rdi     # 0x40efb
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x188fa(%rip), %rdi     # 0x40f03
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x3877c(%rip), %rax     # 0x60d98
cmpl $0x0, (%rax)
leaq 0x1890f(%rip), %rax     # 0x40f35
leaq 0x188e0(%rip), %rdi     # 0x40f0d
cmoveq %rax, %rdi
leaq 0x18913(%rip), %rax     # 0x40f4b
leaq 0x188e1(%rip), %r14     # 0x40f20
cmoveq %rax, %r14
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1c59c
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3d0cd(%rip), %rax     # 0x65738
leaq 0x3604e(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d27c(%rip), %rcx     # 0x658f8
leaq 0x36045(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x36043(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x36041(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
leaq 0x35fbf(%rip), %rax     # 0x5e660
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d06d(%rip), %rax     # 0x65738
leaq 0x35fee(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d21c(%rip), %rcx     # 0x658f8
leaq 0x35fe5(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x35fe3(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x35fe1(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-ppc.c
// Function: predefine_ppc64
static void predefine_ppc64(const struct target *self)
{
	predefine("__powerpc64__", 1, "1");
	predefine("__ppc64__", 1, "1");
	predefine("__PPC64__", 1, "1");
	predefine("_ARCH_PPC64", 1, "1");

	predefine_ppc(self);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x188c7(%rip), %rdi     # 0x40fdb
leaq 0x1bd58(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x188b8(%rip), %rdi     # 0x40fe9
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x188af(%rip), %rdi     # 0x40ff3
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x188a6(%rip), %rdi     # 0x40ffd
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2876b
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-ppc.c
// Function: predefine_ppc
static void predefine_ppc(const struct target *self)
{
	predefine("__powerpc__", 1, "1");
	predefine("__powerpc", 1, "1");
	predefine("__ppc__", 1, "1");
	predefine("__PPC__", 1, "1");
	predefine("__PPC", 1, "1");
	predefine("_ARCH_PPC", 1, "1");
	if (arch_big_endian)
		predefine("_BIG_ENDIAN", 1, "1");
	if (ldouble_ctype.bit_size == 128) {
		predefine("__LONGDOUBLE128", 1, "1");
		predefine("__LONG_DOUBLE_128__", 1, "1");
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x18800(%rip), %rdi     # 0x40f75
leaq 0x1bcf7(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x187ef(%rip), %rdi     # 0x40f81
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x187e6(%rip), %rdi     # 0x40f8b
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x187db(%rip), %rdi     # 0x40f93
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x187d0(%rip), %rdi     # 0x40f9b
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x187c3(%rip), %rdi     # 0x40fa1
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x385a7(%rip), %rax     # 0x60d98
cmpl $0x0, (%rax)
je 0x2880e
leaq 0x187ae(%rip), %rdi     # 0x40fab
leaq 0x1bc6f(%rip), %rdx     # 0x44473
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x1c59c
leaq 0x3db63(%rip), %rax     # 0x66378
cmpl $0x80, 0x50(%rax)
jne 0x28854
leaq 0x18792(%rip), %rdi     # 0x40fb7
leaq 0x1bc47(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x18785(%rip), %rdi     # 0x40fc7
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c59c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3ced5(%rip), %rax     # 0x65738
leaq 0x35e56(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3d084(%rip), %rcx     # 0x658f8
leaq 0x35e4d(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x35e4b(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x35e49(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
jmp 0x28bca
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x3f6ef(%rip)     # 0x67f98
movq %rdi, %rbx
xorl %ecx, %ecx
leaq 0x2cc2b(%rip), %r12     # 0x554e0
leaq 0x10(%rcx), %r13
cmpq $0x60, %r13
je 0x28952
movq (%rcx,%r12), %r15
movq %r15, %rdi
callq 0xe0d0
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe080
movq %r13, %rcx
testl %eax, %eax
jne 0x288b5
movl -0x8(%r13,%r12), %ebp
movl %ebp, 0x3f6a6(%rip)     # 0x67f98
addq %r14, %rbx
pushq $0x8
popq %r12
leaq 0x2cc30(%rip), %r13     # 0x55530
cmpq $0x98, %r12
je 0x2893e
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 0x28938
orl (%r12,%r13), %ebp
movl %ebp, 0x3f663(%rip)     # 0x67f98
addq %r14, %rbx
addq $0x10, %r12
jmp 0x28900
cmpb $0x0, (%rbx)
jne 0x28952
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x31697(%rip), %rax     # 0x59ff0
movq (%rax), %rdi
leaq 0x186c4(%rip), %rsi     # 0x41027
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_O2/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 0x381cb(%rip), %rax     # 0x60d9c
cmpl $0x0, (%rax)
jne 0x28bdc
movl $0x5, (%rax)
leaq 0x381e9(%rip), %rcx     # 0x60dcc
cmpl $0x0, (%rcx)
je 0x28bee
movl $0x6, (%rax)
cmpl $0x0, 0x3f3a3(%rip)     # 0x67f98
je 0x28bf8
retq
movl 0x10(%rdi), %eax
movl %eax, 0x3f397(%rip)     # 0x67f98
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3cb2d(%rip), %rax     # 0x65738
leaq 0x3f376(%rip), %rcx     # 0x67f88
movq %rax, (%rcx)
leaq 0x3ccdc(%rip), %rcx     # 0x658f8
leaq 0x3f36d(%rip), %rdx     # 0x67f90
movq %rcx, (%rdx)
leaq 0x35a93(%rip), %rdx     # 0x5e6c0
movq %rax, (%rdx)
leaq 0x35a91(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x35a8f(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x35a8d(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3cfbd(%rip), %rax     # 0x65c78
leaq 0x3597e(%rip), %rcx     # 0x5e640
movq %rax, (%rcx)
leaq 0x3d16c(%rip), %rax     # 0x65e38
leaq 0x35975(%rip), %rcx     # 0x5e648
movq %rax, (%rcx)
leaq 0x3ca5b(%rip), %rax     # 0x65738
leaq 0x3f2a4(%rip), %rcx     # 0x67f88
movq %rax, (%rcx)
leaq 0x3cc0a(%rip), %rcx     # 0x658f8
leaq 0x3f29b(%rip), %rdx     # 0x67f90
movq %rcx, (%rdx)
leaq 0x359c1(%rip), %rdx     # 0x5e6c0
movq %rax, (%rdx)
leaq 0x359bf(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x359bd(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x359bb(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
leaq 0x3ccb1(%rip), %rax     # 0x659d8
leaq 0x35932(%rip), %rcx     # 0x5e660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c9e1(%rip), %rax     # 0x65738
leaq 0x35962(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3cb90(%rip), %rcx     # 0x658f8
leaq 0x35959(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x35957(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x35955(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
cmpl $0x0, 0x3f20f(%rip)     # 0x67f9c
jne 0x28d99
movl $0x8, 0x3f203(%rip)     # 0x67f9c
leaq 0x317c4(%rip), %rax     # 0x5a564
cmpl $0x9, (%rax)
jne 0x28de4
leaq 0x3cc2c(%rip), %rax     # 0x659d8
leaq 0x358b5(%rip), %rcx     # 0x5e668
movq %rax, (%rcx)
leaq 0x358a3(%rip), %rcx     # 0x5e660
movq %rax, (%rcx)
leaq 0x3595d(%rip), %rax     # 0x5e724
movl $0x80, (%rax)
leaq 0x35954(%rip), %rax     # 0x5e728
movl $0x10, (%rax)
leaq 0x37ffb(%rip), %rax     # 0x60ddc
andl $0x0, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-sparc.c
// Function: predefine_sparc
static void predefine_sparc(const struct target *self)
{
	predefine("__sparc__", 1, "1");
	predefine("__sparc", 1, "1");
	predefine_nostd("sparc");

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x18325(%rip), %rdi     # 0x41166
leaq 0x1b62b(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x18312(%rip), %rdi     # 0x41170
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x18301(%rip), %rdi     # 0x41172
callq 0x1ca93
movl 0x3f120(%rip), %esi     # 0x67f9c
leaq 0x182f5(%rip), %rdi     # 0x41178
xorl %eax, %eax
callq 0x1cb80
movl 0x3f10c(%rip), %esi     # 0x67f9c
leaq 0x182ef(%rip), %rdi     # 0x41186
xorl %eax, %eax
callq 0x1cb80
movl 0x3f0f8(%rip), %esi     # 0x67f9c
leaq 0x182e8(%rip), %rdi     # 0x41193
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1cb80
// File: /workspace/github_c_makefile_star2_O2/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 0x3c879(%rip), %rax     # 0x65738
leaq 0x357fa(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3ca28(%rip), %rcx     # 0x658f8
leaq 0x357f1(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x357ef(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x357ed(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
jmp 0x29160
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/target-x86.c
// Function: predefine_x86_64
static void predefine_x86_64(const struct target *self)
{
	predefine("__x86_64__", 1, "1");
	predefine("__x86_64", 1, "1");
	predefine("__amd64__", 1, "1");
	predefine("__amd64", 1, "1");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x180e6(%rip), %rdi     # 0x411f1
leaq 0x1b361(%rip), %rbx     # 0x44473
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x180d4(%rip), %rdi     # 0x411fc
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x180ca(%rip), %rdi     # 0x41205
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1c59c
leaq 0x180c1(%rip), %rdi     # 0x4120f
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c59c
// File: /workspace/github_c_makefile_star2_O2/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 0x313fd(%rip), %rax     # 0x5a564
movl (%rax), %eax
cmpl $0x8, %eax
je 0x29198
cmpl $0x5, %eax
je 0x29188
cmpl $0x3, %eax
jne 0x291f7
leaq 0x3c4d9(%rip), %rax     # 0x65658
leaq 0x354da(%rip), %rcx     # 0x5e660
jmp 0x291f4
leaq 0x3c5a9(%rip), %rax     # 0x65738
leaq 0x354d2(%rip), %rcx     # 0x5e668
jmp 0x291f4
leaq 0x3c9f9(%rip), %rax     # 0x65b98
leaq 0x3547a(%rip), %rcx     # 0x5e620
movq %rax, (%rcx)
leaq 0x3c828(%rip), %rax     # 0x659d8
leaq 0x35471(%rip), %rcx     # 0x5e628
movq %rax, (%rcx)
leaq 0x3c577(%rip), %rax     # 0x65738
leaq 0x35498(%rip), %rcx     # 0x5e660
movq %rax, (%rcx)
leaq 0x35496(%rip), %rcx     # 0x5e668
movq %rax, (%rcx)
leaq 0x3c2bc(%rip), %rax     # 0x65498
leaq 0x354dd(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3c46b(%rip), %rax     # 0x65658
leaq 0x354d4(%rip), %rcx     # 0x5e6c8
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29160
leaq 0x35513(%rip), %rax     # 0x5e718
movl $0x8, (%rax)
leaq 0x3c526(%rip), %rax     # 0x65738
leaq 0x354a7(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3c6d5(%rip), %rcx     # 0x658f8
leaq 0x3549e(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x3549c(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x3549a(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
leaq 0x3c790(%rip), %rax     # 0x659d8
leaq 0x35411(%rip), %rcx     # 0x5e660
movq %rax, (%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c4dd(%rip), %rax     # 0x65738
leaq 0x3545e(%rip), %rcx     # 0x5e6c0
movq %rax, (%rcx)
leaq 0x3c68c(%rip), %rcx     # 0x658f8
leaq 0x35455(%rip), %rdx     # 0x5e6c8
movq %rcx, (%rdx)
leaq 0x35453(%rip), %rdx     # 0x5e6d0
movq %rax, (%rdx)
leaq 0x35451(%rip), %rax     # 0x5e6d8
movq %rcx, (%rax)
leaq 0x3c747(%rip), %rax     # 0x659d8
leaq 0x353c8(%rip), %rcx     # 0x5e660
movq %rax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x3ec77(%rip)     # 0x67fb0
movb $0x0, 0x3ec71(%rip)     # 0x67fb1
cmpl $0x100, %edi            # imm = 0x100
jl 0x29365
addl $0xffffff00, %edi       # imm = 0xFFFFFF00
leaq 0x3550b(%rip), %rax     # 0x5e860
leaq (%rax,%rdi,4), %rsi
leaq 0x3ec50(%rip), %rdi     # 0x67fb0
jmp 0xe090
leaq 0x3ec44(%rip), %rax     # 0x67fb0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18215(%rip), %rax     # 0x415d7
testq %rdi, %rdi
je 0x294ba
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
je 0x294ac
movb $0x22, 0x3efe4(%rip)    # 0x683d0
leaq 0x3efde(%rip), %r14     # 0x683d1
xorl %ebp, %ebp
movl (%rbx), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
decq %rax
cmpq %rax, %rbp
jge 0x2949f
movb 0x4(%rbx,%rbp), %r15b
movzbl %r15b, %r13d
movzbl 0x5(%rbx,%rbp), %r12d
callq 0xe310
movq (%rax), %rcx
testb $0x40, 0x1(%rcx,%r13,2)
jne 0x2943e
movb $0x5c, (%r14)
cmpl $0x9, %r13d
je 0x29459
cmpl $0xa, %r13d
jne 0x29464
movb $0x6e, 0x1(%r14)
jmp 0x2945e
cmpl $0x5c, %r13d
je 0x2944a
cmpl $0x22, %r13d
jne 0x29451
movb $0x5c, (%r14)
incq %r14
movb %r15b, (%r14)
incq %r14
jmp 0x29497
movb $0x74, 0x1(%r14)
addq $0x2, %r14
jmp 0x29497
incq %r14
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r12,2)
jne 0x2947e
movq %r14, %rdi
leaq 0x18235(%rip), %rsi     # 0x416b1
jmp 0x29488
movq %r14, %rdi
leaq 0x1822c(%rip), %rsi     # 0x416b4
movl %r13d, %edx
xorl %eax, %eax
callq 0xe2d0
cltq
addq %rax, %r14
incq %rbp
jmp 0x293f5
movw $0x22, (%r14)
leaq 0x3ef24(%rip), %rax     # 0x683d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: quote_token
const char *quote_token(const struct token *token)
{
	static char buffer[256];

	switch (token_type(token)) {
	case TOKEN_ERROR:
		return "syntax error";

	case TOKEN_IDENT:
	case TOKEN_ZERO_IDENT:
		return show_ident(token->ident);

	case TOKEN_NUMBER:
		return token->number;

	case TOKEN_SPECIAL:
		return show_special(token->special);

	case TOKEN_CHAR: 
		return quote_char(token->string->data,
			token->string->length - 1, 0, '\'');
	case TOKEN_CHAR_EMBEDDED_0 ... TOKEN_CHAR_EMBEDDED_3:
		return quote_char(token->embedded,
			token_type(token) - TOKEN_CHAR, 0, '\'');
	case TOKEN_WIDE_CHAR: 
		return quote_char(token->string->data,
			token->string->length - 1, 'L', '\'');
	case TOKEN_WIDE_CHAR_EMBEDDED_0 ... TOKEN_WIDE_CHAR_EMBEDDED_3:
		return quote_char(token->embedded,
			token_type(token) - TOKEN_WIDE_CHAR, 'L', '\'');
	case TOKEN_STRING: 
		return quote_char(token->string->data,
			token->string->length - 1, 0, '"');
	case TOKEN_WIDE_STRING: 
		return quote_char(token->string->data,
			token->string->length - 1, 'L', '"');
	default:
		sprintf(buffer, "unhandled token type '%d' ", token_type(token));
		return buffer;
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rsi
movl %esi, %edx
andl $0x3f, %edx
leal -0x2(%rdx), %eax
cmpl $0x10, %eax
ja 0x2982c
leaq 0x17b36(%rip), %rcx     # 0x412a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x10, %rdi
andl $0x3f, %esi
addq $-0x6, %rsi
jmp 0x297e1
addq $0x10, %rdi
andl $0x3f, %esi
addq $-0xb, %rsi
jmp 0x297fb
movq 0x10(%rdi), %rdi
popq %rbx
jmp 0x2936d
movl 0x10(%rdi), %edi
callq 0x29332
leaq 0x3e80a(%rip), %rbx     # 0x67fb0
jmp 0x2980d
movq 0x10(%rdi), %rdi
movl (%rdi), %esi
addq $0x4, %rdi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
pushq $0x22
jmp 0x297e3
leaq 0x17e29(%rip), %rbx     # 0x415ef
jmp 0x2980d
movq 0x10(%rdi), %rbx
jmp 0x2980d
movq 0x10(%rdi), %rdi
movl (%rdi), %esi
addq $0x4, %rdi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
pushq $0x27
popq %rcx
xorl %edx, %edx
jmp 0x29801
movq 0x10(%rdi), %rdi
movl (%rdi), %esi
addq $0x4, %rdi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
pushq $0x4c
popq %rdx
pushq $0x27
popq %rcx
callq 0x29846
leaq 0x58e03(%rip), %rbx     # 0x82610
movq %rbx, %rax
popq %rbx
retq
movq 0x10(%rdi), %rdi
movl (%rdi), %esi
addq $0x4, %rdi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
pushq $0x4c
popq %rdx
pushq $0x22
jmp 0x29800
leaq 0x46c9d(%rip), %rbx     # 0x704d0
leaq 0x17e04(%rip), %rsi     # 0x4163e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe2d0
jmp 0x2980d
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: quote_char
static const char *quote_char(const char *s, size_t len, char prefix, char delim)
{
	static char buffer[2*MAX_STRING + 6];
	size_t i;
	char *p = buffer;
	if (prefix)
		*p++ = prefix;
	if (delim == '"')
		*p++ = '\\';
	*p++ = delim;
	for (i = 0; i < len; i++) {
		if (s[i] == '"' || s[i] == '\\')
			*p++ = '\\';
		*p++ = s[i];
	}
	if (delim == '"')
		*p++ = '\\';
	*p++ = delim;
	*p++ = '\0';
	return buffer;
}

// Assembly:
testb %dl, %dl
je 0x29859
movb %dl, 0x58dc0(%rip)      # 0x82610
leaq 0x58dba(%rip), %rax     # 0x82611
jmp 0x29860
leaq 0x58db0(%rip), %rax     # 0x82610
cmpb $0x22, %cl
jne 0x2986b
movb $0x5c, (%rax)
incq %rax
movb %cl, (%rax)
xorl %edx, %edx
leaq 0x1(%rax), %r8
cmpq %rdx, %rsi
je 0x298a3
movzbl (%rdi,%rdx), %r9d
cmpl $0x5c, %r9d
je 0x29889
cmpl $0x22, %r9d
jne 0x29898
movb $0x5c, 0x1(%rax)
addq $0x2, %rax
movb (%rdi,%rdx), %r9b
movq %rax, %r8
movb %r9b, (%r8)
incq %rdx
movq %r8, %rax
jmp 0x2986f
cmpb $0x22, %cl
jne 0x298b3
movb $0x5c, 0x1(%rax)
addq $0x2, %rax
movq %rax, %r8
movb %cl, (%r8)
movb $0x0, 0x1(%r8)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x298d9
incq %rdi
movl %ecx, %edx
shll $0x4, %edx
addl %eax, %edx
shrl $0x4, %ecx
addl %edx, %ecx
imull $0xb, %ecx, %eax
jmp 0x298be
imull $0x9e370001, %eax, %eax # imm = 0x9E370001
shrl $0x1a, %eax
leaq 0x34e77(%rip), %rcx     # 0x5e760
leaq (%rcx,%rax,4), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e696(%rip), %ebx     # 0x67fa0
movq 0x3e697(%rip), %rdi     # 0x67fa8
cmpl 0x46cb9(%rip), %ebx     # 0x705d0
jl 0x2994d
leal (,%rbx,4), %eax
pushq $0x3
popq %rcx
xorl %edx, %edx
divl %ecx
movl %eax, %r13d
addl $0xa, %r13d
imulq $0x50, %r13, %rsi
callq 0xe240
movq %rax, 0x3e66a(%rip)     # 0x67fa8
testq %rax, %rax
je 0x299c2
movq %rax, %rdi
movl %r13d, 0x46c83(%rip)    # 0x705d0
movslq %ebx, %rax
imulq $0x50, %rax, %rax
leaq (%rdi,%rax), %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rdi,%rax)
movups %xmm0, 0x10(%rdi,%rax)
movups %xmm0, 0x20(%rdi,%rax)
movups %xmm0, 0x40(%rdi,%rax)
movups %xmm0, 0x30(%rdi,%rax)
movq %r14, 0x8(%rdi,%rax)
movl %ebp, (%rdi,%rax)
movq %r12, 0x18(%rdi,%rax)
andl $0x0, 0x28(%rdi,%rax)
testq %r15, %r15
je 0x2998f
movq (%r15), %rax
jmp 0x29994
movl $0xfffc0, %eax          # imm = 0xFFFC0
movq %rax, 0x20(%r13)
leal 0x1(%rbx), %eax
movl %eax, 0x3e5ff(%rip)     # 0x67fa0
movq %r14, %rdi
callq 0x298bc
movl (%rax), %ecx
movl %ecx, 0x30(%r13)
movl %ebx, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17c90(%rip), %rdi     # 0x41659
xorl %eax, %eax
callq 0x113be
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: show_identifier_stats
void show_identifier_stats(void)
{
	int i;
	int distribution[100];

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x3060d(%rip), %r15     # 0x59ff0
movq (%r15), %rdi
movl 0x46be8(%rip), %edx     # 0x705d4
movl 0x46be6(%rip), %ecx     # 0x705d8
leaq 0x17c86(%rip), %rsi     # 0x4167f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe1d0
cmpq $0x64, %rbx
je 0x29a11
andl $0x0, (%rsp,%rbx,4)
incq %rbx
jmp 0x29a02
xorl %eax, %eax
leaq 0x46bc6(%rip), %rcx     # 0x705e0
pushq $-0x1
popq %rdx
pushq $0x63
popq %rsi
cmpq $0x2000, %rax           # imm = 0x2000
je 0x29a46
leaq (%rcx,%rax,8), %r8
movl %edx, %edi
movq (%r8), %r8
incl %edi
testq %r8, %r8
jne 0x29a2e
cmpl $0x63, %edi
cmovael %esi, %edi
incl (%rsp,%rdi,4)
incq %rax
jmp 0x29a20
leaq 0x17c53(%rip), %rbx     # 0x416a0
xorl %r14d, %r14d
cmpq $0x64, %r14
je 0x29a75
movl (%rsp,%r14,4), %ecx
testl %ecx, %ecx
jne 0x29a63
incq %r14
jmp 0x29a50
movq (%r15), %rdi
movq %rbx, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe1d0
jmp 0x29a5e
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: hash_name
static unsigned long hash_name(const char *name, int len)
{
	unsigned long hash;
	const unsigned char *p = (const unsigned char *)name;

	hash = ident_hash_init(*p++);
	while (--len) {
		unsigned int i = *p++;
		hash = ident_hash_add(hash, i);
	}
	return ident_hash_end(hash);
}

// Assembly:
movzbl (%rdi), %ecx
movl %esi, %eax
pushq $0x1
popq %rdx
cmpl %edx, %eax
je 0x29acc
movzbl (%rdi,%rdx), %esi
imulq $0xb, %rcx, %rcx
addq %rsi, %rcx
incq %rdx
jmp 0x29ab8
movl %ecx, %eax
shrl $0xd, %eax
addl %ecx, %eax
andl $0x1fff, %eax           # imm = 0x1FFF
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0x46ac4(%rip), %rax     # 0x705e0
leaq (%rax,%rdx,8), %r13
movslq %esi, %r15
leaq 0x46aaa(%rip), %r12     # 0x705d4
movq (%r13), %rbx
testq %rbx, %rbx
je 0x29b54
movq %rbx, %r13
cmpb %bpl, 0x10(%rbx)
jne 0x29b2a
leaq 0x12(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xe080
movq %rbx, %r13
testl %eax, %eax
jne 0x29b2a
jmp 0x29b90
movl %r15d, %edi
callq 0x2a8db
movq %rax, %rbx
andq $0x0, 0x8(%rax)
movb %bpl, 0x10(%rax)
andb $-0x2, 0x11(%rax)
leaq 0x12(%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe1e0
movq %rbx, (%r13)
andq $0x0, (%rbx)
incl 0x46a4f(%rip)           # 0x705d8
leaq 0x5ca84(%rip), %r12     # 0x86614
incl (%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a947
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_O2/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 %rbx
subq $0x2048, %rsp           # imm = 0x2048
movq %rcx, %rbx
movl %edx, %ebp
movq %r8, %rcx
callq 0x298ee
testl %eax, %eax
js 0x2a017
leaq 0x8(%rsp), %r15
leaq 0x40(%rsp), %rcx
movq %r15, %rdi
movl %eax, %esi
movl %ebp, %edx
xorl %r8d, %r8d
callq 0x29c21
movq %rax, %r14
movq %r15, %rdi
callq 0x29c6e
testq %rbx, %rbx
je 0x2a01a
movq %rbx, 0x8(%rax)
jmp 0x2a01a
movq %rbx, %r14
movq %r14, %rax
addq $0x2048, %rsp           # imm = 0x2048
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: stream_pos
static struct position stream_pos(stream_t *stream)
{
	struct position pos;
	pos.type = 0;
	pos.stream = stream->nr;
	pos.newline = stream->newline;
	pos.whitespace = stream->whitespace;
	pos.pos = stream->pos;
	pos.line = stream->line;
	pos.noexpand = 0;
	return pos;
}

// Assembly:
movl 0xc(%rdi), %ecx
movl 0x14(%rdi), %eax
shll $0x6, %eax
movl 0x18(%rdi), %edx
andl $0x1, %edx
shll $0x14, %edx
andl $0xfffc0, %eax          # imm = 0xFFFC0
orl %edx, %eax
movl 0x1c(%rdi), %edx
shll $0x16, %ecx
andl $0x1, %edx
shll $0x15, %edx
orl %eax, %edx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl 0x10(%rdi), %eax
orl %ecx, %edx
shlq $0x20, %rax
orq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lucvoo[P]sparse-dev/tokenize.c
// Function: nextchar
static inline int nextchar(stream_t *stream)
{
	int offset = stream->offset;

	if (offset < stream->size) {
		int c = stream->buffer[offset++];
		static const char special[256] = {
			['\t'] = 1, ['\r'] = 1, ['\n'] = 1, ['\\'] = 1
		};
		if (!special[c]) {
			stream->offset = offset;
			stream->pos++;
			return c;
		}
	}
	return nextchar_slow(stream);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
movl 0x8(%rdi), %eax
cmpl %eax, %ebp
jge 0x2a0c1
movslq %ebp, %rcx
movq 0x30(%rbx), %rdx
movzbl (%rdx,%rcx), %r14d
leaq 0x1723a(%rip), %rcx     # 0x412f0
cmpb $0x0, (%r14,%rcx)
je 0x2a1e6
movb $0x1, %cl
movl %ecx, (%rsp)
pushq $0x1
popq %r13
pushq $0x5c
popq %r14
movl $0x0, 0x4(%rsp)
movb $0x1, %r12b
xorl %r15d, %r15d
cmpl %eax, %ebp
jge 0x2a0e4
movl %ebp, %ecx
jmp 0x2a10d
movl (%rbx), %edi
testl %edi, %edi
js 0x2a191
movq 0x30(%rbx), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0xe180
testl %eax, %eax
jle 0x2a191
movl %eax, 0x8(%rbx)
andl $0x0, 0x4(%rbx)
xorl %ecx, %ecx
movq 0x30(%rbx), %rdx
leal 0x1(%rcx), %ebp
movslq %ecx, %rsi
movzbl (%rdx,%rsi), %edx
testb $0x1, %r12b
je 0x2a142
cmpl $0xd, %edx
je 0x2a138
testl %r15d, %r15d
jne 0x2a153
cmpl $0x5c, %edx
jne 0x2a16b
incl 0xc(%rbx)
movl %r13d, %r15d
jmp 0x2a0dc
xorl %r12d, %r12d
movl %r15d, 0x4(%rsp)
jmp 0x2a0dc
cmpl $0xa, %edx
cmovel %ebp, %ecx
movl %ecx, %ebp
cmpl $0x0, 0x4(%rsp)
jne 0x2a158
jmp 0x2a1c5
cmpl $0xa, %edx
jne 0x2a1d7
incl 0x10(%rbx)
andl $0x0, 0xc(%rbx)
movl $0x0, (%rsp)
jmp 0x2a0ce
cmpl $0xa, %edx
je 0x2a1c3
cmpl $0x9, %edx
jne 0x2a1db
movl 0x345d5(%rip), %esi     # 0x5e750
movl 0xc(%rbx), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %esi
addl %esi, %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rbx)
pushq $0x9
popq %r14
jmp 0x2a1e1
testl %r15d, %r15d
jne 0x2a1e1
leaq 0x3041f(%rip), %rax     # 0x5a5bc
movl (%rax), %eax
testl %eax, 0xc(%rbx)
je 0x2a200
movq %rbx, %rdi
callq 0x2a052
leaq 0x17506(%rip), %rsi     # 0x416b9
movq %rax, %rdi
xorl %eax, %eax
callq 0x1108a
pushq $-0x1
popq %r14
jmp 0x2a1ee
movl %ebp, %ecx
incl 0x10(%rbx)
andl $0x0, 0xc(%rbx)
movl $0x1, 0x18(%rbx)
pushq $0xa
popq %r14
movl %ecx, %ebp
jmp 0x2a1e1
incl 0xc(%rbx)
movl %edx, %r14d
movl %ebp, 0x4(%rbx)
jmp 0x2a1ee
incl %ebp
movl %ebp, 0x4(%rbx)
incl 0xc(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %r14
testb $0x1, (%rsp)
jne 0x2a1ee
movq %rbx, %rdi
callq 0x2a052
leaq 0x174ba(%rip), %rsi     # 0x416d3
movq %rax, %rdi
xorl %eax, %eax
callq 0x1108a
jmp 0x2a1ee