LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_initializer
static void emit_initializer(struct symbol *sym,
			     struct expression *expr)
{
	int distance = ea_current - ea_last - 1;

	if (distance > 0)
		printf("\t.zero\t%d\n", (sym->bit_size / 8) * distance);

	if (expr->type == EXPR_VALUE) {
		struct symbol *base_type = sym->ctype.base_type;
		assert(base_type != NULL);

		emit_scalar(expr, sym->bit_size / get_expression_value(base_type->array_size));
		return;
	}
	if (expr->type != EXPR_INITIALIZER)
		return;

	assert(0); /* FIXME */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x5d5e6(%rip), %eax     # 0xbfdac
subl 0x5d5dc(%rip), %eax     # 0xbfda8
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x627fb
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %esi
imull -0x14(%rbp), %esi
leaq 0xffe2(%rip), %rdi      # 0x727d6
movb $0x0, %al
callq 0x11110
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x62879
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62820
jmp 0x6283f
leaq 0xff5b(%rip), %rdi      # 0x72782
leaq 0xff66(%rip), %rsi      # 0x72794
movl $0x3c9, %edx            # imm = 0x3C9
leaq 0xffa7(%rip), %rcx      # 0x727e1
callq 0x11140
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x12060
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
cqto
idivq %rcx
movl %eax, %esi
callq 0x61810
jmp 0x628aa
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x18, %eax
je 0x6288b
jmp 0x628aa
leaq 0x8fe7(%rip), %rdi      # 0x6b879
leaq 0xfefb(%rip), %rsi      # 0x72794
movl $0x3d1, %edx            # imm = 0x3D1
leaq 0xff3c(%rip), %rcx      # 0x727e1
callq 0x11140
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: sort_array_cmp
static int sort_array_cmp(const struct expression *a,
			  const struct expression *b)
{
	int a_ofs = 0, b_ofs = 0;

	if (a->type == EXPR_POS)
		a_ofs = (int) a->init_offset;
	if (b->type == EXPR_POS)
		b_ofs = (int) b->init_offset;

	return a_ofs - b_ofs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
jne 0x62904
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1b, %eax
jne 0x6291e
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_global_noinit
static void emit_global_noinit(const char *name, unsigned long modifiers,
			       unsigned long alignment, unsigned int byte_size)
{
	char s[64];

	if (modifiers & MOD_STATIC) {
		sprintf(s, "\t.local\t%s\n", name);
		textbuf_push(&unit_post_text, s);
	}
	if (alignment)
		sprintf(s, "\t.comm\t%s,%d,%lu\n", name, byte_size, alignment);
	else
		sprintf(s, "\t.comm\t%s,%d\n", name, byte_size);
	textbuf_push(&unit_post_text, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x6297b
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xfeb9(%rip), %rsi      # 0x7281d
movb $0x0, %al
callq 0x112f0
leaq -0x60(%rbp), %rsi
leaq 0x5d42a(%rip), %rdi     # 0xbfda0
callq 0x629d0
cmpq $0x0, -0x18(%rbp)
je 0x629a1
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq 0xfe91(%rip), %rsi      # 0x72829
movb $0x0, %al
callq 0x112f0
jmp 0x629ba
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0xfe88(%rip), %rsi      # 0x7283b
movb $0x0, %al
callq 0x112f0
leaq -0x60(%rbp), %rsi
leaq 0x5d3db(%rip), %rdi     # 0xbfda0
callq 0x629d0
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: textbuf_push
static void textbuf_push(struct textbuf **buf_p, const char *text)
{
	struct textbuf *tmp, *list = *buf_p;
	unsigned int text_len = strlen(text);
	unsigned int alloc_len = text_len + 1 + sizeof(*list);

	tmp = calloc(1, alloc_len);
	if (!tmp)
		die("OOM on textbuf alloc");

	tmp->text = ((void *) tmp) + sizeof(*tmp);
	memcpy(tmp->text, text, text_len + 1);
	tmp->len = text_len;

	/* add to end of list */
	if (!list) {
		list = tmp;
		tmp->prev = tmp;
	} else {
		tmp->prev = list->prev;
		tmp->prev->next = tmp;
		list->prev = tmp;
	}
	tmp->next = list;

	*buf_p = list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x110e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
addq $0x20, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %esi
movl $0x1, %edi
callq 0x111d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x62a2e
leaq 0xfe22(%rip), %rdi      # 0x72849
movb $0x0, %al
callq 0x17200
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
callq 0x11200
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x62a7f
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x62aab
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_section
static void emit_section(const char *s)
{
	if (s == current_section)
		return;
	if (current_section && (!strcmp(s, current_section)))
		return;

	printf("\t%s\n", s);
	current_section = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x5d2c9(%rip), %rax     # 0xbfdb0
jne 0x62aeb
jmp 0x62b29
cmpq $0x0, 0x5d2bd(%rip)     # 0xbfdb0
je 0x62b0c
movq -0x8(%rbp), %rdi
movq 0x5d2b0(%rip), %rsi     # 0xbfdb0
callq 0x111e0
cmpl $0x0, %eax
jne 0x62b0c
jmp 0x62b29
movq -0x8(%rbp), %rsi
leaq 0x94bf(%rip), %rdi      # 0x6bfd6
movb $0x0, %al
callq 0x11110
movq -0x8(%rbp), %rax
movq %rax, 0x5d287(%rip)     # 0xbfdb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_return_stmt
static struct storage *emit_return_stmt(struct statement *stmt)
{
	struct function *f = current_func;
	struct expression *expr = stmt->ret_value;
	struct storage *val = NULL, *jmplbl;

	if (expr && expr->ctype) {
		val = x86_expression(expr);
		assert(val != NULL);
		emit_move(val, REG_EAX, expr->ctype, "return");
	}

	jmplbl = new_storage(STOR_LABEL);
	jmplbl->flags |= STOR_WANTS_FREE;
	jmplbl->label = f->ret_target;
	insn("jmp", jmplbl, NULL, NULL);

	return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5d255(%rip), %rax     # 0xbfdb8
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x62be8
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x62be8
movq -0x18(%rbp), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62ba3
jmp 0x62bc2
leaq 0xfdf3(%rip), %rdi      # 0x7299d
leaq 0xfbe3(%rip), %rsi      # 0x72794
movl $0x606, %edx            # imm = 0x606
leaq 0xfdec(%rip), %rcx      # 0x729a9
callq 0x11140
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2fcbb(%rip), %rsi     # 0x92890
addq $0x330, %rsi            # imm = 0x330
leaq 0x673e(%rip), %rcx      # 0x69321
callq 0x63640
movl $0x5, %edi
callq 0x63490
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rsi
leaq 0xa59a(%rip), %rdi      # 0x6d1b9
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63500
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_symbol_decl
static void x86_symbol_decl(struct symbol_list *syms)
{
	struct symbol *sym;
	FOR_EACH_PTR(syms, sym) {
		x86_symbol_init(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x62c6d
jmp 0x62ce2
jmp 0x62c6f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x62cce
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x62cba
cmpq $0x0, -0x10(%rbp)
jne 0x62cba
jmp 0x62cc3
movq -0x10(%rbp), %rdi
callq 0x63960
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x62c76
jmp 0x62cd0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x62c6f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_if_conditional
static void emit_if_conditional(struct statement *stmt)
{
	struct storage *val;
	int cond_end;

	/* emit test portion of conditional */
	val = x86_expression(stmt->if_conditional);
	cond_end = emit_conditional_test(val);

	/* emit if-true statement */
	x86_statement(stmt->if_true);

	/* emit if-false statement, if present */
	if (stmt->if_false) {
		cond_end = emit_conditional_end(cond_end);
		x86_statement(stmt->if_false);
	}

	/* end of conditional; jump target for if-true branch */
	emit_label(cond_end, "end if");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x62220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63ac0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x61d70
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x62d49
movl -0x14(%rbp), %edi
callq 0x63b60
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x61d70
movl -0x14(%rbp), %edi
leaq 0xfd42(%rip), %rsi      # 0x72a95
callq 0x63bd0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: new_storage
static struct storage *new_storage(enum storage_type type)
{
	struct storage *stor;

	stor = calloc(1, sizeof(*stor));
	if (!stor)
		die("OOM in new_storage");

	stor->type = type;

	return stor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x111d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x634c3
leaq 0xf78f(%rip), %rdi      # 0x72c4b
movb $0x0, %al
callq 0x17200
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: insn
static void insn(const char *insn, struct storage *op1, struct storage *op2,
		 const char *comment_in)
{
	struct function *f = current_func;
	struct atom *atom = new_atom(ATOM_INSN);

	assert(insn != NULL);

	strcpy(atom->insn, insn);
	if (comment_in && (*comment_in))
		strncpy(atom->comment, comment_in,
			sizeof(atom->comment) - 1);

	atom->op1 = op1;
	atom->op2 = op2;

	push_atom(f, atom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq 0x5c899(%rip), %rax     # 0xbfdb8
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x63ec0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6353a
jmp 0x63559
leaq 0xf71d(%rip), %rdi      # 0x72c5e
leaq 0xf24c(%rip), %rsi      # 0x72794
movl $0x277, %edx            # imm = 0x277
leaq 0xf717(%rip), %rcx      # 0x72c6b
callq 0x11140
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
callq 0x110a0
cmpq $0x0, -0x20(%rbp)
je 0x63597
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x63597
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
movl $0x27, %edx
callq 0x11080
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x63f10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: new_labelsym
static struct storage *new_labelsym(struct symbol *sym)
{
	struct storage *stor;

	stor = new_storage(STOR_LABELSYM);

	if (stor) {
		stor->flags |= STOR_WANTS_FREE;
		stor->labelsym = sym;
	}

	return stor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x6, %edi
callq 0x63490
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6362d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: opbits
static const char *opbits(const char *insn, unsigned int bits)
{
	static char opbits_str[32];
	char c;

	switch (bits) {
	case 8:	 c = 'b'; break;
	case 16: c = 'w'; break;
	case 32: c = 'l'; break;
	case 64: c = 'q'; break;
	default: abort(); break;
	}

	sprintf(opbits_str, "%s%c", insn, c);

	return opbits_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x8, %eax
je 0x6390a
jmp 0x638ec
movl -0x14(%rbp), %eax
subl $0x10, %eax
je 0x63910
jmp 0x638f6
movl -0x14(%rbp), %eax
subl $0x20, %eax
je 0x63916
jmp 0x63900
movl -0x14(%rbp), %eax
subl $0x40, %eax
je 0x6391c
jmp 0x63922
movb $0x62, -0xd(%rbp)
jmp 0x63927
movb $0x77, -0xd(%rbp)
jmp 0x63927
movb $0x6c, -0xd(%rbp)
jmp 0x63927
movb $0x71, -0xd(%rbp)
jmp 0x63927
callq 0x11060
movq -0x8(%rbp), %rdx
movsbl -0xd(%rbp), %ecx
leaq 0x5c49a(%rip), %rdi     # 0xbfdd0
leaq 0xf0b1(%rip), %rsi      # 0x729ee
movb $0x0, %al
callq 0x112f0
leaq 0x5c485(%rip), %rax     # 0xbfdd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: x86_symbol_init
static void x86_symbol_init(struct symbol *sym)
{
	struct symbol_private *priv = sym->aux;
	struct expression *expr = sym->initializer;
	struct storage *new;

	if (expr)
		new = x86_expression(expr);
	else
		new = stack_alloc(sym->bit_size / 8);

	if (!priv) {
		priv = calloc(1, sizeof(*priv));
		sym->aux = priv;
		/* FIXME: leak! we don't free... */
		/* (well, we don't free symbols either) */
	}

	priv->addr = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x639a0
movq -0x18(%rbp), %rdi
callq 0x62220
movq %rax, -0x20(%rbp)
jmp 0x639ba
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %edi
callq 0x63a00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x639e3
movl $0x1, %edi
movl $0x8, %esi
callq 0x111d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%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/compile-i386.c
// Function: stack_alloc
static struct storage *stack_alloc(int n_bytes)
{
	struct function *f = current_func;
	struct storage *stor;

	assert(f != NULL);

	stor = new_storage(STOR_PSEUDO);
	stor->type = STOR_PSEUDO;
	stor->pseudo = f->pseudo_nr;
	stor->offset = f->stack_size; /* FIXME: stack req. natural align */
	stor->size = n_bytes;
	f->stack_size += n_bytes;
	f->pseudo_nr++;

	add_ptr_list(&f->pseudo_list, stor);

	return stor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x5c3a6(%rip), %rax     # 0xbfdb8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x63a1f
jmp 0x63a3e
leaq 0xf044(%rip), %rdi      # 0x72a6a
leaq 0xed67(%rip), %rsi      # 0x72794
movl $0x20e, %edx            # imm = 0x20E
leaq 0xf03b(%rip), %rcx      # 0x72a74
callq 0x11140
xorl %edi, %edi
callq 0x63490
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x281e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_conditional_test
static int emit_conditional_test(struct storage *val)
{
	struct storage *reg;
	struct storage *target_val;
	int target_false;

	/* load result into EAX */
	emit_comment("begin if/conditional");
	reg = get_reg_value(val, &regclass_32);

	/* compare result with zero */
	insn("test", reg, reg, NULL);
	put_reg(reg);

	/* create conditional-failed label to jump to */
	target_false = new_label();
	target_val = new_storage(STOR_LABEL);
	target_val->label = target_false;
	target_val->flags = STOR_WANTS_FREE;
	insn("jz", target_val, NULL, NULL);

	return target_false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xefc9(%rip), %rdi      # 0x72a9c
movb $0x0, %al
callq 0x63c40
movq -0x8(%rbp), %rdi
leaq 0x2f6d3(%rip), %rsi     # 0x931b8
callq 0x63d20
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xefb4(%rip), %rdi      # 0x72ab1
xorl %eax, %eax
movl %eax, %ecx
callq 0x63500
movq -0x10(%rbp), %rdi
callq 0x63df0
callq 0x62b30
movl %eax, -0x1c(%rbp)
movl $0x5, %edi
callq 0x63490
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x2, 0x8(%rax)
movq -0x18(%rbp), %rsi
leaq 0xef70(%rip), %rdi      # 0x72ab6
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63500
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_conditional_end
static int emit_conditional_end(int target_false)
{
	struct storage *cond_end_st;
	int cond_end;

	/* finished generating code for if-true statement.
	 * add a jump-to-end jump to avoid falling through
	 * to the if-false statement code.
	 */
	cond_end = new_label();
	cond_end_st = new_storage(STOR_LABEL);
	cond_end_st->label = cond_end;
	cond_end_st->flags = STOR_WANTS_FREE;
	insn("jmp", cond_end_st, NULL, NULL);

	/* if we have both if-true and if-false statements,
	 * the failed-conditional case will fall through to here
	 */
	emit_label(target_false, NULL);

	return cond_end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x62b30
movl %eax, -0x14(%rbp)
movl $0x5, %edi
callq 0x63490
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x2, 0x8(%rax)
movq -0x10(%rbp), %rsi
leaq 0x9617(%rip), %rdi      # 0x6d1b9
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x63500
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x63bd0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_label
static void emit_label (int label, const char *comment)
{
	struct function *f = current_func;
	char s[64];

	if (!comment)
		sprintf(s, ".L%d:\n", label);
	else
		sprintf(s, ".L%d:\t\t\t\t\t# %s\n", label, comment);

	push_text_atom(f, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5c1d2(%rip), %rax     # 0xbfdb8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x63c08
leaq -0x60(%rbp), %rdi
movl -0x4(%rbp), %edx
leaq 0x7ec2(%rip), %rsi      # 0x6bac1
movb $0x0, %al
callq 0x112f0
jmp 0x63c21
leaq -0x60(%rbp), %rdi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0xef42(%rip), %rsi      # 0x72b5c
movb $0x0, %al
callq 0x112f0
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63e60
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_comment
static void emit_comment(const char *fmt, ...)
{
	struct function *f = current_func;
	static char tmpbuf[100] = "\t# ";
	va_list args;
	int i;

	va_start(args, fmt);
	i = vsnprintf(tmpbuf+3, sizeof(tmpbuf)-4, fmt, args);
	va_end(args);
	tmpbuf[i+3] = '\n';
	tmpbuf[i+4] = '\0';
	push_text_atom(f, tmpbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x63c7b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x5c10f(%rip), %rax     # 0xbfdb8
movq %rax, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x2f47a(%rip), %rdi     # 0x93153
movl $0x60, %esi
leaq -0x30(%rbp), %rcx
callq 0x110c0
leaq 0x2f462(%rip), %rsi     # 0x93150
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movb $0xa, 0x3(%rax,%rsi)
movslq -0x34(%rbp), %rax
movb $0x0, 0x4(%rax,%rsi)
movq -0x10(%rbp), %rdi
callq 0x63e60
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: get_reg_value
static struct storage *get_reg_value(struct storage *value, struct regclass *class)
{
	struct reg_info *info;
	struct storage *reg;

	/* Do we already have it somewhere */
	info = value->reg;
	if (info && info->contains == value) {
		emit_comment("already have register %s", info->name);
		return get_hardreg(hardreg_storage_table + info->own_regno, 0);
	}

	reg = get_reg(class);
	emit_move(value, reg, value->ctype, "reload register");
	info = reg->reg;
	info->contains = value;
	value->reg = info;
	return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x63d8b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x63d8b
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0xed66(%rip), %rdi      # 0x72ac5
movb $0x0, %al
callq 0x63c40
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cltq
leaq 0x2eb19(%rip), %rdi     # 0x92890
imulq $0x30, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x63f50
movq %rax, -0x8(%rbp)
jmp 0x63de0
movq -0x18(%rbp), %rdi
callq 0x64060
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0xed2f(%rip), %rcx      # 0x72ade
callq 0x63640
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: put_reg
static void put_reg(struct storage *reg)
{
	struct reg_info *info = reg->reg;
	int regno = info->own_regno;

	if (test_and_clear_bit(regno, regs_in_use))
		return;
	fprintf(stderr, "freeing already free'd register %s\n", reg_info_table[regno].name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
leaq 0x5bfd3(%rip), %rsi     # 0xbfdf0
callq 0x64210
cmpl $0x0, %eax
je 0x63e29
jmp 0x63e56
movq 0x271c0(%rip), %rax     # 0x8aff0
movq (%rax), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x2ef92(%rip), %rax     # 0x92dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xece9(%rip), %rsi      # 0x72b38
movb $0x0, %al
callq 0x111f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: push_text_atom
static void push_text_atom(struct function *f, const char *text)
{
	struct atom *atom = new_atom(ATOM_TEXT);

	atom->text = strdup(text);
	atom->text_len = strlen(text);

	push_atom(f, atom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x63ec0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x110e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x63f10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: new_atom
static struct atom *new_atom(enum atom_type type)
{
	struct atom *atom;

	atom = calloc(1, sizeof(*atom));	/* TODO: chunked alloc */
	if (!atom)
		die("nuclear OOM");

	atom->type = type;

	return atom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0x111d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x63ef3
leaq 0xebcd(%rip), %rdi      # 0x72ab9
movb $0x0, %al
callq 0x17200
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: get_hardreg
static struct storage * get_hardreg(struct storage *reg, int clear)
{
	struct reg_info *info = reg->reg;
	const unsigned char *aliases;
	int regno;

	aliases = info->aliases;
	while ((regno = *aliases++) != NOREG) {
		if (test_bit(regno, regs_in_use))
			goto busy;
		if (clear)
			reg_info_table[regno].contains = NULL;
	}
	set_bit(info->own_regno, regs_in_use);
	return reg;
busy:
	fprintf(stderr, "register %s is busy\n", info->name);
	if (regno + reg_info_table != info)
		fprintf(stderr, "  conflicts with %s\n", reg_info_table[regno].name);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x63fc9
movl -0x24(%rbp), %edi
leaq 0x5be55(%rip), %rsi     # 0xbfdf0
callq 0x640f0
cmpl $0x0, %eax
je 0x63fa7
jmp 0x63fe7
cmpl $0x0, -0xc(%rbp)
je 0x63fc7
movslq -0x24(%rbp), %rcx
leaq 0x2ee18(%rip), %rax     # 0x92dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
jmp 0x63f77
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %edi
leaq 0x5be18(%rip), %rsi     # 0xbfdf0
callq 0x64130
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq 0x27002(%rip), %rax     # 0x8aff0
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0xeaef(%rip), %rsi      # 0x72aee
movb $0x0, %al
callq 0x111f0
movslq -0x24(%rbp), %rcx
leaq 0x2edbf(%rip), %rax     # 0x92dd0
shlq $0x5, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
je 0x6404b
movq 0x26fcb(%rip), %rax     # 0x8aff0
movq (%rax), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x2ed9d(%rip), %rax     # 0x92dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0xeabf(%rip), %rsi      # 0x72b03
movb $0x0, %al
callq 0x111f0
movl $0x1, %edi
callq 0x11300
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: get_reg
static struct storage *get_reg(struct regclass *class)
{
	const unsigned char *regs = class->regs;
	int regno;

	while ((regno = *regs) != NOREG) {
		regs++;
		if (register_busy(regno))
			continue;
		return get_hardreg(hardreg_storage_table + regno, 1);
	}
	fprintf(stderr, "Ran out of %s registers\n", class->name);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x640c4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %edi
callq 0x64170
cmpl $0x0, %eax
je 0x640a2
jmp 0x64078
movslq -0x14(%rbp), %rax
leaq 0x2e7e3(%rip), %rdi     # 0x92890
imulq $0x30, %rax, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x63f50
addq $0x20, %rsp
popq %rbp
retq
movq 0x26f25(%rip), %rax     # 0x8aff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0xea3c(%rip), %rsi      # 0x72b18
movb $0x0, %al
callq 0x111f0
movl $0x1, %edi
callq 0x11300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: register_busy
static int register_busy(int regno)
{
	if (!test_bit(regno, regs_in_use)) {
		struct reg_info *info = reg_info_table + regno;
		const unsigned char *regs = info->aliases+1;

		while ((regno = *regs) != NOREG) {
			regs++;
			if (test_bit(regno, regs_in_use))
				goto busy;
		}
		return 0;
	}
busy:
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq 0x5bc6b(%rip), %rsi     # 0xbfdf0
callq 0x640f0
cmpl $0x0, %eax
jne 0x641f1
movslq -0x8(%rbp), %rcx
leaq 0x2ec36(%rip), %rax     # 0x92dd0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0x641e8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
leaq 0x5bc16(%rip), %rsi     # 0xbfdf0
callq 0x640f0
cmpl $0x0, %eax
je 0x641e6
jmp 0x641f3
jmp 0x641b5
movl $0x0, -0x4(%rbp)
jmp 0x641fa
jmp 0x641f3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./bitmap.h
// Function: test_and_clear_bit
static inline int test_and_clear_bit(unsigned int nr, unsigned long *bitmap)
{
	unsigned long offset = nr / BITS_IN_LONG;
	unsigned long bit = nr & (BITS_IN_LONG-1);
	unsigned long old = bitmap[offset];
	unsigned long mask = 1UL << bit;
	bitmap[offset] = old & ~mask;
	return (old & mask) != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
andq $0x3f, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
xorq $-0x1, %rax
andq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_labelsym
static void emit_labelsym (struct symbol *sym, const char *comment)
{
	struct function *f = current_func;
	char s[64];

	if (!comment)
		sprintf(s, ".LS%p:\n", sym);
	else
		sprintf(s, ".LS%p:\t\t\t\t# %s\n", sym, comment);

	push_text_atom(f, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x5bb11(%rip), %rax     # 0xbfdb8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x642ca
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xe8ab(%rip), %rsi      # 0x72b6c
movb $0x0, %al
callq 0x112f0
jmp 0x642e4
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xe897(%rip), %rsi      # 0x72b74
movb $0x0, %al
callq 0x112f0
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x63e60
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: new_val
static struct storage *new_val(long long value)
{
	struct storage *stor;

	stor = new_storage(STOR_VALUE);

	if (stor) {
		stor->flags |= STOR_WANTS_FREE;
		stor->value = value;
	}

	return stor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, %edi
callq 0x63490
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6433d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
orq $0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: loopstk_push
static void loopstk_push(int cont_lbl, int loop_bottom_lbl)
{
	struct function *f = current_func;
	struct loop_stack *ls;

	ls = malloc(sizeof(*ls));
	ls->continue_lbl = cont_lbl;
	ls->loop_bottom_lbl = loop_bottom_lbl;
	ls->next = f->loop_stack;
	f->loop_stack = ls;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x5ba53(%rip), %rax     # 0xbfdb8
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x11230
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: loopstk_pop
static void loopstk_pop(void)
{
	struct function *f = current_func;
	struct loop_stack *ls;

	assert(f->loop_stack != NULL);
	ls = f->loop_stack;
	f->loop_stack = f->loop_stack->next;
	free(ls);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5b9f9(%rip), %rax     # 0xbfdb8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x643d0
jmp 0x643ef
leaq 0xe847(%rip), %rdi      # 0x72c1e
leaq 0xe3b6(%rip), %rsi      # 0x72794
movl $0x766, %edx            # imm = 0x766
leaq 0xe84a(%rip), %rcx      # 0x72c34
callq 0x11140
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x11030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_string_list
static void emit_string_list(struct function *f)
{
	struct atom *atom;

	emit_section(".section\t.rodata");

	FOR_EACH_PTR(f->str_list, atom) {
		/* FIXME: escape " in string */
		printf(".L%d:\n", atom->label);
		printf("\t.string\t%s\n", show_string(atom->string));

		free(atom);
	} END_FOR_EACH_PTR(atom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe8c9(%rip), %rdi      # 0x72cfc
callq 0x62ad0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x64460
jmp 0x6450f
jmp 0x64462
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x644f7
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x644ad
cmpq $0x0, -0x10(%rbp)
jne 0x644ad
jmp 0x644e9
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x7606(%rip), %rdi      # 0x6bac1
movb $0x0, %al
callq 0x11110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31530
movq %rax, %rsi
leaq 0xe834(%rip), %rdi      # 0x72d0d
movb $0x0, %al
callq 0x11110
movq -0x10(%rbp), %rdi
callq 0x11030
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x64469
jmp 0x644f9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x64462
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_atom_list
static void emit_atom_list(struct function *f)
{
	struct atom *atom;

	FOR_EACH_PTR(f->atom_list, atom) {
		switch (atom->type) {
		case ATOM_TEXT: {
			if (write(STDOUT_FILENO, atom->text, atom->text_len) < 0)
				die("can't write to stdout");
			break;
		}
		case ATOM_INSN:
			emit_insn_atom(f, atom);
			break;
		case ATOM_CSTR:
			assert(0);
			break;
		}
	} END_FOR_EACH_PTR(atom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x64554
jmp 0x64652
jmp 0x64556
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x6463a
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x645a8
cmpq $0x0, -0x10(%rbp)
jne 0x645a8
jmp 0x6462c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x645cb
jmp 0x645b7
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x645fc
jmp 0x645c1
movl -0x30(%rbp), %eax
subl $0x2, %eax
je 0x6460b
jmp 0x6462a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
movl $0x1, %edi
callq 0x110d0
cmpq $0x0, %rax
jge 0x645fa
leaq 0xe727(%rip), %rdi      # 0x72d1a
movb $0x0, %al
callq 0x17200
jmp 0x6462a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64850
jmp 0x6462a
leaq 0x7267(%rip), %rdi      # 0x6b879
leaq 0xe17b(%rip), %rsi      # 0x72794
movl $0x2f1, %edx            # imm = 0x2F1
leaq 0xe70b(%rip), %rcx      # 0x72d30
callq 0x11140
jmp 0x6462c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6455d
jmp 0x6463c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x64556
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: func_cleanup
static void func_cleanup(struct function *f)
{
	struct storage *stor;
	struct atom *atom;

	FOR_EACH_PTR(f->atom_list, atom) {
		if ((atom->type == ATOM_TEXT) && (atom->text))
			free(atom->text);
		if (atom->op1 && (atom->op1->flags & STOR_WANTS_FREE))
			free(atom->op1);
		if (atom->op2 && (atom->op2->flags & STOR_WANTS_FREE))
			free(atom->op2);
		free(atom);
	} END_FOR_EACH_PTR(atom);

	FOR_EACH_PTR(f->pseudo_list, stor) {
		free(stor);
	} END_FOR_EACH_PTR(stor);

	free_ptr_list(&f->pseudo_list);
	free(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x64694
jmp 0x64794
jmp 0x64696
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x6477c
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x646e8
cmpq $0x0, -0x18(%rbp)
jne 0x646e8
jmp 0x6476e
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x64709
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x64709
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11030
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x64737
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x64737
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x11030
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x64765
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x64765
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x11030
movq -0x18(%rbp), %rdi
callq 0x11030
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6469d
jmp 0x6477e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x64696
jmp 0x64796
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x647bb
jmp 0x64830
jmp 0x647bd
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x6481c
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x64808
cmpq $0x0, -0x10(%rbp)
jne 0x64808
jmp 0x64811
movq -0x10(%rbp), %rdi
callq 0x11030
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x647c4
jmp 0x6481e
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x647bd
jmp 0x64832
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x28b40
movq -0x8(%rbp), %rdi
callq 0x11030
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_insn_atom
static void emit_insn_atom(struct function *f, struct atom *atom)
{
	char s[128];
	char comment[64];
	struct storage *op1 = atom->op1;
	struct storage *op2 = atom->op2;

	if (atom->comment[0])
		sprintf(comment, "\t\t# %s", atom->comment);
	else
		comment[0] = 0;

	if (atom->op2) {
		char tmp[16];
		strcpy(tmp, stor_op_name(op1));
		sprintf(s, "\t%s\t%s, %s%s\n",
			atom->insn, tmp, stor_op_name(op2), comment);
	} else if (atom->op1)
		sprintf(s, "\t%s\t%s%s%s\n",
			atom->insn, stor_op_name(op1),
			comment[0] ? "\t" : "", comment);
	else
		sprintf(s, "\t%s\t%s%s\n",
			atom->insn,
			comment[0] ? "\t\t" : "", comment);

	if (write(STDOUT_FILENO, s, strlen(s)) < 0)
		die("can't write to stdout");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x648ae
leaq -0xd0(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
addq $0x20, %rdx
leaq 0xe4b2(%rip), %rsi      # 0x72d57
movb $0x0, %al
callq 0x112f0
jmp 0x648b5
movb $0x0, -0xd0(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x64956
leaq -0xf0(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x64a60
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x110a0
leaq -0x90(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x100(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x64a60
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rdx
movq -0xf8(%rbp), %rcx
movq %rax, %r8
leaq -0xd0(%rbp), %r9
leaq 0xe414(%rip), %rsi      # 0x72d5e
movb $0x0, %al
callq 0x112f0
jmp 0x64a10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x649ce
leaq -0x90(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x118(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x64a60
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rdx
movq %rax, %rcx
movsbl -0xd0(%rbp), %esi
leaq 0x2e80(%rip), %r8       # 0x67829
leaq 0x2e78(%rip), %rax      # 0x67828
cmpl $0x0, %esi
cmovneq %rax, %r8
leaq -0xd0(%rbp), %r9
leaq 0xe3a7(%rip), %rsi      # 0x72d6c
movb $0x0, %al
callq 0x112f0
jmp 0x64a0e
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movsbl -0xd0(%rbp), %esi
leaq 0x2e3e(%rip), %rcx      # 0x67829
leaq 0x2e35(%rip), %rax      # 0x67827
cmpl $0x0, %esi
cmovneq %rax, %rcx
leaq -0xd0(%rbp), %r8
leaq 0xe371(%rip), %rsi      # 0x72d78
movb $0x0, %al
callq 0x112f0
jmp 0x64a10
leaq -0x90(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x110e0
movq -0x128(%rbp), %rsi
movq %rax, %rdx
movl $0x1, %edi
callq 0x110d0
cmpq $0x0, %rax
jge 0x64a52
leaq 0xe2cf(%rip), %rdi      # 0x72d1a
movb $0x0, %al
callq 0x17200
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)