LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kilobyte[P]colormatch/256.c
// Function: col256_to_rgb
int col256_to_rgb(int i)
{
    if (i<0 || i > 255)
        abort();

    // Standard colours.
    if (i < 16)
    {
        if (i == 3)
            return 0xaa5500; // real CGA/VGA special-cases brown
        int c = (i&1 ? 0xaa0000 : 0x000000)
              | (i&2 ? 0x00aa00 : 0x000000)
              | (i&4 ? 0x0000aa : 0x000000);
        return (i >= 8) ? c + 0x555555 : c;
    }
    // 6x6x6 colour cube.
    else if (i < 232)
    {
        i -= 16;
        int r = i / 36, g = i / 6 % 6, b = i % 6;
        return (r ? r * 0x280000 + 0x370000 : 0)
             | (g ? g * 0x002800 + 0x003700 : 0)
             | (b ? b * 0x000028 + 0x000037 : 0);
    }
    // Grayscale ramp.
    else // i < 256
        return (i * 10 - 2312) * 0x010101;
}

// Assembly:
cmpl $0x100, %edi            # imm = 0x100
jae 0x1e15
cmpl $0xf, %edi
jg 0x1d91
movl $0xaa5500, %eax         # imm = 0xAA5500
cmpl $0x3, %edi
je 0x1e14
movl %edi, %eax
andl $0x1, %eax
negl %eax
andl $0xaa0000, %eax         # imm = 0xAA0000
movl %edi, %ecx
shll $0x1e, %ecx
sarl $0x1f, %ecx
andl $0xaa00, %ecx           # imm = 0xAA00
orl %eax, %ecx
movl %edi, %eax
shll $0x1d, %eax
sarl $0x1f, %eax
andl $0xaa, %eax
leal (%rcx,%rax), %edx
cmpl $0x8, %edi
leal 0x555555(%rax,%rcx), %eax
cmovll %edx, %eax
retq
cmpl $0xe7, %edi
jg 0x1e09
addl $-0x10, %edi
imulq $0x38e38e39, %rdi, %rax # imm = 0x38E38E39
shrq $0x23, %rax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rdi, %rcx
shrq $0x22, %rcx
imulq $0x2aaaaaab, %rcx, %rdx # imm = 0x2AAAAAAB
shrq $0x20, %rdx
addl %edx, %edx
leal (%rdx,%rdx,2), %edx
movl %ecx, %esi
subl %edx, %esi
addl %ecx, %ecx
leal (%rcx,%rcx,2), %ecx
movl %edi, %edx
subl %ecx, %edx
leal (%rax,%rax,4), %eax
shll $0x13, %eax
addl $0x370000, %eax         # imm = 0x370000
xorl %ecx, %ecx
cmpl $0x24, %edi
cmovael %eax, %ecx
leal (%rsi,%rsi,4), %edi
shll $0xb, %edi
addl $0x3700, %edi           # imm = 0x3700
testl %esi, %esi
cmovel %esi, %edi
testl %edx, %edx
leal (%rdx,%rdx,4), %eax
leal 0x37(,%rax,8), %eax
cmovel %edx, %eax
orl %ecx, %eax
orl %edi, %eax
retq
imull $0xa0a0a, %edi, %eax    # imm = 0xA0A0A
addl $0xf6eeeef8, %eax       # imm = 0xF6EEEEF8
retq
pushq %rax
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x52921(%rip), %r15     # 0x60ff0
movq (%r15), %rdi
movl 0x68efc(%rip), %edx     # 0x775d4
movl 0x68efa(%rip), %ecx     # 0x775d8
leaq 0x3ae7a(%rip), %rsi     # 0x4955f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe1d0
movq %rsp, %rdi
movl $0x190, %edx            # imm = 0x190
xorl %esi, %esi
callq 0xe130
leaq 0x68edc(%rip), %rax     # 0x775e0
pushq $-0x1
popq %rcx
pushq $0x63
popq %rdx
leaq (%rax,%rbx,8), %rdi
movl %ecx, %esi
movq (%rdi), %rdi
incl %esi
testq %rdi, %rdi
jne 0xe710
cmpl $0x63, %esi
cmovael %edx, %esi
incl (%rsp,%rsi,4)
incq %rbx
cmpq $0x2000, %rbx           # imm = 0x2000
jne 0xe70a
leaq 0x3ae4a(%rip), %rbx     # 0x49580
xorl %r14d, %r14d
movl (%rsp,%r14,4), %ecx
testl %ecx, %ecx
jne 0xe74c
incq %r14
cmpq $0x64, %r14
jne 0xe739
jmp 0xe75e
movq (%r15), %rdi
movq %rbx, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe1d0
jmp 0xe741
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/allocate.c
// Function: show_allocations
void show_allocations(struct allocator_struct *x)
{
	fprintf(stderr, "%s: %d allocations, %lu bytes (%lu total bytes, "
			"%6.2f%% usage, %6.2f average size)\n",
		x->name, x->allocations, x->useful_bytes, x->total_bytes,
		100 * (double) x->useful_bytes / x->total_bytes,
		(double) x->useful_bytes / x->allocations);
}

// Assembly:
movq %rdi, %rax
movq 0x5287b(%rip), %rcx     # 0x60ff0
movq (%rcx), %rdi
movq (%rax), %rdx
movl 0x20(%rax), %ecx
movq 0x30(%rax), %r8
movq 0x28(%rax), %r9
movq %r8, %xmm0
movq 0x3b01d(%rip), %xmm2    # 0x497b0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x3b021(%rip), %xmm3    # 0x497c0
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x3b019(%rip), %xmm0    # 0x497d0
mulsd %xmm1, %xmm0
movq %r9, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
addsd %xmm4, %xmm2
cvtsi2sd %rcx, %xmm3
divsd %xmm2, %xmm0
divsd %xmm3, %xmm1
leaq 0x3b00c(%rip), %rsi     # 0x497f4
movb $0x2, %al
jmp 0xe1d0
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/obfuscate.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	emit_symbol_list(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		emit_symbol_list(sparse(file));
	} END_FOR_EACH_PTR(file);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x11d82
movq %rax, %rdi
callq 0xea1c
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xea10
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xea07
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xe9eb
testq %rdi, %rdi
je 0xe9f8
callq 0x120c2
movq %rax, %rdi
callq 0xea1c
incq %r15
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0xe9d7
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xe9cc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/obfuscate.c
// Function: emit_symbol_list
static void emit_symbol_list(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
		emit_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xea81
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0xea6d
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xea4e
testq %r14, %r14
je 0xea5e
movq %r14, %rdi
callq 0xed1c
movq %r14, %rdi
callq 0x13a97
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0xea3a
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0xea2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_symbol
int expand_symbol(struct symbol *sym)
{
	int retval;
	struct symbol *base_type;

	if (!sym)
		return 0;
	base_type = sym->ctype.base_type;
	if (!base_type)
		return 0;

	retval = expand_expression(sym->initializer);
	/* expand the body of the symbol */
	if (base_type->type == SYM_FN) {
		if (base_type->stmt)
			expand_statement(base_type->stmt);
	}
	return retval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xed55
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0xed55
movq 0xb0(%rdi), %rdi
callq 0xed5f
movl %eax, %ebx
cmpb $0x5, (%r14)
jne 0xed55
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0xed55
callq 0xef37
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: _get_expression_value
static long long __get_expression_value(struct expression *expr, int strict)
{
	long long value, mask;
	struct symbol *ctype;

	if (!expr)
		return 0;
	ctype = evaluate_expression(expr);
	if (!ctype) {
		expression_error(expr, "bad constant expression type");
		return 0;
	}
	expand_expression(expr);
	if (expr->type != EXPR_VALUE) {
		if (strict != 2)
			expression_error(expr, "bad constant expression");
		return 0;
	}
	if ((strict == 1) && bad_integer_constant_expression(expr)) {
		expression_error(expr, "bad integer constant expression");
		return 0;
	}

	value = expr->value;
	mask = 1ULL << (ctype->bit_size-1);

	if (value & mask) {
		while (ctype->type != SYM_BASETYPE)
			ctype = ctype->ctype.base_type;
		if (!(ctype->ctype.modifiers & MOD_UNSIGNED))
			value = value | mask | ~(mask-1);
	}
	return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xf2c8
movl %esi, %ebx
movq %rdi, %r14
callq 0x32c63
testq %rax, %rax
je 0xf2ba
movq %rax, %r15
movq %r14, %rdi
callq 0xed5f
movl (%r14), %eax
cmpb $0x1, %al
jne 0xf2c3
cmpl $0x1, %ebx
jne 0xf27e
btl $0xc, %eax
jae 0xf2d5
testb $0x1, 0x28(%r14)
jne 0xf2d5
movb 0x50(%r15), %cl
decb %cl
movl $0x1, %eax
shlq %cl, %rax
movq 0x20(%r14), %rbx
movzbl %cl, %ecx
btq %rcx, %rbx
jb 0xf29f
jmp 0xf2e8
movq 0x60(%r15), %r15
cmpb $0x2, (%r15)
jne 0xf29b
testb $0x40, 0x69(%r15)
jne 0xf2e8
movq %rax, %rcx
negq %rcx
orq %rcx, %rbx
orq %rax, %rbx
jmp 0xf2e8
leaq 0x32089(%rip), %rsi     # 0x4134a
jmp 0xf2dc
cmpl $0x2, %ebx
jne 0xf2cc
xorl %ebx, %ebx
jmp 0xf2e8
leaq 0x32094(%rip), %rsi     # 0x41367
jmp 0xf2dc
leaq 0x320a3(%rip), %rsi     # 0x4137f
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11abc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expr_truth_value
int expr_truth_value(struct expression *expr)
{
	const int saved = conservative;
	struct symbol *ctype;

	if (!expr)
		return 0;

	ctype = evaluate_expression(expr);
	if (!ctype)
		return -1;

	conservative = 1;
	expand_expression(expr);
	conservative = saved;

redo:
	switch (expr->type) {
	case EXPR_COMMA:
		expr = expr->right;
		goto redo;
	case EXPR_VALUE:
		return expr->value != 0;
	case EXPR_FVALUE:
		return expr->fvalue != 0;
	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xf371
movq %rdi, %r14
movb 0x57168(%rip), %bpl     # 0x66480
callq 0x32c63
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf37f
movb $0x1, 0x57152(%rip)     # 0x66480
movq %r14, %rdi
callq 0xed5f
andb $0x1, %bpl
movb %bpl, 0x5713f(%rip)     # 0x66480
movzbl (%r14), %eax
cmpl $0x15, %eax
jne 0xf350
movq 0x28(%r14), %r14
jmp 0xf341
cmpl $0x1, %eax
je 0xf375
cmpl $0x1c, %eax
jne 0xf37f
fldt 0x20(%r14)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %al
setne %cl
orb %al, %cl
movzbl %cl, %ebx
jmp 0xf37f
xorl %ebx, %ebx
jmp 0xf37f
xorl %ebx, %ebx
cmpq $0x0, 0x20(%r14)
setne %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: is_zero_constant
int is_zero_constant(struct expression *expr)
{
	const int saved = conservative;
	conservative = 1;
	expand_expression(expr);
	conservative = saved;
	return expr->type == EXPR_VALUE && !expr->value;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x570ed(%rip), %bpl     # 0x66480
movb $0x1, 0x570e6(%rip)     # 0x66480
callq 0xed5f
movb %bpl, 0x570da(%rip)     # 0x66480
xorl %eax, %eax
cmpb $0x1, (%rbx)
jne 0xf3b7
xorl %eax, %eax
cmpq $0x0, 0x20(%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_symbol_expression
static int expand_symbol_expression(struct expression *expr)
{
	struct symbol *sym = expr->symbol;

	if (sym == &zero_int) {
		if (Wundef)
			warning(expr->pos, "undefined preprocessor identifier '%s'", show_ident(expr->symbol_name));
		expr->type = EXPR_VALUE;
		expr->value = 0;
		expr->taint = 0;
		return 0;
	}

	// expand compound literals (C99 & C11 6.5.2.5)
	// FIXME: is this the correct way to identify them?
	//	All compound literals are anonymous but is
	//	the reverse true?
	if (sym->initializer && !expr->symbol_name)
		return expand_expression(sym->initializer);

	/* The cost of a symbol expression is lower for on-stack symbols */
	return (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN)) ? 2 : 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x51bf3(%rip), %rax     # 0x60fc0
je 0xf3f3
movq 0xb0(%rax), %rdi
testq %rdi, %rdi
je 0xf3e2
cmpq $0x0, 0x28(%rbx)
je 0xf433
movb 0x68(%rax), %al
andb $0xc, %al
cmpb $0x1, %al
movl $0x2, %eax
sbbl $0x0, %eax
jmp 0xf431
leaq 0x58a4a(%rip), %rax     # 0x67e44
cmpl $0x0, (%rax)
je 0xf41d
movq 0x28(%rbx), %rdi
callq 0x2e465
movq 0x8(%rbx), %rdi
leaq 0x31e4d(%rip), %rsi     # 0x41260
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
movb $0x1, (%rbx)
movq $0x0, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
popq %rbx
retq
popq %rbx
jmp 0xed5f
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_logical
static int expand_logical(struct expression *expr)
{
	struct expression *left = expr->left;
	struct expression *right;
	int cost, rcost;

	/* Do immediate short-circuiting ... */
	cost = expand_expression(left);
	if (left->type == EXPR_VALUE) {
		if (expr->op == SPECIAL_LOGICAL_AND) {
			if (!left->value) {
				expr->type = EXPR_VALUE;
				expr->value = 0;
				expr->taint = left->taint;
				return 0;
			}
		} else {
			if (left->value) {
				expr->type = EXPR_VALUE;
				expr->value = 1;
				expr->taint = left->taint;
				return 0;
			}
		}
	}

	right = expr->right;
	rcost = expand_expression(right);
	if (left->type == EXPR_VALUE && right->type == EXPR_VALUE) {
		/*
		 * We know the left value doesn't matter, since
		 * otherwise we would have short-circuited it..
		 */
		expr->type = EXPR_VALUE;
		expr->value = right->value != 0;
		expr->taint = left->taint | right->taint;
		return 0;
	}

	/*
	 * If the right side is safe and cheaper than a branch,
	 * just avoid the branch and turn it into a regular binop
	 * style SAFELOGICAL.
	 */
	if (rcost < BRANCH_COST) {
		expr->type = EXPR_BINOP;
		rcost -= BRANCH_COST - 1;
	}

	return cost + BRANCH_COST + rcost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0xed5f
movl %eax, %r15d
cmpb $0x1, (%r14)
jne 0xf957
cmpl $0x10c, 0x4(%rbx)       # imm = 0x10C
movq 0x20(%r14), %rax
jne 0xf941
testq %rax, %rax
jne 0xf957
movb $0x1, (%rbx)
movq $0x0, 0x20(%rbx)
jmp 0xf951
testq %rax, %rax
je 0xf957
movb $0x1, (%rbx)
movq $0x1, 0x20(%rbx)
movl 0x28(%r14), %eax
jmp 0xf98b
movq 0x28(%rbx), %r12
movq %r12, %rdi
callq 0xed5f
cmpb $0x1, (%r14)
jne 0xf992
cmpb $0x1, (%r12)
jne 0xf992
movb $0x1, (%rbx)
xorl %eax, %eax
cmpq $0x0, 0x20(%r12)
setne %al
movq %rax, 0x20(%rbx)
movl 0x28(%r12), %eax
orl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
jmp 0xf9a3
cmpl $0x9, %eax
jg 0xf99d
movb $0x5, (%rbx)
addl $-0x9, %eax
addl %r15d, %eax
addl $0xa, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_comma
static int expand_comma(struct expression *expr)
{
	int cost;

	cost = expand_expression(expr->left);
	cost += expand_expression(expr->right);
	if (expr->left->type == EXPR_VALUE || expr->left->type == EXPR_FVALUE) {
		unsigned flags = expr->flags;
		unsigned taint;
		taint = expr->left->type == EXPR_VALUE ? expr->left->taint : 0;
		*expr = *expr->right;
		expr->flags = flags;
		if (expr->type == EXPR_VALUE)
			expr->taint |= Taint_comma | taint;
	}
	return cost;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xed5f
movl %eax, %ebp
movq 0x28(%rbx), %rdi
callq 0xed5f
movq 0x20(%rbx), %rsi
movl (%rsi), %ecx
movzbl %cl, %edi
cmpb $0x1c, %dil
je 0xf9dd
cmpl $0x1, %edi
jne 0xfa2d
movzbl 0x1(%rbx), %edx
shll $0x8, %edx
movl $0x1, %ecx
cmpl $0x1, %edi
jne 0xf9f4
movl 0x28(%rsi), %ecx
orl $0x1, %ecx
movq 0x28(%rbx), %rsi
movaps (%rsi), %xmm0
movaps 0x10(%rsi), %xmm1
movaps 0x20(%rsi), %xmm2
movaps 0x30(%rsi), %xmm3
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm3, 0x30(%rbx)
movaps %xmm2, 0x20(%rbx)
movl (%rbx), %esi
movl %esi, %edi
andl $0xffff00ff, %edi       # imm = 0xFFFF00FF
orl %edx, %edi
movl %edi, (%rbx)
cmpb $0x1, %sil
jne 0xfa2d
orl %ecx, 0x28(%rbx)
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_call
static int expand_call(struct expression *expr)
{
	int cost;
	struct symbol *sym;
	struct expression *fn = expr->fn;

	cost = expand_arguments(expr->args);
	sym = fn->ctype;
	if (!sym) {
		expression_error(expr, "function has no type");
		return SIDE_EFFECTS;
	}
	if (sym->type == SYM_NODE)
		return expand_symbol_call(expr, cost);

	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0x10238
movq %r12, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x1022f
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10217
testq %rdi, %rdi
je 0x1021f
callq 0xed5f
addl %eax, %r14d
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x10203
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x101f8
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x102cd
movl $0x2710, %ebp           # imm = 0x2710
cmpb $0x3, (%rax)
jne 0x102e3
movq 0x20(%rbx), %r15
movq 0x10(%r15), %r13
movq %r15, %rdi
callq 0xed5f
cmpb $0x9, (%r15)
jne 0x102e3
testb $0x40, 0x68(%r13)
je 0x102f9
movq 0xc8(%r13), %r12
testq %r12, %r12
cmoveq %r13, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107a4
movl %eax, %r15d
testl %eax, %eax
je 0x102f4
movq 0x60(%r12), %rbp
leaq 0x80cd0(%rip), %rax     # 0x90f70
movq (%rax), %r14
movq %r12, (%rax)
movq %rax, %r12
movq 0x20(%rbx), %rdi
callq 0x35f67
movq %r14, (%r12)
orb $0x10, 0x55(%rbp)
movq %rbx, %rdi
callq 0xed5f
movl %eax, %r14d
andb $-0x11, 0x55(%rbp)
movl %eax, %ebp
jmp 0x102f4
leaq 0x3100a(%rip), %rsi     # 0x412de
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11abc
movl $0x2710, %ebp           # imm = 0x2710
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
jne 0x102e3
movq 0x40(%r13), %rax
testq %rax, %rax
je 0x10321
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x10321
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
incl %r14d
testb $0x1, 0x6b(%r13)
movl $0x2710, %ebp           # imm = 0x2710
cmovnel %r14d, %ebp
jmp 0x102e3
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_conditional
static int expand_conditional(struct expression *expr)
{
	struct expression *cond = expr->conditional;
	struct expression *valt = expr->cond_true;
	struct expression *valf = expr->cond_false;
	int cost, cond_cost;

	cond_cost = expand_expression(cond);
	if (cond->type == EXPR_VALUE) {
		unsigned flags = expr->flags;
		if (!cond->value)
			valt = valf;
		if (!valt)
			valt = cond;
		cost = expand_expression(valt);
		*expr = *valt;
		expr->flags = flags;
		if (expr->type == EXPR_VALUE)
			expr->taint |= cond->taint;
		return cost;
	}

	cost = expand_expression(valt);
	cost += expand_expression(valf);

	if (cost < SELECT_COST) {
		expr->type = EXPR_SELECT;
		cost -= BRANCH_COST - 1;
	}

	return cost + cond_cost + BRANCH_COST;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %r13
movq %r14, %rdi
callq 0xed5f
cmpb $0x1, (%r14)
jne 0x103b2
cmpq $0x0, 0x20(%r14)
cmoveq %r13, %r12
movb 0x1(%rbx), %bpl
testq %r12, %r12
cmoveq %r14, %r12
movq %r12, %rdi
callq 0xed5f
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movaps 0x30(%r12), %xmm3
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm2, 0x20(%rbx)
movaps %xmm3, 0x30(%rbx)
movb (%rbx), %cl
movb %bpl, 0x1(%rbx)
cmpb $0x1, %cl
jne 0x103da
movl 0x28(%r14), %ecx
orl %ecx, 0x28(%rbx)
jmp 0x103da
movl %eax, %r15d
movq %r12, %rdi
callq 0xed5f
movl %eax, %ebp
movq %r13, %rdi
callq 0xed5f
addl %ebp, %eax
cmpl $0x13, %eax
jg 0x103d4
movb $0x12, (%rbx)
addl $-0x9, %eax
addl %r15d, %eax
addl $0xa, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: verify_nonoverlapping
static void verify_nonoverlapping(struct expression_list **list, struct expression *expr)
{
	struct expression *a = NULL;
	unsigned long max = 0;
	unsigned long whole = expr->ctype->bit_size;
	struct expression *b;

	if (!Woverride_init)
		return;

	FOR_EACH_PTR(*list, b) {
		unsigned long off, end;
		if (!b->ctype || !b->ctype->bit_size)
			continue;
		off = bit_offset(b);
		if (a && off < max) {
			warning(a->pos, "Initializer entry defined twice");
			info(b->pos, "  also defined here");
			if (!Woverride_init_all)
				return;
		}
		end = off + bit_range(b);
		if (!a && !Woverride_init_whole_range) {
			// If first entry is the whole range, do not let
			// any warning about it (this allow to initialize
			// an array with some default value and then override
			// some specific entries).
			if (off == 0 && end == whole)
				continue;
		}
		if (end > max) {
			max = end;
			a = b;
		}
	} END_FOR_EACH_PTR(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x511d2(%rip), %rax     # 0x615d0
cmpl $0x0, (%rax)
je 0x10552
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10552
movq 0x10(%rsi), %rax
movslq 0x50(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %r13
movq $0x0, (%rsp)
xorl %r14d, %r14d
movzwl (%r13), %eax
testb %al, %al
jle 0x10543
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1045c
testq %r15, %r15
je 0x1052f
movq 0x10(%r15), %rax
movl $0x8, %ebx
testq %rax, %rax
je 0x1052a
cmpl $0x0, 0x50(%rax)
je 0x1052a
movq %r15, %rdi
callq 0x10727
movq %rax, %r12
testq %r14, %r14
je 0x104be
cmpq (%rsp), %r12
jae 0x104be
movq 0x8(%r14), %rdi
leaq 0x30e5a(%rip), %rsi     # 0x412f3
xorl %eax, %eax
callq 0x118b4
movq 0x8(%r15), %rdi
leaq 0x30e68(%rip), %rsi     # 0x41313
xorl %eax, %eax
callq 0x11744
leaq 0x57957(%rip), %rax     # 0x67e10
cmpl $0x0, (%rax)
je 0x10525
cmpb $0x1b, (%r15)
jne 0x104ec
movq %r15, %rcx
xorl %eax, %eax
movl 0x24(%rcx), %esi
movq 0x10(%rcx), %rdx
movslq 0x50(%rdx), %rdx
decq %rsi
imulq %rdx, %rsi
addq %rsi, %rax
movq 0x28(%rcx), %rcx
cmpb $0x1b, (%rcx)
je 0x104c9
addq %rdx, %rax
jmp 0x104ee
xorl %eax, %eax
addq %r12, %rax
testq %r14, %r14
jne 0x1050e
leaq 0x57917(%rip), %rcx     # 0x67e14
cmpl $0x0, (%rcx)
jne 0x1050e
testq %r12, %r12
jne 0x1050e
cmpq 0x10(%rsp), %rax
je 0x1052a
movq (%rsp), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rcx, (%rsp)
cmovaq %r15, %r14
xorl %ebx, %ebx
jmp 0x1052a
movl $0x1, %ebx
testb $0x7, %bl
jne 0x10552
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x10444
movq 0x10(%r13), %r13
cmpq 0x8(%rsp), %r13
jne 0x10435
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_expression_list
static int expand_expression_list(struct expression_list *list)
{
	int cost = 0;
	struct expression *expr;

	FOR_EACH_PTR(list, expr) {
		cost += expand_expression(expr);
	} END_FOR_EACH_PTR(expr);
	return cost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x105b6
movq %rdi, %r14
xorl %ebx, %ebx
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x105ab
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10595
testq %rdi, %rdi
je 0x1059c
callq 0xed5f
addl %eax, %ebx
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x10581
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x10576
jmp 0x105b8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_pos_expression
static int expand_pos_expression(struct expression *expr)
{
	struct expression *nested = expr->init_expr;
	unsigned long offset = expr->init_offset;
	int nr = expr->init_nr;

	if (nr == 1) {
		switch (nested->type) {
		case EXPR_POS:
			offset += nested->init_offset;
			*expr = *nested;
			expr->init_offset = offset;
			nested = expr;
			break;

		case EXPR_INITIALIZER: {
			struct expression *reuse = nested, *entry;
			*expr = *nested;
			FOR_EACH_PTR(expr->expr_list, entry) {
				if (entry->type == EXPR_POS) {
					entry->init_offset += offset;
				} else {
					if (!reuse) {
						/*
						 * This happens rarely, but it can happen
						 * with bitfields that are all at offset
						 * zero..
						 */
						reuse = alloc_expression(entry->pos, EXPR_POS);
					}
					reuse->type = EXPR_POS;
					reuse->ctype = entry->ctype;
					reuse->init_offset = offset;
					reuse->init_nr = 1;
					reuse->init_expr = entry;
					REPLACE_CURRENT_PTR(entry, reuse);
					reuse = NULL;
				}
			} END_FOR_EACH_PTR(entry);
			nested = expr;
			break;
		}

		default:
			break;
		}
	}
	return expand_expression(nested);
}

// Assembly:
movq 0x28(%rdi), %rax
cmpl $0x1, 0x24(%rdi)
jne 0x10618
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x20(%rdi), %ebp
movzbl (%rax), %ecx
cmpl $0x18, %ecx
je 0x10620
cmpl $0x1b, %ecx
jne 0x106e2
addl 0x20(%rax), %ebp
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm2, 0x20(%rdi)
movaps %xmm3, 0x30(%rdi)
movaps %xmm1, 0x10(%rdi)
movaps %xmm0, (%rdi)
movl %ebp, 0x20(%rdi)
jmp 0x106e5
movq %rax, %rdi
jmp 0xed5f
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm2, 0x20(%rdi)
movaps %xmm3, 0x30(%rdi)
movaps %xmm1, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
je 0x106e5
movq %rdi, (%rsp)
movq %rbx, %r15
movzwl (%r15), %ecx
testb %cl, %cl
jle 0x106cf
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r13
movzwl %cx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x10672
testq %r13, %r13
je 0x106c0
cmpb $0x1b, (%r13)
jne 0x1067f
addl %ebp, 0x20(%r13)
jmp 0x106c0
testq %rax, %rax
jne 0x106a0
movq 0x8(%r13), %r14
xorl %edi, %edi
callq 0x30029
movl (%rax), %ecx
orl $0x1b, %ecx
movq %r14, 0x8(%rax)
andl $0xffff001b, %ecx       # imm = 0xFFFF001B
movl %ecx, (%rax)
movb $0x1b, (%rax)
movq 0x10(%r13), %rcx
movq %rcx, 0x10(%rax)
movl %ebp, 0x20(%rax)
movl $0x1, 0x24(%rax)
movq %r13, 0x28(%rax)
movq %rax, 0x18(%r15,%r12,8)
xorl %eax, %eax
incq %r12
movl (%r15), %ecx
movsbq %cl, %rdx
cmpq %rdx, %r12
jl 0x1065d
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x10652
movq (%rsp), %rdi
jmp 0x106e5
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed5f
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: bit_offset
static unsigned long bit_offset(const struct expression *expr)
{
	unsigned long offset = 0;
	while (expr->type == EXPR_POS) {
		offset += bytes_to_bits(expr->init_offset);
		expr = expr->init_expr;
	}
	if (expr && expr->ctype)
		offset += expr->ctype->bit_offset;
	return offset;
}

// Assembly:
cmpb $0x1b, (%rdi)
jne 0x1074e
leaq 0x54fcd(%rip), %rax     # 0x65700
movslq (%rax), %rcx
xorl %eax, %eax
movslq 0x20(%rdi), %rdx
imulq %rcx, %rdx
addq %rdx, %rax
movq 0x28(%rdi), %rdi
cmpb $0x1b, (%rdi)
je 0x10738
jmp 0x10750
xorl %eax, %eax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x10760
movzbl 0x54(%rcx), %ecx
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/expand.c
// Function: expand_const_expression
static void expand_const_expression(struct expression *expr, const char *where)
{
	if (expr) {
		expand_expression(expr);
		if (expr->type != EXPR_VALUE) {
			expression_error(expr, "Expected constant expression in %s", where);
			expr->ctype = &int_ctype;
			expr->type = EXPR_VALUE;
			expr->value = 0;
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x107a3
pushq %rbx
movq %rdi, %rbx
callq 0xed5f
cmpb $0x1, (%rbx)
je 0x107a2
leaq 0x30bac(%rip), %rsi     # 0x41327
leaq 0x37ea1(%rip), %rdx     # 0x48623
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11abc
leaq 0x5bfa5(%rip), %rax     # 0x6c738
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: create_symbol_list
static struct symbol_list *create_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = create_copy_symbol(sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x10a93
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x10a86
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10a2c
testq %r15, %r15
je 0x10a76
testq %r15, %r15
je 0x10a68
movzbl (%r15), %esi
movq 0x4(%r15), %rdi
callq 0x2b547
movq %rax, %r12
movl $0xe0, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xe1e0
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r12)
movq %r15, 0x28(%r12)
movq %r12, 0x28(%r15)
jmp 0x10a6b
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x2285b
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x10a18
movq 0x10(%r13), %r13
cmpq %rbx, %r13
jne 0x10a0d
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: copy_statement
static void copy_statement(struct statement *src, struct statement *dst)
{
	struct statement *stmt;

	FOR_EACH_PTR(src->stmts, stmt) {
		add_statement(&dst->stmts, copy_one_statement(stmt));
	} END_FOR_EACH_PTR(stmt);
	dst->args = copy_one_statement(src->args);
	dst->ret = copy_symbol(src->pos, src->ret);
	dst->inline_fn = src->inline_fn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x10b0f
leaq 0x10(%rbx), %r15
movq %r12, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x10b06
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10ae6
testq %rdi, %rdi
je 0x10af6
callq 0x10c82
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x10ad2
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x10ac7
movq 0x28(%r14), %rdi
callq 0x10c82
movq %rax, 0x28(%rbx)
movq 0x4(%r14), %rdi
movq 0x18(%r14), %rsi
callq 0x110c4
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: unset_replace_list
static void unset_replace_list(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		unset_replace(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0x10bdd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x30981(%rip), %r14     # 0x414e6
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x10bc5
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10b88
testq %rbp, %rbp
je 0x10bb5
movq 0x28(%rbp), %rax
testq %rax, %rax
je 0x10b9b
movq %r15, 0x28(%rax)
movq %r15, 0x28(%rbp)
jmp 0x10bb5
movq 0x18(%rbp), %rdi
callq 0x2e465
movq 0x4(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x10b74
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x10b68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: uninline
void uninline(struct symbol *sym)
{
	struct symbol *fn = sym->ctype.base_type;
	struct symbol_list *arg_list = fn->arguments;
	struct symbol *p;

	sym->symbol_list = create_symbol_list(sym->inline_symbol_list);
	FOR_EACH_PTR(arg_list, p) {
		p->replace = p;
	} END_FOR_EACH_PTR(p);
	fn->stmt = alloc_statement(fn->pos, STMT_COMPOUND);
	copy_statement(fn->inline_stmt, fn->stmt);
	unset_replace_list(sym->symbol_list);
	unset_replace_list(arg_list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x60(%rdi), %r15
movq 0xa8(%rdi), %rdi
movq 0x88(%r15), %rbx
callq 0x109e8
movq %rax, 0x98(%r14)
testq %rbx, %rbx
je 0x10c45
movq %rbx, %rax
movzwl (%rax), %edx
testb %dl, %dl
jle 0x10c3c
xorl %ecx, %ecx
movq 0x18(%rax,%rcx,8), %rsi
movzwl %dx, %edx
cmpl $0x100, %edx            # imm = 0x100
jb 0x10c2a
testq %rsi, %rsi
je 0x10c2e
movq %rsi, 0x28(%rsi)
incq %rcx
movl (%rax), %edx
movsbq %dl, %rsi
cmpq %rsi, %rcx
jl 0x10c15
movq 0x10(%rax), %rax
cmpq %rbx, %rax
jne 0x10c0c
movq 0x4(%r15), %rdi
movl $0x3, %esi
callq 0x19687
movq %rax, 0x90(%r15)
movq 0xa0(%r15), %rdi
movq %rax, %rsi
callq 0x10aa6
movq 0x98(%r14), %rdi
callq 0x10b44
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10b44
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: copy_symbol
static struct symbol *copy_symbol(struct position pos, struct symbol *sym)
{
	if (!sym)
		return sym;
	if (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN | MOD_TOPLEVEL | MOD_INLINE))
		return sym;
	if (!sym->replace) {
		warning(pos, "unreplaced symbol '%s'", show_ident(sym->ident));
		return sym;
	}
	return sym->replace;
}

// Assembly:
testq %rsi, %rsi
je 0x110db
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testb $0x5c, 0x68(%rsi)
je 0x110de
movq %rbx, %rax
jmp 0x110e7
xorl %eax, %eax
retq
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x110ef
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
movq 0x18(%rbx), %rdi
callq 0x2e465
leaq 0x303cd(%rip), %rsi     # 0x414cf
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
jmp 0x110d6
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: copy_symbol_list
static struct symbol_list *copy_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = copy_symbol(sym->pos, sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x11649
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x11640
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rsi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1161d
testq %rsi, %rsi
je 0x11631
movq 0x4(%rsi), %rdi
callq 0x110c4
movq %r14, %rdi
movq %rax, %rsi
callq 0x2285b
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x11609
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0x115fe
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/inline.c
// Function: copy_asm_operands
static struct asm_operand_list *copy_asm_operands(struct asm_operand_list *in)
{
	struct asm_operand_list *out = NULL;
	struct asm_operand *old;

	FOR_EACH_PTR(in, old) {
		struct asm_operand *new = __alloc_asm_operand(0);
		new->name = old->name;
		new->constraint = copy_expression(old->constraint);
		new->expr = copy_expression(old->expr);
		add_ptr_list(&out, new);
	} END_FOR_EACH_PTR(old);
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x116ea
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x116e0
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1169a
testq %rbp, %rbp
je 0x116d0
xorl %edi, %edi
callq 0x2ffc6
movq %rax, %r15
movq (%rbp), %rax
movq %rax, (%r15)
movq 0x8(%rbp), %rdi
callq 0x11111
movq %rax, 0x8(%r15)
movq 0x10(%rbp), %rdi
callq 0x11111
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2285b
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x11686
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0x1167a
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: do_warn
static void do_warn(const char *type, struct position pos, const char * fmt, va_list args)
{
	static char buffer[512];

	/* Shut up warnings if position is bad_token.pos */
	if (pos.type == TOKEN_BAD)
		return;

	vsprintf(buffer, fmt, args);	

	fflush(stdout);
	fprintf(stderr, "%s:%d:%d: %s%s%s\n",
		show_stream_name(pos), pos.line, pos.pos,
		diag_prefix, type, buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %r14d, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
jne 0x1180d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x54ec9(%rip), %r15     # 0x666e0
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xe280
movq 0x4f6cc(%rip), %rax     # 0x60ef8
movq (%rax), %rdi
callq 0xe210
movq 0x4f7b5(%rip), %rax     # 0x60ff0
movq (%rax), %r12
movl %r14d, %ebp
shrl $0x6, %ebp
andl $0x3fff, %ebp           # imm = 0x3FFF
movl %ebp, %edi
callq 0x2e3c4
movq %rax, %r13
leaq 0x566b5(%rip), %rax     # 0x67f10
movq (%rax), %rsi
cmpq %rsi, %r13
je 0x11876
cmpq 0x55076(%rip), %r13     # 0x668e0
je 0x11876
movq %r13, %rdi
movl %ebp, %edx
callq 0xe320
movq %r14, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
shrl $0x16, %r14d
leaq 0x4fcb2(%rip), %rax     # 0x61540
movq (%rax), %r9
leaq 0x2fcb3(%rip), %rsi     # 0x4154b
movq %r12, %rdi
movq %r13, %rdx
movl %r14d, %r8d
xorl %eax, %eax
pushq %r15
pushq %rbx
callq 0xe1d0
addq $0x18, %rsp
jmp 0x11802
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: warning
void warning(struct position pos, const char * fmt, ...)
{
	va_list args;

	if (Wsparse_error) {
		va_start(args, fmt);
		do_error(pos, fmt, args);
		va_end(args);
		return;
	}

	if (!fmax_warnings || has_error) {
		show_info = 0;
		return;
	}

	if (!--fmax_warnings) {
		show_info = 0;
		fmt = "too many warnings";
	}

	va_start(args, fmt);
	do_warn("warning: ", pos, fmt, args);
	va_end(args);
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, %r10
movq %rdi, %rsi
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x11910
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x4fcc9(%rip), %rax     # 0x615e0
cmpl $0x0, (%rax)
je 0x1194e
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %rsi, %rdi
movq %r10, %rsi
callq 0x119c0
jmp 0x119b8
leaq 0x4fc1b(%rip), %rax     # 0x61570
movl (%rax), %ecx
testl %ecx, %ecx
je 0x119b1
leaq 0x56422(%rip), %rdx     # 0x67d84
cmpl $0x0, (%rdx)
jne 0x119b1
decl %ecx
movl %ecx, (%rax)
jne 0x1197b
movb $0x1, 0x54b5c(%rip)     # 0x664d0
leaq 0x2fb85(%rip), %r10     # 0x41500
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0x2fb6b(%rip), %rdi     # 0x41512
movq %r10, %rdx
callq 0x117e5
jmp 0x119b8
movb $0x1, 0x54b18(%rip)     # 0x664d0
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: do_error
static void do_error(struct position pos, const char * fmt, va_list args)
{
	static int errors = 0;
        die_if_error = 1;
	show_info = 1;
	/* Shut up warnings if position is bad_token.pos */
	if (pos.type == TOKEN_BAD)
		return;
	/* Shut up warnings after an error */
	has_error |= ERROR_CURR_PHASE;
	if (errors > fmax_errors) {
		static int once = 0;
		show_info = 0;
		if (once)
			return;
		fmt = "too many errors";
		once = 1;
	}

	do_warn("error: ", pos, fmt, args);
	errors++;
}

// Assembly:
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x563b0(%rip), %rax     # 0x67d80
movl $0x1, (%rax)
movb $0x0, 0x54af3(%rip)     # 0x664d0
movl %esi, %eax
andl $0x3f, %eax
cmpl $0x1, %eax
je 0x11a37
leaq 0x56396(%rip), %rax     # 0x67d84
orb $0x1, (%rax)
movl 0x54fc1(%rip), %eax     # 0x669b8
leaq 0x4fb6e(%rip), %rdi     # 0x6156c
cmpl (%rdi), %eax
jbe 0x11a20
movb $0x1, 0x54ac7(%rip)     # 0x664d0
cmpb $0x0, 0x54fac(%rip)     # 0x669bc
jne 0x11a37
movb $0x1, 0x54fa3(%rip)     # 0x669bc
leaq 0x2fb70(%rip), %rdx     # 0x41590
pushq %rax
leaq 0x2faf4(%rip), %rdi     # 0x4151c
callq 0x117e5
incl 0x54f85(%rip)           # 0x669b8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: die
NORETURN_ATTR
void die(const char *fmt, ...)
{
	va_list args;
	static char buffer[512];

	va_start(args, fmt);
	vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	fprintf(stderr, "%s%s\n", diag_prefix, buffer);
	exit(1);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x11c49
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x54870(%rip), %rbx     # 0x664e0
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
movq %r10, %rdx
callq 0xe0b0
movq 0x4f369(%rip), %rax     # 0x60ff0
movq (%rax), %rdi
leaq 0x4f8af(%rip), %rax     # 0x61540
movq (%rax), %rdx
leaq 0x2f8bc(%rip), %rsi     # 0x41557
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe1d0
movl $0x1, %edi
callq 0xe2d0
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: add_pre_buffer
void add_pre_buffer(const char *fmt, ...)
{
	va_list args;
	unsigned int size;
	struct token *begin, *end;
	char buffer[4096];

	va_start(args, fmt);
	size = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);
	begin = tokenize_buffer(buffer, size, &end);
	*pre_buffer_next = begin;
	pre_buffer_next = &end->next;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x10e8, %rsp           # imm = 0x10E8
movq %rdi, %r10
leaq 0x30(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x11d13
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x1100(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rbx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r10, %rdx
callq 0xe0b0
movl %eax, %esi
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2eefa
movq 0x4f43a(%rip), %rcx     # 0x611a0
movq %rax, (%rcx)
movq (%r14), %rax
addq $0x8, %rax
movq %rax, 0x4f429(%rip)     # 0x611a0
addq $0x10e8, %rsp           # imm = 0x10E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: sparse_keep_tokens
struct symbol_list * sparse_keep_tokens(char *filename)
{
	struct symbol_list *res;

	/* Clear previous symbol list */
	translation_unit_used_list = NULL;

	new_file_scope();
	res = sparse_file(filename);

	/* And return it */
	return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x599c9(%rip), %rax     # 0x6ba00
movq $0x0, (%rax)
callq 0x22e95
leaq 0x3935f(%rip), %rsi     # 0x4b3a9
movq %rbx, %rdi
callq 0xe1c0
testl %eax, %eax
je 0x12079
movq %rbx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0xe290
movl %eax, %ebp
testl %eax, %eax
jns 0x1207b
leaq 0x2f866(%rip), %rdi     # 0x418d5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x11bea
xorl %ebp, %ebp
leaq 0x55e8e(%rip), %rax     # 0x67f10
movq %rbx, (%rax)
leaq 0x52324(%rip), %r8      # 0x643b0
xorl %edi, %edi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2f3e3
movq %rax, %rbx
movl %ebp, %edi
callq 0xe150
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x120ef
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: sparse
struct symbol_list * sparse(char *filename)
{
	struct symbol_list *res = __sparse(filename);

	if (has_error & ERROR_CURR_PHASE)
		has_error = ERROR_PREV_PHASE;
	/* Evaluate the complete symbol list */
	evaluate_symbol_list(res);

	return res;
}

// Assembly:
pushq %rbx
callq 0x1202a
movq %rax, %rbx
callq 0x2fee5
leaq 0x55cad(%rip), %rax     # 0x67d84
testb $0x1, (%rax)
je 0x120e2
movl $0x2, (%rax)
movq %rbx, %rdi
callq 0x36f42
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/lib.c
// Function: sparse_tokenstream
static struct symbol_list *sparse_tokenstream(struct token *token)
{
	int builtin = token && !token->pos.stream;

	// Preprocess the stream
	token = preprocess(token);

	if (dump_macro_defs || dump_macros_only) {
		if (!builtin)
			dump_macro_definitions();
		if (dump_macros_only)
			return NULL;
	}

	if (preprocess_only) {
		while (!eof_token(token)) {
			int prec = 1;
			struct token *next = token->next;
			const char *separator = "";
			if (next->pos.whitespace)
				separator = " ";
			if (next->pos.newline) {
				separator = "\n\t\t\t\t\t";
				prec = next->pos.pos;
				if (prec > 4)
					prec = 4;
			}
			printf("%s%.*s", show_token(token), prec, separator);
			token = next;
		}
		putchar('\n');

		return NULL;
	}

	// Parse the resulting C code
	while (!eof_token(token))
		token = external_declaration(token, &translation_unit_used_list, NULL);
	return translation_unit_used_list;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1210b
testl $0xfffc0, (%rdi)        # imm = 0xFFFC0
sete %bpl
jmp 0x1210d
xorl %ebp, %ebp
callq 0x1f4ca
movq %rax, %rbx
leaq 0x55ca0(%rip), %rax     # 0x67dbc
leaq 0x55c9d(%rip), %r14     # 0x67dc0
movl (%r14), %ecx
orl (%rax), %ecx
je 0x1213e
testb %bpl, %bpl
jne 0x12134
callq 0x1f7f0
cmpl $0x0, (%r14)
jne 0x121d6
leaq 0x55d17(%rip), %rax     # 0x67e5c
cmpl $0x0, (%rax)
je 0x121da
cmpq 0x4ed83(%rip), %rbx     # 0x60ed8
je 0x121cc
leaq 0x2f770(%rip), %r14     # 0x418ce
leaq 0x7547b(%rip), %r13     # 0x875e0
movq 0x8(%rbx), %r12
movl (%r12), %eax
btl $0x15, %eax
leaq 0x30548(%rip), %r15     # 0x426c0
leaq 0x2f74e(%rip), %rcx     # 0x418cd
cmovaeq %rcx, %r15
movl %eax, %ebp
shrl $0x16, %ebp
cmpl $0x4, %ebp
movl $0x4, %ecx
cmovael %ecx, %ebp
btl $0x14, %eax
movl $0x1, %eax
cmovael %eax, %ebp
leaq 0x2f721(%rip), %rax     # 0x418c7
cmovbq %rax, %r15
movq %rbx, %rdi
callq 0x2e5c0
movq %r14, %rdi
movq %rax, %rsi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xe0f0
movq %r12, %rbx
cmpq %r13, %r12
jne 0x12165
movl $0xa, %edi
callq 0xe040
xorl %eax, %eax
jmp 0x12210
cmpq 0x4ecf7(%rip), %rbx     # 0x60ed8
je 0x12206
leaq 0x59816(%rip), %r14     # 0x6ba00
leaq 0x753ef(%rip), %r15     # 0x875e0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a892
movq %rax, %rbx
cmpq %r15, %rax
jne 0x121f1
leaq 0x597f3(%rip), %rax     # 0x6ba00
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop