LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: usual_conversions
static struct symbol *usual_conversions(int op,
					struct expression *left,
					struct expression *right,
					int lclass, int rclass,
					struct symbol *ltype,
					struct symbol *rtype)
{
	struct symbol *ctype;

	warn_for_different_enum_types(right->pos, left->ctype, right->ctype);

	if ((lclass | rclass) & TYPE_RESTRICT)
		goto Restr;

Normal:
	if (!(lclass & TYPE_FLOAT)) {
		if (!(rclass & TYPE_FLOAT))
			return bigger_int_type(ltype, rtype);
		else
			return rtype;
	} else if (rclass & TYPE_FLOAT) {
		if (rtype->rank > ltype->rank)
			return rtype;
		else
			return ltype;
	} else
		return ltype;

Restr:
	ctype = restricted_binop_type(op, left, right,
				      lclass, rclass, ltype, rtype);
	if (ctype)
		return ctype;

	unrestrict(left, lclass, &ltype);
	unrestrict(right, rclass, &rtype);

	goto Normal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq 0x8(%rax), %rdi
callq 0x508b0
movl -0x24(%rbp), %eax
orl -0x28(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50ea2
jmp 0x50f24
jmp 0x50ea4
movl -0x24(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x50edd
movl -0x28(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x50ed0
movq -0x30(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x50f90
movq %rax, -0x8(%rbp)
jmp 0x50f81
movq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f81
movl -0x28(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x50f1a
movq 0x10(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
movq -0x30(%rbp), %rcx
movl 0x54(%rcx), %ecx
shll $0x6, %ecx
sarl $0x1d, %ecx
cmpl %ecx, %eax
jle 0x50f10
movq 0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f81
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f81
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f81
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x510e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x50f5c
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f81
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x51240
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
leaq 0x10(%rbp), %rdx
callq 0x51240
jmp 0x50ea4
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: bigger_int_type
static struct symbol *bigger_int_type(struct symbol *left, struct symbol *right)
{
	static struct symbol *unsigned_types[] = {
		[0] = &uint_ctype,
		[1] = &ulong_ctype,
		[2] = &ullong_ctype,
		[3] = &uint128_ctype,
	};
	unsigned long lmod, rmod;
	struct symbol *stype, *utype;

	left = integer_promotion(left);
	right = integer_promotion(right);

	if (left == right)
		return left;

	lmod = left->ctype.modifiers;
	rmod = right->ctype.modifiers;
	if (((lmod ^ rmod) & MOD_UNSIGNED) == 0)
		return (left->rank > right->rank) ? left : right;
	if (lmod & MOD_UNSIGNED) {
		utype = left;
		stype = right;
	} else {
		stype = left;
		utype = right;
	}
	if (utype->rank >= stype->rank)
		return utype;
	if (stype->bit_size > utype->bit_size)
		return stype;
	utype = unsigned_types[stype->rank];
	return utype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4c110
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4c110
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x50fd1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x510d5
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
xorq -0x28(%rbp), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
jne 0x5103a
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
movq -0x18(%rbp), %rcx
movl 0x54(%rcx), %ecx
shll $0x6, %ecx
sarl $0x1d, %ecx
cmpl %ecx, %eax
jle 0x51025
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5102d
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x510d5
movq -0x20(%rbp), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
je 0x5105c
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5106c
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
movq -0x30(%rbp), %rcx
movl 0x54(%rcx), %ecx
shll $0x6, %ecx
sarl $0x1d, %ecx
cmpl %ecx, %eax
jl 0x51094
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x510d5
movq -0x30(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x38(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jle 0x510ae
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x510d5
movq -0x30(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
movslq %eax, %rcx
leaq 0x3a67b(%rip), %rax     # 0x8b740
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: restricted_binop_type
static struct symbol *restricted_binop_type(int op,
					struct expression *left,
					struct expression *right,
					int lclass, int rclass,
					struct symbol *ltype,
					struct symbol *rtype)
{
	struct symbol *ctype = NULL;
	if (lclass & TYPE_RESTRICT) {
		if (rclass & TYPE_RESTRICT) {
			if (ltype == rtype) {
				ctype = ltype;
			} else if (lclass & TYPE_FOULED) {
				if (unfoul(ltype) == rtype)
					ctype = ltype;
			} else if (rclass & TYPE_FOULED) {
				if (unfoul(rtype) == ltype)
					ctype = rtype;
			}
		} else {
			if (!restricted_value(right, ltype))
				ctype = ltype;
		}
	} else if (!restricted_value(left, rtype))
		ctype = rtype;

	if (ctype) {
		switch (restricted_binop(op, ctype)) {
		case 1:
			if ((lclass ^ rclass) & TYPE_FOULED)
				ctype = unfoul(ctype);
			break;
		case 3:
			if (!(lclass & rclass & TYPE_FOULED))
				break;
		case 0:
			ctype = NULL;
		default:
			break;
		}
	}

	return ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x511a4
movl -0x20(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51186
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jne 0x51138
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x51184
movl -0x1c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x5115c
movq -0x28(%rbp), %rdi
callq 0x512d0
cmpq 0x10(%rbp), %rax
jne 0x5115a
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x51182
movl -0x20(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x51180
movq 0x10(%rbp), %rdi
callq 0x512d0
cmpq -0x28(%rbp), %rax
jne 0x5117e
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x51180
jmp 0x51182
jmp 0x51184
jmp 0x511a2
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x512f0
cmpl $0x0, %eax
jne 0x511a0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x511a2
jmp 0x511c0
movq -0x10(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x512f0
cmpl $0x0, %eax
jne 0x511be
movq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x511c0
cmpq $0x0, -0x30(%rbp)
je 0x5122d
movl -0x4(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x51340
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
testl %eax, %eax
je 0x51221
jmp 0x511de
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x511f2
jmp 0x511e8
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x5120f
jmp 0x51229
movl -0x1c(%rbp), %eax
xorl -0x20(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x5120d
movq -0x30(%rbp), %rdi
callq 0x512d0
movq %rax, -0x30(%rbp)
jmp 0x5122b
movl -0x1c(%rbp), %eax
andl -0x20(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x5121f
jmp 0x5122b
jmp 0x51221
movq $0x0, -0x30(%rbp)
jmp 0x5122b
jmp 0x5122d
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: unrestrict
static inline void unrestrict(struct expression *expr,
			      int class, struct symbol **ctype)
{
	if (class & TYPE_RESTRICT) {
		if (class & TYPE_FOULED)
			*ctype = unfoul(*ctype);
		warning(expr->pos, "%s degrades to integer",
			show_typename(*ctype));
		*ctype = (*ctype)->ctype.base_type; /* get to arithmetic type */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x512be
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x5127f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x512d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1a90e(%rip), %rsi     # 0x6bbb3
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: restricted_value
static int restricted_value(struct expression *v, struct symbol *type)
{
	if (v->type != EXPR_VALUE)
		return 1;
	if (v->value != 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x51315
movl $0x1, -0x4(%rbp)
jmp 0x51330
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x51329
movl $0x1, -0x4(%rbp)
jmp 0x51330
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: restricted_binop
static int restricted_binop(int op, struct symbol *type)
{
	switch (op) {
		case '&':
		case '=':
		case SPECIAL_AND_ASSIGN:
		case SPECIAL_OR_ASSIGN:
		case SPECIAL_XOR_ASSIGN:
			return 1;	/* unfoul */
		case '|':
		case '^':
		case '?':
			return 2;	/* keep fouled */
		case SPECIAL_EQUAL:
		case SPECIAL_NOTEQUAL:
			return 3;	/* warn if fouled */
		default:
			return 0;	/* warn */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x26, %eax
je 0x513aa
jmp 0x51358
movl -0x14(%rbp), %eax
subl $0x3d, %eax
je 0x513aa
jmp 0x51362
movl -0x14(%rbp), %eax
subl $0x3f, %eax
je 0x513b3
jmp 0x5136c
movl -0x14(%rbp), %eax
subl $0x5e, %eax
je 0x513b3
jmp 0x51376
movl -0x14(%rbp), %eax
subl $0x7c, %eax
je 0x513b3
jmp 0x51380
movl -0x14(%rbp), %eax
addl $0xfffffef6, %eax       # imm = 0xFFFFFEF6
subl $0x2, %eax
jb 0x513bc
jmp 0x5138f
movl -0x14(%rbp), %eax
subl $0x10d, %eax            # imm = 0x10D
je 0x513aa
jmp 0x5139b
movl -0x14(%rbp), %eax
addl $0xfffffef1, %eax       # imm = 0xFFFFFEF1
subl $0x1, %eax
ja 0x513c5
jmp 0x513aa
movl $0x1, -0x4(%rbp)
jmp 0x513cc
movl $0x2, -0x4(%rbp)
jmp 0x513cc
movl $0x3, -0x4(%rbp)
jmp 0x513cc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: mark_addressable
static void mark_addressable(struct expression *expr)
{
	while (expr->type == EXPR_BINOP && expr->op == '+')
		expr = expr->left;
	if (expr->type == EXPR_SYMBOL) {
		struct symbol *sym = expr->symbol;
		sym->ctype.modifiers |= MOD_ADDRESSABLE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
xorl %eax, %eax
cmpl $0x5, %ecx
movb %al, -0x11(%rbp)
jne 0x5161c
movq -0x8(%rbp), %rax
cmpl $0x2b, 0x4(%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x51625
jmp 0x51633
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x515f8
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x51662
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
orq $0x100, %rcx            # imm = 0x100
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: compatible_transparent_union
static int compatible_transparent_union(struct symbol *target,
	struct expression **rp)
{
	struct symbol *t, *member;
	classify_type(target, &t);
	if (t->type != SYM_UNION || !t->transparent_union)
		return 0;

	FOR_EACH_PTR(t->symbol_list, member) {
		const char *typediff;
		if (check_assignment_types(member, rp, &typediff))
			return 1;
	} END_FOR_EACH_PTR(member);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4bf20
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
jne 0x516af
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x16, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x516bb
movl $0x0, -0x4(%rbp)
jmp 0x51780
jmp 0x516bd
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x516e8
jmp 0x51779
jmp 0x516ea
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x51761
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x51735
cmpq $0x0, -0x28(%rbp)
jne 0x51735
jmp 0x51756
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x518a0
cmpl $0x0, %eax
je 0x51754
movl $0x1, -0x4(%rbp)
jmp 0x51780
jmp 0x51756
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x516f1
jmp 0x51763
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x516ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: compatible_assignment_types
static int compatible_assignment_types(struct expression *expr, struct symbol *target,
	struct expression **rp, const char *where)
{
	const char *typediff;

	if (!check_assignment_types(target, rp, &typediff)) {
		struct symbol *source = *rp ? (*rp)->ctype : NULL;
		warning(expr->pos, "incorrect type in %s (%s)", where, typediff);
		info(expr->pos, "   expected %s", show_typename(target));
		info(expr->pos, "   got %s", show_typename(source));
		*rp = cast_to(*rp, target);
		return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x518a0
cmpl $0x0, %eax
jne 0x51882
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x517dd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x517e5
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x517e5
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x8(%rax), %rdi
leaq 0x1a474(%rip), %rsi     # 0x6bc78
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1a464(%rip), %rsi     # 0x6bc92
movb $0x0, %al
callq 0x16c10
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1a449(%rip), %rsi     # 0x6bca1
movb $0x0, %al
callq 0x16c10
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c020
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x51889
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: is_null_pointer_constant
static inline int is_null_pointer_constant(struct expression *e)
{
	if (e->ctype == &null_ctype)
		return NULL_PTR;
	if (!(e->flags & CEF_ICE))
		return NON_NULL;
	return is_zero_constant(e) ? NULL_ZERO : NON_NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x410f1(%rip), %rcx     # 0x92d78
cmpq %rcx, 0x10(%rax)
jne 0x51c96
movl $0x1, -0x4(%rbp)
jmp 0x51cd0
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x51cb5
movl $0x0, -0x4(%rbp)
jmp 0x51cd0
movq -0x10(%rbp), %rdi
callq 0x12290
movl %eax, %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: whitelist_pointers
static int whitelist_pointers(struct symbol *t1, struct symbol *t2)
{
	if (t1 == t2)
		return 0;	/* yes, 0 - we don't want a cast_to here */
	if (t1 == &void_ctype)
		return 1;
	if (t2 == &void_ctype)
		return 1;
	if (classify_type(t1, &t1) != TYPE_NUM)
		return 0;
	if (classify_type(t2, &t2) != TYPE_NUM)
		return 0;
	if (t1 == t2)
		return 1;
	if (t1->rank == -2 && t2->rank == -2)
		return 1;
	if (t1->rank != t2->rank)
		return 0;
	return !Wtypesign;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x51d46
movl $0x0, -0x4(%rbp)
jmp 0x51e2f
leaq 0x3f7ab(%rip), %rax     # 0x914f8
cmpq %rax, -0x10(%rbp)
jne 0x51d5f
movl $0x1, -0x4(%rbp)
jmp 0x51e2f
leaq 0x3f792(%rip), %rax     # 0x914f8
cmpq %rax, -0x18(%rbp)
jne 0x51d78
movl $0x1, -0x4(%rbp)
jmp 0x51e2f
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4bf20
cmpl $0x1, %eax
je 0x51d96
movl $0x0, -0x4(%rbp)
jmp 0x51e2f
movq -0x18(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4bf20
cmpl $0x1, %eax
je 0x51db1
movl $0x0, -0x4(%rbp)
jmp 0x51e2f
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x51dc4
movl $0x1, -0x4(%rbp)
jmp 0x51e2f
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
cmpl $-0x2, %eax
jne 0x51df1
movq -0x18(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
cmpl $-0x2, %eax
jne 0x51df1
movl $0x1, -0x4(%rbp)
jmp 0x51e2f
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
shll $0x6, %eax
sarl $0x1d, %eax
movq -0x18(%rbp), %rcx
movl 0x54(%rcx), %ecx
shll $0x6, %ecx
sarl $0x1d, %ecx
cmpl %ecx, %eax
je 0x51e18
movl $0x0, -0x4(%rbp)
jmp 0x51e2f
leaq 0x3b401(%rip), %rax     # 0x8d220
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: bad_expr_type
static struct symbol *bad_expr_type(struct expression *expr)
{
	switch (expr->type) {
	case EXPR_BINOP:
	case EXPR_COMPARE:
		if (!valid_subexpr_type(expr))
			break;
		sparse_error(expr->pos, "incompatible types for operation (%s):", show_special(expr->op));
		info(expr->pos, "   %s", show_typename(expr->left->ctype));
		info(expr->pos, "   %s", show_typename(expr->right->ctype));
		break;
	case EXPR_PREOP:
	case EXPR_POSTOP:
		if (!valid_expr_type(expr->unop))
			break;
		sparse_error(expr->pos, "incompatible type for operation (%s):", show_special(expr->op));
		info(expr->pos, "   %s", show_typename(expr->unop->ctype));
		break;
	default:
		break;
	}

	expr->flags = CEF_NONE;
	return expr->ctype = &bad_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x5, %eax
je 0x51f0c
jmp 0x51eed
movl -0xc(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x51fb2
jmp 0x51efe
movl -0xc(%rbp), %eax
subl $0x16, %eax
jne 0x52027
jmp 0x51f0c
movq -0x8(%rbp), %rdi
callq 0x4c960
cmpl $0x0, %eax
jne 0x51f1f
jmp 0x52029
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x440f0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x19db0(%rip), %rsi     # 0x6bcf5
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x184ec(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x184ba(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
jmp 0x52029
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x51e60
cmpl $0x0, %eax
jne 0x51fc6
jmp 0x52029
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x440f0
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x19d30(%rip), %rsi     # 0x6bd1c
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x18445(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
jmp 0x52029
jmp 0x52029
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x40c53(%rip), %rcx     # 0x92c98
movq %rcx, 0x10(%rax)
leaq 0x40c48(%rip), %rax     # 0x92c98
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: target_qualifiers
static unsigned long target_qualifiers(struct symbol *type)
{
	unsigned long mod = type->ctype.modifiers & MOD_IGN;
	if (type->ctype.base_type && type->ctype.base_type->type == SYM_ARRAY)
		mod = 0;
	return mod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x11000e00, %rax       # imm = 0x11000E00
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x526b1
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x6, %eax
jne 0x526b1
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_conditional
static struct symbol *evaluate_conditional(struct expression *expr, int iterator)
{
	struct symbol *ctype;

	if (!expr)
		return NULL;

	if (!iterator && expr->type == EXPR_ASSIGNMENT && expr->op == '=')
		warning(expr->pos, "assignment expression in conditional");

	ctype = evaluate_expression(expr);
	if (!valid_type(ctype))
		return NULL;
	if (is_safe_type(ctype))
		warning(expr->pos, "testing a 'safe expression'");
	if (is_func_type(ctype)) {
		if (Waddress)
			warning(expr->pos, "the address of %s will always evaluate as true", "a function");
	} else if (is_array_type(ctype)) {
		if (Waddress)
			warning(expr->pos, "the address of %s will always evaluate as true", "an array");
	} else if (!is_scalar_type(ctype)) {
		sparse_error(expr->pos, "non-scalar type in conditional:");
		info(expr->pos, "   %s", show_typename(ctype));
		return NULL;
	}

	ctype = degenerate(expr);
	return ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x526e3
movq $0x0, -0x8(%rbp)
jmp 0x52851
cmpl $0x0, -0x14(%rbp)
jne 0x52719
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x6, %eax
jne 0x52719
movq -0x10(%rbp), %rax
cmpl $0x3d, 0x4(%rax)
jne 0x52719
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1971a(%rip), %rsi     # 0x6be2c
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rdi
callq 0x4bb70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x51ea0
cmpl $0x0, %eax
jne 0x52741
movq $0x0, -0x8(%rbp)
jmp 0x52851
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
je 0x5276b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x196ed(%rip), %rsi     # 0x6be51
movb $0x0, %al
callq 0x16d80
movq -0x20(%rbp), %rdi
callq 0x52860
cmpl $0x0, %eax
je 0x527a7
leaq 0x3aa40(%rip), %rax     # 0x8d1c0
cmpl $0x0, (%rax)
je 0x527a2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x196d9(%rip), %rsi     # 0x6be6d
leaq 0x199e1(%rip), %rdx     # 0x6c17c
movb $0x0, %al
callq 0x16d80
jmp 0x5283c
movq -0x20(%rbp), %rdi
callq 0x528a0
cmpl $0x0, %eax
je 0x527e0
leaq 0x3aa04(%rip), %rax     # 0x8d1c0
cmpl $0x0, (%rax)
je 0x527de
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1969d(%rip), %rsi     # 0x6be6d
leaq 0x196c5(%rip), %rdx     # 0x6be9c
movb $0x0, %al
callq 0x16d80
jmp 0x5283a
movq -0x20(%rbp), %rdi
callq 0x528e0
cmpl $0x0, %eax
jne 0x52838
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x196a8(%rip), %rsi     # 0x6bea5
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x33340
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x17c3c(%rip), %rsi     # 0x6a463
movb $0x0, %al
callq 0x16c10
movq $0x0, -0x8(%rbp)
jmp 0x52851
jmp 0x5283a
jmp 0x5283c
movq -0x10(%rbp), %rdi
callq 0x4c1c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: modify_for_unsigned
static int modify_for_unsigned(int op)
{
	if (op == '<')
		op = SPECIAL_UNSIGNED_LT;
	else if (op == '>')
		op = SPECIAL_UNSIGNED_GT;
	else if (op == SPECIAL_LTE)
		op = SPECIAL_UNSIGNED_LTE;
	else if (op == SPECIAL_GTE)
		op = SPECIAL_UNSIGNED_GTE;
	return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x3c, -0x4(%rbp)
jne 0x529c6
movl $0x119, -0x4(%rbp)      # imm = 0x119
jmp 0x529fd
cmpl $0x3e, -0x4(%rbp)
jne 0x529d5
movl $0x11a, -0x4(%rbp)      # imm = 0x11A
jmp 0x529fb
cmpl $0x108, -0x4(%rbp)      # imm = 0x108
jne 0x529e7
movl $0x11b, -0x4(%rbp)      # imm = 0x11B
jmp 0x529f9
cmpl $0x109, -0x4(%rbp)      # imm = 0x109
jne 0x529f7
movl $0x11c, -0x4(%rbp)      # imm = 0x11C
jmp 0x529f9
jmp 0x529fb
jmp 0x529fd
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: compatible_float_op
static int compatible_float_op(int op)
{
	return	op == SPECIAL_ADD_ASSIGN ||
		op == SPECIAL_SUB_ASSIGN ||
		op == SPECIAL_MUL_ASSIGN ||
		op == SPECIAL_DIV_ASSIGN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
movb %al, -0x5(%rbp)
je 0x52e9e
movb $0x1, %al
cmpl $0x102, -0x4(%rbp)      # imm = 0x102
movb %al, -0x5(%rbp)
je 0x52e9e
movb $0x1, %al
cmpl $0x105, -0x4(%rbp)      # imm = 0x105
movb %al, -0x5(%rbp)
je 0x52e9e
cmpl $0x106, -0x4(%rbp)      # imm = 0x106
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: mark_assigned
static void mark_assigned(struct expression *expr)
{
	struct symbol *sym;

	if (!expr)
		return;
	switch (expr->type) {
	case EXPR_SYMBOL:
		sym = expr->symbol;
		if (!sym)
			return;
		if (sym->type != SYM_NODE)
			return;
		sym->ctype.modifiers |= MOD_ASSIGNED;
		return;

	case EXPR_BINOP:
		mark_assigned(expr->left);
		mark_assigned(expr->right);
		return;
	case EXPR_CAST:
	case EXPR_FORCE_CAST:
		mark_assigned(expr->cast_expression);
		return;
	case EXPR_SLICE:
		mark_assigned(expr->base);
		return;
	default:
		/* Hmm? */
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x52ec8
jmp 0x52f6d
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1a, %eax
ja 0x52f6b
movq -0x18(%rbp), %rax
leaq 0x18840(%rip), %rcx     # 0x6b72c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x52f0a
jmp 0x52f6d
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
je 0x52f1c
jmp 0x52f6d
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
orq $0x80, %rcx
movq %rcx, 0x68(%rax)
jmp 0x52f6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x52eb0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52eb0
jmp 0x52f6d
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x52eb0
jmp 0x52f6d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x52eb0
jmp 0x52f6d
jmp 0x52f6d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_sign
static struct symbol *evaluate_sign(struct expression *expr)
{
	struct symbol *ctype = expr->unop->ctype;
	int class = classify_type(ctype, &ctype);
	unsigned char flags = expr->unop->flags & ~CEF_CONST_MASK;

	/* should be an arithmetic type */
	if (!(class & TYPE_NUM))
		return bad_expr_type(expr);
	if (class & TYPE_RESTRICT)
		goto Restr;
Normal:
	if (!(class & TYPE_FLOAT)) {
		ctype = integer_promotion(ctype);
		expr->unop = cast_to(expr->unop, ctype);
	} else if (expr->op != '~') {
		/* no conversions needed */
	} else {
		return bad_expr_type(expr);
	}
	if (expr->op == '+')
		*expr = *expr->unop;
	expr->flags = flags;
	expr->ctype = ctype;
	return ctype;
Restr:
	if (restricted_unop(expr->op, &ctype))
		unrestrict(expr, class, &ctype);
	goto Normal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4bf20
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
andl $-0xc, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x52fe1
movq -0x10(%rbp), %rdi
callq 0x51ed0
movq %rax, -0x8(%rbp)
jmp 0x530c3
movl -0x1c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x52ff1
jmp 0x53099
jmp 0x52ff3
movl -0x1c(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x53029
movq -0x18(%rbp), %rdi
callq 0x4c110
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x53046
movq -0x10(%rbp), %rax
cmpl $0x7e, 0x4(%rax)
je 0x53035
jmp 0x53044
movq -0x10(%rbp), %rdi
callq 0x51ed0
movq %rax, -0x8(%rbp)
jmp 0x530c3
jmp 0x53046
movq -0x10(%rbp), %rax
cmpl $0x2b, 0x4(%rax)
jne 0x53066
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x40, %edx
callq 0x111d0
movzbl -0x1d(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x530c3
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x18(%rbp), %rsi
callq 0x53430
cmpl $0x0, %eax
je 0x530be
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdx
callq 0x51240
jmp 0x52ff3
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_addressof
static struct symbol *evaluate_addressof(struct expression *expr)
{
	struct expression *op = expr->unop;
	struct symbol *ctype;

	if (op->op != '*' || op->type != EXPR_PREOP) {
		expression_error(expr, "not addressable");
		return NULL;
	}
	ctype = op->ctype;
	if (ctype->builtin)
		sparse_error(expr->pos, "taking the address of built-in function '%s'", show_ident(ctype->ident));
	*expr = *op->unop;

	mark_addressable(expr);

	/*
	 * symbol expression evaluation is lazy about the type
	 * of the sub-expression, so we may have to generate
	 * the type here if so..
	 */
	if (expr->ctype == &lazy_ptr_ctype) {
		ctype = create_pointer(expr, ctype, 0);
		expr->ctype = ctype;
	}
	return expr->ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2a, 0x4(%rax)
jne 0x53312
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x9, %eax
je 0x53331
movq -0x10(%rbp), %rdi
leaq 0x18cbb(%rip), %rsi     # 0x6bfd8
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x533d8
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
shrl $0x13, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5337d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x18878(%rip), %rsi     # 0x6bbee
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x40, %edx
callq 0x111d0
movq -0x10(%rbp), %rdi
callq 0x515f0
movq -0x10(%rbp), %rax
leaq 0x3f651(%rip), %rcx     # 0x929f8
cmpq %rcx, 0x10(%rax)
jne 0x533cc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x51420
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: restricted_unop
static int restricted_unop(int op, struct symbol **type)
{
	if (op == '~') {
		if ((*type)->bit_size < bits_in_int)
			*type = befoul(*type);
		return 0;
	} if (op == '+')
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x7e, -0x8(%rbp)
jne 0x53479
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x50(%rax), %eax
leaq 0x37282(%rip), %rcx     # 0x8a6d8
cmpl (%rcx), %eax
jge 0x53470
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x40340
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5348f
cmpl $0x2b, -0x8(%rbp)
jne 0x53488
movl $0x0, -0x4(%rbp)
jmp 0x5348f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_compound_literal
static struct symbol *evaluate_compound_literal(struct expression *expr, struct expression *source)
{
	struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
	struct symbol *sym = expr->cast_type;

	sym->initializer = source;
	evaluate_symbol(sym);

	addr->ctype = &lazy_ptr_ctype;	/* Lazy eval */
	addr->symbol = sym;
	if (sym->ctype.modifiers & MOD_TOPLEVEL)
		addr->flags |= CEF_ADDR;

	expr->type = EXPR_PREOP;
	expr->op = '*';
	expr->deref = addr;
	expr->ctype = sym;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3, %esi
callq 0x50ab0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x20(%rbp), %rdi
callq 0x4f490
movq -0x18(%rbp), %rax
leaq 0x3f503(%rip), %rcx     # 0x929f8
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x5353e
movq -0x18(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
orl $0x40, %edx
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x9, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x2a, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: find_member_type
static struct symbol *find_member_type(struct symbol *utype, struct symbol *type)
{
	struct symbol *t, *member;

	if (utype->type != SYM_UNION)
		return NULL;

	FOR_EACH_PTR(utype->symbol_list, member) {
		classify_type(member, &t);
		if (type == t)
			return member;
	} END_FOR_EACH_PTR(member);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
je 0x535ad
movq $0x0, -0x8(%rbp)
jmp 0x53675
jmp 0x535af
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x535da
jmp 0x5366d
jmp 0x535dc
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x53655
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x53627
cmpq $0x0, -0x28(%rbp)
jne 0x53627
jmp 0x5364a
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4bf20
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x53648
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53675
jmp 0x5364a
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x535e3
jmp 0x53657
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x535dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_type_information
static struct symbol *evaluate_type_information(struct expression *expr)
{
	struct symbol *sym = expr->cast_type;
	if (!sym) {
		sym = evaluate_expression(expr->cast_expression);
		if (!sym)
			return NULL;
		/*
		 * Expressions of restricted types will possibly get
		 * promoted - check that here
		 */
		if (is_restricted_type(sym)) {
			if (sym->bit_size < bits_in_int && is_promoted(expr))
				sym = &int_ctype;
		} else if (is_fouled_type(sym)) {
			sym = &int_ctype;
		}
	}
	examine_symbol_type(sym);
	if (is_bitfield_type(sym)) {
		expression_error(expr, "trying to examine bitfield type");
		return NULL;
	}
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5377c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4bb70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x53724
movq $0x0, -0x8(%rbp)
jmp 0x537b7
movq -0x18(%rbp), %rdi
callq 0x51c20
cmpl $0xd, %eax
jne 0x5375f
movq -0x18(%rbp), %rax
movl 0x50(%rax), %eax
leaq 0x36f98(%rip), %rcx     # 0x8a6d8
cmpl (%rcx), %eax
jge 0x5375d
movq -0x10(%rbp), %rdi
callq 0x53810
cmpl $0x0, %eax
je 0x5375d
leaq 0x3e3bf(%rip), %rax     # 0x91b18
movq %rax, -0x18(%rbp)
jmp 0x5377a
movq -0x18(%rbp), %rdi
callq 0x51c20
cmpl $0xe, %eax
jne 0x53778
leaq 0x3e3a4(%rip), %rax     # 0x91b18
movq %rax, -0x18(%rbp)
jmp 0x5377a
jmp 0x5377c
movq -0x18(%rbp), %rdi
callq 0x3f650
movq -0x18(%rbp), %rdi
callq 0x51c20
cmpl $0xb, %eax
jne 0x537af
movq -0x10(%rbp), %rdi
leaq 0x18a25(%rip), %rsi     # 0x6c1c3
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x537b7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: is_promoted
static int is_promoted(struct expression *expr)
{
	while (1) {
		switch (expr->type) {
		case EXPR_BINOP:
		case EXPR_SELECT:
		case EXPR_CONDITIONAL:
			return 1;
		case EXPR_COMMA:
			expr = expr->right;
			continue;
		case EXPR_PREOP:
			switch (expr->op) {
			case '(':
				expr = expr->unop;
				continue;
			case '+':
			case '-':
			case '~':
				return 1;
			default:
				return 0;
			}
		default:
			return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
addl $-0x5, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x10, %eax
ja 0x538a7
movq -0x18(%rbp), %rax
leaq 0x17f60(%rip), %rcx     # 0x6b798
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x538ae
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x53818
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x28, %eax
je 0x53887
jmp 0x53869
movl -0x1c(%rbp), %eax
subl $0x2b, %eax
je 0x53895
jmp 0x53873
movl -0x1c(%rbp), %eax
subl $0x2d, %eax
je 0x53895
jmp 0x5387d
movl -0x1c(%rbp), %eax
subl $0x7e, %eax
je 0x53895
jmp 0x5389e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x53818
movl $0x1, -0x4(%rbp)
jmp 0x538ae
movl $0x0, -0x4(%rbp)
jmp 0x538ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: find_identifier
static struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset)
{
	struct ptr_list *head = (struct ptr_list *)_list;
	struct ptr_list *list = head;

	if (!head)
		return NULL;
	do {
		int i;
		for (i = 0; i < list->nr; i++) {
			struct symbol *sym = (struct symbol *) list->list[i];
			if (sym->ident) {
				if (sym->ident != ident)
					continue;
				*offset = sym->offset;
				return sym;
			} else {
				struct symbol *ctype = sym->ctype.base_type;
				struct symbol *sub;
				if (!ctype)
					continue;
				if (ctype->type != SYM_UNION && ctype->type != SYM_STRUCT)
					continue;
				sub = find_identifier(ident, ctype->symbol_list, offset);
				if (!sub)
					continue;
				*offset += sym->offset;
				return sub;
			}	
		}
	} while ((list = list->next) != head);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x538f8
movq $0x0, -0x8(%rbp)
jmp 0x53a12
jmp 0x538fa
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x539f2
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x5396a
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x5394d
jmp 0x539e4
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53a12
movq -0x40(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x5397f
jmp 0x539e4
movq -0x48(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
je 0x539a1
movq -0x48(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x7, %eax
je 0x539a1
jmp 0x539e4
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x538c0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x539c6
jmp 0x539e4
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53a12
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x53901
jmp 0x539f4
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x538fa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: convert_to_as_mod
static struct symbol *convert_to_as_mod(struct symbol *sym, struct ident *as, int mod)
{
	/* Take the modifiers of the pointer, and apply them to the member */
	mod |= sym->ctype.modifiers;
	if (sym->ctype.as != as || sym->ctype.modifiers != mod) {
		struct symbol *newsym = alloc_symbol(sym->pos, SYM_NODE);
		*newsym = *sym;
		newsym->ctype.as = as;
		newsym->ctype.modifiers = mod;
		sym = newsym;
	}
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movslq -0x14(%rbp), %rax
orq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x53a67
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x53ab2
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0xe0, %edx
callq 0x111d0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_offset
static struct expression *evaluate_offset(struct expression *expr, unsigned long offset)
{
	struct expression *add;

	/*
	 * Create a new add-expression
	 *
	 * NOTE! Even if we just add zero, we need a new node
	 * for the member pointer, since it has a different
	 * type than the original pointer. We could make that
	 * be just a cast, but the fact is, a node is a node,
	 * so we might as well just do the "add zero" here.
	 */
	add = alloc_expression(expr->pos, EXPR_BINOP);
	add->op = '+';
	add->left = expr;
	add->right = alloc_expression(expr->pos, EXPR_VALUE);
	add->right->ctype = &int_ctype;
	add->right->value = offset;

	/*
	 * The ctype of the pointer will be lazily evaluated if
	 * we ever take the address of this member dereference..
	 */
	add->ctype = &lazy_ptr_ctype;
	/*
	 * The resulting address of a member access through an address
	 * constant is an address constant again [6.6(9)].
	 */
	add->flags = expr->flags;

	return add;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x5, %esi
callq 0x50ab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x2b, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x50ab0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0x3dfcf(%rip), %rcx     # 0x91b18
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x3ee90(%rip), %rcx     # 0x929f8
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edx
shrl $0x8, %edx
andl $0xff, %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop